【Python基礎】09-07 元類

2021-03-02 上海老男孩教育

目錄一 元類介紹二 class關鍵字創建類的流程分析四 自定義元類控制類StanfordTeacher的創建五 自定義元類控制類StanfordTeacher的調用五 再看屬性查找六 作業


               ✦ ✦ ✦ ✦ ✦ ✦一 元類介紹

什麼是元類呢？一切源自於一句話：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
插圖：元類與類、對象的關係
二 class關鍵字創建類的流程分析
上文我們基於python中一切皆為對象的概念分析出：我們用class關鍵字定義的類本身也是一個對象，負責產生該對象的類稱之為元類（元類可以簡稱為類的類），內置的元類為type
class關鍵字在幫我們創建類時，必然幫我們調用了元類StanfordTeacher=type(...)，那調用type時傳入的參數是什麼呢？必然是類的關鍵組成部分，一個類有三大組成部分，分別是
1、類名class_name='StanfordTeacher'
2、基類們class_bases=(object,)
3、類的名稱空間class_dic，類的名稱空間是執行類體代碼而得到的
調用type時會依次傳入以上三個參數
綜上，class關鍵字幫我們創建一個類應該細分為以下四個過程
插圖：元類原理之類的創建流程
補充：exec的用法
#exec：三個參數

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

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

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

#可以把exec命令的執行當成是一個函數的執行，會將執行期間產生的名字存放於局部名稱空間中
g={
    'x':1,
    'y':2
}
l={}

exec('''
global x,z
x=100
z=200

m=300
''',g,l)

print(g) #{'x': 100, 'y': 2,'z':200,.}
print(l) #{'m': 300}
三 自定義元類控制類StanfordTeacher的創建
一個類沒有聲明自己的元類，默認他的元類就是type，除了使用內置元類type，我們也可以通過繼承type來自定義元類，然後使用metaclass關鍵字參數為一個類指定元類
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    pass

# StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})
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('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(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父類的功能

        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)
四 自定義元類控制類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)
由上例得知，調用一個對象，就是觸發對象所在類中的__call__方法的執行，如果把StanfordTeacher也當做一個對象，那麼在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就是在調用StanfordTeacher類中的__call__方法
# 然後將StanfordTeacher傳給self,溢出的位置參數傳給*，溢出的關鍵字參數傳給**
# 調用StanfordTeacher的返回值就是調用__call__的返回值
t1=StanfordTeacher('lili',18)
print(t1) #123
默認地，調用t1=StanfordTeacher('lili',18)會做三件事
1、產生一個空對象obj
2、調用__init__方法初始化對象obj
3、返回初始化好的obj
對應著，StanfordTeacher類中的__call__方法也應該做這三件事
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
        #1、調用__new__產生一個空對象obj
        obj=self.__new__(self) # 此處的self是類OldoyTeacher，必須傳參，代表創建一個StanfordTeacher的對象obj

        #2、調用__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的對象的所有屬性都變成私有的
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__，請看下一小節
五 再看屬性查找
結合python繼承的實現原理+元類重新看屬性的查找應該是什麼樣子呢？？？
在學習完元類後，其實我們用class自定義的類也全都是對象（包括object類本身也是元類type的 一個實例，可以用type(object)查看），我們學習過繼承的實現原理，如果把類當成對象去看，將下述繼承應該說成是：對象StanfordTeacher繼承對象Foo，對象Foo繼承對象Bar，對象Bar繼承對象object
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）的查找，另外一個層則是類層（即元類層）的查找
插圖：01元類-繼承背景下的屬性查找
#查找順序：
#1、先對象層：StanfordTeacher->Foo->Bar->object
#2、然後元類層：Mymeta->type
依據上述總結，我們來分析下元類Mymeta中__call__裡的self.__new__的查找
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__
我們在元類的__call__中也可以用object.__new__(self)去造對象
插圖：02元類-繼承背景下的屬性查找
但我們還是推薦在__call__中使用self.__new__(self)去創造空對象，因為這種方式會檢索三個類StanfordTeacher->Foo->Bar,而object.new則是直接跨過了他們三個
最後說明一點
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的一個對象
#         self.__init__(obj,*args,**kwargs) 
#         return obj
六 作業
1、在元類中控制把自定義類的數據屬性都變成大寫
class Mymetaclass(type):
    def __new__(cls,name,bases,attrs):
        update_attrs={}
        for k,v in attrs.items():
            if not callable(v) and not k.startswith('__'):
                update_attrs[k.upper()]=v
            else:
                update_attrs[k]=v
        return type.__new__(cls,name,bases,update_attrs)

class Chinese(metaclass=Mymetaclass):
    country='China'
    tag='Legend of the Dragon' #龍的傳人
    def walk(self):
        print('%s is walking' %self.name)


print(Chinese.__dict__)
'''
{'__module__': '__main__',
 'COUNTRY': 'China', 
 'TAG': 'Legend of the Dragon',
 'walk': <function Chinese.walk at 0x0000000001E7B950>,
 '__dict__': <attribute '__dict__' of 'Chinese' objects>,                                         
 '__weakref__': <attribute '__weakref__' of 'Chinese' objects>,
 '__doc__': None}
'''
2、在元類中控制自定義的類無需__init__方法
1.元類幫其完成創建對象，以及初始化操作；
　　2.要求實例化時傳參必須為關鍵字形式，否則拋出異常TypeError: must use keyword argument
　　3.key作為用戶自定義類產生對象的屬性，且所有屬性變成大寫
class Mymetaclass(type):
    # def __new__(cls,name,bases,attrs):
    #     update_attrs={}
    #     for k,v in attrs.items():
    #         if not callable(v) and not k.startswith('__'):
    #             update_attrs[k.upper()]=v
    #         else:
    #             update_attrs[k]=v
    #     return type.__new__(cls,name,bases,update_attrs)

    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError('must use keyword argument for key function')
        obj = object.__new__(self) #創建對象，self為類Foo

        for k,v in kwargs.items():
            obj.__dict__[k.upper()]=v
        return obj

class Chinese(metaclass=Mymetaclass):
    country='China'
    tag='Legend of the Dragon' #龍的傳人
    def walk(self):
        print('%s is walking' %self.name)


p=Chinese(name='lili',age=18,sex='male')
print(p.__dict__)
3、在元類中控制自定義的類產生的對象相關的屬性全部為隱藏屬性
class Mymeta(type):
    def __init__(self,class_name,class_bases,class_dic):
        #控制類Foo的創建
        super(Mymeta,self).__init__(class_name,class_bases,class_dic)

    def __call__(self, *args, **kwargs):
        #控制Foo的調用過程，即Foo對象的產生過程
        obj = self.__new__(self)
        self.__init__(obj, *args, **kwargs)
        obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()}

        return obj

class Foo(object,metaclass=Mymeta):  # Foo=Mymeta(...)
    def __init__(self, name, age,sex):
        self.name=name
        self.age=age
        self.sex=sex


obj=Foo('lili',18,'male')
print(obj.__dict__)
4、基於元類實現單例模式
#步驟五：基於元類實現單例模式
# 單例：即單個實例，指的是同一個類實例化多次的結果指向同一個對象，用於節省內存空間
# 如果我們從配置文件中讀取配置來進行實例化，在配置相同的情況下，就沒必要重複產生對象浪費內存了
#settings.py文件內容如下
HOST='1.1.1.1'
PORT=3306

#方式一:定義一個類方法實現單例模式
import settings

class Mysql:
    __instance=None
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance=cls(settings.HOST,settings.PORT)
        return cls.__instance

obj1=Mysql('1.1.1.2',3306)
obj2=Mysql('1.1.1.3',3307)
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True


#方式二：定製元類實現單例模式
import settings

class Mymeta(type):
    def __init__(self,name,bases,dic): #定義類Mysql時就觸發
        # 事先先從配置文件中取配置來造一個Mysql的實例出來
        self.__instance = object.__new__(self)  # 產生對象
        self.__init__(self.__instance, settings.HOST, settings.PORT)  # 初始化對象
        # 上述兩步可以合成下面一步
        # self.__instance=super().__call__(*args,**kwargs)
        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs): #Mysql(...)時觸發
        if args or kwargs: # args或kwargs內有值
            obj=object.__new__(self)
            self.__init__(obj,*args,**kwargs)
            return obj
        return self.__instance

class Mysql(metaclass=Mymeta):
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql() # 沒有傳值則默認從配置文件中讀配置來實例化，所有的實例應該指向一個內存地址
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3)
obj4=Mysql('1.1.1.4',3307)


#方式三:定義一個裝飾器實現單例模式
import settings

def singleton(cls): #cls=Mysql
    _instance=cls(settings.HOST,settings.PORT)

    def wrapper(*args,**kwargs):
        if args or kwargs:
            obj=cls(*args,**kwargs)
            return obj
        return _instance
    return wrapper


@singleton # Mysql=singleton(Mysql)
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql()
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3) #True

obj4=Mysql('1.1.1.3',3307)
obj5=Mysql('1.1.1.4',3308)
print(obj3 is obj4) #False

相關焦點

  • Python視頻教程網課編程零基礎入門數據分析網絡爬蟲全套Python...
    本課程為python教程大合集,包含python所有就業方向,每套課程均來自市面上主流培訓機構的原版教程,價值都在數百元以上 每套課程均包含:視頻課程+課件+原始碼 重要:建議根據自己工作方向和需求,重點選擇2到3套課程學精,吃透,然後在工作 重要:零基礎小白建議先選擇零基礎全能篇的一套課程學精
  • Python基礎
    usr/bin/python#coding=utf-8print("hello world!");Python 基礎語法$ python test.py以下劃線開頭的標識符是有特殊意義的。以單下劃線開頭（_foo）的代表不能直接訪問的類屬性，需通過類提供的接口進行訪問，不能用"from xxx import *"而導入；以雙下劃線開頭的（foo）代表類的私有成員；以雙下劃線開頭和結尾的（foo）代表python裡特殊方法專用的標識，如init（）代表類的構造函數。在Python的代碼塊中必須使用相同數目的行首縮進空格數。
  • 乾貨Python類和元類(metaclass)的理解和簡單運用
    類，都基於python2.7x以及繼承於object的新式類進行討論。首先在python中，所有東西都是對象。這句話非常重要要理解元類我要重新來理解一下python中的類。class Trick(object):    pass當python在執行帶class語句的時候，會初始化一個類對象放在內存裡面。例如這裡會初始化一個Trick對象。
  • python語法基礎
    學一門語言，基礎語法一定要紮實。很多入門的編程書籍，都會花大量的篇幅來介紹基礎語法，對於毫無編程經驗的新手而言，這樣的書籍無疑是很友好的，但是對於有編程經驗的開發者而言，很多的基礎語法是通用的, 只需花費較少的時間瀏覽下基礎語法，將精力集中在語言獨有的特徵上即可。
  • python基礎學習教程:Python基礎語法
    在本章中我們將來學習 Python 的基礎語法，讓你快速學會 Python 編程。第一個 Python 程序交互式編程交互式編程不需要創建腳本文件，是通過 Python 解釋器的交互模式進來編寫代碼。以單下劃線開頭 _foo 的代表不能直接訪問的類屬性，需通過類提供的接口進行訪問，不能用 from xxx import * 而導入。以雙下劃線開頭的 __foo 代表類的私有成員，以雙下劃線開頭和結尾的 __foo__ 代表 Python 裡特殊方法專用的標識，如 __init__() 代表類的構造函數。
  • 07月09日利華益維遠雙酚A為12500元
    07月09日利華益維遠關於雙酚A的報價為12500元/噸。雙酚A的規格：優等品。該報價有效期為3天。報價提供方：山東利華益維遠化學有限公司。
  • Python基礎篇-07 Python能幹什麼,Python的應用領域
    公眾號關注「專攻python」，設為「星標」重磅文章，第一時間送達！！
  • 2020/09/07更新日誌
    2020.09.07課程更新明細一、財經類課程更新：三、教師類課程更新：2020下半年粉筆專業課各科已更至最新四、考研類課程更新：【1】【2021有道政治】精講班 思修6-7節【2】【2021新東方英語全程班】學習包 完型2009年真題【3】【2021文都數學特訓班】特訓班歷年真題解析 數學一6節 數學二
  • Python的武器庫07:sympy模塊
    說到程式語言python，有一個著名的格言"餘生太短，只用python"。如果要分析為什麼會存在這麼一句格言？python的語法並不簡單，有複雜難懂的部分，之所以有這樣一句格言，是因為python中有很多強大的模塊，就像一個武器庫。Python正式由於這些模塊的出現，只要引入這個模塊，調用這個模塊的集成函數，問題迎刃而解；不需要從頭開始，節省了大量的時間。
  • 2018年最新Python學習路線圖(內含大綱+視頻+工具+書籍+面試)
    03、初學者學習Python的整體規劃與建議04、初學python用什麼編輯器好？05、黑馬與其他培訓機構比，有哪些優勢06、沒有基礎應該怎麼學07、沒接觸過電腦，能不能學會python啊？2、經驗篇-技術問題01、Python基礎中繼承與派生02、Python中什麼是閉包03、Python中什麼是迭代04、Python中什麼是生成器05、什麼是IPython06、什麼是字符編碼？07、提高python效率的6大技巧！
  • 【Python雜貨鋪】速學python基礎
    「人生苦短，我學python」是編程屆的名言。用python寫小腳本的便捷性，讓很多其他語言的學習者把python當作輔助語言。擁有了某一個語言的功底，再來學習另外一種語言應該是十分快速的。編程理念都十分相似，只是看看語言的差異性。帶著Java的基礎，學習Python，準備上路了。
  • 兩句話掌握Python最難知識點:元類
    學懂元類，你只需要知道兩句話：道生一，一生二，二生三，三生萬物我是誰？我從哪來裡？我要到哪裡去？在python世界，擁有一個永恆的道，那就是「type」，請記在腦海中，type就是道。如此廣袤無垠的python生態圈，都是由type產生出來的。
  • Python基礎知識
    (input)不難發現，python2 中的 input 相當於對 raw_input 函數返回的結果進行 eval 一下，即input ()相當於 eval(raw_input()) 在 python3 中只有 input，但 python3 的 input 和 python2 的 raw_input 的使 用方法是一樣的，返回的值都是一個字符串。
  • Python入門基礎之面向對象二:類和實例、方法
    前面一篇文章我介紹了python面向對象的基本知識，連結在最下面。初步解釋了面向對象和面向對象的優點，今天就開始正式用代碼來展現面向對象。1、利用class創建類Python中，創建類的語句是如下所示先解釋一下，class後面跟的是類名，括號裡面是基類（也成為父類）python3中默認繼承object。
  • python基礎知識 ——類
    說到類，就不得不提面向過程編程和面向對象編程。下面用兩個例子說明這兩種編程方式在編碼上的區別，如圖5-3-9和圖5-3-10所示。▲圖5-3-10 案例2（1) 在面向對象編程中最重要的概念是類（Class) 和實例（Instance) 。（2) 類是抽象的模板，可以將其理解為一個基礎模板，比如Student類。
  • 學python?不是一個python入門教程就行,學之前你必須知道這些
    既然是就業那麼就要看市場，就是人才需求市場，這裡說的市場當讓是說python人才需求的市場了。說到市場當然python每個方向肯定有市場了，咱們直接看主要矛盾：一個是需求量，另一個是入行的難易程度。python全棧目前是市場的需求量最大，入行也是最容易的。要是為了就業那就先這樣入門入行，就不用想了。
  • Python打牢基礎,從22個語法開始!
    萬丈高樓平地起，咱們先從Python中最最基礎的開始。如何字符串中包括單引號或者雙引號，python使用反斜線（）對字符串中的字符進行轉義。'] 09 元組列表是可以修改的數據結構，而元組是固定長度，不能被修改元素值的數據結構。
  • Python零基礎入門-03-Python基礎語法
    Python零基礎入門-03-Python基礎語法本節課的知識點：1，python系列教程的學習方法。2，熟悉Python的基礎語法內容。1，python系列課程學習方法由於python屬於腳本語言，如果單純的解釋語法沒有什麼實在的意義，所以我python系列的課程都是以視頻講解為主，至於這裡的文章，是給你複習用的。2. 基礎語法python的基礎語法都將以小例子作為驅動來講解。如果你有其他程式語言的基礎，那麼直接看文章就會很快上手。
  • 後區關注07 09 _ 東方財富網
    原標題：後區關注07 09 　　體彩大樂透第20126期獎號為：01 04 09 22 28 + 04 12。
  • 大宗交易:瑞貝卡成交2520萬元,溢價9.09%(07-03)
    摘要 2020年7月3日，瑞貝卡發生1筆大宗交易，總成交750萬股，成交金額2520萬元，成交價3.36元，溢價9.09%。