python修鍊第六天

標籤：自動   python2   初始   內容   刪除   直接   類別   執行個體化   思考   

越來越難了....現在啥也不想說了，擼起袖子幹。1 物件導向

先來個例子：

比如人狗大戰
需要有狗，人
所以建立兩個類別模子
def Person(name,sex,hp,dps):
    dic = {"name":name,"sex":sex,"hp":hp,"dps":dps,"bag",[]}
    return dic

def Dog(name,kind,hp,dps):
    dic = {"name":name,"kind":sex,"hp":hp,"dps":dps}
    return dic

alex = Person("alex","geil")
ha2 = Dog("","",)

造模子  ---物件導向
規範了一個類別

概念：
類 具有相同屬性和相同動作的一類事物，組成一個類
對象 具體的某一個具有實際屬性 和具體動作的一個實體
類是抽象的，對象是具體的

類的文法：
類：
    1 定義：
        class 類名:
           靜態屬性 = None
           def 動態屬性(self):
                pass
    2 類的第一個功能;查看
        # 只要是寫在類名中的名字，不管是變數還是函數名，都不能在類的外部直接調用
        # 只能通過類名來使用：類名.靜態屬性
            可以修改靜態屬性
                類名.靜態屬性 = 345
            可以增加靜態屬性
                類名.靜態屬性2 = "abc"
            可以刪除靜態屬性
                del 類名.靜態屬性2

            動態屬性：
            定義動態屬性時要加個self
            def func(self):
                print("--->",self)
            類名可以查看某個方法，但是一般情況下 我們不直接使用類名來調用方法
            而是使用對象來調用方法。

    3 類的第二個功能：執行個體化（創造對象）
        class Person:pass
        alex = Person()
        # 對象 = 類名()  類名加上括弧就是執行個體化，
        在執行個體化的過程中，發生了很多事情是外部看不到的步驟：
            1 建立了一個對象
            2 自動調用__init__方法
            3 這個被創造的對象會被當作一個實際參數傳到__init__方法中，並且傳給第一個參數self
            4 然後執行init方法中的內容
            5 自動的吧self作為傳回值，返回給執行個體化的地方

        __dict__ # 記錄了必要的預設值之外，還記錄了程式員在類中定義的所有名字
            print(alex.__dict__)
            alex.__dict__["name"] = "alex"
            alex.__dict__["hp"] = "alex"
            alex.__dict__["dps"] = "alex"
            可以簡寫為:
            alex.name = "alex"
            alex.hp = 250
            alex.dps = 5

        初始化方法：
        上面是在類外面建立對象的屬性，能不能在類裡面直接產生屬性？
        這個被創造的對象會被當作一個實際參數傳到__init__方法中，並且傳給第一個參數self
        能不能這樣：alex = Person("alex","boy",250,5)
         class Person:
            def __init__(self，name,hp,dps):
                self.name = name
                self.hp = hp
                self.dps = dps
          alex = Person("alex",250,5)
          print(alex.__dict__)
          print(alex.name)

        對象名.方法名  相當於調用類的函數，同時第一個參數是對象名，第二個參數是

        當一個類建立一個對象的時候，就產生了一個這個執行個體和類之間的聯絡
        可以通過執行個體 對象找到執行個體化他的類。
        但是類無法找到他執行個體化了多少個對象。
        所以：
        對象可以訪問類的空間
        類無法訪問對象的空間

        命名空間問題： 類命名空間與對象執行個體的命名空間
        alex.country = "印度人"
        在訪問變數的時候，都先使用自己的命名空間中的變數，如果自己的空間中沒有
        再到類的空間去找
        在使用對象修改靜態變數的過程中，相對於在自己的空間中建立了一個新的變數


        alex.country[0] = "印度人"
        在類的靜態變數的操作中，應該使用類名來直接進行操作。就不會出現烏龍問題



    思考題
        建立一個類，能夠計算這個類建立了多少個執行個體


    組合
        一個類的對象，作為另外一個類的屬性
        比如 人有武器
             圓環有圓

2 物件導向的三大特性

1 繼承 佔了2/1
    為什麼會有繼承： 是為瞭解決代碼冗餘的問題。
    怎麼繼承？
    單繼承：
        class Parent:
            pass
        class sun(Parent):    這就代表sun這個類 繼承Parent類
            pass
        產生很多名詞：父類，基類，超類 --- parent類
        子類 衍生類別 ----- sun類

    多繼承,有多個父類:
        class Parent1:pass
        class Parent2:pass
        class sun(Parent1,Parent2):pass

    先找對象的記憶體空間，再找建立這個對象的類的記憶體空間，如果還沒有 再找建立這個類的父類記憶體空間。
    class Animal:
        def __init__(self,name,hp,dps)
            self.name = name
            self.hp = hp
            self.dps = dps
        def cat()
            print("%s吃藥回血了",%self.name)

    class  Person(Animal):
        def __init__(self,name,hp,dps,sex)
            Animal.__init__(self,name,hp,dps)   # 或者寫為 super().__init__(name,hp.dps) ，但是如果是多繼承要寫這個。
            self.sex = sex   # 派生屬性
        def attack(self):
            pass

    class Dog(Animal):
        def __init__(self,name,hp,dps,kind)
            Animal.__init__(self,name,hp,dps)
            self.kind = kind
        def bite():
            pass

    面試題：
        class Foo;
            def __init__(self):
                self.func()
            def func(self):
                print("in Foo")
        class Son(Foo):
            def func(self):
                print("in Son")
        Son()       # 先調用self自己的方法。所以是in Son


    多繼承：
        鑽石繼承問題：
                    A  4
                  /   \
                /       \
            2  B           C  3
                \        /
                  \    /
               1    D
        優先順序：D,B,C,A

        小烏龜模型：
                   A  6
                 /   \
                /      \
            3  B       C  5
               |       |
               |       |
            2  D       E  4
                \     /
                 \   /
                   F  1
        優先順序：F,D,B,E,C,A
        遍曆演算法 ： 廣度優先演算法
    python3 都遵循廣度優先演算法

    python3有2種類
    1 經典類 Python3已經滅絕了，在python2中還存在，在py2中只要程式員不主動繼承object，這個類就是經典類
        就遵循深度優先演算法。 一條道走到黑。

    2 新式類 Python3所有的類都是新式類，所有新式類都繼承自object--- 在多繼承成中遵循廣度優先演算法。

    super注意：
    在單繼承中 super就是找父類
    在多級繼承 super的軌跡 是根據整個模型的起始點而展開的一個廣度優先循序，遵循mro規則


抽象類別與介面類 主要是針對java的，略



2 多態
    在Python當中，處處都是多態。 略 還沒講



3 封裝
　　略 還沒講

python修鍊第六天