摘要：構造函數構造函數參數列表在使用類創建對象時自動調用。類是從一堆對象中抽取相同的屬性及方法得出的，抽象類就是從一堆類中抽取相同的屬性及方法得出的。抽象類不能實例化對象。

構造函數：__init__(參數列表)  ：在使用類創建對象時自動調用。
注意：如果自己不寫構造函數，系統默認也會加上一個空的構造函數。
對象屬性的優先級高于類屬性，當對象調用屬性時，如果有對象屬性時，先獲取對象屬性的值；如果沒有對象屬性，會去找同樣名字的類屬性；如果沒有同樣名字的類屬性，返回一個錯誤。

class Person():
    # 直接寫在class中的屬性叫類屬性(可以通過類名直接調用)
    # name = ""
    # age = 0

    # 默認的構造函數(在init方法中的屬性叫對象屬性)
    # __init__函數沒有返回值，不能寫return
    # def __init__(self):
    #     pass

    # 自己重新寫構造函數時，只能更改參數列表及函數體，不能寫return這條語句
    # def __init__(self):
    #     print("我顯示的是init函數")

    def __init__(self, name, age, weight=30.0):
        print("小兔子乖乖")
        # 對象屬性(定義在構造函數中的屬性為對象屬性)
        self.name = name
        self.age = age
        self.weight = weight
    # 建議：一個類中最好只有一個init函數，如果寫了多個，程序不會報錯，
    # 但是只會執行最后一個寫的init函數

    def eat(self):
        print("person--eat")
    def sleep(self, hours):
        print("我睡了%d小時" % hours)
    
    # 建議使用關鍵字 實例化對象
    per1 = Person(name="Lily", age=30, weight=50.0)

self:當前類的實例對象，但是在類中用self表示。
哪個對象調用帶有self參數的方法時，self就指向哪一個對象。
__class__: 代表當前類的類名。
self:不是關鍵字，換成其他的詞語也可以，只要類中的成員方法至少有一個形參即可，第一個形參就代表當前類的實例對象

析構函數：__del__()  : 釋放對象時調用，銷毀對象時調用。

class Person():
    # 構造函數
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print("析構函數" + self.name)


per1 = Person("tom")
per2 = Person("lucy")
per3 = Person("lily")
# del per3.name 刪除對象屬性
# del per3 # 手動刪除優先級高 先刪除lily 然后執行類里的析構函數，系統的自動回收


def fun1():
    per4 = Person("Json") # 局部變量
    print(per4.name)

fun1() # Json 析構函數Json 用完函數后 per4 被析構函數回收

在使用print打印對象時會自動調用，這個方法是給用戶使用的，是描述對象的方法。

class Person():
    def __init__(self, name, age, sex):
        self.name = name
        self.sex = sex
        self.age = age

    # 可以在類中重新寫__str__方法
    # 要求必須有返回值，返回值類型str類型
    def __str__(self):
        sexStr = ""
        if self.sex == 1:
            sexStr = "女"
        elif self.sex == 0:
            sexStr = "男"
        return "姓名為%s, 年齡為%d，性別為%s" %(self.name, self.age, sexStr)

私有屬性子類不能繼承，子類的對象不能使用
實例對象不能直接訪問私有屬性__age,因為python解釋器把__age私有屬性變成了_Person__age， 我們就可以通過_Person__age訪問私有屬性__age。強烈建議：不要這么干

class Person():
    def __init__(self, name, age, weight, height):
        # 公有屬性：能夠在當前類、當前類的實例對象、子類中均能使用
        self.name = name
        # 私有屬性: 只能在當前類中使用
        # 格式：__屬性名(只在屬性名前面加兩個下劃線)
        self.__age = age
        # 格式：__變量名__：在python中屬于特殊變量，可以直接訪問，類似公有屬性
        self.__weight__ = weight
        # 格式: _變量名:在python中能夠正常訪問，類似公有屬性，但是，當我們
        # 看到這種屬性時，把它當成是私有屬性使用。
        # _變量名(雖然我現在能直接訪問并使用，但請把我當成私有屬性，不要用
        # 對象直接訪問)
        self._height = height
    # set方法：賦值
    def setAge(self, age):
        if age < 0:
            self.__age = 20
        else:
            self.__age = age

    # get方法: 取值
    def getAge(self):
        return self.__age + 20

    def setName(self, name):
        self.name = name
    def getName(self):
        return self.name

class Animal():
    def __init__(self, name, color, age):
        self.name = name
        self.age = age
        # 私有屬性
        self.__color = color
    def run(self):
        print(self.__color)
        print("run")
    def eat(self):
        print("eat")
class Cat(Animal):
    def __init__(self, name, age, color, miao):
        # 調用父類的__init__方法
        # 父類名稱.__init__(self, 根據父類形參賦值實參)
        Animal.__init__(self, name, color, age)
        # 使用super關鍵字調用init方法(同上)
        # super(Cat, self).__init__(name, color, age)
        # 子類可以有自己獨有的屬性
        self.miao = miao

單繼承：一個子類只有一個父類
多重繼承：子類有父類，父類又有父類 ：  父類->子類->子子類。。。。。
多繼承： Son -> Father,Mother
注意：如果父類們中的方法名相同，默認調用小括號中排在前面的父類中的方法(就近原則)

類方法  @classmethod
類方法一般來說使用類名調用。
類方法類和對象均能調用，但是不管是類還是對象調用，cls都代表類；比如當前例子中，cls就代表Person，cls不是關鍵字，使用其他形參名稱也可以，總之，類方法的第一個形參就代表類。
靜態方法  @staticmethod
靜態方法一般來說不是給對象是用的，一般使用類名調用
靜態方法就是一個普通函數，不會默認需要傳參數
類和對象均能調用，但一般使用類名調用

class Person():
    # 對象方法，使用實例對象調用
    def eat(self):
        print("eat")

    # 類方法  @classmethod
    @classmethod
    def play(cls, a, b):
        print("類方法", a+b)
        print(cls)
    # 靜態方法  @staticmethod
    @staticmethod
    def run(num1, num2):
        print(num1 + num2)

from types import MethodType

class Person():
    def run(self):
        print("run")
    pass

# 動態添加屬性
per1 = Person()
per1.name = "Lily"
print(per1.name)
# 動態添加方法

def say(self):
    print("say")
# MethodType(函數名稱, 當前實例對象的名稱)
# 把當前的實例對象傳遞給函數的第一個形參
per1.saying = MethodType(say, per1)
per1.saying()

思考：如果我們要限制動態添加屬性或方法的個數及名稱怎么辦？比如我們只能動態添加name及age屬性，run方法。為了達到要求，python允許在定義類時，定義一個特殊的屬性__slots__屬性變量，__slots__屬性可以限制動態添加的屬性及方法的名稱。
__slots__ :使用元組的方式賦值
注：__slots__定義的屬性只對當前類有效，對它繼承的子類無效；
如果子類中也定義了__slots__屬性，這樣定義的屬性的個數為子類本身的內容加上父類中定義的內容。

class Student():
    __slots__ = ("name", "age", "run")
    pass
stu1 = Student()
stu1.name = "Tom"
# stu1.weight = 56.7  # 錯誤，不允許添加

def run(self, a, b):
    print("run", a+b)
stu1.run = MethodType(run, stu1)
stu1.run(2,3)

@property  裝飾器
@property: 可以使對象通過點方法訪問私有屬性。

class Person():
    def __init__(self, name, age):
        # 公有屬性
        self.name = name
        # 私有屬性
        self.__age = age
    @property
    def age(self):
        return self.__age
    
    @age.setter
    def age(self, age):
        if age < 0:
            age = 1
        self.__age = age
per1 = Person(name="二胖", age=1)
# 如果屬性為公有屬性，對象可以直接調用進行更改或使用
# 這樣，不安全，數據可以直接被重新賦值，而且沒有任何限制條件。
# 相當于調用set方法，現在調用的是加了@age.setter裝飾器的方法
per1.age = 99
# 相當于調用get方法，現在調用的是加了@property裝飾器的方法
print(per1.age)

class Person():
    def __init__(self, num):
        self.num = num
    # 打印對象時調用
    def __str__(self):
        return "目前num為：" + str(self.num)
    # 運算符重載
    def __add__(self, other):
        return Person(self.num + other.num)
    def __mul__(self, other):
        return Person(self.num * other.num)
p1 = Person(100)
print(p1)
p2 = Person(266)
print(p2)
print(p1 + p2)  # p1.__add__(p2)   __add__(self, other)
Person(111)
Person(111)
print(p1 * p2)

__init__: 構造函數
__del__:析構函數
__str__:打印對象
__add__:加運算
__mul__:乘運算
__sub__:減運算
__mod__:余運算
__div__:除運算
__pow__:冪運算

在開發中，我們遇到的所有事物都是對象，對象是通過類創建的。但是不是所有的類都是用來描述對象的。如果一個類中沒有足夠的條件信息來描述一個具體的事物/對象，而需要其他具體的類來輔助他，那么，這樣的類我們稱之為抽象類。
抽象類中可以有抽象方法，一般包含抽象方法的類都是抽象類。
抽象方法可以不包含任何方法實現的代碼，只有一個方法名字，但是，在子類中要求必須實現該抽象方法，否則，子類也為抽象類。
類是從一堆對象中抽取相同的屬性及方法得出的，抽象類就是從一堆類中抽取相同的屬性及方法得出的。
抽象類不能實例化對象。

1、定義抽象類
在定義抽象類之前，我們需要導入模塊abc中的ABCMeta類(抽象基類的元類)（Metaclass for defining Abstract BaseClass）。在定義抽象類時，我們需要在代碼中加入 metaclass=ABCMeta,指定該類的元類為ABCMeta元類：創建一個類的類。
抽象類不能實例化對象。
抽象類一般都用作父類。
2、定義抽象方法
在定義抽象方法之前，我們需要導入模塊abc中的abstractmethod類。
在定義抽象方法時，我們需要在方法前面加上@abstractmethod修飾詞。
因為抽象方法一般不需要在抽象類中實現，我們只需要在抽象方法的函數體中寫一條pass語句即可。
3、實現類
實現類為抽象類的子類。
如果實現類不實現父類(抽象類)中的抽象方法，那么該類也是抽象類；
如果實現類實現了父類(抽象類)中的抽象方法，那么該類就是普通類，可以實例化對象。

from abc import ABCMeta, abstractmethod
# 定義抽象類

class Animal(metaclass=ABCMeta):
    # 定義屬性
    def __init__(self, color):
        self.color = color
    # 對象方法
    def eat(self):
        print("Animal--eat")
    # 定義抽象方法
    @abstractmethod
    def play(self):
        pass
# 創建實現類（以一個抽象類為父類）
class Cat(Animal):
    def __init__(self, color, name):
        Animal.__init__(self, color)
        self.name = name
    # 子類實現父類的抽象方法
    def play(self):
        print("cat--play")

cat1 = Cat(color="black", name="旺財")
print(cat1.color)

真正的接口中不能定義變量，接口中只能有抽象方法。
1.什么是接口  interface，接口都是當作父類使用。
子類實現接口中的抽象方法。
在python中沒有interface這個關鍵字，我們目前所寫的接口只是通過抽象類仿寫，
所以，目前，接口可以認為就是一個類，一個只包含抽象方法并且不能實例化對象的類。其子類如果想要實例化對象，必須實現接口中所有的抽象方法。
2.為什么要使用接口？
接口本身就是一系列方法的聲明，一些特殊方法的集合，一個接口中只有方法的聲明，但是沒有方法的實現，這些特殊的方法要在不同的類之間進行不同的實現。接口本身是用于封裝代碼的。
例子：鳥類和昆蟲類都有飛行的行為，功能相同，但實現內容不同，二者如果抽象出一個類不太方便，但可以抽象一個接口，用于飛行行為的封裝。
3.注意：一般在接口中只有方法的聲明，沒有方法的實現。在接口中不能出現變量。

from abc import abstractmethod
# 定義接口
class Interface: # 仿寫接口
    # 定義抽象方法
    @abstractmethod
    def fly(self):
        pass
    # ...
# 定義接口的實現類
class Bird(Interface):
    def __init__(self, leg):
        self.leg = leg
    def egg(self):
        print("鳥生蛋")
    def fly(self):
        print("小鳥飛的高")
class Insect(Interface):
    def __init__(self, leg):
        self.leg = leg
    def spawn(self):
        print("昆蟲產卵")
    def fly(self):
        print("昆蟲飛的低")
b1 = Bird(2)
b1.fly()

i1 = Insect(6)
i1.fly()

面向對象的三大特征： 封裝，繼承，多態
多態：一種事物的多種形態，子類可以認為是父類的不同形態的實現
python是弱類型語言,聲明變量時，不要求數據類型，根據賦值的類型去確定該變量的類型。c，Java強類型語言，聲明變量時，已經確定該變量的數據類型，如果賦值的類型與聲明的類型不一致，程序會報錯。在強類型語言中：子類對象可以強轉為父類類型的對象，但父類類型的對象不能強轉為子類類型的對象。在強類型語言中：子類對象可以強轉為父類類型的對象，父類類型的對象也能強轉為子類類型的對象。

class Animal():
    def __init__(self, name):
        self.name = name
    def eat(self):
        print(self.name + "eat")
class Cat(Animal):
    def __init__(self, name):
        Animal.__init__(self, name)
    def run(self):
        print(self.name + "run")
class Dog(Animal):
    def __init__(self, name):
        Animal.__init__(self, name)

class Person():
    # def feedAnimalCat(self, cat):
    #     print("人喂了" + cat.name)
    # def feedAnimalDog(self, dog):
    #     print("人喂了" + dog.name)
    def feedAnimal(self, animal):
        print("人喂了" + animal.name)

per = Person()
cat1 = Cat("喵")
# per.feedAnimalCat(cat1)
dog1 = Dog("汪")
# per.feedAnimalDog(dog1)

per.feedAnimal(cat1)
per.feedAnimal(dog1)

class Animal(object):
    def run(self):
        print("animal is running")


class Dog(object):
    def run(self):
        print("dog is running")


class Cat(object):
    def run(self):
        print("cat is running")


def run_twice(animal):
    animal.run()
    animal.run()

run_twice(Animal())
run_twice(Cat())
run_twice(Dog())

class Tortoise(Animal):
    def run(self):
        print("Tortoise is running slowly...")

run_twice(Tortoise())