類型這塊

type 一個對象的時候，這個對象的類型，總是這個對象所屬的類

type任何一個類，它的類型都是type，type是所有數據類型和類的鼻祖

type的類型是它本身 type = type(type)

函數的類型就是函數

python是一種動態語言，一個鴨子類型舉例：動態python變量，在賦值的時候，賦值號（=）右邊的數據類(list，set，float等)對象是什麽類型，他就是什麽類型

a. 常規創造的類 總是有幾個特性:

　　能夠實例化

　　能有屬性

　　能有方法

b.元類能夠幫助你創造不同尋常的類（下面就來了）

　　不能實例化

　　只能有一個實例

類 =type（該類對象）

type = type(類)

所有的類型：說的都是這個對象是屬於哪一類的

所有的用class常規語法創造出來的類都是type類型

‘

元類的應用（歸一化設計）

歸一化設計

　　a.方便用戶記憶

　　b.方便用戶使用

python 的歸一化設計用的是一下的東西：

from abc import ABCMeta,abstractmethod
class Father(metaclass= ABCMeta):     #抽象類，如果你用了這種，
    def __init__(self,name,price):    #在@abstractmethod方法下面函數，在此類的每一個
        self.name 
 
= name              #子函數必須實現該函數，但是在此類此函數可以寫一些
        self.price = price            #簡單代碼，抽象類也不能實例化
    @abstractmethod
    def pay(self):
        pass
class Wechatpay(Father):
    def pay(self):
        print(f‘{self.name}付了{self.price}‘)
class Alipay(Father):
    def pay(self):
        print(f
 
‘{self.name}付了{self.price}‘)
def pay(person):                #歸一化設計  就是將zy.pay() = pay(zy)
    return person.pay()         #方便用戶記憶
                                #方便用戶使用
zy = Wechatpay(‘zy‘,1000)
hfl = Alipay(‘hfl‘,2000)
pay(zy)
pay(hfl)

多變化的抽象類繼承

from abc import ABCMeta,abstractmethod
class Normalanimals(metaclass=ABCMeta):
    @abstractmethod
    def eat(self):
        pass
    @abstractmethod
    def drink(self):
        pass

class Flyanimals(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):
        pass
class Swimanimals(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):
        pass
class Tiger(Normalanimals,Swimanimals):
    def eat(self):pass
    def drink(self):pass
    def swim(self):pass
class swam(Normalanimals,Swimanimals,Flyanimals):
    def eat(self):pass
    def drink(self):pass
    def swim(self):pass
    def fly(self):pass

鴨子類型：
python當中寫程序的一種特殊的情況
其他語言中 正常的我們說一個數據類型具有某個特點，通常是通過繼承來實現
繼承叠代器類，來證明自己本身是個叠代器
繼承可哈希的類，來證明自己本身是可哈希的
但是所有的這些都不是通過繼承來完成的
我們只是通過一種潛規則的約定，如果具有__iter__,__next__就是叠代器
如果具有__hash__方法就是可哈希的
如果具有__len__就是可以計算長度的
這樣的數據類型之間的關系並不僅僅是通過繼承來約束的
而是通過約定俗成的關系來確認的
list.index()
str.index()
鴨子類型是一種約定俗稱的關系,只在python裏有
多態：
在傳遞參數的時候，如果要傳遞的參數有可能是多個類的對象
我們又必須在於嚴重清楚的描述出到底是哪一個類型的對象
我們就可以使用繼承的形式，有一個父類作為這些所有可能被傳遞進來的對象的基類
基礎類型就可以寫成這個父類了
於是所有子類的對象都是屬於這個父類的
在python當中，因為要傳遞的對象的類型在定義階段不需要明確，所以我們在python中處處是多態
數據類型不需要通過繼承來維護統一

命名元組

創建一個不可以更改屬性，沒有自帶方法的類

調用的時候用 from collections import nametuple

對比：通過這個對比，我們知道這個類只能做調用單個參數值，連呈現內容都做不到，看來跟常量性質一樣了

from collections import namedtuple

Course = namedtuple(‘Course‘,[‘name‘,‘ad‘,‘hp‘])
python = Course(‘python‘,100,120)
print(python.name)          #只能這樣做
# print(python.__dict__)   不可行 ，連特麽的呈現內容都呈現不出來，看來跟常量的性質一樣

class A:
    def __init__(self,name,ad,hp):
        self.name = name
        self.ad = ad
        self.hp = hp
c = A(‘zy‘,12,34)
print(c.__dict__)

還有一種命名元組你想到了麽？

嘿嘿，那就是time時間模塊裏的 struct_time

它是通過 time.localtime 獲取，它的也是一個struct_time類，但是它的屬性更nametuple一樣不可更改，也不可以添加

也沒有自己的方法

>>> time.localtime()
time.struct_time(tm_year=2014, tm_mon=7, tm_mday=8, tm_hour=22, tm_min=9, tm_sec=1, tm_wday=1, tm_yday=189, tm_isdst=0)
>>> time.localtime()[1]
7
>>> time.localtime().tm_mon
7

pickle的意義

    import pickle    
    class A(object):
        def __init__(self,name,hp,ad)
            self.name = name
            self.hp = hp
            self.ad = ad
    person = A(‘zy‘,100,10)
    with open(‘t1‘,‘wb‘) as f1:
        pickle.dump(person,f1)
    with open(‘t1‘,‘rb‘)as f2:
        c = pickle.load(f2)
    print(c.__dict__)

總結：
多態的實現在其他語言中用繼承來實現，比如Java用接口實現多繼承
在python當中是通過鴨子類型來實現，弱類型語言的意思就是不同類型的變量不允許相加
python還是一種動態語言，一個鴨子類型舉例 動態python變量，在賦值的時候，賦值號（=）右邊的數據類（list，set，int，float等）對象是什麽類型 它就是什麽類型

python 多態這一部分的知識點相關應用