1. 入門(mén)

Python語(yǔ)法采用縮進(jìn)方式，以#開(kāi)頭的語(yǔ)句是注釋，當(dāng)語(yǔ)句以:為結(jié)尾時(shí)，縮進(jìn)的語(yǔ)句視為代碼塊

Python是動(dòng)態(tài)語(yǔ)言，其變量本身類(lèi)型不固定。與之對(duì)應(yīng)的是靜態(tài)語(yǔ)言。靜態(tài)語(yǔ)言在定義變量時(shí)必須指定變量類(lèi)型，如果賦值的時(shí)候類(lèi)型不匹配，就會(huì)報(bào)錯(cuò)，Java就屬于靜態(tài)語(yǔ)言

空值None是Python里一個(gè)特殊的值，None不能理解為0，因?yàn)?是有意義的，而None是一個(gè)特殊的空值

a = -1; if a>=0:print(a) else: #冒號(hào)下相同縮進(jìn)部分視為在同一個(gè)代碼塊print(-a)print("hello") print("你好")

2. 輸入輸出

# 單引號(hào)引起來(lái)是字符串 print('Hello') # 逗號(hào)隔開(kāi)輸出不同內(nèi)容，同時(shí)會(huì)自動(dòng)填上一個(gè)空格 print('100+200=',100+200) # 若不想要空格可以在print最后添加參數(shù)sep=''，默認(rèn)情況sep=' ' print('100+200=',100+200,sep='')num = 15 # 也可以使用這種方式進(jìn)行格式化輸出 print(f"num是{num}") # input()是輸入函數(shù)，輸入結(jié)果放入name變量，python不需要手動(dòng)定義類(lèi)型 name = input(); # 在提示語(yǔ)句后輸入 name = input('請(qǐng)輸入：');

3. 數(shù)據(jù)類(lèi)型和變量

計(jì)算機(jī)能處理的遠(yuǎn)不止數(shù)值，還可以處理文本、圖形、音頻、視頻、網(wǎng)頁(yè)等各種各樣的數(shù)據(jù),不同的數(shù)據(jù)，需要定義不同的數(shù)據(jù)類(lèi)型。

3.1 整數(shù)

Python可以處理任意大小的整數(shù)，當(dāng)然包括負(fù)整數(shù)，在程序中的表示方法和數(shù)學(xué)上的寫(xiě)法一模一樣，例如：1，100，-8080，0

計(jì)算機(jī)由于使用二進(jìn)制，所以，有時(shí)候用十六進(jìn)制表示整數(shù)比較方便，十六進(jìn)制用0x前綴和0-9，a-f表示，例如：0xff00，0xa5b4c3d2

對(duì)于很大的數(shù)，例如10000000000，很難數(shù)清楚0的個(gè)數(shù)。Python允許在數(shù)字中間以_分隔，因此，寫(xiě)成10_000_000_000和10000000000是完全一樣的。十六進(jìn)制數(shù)也可以寫(xiě)成0xa1b2_c3d4

3.2 浮點(diǎn)數(shù)

浮點(diǎn)數(shù)也就是小數(shù)，之所以稱(chēng)為浮點(diǎn)數(shù)，是因?yàn)榘凑湛茖W(xué)記數(shù)法表示時(shí)，一個(gè)浮點(diǎn)數(shù)的小數(shù)點(diǎn)位置是可變的

比如， $$1.23\times 10^9$$ 和 $12.3\times 10^8$ 是完全相等的。浮點(diǎn)數(shù)可以用數(shù)學(xué)寫(xiě)法，如1.23，3.14，-9.01

• 對(duì)于很大或很小的浮點(diǎn)數(shù)，必須用科學(xué)計(jì)數(shù)法表示，把10用e替代，$1.23?10^9$ 就是1.23e9，或者12.3e8，0.000012可以寫(xiě)成1.2e-5
• 整數(shù)和浮點(diǎn)數(shù)在計(jì)算機(jī)內(nèi)部存儲(chǔ)的方式是不同的，整數(shù)運(yùn)算永遠(yuǎn)是精確的，而浮點(diǎn)數(shù)運(yùn)算則可能會(huì)有四舍五入的誤差【詳情請(qǐng)看計(jì)算機(jī)組成原理】

3.3 字符串

字符串是以單引號(hào)'或雙引號(hào)"括起來(lái)的任意文本，比如'abc'，"xyz"

• 如果字符串內(nèi)部既包含單引號(hào)''又包含雙引號(hào)""怎么辦？可以用轉(zhuǎn)義字符\來(lái)標(biāo)識(shí)，使特殊字符失去特殊含義

  s = 'I\'m \"OK\"!' # 輸出：I'm "OK"! print(s)

• 轉(zhuǎn)義字符\除了使特殊字符失去特殊含義，也能讓部分字符得到特殊含義，比如\n表示換行，\t表示制表符，字符\本身也要轉(zhuǎn)義，所以\\表示的字符就是\

• 如果字符串里面有很多字符都需要轉(zhuǎn)義，就需要加很多\，為了簡(jiǎn)化，Python還允許用r''表示''內(nèi)部的字符串默認(rèn)不轉(zhuǎn)義

  # 輸出\t print(r'\t')

• 如果字符串內(nèi)部有很多換行，用\n寫(xiě)在一行里不好閱讀，為了簡(jiǎn)化，Python允許用'''...'''的格式表示多行內(nèi)容

  # 輸出 line1 line2 line3三行 print('''line1 line2 line3''')

3.4 布爾值

布爾值和布爾代數(shù)的表示完全一致，一個(gè)布爾值只有True、False兩種值，要么是True，要么是False，在Python中，可以直接用True、False表示布爾值，也可以通過(guò)布爾運(yùn)算計(jì)算出來(lái)

• 布爾值可以用and【與】、or【或】和not【非】計(jì)算

  # 輸出False print(True and False) # 輸出True print(not False) # 輸出False print(17 > 18)

3.5 常量

常量就是不能變的變量，比如常用的數(shù)學(xué)常數(shù)π就是一個(gè)常量。在Python中，通常用全部大寫(xiě)的變量名表示常量

PI = 3.14159265359

但事實(shí)上PI仍然是一個(gè)變量，Python根本沒(méi)有任何機(jī)制保證PI不會(huì)被改變，所以，用全部大寫(xiě)的變量名表示常量只是一個(gè)習(xí)慣上的用法

• /除法計(jì)算結(jié)果是浮點(diǎn)數(shù)，即使是兩個(gè)整數(shù)恰好整除，結(jié)果也是浮點(diǎn)數(shù)
• 還有一種除法是//，稱(chēng)為地板除，結(jié)果只保留整數(shù)部分

# 輸出為 3.0 print(9 / 3) # 輸出為 3 print(10 // 3)

3.6 理解變量在內(nèi)存中的表示

a = 'ABC' b = a a = 'XYZ' # 最終輸出ABC print(b)

• 當(dāng)a賦給b時(shí)，實(shí)際上是令b指向了a此時(shí)指向的常量數(shù)據(jù)ABC
• 由于b本質(zhì)指向的是數(shù)據(jù)，因此隨后a指向了新數(shù)據(jù)后并不會(huì)影響b的指向
• 因此b最終指向的依然是ABC

4. 字符串

Python的字符串類(lèi)型是str，在內(nèi)存中以Unicode表示，一個(gè)字符對(duì)應(yīng)若干個(gè)字節(jié)。如果要在網(wǎng)絡(luò)上傳輸，或者保存到磁盤(pán)上，就需要把str變?yōu)橐宰止?jié)為單位的bytes

4.1 編碼

在操作字符串時(shí)，我們經(jīng)常遇到str和bytes的互相轉(zhuǎn)換。為了避免亂碼問(wèn)題，應(yīng)當(dāng)始終堅(jiān)持使用UTF-8編碼對(duì)str和bytes進(jìn)行轉(zhuǎn)換。

# ord()函數(shù)獲取字符的Unicode編碼 # 輸出65【英文字符上Unicode編碼與ASKII碼一致】 print(ord('A')) # chr()函數(shù)把編碼轉(zhuǎn)換為對(duì)應(yīng)的字符 # 輸出a，因?yàn)?7對(duì)應(yīng)的是a print(chr(97)) # 如果知道字符的整數(shù)編碼，也可以直接用十六進(jìn)制寫(xiě) # Unicode編碼對(duì)應(yīng)'中文'，因此輸出'中文'兩個(gè)字 print('\u4e2d\u6587') # Python對(duì)bytes類(lèi)型的數(shù)據(jù)用帶b前綴的單引號(hào)或雙引號(hào)表示 # 此時(shí)x存放的是bytes類(lèi)型 x=b'ABC' # 通過(guò)encode()方法可以編碼為指定的bytes # 將字符串轉(zhuǎn)換為ASKII碼對(duì)應(yīng)的bytes存儲(chǔ) print('ABC'.encode('ascii')) # 將字符串轉(zhuǎn)換為UTF-8碼對(duì)應(yīng)的bytes存儲(chǔ) print('中文'.encode('UTF-8')) # 通過(guò)decode()方法可以將bytes按照指定方式解碼 # 以ASKII碼的方式解釋字節(jié)流，輸出ABC print(b'ABC'.decode('ascii')) # 如果bytes中只有一小部分無(wú)效的字節(jié)，可以傳入errors='ignore'忽略錯(cuò)誤的字節(jié)，如下 # 只輸出'中'，因?yàn)榱硪粋€(gè)字節(jié)碼在utf-8編碼情況下不對(duì)應(yīng)任何字符 print(b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore'))

4.2 其他方法

4.3 格式化

%運(yùn)算符用來(lái)格式化字符串。在字符串內(nèi)部，%s表示用字符串替換，%d表示用整數(shù)替換，有幾個(gè)%?占位符，后面就跟幾個(gè)變量或者值，順序要對(duì)應(yīng)好。如果只有一個(gè)%?，括號(hào)可以省略

如果不太確定應(yīng)該用什么，%s永遠(yuǎn)起作用，它會(huì)把任何數(shù)據(jù)類(lèi)型轉(zhuǎn)換為字符串

字符串里面的%是一個(gè)普通字符時(shí)需要轉(zhuǎn)義，用%%來(lái)表示一個(gè)%

# 輸出'Hello, world' print('Hello, %s' % 'world') # 輸出'Hi, Michael, you have $1000000.' print('Hi, %s, you have $%d.' % ('Michael', 1000000))

5. 數(shù)據(jù)結(jié)構(gòu)

5.1 鏈表 list

Python內(nèi)置的一種數(shù)據(jù)類(lèi)型是list，可以隨時(shí)添加和刪除其中的元素，將其理解為鏈表即可，同時(shí)Python中的list更加強(qiáng)大，內(nèi)部可以存放不同類(lèi)型的元素

# 創(chuàng)建一個(gè)list classmates=['tom','jack','mike'] # 用下標(biāo)進(jìn)行訪問(wèn)，輸出tom print(classmates[0]) # 負(fù)的下標(biāo)代表倒數(shù)第幾個(gè)，此處輸出mike print(classmates[-1]) p = ['asp', 'php'] # 此時(shí)s[2][1]等價(jià)于p[1] s = ['python', 'java', p, 'scheme']

list方法

# append方法將元素追加至末尾 append('martin') # insert方法將元素插入指定索引位置 insert(0,'linda') # pop()方法刪除末尾元素，也可刪除指定索引元素 pop() # 移除符合要求的第一個(gè)值 remove('xxx') # 連接兩個(gè)列表，這是比+運(yùn)算符連接效率更高的方法 extend(list) # 統(tǒng)計(jì)num在list中出現(xiàn)的次數(shù) count(num) # 某個(gè)元素在不在列表中，返回布爾型 element in/not in listname list(reversed(range(5))) # 生成一個(gè)倒序列表[4,3,2,1,0] # 二分搜索以及已排序列表的插值【bisect本身不檢查列表是否有序】 import bisect c=[1,2,2,2,3,4,7] # 返回元素2在c中應(yīng)當(dāng)插入的位置 bisect.bisect(c,2) # 把元素2插入應(yīng)當(dāng)插入的位置 bisect.insort(c,2)

5.2 靜態(tài)鏈表 tuple

tuple一旦初始化就不能修改【所謂“不變”是說(shuō)每個(gè)元素指向永遠(yuǎn)不變】，這是其與list的唯一區(qū)別

# 當(dāng)你定義一個(gè)tuple時(shí)，在定義的時(shí)候，tuple的元素就必須被確定下來(lái) t = (1, 2) # 定義一個(gè)空的tuple t = () # 只有1個(gè)元素的tuple定義時(shí)必須加一個(gè)逗號(hào)，否則會(huì)與數(shù)學(xué)中的小括號(hào)歧義 t = (1,) # tuple和list還具有拆包特性 seq=(1,2,3,4) # 將1賦值給a，將2賦值給b，剩余部分成為列表放入rest a,b,*rest=seq

5.3 字典 dict (map)

# 定義key-value d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} # 取出鍵值對(duì)應(yīng)的值 d['Michael'] # 放入鍵值對(duì) d['Adam'] = 67

dict方法

# 當(dāng)鍵值不存在于字典中時(shí)會(huì)報(bào)錯(cuò)，因此取值前最好進(jìn)行判斷 # 若此時(shí)不存在這樣的鍵值則返回False 'Thomas' in d # 若當(dāng)前鍵值對(duì)不存在則返回None d.get('Thomas') # 當(dāng)鍵值對(duì)不存在時(shí)返回-1 d.get('Thomas', -1) # 刪除鍵值對(duì) d.pop('Bob')

5.4 集合 set

set的原理與dict一致，不過(guò)其只存儲(chǔ)key值

# 得到一個(gè)空集合 s=set() # set的賦值初始化需要list作為輸入集合 s=set([1, 2, 3])

set方法

# add方法往集合添加元素 s.add(4) # remove方法移除集合中的元素 s.remove(4) # 得到交集 s1 & s2 # 得到并集 s1 | s2

6. 基礎(chǔ)用法

6.1 條件判斷

Python的條件判斷是不需要小括號(hào)括起來(lái)的，同時(shí)由于其依靠相同縮進(jìn)代表同一代碼塊，因此也無(wú)需中括號(hào)

age = 3 #只要age是非零數(shù)值、非空字符串、非空l(shuí)ist等，就判斷為T(mén)rue，否則為False if age >= 18: #不要少寫(xiě)冒號(hào)print('adult') elif age >= 6: #else if在此處縮寫(xiě)為elifprint('teenager') else:print('kid')

6.2 循環(huán)

# 定義一個(gè)list nums=[1,2,3] # for的用法，不要忘了冒號(hào):，while循環(huán)同樣需要冒號(hào) for x in nums: # x是nums中的元素print(x)# Python內(nèi)置的enumerate函數(shù)可以把一個(gè)list變成[索引-元素]對(duì)，這樣就可以在for循環(huán)中同時(shí)迭代索引和元素本身 for i, value in enumerate(['A', 'B', 'C']):# i即此元素在list中的下標(biāo)print(i, value) # 也可以同時(shí)引用多個(gè)變量，此時(shí)就像是有多個(gè)索引進(jìn)行遍歷 for x, y in [(1, 1), (2, 4), (3, 9)]:print(x, y)

6.3 賦值

# 后邊的部分先得到，接著按順序賦值 a, b = b, a + b # 上述賦值語(yǔ)句等價(jià)于👇 # t是一個(gè)tuple t = (b, a + b) a = t[0] b = t[1]

6.4 與and或or非not

and和or返回第一個(gè)能讓其確定結(jié)果為T(mén)rue或者False的值

# 輸出None，因?yàn)镹one視為False，此時(shí)已經(jīng)可以指定整體輸出為False print(None and 'a') # 輸出None，因?yàn)閍不為None視為T(mén)rue，此時(shí)結(jié)果看后半部分，即None print('a' and None) # 輸出b，理由同上 print('a' and 'b') # 空字符串也被視為False # 輸出a，因?yàn)閍不為None視為False，此時(shí)整體已可以得知為False print('a' or 'b')

6.5 函數(shù)

在Python中，定義一個(gè)函數(shù)要使用關(guān)鍵詞def，函數(shù)名，括號(hào)，括號(hào)中的參數(shù)以及冒號(hào)

在縮進(jìn)塊中編寫(xiě)函數(shù)體，函數(shù)的返回值用return語(yǔ)句返回，如果沒(méi)有return語(yǔ)句，函數(shù)執(zhí)行完畢后也會(huì)返回結(jié)果，只是結(jié)果為None，return None可以簡(jiǎn)寫(xiě)為return

num=0 def my_abs(x):# num是全局變量，想在函數(shù)中使用需要用global關(guān)鍵字標(biāo)記global num if x >= 0:return xelse:return num

6.5.1 空函數(shù)

如果想定義一個(gè)什么事也不做的空函數(shù)，可以用pass語(yǔ)句：

def nop():pass

pass語(yǔ)句什么都不做，那有什么用？實(shí)際上pass可以用來(lái)作為占位符，比如現(xiàn)在還沒(méi)想好怎么寫(xiě)函數(shù)的代碼，就可以先放一個(gè)pass，讓代碼能運(yùn)行起來(lái)。pass還可以用在其他語(yǔ)句里，如下：

if age >= 18:# 此處若缺少了pass，代碼運(yùn)行就會(huì)有語(yǔ)法錯(cuò)誤pass

6.5.2 返回值

Python可以允許返回多個(gè)值，其原理是返回一個(gè)tuple，多個(gè)變量可以同時(shí)接收一個(gè)tuple，按位置賦給對(duì)應(yīng)的值

def move(x, y):nx = x ny = y # 返回多個(gè)值return nx, ny # x,y依次接受move函數(shù)返回的nx,ny x, y = move(100, 100)

6.5.3 默認(rèn)參數(shù)

當(dāng)函數(shù)有多個(gè)參數(shù)時(shí)可以指定默認(rèn)參數(shù)，不過(guò)需要保證必選參數(shù)在前，默認(rèn)參數(shù)在后

# 使用時(shí)當(dāng)n處不填參數(shù)也不會(huì)報(bào)錯(cuò)，n默認(rèn)為2 def power(x, n=2): s = 1while n > 0:n = n - 1s = s * xreturn s

有多個(gè)默認(rèn)參數(shù)時(shí)，調(diào)用的時(shí)候，既可以按順序提供默認(rèn)參數(shù)，也可以不按順序提供部分默認(rèn)參數(shù)。

當(dāng)不按順序提供部分默認(rèn)參數(shù)時(shí)，需要把參數(shù)名寫(xiě)上。比如調(diào)用enroll('Adam', 'M', city='Tianjin')，意思是，city參數(shù)用傳進(jìn)去的值，其他默認(rèn)參數(shù)繼續(xù)使用默認(rèn)值

不過(guò)使用時(shí)需要注意一個(gè)陷阱：默認(rèn)參數(shù)必須指向不變對(duì)象！

# Python函數(shù)在定義的時(shí)候，默認(rèn)參數(shù)L的值就被計(jì)算出來(lái)了 # 由于L的默認(rèn)參數(shù)指向的是地址，因此下次使用時(shí)會(huì)保留上次添加的數(shù)據(jù) def add_end(L=[]):L.append('END')return L# 修改如下 # 由于None是一個(gè)不變對(duì)象，因此保證每次L指向的內(nèi)容不發(fā)生改變 def add_end(L=None):if L is None:L = []L.append('END')return L

6.5.4 可變參數(shù)

可變參數(shù)就是傳入的參數(shù)個(gè)數(shù)是可變的，可以是1個(gè)、2個(gè)到任意個(gè)，還可以是0個(gè)

定義可變參數(shù)和定義一個(gè)list或tuple參數(shù)相比，僅僅在參數(shù)前面加了一個(gè)*號(hào)。在函數(shù)內(nèi)部，參數(shù)numbers接收到的是一個(gè)tuple，因此，函數(shù)代碼完全不變。但是，調(diào)用該函數(shù)時(shí)，可以傳入任意個(gè)參數(shù)，包括0個(gè)參數(shù)

def calc(*numbers):sum=0# 將傳入的參數(shù)全部進(jìn)行相加for n in numbers:sum+=nreturn sum # 得到2，3，4之和 result = calc(2,3,4)# 也可以在list或tuple前面加一個(gè)*號(hào)，把list或tuple的元素變成可變參數(shù)傳進(jìn)去 nums = [1,2,3] calc(*nums)

6.5.5 關(guān)鍵字參數(shù)

關(guān)鍵字參數(shù)允許傳入0個(gè)或任意個(gè)含參數(shù)名的參數(shù)，這些關(guān)鍵字參數(shù)在函數(shù)內(nèi)部自動(dòng)組裝為一個(gè)dict

def person(name, age, **kw):print('name:', name, 'age:', age, 'other:', kw) # kw接收鍵值對(duì) person('Adam', 45, gender='M', job='Engineer') # 也可以直接傳入定義好的dict extra = {'city': 'Beijing', 'job': 'Engineer'} person('Jack', 24, **extra)

kw獲得的dict是extra的一份拷貝，對(duì)kw的改動(dòng)不會(huì)影響到函數(shù)外的extra

命名關(guān)鍵字參數(shù)

當(dāng)使用了關(guān)鍵字參數(shù)時(shí)，正常情況下會(huì)將所有輸入的鍵值對(duì)都進(jìn)行接收，若我們只想接收指定關(guān)鍵值則需要用到命名關(guān)鍵字參數(shù)

# 命名關(guān)鍵字參數(shù)需要一個(gè)特殊分隔符*, *后面的參數(shù)被視為命名關(guān)鍵字參數(shù) # 只接受city和job的關(guān)鍵字 def person(name, age, *, city, job): print(name, age, city,job) # 調(diào)用函數(shù)，其中key = value必須寫(xiě)全，不能單寫(xiě)一個(gè)value # 命名關(guān)鍵字參數(shù)可以有缺省值【即默認(rèn)參數(shù)】，從而簡(jiǎn)化調(diào)用 person('Jack',24, city='Beijing', job='Engineer') # 如果函數(shù)定義中已經(jīng)有了一個(gè)可變參數(shù)，后面跟著的命名關(guān)鍵字參數(shù)就不再需要一個(gè)特殊分隔符*了 # *args說(shuō)明是可變參數(shù) def person(name, age, *args, city, job): print(name, age, args, city, job)

6.5.6 參數(shù)組合

Python中參數(shù)定義的順序必須是：必選參數(shù)、默認(rèn)參數(shù)、可變參數(shù)、命名關(guān)鍵字參數(shù)，關(guān)鍵字參數(shù)

# a和b對(duì)應(yīng)必選參數(shù)，c為默認(rèn)參數(shù)，*開(kāi)始的位置表示命名關(guān)鍵字【只接收d和kw關(guān)鍵值】 def f2(a, b, c=0, *, d, **kw):print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw) # 除了挨個(gè)傳參外，也可以通過(guò)一個(gè)tuple和dict也調(diào)用上述函數(shù)，不過(guò)需要保證tuple內(nèi)容可以與參數(shù)對(duì)上 args = (1, 2, 3) # kw中d的鍵值對(duì)會(huì)對(duì)應(yīng)給d的參數(shù)，剩下的內(nèi)容才會(huì)歸入?yún)?shù)中的kw kw = {'d': 88, 'x': '#'} f2(*args, **kw)

雖然可以組合多達(dá)5種參數(shù)，但不要同時(shí)使用太多的組合，否則函數(shù)接口的可理解性很差

7. 基礎(chǔ)內(nèi)置函數(shù)

即Python已經(jīng)封裝好，我們可以直接拿來(lái)用的函數(shù)

7.1 數(shù)學(xué)

# 得到絕對(duì)值 abs(-100) # 得到最大值，參數(shù)可多個(gè) max(2, 3, 1, -5) # 開(kāi)平方 math.sqrt() # 對(duì)num進(jìn)行四舍五入，保留2位小數(shù) round(num,2)

7.2 類(lèi)型轉(zhuǎn)換

# 轉(zhuǎn)為整型 int('123') # 轉(zhuǎn)為浮點(diǎn)型，Python沒(méi)有double float('12.34') # 轉(zhuǎn)為字符串 str(1.23) # 轉(zhuǎn)為布爾型，非空即為T(mén)rue bool(1)

7.3 數(shù)據(jù)類(lèi)型檢查isinstance

# 數(shù)據(jù)類(lèi)型檢查可以用內(nèi)置函數(shù)isinstance()實(shí)現(xiàn) # 若x屬于int型或float型時(shí)返回True isinstance(x, (int, float))

7.4 長(zhǎng)度len

# len()函數(shù)計(jì)算的是str的字符數(shù)【中文同適用】，如果換成bytes，len()函數(shù)就計(jì)算字節(jié)數(shù) # 輸出2，因?yàn)橛袃蓚€(gè)字符 print(len('中文')) # 輸出3，UTF-8編碼一個(gè)中文字符通常占3個(gè)字節(jié)，所以輸出6 print(len('你好'.encode('utf-8'))) 方法說(shuō)明

range(a,b)	生成[a,b)的整數(shù)列表

8. 高級(jí)特性

8.1 切片

Python提供一系列取指定索引范圍的操作，形象地稱(chēng)為切片Slice，list，tuple，字符串都可進(jìn)行切片操作

a[x:y:z]：x表示切片起點(diǎn)，y表示切片終點(diǎn)【不包括】，z表示步長(zhǎng)。如果不指定x和y，則默認(rèn)開(kāi)始和最后；如果不指定z，則默認(rèn)步長(zhǎng)為1。當(dāng)**z為-1時(shí)代表倒序且步長(zhǎng)為1**，此時(shí)x與y對(duì)應(yīng)的是倒序后的下標(biāo)

L=['tom','jack','jery'] # L[0:2]表示，從索引0開(kāi)始取，直到索引1為止 L[0:2] # 如果第一個(gè)索引是0，還可以省略，寫(xiě)成L[:2] # L[-2:-1]取倒數(shù)第二個(gè)，但不包括倒數(shù)第一個(gè) # L[-2:]從倒數(shù)第二個(gè)開(kāi)始往后取至末尾n='1234' # -1代表逆序，此時(shí)起點(diǎn)是最后一個(gè)元素，由后往前取，輸出[4,3,2,1] n[::-1] # 從下標(biāo)2開(kāi)始往前取，所以是[3, 2, 1] n[2::-1] # 從最后一個(gè)元素處取到下標(biāo)2【不包括】，所以是[4] n[:2:-1]

8.2 迭代

如果給定一個(gè)list或tuple，我們可以通過(guò)for循環(huán)來(lái)遍歷這個(gè)list或tuple，這種遍歷我們稱(chēng)為迭代Iteration

在Python中，迭代是通過(guò)for ... in來(lái)完成的，默認(rèn)情況下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同時(shí)迭代key和value，可以用for k, v in d.items()

8.3 列表生成式

創(chuàng)建列表的時(shí)可以直接在列表內(nèi)寫(xiě)表達(dá)式，符合表達(dá)式的部分成為列表元素

# 如下，生成[4, 16, 36, 64, 100] L = [] for x in range(1, 11):if x % 2 == 0:L.append(x*x)# 也可以在表達(dá)式中直接這樣寫(xiě)👇 # 寫(xiě)列表生成式時(shí)，把要生成的元素x * x放到前面，后面跟for循環(huán)，就可以把list創(chuàng)建出來(lái) # 此時(shí)if后不能用else L=[x * x for x in range(1, 11) if x % 2 == 0] # 當(dāng)if語(yǔ)句放在for前時(shí)必須使用else，因?yàn)榇藭r(shí)if..else是表達(dá)式而不是過(guò)濾條件 L=[x if x % 2 == 0 else -x for x in range(1, 11)] # 此時(shí)L=[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]

8.4 生成器

Python一邊循環(huán)一邊計(jì)算的機(jī)制，稱(chēng)為生成器：generator。當(dāng)我們僅僅需要使用列表生成式中的少量元素時(shí)，使用generator可以節(jié)省根據(jù)需要?jiǎng)?chuàng)建我們需要的元素，從而節(jié)約空間

8.4.1 創(chuàng)建generator方法 1

把一個(gè)列表生成式的[]改成()，就創(chuàng)建了一個(gè)generator

# 這里通過(guò)列表生成式得到list l = [x * x for x in range(10)] # 這里得到generator g = (x * x for x in range(10)) # g內(nèi)元素如果要一個(gè)一個(gè)打印出來(lái)，可以通過(guò)next()函數(shù)獲得generator的下一個(gè)返回值 # 直到計(jì)算到最后一個(gè)元素，沒(méi)有更多的元素時(shí)，拋出StopIteration的錯(cuò)誤 # 不過(guò)此方法一般不用，因?yàn)橥ㄟ^(guò)循環(huán)同樣可以對(duì)g進(jìn)行遍歷且不用擔(dān)心異常 next(g)

8.4.2 創(chuàng)建generator方法 2

如果一個(gè)函數(shù)定義中包含yield關(guān)鍵字，那么這個(gè)函數(shù)就不再是一個(gè)普通函數(shù)，而是一個(gè)generator函數(shù)，調(diào)用一個(gè)generator函數(shù)將返回一個(gè)generator

generator的函數(shù)會(huì)在每次調(diào)用next()的時(shí)候執(zhí)行，遇到y(tǒng)ield語(yǔ)句返回，再次執(zhí)行時(shí)從上次返回的yield語(yǔ)句處繼續(xù)執(zhí)行

調(diào)用generator函數(shù)會(huì)創(chuàng)建一個(gè)generator對(duì)象，多次調(diào)用generator函數(shù)會(huì)創(chuàng)建多個(gè)相互獨(dú)立的generator

def odd():print('hh')# yield是generator函數(shù)的標(biāo)志yield 1 print('jj')yield(2)print('kk')yield(3)# 調(diào)用該generator函數(shù)時(shí)，首先要生成一個(gè)generator對(duì)象，然后用next()函數(shù)不斷獲得下一個(gè)返回值 # 得到一個(gè)generator對(duì)象 o = odd() # 輸出hh，返回1 next(o) # 輸出jj，返回2 next(o) # 輸出kk，返回3 next(o) # 此時(shí)函數(shù)已經(jīng)執(zhí)行完畢，報(bào)錯(cuò)StopIteration next(o)

實(shí)際上，遍歷generator很少使用next方法，通常能用for解決就用for

# 斐波那契數(shù)列 def fib(max):n, a, b = 0, 0, 1while n < max:yield ba, b = b, a + bn = n + 1return 'done'for n in fib(6):# 輸出1,1,2,3,5,8print(n) # 但是此方法只能拿到y(tǒng)ield返回值，無(wú)法拿到return返回值 g = fib(6)# 若需要拿到return返回值則需要進(jìn)行如下操作 while True:try:x = next(g)print('g:', x)# 發(fā)生異常后才會(huì)執(zhí)行此代碼塊except StopIteration as e: # e.value即return返回值print('Generator return value:', e.value) break

8.5 迭代器

我們已經(jīng)知道，可以直接作用于for循環(huán)的數(shù)據(jù)類(lèi)型有以下幾種：

• 一類(lèi)是集合數(shù)據(jù)類(lèi)型，如list、tuple、dict、set、str等；
• 一類(lèi)是generator，包括生成器和帶yield的generator function

這些可以直接作用于for循環(huán)的對(duì)象統(tǒng)稱(chēng)為可迭代對(duì)象：Iterable，可以使用isinstance()判斷一個(gè)對(duì)象是否是Iterable對(duì)象

可以被next()函數(shù)調(diào)用并不斷返回下一個(gè)值的對(duì)象稱(chēng)為迭代器：Iterator

生成器都是Iterator對(duì)象，但list、dict、str雖然是Iterable，卻不是Iterator

# 通過(guò)iter()函數(shù)可以把Iterable變成Iterator # 將list轉(zhuǎn)變?yōu)镮terator對(duì)象后進(jìn)行判斷，返回True isinstance(iter([]), Iterator)

為什么list、dict、str等數(shù)據(jù)類(lèi)型不是Iterator？

因?yàn)镻ython的Iterator對(duì)象表示的是一個(gè)數(shù)據(jù)流，Iterator對(duì)象可以被next()函數(shù)調(diào)用并不斷返回下一個(gè)數(shù)據(jù)，直到?jīng)]有數(shù)據(jù)時(shí)拋出StopIteration錯(cuò)誤?？梢园堰@個(gè)數(shù)據(jù)流看做是一個(gè)有序序列，但我們卻不能提前知道序列的長(zhǎng)度，只能不斷通過(guò)next()函數(shù)實(shí)現(xiàn)按需計(jì)算下一個(gè)數(shù)據(jù)，所以Iterator的計(jì)算是惰性的，只有在需要返回下一個(gè)數(shù)據(jù)時(shí)它才會(huì)計(jì)算。Iterator甚至可以表示一個(gè)無(wú)限大的數(shù)據(jù)流，例如全體自然數(shù)。而使用list是永遠(yuǎn)不可能存儲(chǔ)全體自然數(shù)的

• 凡是可作用于for循環(huán)的對(duì)象都是Iterable類(lèi)型
• 凡是可作用于next()函數(shù)的對(duì)象都是Iterator類(lèi)型，它們表示一個(gè)惰性計(jì)算的序列

9. 函數(shù)式編程

函數(shù)式編程是一種抽象程度很高的編程范式，純粹的函數(shù)式編程語(yǔ)言編寫(xiě)的函數(shù)沒(méi)有變量，因此，任意一個(gè)函數(shù)，只要輸入是確定的，輸出就是確定的，這種純函數(shù)我們稱(chēng)之為沒(méi)有副作用。

而允許使用變量的程序設(shè)計(jì)語(yǔ)言，由于函數(shù)內(nèi)部的變量狀態(tài)不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數(shù)是有副作用的。

函數(shù)式編程的一個(gè)特點(diǎn)是：允許把函數(shù)本身作為參數(shù)傳入另一個(gè)函數(shù)，還允許返回一個(gè)函數(shù)！

9.1 高階函數(shù)

變量可以指向函數(shù)，函數(shù)的參數(shù)能接收變量，一個(gè)函數(shù)就可以接收另一個(gè)函數(shù)作為參數(shù)，這種函數(shù)就稱(chēng)之為高階函數(shù)

函數(shù)名其實(shí)就是指向一個(gè)函數(shù)對(duì)象的引用，完全可以把函數(shù)名賦給一個(gè)變量，相當(dāng)于給這個(gè)函數(shù)起了一個(gè)“別名”

# 變量a指向abs函數(shù) a = abs # 所以也可以通過(guò)a調(diào)用abs函數(shù) a(-1) # 將1賦給abs，此時(shí)abs不再指向絕對(duì)值函數(shù)，而指向數(shù)字1 abs=1; # 一個(gè)簡(jiǎn)單例子 # f作為參數(shù)接受的是函數(shù) def add(x,y,f): return f(x) + f(y) # 輸出11 print(add(5,6,abs))

9.1.1 map

map()函數(shù)接收兩個(gè)參數(shù)，一個(gè)是函數(shù)，一個(gè)是Iterable，map將傳入的函數(shù)依次作用到序列的每個(gè)元素，并把結(jié)果作為新的Iterator返回

def f(x):return x * x # list中的元素依次執(zhí)行f(x) r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) # 用list裝Iterator r=list(r) # 輸出[1, 4, 9, 16, 25, 36, 49, 64, 81] print(r) # 將list中的元素都變成字符串 l=list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

9.1.2 reduce

reduce把一個(gè)函數(shù)作用在一個(gè)序列[x1, x2, x3, ...]上，這個(gè)函數(shù)必須接收兩個(gè)參數(shù)，reduce把結(jié)果繼續(xù)和序列的下一個(gè)元素做累積計(jì)算

# 👇等價(jià)于 f(f(f(x1, x2), x3), x4) reduce(f, [x1, x2, x3, x4]) # 如下簡(jiǎn)單例子，對(duì)序列求和 def add(x, y):return x + y # 先 f(1,3)，再將結(jié)果放入問(wèn)號(hào) f(?,5)... reduce(add, [1, 3, 5, 7, 9]) def fn(x, y):return x * 10 + ydef char2num(s):digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}return digits[s]# reduce與map結(jié)合使用，實(shí)現(xiàn)把字符串轉(zhuǎn)整型 reduce(fn, map(char2num, '13579'))

9.1.3 filter

與map()類(lèi)似，filter()也接收一個(gè)函數(shù)和一個(gè)序列，不過(guò)和map()不同的是，filter()把傳入的函數(shù)依次作用于每個(gè)元素，然后根據(jù)返回值是True還是False決定保留還是丟棄該元素

# 一個(gè)簡(jiǎn)單例子 def is_odd(n):# 結(jié)果為T(mén)rue的元素保留return n % 2 == 1 # 保留下奇數(shù) # 結(jié)果: [1, 5, 9, 15] l=list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) def not_empty(s):# 如果s不是None或空串說(shuō)明為T(mén)rue，此時(shí)返回去除多余空格的字符串# 如果s是None或空串說(shuō)明為False，此時(shí)配合filter對(duì)這部分?jǐn)?shù)據(jù)不保留return s and s.strip() # filter返回的是一個(gè)Iterator l = list(filter(not_empty, ['A', '', 'B', None, 'C', ' '])) # 結(jié)果: ['A', 'B', 'C']

9.1.4 sorted/sort

sorted()函數(shù)也是一個(gè)高階函數(shù)，它可以接收一個(gè)key函數(shù)來(lái)實(shí)現(xiàn)自定義的排序

# 默認(rèn)從小到大排序 sorted([36, 5, -12, 9, -21]) # 加上參數(shù)就是從大到小排序 sorted([36, 5, -12, 9, -21], reverse=True) # key指定的函數(shù)將作用于list的每一個(gè)元素上，并根據(jù)key函數(shù)返回的結(jié)果進(jìn)行排序，不過(guò)只能是內(nèi)置函數(shù) # 根據(jù)絕對(duì)值大小從小到大排序 sorted([36, 5, -12, 9, -21], key=abs) # 如果需要進(jìn)行自定義函數(shù)排序則需要使用容器內(nèi)部的sort方法進(jìn)行操作

9.2 返回函數(shù)

高階函數(shù)除了可以接受函數(shù)作為參數(shù)外，還可以把函數(shù)作為結(jié)果值返回

def lazy_sum(*args):def sum():ax = 0for n in args:ax = ax + nreturn ax# 返回值是sum()這個(gè)函數(shù)return sum # 多次調(diào)用lazy_sum時(shí)返回的函數(shù)是獨(dú)立的 # 此時(shí)得到的是sum()這個(gè)函數(shù)，并未進(jìn)行求和 f = lazy_sum(1, 3, 5, 7, 9) # 調(diào)用f()函數(shù)時(shí)才開(kāi)始執(zhí)行 num=f()

閉包

閉包Closure是一種程序結(jié)構(gòu)，指內(nèi)部函數(shù)sum可以引用外部函數(shù)lazy_sum的參數(shù)和局部變量，當(dāng)lazy_sum返回函數(shù)sum時(shí)，相關(guān)參數(shù)和變量都保存在返回的函數(shù)中

def count():fs = []for i in range(1, 4):def f():return i*ifs.append(f)return fs# 此時(shí)f()并沒(méi)有真正執(zhí)行，但是當(dāng)count()執(zhí)行完畢并返回fs后，i已經(jīng)變成了3 f1, f2, f3 = count() # 調(diào)用f1()等函數(shù)時(shí)f()才真正執(zhí)行，此時(shí)返回 3 * 3 = 9 # 輸出9，9，9 print(f1(),f2(),f3())

返回閉包時(shí)牢記一點(diǎn)：返回函數(shù)不要引用任何循環(huán)變量，或者后續(xù)會(huì)發(fā)生變化的變量【如上👆】

如果一定要引用循環(huán)變量怎么辦？

可以再創(chuàng)建一個(gè)函數(shù)，用該函數(shù)的參數(shù)綁定循環(huán)變量當(dāng)前的值，無(wú)論該循環(huán)變量后續(xù)如何更改，已綁定到函數(shù)參數(shù)的值不變，缺點(diǎn)是代碼較長(zhǎng)，可利用lambda函數(shù)縮短代碼【9.3學(xué)】

def count():def f(j):def g():return j*jreturn gfs = []for i in range(1, 4):# f(i)立刻被執(zhí)行，因此i的當(dāng)前值被傳入f()fs.append(f(i)) return fsf1, f2, f3 = count() # 此時(shí)輸出1，4，9 print(f1(),f2(),f3())

nonlocal

使用閉包，就是內(nèi)層函數(shù)引用了外層函數(shù)的局部變量，如果內(nèi)層函數(shù)直接對(duì)外層變量賦值，由于Python解釋器會(huì)把x當(dāng)作函數(shù)fn()的局部變量，它會(huì)報(bào)錯(cuò)。原因是x作為局部變量并沒(méi)有初始化，直接計(jì)算x+1是不行的，但我們其實(shí)是想引用inc()函數(shù)內(nèi)部的x，所以需要在fn()函數(shù)內(nèi)部加一個(gè)nonlocal x的聲明

def inc():x = 0def fn(): # nonlocal x # 加此聲明# 此時(shí)解釋器會(huì)把x當(dāng)作是外層變量x = x + 1 return xreturn fnf = inc() # 輸出1 print(f()) # 輸出2 print(f())

9.3 匿名函數(shù)

當(dāng)我們?cè)趥魅牒瘮?shù)時(shí)，有些時(shí)候，不需要顯式地定義函數(shù)，直接傳入匿名函數(shù)更方便

關(guān)鍵字lambda表示匿名函數(shù)，冒號(hào):前面的x表示函數(shù)參數(shù)。此外，匿名函數(shù)也是一個(gè)函數(shù)對(duì)象，也可以把匿名函數(shù)賦值給一個(gè)變量，再利用變量來(lái)調(diào)用該函數(shù)

# 傳入?yún)?shù)為x，返回值為x*x f = lambda x: x * x # 輸出 25 print(f(5))

9.4 裝飾器

在代碼運(yùn)行期間動(dòng)態(tài)增加功能的方式，稱(chēng)之為“裝飾器”Decorator，本質(zhì)上，decorator就是一個(gè)返回函數(shù)的高階函數(shù)

def log(func):# 可以接受任何參數(shù)def wrapper(*args, **kw): # 每個(gè)函數(shù)都有__name__屬性，其封裝了函數(shù)名print('call %s():' % func.__name__) return func(*args, **kw)return wrapper# 因?yàn)閘og是一個(gè)decorator，所以接受一個(gè)函數(shù)作為參數(shù)，并返回一個(gè)函數(shù)。我們要借助Python的@語(yǔ)法，把decorator置于函數(shù)的定義處 @log def now():print('2015-3-25') # 此時(shí)調(diào)用now()的輸出如下： call now(): 2015-3-25# 把@log放到now()函數(shù)的定義處，相當(dāng)于執(zhí)行了語(yǔ)句👇 # 相當(dāng)于wrapper函數(shù)賦給now()，所以再次執(zhí)行now()實(shí)際是wrapper，而原本的now早已通過(guò)參數(shù)func被wrapper獲得，因此后續(xù)執(zhí)行仍能定位到原now now = log(now) # 不過(guò)由于當(dāng)前now已經(jīng)被賦為wrapper了，因此通過(guò)now._name_屬性我們只能得到wrapper # 因此我們工作仍未完成，需要把原始函數(shù)的__name__等屬性復(fù)制到wrapper()函數(shù)中，否則，有些依賴(lài)函數(shù)簽名的代碼執(zhí)行會(huì)出錯(cuò) # 不需要編寫(xiě)wrapper.__name__ = func.__name__這樣的代碼，Python內(nèi)置的functools.wraps就是干這個(gè)事的，所以，一個(gè)完整的decorator的寫(xiě)法如下 # 導(dǎo)入functools模塊 import functools def log(func):@functools.wraps(func)def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper # 如果decorator本身需要傳入?yún)?shù)，那就需要編寫(xiě)一個(gè)返回decorator的高階函數(shù)，寫(xiě)出來(lái)會(huì)更復(fù)雜 def log(text):def decorator(func):def wrapper(*args, **kw):print('%s %s():' % (text, func.__name__))return func(*args, **kw)return wrapperreturn decorator@log('execute') def now():print('2015-3-25') # 此時(shí)調(diào)用now()的輸出如下： execute now(): 2015-3-25 # 把@log放到now()函數(shù)的定義處，相當(dāng)于執(zhí)行了語(yǔ)句👇 # 前半部分返回decorator函數(shù)，接著傳參now，后續(xù)執(zhí)行如上 now = log('execute')(now)

9.5 偏函數(shù)

通過(guò)設(shè)定參數(shù)的默認(rèn)值，可以降低函數(shù)調(diào)用的難度，偏函數(shù)也可以做到這一點(diǎn)

# int()默認(rèn)將字符串當(dāng)成十進(jìn)制進(jìn)行解析，我們通過(guò)設(shè)置參數(shù)默認(rèn)值使得int2()將字符串當(dāng)成二進(jìn)制進(jìn)行解析 def int2(x, base=2):return int(x, base)# functools.partial就是幫助我們創(chuàng)建一個(gè)偏函數(shù)的，不需要我們自己定義int2()，可以直接使用下面的代碼創(chuàng)建一個(gè)新的函數(shù)int2 import functools int2 = functools.partial(int, base=2) # 輸出64 print(int2('1000000')) # 新的int2函數(shù)，僅僅是把base參數(shù)重新設(shè)定默認(rèn)值為2，但也可以在函數(shù)調(diào)用時(shí)傳入其他值 # 輸出1000000 print(int2('1000000',base=10)) # 創(chuàng)建偏函數(shù)時(shí)，實(shí)際上可以接收函數(shù)對(duì)象、*args和**kw這3個(gè)參數(shù) # 上邊創(chuàng)建的int2()，等價(jià)于👇 kw = { 'base': 2 } int('10010', **kw)# 當(dāng)傳入*arg的參數(shù)時(shí)，實(shí)際上會(huì)被安排到最左邊 max2 = functools.partial(max, 10) max2(5, 6, 7) # 等價(jià)于👇 args = (10, 5, 6, 7) max(*args)

10. 模塊

為了編寫(xiě)可維護(hù)的代碼，我們把很多函數(shù)分組，分別放到不同的文件里，這樣，每個(gè)文件包含的代碼就相對(duì)較少，很多編程語(yǔ)言都采用這種組織代碼的方式。在Python中，一個(gè).py文件就稱(chēng)之為一個(gè)模塊Module

同時(shí)，為了避免模塊名沖突，Python又引入了按目錄來(lái)組織模塊的方法，稱(chēng)為包Package。注意：每一個(gè)包目錄下面都會(huì)有一個(gè)__init__.py的文件，這個(gè)文件是必須存在的，否則，Python就把這個(gè)目錄當(dāng)成普通目錄，而不是一個(gè)包。__init__.py可以是空文件，也可以有Python代碼，因?yàn)開(kāi)_init__.py本身就是一個(gè)模塊

# 此注釋👇允許此.py文件直接在Unix/Linux/Mac上運(yùn)行 #!/usr/bin/env python3 # 此注釋👇表示.py文件本身使用標(biāo)準(zhǔn)UTF-8編碼 # -*- coding: utf-8 -*- # 表示模塊的文檔注釋，任何模塊代碼的第一個(gè)字符串都被視為模塊的文檔注釋 ' a test module ' # 使用__author__變量把作者寫(xiě)進(jìn)去 __author__ = 'Michael Liao' # 上面部分👆是Python模塊的標(biāo)準(zhǔn)文件模板 # 導(dǎo)入sys模塊 import sys def test(): # sys模塊有一個(gè)argv變量，用list存儲(chǔ)了命令行的所有參數(shù)。argv至少有一個(gè)元素，因?yàn)榈谝粋€(gè)參數(shù)永遠(yuǎn)是該.py文件的名稱(chēng)args = sys.argvif len(args)==1:print('Hello, world!')elif len(args)==2:print('Hello, %s!' % args[1])else:print('Too many arguments!') # 當(dāng)我們直接運(yùn)行該模塊文件時(shí)，Python解釋器把一個(gè)特殊變量__name__置為_(kāi)_main__，而如果在其他地方導(dǎo)入該模塊時(shí)，if判斷將失敗 if __name__=='__main__':test()

作用域

正常的函數(shù)和變量名是公開(kāi)的public，在Python中，是通過(guò)_前綴來(lái)實(shí)現(xiàn)私有private

之所以我們說(shuō)，private函數(shù)和變量“不應(yīng)該”被直接引用，而不是“不能”被直接引用，是因?yàn)镻ython并沒(méi)有一種方法可以完全限制訪問(wèn)private函數(shù)或變量，但是，從編程習(xí)慣上不應(yīng)該引用private函數(shù)或變量

類(lèi)似__xxx__這樣的變量是特殊變量，可以被直接引用，但是有特殊用途，比如的__author__，__name__就是特殊變量，我們自己的變量一般不要用這種變量名

外部不需要引用的函數(shù)全部定義成private，只有外部需要引用的函數(shù)才定義為public

11. 面對(duì)對(duì)象編程

在Python中，所有數(shù)據(jù)類(lèi)型都可以視為對(duì)象，當(dāng)然也可以自定義對(duì)象。自定義的對(duì)象數(shù)據(jù)類(lèi)型就是面向?qū)ο笾械念?lèi)Class的概念

11.1 類(lèi)和實(shí)例

# 定義一個(gè)類(lèi)，object代表Student是從object繼承下來(lái)的 class Student(object): pass# 創(chuàng)建Student實(shí)例 bart = Student() # 可以自由地給一個(gè)實(shí)例變量綁定屬性，比如，給實(shí)例bart綁定一個(gè)name屬性 bart.name = 'Bart Simpson'# 由于類(lèi)可以起到模板的作用，因此，可以在創(chuàng)建實(shí)例的時(shí)候，把一些我們認(rèn)為必須綁定的屬性強(qiáng)制填寫(xiě)進(jìn)去 # 通過(guò)定義一個(gè)特殊的__init__方法【構(gòu)造函數(shù)】，在創(chuàng)建實(shí)例的時(shí)候，就把name，score等屬性綁上去 # __init__方法的第一個(gè)參數(shù)永遠(yuǎn)是self，表示創(chuàng)建的實(shí)例本身，因此，在__init__方法內(nèi)部，就可以把各種屬性綁定到self，因?yàn)閟elf就指向創(chuàng)建的實(shí)例本身 class Student(object):def __init__(self, name, score):self.name = nameself.score = score# 有了__init__方法，在創(chuàng)建實(shí)例的時(shí)候，就不能傳入空的參數(shù)了，必須傳入與__init__方法匹配的參數(shù)，但self不需要傳，Python解釋器自己會(huì)把實(shí)例變量傳進(jìn)去 bart = Student('Bart Simpson', 59)

11.2 訪問(wèn)限制

# 如果要讓內(nèi)部屬性不被外部訪問(wèn)，可以把屬性的名稱(chēng)前加上兩個(gè)下劃線(xiàn)__，在Python中，實(shí)例的變量名如果以__開(kāi)頭，就變成了一個(gè)私有變量（private），只有內(nèi)部可以訪問(wèn)，外部不能訪問(wèn) class Student(object):def __init__(self, name, score):# 兩個(gè)下劃線(xiàn)，說(shuō)明name是私有變量self.__name = name self.__score = score # 如果外部代碼要獲取或修改score怎么辦？可以給Student類(lèi)增加get和set這樣的方法def get_score(self):return self.__scoredef set_score(self, score):self.__score = score

需要注意的是，在Python中，變量名類(lèi)似__xxx__的，也就是以雙下劃線(xiàn)開(kāi)頭，并且以雙下劃線(xiàn)結(jié)尾的，是特殊變量，特殊變量是可以直接訪問(wèn)的，不是private變量，所以，不能用__name__、__score__這樣的變量名

11.3 繼承和多態(tài)

當(dāng)我們定義一個(gè)class的時(shí)候，可以從某個(gè)現(xiàn)有的class繼承，新的class稱(chēng)為子類(lèi)Subclass，而被繼承的class稱(chēng)為基類(lèi)、父類(lèi)或超類(lèi)Base class、Super class

class Animal(object):def run(self):print('Animal is running...')# Dog就是Animal的子類(lèi) class Dog(Animal):pass

• 子類(lèi)可以獲得父類(lèi)的全部功能
• 當(dāng)子類(lèi)和父類(lèi)都存在相同的run()方法時(shí)，我們說(shuō)，子類(lèi)的run()覆蓋了父類(lèi)的run()，在代碼運(yùn)行的時(shí)候，總是會(huì)調(diào)用子類(lèi)的run()。這樣，我們就獲得了繼承的另一個(gè)好處：多態(tài)

對(duì)于靜態(tài)語(yǔ)言（例如Java）來(lái)說(shuō)，如果需要傳入Animal類(lèi)型，則傳入的對(duì)象必須是Animal類(lèi)型或者它的子類(lèi)，否則，將無(wú)法調(diào)用run()方法

對(duì)于Python這樣的動(dòng)態(tài)語(yǔ)言來(lái)說(shuō)，則不一定需要傳入Animal類(lèi)型。我們只需要保證傳入的對(duì)象有一個(gè)run()方法就可以了。這就是動(dòng)態(tài)語(yǔ)言的“鴨子類(lèi)型”，它并不要求嚴(yán)格的繼承體系，一個(gè)對(duì)象只要“看起來(lái)像鴨子，走起路來(lái)像鴨子”，那它就可以被看做是鴨子

11.4 獲取對(duì)象信息

判斷對(duì)象類(lèi)型，可以使用type()函數(shù)，它返回對(duì)應(yīng)的Class類(lèi)型。如果我們要在if語(yǔ)句中判斷，就需要比較兩個(gè)變量的type類(lèi)型是否相同

>>> type(abs)==types.BuiltinFunctionType True >>> type(lambda x: x)==types.LambdaType True >>> type((x for x in range(10)))==types.GeneratorType True# 但是對(duì)于class的繼承關(guān)系來(lái)說(shuō)，使用type()就很不方便，所以?xún)?yōu)先考慮isinstance() >>> a = Animal() >>> d = Dog() >>> h = Husky() # 子類(lèi)屬于父類(lèi)，因此返回True >>> isinstance(h, Animal) True # 判斷一個(gè)變量是否是某些類(lèi)型中的一種 >>> isinstance([1, 2, 3], (list, tuple)) True # 基本類(lèi)型也可以用isinstance()判斷 >>> isinstance(b'a', bytes) True # 如果要獲得一個(gè)對(duì)象的所有屬性和方法，可以使用dir()函數(shù)，它返回一個(gè)包含字符串的list，比如，獲得一個(gè)str對(duì)象的所有屬性和方法 >>> dir('ABC') ['__add__', '__class__',..., '__subclasshook__', 'capitalize', 'casefold',..., 'zfill']# 類(lèi)似__xxx__的屬性和方法在Python中都是有特殊用途的，比如__len__方法返回長(zhǎng)度。在Python中，如果你調(diào)用len()函數(shù)試圖獲取一個(gè)對(duì)象的長(zhǎng)度，實(shí)際上，在len()函數(shù)內(nèi)部，它自動(dòng)去調(diào)用該對(duì)象的__len__()方法，所以，下面的代碼是等價(jià)的 >>> len('ABC') 3 >>> 'ABC'.__len__() 3 # 我們自己寫(xiě)的類(lèi)，如果也想用len(myObj)的話(huà)，就自己寫(xiě)一個(gè)__len__()方法

僅僅把屬性和方法列出來(lái)是不夠的，配合getattr()、setattr()以及hasattr()，我們可以直接操作一個(gè)對(duì)象的狀態(tài)

11.5 實(shí)例對(duì)象和類(lèi)屬性

# 如果類(lèi)本身需要綁定一個(gè)屬性，可以直接在class中定義屬性，這種屬性是類(lèi)屬性，歸該類(lèi)所有 >>> class Student(object): ... name = 'Student' ... # 創(chuàng)建實(shí)例s >>> s = Student() # 打印name屬性，因?yàn)閷?shí)例并沒(méi)有name屬性，所以會(huì)繼續(xù)查找class的name屬性 >>> print(s.name) Student # 打印類(lèi)的name屬性 >>> print(Student.name) Student# 給實(shí)例綁定name屬性 >>> s.name = 'Michael' # 由于實(shí)例屬性?xún)?yōu)先級(jí)比類(lèi)屬性高，因此，它會(huì)屏蔽掉類(lèi)的name屬性 >>> print(s.name) Michael# 但是類(lèi)屬性并未消失，用Student.name仍然可以訪問(wèn) >>> print(Student.name) Student# 如果刪除實(shí)例的name屬性 >>> del s.name # 再次調(diào)用s.name，由于實(shí)例的name屬性沒(méi)有找到，類(lèi)的name屬性就顯示出來(lái)了 >>> print(s.name) Student

12. 面對(duì)對(duì)象高級(jí)編程

from types import MethodType # 定義一個(gè)函數(shù)作為實(shí)例方法 def set_age(self, age): self.age = age # 除了可以給實(shí)例對(duì)象綁定屬性外，也可以給實(shí)例對(duì)象綁定方法 class Student(object):passs = Student()# 給實(shí)例綁定一個(gè)方法【需要借助MethodType】 s.set_age = MethodType(set_age, s) # 調(diào)用實(shí)例方法 s.set_age(25) # 測(cè)試結(jié)果，輸出 25 print(s.age) # 為了給所有實(shí)例都綁定方法，可以給 class 綁定方法 # 注意：給實(shí)例綁定方法和給類(lèi)綁定方法寫(xiě)法是不一樣的 Student.set_age = set_age

12.1 使用__slots__

Python允許在定義class的時(shí)候，定義一個(gè)特殊的__slots__變量，來(lái)限制該class實(shí)例能添加的屬性

class Student(object):# 用tuple定義允許綁定的屬性名稱(chēng)__slots__ = ('name', 'age') # 創(chuàng)建新的實(shí)例 s = Student() # 由于'score'沒(méi)有被放到__slots__中，所以不能綁定score屬性，試圖綁定score將得到AttributeError的錯(cuò)誤 s.score = 99

使用__slots__要注意，__slots__定義的屬性?xún)H對(duì)當(dāng)前類(lèi)實(shí)例起作用，對(duì)繼承的子類(lèi)是不起作用的

如果在子類(lèi)中也定義__slots__，這樣子類(lèi)實(shí)例允許定義的屬性就是自身的__slots__加上父類(lèi)的__slots__

12.2 @property

利用@property可以實(shí)現(xiàn)通過(guò)屬性調(diào)用【方法在此被視為屬性】智能綁定get方法和set方法

class Student(object):# @proerty綁定get方法，使得score屬性擁有g(shù)et方法@property def score(self):return self._score# @score.setter使得set方法變?yōu)閷傩?#xff0c;使得score屬性擁有set方法@score.setter def score(self, value):if(value >= 60):self._score = valueelse:print('沒(méi)有及格')s=Student() # score是方法名，但是被注釋后成為屬性名，賦值操作實(shí)則是調(diào)用set s.score=61 # 非賦值的調(diào)用實(shí)則調(diào)用get，因此輸出 61 print(s.score)

特別注意：屬性的方法名不要和實(shí)例變量重名，否則會(huì)造成無(wú)限遞歸！

12.3 多重繼承

Python允許子類(lèi)擁有多個(gè)父親，通過(guò)多重繼承，一個(gè)子類(lèi)就可以同時(shí)獲得多個(gè)父類(lèi)的所有功能

class Animal(object):def run(self):print('I am Animal') class Runnable(object):def run(self):print('Running...')# 同時(shí)有兩個(gè)父類(lèi) class Dog(Runnable,Animal): d=Dog() # 遇到同名方法時(shí)優(yōu)先調(diào)用寫(xiě)在最左邊的父類(lèi)，輸出Running... d.run()

MixIn

MixIn的目的就是給一個(gè)類(lèi)增加多個(gè)功能，這樣，在設(shè)計(jì)類(lèi)的時(shí)候，我們優(yōu)先考慮通過(guò)多重繼承來(lái)組合多個(gè)MixIn的功能，而不是設(shè)計(jì)多層次的復(fù)雜的繼承關(guān)系

# 每個(gè)MixIn都有自己的功能 class RunnableMixIn(object):def run(self):print('Running...')# 我們根據(jù)需要將MixIn進(jìn)行繼承，從而獲得想要的功能 class Dog(Animal,RunnableMixIn):pass

12.4 定制類(lèi)

我們可以根據(jù)需要重寫(xiě)一些類(lèi)方法從而使其能更好為我們服務(wù)

12.4.1 __str__

__str__類(lèi)似與Java中的toString方法，通過(guò)重寫(xiě)此方法，可以使得直接輸出類(lèi)時(shí)按照我們想要的格式進(jìn)行輸出

class Student(object):def __init__(self, name):self.name = name# 重寫(xiě)__str__def __str__(self): return 'Student object (name: %s)' % self.name# 輸出 Student object (name: Michael) print(Student('Michael'))

12.4.2 __iter__

如果一個(gè)類(lèi)想被用于for ... in循環(huán)，類(lèi)似list或tuple那樣，就必須實(shí)現(xiàn)一個(gè)__iter__()方法，該方法返回一個(gè)迭代對(duì)象，然后，Python的for循環(huán)就會(huì)不斷調(diào)用該迭代對(duì)象的__next__()方法拿到循環(huán)的下一個(gè)值，直到遇到StopIteration錯(cuò)誤時(shí)退出循環(huán)

# 以斐波那契數(shù)列為例 class Fib(object): def __init__(self):# 初始化兩個(gè)計(jì)數(shù)器a，bself.a, self.b = 0, 1 # 使用for...in的時(shí)候會(huì)調(diào)用def __iter__(self): return self # 實(shí)例本身就是迭代對(duì)象，故返回自己# for循環(huán)每進(jìn)行一次就會(huì)調(diào)用一次def __next__(self): # 計(jì)算下一個(gè)值self.a, self.b = self.b, self.a + self.b# 退出循環(huán)的條件if self.a > 100000: raise StopIteration()# 斐波那契數(shù)列當(dāng)前值return self.a for n in Fib():# 此時(shí)會(huì)打印Fib類(lèi)中每次__next__的執(zhí)行結(jié)果print(n)

12.4.3 __getitem__

如果類(lèi)想像list那樣按照下標(biāo)取出元素，需要實(shí)現(xiàn)__getitem__()方法

class Fib(object):# n為下標(biāo)值def __getitem__(self, n):a, b = 1, 1for x in range(n):a, b = b, a + breturn af = Fib() # 此時(shí)調(diào)用__getitem__方法，n為0，輸出 1 print(f[0]) # list還可以使用切片的方式訪問(wèn)，因此若我們將n定死為整型則無(wú)法使用切片訪問(wèn) class Fib(object):def __getitem__(self, n):# n是索引if isinstance(n, int): a, b = 1, 1for x in range(n):a, b = b, a + breturn a# n是切片if isinstance(n, slice): # 開(kāi)始索引start = n.start # 結(jié)束索引，但不包括此索引stop = n.stop if start is None:start = 0a, b = 1, 1L = []for x in range(stop):# 過(guò)濾掉不需要的部分if x >= start: L.append(a) a, b = b, a + breturn Lf = Fib() # 輸出[1, 1, 2, 3, 5] print(f[0:5]) # 像上述👆這樣設(shè)計(jì)仍然有缺陷，比如步數(shù)step還未處理等

與之對(duì)應(yīng)的是__setitem__()方法，把對(duì)象視作list或dict來(lái)對(duì)集合賦值。最后，還有一個(gè)__delitem__()方法，用于刪除某個(gè)元素?？傊?#xff0c;通過(guò)上面的方法，我們自己定義的類(lèi)表現(xiàn)得和Python自帶的list、tuple、dict沒(méi)什么區(qū)別，這完全歸功于動(dòng)態(tài)語(yǔ)言的“鴨子類(lèi)型”，不需要強(qiáng)制繼承某個(gè)接口。

12.4.4 __getattr__

正常情況下，當(dāng)我們調(diào)用類(lèi)的方法或?qū)傩詴r(shí)，如果不存在，就會(huì)報(bào)錯(cuò)。要避免這個(gè)錯(cuò)誤，除了可以加上這個(gè)屬性外，Python還有另一個(gè)機(jī)制，那就是寫(xiě)一個(gè)__getattr__()方法，動(dòng)態(tài)返回一個(gè)屬性

class Student(object): # 只有在沒(méi)有找到屬性的情況下才調(diào)用__getattr__，已有的屬性不會(huì)在__getattr__中查找def __getattr__(self, attr):# 如果訪問(wèn)的屬性是score就返回 99if attr=='score': return 99

12.4.5 __call__

一個(gè)對(duì)象實(shí)例可以有自己的屬性和方法，當(dāng)我們調(diào)用實(shí)例方法時(shí)，我們用instance.method()來(lái)調(diào)用，同時(shí)任何類(lèi)只需要定義一個(gè)__call__()方法，就可以直接對(duì)實(shí)例進(jìn)行調(diào)用

class Student(object):# 構(gòu)造函數(shù)def __init__(self, name): self.name = namedef __call__(self):print('My name is %s.' % self.name)s = Student('Michael') # self參數(shù)不要傳入，輸出 My name is Michael. s()

__call__()還可以定義參數(shù)。對(duì)實(shí)例進(jìn)行直接調(diào)用就好比對(duì)一個(gè)函數(shù)進(jìn)行調(diào)用一樣，所以你完全可以把對(duì)象看成函數(shù)，把函數(shù)看成對(duì)象。如果把對(duì)象看成函數(shù)，那么函數(shù)本身其實(shí)也可以在運(yùn)行期動(dòng)態(tài)創(chuàng)建出來(lái)，因?yàn)轭?lèi)的實(shí)例都是運(yùn)行期創(chuàng)建出來(lái)的，這么一來(lái)，我們就模糊了對(duì)象和函數(shù)的界限。

那么，怎么判斷一個(gè)變量是對(duì)象還是函數(shù)呢？

其實(shí)，更多的時(shí)候，我們需要判斷一個(gè)對(duì)象是否能被調(diào)用，能被調(diào)用的對(duì)象就是一個(gè)Callable對(duì)象，比如函數(shù)和我們上面定義的帶有__call__()的類(lèi)實(shí)例

# max函數(shù)可以被調(diào)用，所以為T(mén)rue >>> callable(max) True # list不可以被調(diào)用，所以為False >>> callable([1, 2, 3]) False

12.5 枚舉類(lèi)

當(dāng)我們需要定義常量時(shí)，一個(gè)辦法是用大寫(xiě)變量通過(guò)整數(shù)來(lái)定義，好處是簡(jiǎn)單，缺點(diǎn)是類(lèi)型是int，并且仍然是變量。更好的方法是為這樣的枚舉類(lèi)型定義一個(gè)class類(lèi)型，然后，每個(gè)常量都是class的一個(gè)唯一實(shí)例。Python提供了Enum類(lèi)來(lái)實(shí)現(xiàn)這個(gè)功能

from enum import EnumMonth = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')) for name,member in Month.__members__.items():# value 屬性則是自動(dòng)賦給成員的int常量，默認(rèn)從1開(kāi)始計(jì)數(shù)print(name,'=>',member,'=>',member.value) # 輸出格式類(lèi)似于：Jan => Month.Jan => 1# @unique 裝飾器可以幫助我們檢查保證沒(méi)有重復(fù)值 @unique class Weekday(Enum):# Sun的value被設(shè)定為0Sun = 0 Mon = 1Tue = 2Wed = 3Thu = 4Fri = 5Sat = 6 # 訪問(wèn)這些枚舉類(lèi)型可以有若干種方法 >>> print(Weekday.Tue) Weekday.Tue >>> print(Weekday['Tue']) Weekday.Tue >>> print(Weekday.Tue.value) 2 >>> print(Weekday(1)) Weekday.Mon

12.6 使用元類(lèi)

動(dòng)態(tài)語(yǔ)言和靜態(tài)語(yǔ)言最大的不同，就是函數(shù)和類(lèi)的定義，不是編譯時(shí)定義的，而是運(yùn)行時(shí)動(dòng)態(tài)創(chuàng)建的

class Hello(object):def hello(self, name='world'):print('Hello, %s.' % name)h = Hello() h.hello()

當(dāng)Python解釋器載入hello模塊時(shí)，才會(huì)依次執(zhí)行該模塊的所有語(yǔ)句，執(zhí)行結(jié)果就是動(dòng)態(tài)創(chuàng)建出一個(gè)Hello的class對(duì)象

type()

type()函數(shù)可以查看一個(gè)類(lèi)型或變量的類(lèi)型，Hello是一個(gè)class，它的類(lèi)型就是type，而h是一個(gè)實(shí)例，它的類(lèi)型就是class Hello。

我們說(shuō)class的定義是運(yùn)行時(shí)動(dòng)態(tài)創(chuàng)建的，而創(chuàng)建class的方法就是使用type()函數(shù)

type()函數(shù)既可以返回一個(gè)對(duì)象的類(lèi)型【比如整數(shù)是int，字符串是str，class是type】，又可以創(chuàng)建出新的類(lèi)型【不通過(guò)class定義而直接通過(guò)class定義的本質(zhì)type()函數(shù)創(chuàng)建】

# 先定義函數(shù) def fn(self, name='world'): print('Hello, %s.' % name)# 要?jiǎng)?chuàng)建一個(gè)class對(duì)象，type()函數(shù)依次傳入3個(gè)參數(shù)： # 1. class的名稱(chēng)； # 2. 繼承的父類(lèi)集合，注意Python支持多重繼承，如果只有一個(gè)父類(lèi)，別忘了tuple的單元素寫(xiě)法； # 3. class的方法名稱(chēng)與函數(shù)綁定，這里我們把函數(shù)fn綁定到方法名hello上 # 創(chuàng)建 class Hello Hello = type('Hello', (object,), dict(hello=fn))

通過(guò)type()函數(shù)創(chuàng)建的類(lèi)和直接寫(xiě)class是完全一樣的，因?yàn)镻ython解釋器遇到class定義時(shí)，僅僅是掃描一下class定義的語(yǔ)法，然后調(diào)用type()函數(shù)創(chuàng)建出class

正常情況下，我們都用class Xxx...來(lái)定義類(lèi)，但是，type()函數(shù)也允許我們動(dòng)態(tài)創(chuàng)建出類(lèi)來(lái)，也就是說(shuō)，動(dòng)態(tài)語(yǔ)言本身支持運(yùn)行期動(dòng)態(tài)創(chuàng)建類(lèi)，這和靜態(tài)語(yǔ)言有非常大的不同，要在靜態(tài)語(yǔ)言運(yùn)行期創(chuàng)建類(lèi)，必須構(gòu)造源代碼字符串再調(diào)用編譯器，或者借助一些工具生成字節(jié)碼實(shí)現(xiàn)，本質(zhì)上都是動(dòng)態(tài)編譯，會(huì)非常復(fù)雜。

除了使用type()動(dòng)態(tài)創(chuàng)建類(lèi)以外，要控制類(lèi)的創(chuàng)建行為【得到類(lèi)的實(shí)例】，需要使用metaclass

metaclass

metaclass直譯為元類(lèi)，簡(jiǎn)單的解釋就是：當(dāng)我們定義了類(lèi)以后，就可以根據(jù)這個(gè)類(lèi)創(chuàng)建出實(shí)例，所以：先定義類(lèi)，然后創(chuàng)建實(shí)例。可以把類(lèi)看成是metaclass創(chuàng)建出來(lái)的“實(shí)例”

正常情況下不會(huì)碰到需要使用metaclass的情況，等需要的時(shí)候再回來(lái)看這部分知識(shí)點(diǎn)！

13. 文件

在Python使用open函數(shù)，可以打開(kāi)一個(gè)已經(jīng)存在的文件，或者創(chuàng)建一個(gè)新文件

# name:是要打開(kāi)的目標(biāo)文件名的字符串(可以包含文件所在的具體路徑) # mode:設(shè)置打開(kāi)文件的模式(訪問(wèn)模式):只讀(r)、從頭寫(xiě)入(w)、追加(a)等。 # encoding:編碼格式（推薦使用UTF-8) # 返回一個(gè)_io.TextIOWrapper對(duì)象 f = open(name, mode, encoding) # 讀取文件所有內(nèi)容，填寫(xiě)參數(shù)時(shí)則讀取參數(shù)長(zhǎng)度字節(jié)內(nèi)容，返回str類(lèi)型 f.read() # 讀取所有內(nèi)容，每一行為list中的一個(gè)元素 f.readlines() # 調(diào)用一次讀取一行內(nèi)容 f.readline() # 也可以通過(guò)for循環(huán)進(jìn)行讀取 for line in f: print(f"每一行數(shù)據(jù)是:{line}")# 關(guān)閉文件流，內(nèi)含flush功能 f.close() # 若使用此語(yǔ)句打開(kāi)文件，則文件流最后會(huì)自動(dòng)關(guān)閉 with open(xxx) as f: xxxxx# 將內(nèi)容寫(xiě)入文件 f.write(xxx) # 刷新后寫(xiě)入的內(nèi)容才會(huì)從緩存中發(fā)送到硬盤(pán)上 f.flush()

14. 異常處理

當(dāng)我們認(rèn)為某些代碼可能會(huì)出錯(cuò)時(shí)，就可以用try來(lái)運(yùn)行這段代碼，如果執(zhí)行出錯(cuò)，則后續(xù)代碼不會(huì)繼續(xù)執(zhí)行，而是直接跳轉(zhuǎn)至錯(cuò)誤處理代碼，即except語(yǔ)句塊，執(zhí)行完except后，如果有finally語(yǔ)句塊，則執(zhí)行finally語(yǔ)句塊，至此，執(zhí)行完畢

try:print('try...')r = 10 / 0print('result:', r) # python所有的錯(cuò)誤類(lèi)型都繼承自BaseException，捕獲錯(cuò)誤時(shí)也會(huì)把子類(lèi)一網(wǎng)打盡 # except: 是捕獲所有異常 # 可以有多個(gè)except捕獲不同的錯(cuò)誤 except ZeroDivisionError as e: # except (xxx,xxx) as e 是捕獲多個(gè)異常print('except:', e) # finally是一定會(huì)執(zhí)行的部分 finally: print('finally...') print('END')

各異常的層級(jí)關(guān)系👇

使用try...except捕獲錯(cuò)誤還有一個(gè)巨大的好處，就是可以跨越多層調(diào)用，比如函數(shù)main()調(diào)用bar()，bar()調(diào)用foo()，結(jié)果foo()出現(xiàn)異常了，此時(shí)foo()的異常會(huì)拋給bar()，bar()再拋給main()，只要main()捕獲到了，就可以處理。換句話(huà)說(shuō)，異常是可以向上傳遞的。

def foo(s):return 10 / int(s)def bar(s):return foo(s) * 2def main():try:bar('0')except Exception as e:print('Error:', e)finally:print('finally...')

Python內(nèi)置的logging模塊可以非常容易地記錄錯(cuò)誤信息，通過(guò)配置，logging還可以把錯(cuò)誤記錄到日志文件里，方便事后排查。

如果錯(cuò)誤沒(méi)有被捕獲，它就會(huì)一直往上拋，最后被Python解釋器捕獲，打印一個(gè)錯(cuò)誤信息

有時(shí)捕獲錯(cuò)誤目的只是記錄一下，便于后續(xù)追蹤。但是，由于當(dāng)前函數(shù)不知道應(yīng)該怎么處理該錯(cuò)誤，所以，最恰當(dāng)?shù)姆绞绞抢^續(xù)往上拋，讓頂層調(diào)用者去處理。好比一個(gè)員工處理不了一個(gè)問(wèn)題時(shí)，就把問(wèn)題拋給他的老板

def foo(s):n = int(s)if n==0:# raise的作用是顯式的拋出異常raise ValueError('invalid value: %s' % s) return 10 / ndef bar():try:foo('0')except ValueError as e:print('ValueError!')# 主動(dòng)拋出此異常，說(shuō)明ValueError這個(gè)異常還未被解決，上層依舊可以進(jìn)行捕獲raise bar()

15. 模塊

Python模塊Module，是一個(gè)Python 文件，以.py 結(jié)尾。模塊能定義函數(shù)，類(lèi)和變量，模塊里也能包含
可執(zhí)行的代碼。

python中有很多各種不同的模塊，每一個(gè)模塊都可以幫助我們快速的實(shí)現(xiàn)一些功能，比如實(shí)現(xiàn)和時(shí)間相關(guān)的功能可以使用time模塊等。我們可以認(rèn)為一個(gè)模塊就是一個(gè)工具包，每一個(gè)工具包中都有各種不同的工具供我們使用進(jìn)而實(shí)現(xiàn)各種不同的功能。

# 模塊在使用前需要先導(dǎo)入，導(dǎo)入語(yǔ)法如下👇 [from 模塊名] import [模塊│類(lèi)│變量│函數(shù)│*] [as 別名]# 常見(jiàn)的有以下👇幾種形式 # 整個(gè)模塊引入 import 模塊名 # 引入具體的方法 from 模塊名 import 類(lèi)、變量、方法等 from 模塊名 import * import 模塊名 as 別名 from 模塊名 import 功能名 as 別名# 導(dǎo)入time模塊 import time # 通過(guò)模塊調(diào)用內(nèi)部方法 time.sleep(5) # 導(dǎo)入time.sleep()方法 from time import sleep # 直接使用方法名就可以完成調(diào)用 sleep(5)

15.1 自定義模塊

簡(jiǎn)單來(lái)說(shuō)就是將自己寫(xiě)的模塊導(dǎo)入當(dāng)前正在處理的.py文件，類(lèi)似于Java在一個(gè)類(lèi)中使用另一個(gè)文件的類(lèi)時(shí)也需要先導(dǎo)入此類(lèi)

# 當(dāng)遇到不同模塊的重名方法時(shí)，后導(dǎo)入的方法會(huì)覆蓋先導(dǎo)入的方法 from module1 import test from module2 import test # 此時(shí)調(diào)用的是module2中的方法 test()

在導(dǎo)入模塊時(shí)，其實(shí)Python是將整個(gè)模塊執(zhí)行了一遍，而有時(shí)模塊中有部分測(cè)試數(shù)據(jù)我們不希望他在被調(diào)用時(shí)執(zhí)行則需要做以下處理👇

def test(a, b):return a + b # 只有發(fā)起運(yùn)行的.py文件中的內(nèi)置變量__name__才是__main__ # 因此當(dāng)此模塊被導(dǎo)入時(shí)，if下方的語(yǔ)句并不會(huì)執(zhí)行 if __name__ == '__main__': test(1 + 2)

__all__變量可以控制import *時(shí)哪些功能可以被導(dǎo)入

# 此時(shí)若有程序通過(guò)import *導(dǎo)入此模塊的方法時(shí)只能導(dǎo)到test1 __all__=['test1'] def test1(a, b):return a - b def test2(a, b):return a + b

15.2 自定義Python包

從物理上看，包就是一個(gè)文件夾，在該文件夾下包含了一個(gè)_init_.py文件，該文件夾可用于包含多個(gè)模塊文件。從邏輯上看，包的本質(zhì)依然是模塊【區(qū)別在于是否有_init_.py文件】

在PyCharm中直接可以創(chuàng)建Python Package，創(chuàng)建后會(huì)自動(dòng)生成_init_.py文件，接著我們將自己定義的模塊放入此包下就行

# 導(dǎo)入包的方法 # 導(dǎo)入my_package下的module1模塊 from my_package import module1 # 導(dǎo)入my_package下的module1，module2模塊 from my_package import module1,module2 # 導(dǎo)入my_package下的module模塊的test()方法 from my_package.module1 import test # 還可以通過(guò)在__init__.py中設(shè)置__all__變量來(lái)控制import *的行為 # 例如在__init__.py寫(xiě)入此語(yǔ)句 __all__=['module2'] # 此時(shí)只能導(dǎo)入module2模塊 from my_package import *

16. 引入第三方包

在Python程序的生態(tài)中，有許多非常多的第三方包【非Python官方】，可以極大的幫助我們提高開(kāi)發(fā)效率，如：

• 科學(xué)計(jì)算中常用的：numpy包
• 數(shù)據(jù)分析中常用的：pandas包
• 大數(shù)據(jù)計(jì)算中常用的：pyspark，apache-flink包
• 圖形可視化常用的：matplotlib，pyecharts

但是由于是第三方，所以Python沒(méi)有內(nèi)置，所以我們需要安裝它們才可以導(dǎo)入使用

# 第三方包的安裝非常簡(jiǎn)單，我們只需要使用Python內(nèi)置的pip程序即可 # 此語(yǔ)句在命令提示符中運(yùn)行 pip install 包名稱(chēng) # 由于pip命令默認(rèn)是從國(guó)外服務(wù)器下載包，因此速度較慢，我們可以為其設(shè)置鏡像下載地址 pip install xlrd -i https://pypi.tuna.tsinghua.edu.cn/simple openpyxl

當(dāng)然，在PyCharm中也支持安裝第三方包

或者在PyCharm中直接使用import語(yǔ)句導(dǎo)入包再按Alt+Enter也會(huì)進(jìn)行自動(dòng)導(dǎo)包

17. Json

JSON是一種輕量級(jí)的數(shù)據(jù)交互格式，可以按照J(rèn)SON指定的格式去組織和封裝數(shù)據(jù)，本質(zhì)上是一個(gè)帶有特定格式的字符串，是不同編程語(yǔ)言通信的中轉(zhuǎn)站

// Json格式如下👇 // 單個(gè)Json的格式與Python中的字典dict類(lèi)似 {"name":"tom","age":18} // 多個(gè)Json實(shí)則是列表+字典 [{"name":"tom","age":18},{"name":"tom","age":18}] # 使用Json需要導(dǎo)入內(nèi)置模塊 import json # data是一個(gè)列表字典 data = [{"name": "tom", "age": 18}, {"name": "mike", "age": 20}] # 通過(guò)json.dumps將列表字典轉(zhuǎn)變?yōu)閖son對(duì)象，ensure_ascii=False確保中文能夠正常顯示 json_str = json.dumps(data, ensure_ascii=False)# s是一個(gè)長(zhǎng)著Json樣子的字符串 s = '[{"name": "tom", "age": 18}, {"name": "mike", "age": 20}]' # 通過(guò)loads方法將字符串轉(zhuǎn)換為list對(duì)象，當(dāng)然只有{}包圍時(shí)也可以轉(zhuǎn)為dict對(duì)象 l = json.loads(s)

總結(jié)

以上是生活随笔為你收集整理的Python基础学习笔记【廖雪峰】的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。