摘要：測試對象是否為某類型返回以內(nèi)的倍數(shù)返回是一堆或者當(dāng)為偶數(shù)時(shí)生成一個(gè)新列表將其加入中的，就是用定義的一個(gè)匿名函數(shù)，并通過函數(shù)，將其應(yīng)用到列表中的每個(gè)元素。

在Python中，函數(shù)必須先聲明，然后才能調(diào)用它，使用函數(shù)時(shí)，只要按照函數(shù)定義的形式，向函數(shù)傳遞必需的參數(shù)，就可以調(diào)用函數(shù)完成相應(yīng)的功能或者獲得函數(shù)返回的處理結(jié)果。

如果函數(shù)有返回值，那么需要在函數(shù)中使用return語句返回計(jì)算結(jié)果，聲明函數(shù)的一般形式如下。

def <函數(shù)名 > (參數(shù)列表）：
　　 <函數(shù)語句>
　 　return <返回值>
　 　
其中參數(shù)列表和返回值不是必須的，return后也可以不跟返回值，甚至連return也沒有。對于return后沒有返回值的和沒有return語句的函數(shù)都會(huì)返回None值。
有些函數(shù)可能既不需要傳遞參數(shù)，也沒有返回值。

def tpl_sum( T )：
　　   result = 0
　　   for i in T:
　　      result += i
　   　return result

聲明一個(gè)參數(shù)具有默認(rèn)值的函數(shù)形式如下。

　　def <函數(shù)名> (參數(shù)=默認(rèn)值）：
　 　<語句>

聲明了一個(gè)帶默認(rèn)值參數(shù)的函數(shù)，代碼如下：

def hello (name="Python"):
　　   print ("你好,%s!" % name）
　　print ("無參數(shù)調(diào)用時(shí)的輸出：")
　　hello()
　　print ("有參數(shù)("Jonson")調(diào)用時(shí)的輸出："）
　　hello("Jonson")

調(diào)用函數(shù)提供參數(shù)時(shí)，按順序傳遞的參數(shù)要位于關(guān)鍵字參數(shù)之前，而且不能有重復(fù)的情況。

在自定義函數(shù)時(shí)，如果參數(shù)名前加上一個(gè)星號(hào)“*”，則表示該參數(shù)就是一個(gè)可變長參數(shù)。在調(diào)用該函數(shù)時(shí)，如果依次序?qū)⑺械钠渌兞慷假x予值之后，剩下的參數(shù)將會(huì)收集在一個(gè)元組中，元組的名稱就是前面帶星號(hào)的參數(shù)名。

def change_para_num (*tp1):
　　   print (type (tp1))             #輸出tp1變量的類型
　　   print (tp1)

　　change_para_num (1)
　　change_para_num (1,2,3)

當(dāng)自定義函數(shù)時(shí)，參數(shù)中含有前面所介紹的三種類型的參數(shù)，則一般來說帶星號(hào)的參數(shù)應(yīng)放在最后。當(dāng)帶星號(hào)的參數(shù)放在最前面時(shí)，仍然可以正常工作，但調(diào)用時(shí)后面的參數(shù)必須以關(guān)鍵字參數(shù)方式提供，否則因其后的位置參數(shù)無法獲取值而引發(fā)錯(cuò)誤。

def change_para_num(*tpl,a,b=0,,**dict):
　　   print("tp1:",tp1)
　　   print("dict",dict)
　　   print("a:",a)
　　   print ("b:",b)

　　change_para_num (1,2,3,a=5,c=1,d=2,e=3) #c d e 會(huì)以字典的形式儲(chǔ)存
　　change_para_num(1,2,3)             #該調(diào)用會(huì)出錯(cuò)，a變量沒有默認(rèn)值，也不能獲取值

如果要收集不定數(shù)量的關(guān)鍵字參數(shù)可以在自定義函數(shù)時(shí)的參數(shù)前加兩顆星即**valuename，可以以字典的方式被收集到變量valuename之中。

def cube (name, **nature):
        all_nature = {"x":1,
                      "y":1,
                      "z":1,
                      "color":"white",
                      "weight":1}
        all_nature.update (nature)
        print (name,"立方體的屬性:")
        print ("體積:",all_nature ["x"]*all_nature ["y"]*all_nature ["z"])
        print ("顏色:",all_nature ["color"])
        print ("重量:",all_nature ["weight"])

cube ("first")                                    #只給出必要參數(shù)的調(diào)用
cube ("second",y=3, color="red")                  #提供部分可選參數(shù)
cube ("third", z=2, color="green", weight=10)     #提供部分可選參數(shù)

前面使用函數(shù)調(diào)用時(shí)提供的參數(shù)都是位置參數(shù)和關(guān)鍵字參數(shù)，實(shí)際上調(diào)用函數(shù)時(shí)還可以把元組和字典進(jìn)行拆解調(diào)用。

拆解元組提供位置參數(shù)；

拆解字典提供關(guān)鍵字參數(shù)。

調(diào)用時(shí)使用拆解元組的方法是在調(diào)用時(shí)提供的參數(shù)前加一個(gè)*號(hào)；要拆解字典必須在提供的調(diào)用參數(shù)前加兩個(gè)*號(hào)。

def mysum (a,b)：
　　   return a+b

　　print ("拆解元組調(diào)用："）
　　print (mysum(* (3,4)))              #調(diào)用時(shí)拆解元組作為位置參數(shù)
　　print ("拆解字典調(diào)用："）
　　print (mysum(**{"a":3, "b":4})      #調(diào)用時(shí)拆解字典作為關(guān)鍵字參數(shù)

Python中的元素有可變和不可變之分，如整數(shù)、浮點(diǎn)數(shù)、字符串、元組等都屬于不可變的；而列表和字典都屬于可變的。

列表和字典的可變也是很好理解的，即它們可以增減元素、修改元素的值。那么整數(shù)、浮點(diǎn)數(shù)、字符串等為什么是不可變的呢？
“=”號(hào)的作用是將對象引用與內(nèi)存中某對象進(jìn)行綁定，既然整數(shù)是不可變的，那么怎么改變一個(gè)指向整數(shù)的變量的值的呢？答案是直接在內(nèi)存中創(chuàng)建一個(gè)新的整數(shù)值，然后將變量引用與其綁定，這雖然本質(zhì)上的其他高級語言不同，但在使用上是看不出什么差別的，但若將其提供給函數(shù)作為參數(shù)，則效果不同。

在函數(shù)調(diào)用時(shí)，若提供的是不可變參數(shù)，那么在函數(shù)內(nèi)部對其修改時(shí)，在函數(shù)外部其值是不變的；若提供是可變參數(shù)，則在函數(shù)內(nèi)部對它修改時(shí)，在函數(shù)外部其值也會(huì)改變的。

def change (aint, alst):              #定義函數(shù)
        aint = 0                      #修改 aint 值
        alst[0]=0                     #修改alst第1個(gè)值為0
        alst.append (4)               #在 alst 中添加一個(gè)元素4
        print ("函數(shù)中aint:", aint)    #輸出函數(shù)中的aint的值
        print ("函數(shù)中alst:", alst)    #輸出函數(shù)中的alst的值

aint = 3
alst = [1,2,3]
print ("調(diào)用前aint:", aint)
print ("調(diào)用前 alst:", alst)
change(aint, alst)
print ("調(diào)用后aint:", aint)      #調(diào)用后值和調(diào)用前值相同
print ("調(diào)用后alst:", alst)      #調(diào)用后值和調(diào)用前值不同

 def myfun (lst= []):     #定義有一個(gè)默認(rèn)值為空列表的參數(shù)
    lst.append("abc")
    print (lst)
#此后三次調(diào)用自定義函數(shù)
myfun()
myfun()
myfun()
#每次調(diào)用函數(shù)按默認(rèn)值的理解，應(yīng)該每次傳入空列表，列表中只有一個(gè)元素"abc"
#在該函數(shù)的域上lst是已經(jīng)存在的，在一個(gè)線程內(nèi)多次執(zhí)行會(huì)保留上一次執(zhí)行的值。

def myfun (lst=None):       #定義有一個(gè)默認(rèn)值為空列表的參數(shù)
        lst = [] if lst is None else lst
        lst.append("abc")
        print (lst)

myfun()
myfun()
myfun()
#增加一條推導(dǎo)語句，將lst置空，就可以達(dá)到想要的效果。

內(nèi)置作用域：Python預(yù)先定義的；

全局作用域：所編寫的整個(gè)程序；

局部作用域：某個(gè)函數(shù)內(nèi)部范圍。

每次執(zhí)行函數(shù)，都會(huì)創(chuàng)建一個(gè)新的命名空間，這個(gè)新的命名空間就是局部作用域，同一函數(shù)不同時(shí)間運(yùn)行，其作用域是獨(dú)立的，不同的函數(shù)也可以具有相同的參數(shù)名，其作用域也是獨(dú)立的。
在函數(shù)內(nèi)已經(jīng)聲明的變量名，在函數(shù)以外依然可以使用。并且在程序運(yùn)行的過程中，其值并不相互影響。

def myfun():
        a = 0                   #函數(shù)內(nèi)聲明并初始化變量a為整數(shù)，局部作用域
        a += 3                  #修改a的值
        print ("函數(shù)內(nèi)a:", a)    #輸出函數(shù)內(nèi)a的值

a = "external"             #全局作用域內(nèi)a聲明并初始化

print ("全局作用域a:", a)
myfun()                    #調(diào)用函數(shù)myfun()
print("全局作用域a:", a)

#總結(jié)：函數(shù)內(nèi)部聲明的a和外部聲明的a在各自的域上互不干擾！

#那么如何在函數(shù)內(nèi)使用全局作用域的變量呢？
    def myfun():
        global a             #增加此語句
        a = 0
        a += 3
        print ("函數(shù)內(nèi)a:", a)

a = "external"
print ("全局作用域a:",a)
myfun()
print ("全局作用域a:", a)

在局部作用域內(nèi)可以引用全局作用域內(nèi)的變量，但不可以修改它。

比如以下代碼是沒有錯(cuò)誤的：

　a = 3 #定義全局變量
　　def myprint(): #聲明函數(shù)myprint()
　　 print (a) #引用全局變量

運(yùn)行函數(shù)myprint()時(shí)，會(huì)輸出全局變量a的值3。但是若將其改為則會(huì)引發(fā)錯(cuò)誤：

　a = 3 #定義全局變量
　　def myprint(): #聲明函數(shù)myprint()
　　 print (a) #引用全局變量
　　 a = 5

以上代碼引發(fā)的錯(cuò)誤是局部變量在分配前不能引用，原因是與Python中的變量查找有關(guān)，在此外代碼中函數(shù)內(nèi)聲明了a變量并初始化，所以a被判為局部變量，但卻之前在print（a）中引用了它。

Python中的變量查找:

語法形式如下:
lambda params：expr

其中params相當(dāng)于聲明函數(shù)時(shí)的參數(shù)列表中用逗號(hào)分隔的參數(shù)，expr是函數(shù)要返回值的表達(dá)式，而表達(dá)式中不能包含其他語句，也可以返回元組（要用括號(hào)），還允許在表達(dá)式中調(diào)用其他函數(shù)。

lambda的示例代碼：

import math
s = lambda x1, y1, x2, y2:math. sqrt( (x1-x2) **2+(y1-y2) **2)
s(1,1,0,0)
#結(jié)果:1.4142135623730951

代碼的第二行定義了一個(gè)求兩坐標(biāo)點(diǎn)距離的匿名函數(shù)，并用s引用，之后調(diào)用它來求（1，1）與（0，0）坐標(biāo)點(diǎn)的距離，結(jié)果為1.414。

這里的params是參數(shù)列表。它的結(jié)構(gòu)與Python中函數(shù)(function)的參數(shù)列表是一樣的。具體來說，argument_list可以有非常多的形式。例如：

 

  a, b
  a=1, b=2
  *args
  **kwargs
  a, b=1, *args

這里的expr是一個(gè)關(guān)于參數(shù)的表達(dá)式。表達(dá)式中出現(xiàn)的參數(shù)需要在argument_list中有定義，并且表達(dá)式只能是單行的。以下都是合法的表達(dá)式：

1

None

a + b

sum(a)

1 if a >10 else 0

下面是一些lambda函數(shù)示例：

lambda x, y: x*y；函數(shù)輸入是x和y，輸出是它們的積x*y

lambda:None；函數(shù)沒有輸入?yún)?shù)，輸出是None

lambda *args: sum(args); 輸入是任意個(gè)數(shù)的參數(shù)，輸出是它們的和(隱性要求是輸入?yún)?shù)必須能夠進(jìn)行加法運(yùn)算)

lambda **kwargs: 1；輸入是任意鍵值對參數(shù)，輸出是1

簡單匿名函數(shù)　寫起來快速而簡單，省代碼；

不復(fù)用的函數(shù)　在有些時(shí)候需要一個(gè)抽象簡單的功能，又不想多帶帶定義一個(gè)函數(shù)；

為了代碼清晰　有些地方使用它，代碼更清晰易懂。

比如在某個(gè)函數(shù)中需要一個(gè)重復(fù)使用的表達(dá)式，就可以使用lambda來定義一個(gè)匿名函數(shù)，多次調(diào)用時(shí)，就可以少寫代碼，但條理清晰。

沒有導(dǎo)入任何模塊或包時(shí)Python運(yùn)行時(shí)提供的函數(shù)稱為內(nèi)建函數(shù)

print(list(filter(lambda x:True if x % 3 == 0 else False, range(100)))) #返回100以內(nèi)3的倍數(shù)
print(list(map(lambda x:True if x % 3 == 0 else False, range(100))))#返回是一堆true或者false
print(list(filter (lambda x:x % 2, alst)))#當(dāng)x為偶數(shù)時(shí)生成一個(gè)新列表將其加入
print(list (map (lambda x:2*x,alst)))#list（map（lambda x:2*x,alst））中的lambda x:2*x，就是用lambda定義的一個(gè)匿名函數(shù)，并通過map()函數(shù)，將其應(yīng)用到alst列表中的每個(gè)元素。

class <類名>(父類名):
　　   pass

class MyClass():
    "pass"

myclass=MyClass()
help(MyClass)           輸出MyClass的幫助信息
print(myclass.__doc__)  輸出類的描述信息為pass

類中的方法定義和調(diào)用與函數(shù)定義和調(diào)用的方式基本相同，其區(qū)別有：

方法的第一個(gè)參數(shù)必須是self，而且不能省略

方法的調(diào)用需要實(shí)例化類，并以實(shí)例名．方法名（參數(shù)列表）形式調(diào)用；

整體進(jìn)行一個(gè)單位的縮進(jìn)，表示其屬于類體中的內(nèi)容。

class Demolnit：

def __init__(self,x,y=0):      #定義構(gòu)造方法，具有兩個(gè)初始化
    self.x = x
    self.y = y

def mycacl (self):             #定義應(yīng)用初始化數(shù)據(jù)的方法
      return self.x + self.y

def info (self):             #定義一個(gè)類方法info()
    print ("我定義的類！")

def mycacl_2 (self,x,y):       #定義一個(gè)類方法mycacl()
    return x + y
    
dia = Demolnit (3)                #用一個(gè)參數(shù)實(shí)例化類
print ("調(diào)用mycacl方法的結(jié)果1:")
print (dia.mycacl())

dib = Demolnit (3, 7)             #用二個(gè)參數(shù)實(shí)例化類
print ("調(diào)用mycacl方法的結(jié)果2:")
print (dib.mycacl())

def coord_chng(x,y):                 #定義一個(gè)全局函數(shù)，模擬坐標(biāo)值變換
        return (abs (x),abs (y))          #將x,y值求絕對值后返回

class Ant: #定義一個(gè)類Ant

        def __init__(self,x=0,y=0):       #定義一個(gè)構(gòu)造方法
            self.x = x
            self.y = y
            self.disp_point()              #構(gòu)造函數(shù)中調(diào)用類中的方法disp_point()


        def move (self,x, y):            #定義一個(gè)方法move()
            x,y = coord_chng(x,y)         #調(diào)用全局函數(shù)，坐標(biāo)變換
            self.edit_point (x, y)        #調(diào)用類中的方法edit_point()
            self.disp_point()             #調(diào)用類中的方法disp_point()

        def edit_point (self, x,y):      #定義一個(gè)方法
            self.x += x
            self.y += y

        def disp_point (self):          #定義一個(gè)方法
            print ("當(dāng)前位置:(%d,%d)" % (self .x, self.y))

ant_a = Ant()                      #實(shí)例化Ant()類
ant_a.move(2,4)                   #調(diào)用ant_a實(shí)例的方法move()
ant_a.move (-9, 6)                #調(diào)用ant_a實(shí)例的方法move()

類的屬性有兩類：

實(shí)例屬性；

類屬性。

實(shí)例屬性即同一個(gè)類的不同實(shí)例，其值是不相關(guān)聯(lián)的，也不會(huì)互相影響的，定義時(shí)使用“self.屬性名”，調(diào)用時(shí)也使用它；
類屬性則是同一個(gè)類的所有實(shí)例所共有的，直接在類體中獨(dú)立定義，引用時(shí)要使用“類名.類變量名”形式來引用，只要是某個(gè)實(shí)例對其進(jìn)行修改，就會(huì)影響其他的所有這個(gè)類的實(shí)例。

class Demo_Property: #定義類
    class_name = "Demo_Property"            #類屬性

    def __init__(self,x=0):
        self.x = x                           #實(shí)例屬性

    def class_info (self):                  #輸出信息的方法
        print ("類變量值:", Demo_Property.class_name)
        print ("實(shí)例變量值：", self.x)

    def chng (self,x):                      #修改實(shí)例屬性的方法
        self.x = x                           #注意實(shí)例屬性的引用方式

    def chng_cn (self, name):               #修改類屬性的方法
        Demo_Property.class_name = name      #注意類屬性引用方式

dpa = Demo_Property()                      #實(shí)例化類
dpb = Demo_Property()                      #實(shí)例化類
print ("初始化兩個(gè)實(shí)例")
dpa.class_info()
dpb.class_info()
print ("修改實(shí)例變量")
print ("修改dpa實(shí)例變量")
dpa.chng(3)
dpa.class_info()
dpb.class_info()
print ("修改dpb實(shí)例變量")
dpb.chng(10)
dpa.class_info()
dpb.class_info()
#這里得到實(shí)例變量是屬于每個(gè)對象自己的。
print ("修改類變量")
print ("修改dpa類變量")
dpa.chng_cn("dpa")
dpa.class_info()
dpb.class_info()
print ("修改dpb實(shí)例變量")
dpb.chng_cn("dpb")
dpa.class_info()
dpb.class_info()
#這里得到類變量是屬于每個(gè)對象共有的，一旦修改每個(gè)對象的類變量都會(huì)相應(yīng)的改變。

綜上：對于實(shí)例屬性來說，兩個(gè)實(shí)例之間互不聯(lián)系，它們各自可以被修改為不同的值；對于類屬性來說，無論哪個(gè)實(shí)例修改了它，會(huì)導(dǎo)致所有實(shí)例的類屬性的值發(fā)生變化。

類的屬性有類屬性和實(shí)例屬性之分，類的方法也有不同的種類，主要有：

實(shí)例方法；

類方法；

靜態(tài)方法。

前文中定義的所有類中的方法都是實(shí)例方法，其隱含調(diào)用參數(shù)是類的實(shí)例。類方法隱含調(diào)用參數(shù)則是類，靜態(tài)方法沒有隱含調(diào)用參數(shù)。類方法和靜態(tài)方法的定義方式都與實(shí)例方法不同，它們的調(diào)用方式也不同。

靜態(tài)方法定義時(shí)應(yīng)使用裝飾器@staticmethod進(jìn)行修飾，是沒有默認(rèn)參數(shù)的。類方法定義時(shí)應(yīng)使用裝飾器@classmethod進(jìn)行修飾，必須有默認(rèn)參數(shù)“cls”。它們的調(diào)用方式可以直接由類名進(jìn)行調(diào)用，調(diào)用前也可以不實(shí)例化類，當(dāng)然也可以用該類的任一個(gè)實(shí)例來進(jìn)行調(diào)用。

class DemoMthd:                   #定義一個(gè)類

    @staticmethod                  #靜態(tài)方法的裝飾器
    def static_mthd():            #靜態(tài)類定義
        print ("調(diào)用了靜態(tài)方法！")

    @classmethod                   #類方法的裝飾器
    def class_mthd(cls):          #類方法定義，帶默認(rèn)參數(shù)cls
        print ("調(diào)用了類方法！")

DemoMthd.static_mthd()            #未實(shí)例化類，通過類名調(diào)用靜態(tài)方法
DemoMthd.class_mthd()             #未實(shí)例化類，通過類名調(diào)用類方法
dm = DemoMthd()                   #實(shí)例化類
dm.static_mthd()                  #通過類實(shí)例調(diào)用靜態(tài)方法
dm.class_mthd()                   #通過類實(shí)例雅爾塔類方法

類是可以繼承的，并且也給出了繼承類的代碼格式。子類繼承了父類之后，就具有了父類的屬性與方法，但不能繼承父類的私有屬性和私有方法（屬性名或方法名前綴為兩個(gè)下畫線的__），子類中還可以重載來修改父類的方法，以實(shí)現(xiàn)與父類不同的行為表現(xiàn)或能力。

演示了方法的重寫和添加

class Ant:                                    #定義類Ant

    def __init__(self,x=0,y=0,color="black"):#定義構(gòu)造方法
        self.x = x
        self.y = y
        self.color =color

    def __crawl (self,x,y):                     #定義方法（模擬爬行）
        self.x = x
        self.y = y
        print ("爬行...")
        self.info()

    def info(self):
        print ("當(dāng)前位置：(%d,%d)" % (self.x, self.y))

    def attack (self):                       #定義方法（模擬攻擊）
        print ("用嘴咬！")

class FlyAnt(Ant):                          #定義FlyAnt類，繼承Ant類

    def attack (self):                      #修改行為（攻擊方法不同）
        print ("用尾針！")

    def fly(self,x,y):                       #定義方法（模擬飛行）
        print ("飛行...")
        self.x = x
        self.y = y
        self.info()

flyant = FlyAnt (color="red")               #實(shí)例化類
flyant.crawl(3,5)                            #__crawl此時(shí)會(huì)報(bào)錯(cuò)無法繼承父類實(shí)例方法
#flyant.crawl(3,5)                           #調(diào)用方法（模擬爬行）
flyant.fly(10,14)                           #調(diào)用訪求（模擬飛行）
flyant.attack() 

                        #調(diào)用方法（模擬攻擊）

在面向?qū)ο缶幊痰恼Z言中，有的允許多重繼承，即一個(gè)類可以繼承多個(gè)類；有的只允許單一繼承，即一個(gè)類只能繼承一個(gè)類，而Python中則允許多重繼承。

多重繼承的方式是在類定義時(shí)的繼承父類的括號(hào)中，以“,”分隔開要多重繼承的父類即可。而多重繼承時(shí)，繼承順序也是一個(gè)很重要的要素，如果繼承的多個(gè)父類中有相同的方法名，但在類中使用時(shí)未指定父類名，則Python解釋器將從左至右搜索，即調(diào)用先繼承的類中的同名方法。

當(dāng)子類繼承父類時(shí)，子類如果要想修改父類的行為，則應(yīng)使用方法重載來實(shí)現(xiàn)，方法重載的基本方法是在子類中定義一個(gè)和所繼承的父類中需要重載方法同名的一個(gè)方法即可。

多重繼承中，兩個(gè)父類都具有同名方法info()，但在子類中也定義了一個(gè)info()方法，即info()方法被重載了。當(dāng)子類實(shí)例調(diào)用info()方法時(shí)，就會(huì)直接調(diào)用該實(shí)例中定義的info()方法，而不會(huì)去調(diào)用任何一個(gè)父類的info()方法。

綜合來講一個(gè)同名方法先找子類，然后父類由先繼承到后繼承。

裝飾器重載：

import functools
import locale
from urllib import request

# 函數(shù)重載
@functools.singledispatch
def fun(arg, verbose=False):
    if verbose:
        print("Let me just say,", end=" ")
    print(arg)

@fun.register(int)
def _(arg, verbose=False):
    if verbose:
        print("Strength in numbers, eh?", end=" ")
    print(arg)

@fun.register(list)
def _(arg, verbose=False):
    if verbose:
        print("Enumerate this:")
    for i, elem in enumerate(arg):
        print(i, elem)

print("函數(shù)重載")
fun("test.", verbose=True)
fun(42, verbose=True)
fun(["spam", "spam", "eggs", "spam"], verbose=True)
fun({"a":"txt","b":"dat"}, verbose=True)