1. 入門

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

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

空值None是Python里一個特殊的值，None不能理解為0，因為0是有意義的，而None是一個特殊的空值

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

2. 輸入輸出

# 單引號引起來是字符串 print('Hello') # 逗號隔開輸出不同內(nèi)容，同時會自動填上一個空格 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不需要手動定義類型 name = input(); # 在提示語句后輸入 name = input('請輸入：');

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

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

3.1 整數(shù)

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

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

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

3.2 浮點數(shù)

浮點數(shù)也就是小數(shù)，之所以稱為浮點數(shù)，是因為按照科學(xué)記數(shù)法表示時，一個浮點數(shù)的小數(shù)點位置是可變的

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

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

3.3 字符串

字符串是以單引號'或雙引號"括起來的任意文本，比如'abc'，"xyz"

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

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

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

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

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

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

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

3.4 布爾值

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

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

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

3.5 常量

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

PI = 3.14159265359

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

• /除法計算結(jié)果是浮點數(shù)，即使是兩個整數(shù)恰好整除，結(jié)果也是浮點數(shù)
• 還有一種除法是//，稱為地板除，結(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時，實際上是令b指向了a此時指向的常量數(shù)據(jù)ABC
• 由于b本質(zhì)指向的是數(shù)據(jù)，因此隨后a指向了新數(shù)據(jù)后并不會影響b的指向
• 因此b最終指向的依然是ABC

4. 字符串

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

4.1 編碼

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

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

4.2 其他方法

4.3 格式化

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

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

字符串里面的%是一個普通字符時需要轉(zhuǎn)義，用%%來表示一個%

# 輸出'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ù)類型是list，可以隨時添加和刪除其中的元素，將其理解為鏈表即可，同時Python中的list更加強大，內(nèi)部可以存放不同類型的元素

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

list方法

# append方法將元素追加至末尾 append('martin') # insert方法將元素插入指定索引位置 insert(0,'linda') # pop()方法刪除末尾元素，也可刪除指定索引元素 pop() # 移除符合要求的第一個值 remove('xxx') # 連接兩個列表，這是比+運算符連接效率更高的方法 extend(list) # 統(tǒng)計num在list中出現(xiàn)的次數(shù) count(num) # 某個元素在不在列表中，返回布爾型 element in/not in listname list(reversed(range(5))) # 生成一個倒序列表[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一旦初始化就不能修改【所謂“不變”是說每個元素指向永遠(yuǎn)不變】，這是其與list的唯一區(qū)別

# 當(dāng)你定義一個tuple時，在定義的時候，tuple的元素就必須被確定下來 t = (1, 2) # 定義一個空的tuple t = () # 只有1個元素的tuple定義時必須加一個逗號，否則會與數(shù)學(xué)中的小括號歧義 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} # 取出鍵值對應(yīng)的值 d['Michael'] # 放入鍵值對 d['Adam'] = 67

dict方法

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

5.4 集合 set

set的原理與dict一致，不過其只存儲key值

# 得到一個空集合 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的條件判斷是不需要小括號括起來的，同時由于其依靠相同縮進(jìn)代表同一代碼塊，因此也無需中括號

age = 3 #只要age是非零數(shù)值、非空字符串、非空list等，就判斷為True，否則為False if age >= 18: #不要少寫冒號print('adult') elif age >= 6: #else if在此處縮寫為elifprint('teenager') else:print('kid')

6.2 循環(huán)

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

6.3 賦值

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

6.4 與and或or非not

and和or返回第一個能讓其確定結(jié)果為True或者False的值

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

6.5 函數(shù)

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

在縮進(jìn)塊中編寫函數(shù)體，函數(shù)的返回值用return語句返回，如果沒有return語句，函數(shù)執(zhí)行完畢后也會返回結(jié)果，只是結(jié)果為None，return None可以簡寫為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ù)

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

def nop():pass

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

if age >= 18:# 此處若缺少了pass，代碼運行就會有語法錯誤pass

6.5.2 返回值

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

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

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

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

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

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

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

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

# Python函數(shù)在定義的時候，默認(rèn)參數(shù)L的值就被計算出來了 # 由于L的默認(rèn)參數(shù)指向的是地址，因此下次使用時會保留上次添加的數(shù)據(jù) def add_end(L=[]):L.append('END')return L# 修改如下 # 由于None是一個不變對象，因此保證每次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ù)個數(shù)是可變的，可以是1個、2個到任意個，還可以是0個

定義可變參數(shù)和定義一個list或tuple參數(shù)相比，僅僅在參數(shù)前面加了一個*號。在函數(shù)內(nèi)部，參數(shù)numbers接收到的是一個tuple，因此，函數(shù)代碼完全不變。但是，調(diào)用該函數(shù)時，可以傳入任意個參數(shù)，包括0個參數(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前面加一個*號，把list或tuple的元素變成可變參數(shù)傳進(jìn)去 nums = [1,2,3] calc(*nums)

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

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

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

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

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

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

# 命名關(guān)鍵字參數(shù)需要一個特殊分隔符*, *后面的參數(shù)被視為命名關(guān)鍵字參數(shù) # 只接受city和job的關(guān)鍵字 def person(name, age, *, city, job): print(name, age, city,job) # 調(diào)用函數(shù)，其中key = value必須寫全，不能單寫一個value # 命名關(guān)鍵字參數(shù)可以有缺省值【即默認(rèn)參數(shù)】，從而簡化調(diào)用 person('Jack',24, city='Beijing', job='Engineer') # 如果函數(shù)定義中已經(jīng)有了一個可變參數(shù)，后面跟著的命名關(guān)鍵字參數(shù)就不再需要一個特殊分隔符*了 # *args說明是可變參數(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對應(yīng)必選參數(shù)，c為默認(rèn)參數(shù)，*開始的位置表示命名關(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) # 除了挨個傳參外，也可以通過一個tuple和dict也調(diào)用上述函數(shù)，不過需要保證tuple內(nèi)容可以與參數(shù)對上 args = (1, 2, 3) # kw中d的鍵值對會對應(yīng)給d的參數(shù)，剩下的內(nèi)容才會歸入?yún)?shù)中的kw kw = {'d': 88, 'x': '#'} f2(*args, **kw)

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

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

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

7.1 數(shù)學(xué)

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

7.2 類型轉(zhuǎn)換

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

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

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

7.4 長度len

# len()函數(shù)計算的是str的字符數(shù)【中文同適用】，如果換成bytes，len()函數(shù)就計算字節(jié)數(shù) # 輸出2，因為有兩個字符 print(len('中文')) # 輸出3，UTF-8編碼一個中文字符通常占3個字節(jié)，所以輸出6 print(len('你好'.encode('utf-8'))) 方法說明

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

8. 高級特性

8.1 切片

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

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

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

8.2 迭代

如果給定一個list或tuple，我們可以通過for循環(huán)來遍歷這個list或tuple，這種遍歷我們稱為迭代Iteration

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

8.3 列表生成式

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

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

8.4 生成器

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

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

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

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

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

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

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

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

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

實際上，遍歷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返回值，無法拿到return返回值 g = fib(6)# 若需要拿到return返回值則需要進(jìn)行如下操作 while True:try:x = next(g)print('g:', x)# 發(fā)生異常后才會執(zhí)行此代碼塊except StopIteration as e: # e.value即return返回值print('Generator return value:', e.value) break

8.5 迭代器

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

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

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

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

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

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

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

因為Python的Iterator對象表示的是一個數(shù)據(jù)流，Iterator對象可以被next()函數(shù)調(diào)用并不斷返回下一個數(shù)據(jù)，直到?jīng)]有數(shù)據(jù)時拋出StopIteration錯誤。可以把這個數(shù)據(jù)流看做是一個有序序列，但我們卻不能提前知道序列的長度，只能不斷通過next()函數(shù)實現(xiàn)按需計算下一個數(shù)據(jù)，所以Iterator的計算是惰性的，只有在需要返回下一個數(shù)據(jù)時它才會計算。Iterator甚至可以表示一個無限大的數(shù)據(jù)流，例如全體自然數(shù)。而使用list是永遠(yuǎn)不可能存儲全體自然數(shù)的

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

9. 函數(shù)式編程

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

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

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

9.1 高階函數(shù)

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

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

# 變量a指向abs函數(shù) a = abs # 所以也可以通過a調(diào)用abs函數(shù) a(-1) # 將1賦給abs，此時abs不再指向絕對值函數(shù)，而指向數(shù)字1 abs=1; # 一個簡單例子 # 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ù)接收兩個參數(shù)，一個是函數(shù)，一個是Iterable，map將傳入的函數(shù)依次作用到序列的每個元素，并把結(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把一個函數(shù)作用在一個序列[x1, x2, x3, ...]上，這個函數(shù)必須接收兩個參數(shù)，reduce把結(jié)果繼續(xù)和序列的下一個元素做累積計算

# 👇等價于 f(f(f(x1, x2), x3), x4) reduce(f, [x1, x2, x3, x4]) # 如下簡單例子，對序列求和 def add(x, y):return x + y # 先 f(1,3)，再將結(jié)果放入問號 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é)合使用，實現(xiàn)把字符串轉(zhuǎn)整型 reduce(fn, map(char2num, '13579'))

9.1.3 filter

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

# 一個簡單例子 def is_odd(n):# 結(jié)果為True的元素保留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或空串說明為True，此時返回去除多余空格的字符串# 如果s是None或空串說明為False，此時配合filter對這部分?jǐn)?shù)據(jù)不保留return s and s.strip() # filter返回的是一個Iterator l = list(filter(not_empty, ['A', '', 'B', None, 'C', ' '])) # 結(jié)果: ['A', 'B', 'C']

9.1.4 sorted/sort

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

# 默認(rèn)從小到大排序 sorted([36, 5, -12, 9, -21]) # 加上參數(shù)就是從大到小排序 sorted([36, 5, -12, 9, -21], reverse=True) # key指定的函數(shù)將作用于list的每一個元素上，并根據(jù)key函數(shù)返回的結(jié)果進(jìn)行排序，不過只能是內(nèi)置函數(shù) # 根據(jù)絕對值大小從小到大排序 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()這個函數(shù)return sum # 多次調(diào)用lazy_sum時返回的函數(shù)是獨立的 # 此時得到的是sum()這個函數(shù)，并未進(jìn)行求和 f = lazy_sum(1, 3, 5, 7, 9) # 調(diào)用f()函數(shù)時才開始執(zhí)行 num=f()

閉包

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

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

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

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

可以再創(chuàng)建一個函數(shù)，用該函數(shù)的參數(shù)綁定循環(huán)變量當(dāng)前的值，無論該循環(huán)變量后續(xù)如何更改，已綁定到函數(shù)參數(shù)的值不變，缺點是代碼較長，可利用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() # 此時輸出1，4，9 print(f1(),f2(),f3())

nonlocal

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

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

9.3 匿名函數(shù)

當(dāng)我們在傳入函數(shù)時，有些時候，不需要顯式地定義函數(shù)，直接傳入匿名函數(shù)更方便

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

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

9.4 裝飾器

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

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

9.5 偏函數(shù)

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

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

10. 模塊

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

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

# 此注釋👇允許此.py文件直接在Unix/Linux/Mac上運行 #!/usr/bin/env python3 # 此注釋👇表示.py文件本身使用標(biāo)準(zhǔn)UTF-8編碼 # -*- coding: utf-8 -*- # 表示模塊的文檔注釋，任何模塊代碼的第一個字符串都被視為模塊的文檔注釋 ' a test module ' # 使用__author__變量把作者寫進(jìn)去 __author__ = 'Michael Liao' # 上面部分👆是Python模塊的標(biāo)準(zhǔn)文件模板 # 導(dǎo)入sys模塊 import sys def test(): # sys模塊有一個argv變量，用list存儲了命令行的所有參數(shù)。argv至少有一個元素，因為第一個參數(shù)永遠(yuǎn)是該.py文件的名稱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)我們直接運行該模塊文件時，Python解釋器把一個特殊變量__name__置為__main__，而如果在其他地方導(dǎo)入該模塊時，if判斷將失敗 if __name__=='__main__':test()

作用域

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

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

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

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

11. 面對對象編程

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

11.1 類和實例

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

11.2 訪問限制

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

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

11.3 繼承和多態(tài)

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

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

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

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

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

11.4 獲取對象信息

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

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

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

11.5 實例對象和類屬性

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

12. 面對對象高級編程

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

12.1 使用__slots__

Python允許在定義class的時候，定義一個特殊的__slots__變量，來限制該class實例能添加的屬性

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

使用__slots__要注意，__slots__定義的屬性僅對當(dāng)前類實例起作用，對繼承的子類是不起作用的

如果在子類中也定義__slots__，這樣子類實例允許定義的屬性就是自身的__slots__加上父類的__slots__

12.2 @property

利用@property可以實現(xiàn)通過屬性調(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('沒有及格')s=Student() # score是方法名，但是被注釋后成為屬性名，賦值操作實則是調(diào)用set s.score=61 # 非賦值的調(diào)用實則調(diào)用get，因此輸出 61 print(s.score)

特別注意：屬性的方法名不要和實例變量重名，否則會造成無限遞歸！

12.3 多重繼承

Python允許子類擁有多個父親，通過多重繼承，一個子類就可以同時獲得多個父類的所有功能

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

MixIn

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

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

12.4 定制類

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

12.4.1 __str__

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

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

12.4.2 __iter__

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

# 以斐波那契數(shù)列為例 class Fib(object): def __init__(self):# 初始化兩個計數(shù)器a，bself.a, self.b = 0, 1 # 使用for...in的時候會調(diào)用def __iter__(self): return self # 實例本身就是迭代對象，故返回自己# for循環(huán)每進(jìn)行一次就會調(diào)用一次def __next__(self): # 計算下一個值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():# 此時會打印Fib類中每次__next__的執(zhí)行結(jié)果print(n)

12.4.3 __getitem__

如果類想像list那樣按照下標(biāo)取出元素，需要實現(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() # 此時調(diào)用__getitem__方法，n為0，輸出 1 print(f[0]) # list還可以使用切片的方式訪問，因此若我們將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): # 開始索引start = n.start # 結(jié)束索引，但不包括此索引stop = n.stop if start is None:start = 0a, b = 1, 1L = []for x in range(stop):# 過濾掉不需要的部分if x >= start: L.append(a) a, b = b, a + breturn Lf = Fib() # 輸出[1, 1, 2, 3, 5] print(f[0:5]) # 像上述👆這樣設(shè)計仍然有缺陷，比如步數(shù)step還未處理等

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

12.4.4 __getattr__

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

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

12.4.5 __call__

一個對象實例可以有自己的屬性和方法，當(dāng)我們調(diào)用實例方法時，我們用instance.method()來調(diào)用，同時任何類只需要定義一個__call__()方法，就可以直接對實例進(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ù)。對實例進(jìn)行直接調(diào)用就好比對一個函數(shù)進(jìn)行調(diào)用一樣，所以你完全可以把對象看成函數(shù)，把函數(shù)看成對象。如果把對象看成函數(shù)，那么函數(shù)本身其實也可以在運行期動態(tài)創(chuàng)建出來，因為類的實例都是運行期創(chuàng)建出來的，這么一來，我們就模糊了對象和函數(shù)的界限。

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

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

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

12.5 枚舉類

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

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 屬性則是自動賦給成員的int常量，默認(rèn)從1開始計數(shù)print(name,'=>',member,'=>',member.value) # 輸出格式類似于：Jan => Month.Jan => 1# @unique 裝飾器可以幫助我們檢查保證沒有重復(fù)值 @unique class Weekday(Enum):# Sun的value被設(shè)定為0Sun = 0 Mon = 1Tue = 2Wed = 3Thu = 4Fri = 5Sat = 6 # 訪問這些枚舉類型可以有若干種方法 >>> print(Weekday.Tue) Weekday.Tue >>> print(Weekday['Tue']) Weekday.Tue >>> print(Weekday.Tue.value) 2 >>> print(Weekday(1)) Weekday.Mon

12.6 使用元類

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

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

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

type()

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

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

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

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

通過type()函數(shù)創(chuàng)建的類和直接寫class是完全一樣的，因為Python解釋器遇到class定義時，僅僅是掃描一下class定義的語法，然后調(diào)用type()函數(shù)創(chuàng)建出class

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

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

metaclass

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

正常情況下不會碰到需要使用metaclass的情況，等需要的時候再回來看這部分知識點！

13. 文件

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

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

14. 異常處理

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

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

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

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

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模塊可以非常容易地記錄錯誤信息，通過配置，logging還可以把錯誤記錄到日志文件里，方便事后排查。

如果錯誤沒有被捕獲，它就會一直往上拋，最后被Python解釋器捕獲，打印一個錯誤信息

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

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!')# 主動拋出此異常，說明ValueError這個異常還未被解決，上層依舊可以進(jìn)行捕獲raise bar()

15. 模塊

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

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

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

15.1 自定義模塊

簡單來說就是將自己寫的模塊導(dǎo)入當(dāng)前正在處理的.py文件，類似于Java在一個類中使用另一個文件的類時也需要先導(dǎo)入此類

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

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

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

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

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

15.2 自定義Python包

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

在PyCharm中直接可以創(chuàng)建Python Package，創(chuà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 # 還可以通過在__init__.py中設(shè)置__all__變量來控制import *的行為 # 例如在__init__.py寫入此語句 __all__=['module2'] # 此時只能導(dǎo)入module2模塊 from my_package import *

16. 引入第三方包

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

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

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

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

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

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

17. Json

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

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

總結(jié)

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

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