類

一、編程範式：

　　　　　　　1.函數式編程 def

　　　　　　2.面向過程編程 (Procedural Programming)

　　　　　　　　基本設計思路就是程序一開始是要著手解決一個大的問題，然後把一個大問題分解成很多個小問題或子過程，這些子過程再執行的過程再繼　　　　　　　　續分解直到小問題足夠簡單到可以在一個小步驟範圍內解決。

　　　　　　3.面向對象編程 (object oriented programming)

　　　　　　　　　OOP編程是利用“類”和“對象”來創建各種模型來實現對真實世界的描述，使用面向對象編程的原因一方面是因為它可以使程序的維護和擴　　　　　　　　　展變得更簡單，並且可以大大提高程序開發效率 ，另外，基於面向對象的程序可以使它人更加容易理解你的代碼邏　　　　　　　　　　　　　　　　　　　輯，從而使團隊開發變得更從容。

 1 #面向對象編程
 2 class Dog():
 3     ‘‘‘一次小狗的簡單模擬類‘‘‘
 4     def __init__(self,name,age):
 5         self.name = name
 6         self.age = age
 7     def eating(self,food):
 8         ‘‘‘模擬小狗吃東西‘‘‘
 9         print("%s is eating %s"%(self.name,food))
10     def running(self):
11         ‘‘‘模擬小狗跑步
 
‘‘‘
12         print("%s is running "%self.name)
13     def main(self):
14         self.eating("apple")
15         self.running()
16 if __name__ == "__main__":
17     dog1 = Dog("xiaoming",3)
18     dog1.main()

　　　　　　1.方法__init__():初始化函數，每當實例化類時，python就會自動運行該函數。調用該函數時，會自動傳遞實參self,它是一個指向實例本身的引用，讓實例能訪問類中的　　　　　　　屬性和方法.__init__()函數中需要的參數，就是實例化類時需要傳遞的參數

　　　　　　2. 其他方法：通過實例來調用該方法

　　　　　　3.類屬性和實例屬性 調用時用.調用 類方法也通過.來調用

 1 class Car():
 2     name = "Ryoma"
 3     ‘‘‘一次汽車的簡單模擬類‘‘‘
 4     def __init__(self,make,model,year):
 5         ‘‘‘汽車的屬性‘‘‘
 6         self.make = make
 7         self.model = model
 8         self.year = year
 9         self.odometer_ing = 0
10     def get_describe(self):
11         ‘‘‘車的描述‘‘‘
12         print(str(self.make)+‘ ‘+str(self.model)+‘ ‘+str(self.year))
13     def read_odometer(self):
14         ‘‘‘讀裏程表‘‘‘
15         print("this car has "+str(self.odometer_ing)+‘ ‘+"miles ")
16     def update_odometer(self,miles):
17         ‘‘‘更新裏程表的數‘‘‘
18         self.odometer_ing += miles
19 car = Car("AUDI",‘A6‘,1995)
20 car.update_odometer(100)
21 print(car.odometer_ing)
22 car.read_odometer()

二、類的三大特性

　　　　　　　　1.封裝

　　　　　　　　　　　　封裝也就是把客觀事物封裝成抽象的類，並且類可以把自己的數據和方法只讓可信的類或對象操作，對不可信的進行信息隱藏

　　　　　　　　2.繼承

　　　　　　　　　　　　繼承是指這樣一種能力，它可以使用現有類的所有功能，並在無需重新編寫原來類的情況下對這些功能進行擴展。

　　　　　　　　　　　　通過繼承創建的類為“子類”或“派生類”。被繼承的類稱為“父類”或“基類”。

　　　　　　　　　　　　繼承實現的方式主要有兩種：實現繼承、接口繼承。實現繼承指的是使用基類的屬性或方法而無需額外的編碼能力。接口繼承指使用屬性和方法的名稱，　　　　　　　　　　　　但是子類必須提供實現的能力（即重構父類的方法）

 1 class Car():
 2     def __init__(self,make,model,year,fill_gas=100):
 3         ‘‘‘汽車的屬性‘‘‘
 4         self.make = make
 5         self.model = model
 6         self.year = year
 7         self.odometer_ing = 0
 8         self.fill_gas = 100
 9     def get_describe(self):
10         ‘‘‘車的描述‘‘‘
11         print(str(self.make)+‘ ‘+str(self.model)+‘ ‘+str(self.year))
12     def read_odometer(self):
13         ‘‘‘讀裏程表‘‘‘
14         print("this car has "+str(self.odometer_ing)+‘ ‘+"miles ")
15     def update_odometer(self,miles):
16         ‘‘‘更新裏程表的數‘‘‘
17         self.odometer_ing += miles
18     def fill_gas_tank(self):
19         print("this var has %s "%self.fill_gas)
20 class ElectricCar(Car):
21     ‘‘‘創建一個電動車的模擬類‘‘‘
22     def __init__(self,make,model,year):
23         super(ElectricCar,self).__init__(make,model,year)
24         self.battery = Battery()
25     def fill_gas_tank(self):
26         print("this car has no fill_gas")
27 class Battery():
28     ‘‘‘一次對電池的簡單模擬‘‘‘
29     def __init__(self,battery_size=70):
30         self.battery_size = battery_size
31     def describe_battery(self):
32         print("this battery size is %s"%self.battery_size)
33 ecar = ElectricCar(‘tesla‘,‘s‘,2000)
34 ecar.battery.describe_battery()

 1 class Company():
 2     def __init__(self,name,addr,found_year):
 3         self.name = name
 4         self.addr = addr
 5         self.found_year = found_year
 6     def tell(self):
 7         print("公司名為%s,地址是%s,成立於%s"%(self.name,self.addr,self.found_year))
 8     def roll_member(self):
 9         print("\033[31;1m%s正在招人才，大家可以投簡歷\033[0m"%self.name)
10 class CompanyMember():
11     members =0
12     def __init__(self,name,age):
13         self.name = name
14         self.age = age
15     def roll_member(self):
16         CompanyMember.members += 1
17         print("\033[41;1m %s 已被錄用,現在公司人數為%s\00[0m"%(self.name,self.members))
18 class Leader(CompanyMember):
19     def __init__(self,name,age,salary):
20         super(Leader,self).__init__(name,age)
21         self.salary = salary
22         self.roll_member()
23     def job(self):
24         print("%s的工作是CEO"%self.name)
25     def tell_info(self):
26         print("my name is %s,age is %s"%(self.name,self.age))
27 class Putonh(CompanyMember):
28     def __init__(self,name,age):
29        super(Putonh,self).__init__(name,age)
30        self.roll_member()
31     def tell_info(self):
32         print("my name is %s,age is %s"%(self.name,self.age))
33 if __name__ == "__main__":
34     company = Company("Ryoma Fintech","hangzhou",2020)
35     company.tell()
36     company.roll_member()
37     led = Leader(‘zqq‘,24,200000)
38     led.tell_info()
39     led.job()
40     pu = Putonh(‘a‘,18)
41     pu.tell_info()

　　　　　　　　繼承主要有兩種繼承方式：1.在python2.7經典類中是深度優先繼承 2.在2.7新式類中是廣度優先繼承3.在3.x中都是廣度優先

 1 class A(object):
 2     def __init__(self):
 3         print("in the A")
 4 class B(A):
 5     def __init__(self):
 6         print("in the B")
 7 class C(A):
 8     def __init__(self):
 9         print("in the C")
10 class D(B,C):
11     # def __init__(self):
12     #     print("in the D")
13     pass
14 D()

　　　　　　　　3.多態

　　　　　　　　　　　 允許你將父對象設置成為和一個或多個子對象相同的技術，賦值之後，父對象就可以根據當前賦值給它的子對象的特性以不同的方式運行，為了實現接口　　　　　　　　　　　　重用。

 1 class Animal():
 2     def __init__(self,name):
 3         self.name = name
 4     def talk(self):
 5         raise NotImplementedError("Subclass must implement abstract method")
 6 
 7 class Cat(Animal):
 8     def talk(self):
 9         print("喵喵喵")
10 class Dog(Animal):
11     def talk(self):
12         print("WOw")
13 def func(obj):
14     obj.talk()
15 if __name__ == ‘__main__‘:
16    c1 = Cat(‘dd‘)
17    d1 = Dog("xx")
18    func(c1)
19    func(d1)               #一個接口，多種實現

 1 class Animal():
 2     def __init__(self,name):
 3         self.name = name
 4     def talk(self):
 5         raise NotImplementedError("Subclass must implement abstract method")
 6     @staticmethod
 7     def animal_talk(obj):
 8         obj.talk()
 9 class Cat(Animal):
10     def talk(self):
11         print("喵喵喵")
12 class Dog(Animal):
13     def talk(self):
14         print("WOw")
15 
16 if __name__ == ‘__main__‘:
17    c1 = Cat(‘dd‘)
18    d1 = Dog("xx")
19    Animal.animal_talk(c1)
20    Animal.animal_talk(d1)

三、靜態方法 @staticmethod 實際上讓方法變成與類沒關系，變成類下的一個方法，不要傳self

四、類方法 @classmethod 只能調用類屬性，不能訪問實例屬性

五、靜態方法@property 1.將方法變為靜態屬性，調用時直接實例+方法名，不加括號　　

六、其他特殊成員方法

　　1.__doc__ 表示類的描述信息

　　2.__module__表示當前操作的對象在哪個模塊

　　3.__class__表示當前操作的類是哪個

　　4.__init__構造函數，通過類創建對象時，自動觸發

　　5.__del__析構函數，當對象在內存中釋放的時候，自動觸發

　　6.__call__對象後面加（），觸發執行，或類()(）

　　7.__dict__查看類或對象的所有屬性，類.__dict__只能查看類中的屬性，對象.__dict__只能查看對象中的屬性。

　　8.__getitem__ /__setitem__/__delitem__用於索引操作，分別對應獲得，設置，刪除操作

 1 def tell(self):
 2     print("my name is %s"%self.name)
 3 class Foo(object):
 4     def __init__(self):
 5         self.name = ‘zz‘
 6     def func(self):
 7         return ‘func‘
 8 foo = Foo()
 9 print(hasattr(foo,‘name‘))   #判斷是否有名字屬性
10 print(hasattr(foo,‘func‘))   #判斷是否有func方法
11 print(getattr(foo,‘name‘))  #獲得name屬性的值
12 print(getattr(foo,‘func‘))  #獲得func對應的函數地址
13 setattr(foo,"age",18)    #設置成員函數
14 setattr(foo,"tell",tell)   
15 print(getattr(foo,‘age‘))
16 fuc = getattr(foo,"tell")
17 fuc(foo)
18 delattr(foo,"name")  #刪除成員函數

我的Python分析成長之路7