---python基礎（二十八）：元類

原創 凤求凰的博客 2020-06-26 13:05

下面是小凰凰的簡介，看下吧！
💗人生態度：珍惜時間，渴望學習，熱愛音樂，把握命運，享受生活
💗學習技能：網絡 -> 雲計算運維 -> python全棧( 當前正在學習中)
💗您的點贊、收藏、關注是對博主創作的最大鼓勵，在此謝過！
有相關技能問題可以寫在下方評論區，我們一起學習，一起進步。
後期會不斷更新python全棧學習筆記，秉着質量博文爲原則，寫好每一篇博文。

文章目錄

鑑於本篇博文知識點較難，因此可能會有些錯誤，若有錯誤，懇請各位朋友指出，多謝各位小夥伴！

一、元類介紹

什麼是元類呢？一切源自於一句話：python中一切皆爲對象，因此類也是對象。讓我們先定義一個類，然後逐步分析：

class StanfordTeacher(object):
    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

所有的對象都是實例化或者說調用類而得到的（調用類的過程稱爲類的實例化），比如對象t1是調用類StanfordTeacher得到的

t1=StanfordTeacher('lili',18)
print(type(t1)) #查看對象t1的類是<class '__main__.StanfordTeacher'>

如果一切皆爲對象，那麼類StanfordTeacher本質也是一個對象，既然所有的對象都是調用類得到的，那麼StanfordTeacher必然也是調用了一個類得到的，這個類稱爲元類（又稱類的類）即：產生StanfordTeacher的過程一定發生了：StanfordTeacher=元類(...)

# 驗證
print(type(StanfordTeacher)) # 結果爲<class 'type'>，證明是調用了type這個元類而產生的StanfordTeacher，即默認的元類爲type

在這裏插入圖片描述
注意：光理論是不夠的,在此送大家一套2020最新Python全棧實戰視頻教程，點擊此處 進來獲取 跟着練習下，希望大家一起進步哦！

二、class關鍵字創建類的流程分析

我們應該都曉得，標誌類的關鍵字是class，那麼創建類的過程就應該是由class關鍵字引導的。
class關鍵字在幫我們創建類時，必然幫我們調用了元類StanfordTeacher=type(...)，那調用type時傳入的參數是什麼呢？必然是類的關鍵組成部分，一個類有三大組成部分，分別是：

1、類名class_name='StanfordTeacher'

2、基類們class_bases=(object,)

3、類的名稱空間class_dic，類的名稱空間是執行類體代碼而得到的

調用type時會依次傳入以上三個參數

綜上，class關鍵字幫我們創建一個類應該細分爲以下四個過程
在這裏插入圖片描述對於上圖的第3步是如何生成類名稱空間字典，做個補充：

# 整個類體代碼其實是一個字符串，把這個字符串交給exec函數，返回一個類名稱空間字典，下面爲exec詳解：
1. exec：三個參數

2. 參數一：包含一系列python代碼的字符串

3. 參數二：全局作用域（字典形式），如果不指定，默認爲globals()

4. 參數三：局部作用域（字典形式），如果不指定，默認爲locals()

5. 可以把exec命令的執行當成是一個函數的執行，會將執行期間產生的名字存放於局部名稱空間或全局名稱空間中，最後我們要的類名稱空間就是這個局部名稱空間字典。
g={ # 代表全局名稱空間，爲什麼裏面還有內容呢？
    'x':1,
    'y':2
}
l={}

exec('''
global x,z # 聲明x、z爲全局變量
x=100
z=200

m=300 # m爲局部變量
''',g,l)

print(g) # {'x': 100, 'y': 2......} # z不是全局變量嗎，爲什麼g裏面沒有呢？
print(l) # {'m': 300}

上面代碼中有人提出了兩個疑問，這是由於你沒有把參數二、三的意思整明白，問題解析如下：

# 參數二、三解析
答：參數二實際應該爲globals(),這個globals函數獲取的是當前python程序的所有全局變量，並且將其變量名和值存在字典之中，代碼中的g只是模擬globals生成的字典。參數三也一樣的

# 接下來再說爲什麼g中還有內容呢？不可以爲空嗎？
答：可以爲空，但沒有意義。global x,z，聲明的是x、z爲全局變量，那麼globals()函數執行所得到的字典，是不是應該有這兩個變量？因此我們的g模擬globals函數也應該有x、z這兩個變量。

# z不是全局變量嗎，爲什麼g裏面沒有呢？
答：上面說了g模擬globals函數也應該有x、z這兩個變量，在我們上面的程序中，其中全局變量z是沒有，因此exec函數執行後，print(g)其中沒有z，其中有y，但是值沒改變，因此print(g)還是打印原值。

四、自定義元類

爲什麼要自定義元類？

答：我們的類都是通過元類產生的，元類定義產生類這個對象的流程和規範，我們通過自定義元類，達到控制我們類的一些使用規範。比如類中必須有註釋、類名必須大寫，如果不這樣就報錯。

1、自定義元類控制類StanfordTeacher的創建

一個類沒有聲明自己的元類，默認它的元類就是type，除了使用內置元類type，我們也可以通過繼承type來自定義元類，然後使用metaclass關鍵字參數爲一個類指定元類

class Mymeta(type): # 只有繼承了type類才能稱之爲一個元類，否則就是一個普通的自定義類
    pass
											類名         父類們 類名稱空間  
# class相當於：StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
class StanfordTeacher(object,metaclass=Mymeta): # 這裏如果不寫object，會默認繼承object，但是上面的傳給Mymeta的第二個參數裏面就沒有，當然，沒寫也沒有什麼，python自己會默認傳，只是你看不到，我寫出來是爲了讓大家看到。
    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

自定義元類可以控制類的產生過程，類的產生過程其實就是元類的調用過程,即StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})，調用Mymeta會先產生一個空對象StanfordTeacher，然後連同調用Mymeta括號內的參數一同傳給Mymeta下的__init__方法，完成初始化，返回初始化後的對象，於是我們可以：

class Mymeta(type): # 只有繼承了type類才能稱之爲一個元類，否則就是一個普通的自定義類
    def __init__(self,class_name,class_bases,class_dic):
        # print(self) #<class '__main__.StanfordTeacher'>
        # print(class_bases) #(<class 'object'>,)
        # print(class_dic) #{'__module__': '__main__', '__qualname__': 'StanfordTeacher', 'school': 'Stanford', '__init__': <function StanfordTeacher.__init__ at 0x102b95ae8>, 'say': <function StanfordTeacher.say at 0x10621c6a8>}
        super().__init__(class_name, class_bases, class_dic)  # 重用父類的init功能
        
# 爲什麼要重用父類？因爲我們現在只用重用父類方法，完成基本的初始化對象，然後加上自己的限制即可！！

		# 下面爲定製類的代碼，也是對我們所做的對元類產生的類的限制
        if class_name.islower(): # 規範類名
            raise TypeError('類名%s請修改爲駝峯體' %class_name) # 主動報錯語句
            
        if '__doc__' not in class_dic or len(class_dic['__doc__'].strip(' \n')) == 0: # 規範文檔註釋
            raise TypeError('類中必須有文檔註釋，並且文檔註釋不能爲空') # 主動報錯語句

# StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
class StanfordTeacher(object,metaclass=Mymeta): 
    """
    類StanfordTeacher的文檔註釋
    """
    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

2、自定義元類控制類StanfordTeacher的調用

核心知識：__call__方法

class Foo:
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)

obj=Foo()
# 1、要想讓obj這個對象變成一個可調用的對象，需要在該對象的類中定義一個方法__call__方法，該方法會在調用對象時自動觸發
# 2、調用obj的返回值就是__call__方法的返回值
res=obj(1,2,3,x=1,y=2) # 相當於res=obj.__call__(1,2,3,x=1,y=2)，自動觸發，因此可以obj()
# 執行結果：
<__main__.Foo object at 0x10874ccd0> # print(self)
(1, 2, 3) # print(args)
{'x': 1, 'y': 2} # print(kwargs)

想一下，調用對象，執行個call方法這並沒有什麼用途，當然我也只是借調用對象，說明call的作用，引出下面這個重點，調用一個對象:obj()，就是觸發對象所在類中的__call__方法的執行，類也是對象。那麼調用一個類：StanfordTeacher(),就是觸發類的元類中的__call__方法的執行。

class Mymeta(type): #只有繼承了type類才能稱之爲一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs):
        print(self) #<class '__main__.StanfordTeacher'>
        print(args) #('lili', 18)
        print(kwargs) #{}
        return 123

class StanfordTeacher(object,metaclass=Mymeta):
    school='Stanford'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

# 調用StanfordTeacher就是在調用Mymeta類中的__call__方法
# 然後將StanfordTeacher這個對象傳給self,溢出的位置參數'lili'、18傳給*，溢出的關鍵字參數傳給**
# 調用StanfordTeacher的返回值就是調用__call__的返回值
t1=StanfordTeacher('lili',18)
print(t1) # 123

默認地，我們常說調用t1=StanfordTeacher(‘lili’,18)會做三件事

1、產生一個空對象obj

2、調用__init__方法初始化對象obj

3、返回初始化好的obj

其實這三件事就是在Mymeta類中的__call__方法中完成的。下面的代碼演示完成這三件事的過程：

class Mymeta(type): # 只有繼承了type類才能稱之爲一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
        #1、調用__new__產生一個空對象obj
        obj=self.__new__(self) # 此處的self是類StanfordTeacher，必須傳參，代表創建一個StanfordTeacher的對象obj

        #2、調用StanfordTeacher的__init__方法初始化空對象obj，
        self.__init__(obj,*args,**kwargs)

        #3、返回初始化好的對象obj
        return obj

class StanfordTeacher(object,metaclass=Mymeta):
    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

t1=StanfordTeacher('lili',18)
print(t1.__dict__) #{'name': 'lili', 'age': 18}

上例的__call__相當於一個模板，我們可以在該基礎上改寫__call__的邏輯從而控制調用StanfordTeacher的過程，比如將StanfordTeacher的對象的所有屬性都變成私有的

先看看私有屬性在dict中長啥樣：

class Foo:
    def __init__(self):
        self.__name = '123'

obj=Foo()
print(obj.__dict__)
# 執行結果
{'_Foo__name': '123'}
# 我們獲取dict裏的內容，然後所有屬性改成_Foo__name這樣子，再覆蓋回dict，就完成了對所有屬性的私有化。

class Mymeta(type): #只有繼承了type類才能稱之爲一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
        #1、調用__new__產生一個空對象obj
        obj=self.__new__(self) # 此處的self是類StanfordTeacher，必須傳參，代表創建一個StanfordTeacher的對象obj

        #2、調用__init__初始化空對象obj
        self.__init__(obj,*args,**kwargs)

        # 在初始化之後，obj.__dict__裏就有值了
        obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()} # 這裏採用了字典生成式
        
        #3、返回初始化好的對象obj
        return obj

class StanfordTeacher(object,metaclass=Mymeta):
    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

t1=StanfordTeacher('lili',18)
print(t1.__dict__) #{'_StanfordTeacher__name': 'lili', '_StanfordTeacher__age': 18}

上面的代碼中涉及到查找屬性的問題，比如self.__new__，請看第五點。

3、自定義元類的調用

class Mymeta(type): #只有繼承了type類才能稱之爲一個元類，否則就是一個普通的自定義類
    n=444
    
    def __new__(cls, *args, **kwargs):
        obj=type.__new__(cls,*args,**kwargs) # 必須按照這種傳值方式
        print(obj.__dict__)
        # return obj # 只有在返回值是type的對象時，纔會觸發下面的__init__
        return 123

    def __init__(self,class_name,class_bases,class_dic):
        print('run。。。')


class StanfordTeacher(object,metaclass=Mymeta): #StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
    n=111

    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)


print(type(Mymeta)) #<class 'type'>
# 產生類StanfordTeacher的過程就是在調用Mymeta，而Mymeta也是type類的一個對象，那麼Mymeta之所以可以調用，一定是在元類type中有一個__call__方法
# 該方法中同樣需要做至少三件事：
# class type:
#     def __call__(self, *args, **kwargs): #self=<class '__main__.Mymeta'>
#         obj=self.__new__(self,*args,**kwargs) # 調用Mymeta的new方法，產生Mymeta的一個空對象obj
#         self.__init__(obj,*args,**kwargs)  # 調用Mymeta的init方法初始化空對象obj
#         return obj

4、總結

對象()->類內的__call__
類()->自定義元類內的__call__
自定義元類()->內置元類type的__call__

# 下面是內置元類type的部分代碼
# class type:
#     def __call__(self, *args, **kwargs): #self = <class '__main__.Mymeta'>
#         obj=self.__new__(self,*args,**kwargs) # 調用的是Mymeta的new方法，但是產生的是StanfordTeacher的空對象，args中存儲的類名、基類、類名稱空間字典。
#         self.__init__(obj,*args,**kwargs) 
#         return obj

class Mymeta(type): #只有繼承了type類才能稱之爲一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs): # self = <class '__main__.StanfordTeacher'>
        print('StanfordTeacher的new方法準備運行了...')
        
        '''查看StanfordTeacher調用時，傳入的參數有哪些？
        print(self, args, kwargs) 
        self =  <class '__main__.StanfordTeacher'> 
        args = ('lili', 18) 
        kwargs = {}
        '''
        
        obj=self.__new__(self)
        print('StanfordTeacher的init方法準備運行了...')
        self.__init__(obj,*args,**kwargs)
        return obj

    def __new__(cls, *args, **kwargs):
        print('Mymeta的new方法準備運行了...')
        
        ''' 查看內置元類中的type.call中傳入的是哪些參數
        print(cls, args, kwargs) 
         cls = <class '__main__.Mymeta'> 
        				類名					基類					類名稱空間字典
         args = ('StanfordTeacher' ,  (<class 'object'>,) ,  {'__module__': '__main__', '__qualname__': 'StanfordTeacher', 'n': 111, 'school': 'Stanford', '__init__': <function StanfordTeacher.__init__ at 0x10e33fcb0>, 'say': <function StanfordTeacher.say at 0x10e33fd40>})
         kwargs = {}
        '''
        
        obj=type.__new__(cls,*args,**kwargs) # 必須按照這種傳值方式
        return obj

    def __init__(self,class_name,class_bases,class_dic):
        print('Mymeta的init方法準備運行了...')
        
        ''' 查看執行完Mymeta的new方法之後生成的對象是什麼？
        print(self,class_name,class_bases,class_dic) 
        # self = <class '__main__.StanfordTeacher'>
        # class_name = StanfordTeacher
        # class_bases = (<class 'object'>,)
        # class_dic = {'__module__': '__main__', '__qualname__': 'StanfordTeacher', 'n': 111, 'school': 'Stanford', '__init__': <function StanfordTeacher.__init__ at 0x10e33fcb0>, 'say': <function StanfordTeacher.say at 0x10e33fd40>}
        '''
        
        type.__init__(self,class_name,class_bases,class_dic)

class StanfordTeacher(object,metaclass=Mymeta): # StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
    n=111

    school='Stanford'

    def __init__(self,name,age):

        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)
obj = StanfordTeacher('lili',18)

# 運行結果：
Mymeta的new方法準備運行了...
Mymeta的init方法準備運行了...
StanfordTeacher的new方法準備運行了...
StanfordTeacher的init方法準備運行了...

執行順序解析：

# 因爲元類產生類這個對象，類這個對象又實例化產生類的對象！
# 因此產生類StanfordTeacher的過程稱之爲類對象的實例化流程，而下面這整個流程是類對象的實例對象的實例化流程
1. obj = StanfordTeacher('lili',18) # 先產生類StanfordTeacher，再調用
			👇
2. 類的產生過程其實就是元類的調用過程：StanfordTeacher=Mymeta('StanfordTeacher',(object),{類名稱空間})
			👇
3. 自定義元類的調用就是調用內置元類type的__call__：type.call('Mymeta',*args,**kwargs)，因此先執行Mymeta的new、init方法,call中傳入的參數是什麼，我們在Mymeta的new方法裏print(cls, args, kwargs)就曉得了
# 注意type.call,調用的Mymeta的new方法生成的是StanfordTeacher空對象，爲什麼？因爲args中存儲的是StanfordTeacher的類名、基類、類名稱空間字典，這個在Mymeta的init方法裏print(self)就曉得了，
			👇
5. 然後type.call返回創建好的對象給StanfordTeacher，因此產生類StanfordTeacher完成
			👇
6. 調用StanfordTeacher('lili',18)就是調用自定義元類的__call__方法：Mymeta.__call__('StanfordTeacher','lili', 18)。args是('lili', 18),kwargs接收關鍵字參數，沒有，因此是個空字典
			👇
7. 因此這個時候就該StanfordTeacher的new、init方法執行了
			👇
8. 自定義元類的__call__方法返回創建好的對象給obj

有人可能有疑問，在第2步元類調用過程，在這裏是自定義元類的調用過程，但是自定義元類也需要產生吧？然後認爲自定義元類的產生就是內置元類的調用過程。這種想法是正確的，自定義元類其實也是一個由class定義的普通類，只是我們繼承了type類，擴展type類的功能。但是我們不需要研究這麼深入，只需要享受它繼承type，帶來的擴展type元類的功能。

五、屬性查找

結合python繼承的實現原理+元類重新看屬性的查找應該是什麼樣子呢？？？

在學習完元類後，其實我們用class自定義的類也全都是對象（包括object類本身也是元類type的 一個實例，可以用type(object)查看），我們學習過繼承的實現原理，如果把類當成對象去看，將下述繼承應該說成是：對象StanfordTeacher繼承對象Foo，對象Foo繼承對象Bar，對象Bar繼承對象object

1、類查找屬性（StanfordTeacher.屬性）的順序

（1）尋找類查找屬性順序，代碼驗證
class Mymeta(type): #只有繼承了type類才能稱之爲一個元類，否則就是一個普通的自定義類
    n=444

    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
        obj=self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    n=333

class Foo(Bar):
    n=222

class StanfordTeacher(Foo,metaclass=Mymeta):
    n=111

    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)


print(StanfordTeacher.n) #自下而上依次註釋各個類中的n=xxx，運行一次，註釋一個，發現n的查找順序爲StanfordTeacher->Foo->Bar->object->Mymeta->type

於是屬性查找應該分成兩層，一層是繼承類查找（基於c3算法的MRO）的查找，另外一個層則是元類層的查找。

#查找順序：
#1、先對象層：StanfordTeacher->Foo->Bar->object
#2、然後元類層：Mymeta->type
（2）類查找屬性順序圖解

在這裏插入圖片描述

（2）元類Mymeta中__call__裏的self.__new__的屬性查找

依據上述總結，我們來分析下元類Mymeta中__call__裏的self.__new__的查找，注意self就是一個類，所以是符合類查找屬性的順序的：

class Mymeta(type): 
    n=444

    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
        obj=self.__new__(self)
        print(self.__new__ is object.__new__) #True


class Bar(object):
    n=333

    # def __new__(cls, *args, **kwargs):
    #     print('Bar.__new__')

class Foo(Bar):
    n=222

    # def __new__(cls, *args, **kwargs):
    #     print('Foo.__new__')

class StanfordTeacher(Foo,metaclass=Mymeta):
    n=111

    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)


    # def __new__(cls, *args, **kwargs):
    #     print('StanfordTeacher.__new__')


StanfordTeacher('lili',18) #觸發StanfordTeacher的類中的__call__方法的執行，進而執行self.__new__開始查找

總結：Mymeta下的__call__裏的self.__new__在StanfordTeacher、Foo、Bar裏都沒有找到__new__的情況下，會去找object裏的__new__，而object下默認就有一個__new__，所以即便是之前的類均未實現__new__,也一定會在object中找到一個，根本不會、也根本沒必要再去找元類Mymeta->type中查找__new__

注意：

1. 對於上面的代碼。我們在其他繼承類並沒有new方法，相當於我們直接用的object的new方法，因此我們在元類的__call__中也可以直接用object.__new__(self)去造對象
2. 但我們還是推薦在__call__中使用self.__new__(self)去創造空對象，因爲這種方式會檢索三個類StanfordTeacher->Foo->Bar,而object.__new__則是直接跨過了他們三個

2、對象查找屬性順序

（1）何爲對象查找屬性順序？
obj = StanfordTeacher('lili',18)
print(obj.n) # obj這個對象查找屬性n的值
（2）尋找對象查找屬性的順序，代碼驗證
class Mymeta(type): #只有繼承了type類才能稱之爲一個元類，否則就是一個普通的自定義類
    n=444

    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
        obj=self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    #n=333
    pass
class Foo(Bar):
    # n=222
    pass
class StanfordTeacher(Foo,metaclass=Mymeta):
    # n=111
    school='Stanford'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Stanford to learn Python' %self.name)

obj = StanfordTeacher('lili',18)
print(obj.n)

上述代碼運行發現報錯：
在這裏插入圖片描述這是爲什麼呢？

答：因爲對象的屬性查找不會到元類去找，只會在繼承體系中的類去找！因此它說沒有這個屬性n。
（3）對象屬性查找順序圖解

在這裏插入圖片描述 注意：最後送大家一套2020最新企業Pyhon項目實戰視頻教程，點擊此處 進來獲取 跟着練習下，希望大家一起進步哦！

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Python3網絡編程--socket編程之Tcp編程

目錄 1：Python3中socket編程介紹 2：簡單的點對點 3：併發服務端 3.1：創建線程處理 3.2：socketserver模塊處理 3.3：使用select模塊 4：socket實現web服務器 4.1：簡單web服務器 4

python编程汇 2020-07-08 10:32:36

Python3中內置函數

目錄 1：查看內置函數及函數說明 2：內置函數 2.1 map 2.2 filter 2.3 zip 2.4 sorted 排序 1：查看內置函數及函數說明 Python3中有哪些內置函數呢？可以使用下面代碼查看： print([ite

python编程汇 2020-07-02 01:23:39

Python3中函數基礎

函數是對功能或者動作的封裝，它的主要目的是：最大化代碼重用和最小化代碼冗餘，以及對複雜過程的分解。 1：函數的定義與調用 在Python中使用如下的語法進行定義一個函數： def name(arg1,arg2,... argN):

python编程汇 2020-07-02 01:23:39

Python3中函數進階

1：動態傳參 首先看下下列代碼，實現對2個整數進行求和 運算；如果只有兩個參數的話，函數m_sum是能夠很好地運行，但是如果要對3個，4個甚至更多的整數進行求和運算時，函數m_sum將不能工作。 def m_sum(a,b): ret

python编程汇 2020-07-02 01:23:39

Python3中的迭代器

1：for循環遍歷 在Python中for循環可以用於遍歷任何序列類型，包括列表，元組，字符串，但是不能用與遍歷整數，代碼如下： # 遍歷列表 t = [1,2,3] for x in t: print(x) # 遍歷元組 t =

python编程汇 2020-07-02 01:23:39

Python3中的if語句

1：if語句 Python中的if語句是選擇操作來執行，其語法形式如下： if test1: statements1 elif test2: # 是可選的 statements2 elif test3:

python编程汇 2020-07-02 01:23:39

Python3中的遞歸函數

目錄 1：遞歸函數 2：遞歸函數的最大深度 3：重置遞歸函數的最大深度 4遞歸函數示例 4.1 計算階乘 n!  4.2:斐波納契數列 4.3：求x的n次方 1：遞歸函數 遞歸函數就是在函數中調用它自身，其主要用於將複雜問題分解爲多個子問

python编程汇 2020-07-02 01:23:39

Python3中的for循環語句

       Python中for循環是一個通用的序列迭代器：它可以遍歷任何有序序列和其他可迭代對象內的元素。for循環可用於字符串，列表，元組或其他內置可迭代對象。 其語法形式如下： """ 當運行for循環時，會逐個將可迭代對象ob

python编程汇 2020-07-02 01:23:39

Python3中的推導式

目錄 1：推導式介紹 2：列表推導式 2.1創建列表 2.2：對列表操作 2.3：嵌套for 2.4：帶if 3：字典推導式 4：集合推導式 5：元組沒有推導式 1：推導式介紹 python3中推導式提供了一種簡明快速的方法來創建列表、

python编程汇 2020-07-02 01:23:29

Python3中的閉包

1：閉包的定義 首先看下面代碼： def outer(): x = 100 def inner(): print(x) return inner ret = outer() ret() """ 輸出： 100 """

python编程汇 2020-07-02 01:23:29

Python3面向對象-運算符重載

目錄 1：運算符重載介紹 2：Python3中常見運算符重載方法 3：運算符重載方法示例 3.1：索引和分片:__getitem__和__setitem__ 3.2：返回數值:__index__   （__index__不是索引） 3.3

python编程汇 2020-07-02 01:23:29

Python3中異常處理和try/except,try/finally的用法

目錄 1：Python3中異常處理介紹 2：異常處理語句 2.1：try/except/else捕獲指定的異常： 2.2：try/finally 2.3：raise：引發異常 2.4：with/as:上下文管理器 3：Python中常見異

python编程汇 2020-07-02 01:23:29

Python3之excel操作--openpyxl模塊

目錄 1：openpyxl模塊介紹     2： openpyxl模塊安裝  3：openpyxl模塊常用操作 3.1：獲取工作表 3.2：行操作 3.3：列操作 3.4：單元格操作 3.5：寫excel文件，合併單元格，樣式處理，設置公

python编程汇 2020-07-02 01:23:29

Python3僞私有屬性

目錄 1：僞私有屬性介紹  2：雙下劃線：僞私有屬性實現過程 1：僞私有屬性介紹  在Python中一切都是對象，並且類的所有屬性和方法都是公有的(public)，並不存在private 關鍵字來聲明私有方法或屬性。那麼在Python中怎

python编程汇 2020-07-02 01:23:29

Python3中的生成器表達式

與生成器函數一樣，生成器表達式也是Python中的一種延遲工具。 生成器表達式的定義         從語法上，生成器表達式與一般的列表推導式一樣，並且支持列表推導的語法（if選擇和循環嵌套），不同的是生成器表達式包括在圓括號中，而列表推

python编程汇 2020-07-02 01:23:29