Python語法統計

Python語法統計

1、 print（’ ’）關鍵字打印功能

2、 變量名字是隨意起的可以給它賦值變量名是由下劃線、數字、字母組成的，數字不能作爲開頭，其實這個變量就是可以儲存值的一個罐子

例如：M=（’hello world’）這是給值起了個名字Print(M)然後再把這個變量名打印出來也就是把變量名裏的值打印出來賦值是用=來賦值.
變量的類型有：
Number（數字）
string（字符串）
list（列表）
set（集合）
tuple（元祖）
dictionary（字典）

3、 list列表是用[]義的，列表的內容可以用變量名打印出來，就是把這個列表賦值給變量名，列表可以是多個值，

例如：list=[12,45,58,69,85,89]只是數字列表
List=[‘ ‘,45,’ ‘,58]可以組合字符串用引號引起來
List是數學意義上的有序集合，可以隨時添加和刪除，修改其中的元素（列表裏的數據稱爲元素）也就是說列表是有序排列的，稱爲索引，索引是從0開始排序的，比如列表的第一個元素索引號就是0，第二個就是1，對於Python來說list是一個動態語言，所以它中的元素並不要求是哪個類型的數據，它可以是任何類型的數據組合也可以，
一個元素都沒有的列表就是一個空的list

4、 首字母大寫title();例如：print（變量名.title（））；

5、 全大寫upper（）；同上

6、 全小寫lower（）；同上

7、 Print不光打印字符，也可以運算，運算符有+、-、*、\加減乘除都可以

如：print（3+2）;會等於5這是數字運算也可以字符運算
如：print（’hello’+’world’）;會打印出hello world

8、 如果字符串內容有點長我們也可以換行‘/n’，也可以添加‘/t’空格

9、 說了加空格當然也有減空格的；

Print（變量名.rstrip）這個是去右邊的空格的
Print（變量名.lstrip）這是去左邊的空格的
Print（變量名.strip）這是去全部的空格的

10、給列表添加元素

表名.append（新元素）append（）是默認給列表最後添加元素
指定位置添加元素

表名.insert（索引號，新元素）如：是0新元素會在列表第一個之前的索引0會自動往後移變成索引號1

11、除列表：del 表名;整個表就都刪了

        del表名[索引號]可以刪除指定的索引所對應的元素
還有刪除列表裏的元素的也可以使用pop（）；

表名.pop（）;pop（）是默認刪除列表最後一個元素的，你在括號裏填-2是刪除倒數第二個元素；用pop刪除的元素還可以賦值給一個變量名以便以後拿來用

12、修改列表元素如：表名[索引號]=新元素 給指定索引換新元素

13、查看列表裏有多少數據用len；如：print（len(表名)）；

14、給列表排序；如：print(sorted(表名))這個是正序 字母的話是用（a,b,c,d）來排序的

給列表倒敘；如：表名.sort(reverse=True) ;print(表名);倒敘關鍵詞寫在打印前面，倒序好了再進行打印

15、給列表換新名字也是循環，循環也是給列表換行，方便查看

如：for 新名（變量名）in 舊的列表名

16、創建一個整數列表；整數關鍵字range

首先創個空表；
 表名=[]
For 變量名 in  range (1,1000)；
表名.append（變量名）給空表添加1到1000的數據，再賦值給變量
Print（變量名）只會顯示1到999的數據，因爲插入的數據是包頭不包尾的，

17、創建整數列表，另一個版本；

第一個參數表示從幾開始，第二個是到幾結束，第三個表示每次增加幾

    表名=[]
For 變量名 in  range（2,45,2）數字時隨便寫的
表名.append（變量名）
Print（變量名）

18、切片（處理列表中的一部分稱爲切片）；

從另一個表取值如：number[1,1000]，這表是1到1000的數據
Number1=number[30:300]；從number表裏取走30到300的數據並賦值給number1
首先看列表的長度      也可以取[:300] 就是從0到299的數據
Print（len(number1)）      [30:]就是從30到列表最後都會顯示
獲取列表的最後一個元素   切片是包尾不包頭
Print（number1[-1]）括號裏是索引號哦-1就是最後一個哦
列表切片元素是字符或字母，是按索引號切片

19、創建元祖列表

元祖列表和list非常相似，但是元祖一旦創建是不能修改的，沒有pop，insert等方法，元祖和list的獲取方式是一樣的，但不能賦值給別的元素，元祖是用（）來定義的，元祖添加一個元素的時候後面要加‘，’要不它就不能是一個列表只是一個字符或數字，
Python ‘if’語句
1、 注意python 代碼的縮進規則，具有相同縮進的代碼被視爲代碼塊
2、 If 語句後接表達式，然用：表示代碼塊開始，if 就是作爲條件判斷對錯的 對（True）錯（false）else，如果條件是對的會打印對的，如果是錯的會走else，打印錯的
如：列表=[1,2,3] 這表裏有三個數據
For a in 表名：這裏是冒號，看a 是不是在這個表裏，下面給a賦值列表裏的數據
If(如果)a 1；或2或3
Print（’True’）; 如果a1在表裏會打印對的，如果不在這個表裏打印錯的，
Else(否則)： 這分兩個代碼塊，如果對了會打上面的，錯的打下面的；
Print（’False’）;
3、 多個條件判斷
如果年齡在15到18之間應該是高中，多個條件之間使用and 連接，表示同時成立，
年齡=16;
If 年齡<18 and 年齡>15: 表達還是和上面一樣的，只不過加了個條件連接，
Print(‘高中’)
Else:
Print(‘其他’);
4、 在列表中循環比較判斷
表名=[12,15,89,87,16] 這個主要是正對數字列表，讓這個表循環去比較 然後得出結果，

For a in 表名： 如果a 在這個表裏 是<18 並且>15是青少年
   If a<18 and a>15    如果不是就打印其他的，
     Print(‘青少年’) ;
   Else:
     Print(‘其他’);

5、 多個條件判斷使用or表示滿足其中一個
變量名1=12；
變量名2=20；
If 變量名1<18 or 變量名2>15:
Print(‘青少年’)
6、 多個條件一個if不夠用，可以加個elif 來進行加條件

小明=13歲
If（如果）小明年齡小於<14
Print（’小於14歲’）;
Elif 小明年齡<18：
   Print(‘年齡在14到18之間’);
Else :
   Print(‘大於18歲’);

7、 判斷列表是不是空的，判斷某個元素是不是在該列表中

列表=[12,13,16,56,45];
   A=12
If A in 列表;
 Print(‘在列表中’);
Else:
  Print(‘不在列表中’);

8、 迭代累加，用於計算總和；
A=0 首先是空表，給它插入整數1到100然後循環相加，

For B in range(1,101)；
  A+=B;(每次迭代累加)
 Print(A);

9、 字典
字典是一個鍵對值，每個鍵對應一個值，可以使用鍵來訪問值，於鍵關聯的值可以是數字也可以是字符，鍵和值之間用冒號隔開，一個字典裏可以存放多個鍵對值，字典是用{}來定義的。
變量名={‘ ’:’ ’,’ ’:’ ’};同樣和列表一樣把字典存儲到一個變量名裏
10、鍵對值的查詢
Print（ 表名[ ’鍵’]）會打印出相對應的值，
11、鍵對值的新增
表名[‘ 鍵’]=值 新增也是默認添加末尾
12、鍵對值的刪除
Del 表名[‘鍵’] 和鍵相對應的值也會刪除，
13、鍵對值的修改
表名[‘ 想要修改的鍵 ’]=’新值’
14、鍵對值的遍歷也叫循環

For key,value in 表名.items（）;
  Print(key);  鍵和值分開循環打印，值如果是字符，數字組合，後面加類型打印
  Print(str (values));
只循環key
For key in 表名.keys()
  Print(key)
只循環value
For value in 表名 values()
  Print(value)

15、嵌套的定義
將一系列的字典存儲在列表裏，或者將字典存儲在字典中成爲嵌套
首先由多個字典
字典1={ }
字典2={ }
字典3={ }
字典4={ }
變量名=[字典1，字典2，字典3，字典4]；把多個字典賦值給一個變量同時把它變成一個列表
For 新變量名 in 變量名：首先從列表中取出一個字典去循環，然後查詢它的鍵或值，
For key in 新變量名.keys();
Print(新變量名[key])；
16、在字典中存儲列表
字典名={‘在這個字典裏代表鍵’：[‘ ’,’ ’,’ ’],’代表第二個鍵 ’:[‘ ’,’ ’,’ ’] }
取字典裏的一個鍵和值賦值給一個變量
變量名=字典名[‘鍵 ’];然後這個變量名就是一個列表了，
然後根據列表查詢去查數據；print（變量也就是表名[索引號]）;
17、在字典中存儲字典
字典名={‘ 在這個字典裏代表鍵 ’：{’ ’:’ ’,’ ’:’ ’},’另一個鍵’：{‘ ’:’ ’,’ ’:’ ’} }
和上面一樣從字典中取出一個鍵賦值給一個變量
變量名=字典名[‘ 鍵’]; 這個變量就變成了一個字典；
然後去循環這個字典進行查詢；
For key,value in 變量名.items（）；
Print（key）
Print(value);
18、測試用戶輸入

19、函數input()的工作原理
讓程序暫定一會運行，等待用戶輸入一些文本，獲取用戶輸入後，Python將其存儲在一個變量中，以便使用
變量名=input（’’） input裏面可以存儲別的東西
Print(‘’hello’+變量名’);
變量名=’隨便都行’
變量名+=’隨便道行’；
Print(變量名)；
根據用戶輸入的數字，判斷是奇數還是偶數
變量名=11
變量名%=3；
Print（變量名）
20、while循環不會迭代list或tuple的元素，而是根據表達式判斷循環是否結束
如要從0開始打印不大於n的整數

  N=20
  X=0
  While x<n  while 每次循環先判斷x<n，如果爲True,則執行循環體的代碼塊，否則退出循環，
    X+=x
    Print(x) x+=x會讓x 不斷增加，最終因爲x<n不成立而退出循環
      如果沒有這樣一個語句，while循環在判斷x<n的時候總是True,就會無限循環下去，變成死循環

21、使用退出循環表示返回到循環的開頭，並根據測試條件再決定是否還要執行

     變量名=0
     While 變量名<10:
       變量名+=1;
     If 變量名%2==0：
       Print（'偶數’,+str(變量名)）;
        Continue
   Else :
    Print(‘奇數’+str(變量名))

22、測試while 用戶輸入q表示程序退出

    變量名1=True;
    While 變量名:
          變量名2=input(‘請輸入q表示退出’)
         If  變量名2（input註釋）!=’q’:
          Print(變量名2);
    Else:
       變量名1=False
       Print(‘退出程序’)

23、使用關鍵字來退出循環
表示立即退出循環，不再運行while裏面的代碼可用於控制程序的流程

變量名=0；
 While 變量名<10：
    變量名+=1;
    If 變量名%2==0：
       Print(‘偶數’+str(變量名));
        Break
 Else:
     Print(‘奇數’+str(變量名))；

24、函數（方法）
帶有名字的代碼塊，完成具體的工作，見名知義

   定義函數的關鍵字def 函數名（）：
        Def 函數名（）無參數的函數（方法）
      Print（'hello word ’）;
    實參（實際的參數）
    調用函數時傳遞給函數的實際信息，就是給形參賦值
    形參（形式參數）
      函數完成工作所需要的一項信息
    如：def 函數名(a,b):
        變量名=a+b;
         Print(c)
    If_name_==’_main_’:這個是固定的是給形參賦值，
         函數名（2,3）

** 25、計算加減乘除的函數，a和b 代表具體的數值，c代表運算符 **

    Def 函數名(a,b,c);
     If c==’+’或==’-’或==’*’或==’/’  
          Print(a+b)或….
    Else:
       Print(a%b);

26、參數的傳遞
位置實參：在你調用函數或者方法的時候python 必須將函數的每一個實參都關聯到函數定義的一個形參中，爲此最簡單的關聯方式是基於實參的順序的；
關鍵字實參：產地給函數的名稱-值，關鍵詞實參不考慮實參的順序
參數的默認值：給該參數指定一個默認的值，默認值的參數必須放到最後

  如：def 函數名（a,b,c=’男’）;
     Print(a+b+c);
     If_name_==’main’:
     函數名（’張三’,’18歲’）;

27、參數可選也必須放到最後

    Def 函數名（a,b,c,d=’’）
     If d==’’;
      Return(a+b+c);
    Else:
      Return(a+b+c+d);

28、參數的個數是任意的

Def 函數名（*cc）：*代表了沒有東西，任意
For 變量名 in  cc:
      Print(變量名);
    If_name_==’main’:
      函數名（12,15,46,78,89,89）;沒有固定裏面填多少數據都可以

29、位置參數和任意參數一塊使用
Def 函數名（a,ac）：
Print（a）
For c in ac :
Print(str©);
** 30、關鍵詞參數和任意參數*

    Def 函數名(a,b **c):
    Print(a);
    Print(b);
   For key, value in c.items():
     Print(key);
    Print(value);

31、調用以.py 結尾的文件的方法
From 文件名稱 import 函數名，
32、模塊名import 指定函數
Import 文件名 as 別名 導入整個模塊as 代表模塊的別名
**33、class 分類 **
，比如有三個類，有人，有大象，有冰箱，實現打開冰箱門，把大象放進去，關閉冰箱門，
如：

class  大象（）
       Def _init_ (self,tizhong,nianling):
          Self.tizhong=tizhong
          Self.nianling=nianling
       Class ren();
         Def _init_(self,name,nianling):
          Self.name=name
          Self.nianling=nianling
       Del open(self):
         Print(self.name+’打開冰箱門’);
       Def close(self):
         Print(self.name+’關閉冰箱門’);
       Def into bingxiang(self,weight,time,size):
      Print(self.name+’花了：’+str(time)+’分鐘把體重爲：’+str(weight)+’的大象放了尺寸是：’+str(size)+’的冰箱裏面’)
        Class bingxiang():
         Def _init_(self,size):
          Self.size=size
       If_name_==’_main_’:
        Ren= ren (‘張三’,25)；
        Daxiang=daxiang(100,5880);
        Bingxiang=bingxiang(6000);
        ren.open();
        ren.intlbinxing(1800,10,bingxiang.size)
        ren.close()

34、 冒泡排序（從大到小）

       冒泡排序：原理：比較相鄰的兩個元素將值大的元素交換的前面
            思路：一次比較相鄰的兩個元素，將大數放到前面，小數放後面，即在第一趟比較的時候首先比較第一個和第二個數，將小數放後面，
    大數放到前面然後比較第二個和第三個，將小數放到最後面，大數放到最前面，如此反覆，一直到比較最後兩個數
    第一趟比較完畢之後最後一個數字一定是最小，因此在第二趟中比較的時候最後一個數不參與比較，
    第二趟比較完畢之後倒數第二個一定是這一組最倒數第二最小的，因此第三趟比較中不參與比較，
     …………其他不寫了，一次類推
    每次比較的次數減少一次

編程語法如：

     列表名=[45,13,56,89,45];
     變量名=len(列表名)；查看有多少數據；
     For I in range(變量名)：控制次數
        For j in range(變量名-1)：交換次數 j 代表下標
          If (列表名[j])<列表名[j+1]：
           變量名=列表名[j]; 把下標賦值給一個變量
           列表名[j]=列表名[j+1]；
            列表名[j+1]=變量名
    Print(列表名);

類

  class car():
    def __init__(self,make,model,year):
        self.make = make;
        self.model  = model;
        self.year  =year;
        self.lichenshu = 0; #默認值
    def get_describe(self):
        '''定義一個汽車的描述'''
        return '這輛車的廠家是：'+self.make+'品牌是:'+self.model+"生產年份是："+str(self.year)+"里程數是："+str(self.lichenshu);

    def addlichenshu(self):
        '''修改默認值'''
        self.lichenshu+=100;
    def addUserchenli(self,userli):
        '''修改指定的值'''
        self.lichenshu +=userli;
    def volitalichen(self,lisheng):
            '''添加了一個里程的校驗'''
            if lisheng < 0:
                return ;
            else:
                self.lichenshu +=lisheng;
    if __name__ == '__main__':
        car =Car('上汽集團','大衆',2017);
        desc = car.get_describe();
        car.lichenshu=100;
        car.year=2018;
        print(desc);
       # car.addlichenshu();
        print(car.lichenshu);
        print(car.get_describe())

** 35、 #面向對象的特徵：繼承 **
#通過繼承的創建的新的類成爲子類或者派生類 被繼承的類成爲 父類或者超類 基類
#繼承可以實現現有類的所有功能，並且無需重編別寫原來的類並對這些功能進行擴展

class person():
    def __init__(self,name,age):
        self.name = name;
        self.age= age;

    def get_describe(self):
        return "我的名字是:"+self.name+"年齡是:"+str(self.age);
class students (person):

    def __init__(self,name,age):
        super(students,self).__init__(name,age)
if __name__ == '__main__':
    stu = students('楊麗',25);
    print(stu.get_describe()); Administrator(0C9D92C05DE9) 22:47:37
class person():
    def __init__(self,name,age):
        self.name = name;
        self.age= age;

    def get_describe(self):
        return "我的名字是:"+self.name+"年齡是:"+str(self.age);
class students (person):

    def __init__(self,name,age,score,cla_):
        super(students,self).__init__(name,age)
        self.score =  score;#給子類增加額外的屬性
        self.cla_ = cla_;#給子類增加額外的屬性

    def get_describe(self):
        '''z子類繼承父類方法並且重寫父類的方法'''
        return "我的名字是:"+self.name+"年齡是:"+str(self.age)+'成績：'+str(self.score)+"班級是："+self.cla_;

if __name__ == '__main__':
    stu = students('張彪',25,100,'北斗星一班');
    print(stu.get_describe1());

** 36、 文件的讀取**

#使用文件的相對路徑讀取文件
#with open('../file/test.txt')  as file_object:
 #  content= file_object.read();
  # print(content);
#使用絕對路徑讀取文件(練習題)
#read()參數 表示讀取文件的長度
#with open('test11.txt') as file_object:
 #   content =file_object.read(4)
#    print(content);
Administrator(0C9D92C05DE9對話) 14:49:48
#文件處理類
class readUtil():
    def __init__(self,file):
        self.file = file;

    def readfile(self,file):
        '''讀取文件的方法'''
        with open(file) as file_object:
            content = file_object.read();
        return content;
Administrator(0C9D92C05DE9對話) 15:11:59
#一行一行的讀取
with open ('test11.txt') as file_object:
    count = 0;
    for line in file_object:
        count+=1;
        print("第"+str(count)+"行的數據是:"+line);

#讀取文件的內容並寫到列表中
number_1=[];
with open ('test11.txt') as file_object:
    for line in file_object:
        number_1.append(line.strip());

    print(number_1);



print("==================")
#number = [];
with open('test11.txt') as file_object:
    number.append(file_object.readlines());
    #content = file_object.readlines();
    #print(content)
    print(number);
 
 
print('數據類型在數據結構中的定義是一個值的集合以及定義在這個值集上的一組操作')
print('變量是用來存儲值的所在處；他們有名字和數據類型')
print('python 的數字也有四種數據類型有整數（int），浮點數（float），布爾值（bool），複數（complex）');
print('我們發現測量出的233整數類型（int）233.0是浮點數類型（float），’233‘（注意有單引號）是字符串類型（str）')
print(type(233))
#判斷233的類型
print(type(233.0))
print(type('2.33'))
#判斷是不是正確的類型
print(isinstance(233,int));
print(isinstance(233,float));
print(isinstance('23.3',str));
print(0b1001110)
233==233.0
print(-2.33-5.7j)
print(-2.33-5.7j)
a=1
b=2
c=3
print(c);
print(45678+0x12fd2);
print('learn Python in imooc');
if 0xff==255:
    print(True);
else:
    print(False);
print("======================================================快樂的分割線========================================================")
#print('hello world')

#定義函數
def prikd(a,b):
    c= a+b;
    print(c);
if __name__ == '__main__':
   prikd(6,4);
#換行
s=('Python was started in 1989 by "Guido".\nPython is free and easy to learm.')
print(s);
print (r''''\"To be,or not bo be":that is the question .\nwhether it\'s nobler in the mind to suffer'.''');
print(2.5+10/4);
print(True or False);#布爾值用（and，or，not）進行運算
a='python';
print('hello,',a or'world');
b=''
print('hello,',b or 'world');
list=['Adam',95.5, 'Lisa',85, 'Bart',59];
#刪除與替換，添加，pop默認刪除最後一個
list.append('pruie');#默認添加到最後一個
list.append(70);
A=list.pop();#pop默認刪除列表最後一個並且可以賦值給一個變量以便調用
B=list.pop();
print(list);#list是一個有序列表
print(A);
print(B);
tuple=(0,1,2,3,4,5,6,7,8,9);#是元祖列表數據是不可變的
print(tuple);
t=('Admin',)
print(t);
yangli=26;
#計算機之所以能做很多自動化的任務，因爲它可以自己做判斷條件
#if else 如果不等於if，就等於else
if yangli>26:
    print('還是少女');
else:
    print('娘們');
#差點就出錯了，part 的成績是75，如果>60是passed,如果<60是不及格。
part=75;
if part>60:
    print('passed');
else:
    print('不及格');
ta=20;
if ta<=18:
    print('teenage');
else:
    print('adult');
#多個條件判斷
優秀生=70
if 優秀生<90 and 優秀生>=60:
    print('中等生');
elif 優秀生<30:
    print('不及格');
else:
    print('0');
score=85;
if score>90:
    print('excellent');
elif score>80:
    print('good');
elif score>60:
    print('passed');
else:
    print('failed');
#求大於60分的平均值
L=[59,92,59,40,70,68];
sum=0.0
N=0
for C in L:
 if C>60:
  N+=1#迭代累加
  sum+=C#迭代累加
print(sum/N);
#求平均值
n = [75, 92, 59, 68];
sum = 0.0;
b=0;
for name in n:
   if name>=60:
    b+=1
    sum += name;
print(sum / b);

class daxiang():
    def __init__(self,age,weight):
        self.age = age;
        self.weight = weight;

class person():
    def __init__(self,name,age):#定義：前後兩個下劃線__init__ 一個必須的參數self必須在最前面 後面再定義其他的參數
        self.age = age;
        self.name = name;

    def open(self):
        '''打開冰箱門'''
        print(self.name+"打開冰箱門");

    def close(self):
        '''關閉冰箱門'''
        print(self.name+"關閉冰箱門")

    def intobinxing(self,weight,time,size):
        '''把大象放冰箱'''
        print(self.name+"花了："+str(time)+"分鐘把體重爲:"+str(weight)+"的大象放了尺寸是:"+str(size)+"的冰箱裏面");

class binxing():
    def __init__(self,size):
        self.size = size;

if __name__ == '__main__':
    person = person('張三', 25);
    daxiang = daxiang(100, 5800);
    bixin = binxing(200);
    person.open();
    person.intobinxing(1800,10,bixin.size);
    person.close();
#1-100循環求奇數的和，有兩個條件，一個是不能大於100，一個是除於2沒有餘數
sum=0;
x=0;
while True:
    x = x +1 #從1開始加直到一百
    if x>100:
        break#如果大於100會停止循環
    if x % 2 != 0:#除於2沒有餘數就是求奇數
        sum += x#sum=sum+x就是每次x相加會再加一次
        continue#會再回去循環
print(sum);
sum=0;
n=0
x=0;
while True:
    x=x+1
    if x >100:
        break
    if x %2!=0:
        sum+=x;
        n+=1
        continue;
print('奇數總和', sum);
print(n)
print(sum)
#1,2,4,8，以這種規律求前20項的總和
sum=0
x=1
n=1
while True:
   x=2**(n-1)
   x=x+1
   if n>20:
      break
   sum+=x
   n+=1
   continue
print(sum);
sum=0;
x=1;
n=1;
while True:
    x = 2 ** (n - 1);
    x=x+1
    if n>20:
        break
    sum+=x
    n+=1
    continue
print(sum)
#合併循環
x=[];
for y in range(1,11):

 for A in range(1,11):
  if y<A:
   print('y'+'A')
#冒泡排序一個數字一個數字去比較
N=[89,45,65,23,52,56];
c=len(N);
for a in range(c-1):
    for b in range(c-1):
     if(N[b])<N[b+1]:
         m=N[b];
         N[b]=N[b+1];
         N[b+1]=m;
print(N)
分幾個對象去定義方法
class daxiang():#類
    def __init__(self,mianji,nianling):#定義值
        self.mianji=mianji;
        self.nianling=nianling;
class bingxiang():
    def __init__(self,size):
        self.size=size;
class pepo():
    def __init__(self,name,nianling):#定義方法
        self.name=name;
        self.nianling=nianling;
    def open(self):
        print(self.name+'打開冰箱');
    def coles(self):
        print(self.name+'關閉冰箱門');
    def intobingxiang(self,mianji,size):
        print(self.name+'把大象放進冰箱');
if __name__ == '__main__':
    daxiang=daxiang(200,5800);
    bingxiang=bingxiang(6000);
    pepo=pepo('小王',25);
    pepo.open()
    pepo.intobingxiang(5800,bingxiang.size)
    pepo.coles();
#使用絕對路徑讀取文件
with open('test.txt') as a:#首先找到文件的所在，順便改個名字；
      b =a.read(5) # 讀取文件數據，把讀出來的數據賦值給一個變量
      print(b);
#文件處理,類
class readUtil():
    def __init__(self,file):
        self.file = file;

    def readfile(self,file):
        '''讀取文件的方法'''
        with open(file) as file_object:
            content = file_object.read();
        return content;
if __name__ == '__main__':
   n= readUtil.readfile(0,'test.txt');
print(n);
#一行一行讀取
with open ('test.txt') as n :
    s=0;
    for b in n:
        s+=1;
        print('第'+str(s)+'行的數據是：'+b);
#讀取文件的內容並寫到列表中
a=[];
with open ('test.txt') as c:#首先找到文件 並改名稱
    for m in c :  # 循環文件內容並賦值給一個變量，
        a.append(m.strip());#然後給空列表填入文件的數據
    print(a);
#或者：另一個方法
a1=[];
with open ('test.txt') as c:
    a1.append(c.readlines());

    print(a1);
 

#文件的寫入
#w表示寫入模式，a表示追加模式,r表示讀取模式

#with open (ad,'w') as bd:
 #   for p in range(1,50):
  #      bd.write(str(p)+'\n');
#print('寫入完成');
#用input 輸入往文件添加內容；

def defc(self,women):
    with open(women,'a')as hhh:
        while True:
            name=input('請輸入'+'\n');
            if name=='q':
                break
            else:
                hhh.write(name+'\n');
if __name__ == '__main__':
  ss= defc(0,'test1.txt');
print(ss)