目錄

一、Python進階初體驗——內置函式

1、資料型別相關

2、數值計算相關

3、bool 值判斷相關

4、IO 相關

5、元資料相關

6、help()函式

7、sorted()函式

8、range()函式

二、給代碼安個家——函式進階

1、位置引數

2、引數默認值

3、關鍵字引數

4、任意引數串列

5、多回傳值

三、讓你函式更好用——類進階

1、類屬性和類方法

（1）類屬性的定義

（2）類方法的定義

2、靜態方法

3、私有屬性、方法

4、特殊方法

5、類的繼承

（1）類的簡單繼承

（2）類的繼承鏈

（3）類的多繼承

四、從小獨棟升級為別墅區——函式式編程

1、函式賦值給變數

2、函式作為函式引數

3、lambda 運算式

---

寫在前面

Hello，你好呀，我是灰小猿！一個超會寫bug的程式猿！

最近和大家總結了幾期有關Python基礎入門和常見報錯解決的相關文章，得到了很多小伙伴的支持，同時Python基礎入門相關的內容也算是和大家總結得差不多了，有想學習或參考的小伙伴可以看以下幾篇文章：

Python基礎入門：

【全網力薦】堪稱最易學的Python基礎入門教程

萬字長文爆肝Python基礎入門【第二彈、超詳細資料型別總結】

常見報錯及解決：

全網最值得收藏的Python常見報錯及其解決方案，再也不用擔心遇到BUG了！

今天就繼續來和大家分享有關Python進階中函式和類使用的相關內容，同時之后還會繼續更新，感興趣的小伙伴可以關注一起學習呀！

一、Python進階初體驗——內置函式

Python 中內置有很多常用的函式，這些函式無需從模塊中匯入，可直接使用，由于內置函式有六七十個之多，

故這里不一一介紹，只介紹一些最常用的，有關其他詳細的內置函式大家可以參考這里“菜鳥教程—Python內置函式”，

1、資料型別相關

內置函式	功能	示例	示例結果
dict()	將引數轉換為字典型別	dict(a=1, b=2, c=3)	{'a': 1, 'b': 2, 'c': 3}
float()	將字串或數字轉換為浮點型	float('0.22')	0.22
int()	將字串或數字轉換為整數型	int(1.23)	1
list()	將元組、字串等可迭代物件轉換為串列	list('abc')	['a', 'b', 'c']
tuple()	將串列、字串等可迭代物件轉換為元組	tuple([1, 2, 3])	(1, 2, 3)
set()	1.創建空集合；2.將可迭代物件轉換為串列集合	set('abc')	{'b', 'a', 'c'}
str()	將引數轉換為字串	str(3.14)	'3.14'
bytes()	將引數轉換為位元組序列	bytes(4)	b'\x00\x00\x00\x00

擴展：上表中的函式嚴格來講并不是函式，而是類，只是其命名風格和使用方式和函式類似，

可迭代物件：如串列、元組、字串、集合、字典等，關于可迭代物件的使用計劃在下一篇和大家分享，

2、數值計算相關

內置函式	功能	示例	示例結果
max()	求最大值	max([13, 2, 0.6, -51, 7])	13
min()	求最小值	min([13, 2, 0.6, -51, 7])	-51
sum()	求和	sum([13, 2, 0.6, -51, 7])	-28.4
abs()	求絕對值	abs(-51)	51
pow()	求次方	pow(2, 10)	1024
bin()	轉換為二進制	bin(77)	'0b1001101' （注意結果為字串）
hex()	轉換為十六進制	hex(77)	'0x4d' （注意結果為字串）
round()	浮點數四舍五入	round(4.5678, 2) （第二個引數為小數精度）	4.57

3、bool 值判斷相關

內置函式	功能
bool()	判斷引數是否為真，為真則回傳 True，否則回傳 False，「為真」指的是，運算式的結果為布林值 True，或非零數字，或非空字串，或非空串列
all()	如果可迭代物件中的所有值，在逐一應用 bool(值) 后結果都為 True，則回傳 True，否則回傳 False
any()	如果可迭代物件中的任意一個或多個值，在應用 bool(值) 后結果為 True，則回傳 True，否則回傳 False

關于上述三個函式的使用可以看下面的實體：

>>> bool(2)
True
>>> bool(0)
False
>>> bool([1, 2, 3])
True
>>> bool([])
False
>>> bool(‘abc’)
True
>>> bool(’’)
False

>>> all([‘a’, 1, [1]])
True
>>> all([‘a’, 0, [1]])
False

>>> any([’’, 0, []])
False
>>> any([‘a’, 0, []])
True

4、IO 相關

IO 即輸入輸出，

內置函式	功能
input()	從標準輸入中讀取字串
print()	將內容寫入標準輸出中
open()	打開一個檔案，之后便可以對檔案做讀寫操作，詳見 IO 操作章節

5、元資料相關

內置函式	功能
type()	獲取物件的型別
isinstance()	判斷物件是否是某個類（或其子類）的物件
dir()	獲取類或物件中的所有方法和屬性；無引數時獲取當前作用域下的所有名字
id()	回傳一個物件的唯一標識，在我們所使用的 CPython 中這個唯一標識實際為該物件在記憶體中的地址

type() 示例：

>>> numbers = [1, 2, 3]
>>> type(numbers)
<class ‘list’>

isinstance() 示例：

>>> numbers = [1, 2, 3]
>>> isinstance(numbers, list)
True
>>> isinstance(numbers, str)
False

也可以把多個型別放在元組中，其中一個與物件的型別相符即為 True，若無相符則為 False，如：

>>> numbers = [1, 2, 3]
>>> isinstance(numbers, (list, str))
True

dir() 示例：

>>> dir(list)
[’__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__delitem__’, ‘__dir__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__gt__’, ‘__hash__’, ‘__iadd__’, '__imul__, ‘__init__’, ‘__init_subclass__’, ‘__iter__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mul__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__reversed__’, ‘__rmul__’, ‘__setattr__’, ‘__setitem__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘append’, ‘clear’, ‘copy’, ‘count’, ‘extend’, ‘index’, ‘insert’, ‘pop’, ‘remove’, ‘reverse’, ‘sort’]

id() 示例：

>>> number = 1
>>> id(number)
4411695232

>>> numbers = [1, 2, 3, 4]
>>> id(numbers)
4417622792

6、help()函式

解釋器互動模式下獲取某個函式、類的幫助資訊，非常實用，

比如查看內置函式 any() 的用法：

>>> help(any) # 只需使用函式名字

將顯示出 any() 的幫助資訊：

Help on built-in function any in module builtins:

any(iterable, /)
    Return True if bool(x) is True for any x in the iterable.
    
    If the iterable is empty, return False.
(END)

按下 q 鍵退出上述界面，

對于這個章節中的內置函式，如果你有不清楚的地方，便可以用 help() 來查看使用說明，

7、sorted()函式

對可迭代物件中的資料進行排序，回傳一個新的串列，

>>> numbers = (4, 5, 2, 8, 9, 1, 0)
>>> sorted(numbers)
[0, 1, 2, 4, 5, 8, 9]

通過引數 reverse=True 指定倒序：

>>> numbers = (4, 5, 2, 8, 9, 1, 0)
>>> sorted(numbers, reverse=True)
[9, 8, 5, 4, 2, 1, 0]

通過引數 key 指定排序時所使用的欄位：

>>> codes = [(‘上海’, ‘021’), (‘北京’, ‘010’), (‘成都’, ‘028’), (‘廣州’, ‘020’)]
>>> sorted(codes, key=lambda x: x[1])
[(‘北京’, ‘010’), (‘廣州’, ‘020’), (‘上海’, ‘021’), (‘成都’, ‘028’)]

說明：指定 key 排序需要用到 lambda 運算式，有關 lambda 運算式的內容將在函式式編程章節中介紹，

8、range()函式

獲取一個整數序列，可指定起始數值，結束數值，增長步長，

在 for 回圈中想要指定回圈次數時非常有用，

• 指定起始數值和結束數值，獲取一個連續的整數序列

  for i in range(2, 6):
      print(i)
  

  >>> for i in range(2, 6):
  … print(i)
  …
  2
  3
  4
  5

  注意，生成的數值范圍為左開右閉區間，即不包括所指定的結束數值，

• 只指定結束數值，此時起始數值默認為 0

  >>> for i in range(4):
  … print(i)
  …
  0
  1
  2
  3

• 指定步長（第三個引數）

  >>> for i in range(3, 15, 3):
  … print(i)
  …
  3
  6
  9
  12

二、給代碼安個家——函式進階

1、位置引數

位置引數這個名稱其實我們并不陌生，之前所撰寫的函式使用的就是位置引數，位置引數，顧名思義，傳入函式時每個引數都是通過位置來作區分的，函式呼叫時，傳入的值需按照位置與引數一一對應，

比如下面這個程式：

def overspeed_rate(current, max, min):
    if current > max:
        return (current - max) / max    # 超過最大時速，結果為正
    elif current < min:
        return (current - min) / min    # 超過最小時速，結果為負
    else:
        return 0                        # 不超速，結果為 0

這個函式用來判斷車輛在高速上行駛時超速的比例，它接受三個引數，current 表示當前時速，max 引數表示當前路段的允許的最大時速，min 表示所允許的最小時速，

位置引數需要按位置順序來傳遞，否則結果不可預期，

>>> overspeed_rate(150, 120, 90)
0.25 # 超過最大時速 25%
>>> overspeed_rate(80, 100, 60)
0 # 不超速
>>> overspeed_rate(60, 120, 90)
-0.3333333333333333 # 超過最小時速 33.33%

2、引數默認值

前面的函式中，如果最大時速和最小時速比較固定，那么每次函式呼叫時都輸入這個兩個引數就顯得有些繁瑣，這時我們可以使用引數默認值，

引數默認值也就是給引數設定默認值，之后函式呼叫時便可以不傳入這個引數，Python 自動以默認值來填充引數，如果一個有默認值的引數依然被傳入了值，那么默認值將會被覆寫，

函式定義時，以 引數=值 來指定引數默認值，如下：

def 函式(引數1, 引數2=默認值):
    pass

例如上面的 overspeed_rate 函式， max 和 min 通常比較固定，我們可以使用一個常用值來作為默認值，

def overspeed_rate(current, max=120, min=90):
    if current > max:
        return (current - max) / max
    elif current < min:
        return (current - min) / min
    else:
        return 0

>>> overspeed_rate(192)
0.6
>>> overspeed_rate(45)
-0.5

3、關鍵字引數

對于 overspeed_rate 函式，我們還可以在函式呼叫時，以 引數名=值 的形式來向指定的引數傳入值，

如：

overspeed_rate(100, min=80)

或者

overspeed_rate(current=100, min=80)

或者

overspeed_rate(current=100, max=100, min=80)

在呼叫函式時以 引數名=值 指明要傳遞的引數，這種以關鍵字的形式來使用的引數叫做關鍵字引數，

使用關鍵字時甚至可以打亂引數傳遞次序：

overspeed_rate(min=80, max=100, current=100)

>>> overspeed_rate(min=80, max=100, current=100)
0

但要注意，關鍵字引數需要出現在位置引數之后，否則將拋出 SyntaxError 例外：

>>> overspeed_rate(100, max=100, 80)
File “”, line 1
SyntaxError: positional argument follows keyword argument

關鍵字引數的用法還不止如此，

當我們在定義函式時，如果引數串列中某個引數使用 **引數名 形式，那么這個引數可以接受一切關鍵字引數，如下：

def echo(string, **keywords):
    print(string)
    for kw in keywords:
        print(kw, ":", keywords[kw])

>>> echo(‘hello’, today=‘2019-09-04’, content=‘function’, section=3.6)
hello
today : 2019-09-04
content : function
section : 3.6

顯然，我們并沒有在函式定義時定義 today、content、section 引數，但是我們卻能接收到它們，這正是 **keywords 發揮了作用，函式會將所有接收到的關鍵字引陣列裝成一個字典，并系結到 keywords 上，驗證一下：

>>> def foo(**keywords):
… print(keywords)
…
>>> foo(a=1, b=2, c=3)
{‘a’: 1, ‘b’: 2, ‘c’: 3}

4、任意引數串列

定義函式時，在引數串列中使用 **引數名，可以接收一切關鍵字引數，類似的，引數串列中使用 *引數名，就可以接受任意數量的非關鍵字引數，也就是可變引數，

如，計算任意個數的乘積：

def multiply(*nums):
    result = 1
    for n in nums:
        result *= n
    return result

>>> multiply(1,3,5,7)
105

這個函式能接收任意個引數，這正是 *nums 所發揮的作用，函式所有接收到的非關鍵字引陣列裝成一個元組，并系結到 nums 上，來試驗一下：

>>> def multiply(*nums):
… print(nums)
…
>>> multiply(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)

5、多回傳值

典型情況下，函式只有一個回傳值，但是 Python 也支持函式回傳多個回傳值，

要回傳多個回傳值，只需在 return 關鍵字后跟多個值（依次用逗號分隔），

例如：

def date():
    import datetime
    d = datetime.date.today()
    return d.year, d.month, d.day

date() 回傳了今天的日期的年、月、日，

接收函式回傳值時，用對應回傳值數量的變數來分別接收它們，

>>> year, month, day = date()
>>> year
2019
>>> month
9
>>> day
4

函式回傳多個回傳值是什么原理呢？其實多回傳值時，Python 將這些回傳值包裝成了元組，然后將元組回傳，來驗證下：

>>> date()
(2019, 9, 4)

接識訓傳值時，year, month, day = date()，這樣賦值寫法，會將元組解包，分別將元素賦予單獨的變數中，即：

>>> year, month, day = (2019, 9, 4)
>>> year
2019
>>> month
9
>>> day
4

三、讓你函式更好用——類進階

1、類屬性和類方法

之前介紹類的時候，我們學習了物件屬性和物件方法，物件屬性和物件方法是系結在物件這個層次上的，也就是說需要先創建物件，然后才能使用物件的屬性和方法，

即：

物件 = 類()

物件.屬性
物件.方法()

除此之外，還有一種系結在類這個層面的屬性和方法，叫作類屬性和類方法，使用類屬性和類方法時，不用創建物件，直接通過類來使用，

類屬性和類方法的使用方式：

類.屬性
類.方法()

（1）類屬性的定義

類屬性如何定義呢？

只要將屬性定義在類之中方法之外即可，如下面的 屬性1 和 屬性2：

class 類：
	屬性1 = X
    屬性2 = Y
    
    def 某方法():
        pass

舉個例子:

class Char:
    letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    digits = '0123456789'

這里定義了類 Char，有兩個類屬性，這兩個類屬性分別包含所有大寫字母和所有數字，可以通過類名來使用這兩個類屬性，此時無需創建物件：

>>> Char.letters
’ABCDEFGHIJKLMNOPQRSTUVWXYZ’
>>> Char.digits
’0123456789’

當然，類所創建出來的物件也能使用類屬性：

>>> char = Char()
>>> char.letters
’ABCDEFGHIJKLMNOPQRSTUVWXYZ’
>>> char.digits
’0123456789’

（2）類方法的定義

再來看下類方法的定義方法，類方法的定義需要借助于裝飾器，裝飾器具體是什么后續文章中會介紹，目前只要知道用法即可，

定義類方法時，需要在方法的前面加上裝飾器 @classmethod，如下：

class 類:
	@classmethod
    def 類方法(cls):
        pass

注意與物件方法不同，類方法的第一個引數通常命名為 cls，表示當前這個類本身，我們可以通過該引數來參考類屬性，或類中其它類方法，

類方法中可以使用該類的類屬性，但不能使用該類的物件屬性，因為類方法隸屬于類，而物件屬性隸屬于物件，使用類方法時可能還沒有物件被創建出來，

在之前 Char 類的基礎上，我們加上隨機獲取任意字符的類方法，代碼如下：

import random

class Char:
    letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    digits = '0123456789'
	
    @classmethod
    def random_letter(cls):
        return random.choice(cls.letters)
	
    @classmethod
    def random_digits(cls):
        return random.choice(cls.digits)

方法 random_letter() 可以從屬性 letters 隨機獲取一個大寫字母；方法 random_digits() 可以從屬性 digits 隨機獲取一個數字，它們函式體中的 random.choice() 可從指定序列中隨機獲取一個元素，

>>> Char.random_digits()
‘8’
>>> Char.random_letter()
‘X’

擴展：import 陳述句不僅可用于模塊的開頭，也可用于模塊的任意位置，如函式中，

2、靜態方法

與類方法有點相似的是靜態方法，靜態方法也可直接通過類名來呼叫，不必先創建物件，不同在于類方法的第一個引數是類自身（cls），而靜態方法沒有這樣的引數，如果方法需要和其它類屬性或類方法互動，那么可以將其定義成類方法；如果方法無需和其它類屬性或類方法互動，那么可以將其定義成靜態方法，

定義靜態方法時，需要在方法的前面加上裝飾器 @staticmethod，如下：

class 類:
	@staticmethod
    def 靜態方法():
        pass

之前的例子中，我們可以從類屬性 letters 和 digits 中隨機獲取字符，如果想要自己來指定字符的范圍，并從中獲取一個隨機字符，可以再來定義一個靜態方法 random_char()，如：

import random

class Char:
    letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    digits = '0123456789'
	
    @classmethod
    def random_letter(cls):
        return random.choice(cls.letters)
	
    @classmethod
    def random_digits(cls):
        return random.choice(cls.digits)
    
    @staticmethod
    def random_char(string):
        if not isinstance(string, str):
        	raise TypeError('需要字串引數')
        
        return random.choice(string)

靜態方法 random_char 從傳入的字串中隨機挑選出一個字符，之所以定義成靜態方法，是因為它無需與類屬性互動，

>>> Char.random_char(‘imooc2019’)
‘0’
>>> Char.random_char(‘imooc2019’)
‘m’

3、私有屬性、方法

類屬性 letters 和 digits 是為了提供給同一個類中的類方法使用，但我們可以通過類或物件從類的外部直接訪問它們，比如：

Char.letters
Char.digits

>>> Char.letters
’ABCDEFGHIJKLMNOPQRSTUVWXYZ’
>>> Char.digits
’0123456789’

有時我們不想把過多的資訊暴露出去，有沒有什么方法來限制屬性不被類外部所訪問，而是只能在類中使用？

答案是有的，我們只需要在命名上動動手腳，將屬性或方法的名稱用 __（兩個下劃線）開頭即可，如：

import random

class Char:
    __letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    __digits = '0123456789'
	
    @classmethod
    def random_letter(cls):
        return random.choice(cls.__letters)
	
    @classmethod
    def random_digits(cls):
        return random.choice(cls.__digits)

從類外部訪問這兩個屬性看看：

>>> Char.__letters
Traceback (most recent call last):
File “”, line 1, in
AttributeError: type object ‘Char’ has no attribute ‘__letters’

>>> Char.__digits
Traceback (most recent call last):
File “”, line 1, in
AttributeError: type object ‘Char’ has no attribute ‘__digits’

可以看到，修改過后的屬性不能直接被訪問了，解釋器拋出 AttributeError 例外，提示類中沒有這個屬性，

但位于同一個類中的方法還是可以正常使用這些屬性：

>>> Char.random_letter()
‘N’
>>> Char.random_digits()
‘4’

像這樣以 __（兩個下劃線）開頭的屬性我們稱為私有屬性，顧名思義，它是類所私有的，不能在類外部使用，

上述是以類屬性作為示例，該規則對類方法、物件屬性、物件方法同樣適用，只需在名稱前加上 __（兩個下劃線）即可，

我們也可以使用 _（一個下劃線）前綴來宣告某屬性或方法是私有的，但是這種形式只是一種使用者間的約定，并不在解釋器層面作限制，如：

class Char:
    _letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    _digits = '0123456789'

上面的 _letters 和 _digits 也可看作私有屬性，只不過是約定上的私有，通過名稱前綴 _（一個下滑線）向使用者告知這是私有的，但你如果非要使用，依然可以用，

>>> Char._letters
’ABCDEFGHIJKLMNOPQRSTUVWXYZ’
>>> Char._digits
’0123456789’

4、特殊方法

類中以 __ 開頭并以 __ 結尾的方法是特殊方法，特殊方法有特殊的用途，它們可以直接呼叫，也可以通過一些內置函式或運算子來間接呼叫，如之前學習過的 __init__()、__next__()，

特殊方法很多，在這里我們簡單例舉幾個：

• __init__()

  __init__() 是非常典型的一個特殊方法，它用于物件的初始化，在實體化類的程序中，被自動呼叫，

• __next__()

  在迭代器章節中我們講過，對迭代器呼叫 next() 函式，便能生成下一個值，這個程序的背后，next() 呼叫了迭代器的 __next__() 方法，

• __len__()

  你可能會好奇，為什么呼叫 len() 函式時，便能回傳一個容器的長度？原因就是容器類中實作了 __len__() 方法，呼叫 len() 函式時將自動呼叫容器的 __len__() 方法，

• __str__()

  在使用 print() 函式時將自動呼叫類的 __str__() 方法，如：

  class A:
      def __str__(self):
          return '這是 A 的物件'
  

  >>> a = A()
  >>> print(a)
  這是 A 的物件`

• __getitem__()

  諸如串列、元素、字串這樣的序列，我們可以通過索引的方式來獲取其中的元素，這背后便是 __getitem__() 在起作用，

  'abc'[2] 即等同于 'abc'.__getitem__(2)，

  >>> ‘abc’[2]
  ‘c’
  >>> ‘abc’.__getitem__(2)
  ‘c’

5、類的繼承

（1）類的簡單繼承

如果想基于一個現有的類，獲取其全部能力，并以此擴展出一個更強大的類，此時可以使用類的繼承，被繼承的類叫作父類（或基類），繼承者叫作子類（或派生類），關于類的簡單繼承可以看下圖就是一個典型的例子：

在類的繼承的定義時，子類名稱的后面加上括號并寫入父類，如下：

class 父類:
    父類的實作
    
class 子類(父類)：
	子類的實作

例如：

class A:
    def __init__(self):
        self.apple = 'apple'
    
    def have(self):
        print('I hava an', self.apple)

class B(A):
	def who(self):
		print('I am an object of B')

>>> b = B()

>>> b.who()
I am an object of B

>>> b.apple
’apple’

>>> b.have()
I hava an apple

可以看到，雖然類 B 中什么都沒定義，但由于 B 繼承自 A，所以它擁有 A 的屬性和方法，

子類 B 中當然也可以定義自己的屬性，

class B(A):
	def __init__(self):
		super().__init__()
		self.banana = 'banana'

>>> b = B()
>>> b.banana
’banana’

我們在 B 中定義 __init__() 方法，并在其中定義了 B 自己的屬性 banana，

super().__init__() 這一句代碼是什么作用？由于我們在子類中定義了 __init__() 方法，這會導致子類無法再獲取父類的屬性，加上這行代碼就能在子類初始化的同時初始化父類，super() 用在類的方法中時，回傳父類物件，

子類中出現和父類同名的方法會怎么樣？答案是子類會覆寫父類的同名方法，

class A:
    def __init__(self):
        self.apple = 'apple'
    
    def have(self):
        print('I hava an', self.apple)

class B(A):
	def __init__(self):
		super().__init__()
		self.banana = 'banana'
	
	def have(self):
		print('I hava an', self.banana)

>>> b = B()
>>> b.have()
I hava an banana

（2）類的繼承鏈

子類可以繼承父類，同樣的，父類也可以繼承它自己的父類，如此一層一層繼承下去，

class A:
	def have(self):
		print('I hava an apple')

class B(A):
	pass

class C(B):
	pass

>>> c = C()
>>> c.have()
I hava an apple

在這里 A 是繼承鏈的頂端，B 和 C 都是它的子類（孫子類），

其實 A 也有繼承，它繼承自 object，任何類的根源都是 object 類，如果一個類沒有指定所繼承的類，那么它默認繼承 object，

A 中也可以顯式指明其繼承于 object ：

class A(object):
	def have(self):
		print('I hava an apple')

如果想要判斷一個類是否是另一個類的子類，可以使用內置函式 issubclass() ，用法如下：

>>> issubclass(C, A)
True
>>> issubclass(B, A)
True
>>> issubclass(C, B)
True

（3）類的多繼承

子類可以同時繼承多個父類，這樣它便擁有了多份能力，如下圖，步兵類就同時擁有士兵類和人類的屬性，就步兵類屬于多繼承，

定義時，子類名稱后面加上括號并寫入多個父類，如下：

class A:
    def get_apple(self):
        return 'apple'

class B:
    def get_banana(self):
        return 'banana'

class C(A, B):
    pass

>>> c = C()
>>> c.get_apple()
‘apple’
>>> c.get_banana()
‘banana’

此時 C 便同時擁有了 A 和 B 的能力，

四、從小獨棟升級為別墅區——函式式編程

1、函式賦值給變數

在 Python 中，所有的物件都可以賦值給變數，包括函式，這可能有點出乎意料，我們不妨來試一試：

def say_hello(name):
    return name + ', hello!'

f = say_hello

>>> f(‘開發者’)
‘開發者, hello!’

>>> f
<function say_hello at 0x10befec80>

注意，這里被賦值的是函式本身，而不是函式的結果，賦值后，變數 f 與函式 say_hello 系結，f 也就相當于是 say_hello 的別名，完全可以用呼叫 say_hello 的方式來呼叫 f，

擴展：類也可以賦值給變數，如：

class Apple:
    who_am_i = 'apple'

banana = Apple

>>> banana.who_am_i
’apple’

注意，被賦值的是類本身，而不是類實體化后的物件，賦值后，變數 banana 與類 Apple 系結，banana 也就相當于是 Apple 的別名，使用 banana 就相當于使用 Apple，

2、函式作為函式引數

一切物件都可以作為函式的引數，包括另一個函式，接受函式作為引數的函式，稱為高階函式，這和數學中的高階函式有些相似，

來看一個函式作為引數的例子，

這個例子中，我們實作了一個函式，它從給定的數字串列中篩選數字，而具體的篩選策略由另一個函式決定并以引數的形式存在：

def filter_nums(nums, want_it):
    return [n for n in nums if want_it(n)]

函式 filter_nums 用來篩選數字，它接受兩個引數，nums 是包含所有待篩選數字的串列，want_it 是一個函式，用來決定某個數字是否保留，

我們選定一個簡單的策略來實作下 want_it 引數所對應的函式（其函式名不必為 want_it）：

def want_it(num):
    return num % 2 == 0

這里 want_it 接受一個數字作為引數，如果這個數字是 2 的倍數，則回傳 True，否則回傳 False，

呼叫一下 filter_nums 試試：

>>> def filter_nums(nums, want_it):
… return [n for n in nums if want_it(n)]
…
>>> def want_it(num):
… return num % 2 == 0
…
>>> filter_nums([11, 12, 13, 14, 15, 16, 17, 18], want_it)
[12, 14, 16, 18]

這里每個數字都經過 want_it() 函式的判斷，而 want_it() 是以 filter_num() 第二個引數的形式傳遞進去，供 filter_num() 呼叫，

3、lambda 運算式

在 Python 中，可以通過 lambda 運算式來便捷地定義一個功能簡單的函式，這個函式只有實作沒有名字，所以叫作匿名函式，

lambda 運算式的寫法如下：

lambda 引數1, 引數2, 引數N: 函式實作

使用上述運算式將定義一個匿名函式，這個匿名函式可接受若干引數，引數寫在冒號前（:），多個引數時用逗號分隔，其實作寫在冒號后（:），

舉個例子：

f = lambda x: x ** 2

這個 lambda 運算式定義了一個匿名函式，這個匿名函式接受一個引數 x，回傳 x ** 2 的計算結果，同時賦值陳述句將這個匿名函式賦值給了變數 f，注意 f 保存的是函式，而不是函式結果，

>>> f
<function at 0x10bcba0d0>

>>> f(4)
16
>>> f(9)
81

通過觀察上述示例可以發現，lambda 運算式中并沒有 return 關鍵字，但結果被回傳出來，是的，匿名函式的 函式實作 的執行結果就會作為它的回傳值，無需使用 return 關鍵字，

從功能上來看，lambda x: x ** 2 等同于：

def no_name(x):
    return x ** 2

>>> no_name(4)
16

一般情況下，我們不會像 f = lambda x: x ** 2 這樣直接將匿名函式賦值給變數，然后去用這個變數，而是在需要將函式作為引數時，才去使用 lambda 運算式，這樣就無需在函式呼叫前去定義另外一個函式了，

如我們剛才寫的函式 filter_nums：

def filter_nums(nums, want_it):
    return [n for n in nums if want_it(n)]

它的 want_it 引數需要是一個函式 ，這時用 lambda 運算式便能方便的解決問題，可以像這樣來使用：

>>> filter_nums([11, 12, 13, 14, 15, 16, 17, 18], lambda x: x % 2 == 0)
[12, 14, 16, 18]

以前講內置函式的時候，我們介紹過排序函式 sorted()，它有一個引數 key，用來在排序復雜元素時，指定排序所使用的欄位，這個引數需要是個函式，同樣可以用 lambda 運算式來解決：

>>> codes = [(‘上海’, ‘021’), (‘北京’, ‘010’), (‘成都’, ‘028’), (‘廣州’, ‘020’)]
>>> sorted(codes, key=lambda x: x[1]) # 以區號字典來排序
[(‘北京’, ‘010’), (‘廣州’, ‘020’), (‘上海’, ‘021’), (‘成都’, ‘028’)]

關于Python進階的第一部分內容就和大家分享到這里，評論區留言你們的問題和見解，我們一起學習！

之后還會和大家繼續更新更多關于Python技術干貨，

感興趣的小伙伴別忘了點個關注哈！

灰小猿陪你一起進步呀！