Python 基礎入門學習
一.基本陳述句
-
注釋：
#單行注釋"""多行注釋""" -
print (" ")輸出函式 -
基本運算子：
+-*///(取整)%(取余)**(冪運算) -
變數的定義：
變數名 = 值(每個變數使用前都必須賦值，變數在賦值以后才會被創造，定義時不需要指定變數型別) -
type( )查看變數型別函式 -
input( )變數輸入函式 用法舉例： a = input(“輸入數字:”) 輸入的任何內容的資料型別默認為字符型str -
int(a)float(b)型別轉換函式，將a轉換為int型，將b轉換為float型 -
格式化輸出：
print("格式化字串" % 變數1)print("格式化字串" % (變數1,變數2...))(%s - 字串)
(%d - 帶符號十進制整數——%06d表示輸出六位數，不足地方用0補全)
(%f - 浮點數——%.02f表示小數點后顯示兩位)
(%% - 輸出%)
-
f-格式化字串： print(f’ My name is {name} ')
-
轉義字符：
\n換行\t制表符 ： 1個tab鍵（4個空格） -
結束符：python中的 print 默認以
\n為結束符，即默認換行，但可自己設定,如：print('hello', end="\t") -
識別符號 由字母、數字、下劃線組成，不能以數字開頭，不能與關鍵詞重名，識別符號區分大小寫，命名規則推薦多個單詞時全部小寫并將每個單詞用下劃線隔開，
-
if陳述句： 在Python開發中，Tab和空格一定不能混用！
if 條件1: 條件1成立時要執行的代碼 elif 條件2: 條件2成立時要執行的代碼 else: 條件1、2都不成立時執行的代碼 -
if陳述句訓練：猜拳游戲
#if-elif-else訓練： 猜拳游戲 import random player = int(input('請出拳 (0-拳頭 1-剪刀 2-布):')) computer = random.randint(0,2) #平局 if player == computer: print('平局') #電腦勝 elif ( ((player == 0) and (computer == 2)) or ((player == 1)and(computer == 0)) or ((player == 2)and(computer == 1)) ): print('電腦贏了！你個睿智！你連電腦都打不過！') #玩家勝 else: print('你贏了！不容易不容易啊！') -
亂數的實作：
匯入
random模塊，使用randint(隨機整數) 功 如：import random num = random.randint(0,2)? (num為0、1、2中的隨機一個數)
-
三目運算子：
條件成立時的運算式 if 條件 else 條件不成立時的運算式如：
MaxNum = a if a>b else b -
While 回圈:
while 條件: 條件成立時重復執行的代碼注意： 計數的初始值習慣寫為0
-
break 和 continue :
break為終止回圈，即不再回圈continue為退出當前一次回圈而直接執行下一次回圈，即跳入下一次回圈 -
for 回圈:
for 臨時變數 in 序列: 重復執行的代碼 -
while 與 else : 如果回圈由 break 停止，則else下的代碼不執行，for 與 else 的用法與此類似
while 條件: 條件成立時重復執行的代碼 else: 回圈正常結束之后執行的代碼
二.基本資料型別
-
字串可以用單引號、雙引號、三引號括起來，字串為不可變型別，
-
python中每個字串自帶下標和索引，可用
str[x]來精確訪問字串 str 中的某個字符 -
切片： 指對 字串、串列、元組 進行截取其中一部分的操作
語法： 序列[開始位置下標 : 結束位置下標 : 步長]
其中切片不包含結束位置下標對應的資料 ，即開始位置下標和結束位置下標為 [ ) 的包含形式
下標 和 步長 均可不寫或寫負數，步長默認為1，若下標開始到結束的方向與步長的方向沖突，則無法選取出資料
-
字串的查找： find() 、index() 、count() 、rfind() 、rindex()
find(): 檢測某個子串是否包含在這個字串中，如果存在則回傳這個子串開始位置的下標，否則回傳-1字串序列.find( 子串 , 開始位置下標 , 結束位置下標 )開始和結束位置下標可以省略，表示在整個字串序列中查找
index(): 與find()函式的用法一樣，但如果不存在要查找的子串，則會報錯count()：回傳某子串在該字串中出現的次數，若不存在則回傳0rfind()與rindex()查找方向為從右側開始，其功能與 find() 與 index() 相同 -
字串的替換 ：replace() 替換
字串序列.replace ( 舊子串、新子串、替換次數 )注意： replace函式并不會改變原有字串的資料，修改后的資料是replace函式的回傳值
-
字串的分割： split() 分割，回傳一個串列，丟失分割字符
字串序列.split(分割字符,分割次數)注意：split函式也不會改變原有字串資料，修改后的資料為函式回傳值
-
串列的合并：join() 合并，回傳一個字串，添加連接字符
連接字串.join(多字串組成的串列)注意： join() 合并 是 split() 分割 的逆序操作
-
字串修改大小寫函式：
capitalize()將字串第一個字母轉換為大寫，其余均為小寫title()將字串中每個單詞的首字母轉化成大寫，其余均為小寫lower()將字串中的大寫全部轉換為小寫upper()將字串中的小寫全部轉換為大寫例：
initial: brotheR aNd me
capitalize: Brother and me
title: Brother And Me
lower: brother and me
upper: BROTHER AND ME -
字串洗掉空白字符函式：
lstrip(): 洗掉字串左側空白字符rstrip(): 洗掉字串右側空白字符strip(): 洗掉字串兩側空白字符例：
initial: " brother and me "
lstrip: “brother and me "
rstrip: " brother and me”
strip: “brother and me” -
字串對齊函式： ljust() 、 rjust() 、center()
回傳 一個原字串 左/右/中 對齊，并用指定字符(默認空格)填充至對應長度的新字串
字串序列.ljust( 長度 , 填充字符 ) 字串序列.rjust( 長度 , 填充字符 ) 字串序列.center( 長度 , 填充字符 )例：
initial: brother and me
ljust: brother and me----------------
rjust: ----------------brother and me
center: --------brother and me-------- -
字串判斷開頭或結尾函式：
startswith(): 檢查字串是否以指定子串開頭，是則回傳True，否則回傳False，如果設定開始和結束位置下標，則在指定范圍內檢查字串序列.startswith(子串，開始位置下標，結束位置下標)endswith(): 檢查字串是否以指定子串結尾，用法與 startswith()相同字串序列.endswith(子串，開始位置下標，結束位置下標) -
字串字符型別判斷函式：
isalpha(): 如果字串非空且只包含字母則回傳True , 否則回傳Falseisdigit(): 如果字串非空且只包含數字則回傳True , 否則回傳Falseisalnum(): 如果字串非空且只包含數字或字母則回傳True, 否則回傳Falseisspace(): 如果字串非空且只包含空格則回傳True , 否則回傳False -
串列 : 可以用下標選取指定資料，串列為可變型別，
-
串列資料查找函式：
index(): 回傳指定資料所在位置的下標，若資料不存在則報錯串列序列.index(資料, 開始位置下標, 結束位置下標)count(): 回傳指定資料在該串列出現的次數，若資料不存在則回傳0串列序列.count(數據)len(): 回傳串列的長度，即串列中資料的個數len(串列序列) -
判斷串列中是否存在指定資料：
in: 判斷指定資料在某個序列的存在，存在回傳True，否則回傳False'指定資料' in 串列序列not in: 與 in 的用法相同，回傳結果相反 -
串列資料增加函式：
append(): 串列結尾追加資料，若資料為一個序列，則直接追加整個序列到串列的結尾位置串列序列.append(資料)extend(): 串列結尾追加資料，若資料為一個序列，則將序列的資料逐一添加到串列，若資料為字串，則將單獨的每個字符逐一添加到串列串列序列.extend(資料)insert(): 指定位置新增資料，增添方式與 append() 相同串列序列.insert(位置下表,資料) -
串列資料洗掉函式：
del 目標(串列名 或 串列指定下標資料)pop(): 洗掉指定下標的資料(默認為最后一個)，并回傳該資料，串列序列.pop(下標)remove(): 移除串列中某個資料的第一個匹配項，若匹配失敗則報錯串列序列.remove(資料)clear(): 清空串列中的所有資料串列序列.clear() -
串列資料修改函式：
修改指定下標資料： 串列序列[下標] = 資料
reverse(): 將串列資料的順序逆置串列序列.reverse()sort(): 對串列的資料進行排序串列序列.sort( key = None, reverse = False)注意： reverse = True 降序 reverse = False 升序(默認)
-
串列資料復制函式：
copy(): 串列資料復制新串列序列 = 原串列序列.copy()即將原串列的資料復制到新串列中
-
串列的回圈遍歷：
while回圈方法 :
i = 0 while i < len(list): print(list[i]) i += 1for回圈方法 :
for i in list: print(i) -
串列嵌套：指一個串列里包含了其他的子串列，
例：
List = [ ['a' , 'b' , 'c'] , ['1' , '2' , '3'] , ['&' , '$' , '%'] ] -
串列綜合訓練：
#將8位老師隨機分配到3個辦公室中 import random teacher = ['a1','a2','a3','a4','a5','a6','a7','a8'] room = [[],[],[]] for i in teacher: n = random.randint(0,2) room[n].append(i) print(room) i = 1 for r in room: print(f'辦公室{i}的人數是{len(r)},他們分別為：',end = '\t') for name in r: print(name,end = '\t') print() i += 1 -
元組： 一個元組可以存盤多個資料(與串列相同)，但元組內的資料是不能修改的，
元組名 (資料1 , 資料2 , 資料3)
注意： 如果定義的元組只有一個資料，那么需要添加逗號，湊則資料型別為該資料型別，而不是 元組(tuple) 資料型別，如 tuple = (‘x’ , )
-
元組的常見操作：
按下標查找資料 ： 如tuple1[0] 、 tuple1[1]等
index(): 查找某個資料，用法與字串、串列的index相同count(): 統計某個資料在當前元組出現的次數len(): 統計元組中的資料個數 -
元組資料的修改：
元組內的直接資料如果修改則立即報錯
如果元組里面有串列，可直接修改串列內的資料，如 (‘abc’ , ‘qwe’ , [‘123’ , ‘456’ , ‘789’] , ‘jkl’) 元組就可以修改其中的 ‘123’ , ‘456’ , ‘789’ 資料
-
字典：字典里的資料是以鍵值對形式存盤的，字典為可變型別，
特點： 符號為大括號，資料為鍵值對形式出現，各個鍵值對之間用逗號隔開，
dict1 = { '鍵1' : '值1' , '鍵2' : '值2' , '鍵3' : '值3' }空字典除了可以用空大括號創建，也可以用函式創建: dict2 = dict()
-
字典常見操作：
增 / 改： 字典序列[‘key’] = 值
注意： 如果key存在則修改該鍵對應的值，如果key不存在則新增此鍵值對
刪：
del(dict)洗掉字典del dict['Key']洗掉字典中指定鍵值對dict.clear()清空字典查：
按key值寫法直接查找： 字典序列[‘鍵’]
按函式寫法查找： get() keys() values() items()
get(): 獲取某個鍵對應的值字典序列.get(key , 默認值)注意：若當前查找的key不存在則回傳默認值，若默認值省略不寫則回傳None
keys(): 獲取字典中所有的key，并回傳可迭代物件字典序列.keys()values(): 獲取字典中所有的values，并回傳可迭代物件字典序列.values()items(): 獲取字典中所有的鍵值對(key 和 values)，并回傳可迭代物件 ，里面的資料是元組字典序列.items() -
字典的回圈遍歷：
遍歷字典的Key：
for key in dict1.keys(): print(key)遍歷字典的Value：
for value in dict1.values(): print(value)遍歷字典的元素：
for item in dict1.items(): print(item)遍歷字典的鍵值對(拆包)：
for key, value in dict1.items(): print(f'{key} = {value}') -
集合： 創建集合可使用 {} 或 set() ，但是如果要創建空集合只能使用 set() , 因為使用 {} 會創建空字典，
集合資料特點： 集合里面的資料會自動去重，不允許重復；集合里面的資料沒有順序，且不支持下標，集合是可變型別，
-
集合的創建：
直接創建：
s1 = {10 , 20 , 30 , 40 , 50}使用set()創建：
s2 = set('brother')創建空集合：
s3 = set() -
集合中資料的常見操作：
增加資料： add() update()
集合.add(資料)增加單個資料，要增加的資料在原集合中存在的話，不進行任何操作集合.update(資料串列)在集合中增加資料序列洗掉資料： remove() discard() pop()
集合.remove(資料)洗掉集合中的指定資料，如果資料不存在則會報錯集合.discard(資料)洗掉集合中的指定資料，如果資料不存在也不會報錯集合.pop()隨即洗掉集合中的某個資料，并回傳這個資料查找資料： in 判斷資料在集合序列 not in 判斷資料不在集合序列
-
公共操作：運算子、公共方法、容器型別轉換
運算子:
+合并，支持字串、串列、元組*復制，支持字串、串列、元組in元素是否存在，支持字串、串列、元組、字典not in元素是否不存在，支持字串、串列、元組、字典公共方法:
len()計算容器中元素個數del()洗掉元素max()回傳容器中元素的最大值min()回傳容器中元素的最小值range(start,end,step)生成從start到end的數字(其中不包含end數字)，步長為step，供for回圈使用enumerate()將一個可遍歷的資料物件(串列、元組或字串)組合為一個索引序列，同時列出資料和資料下標，一般用在for回圈中enumerate(可遍歷物件, start=0)容器型別轉換:
tuple(序列): 將某個序列轉換成元組list(序列): 將某個序列轉換成串列set(序列): 將某個序列轉換成集合 -
推導式(生成式): 串列推導式、字典推導式、集合推導式
作用： 化簡代碼
串列推導式：用一個運算式創建一個有規律的串列或控制一個有規律串列，
創建0-10的串列：
list = [i for i in range(10)]創建0-10的偶數串列：
list = [i for i in range(10) if i % 2 == 0]多個for回圈串列：
list = [(i , j) for i in range(3) for j in range(3)]字典推導式：快速合并串列為字典或提取字典中目標資料
賦值體驗：
dict = {i:i*2 for i in range(1,5)}將兩個串列合并為字典：
list1 = ['name' , 'age' , 'gender'] list2 = ['Tom' , 20 , 'man'] dict = { list1[i] : list2[i] for i in range(len(list1)) }提取字典中目標資料：
counts = {'a' : 150 , 'b' : 200 , 'c' : 250} count = {key : value for key , value in counts.items() if value >= 200}集合推導式：
list = [1,1,2] set = {i * 2 for i in list}
三.函式
-
函式：
def 函式名(引數):
? “”" 說明檔案內容 “”"
? 代碼1
? 代碼2
? …
注意：引數可有可無，必須先定義后使用
函式中return之后的代碼并不會執行
help(函式名) 查看函式解釋說明的資訊
-
函式（二）：
區域變數：只在函式體內部生效的變數
全域變數：指在函式體內、外都能生效的變數
在函式體內部修改全域變數：在函式體內部用 global 宣告變數為全域變數后修改
函式有多個回傳值時： return 后面可以直接書寫 元組、串列、字典，回傳多個值
位置引數：呼叫函式時根據函式定義的引數位置來傳遞引數，傳遞和定義引數的順序及個數必須一致
關鍵字引數：函式呼叫時，通過“鍵=值”的形式加以指定傳參，關鍵字引數之間不存在先后順序
預設引數：也叫默認引數，用于在定義函式時為引數提供默認值，呼叫函式時可以不傳入有默認值的引數，在定義和呼叫函式時，位置引數必須在預設引數之前
不定長引數：也叫可變引數，用于不確定呼叫時會傳遞多少個引數的場景，可用 包裹位置引數 或 包裹關鍵字引數 來進行引數傳遞
包裹位置傳遞(元組)：
def 函式名( *args ): print( args ) 函式名( 'abc' , 123 )包裹關鍵字傳遞(字典)：
def 函式名( **kwargs): print( kwargs ) 函式名( a = 'abc' , b = 123)包裹位置傳遞和包裹關鍵字傳遞都是一個組包的程序，即收集零散資料并組成一個元組或字典
回傳值拆包：
元組： return 10, 20 num1, num2 = 函式 即得到num1 = 10 , num2 = 20
字典： 對字典拆包，得到的是字典的key
-
交換變數值：
方法一：借助第三變數存盤資料
方法二： a, b = b, a
-
參考： 在python中，值是靠參考來傳遞的
可以用 id() 來判斷兩個變數是否為同一個值的參考，可以將id理解為那塊記憶體的地址標識，
-
可變型別與不可變型別：
可變型別：串列(list)、字典(dict)、集合(set)
不可變型別：整型、浮點型、字串、元組
-
函式加強應用—學員管理系統：
#定義功能界面函式 def print_info(): """函式功能界面""" print('---select---') print('1.add') print('2.delete') print('3.modify') print('4.query') print('5.show all') print('6.exit') print('----end----') #定義串列等待存盤學員資訊 info = [] #添加學員資訊函式 def add_info(): """學員添加函式""" new_name = input('input name:') new_id = input('input id:') new_tel = input('input telephone:') global info for i in info: if new_name == i['name']: print('name exists!') #return 退出當前函式，不執行下面添加資訊的代碼 return info_dict = {} info_dict['name'] = new_name info_dict['id'] = new_id info_dict['tel'] = new_tel info.append(info_dict) print('add successful!') #洗掉學員資訊 def del_info(): """學員洗掉函式""" del_name = input('input name:') global info for i in info: if del_name == i['name']: info.remove(i) print('delete successful!') break else: print('name does not exist!') #修改學員資訊 def modify_info(): """學員資訊修改函式""" modify_name = input('input name:') global info for i in info: if modify_name == i['name']: i['tel'] = input('input new telephone:') print('modify successful!') break else: print('name does not exist!') #查詢學員資訊 def search_info(): """查詢資訊函式""" search_name = input('input name:') global info for i in info: if search_name == i['name']: print('---Message---') print(f"The name is {i['name']}, The id is {i['id']}, The telephone is {i['tel']}，") break else: print('name does not exist!') #展示所有學員資訊函式 def showall_info(): """展示資訊函式""" print('name\tid\ttelephone') global info for i in info: print(f"{i['name']}\t{i['id']}\t{i['tel']}") while True: #1.顯示功能界面 print_info() #2.用戶輸入功能序號 user_num = int(input('your choice:')) #3.按照用戶輸入的功能序號，執行不同的功能（函式） if user_num == 1: add_info() elif user_num == 2: del_info() elif user_num == 3: modify_info() elif user_num == 4: search_info() elif user_num == 5: showall_info() elif user_num == 6: exit_flag = input('are you sure? Y/N') if exit_flag == 'Y': break else: print('Error!') -
遞回：
特點： 函式內部自己呼叫自己、必須有出口，
#遞回函式求1~n的累加和 def num(n): #出口 if n == 1: return 1 #函式內部自己呼叫自己 return n+num(n-1)若沒有出口，則報錯提示超出最大遞回深度（996），
-
lambda運算式（匿名函式）：應用場景： 化簡代碼，如果一個函式只有一個回傳值，并且只有一句代碼，可以使用lambda簡化，
lambda 引數串列: 運算式lambda運算式的引數串列可有可無，函式的引數在lambda運算式中完全適用，
lambda運算式能夠接收任何數量的引數但只能回傳一個運算式的值，
#計算 a+b 的lambda實作 fn = lambda a,b: a+b print(fn(1,2)) #輸出結果： 3lambda的引數形式：無參、有參、預設引數（默認）、可變引數*args、可變引數**kwargs，
#無參 fn1 = lambda : 100 #有參 fn2 = lambda a: a #預設引數 fn3 = lambda a,b,c=100: a+b+c #可變引數 *args(元組) fn4 = lambda *args: args #可變引數 *kwargs(字典) fn5 = lambda **kwargs: kwargslambda的應用：
#1.帶判斷的lambda fn1 = lambda a,b: a if a>b else b #兩個數比大小 fn2 = lambda n: n+fn2(n-1) if n != 1 else 1 #遞回求1~n的累加和 #2.串列資料按字典key的值排序 students = [ {'name':'Tom','age':19}, {'name':'Alice','age':20}, {'name':'Hack','age':18} ] students.sort(key=lambda n: n['name']) #按照名字首字母升序排序 students.sort(key=lambda n: n['age'], reverse=True) #按照年齡降序排序 -
高階函式：
把函式作為引數傳入，這樣的函式稱為高階函式（即復合函式），
測驗用到的小函式：
abs()：對數字求絕對值
round()：對數字進行四舍五入
def sum(a, b, f): return f(a)+f(b) result1 = sum(3.14, -2.8, abs) result2 = sum(3.14, -2.8, round) #lambda運算式改寫 sum = lambda a,b,f: f(a)+f(b)Python內置高階函式： map()、reduce()、filter()，
map(func, list)：將傳入的函式變數func作用到串列變數list中的每個元素中，并將結果組成新的串列(python2)/迭代器(python3)回傳，#計算list1序列中各個數字的三次方 list1 = [1,2,3,4,5] def func(x): return x ** 3 result = map(func, list1) #此時result為map回傳的迭代器 print(result) #將回傳迭代器result的地址 print(list(result)) #[1, 8, 27, 64, 125]reduce(func, list)：functools模塊中的一個高階函式，其中func必須有兩個引數，每次func結算的結果繼續和序列的下一個元素做累積計算，#計算list2序列中各個數字的累加和 import functools #匯入模塊 list2 = [1,2,3,4,5] def func(a,b): return a+b result = functools.reduce(func,list2) print(result) #15filter(func, list)：用于過濾序列，過濾掉不符合條件的元素，并回傳一個filter物件，可用 list() 轉換為串列，#過濾list3序列中所有的偶數，只留下奇數 list3 = [1,2,3,4,5,6,7,8,9] def func(x): return x%2 != 0 result = filter(func,list3) result = list(result) print(result) #[1,3,5,7,9]
四.檔案操作
-
檔案操作：
作用：把一些內容（資料）存盤存放起來，可以讓程式下一次執行的時候直接使用，而不必重新制作一份，省時省力，
檔案操作步驟：打開檔案、讀寫等操作、關閉檔案，
open()：打開一個已經存在的檔案，或創建一個新檔案，f = open(name, mode) #name: 是要打開的目標檔案名的字串（可以包含檔案所在的具體路徑） #mode: 設定打開檔案的模式（訪問模式）:只讀、寫入、追加等 #此時f為name檔案的檔案物件，可通過f執行之后的讀寫等操作主訪問模式 描述 r 以只讀方式打開檔案，檔案的指標將會放在檔案的開頭，這是默認模式（訪問模式未指定時，即為只讀模式）， w 打開一個檔案只用于寫入，如果該檔案已存在則打開檔案，并從開頭開始編輯，即原有內容會被洗掉，如果該檔案不存在，創建新檔案， a 打開一個檔案用于追加，如果該檔案已存在，檔案指標將會放在檔案的結尾，也就是說，新的內容將會被寫入到已有內容之后，如果該檔案不存在，創建新檔案進行寫入， (b) 以二進制形式讀取 (+) 可讀可寫 訪問模式r+、w+、a+的區別：
r+：沒有該檔案則報錯，檔案指標在開頭故能讀取資料w+：沒有該檔案會新建，檔案指標在開頭并會用新內容覆寫原有內容，故無法讀取檔案內原有的資料a+：沒有該檔案會新建，檔案指標在結尾故不能讀取資料寫入內容：write()
檔案物件.write('內容')讀取內容：read()、readlines()、readline()，
檔案物件.read(num) #num 表示要從檔案中讀取的資料的長度，不寫則默認讀取所有資料，其中換行符'\n'會占一位 檔案物件.readnlines() #按照行的方式把整個檔案的內容進行一次性讀取，并回傳一個串列，其中每一行資料為一個元素 檔案物件.readline() #一次讀取一行內容、重復呼叫readline()則依次讀取檔案中每一行的內容移動檔案指標：seek()
檔案物件.seek(偏移量，起始位置) #起始位置引數： 0開頭 1當前 2結尾應用：
#使用 a 訪問模式打開檔案，通過改變檔案指標位置來讀取資料 f = open('test.txt','a') f.seek(0,0) #此時可簡寫為 f.seek(0) con = f.read() f.close() -
檔案備份案例：
#用戶輸入當前目錄下任意檔案名，程式完成對該檔案的備份功功能（備份檔案名為 xx[備份].后綴） #1.接收用戶輸入的檔案名 old_name = input('input yoru backup file name:') #2.規劃備份檔案名 index = old_name.rfind('.') #檔案名中'.'的位置 if index > 0: #判斷檔案名，防止出現'.txt'類的無效檔案名 postfix = old_name[index:] new_name = old_name[:index] + '[備份]' + postfix #利用字串的切片重新規劃備份檔案名 #3.備份檔案寫入資料 old_f = open(old_name,'rb') new_f = open(new_name,'wb') while True: #回圈讀取，防止檔案過大時卡死 con = old_f.read(1024) if len(con) == 0: #讀取完成時 break new_f.write(con) new_f.close() old_f.close() -
檔案和檔案夾的操作：
模塊：使用 os 模塊
import os #1.檔案操作 #檔案重命名，也可以重命名檔案夾 os.rename(目標檔案名或路徑, 新檔案名) #檔案洗掉，也可以洗掉檔案夾 os.remove(目標檔案名) #2.檔案夾操作 #創建檔案夾 os.mkdir(檔案夾名字) #洗掉檔案夾 os.rmdir(檔案夾名字) #3.目錄操作 #獲取當前目錄 os.getcwd() #改變當前默認目錄 os.chdir(目錄檔案夾) #獲取目錄串列 os.listdir(目錄檔案夾) -
檔案和檔案夾操作應用案例：
#批量修改檔案名，既可添加指定字串，又能洗掉指定字串 import os #構造條件資料 flag = input('輸入操作型別（1為添加，2為洗掉）：') #構造指定字串 str = input('請輸入指定字串：') #找到所有檔案 file_list = os.listdir() #添加或洗掉指定字串 for i in file_list: if flag == '1': new_name = str + i elif flag == '2': num = len(str) new_name = i[num:] else: print('操作模式輸入錯誤！') break #重命名 os.rename(i, new_name)
五.面向物件
-
類是對一系列具有相同特征和行為的事物的統稱，是一個抽象的概念，不是真實存在的事物，物件是由類創建出來的真實存在的事物，
#創建類 class 類名(): #類名要滿足識別符號命名規則，同時遵循大駝峰命名習慣 代碼 ...... def 函式名(self): #self指呼叫該函式的物件 代碼 #創建物件 物件名 = 類名() -
類外面添加物件屬性：
物件名.屬性名 = 值類外面獲取物件屬性：
物件名.屬性名類里面獲取物件屬性：
self.屬性名綜合實體：
class Washer(): def wash(self): print('wash the clothes!') def get_size(self): print(f'此洗衣機的尺寸是{self.width} X {self.height}') haier1 = Washer() haier1.width = 500 haier1.height = 300 haier2 = Washer() haier2.width = 600 haier2.height = 400 print(haier1.width) haier1.get_size() haier2.get_size() -
魔法方法： __init__() 、 __str__()、__del__()，
#1. __init__() 初始化物件， #創建物件時默認被呼叫；不需開發者傳遞self引數，python解釋器會自動把當前物件參考傳遞過去， class washer(): def __init__(self,width,height): self.width = width self.height = height def print_info(self): print(f'{self.width} X {self.height}') h = washer(500,800) h.print_info() #輸出結果 500 X 800 #2. __str__() 使得用print輸出物件時，輸出該方法中return的資料,而不再輸出物件的記憶體地址， def __str__(self): return "這是洗衣機物件！" print(h) #輸出結果 這是洗衣機物件！ #3. __del__() 當洗掉物件時，python解釋器會默認呼叫__del__()方法 def __del__(self): print(f'{self}物件已經被洗掉！') del h #輸出結果 <__main__.washer object at 0x000002531DF744F0>物件已經被洗掉！ -
兩個案例：
烤地瓜
#需求：1.被烤時間和地瓜狀態相對應 2.用戶可按意愿添加調料 class SweetPotato(): def __init__(self): self.cook_time=0 self.cook_state='生的' self.condiments=[] def cook(self, time): if time >=0: self.cook_time += time if 0<= self.cook_time < 3: self.cook_state = '生的' elif 3 <= self.cook_time < 5: self.cook_state = '半生不熟' elif 5 <= self.cook_time < 8: self.cook_state = '熟了' elif self.cook_time >= 8: self.cook_state = '糊了!' else: print('時間刺客？！') def add_condiment(self, con): self.condiments.append(con) def __str__(self): return f'這個地瓜烤了{self.cook_time}分鐘，狀態是{self.cook_state}，添加的調料有{self.condiments}' p = SweetPotato() p.add_condiment('番茄醬') print(p) p.cook(8) p.add_condiment('芥末') print(p) # 這個地瓜烤了0分鐘，狀態是生的，添加的調料有['番茄醬'] # 這個地瓜烤了8分鐘，狀態是糊了!，添加的調料有['番茄醬', '芥末']搬家具
#需求 將小于房子剩余面積的家具擺放到房子中 class Furniture(): def __init__(self,name,area): self.name = name self.area = area class House(): def __init__(self,adress,area): self.adress = adress self.area = area self.free_area = area self.furniture = [] def add_furniture(self,item): if self.free_area >= item.area: self.furniture.append(item.name) self.free_area -= item.area else: print('家具太大，剩余面積不足，無法容納') def __str__(self): return f'這個房子的地址是{self.adress}，總面積是{self.area}，當前剩余面積是{self.free_area}，家具有{self.furniture}' bed = Furniture('雙人床',6) sofa = Furniture('沙發',10) court = Furniture('高爾夫球場',1000) house = House('陸家嘴',200) print(house) house.add_furniture(bed) house.add_furniture(sofa) house.add_furniture(court) print(house) #這個房子的地址是陸家嘴，總面積是200，當前剩余面積是200，家具有[] #家具太大，剩余面積不足，無法容納 #這個房子的地址是陸家嘴，總面積是200，當前剩余面積是184，家具有['雙人床', '沙發'] -
繼承： Python面向物件的繼承指的是多個類之間的所屬關系，即子類默認繼承父類的所有屬性和方法，具體如下：
#定義父類A class A(object): def __init__(self): self.num = 1 def infor_print(self): print(self.num) #定義子類B，繼承父類A class B(A): pass #創建物件，驗證物件繼承 result = B() result.info_print()在python中，所有類默認繼承object類，object類是頂級類或基類；其他子類叫派生類，
拓展：python2中的經典類 和 python3中的新式類
#經典類(不由任意內置型別派生出的類) class 類名: 代碼 ...... #新式類 class 類名(object): 代碼 ...... #在今后的學習和運用中，統一使用新式類單繼承：一個子類繼承一個父類，這種單一的繼承關系稱為單繼承，
多繼承：一個子類同時繼承多個父類，
class 子類(父類A,父類B,父類C) #當兩個父類中的屬性和方法有同名時，優先繼承第一個父類中的同名屬性和方法，即繼承A類，子類重寫父類同名屬性與方法：在子類中可以重寫與父類中同名的屬性和方法，子類創建的物件呼叫屬性和方法時，會呼叫子類中重寫的屬性和方法，
拓展： **__mro__**順序 方法查看類的繼承層級順序，
print(類名.__mro__)子類呼叫父類同名屬性和方法：在子類中重寫了父類中同名屬性與方法的情況下，呼叫父類中的同名屬性和方法，
class 子類B(父類A): def 同名方法(self): #如果之前呼叫了父類的屬性和方法，則父類屬性會覆寫子類屬性，故在呼叫子類屬性前，先呼叫子類自己的初始化 self.__init__(self) 代碼 def 呼叫父類方法(self): #呼叫父類方法，為保證呼叫到的屬性也是父類的屬性，必須在呼叫方法前呼叫父類的初始化 父類A.__init__(self) 父類A.同名方法(self)多層繼承：一般指大于兩層的繼承關系，
class A(object): ... class B(A): ... class C(B): #多層繼承 ...super()呼叫父類方法：自動查找父類，直接呼叫父類的屬性方法，呼叫順序遵循__mro__類屬性的順序，
class A(object) class B(A) class C(B): #方法一：原始方法 def useAB(self): A.__init__(self) A.同名方法(self) B.__init__(self) b.同名方法(self) #方法二：super()方法 #方法2.1 super(當前類名,self).函式() def useAB(self): super(C,self).__init__() super(C,self).同名方法() #此時會呼叫父類B的方法;若想呼叫A類的方法，需要在B類的同名方法中添加同樣的super方法代碼來呼叫A類 #方法2.2 super().函式() def useAB(self): super().__init__(self) super().同名方法() #同樣呼叫父類B的方法;無法直接呼叫父類的父類A的屬性和方法 -
私有權限
**設定私有屬性和方法：在屬性名和方法名 **前面加上兩個下劃線，
私有屬性和私有方法只能在類內訪問和修改，即子類無法繼承或直接訪問父類的私有屬性和方法，
class A(object): def __init__(self): self.name = 'A' self.__money = 99999 #私有屬性 def __CostMoney(self,money): #私有方法 self.__money -= money獲取和修改私有屬性值：可在類內定義公有函式來獲取和修改 私有屬性值，在類外呼叫該函式來實作獲取和修改私有屬性功能，
#一般在類內用函式名get_xx來獲取私有屬性，用set_xx來修改私有屬性 class A(object): def __init__(self): self.__money = 99999 def get_money(self): return self.__money def set_money(self,new_money): self.__money = new_money class B(A): pass b = B() b.get_money() #成功獲取父類中的私有屬性 b.set_money(0) #成功修改父類中的私有屬性 -
多型：一種使用物件的方式，子類重寫父類方法，呼叫不同子類物件的相同父類方法，可以產生不同的執行結果，即傳入不同的物件，產生不同的結果，
-
類屬性和實體屬性：類屬性即類所擁有的屬性，它為該類所有物件共有，類屬性可以用 類物件 或 實體物件 訪問，
類屬性只能通過類物件修改，
#修改類屬性 類名.屬性 = 值 -
類方法：需要用裝飾器
@classmethod來標識其為類方法，類方法第一個引數必須是類物件，一般以cls作為第一個引數，class A(object): __num = 777 @classmethod def get_num(cls): return cls.__num obj = A() print(obj.get_num()) -
靜態方法：通過裝飾器
@staticmethod進行修飾，靜態方法即不需要傳遞類和物件的方法，有利于減少不必要的記憶體占用和性能消耗，class A(object): @staticmethod def info_print(): print('這是A類')
六.例外
-
例外的定義：解釋器檢測到錯誤時無法繼續執行，并出現一些錯誤的提示，這就是所謂的例外，
例外的作用：使得解釋器檢測到錯誤時，轉而執行另一句沒錯誤的陳述句，使得程式不因一個錯誤而停止下來，
-
基本寫法：
try: 可能發生錯誤的代碼 except: 出現例外時執行的代碼 else: 沒有例外時執行的代碼 finally: 無論是否例外都要執行的代碼體驗案例：
#需求：嘗試以r模式打開檔案，若檔案不存在(發生錯誤)，則以w方式打開 try: f = open('test.txt','r') except: f = open('test.txt','w') -
捕獲指定例外：
try: print(num) except (NameError, ZeroDivisionError) as result: print(result) #捕獲的例外描述資訊 num = 777 print(num) #若嘗試執行代碼的例外型別和要捕獲的例外型別不一致，則無法捕獲例外 #一般try下方只放一行嘗試執行的代碼 -
捕獲所有例外：利用 Exception 類
#Exception是所有程式例外類的父類 try: 可能錯誤的代碼 except Exception as result: print(result) -
例外中的 else 和 finally:
try: f = open('test.txt','r') except Exception as result: f = open('test.txt','w') print(result) else: # try 下方的代碼無例外時執行的代碼 print('代碼沒有例外和錯誤') finally: #無論有無例外都要執行的代碼，如關閉檔案 f.close() -
例外的傳遞：
import time try: f = open('test.txt') #默認打開模式為只讀 #嘗試回圈讀取內容 try: while True: con = f.readline() #無內容時退出回圈 if len(con) == 0: break time.sleep(2) print(con) except: #在命令提示符中按下 Ctrl+C 終止程式 print('程式被意外終止') except: print('檔案不存在') -
自定義例外： 拋出自定義例外的語法為
raise 例外類物件#自定義例外類，繼承Exception class ShortInputError(Exception): def __init__(self,length,min_length): self.length=length self.min_length=min_length #設定拋出例外的描述資訊 def __str__(self): return f'輸入長度為{self.length},不能少于{self.min_length}個字符' def main(): #封裝代碼 try: con = input('請輸入密碼: ') if len(con) < 6: raise ShortInputError(len(con),6) except Exception as result: print(result) else: print('密碼輸入完成') main()
七.模塊
-
了解模塊：Python模塊(Module)，是一個Python檔案，包含了Python物件定義和陳述句，
-
匯入和呼叫模塊：
#匯入及呼叫模塊 #寫法一 import 模塊名 #匯入模塊中的所有代碼 模塊名.功能名() #寫法二 from 模塊名 import 功能1,功能2... #單個呼叫某功能 功能名() #即不需要在功能前寫 "模塊名." #寫法三 from 模塊名 import * 功能名() #一般用第一種寫法利用as定義別名：定義別名后，使用時要用定義的別名
#模塊定義別名 import 模塊名 as 別名 #功能定義別名 from 模塊名 import 功能 as 別名 -
制作模塊：模塊名字就是py檔案的名字，自定義模塊名必須要符合識別符號命名規則，
#只會在當前檔案中呼叫下列測驗代碼，其他匯入的檔案內不符合該條件，也就不會執行測驗代碼 # __name__ 是系統變數，是模塊的識別符號，如果在自身模塊里，則其值為 '__main__';否則是所在模塊的名字 if __name__ == '__main__': 測驗模塊功能代碼 -
模塊定位順序：當匯入一個模塊，Python解釋器對模塊位置的搜索順序是：
當前目錄 > 搜索在shell變數PYTHONPATH下的每個目錄 > 作業系統的默認python路徑
注意：
自己的檔案名不要和已有模塊名重復，否則模塊功能無法使用，
使用
from 模塊名 import 功能時，若功能名字重復，則呼叫最后定義的或最后匯入的功能，當使用
import 模塊名的寫法呼叫模塊時，不需要擔心功能名重復， -
__all__串列：如果一個模塊檔案中有__all__變數串列，當使用from 模塊名 import *匯入該模塊時，則只能匯入__all__串列中的元素， -
包：包將有聯系的模塊組織在一起，放到同一個檔案夾下，并且在這個檔案夾內自動生成一個名字為
__init__.py的檔案，這個檔案控制著包的匯入行為，創建包：在Pycharm中 New -> Python Package -> 輸入包名 - > [OK] 即可新建一個包，
匯入包：
#方法一 import 包名.模塊名 包名.模塊名.功能 #方法二 #注意，必須在 __init__.py 檔案中添加 __all__ = [] 來控制允許匯入的模塊串列 from 包名 import * 模塊名.功能
八.面向物件綜合實體
#使用面向物件編程思想完成學員管理系統的開發
#為了方便維護代碼，一般一個角色一個程式檔案
#專案要有主程式入口，習慣為main.py
#系統要求：學員資料存盤在檔案中
#系統功能：添加學員、洗掉學員、修改學員資訊、查詢學員資訊、顯示所有學員資訊、保存學員資訊、退出系統等功能
#student.py
#學員類
class Student(object):
def __init__(self,name,gender,tel):
#姓名、性別、手機號
self.name = name
self.gender = gender
self.tel = tel
def __str__(self):
return f'{self.name},{self.gender},{self.tel}'
#mangerSystem.py
#存盤資料的: student.data
#存盤資料的形式: 串列存盤學員物件
#系統功能: 添加、洗掉、修改、查詢、顯示、保存學員資訊
#管理系統類
class StudentManager(object):
def __init__(self):
#存盤資料所用串列
self.student_list = []
#一. 程式入口函式，啟動程式后執行的函式
def run(self):
#1. 加載學員資訊
self.load_student()
while True:
#2. 顯示功能選單
self.show_menu()
#3. 用戶輸入目標功能序號
menu_num = int(input('請輸入您需要的功能序號: '))
#4. 根據用戶輸入的序號執行相應功能
if menu_num == 1:
# 添加學員
self.add_student()
elif menu_num == 2:
# 洗掉學員
self.del_student()
elif menu_num == 3:
# 修改學員資訊
self.modify_student()
elif menu_num == 4:
# 查詢學員資訊
self.search_student()
elif menu_num == 5:
# 顯示所有學員資訊
self.show_menu()
elif menu_num == 6:
# 保存學員資訊
self.save_student()
elif menu_num == 7:
# 退出系統 - 退出回圈
break
#二. 系統功能函式
#2.1 顯示功能選單 -- 靜態方法
@staticmethod
def show_menu():
print('請選擇如下功能: ')
print('1.添加學員')
print('2.洗掉學員')
print('3.修改學員資訊')
print('4.查詢學員資訊')
print('5.顯示所有學員資訊')
print('6.保存學員資訊')
print('7.退出系統')
#2.2 添加學員
def add_student(self):
#1. 用戶輸入
name = input('請輸入姓名: ')
gender = input('請輸入性別: ')
tel = input('請輸入手機號: ')
#2. 創建學員物件 -- 先匯入student.py模塊
student = Student(name,gender,tel)
#3. 將物件添加到學員串列
self.student_list.append(student)
#2.3 洗掉學員
def del_student(self):
#1. 用戶輸入目標學員姓名
del_name = input('請輸入要洗掉的學員姓名:')
#2. 如果用戶輸入的目標學員存在則洗掉，否則提示不存在
for i in self.student_list:
if i.name == del_name:
self.student_list.remove(i)
break
else:
print('查無此人!')
#2.4 修改學員資訊
def modify_student(self):
#1. 用戶輸入目標學員姓名
modify_name = input('請輸入要修改的學員姓名: ')
#2. 如果用戶輸入的目標學員存在，則修改資訊，否則提示不存在
for i in self.student_list:
if i.name == modify_name:
i.name = input('請輸入學員姓名: ')
i.gender = input('請輸入學員性別: ')
i.tel = input('請輸入學員手機號: ')
print('修改成功!')
break
else:
print('查無此人!')
#2.5 查詢學員資訊
def search_student(self):
#1. 用戶輸入目標學員姓名
search_name = input('請輸入要查詢的學員姓名: ')
#2. 若存在，列印學員資訊，否則提示不存在
for i in self.student_list:
if i.name == search_name:
print(f'姓名{i.name}，性別{i.gender}，手機號{i.tel}')
break
else:
print('查無此人!')
#2.6 顯示所有學員資訊
def show_student(self):
print('姓名\t性別\t手機號')
for i in self.student_list:
print(f'{i.name}\t{i.gender}\t{i.tel}')
#2.7 保存學員資訊
def save_student(self):
# 拓展 __dict__方法，以字典方式回傳類和物件內的屬性
#1. 打開檔案
f = open('student.data','w')
#2. 檔案寫入學員資料 - 先將學員物件資料轉換成串列字典資料再做存盤
new_list = [i.__dict__ for i in self.student_list]
# 檔案內資料要求為字串型別，故要先轉換資料型別為字串才能寫入檔案
f.write(str(new_list))
#3. 關閉檔案
f.close()
#2.8 加載學員資訊
def load_student(self):
#嘗試以"r"模式打開資料檔案，有例外則用"w"模式打開;存在則讀取資料
try:
f = open('student.data','r')
except:
f = open('student.data','w')
else:
#1. 讀取資料
data = f.read()
#2. 先將檔案中的 字串型字典資料 轉換為 物件資料 后再存盤到學員串列
new_list = eval(data)
self.student_list = [Student(i['name'],i['gender'],i['tel']) for i in new_list]
finally:
#3. 關閉檔案
f.close()
#main.py
#匯入模塊
#from managerSystem import *
#啟動管理系統
#if __name__ == '__main__':
student_manager = StudentManager()
student_manager.run()
?
?
轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/182029.html
標籤：其他
下一篇：自制爬蟲框架