本節主要內容：面向對象介紹、特性、語法

一、面向對象介紹

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 """
 4 編程範式：
 5     編程是 程序員 用特定的語法+數據結構+算法 組成的代碼來告訴計算機如何執行任務的過程 ，
 6     一個程序是程序員為了得到一個任務結果而編寫的一組指令的集合，正所謂條條大路通羅馬，
 7     實現一個任務的方式有很多種不同的方式，對這些不同的編程方式的特點進行歸納總結得出來的編程方式類別，即為編程範式。
 8     不同的編程範式本質上代表對各種類型的任務采取的不同的解決問題的思路，
 9
 
     大多數語言只支持一種編程範式，當然也有些語言可以同時支持多種編程範式。
10     兩種最重要的編程範式分別是 面向過程編程 和 面向對象編程。
11 
12 面向過程編程：
13     面向過程編程依賴過程，一個過程包含一組要被進行計算的步驟，面向過程又被稱為top-down languages，
14     就是程序從上到下一步步執行，一步步從上到下，從頭到尾的解決問題 。
15     基本設計思路就是程序一開始是要著手解決一個大的問題，然後把一個大問題分解成很多個小問題或子過程，
16     這些子過程再執行的過程再繼續分解直到小問題足夠簡單到可以在一個小步驟範圍內解決。
 
17     缺點：
18         如果要對程序進行修改，對修改的那部分有依賴的各個部分你都也要跟著修改。
19         舉個例子，如果程序開頭你設置了一個變量值為1 ，但如果其它子過程依賴這個值為1的變量才能正常運行，
20         那如果你改了這個變量，那這個子過程你也要修改，假如又有一個其它子程序依賴這個子過程，那就會發生一連串的影響，
21         隨著程序越來越大，這種編程方式的維護難度會越來越高。
22     總結：
23         所以我們一般認為，如果你只是寫一些簡單的腳本，去做一些一次性任務，用面向過程的方式是極好的。
24         但如果你要處理的任務是復雜的，且需要不斷叠代和維護的，那還是用面向對象最方便了。
 
25 
26 面向對象編程：
27     OOP編程是利用“類”和“對象”來創建各種模型來實現對真實世界的描述，
28     使用面向對象編程的原因一方面是因為它可以使程序的維護和擴展變得更簡單，並且可以大大提高程序開發效率 ，
29     另外，基於面向對象的程序可以使它人更加容易理解你的代碼邏輯，從而使團隊開發變得更從容。
30     核心特性：
31         class 類
32             一個類即是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具備的屬性、共同的方法。
33         object 對象
34             一個對象即是一個類的實例化後的實例，一個類必須經過實例化後方可在程序中調用，一個類可以實例化多個對象，
35             每個對象亦可以有不同的屬性，就像人類是指所有人，每個人是指具體的對象，人與人之間有共性，亦有不同。
36         封裝
37             在類中對數據的賦值、內部調用對外部用戶是透明的（這裏透明的意思是類的外部不能調用這些數據，但是類的內部可以調用），
38             這使類變成了一個膠囊或容器，裏面包含著類的數據和方法
39         繼承
40             一個類可以派生出子類，在這個父類裏定義的屬性、方法自動被子類繼承
41         多態
42             多態是面向對象的重要特性,簡單點說:“一個接口，多種實現”。
43             指一個基類(父類)中派生出了不同的子類，且每個子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是同一種事物表現出的多種形態。
44             多態允許將子類的對象當作父類的對象使用，某父類型的引用指向其子類型的對象,調用的方法是該子類型的方法。
45             這裏引用和調用方法的代碼編譯前就已經決定了,而引用所指向的對象可以在運行期間動態綁定。
46 
47 為什麽要使用面向對象編程：
48     無論用什麽形式來編程，我們都要明確記住以下原則：
49         1.寫重復代碼是非常不好的低級行為
50         2.你寫的代碼需要經常變更
51     代碼需要：可讀性好、易擴展。"""
52 
53 
54 ‘‘‘
55 #面向過程編程範例
56 def db_conn():
57     print("connecting db...")
58 
59 def db_backup(dbname):
60     print("導出數據庫",dbname)
61 
62 def db_backup_test():
63     print("將備份文件導入測試庫，看導入是否成功")
64 
65 def main():
66     db_conn()
67     db_backup(‘mysql‘)
68     db_backup_test()
69 
70 if __name__ == ‘__main__‘:
71     main()‘‘‘

二、類簡單介紹

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 class Dog(object):              #Dog是類的名稱，object是所有類的父類，被稱為基類
 5     """狗類"""
 6 
 7     def __init__(self,name):    #構造函數，初始化數據，接收參數
 8         self.name = name
 9 
10     def bulk(self):             #方法
11         """叫的方法"""
12         print("%s:wang wang wang!"%self.name)
13 
14 d1 = Dog("tom")                 #d1 是實例（又叫對象） ，d1 = Dog("tom") 這個是實例化過程 。實例化（初始化一個類，相當於造了一個對象）
15 d2 = Dog("jack")
16 d3 = Dog("tim")
17 
18 d1.bulk()                       #調用d1這個實例的 bulk() 方法
19 d2.bulk()
20 d3.bulk()

三、語法

屬性、方法、構造函數、析構函數、私有方法、私有屬性、類變量、實例變量

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 class Role(object):
 5     n = 123     #類變量（賦給了類）  類變量的用途：大家公用的屬性
 6     name = ‘我是類變量‘
 7     n_list = []
 8     n_tuple = (‘類元組‘,)
 9     def __init__(self, name, role, weapon, life_value=100, money=15000):
10         """
11         構造函數
12         作用：在實例化時做一些類的初始化的工作
13         此處的self，相當於實例化中的變量，如r1，r2 。
14         """
15         self.name = name                #實例變量（賦給了實例，又叫屬性或者靜態屬性）作用域就是實例本身
16         self.role = role                #實例變量（賦給了實例）
17         self.weapon = weapon            #實例變量（賦給了實例）
18         self.__life_value = life_value  #實例變量（賦給了實例）      #__ 表示私有屬性，類的外部不能訪問，但是類的內部可以訪問
19         self.money = money              #實例變量（賦給了實例）
20 
21     #def __del__(self):
22         """析構函數，在實例釋放，銷毀的時候自動執行的，通常用於做一些收尾工作，如關閉一些數據庫鏈接，打開的臨時文件"""
23         #print("%s 徹底撕了"%self.name)
24 
25     def shot(self):     #類的方法、此處的self，相當於實例化中的變量，如r1，r2 。（動態屬性）
26         ‘‘‘開槍方法‘‘‘
27         print("shooting...")
28 
29     def got_shot(self):#此處的self，相當於實例化中的變量，如r1，r2 。
30         ‘‘‘死亡方法‘‘‘
31         print("ah...,I got shot...")
32 
33     def buy_gun(self, gun_name):#此處的self，相當於實例化中的變量，如r1，r2 。
34         ‘‘‘買槍方法‘‘‘
35         print("%s just bought %s" %(self.name,gun_name))
36 
37     def show_status(self):
38         print("name:%s life_val:%s "%(self.name,self.__life_value))
39 
40     def __siyoufangfa(self):
41         ‘‘‘私有方法‘‘‘
42         print(‘私有方法‘)
43     def show_siyou(self):
44         self.__siyoufangfa()
45 ‘‘‘
46 #如果不賦值變量也可以，但是調用完就在內存中消失了。
47 Role(‘alnk‘, ‘police‘, ‘AK47‘).got_shot()
48 Role(‘alnk‘, ‘police‘, ‘AK47‘).got_shot()
49 註意：上面是兩個對象，不是同一個對象，在內存中的地址是不一樣的。如果想要常駐在內存中，需要賦值給一個變量，如下面的演示。‘‘‘
50 
51 ‘‘‘
52 r1 = Role(‘alnk‘, ‘police‘, ‘AK47‘) #把一個類變成一個具體對象的過程叫實例化（初始化一個類，相當於造了一個對象）
53 r2 = Role(‘Jack‘, ‘terrorist‘, ‘B22‘)  #生成一個角色
54 r1.buy_gun(‘ak47‘)      #等價於 Role.buy_gun(r1,‘ak47‘) 。類中的方法是存在類的內存中的，類是存在系統的內存中的‘‘‘
55 
56 ‘‘‘
57 #類變量和實例變量的區別
58 print(Role.n)                           #類變量存在類的內存裏
59 r1 = Role(‘alnk‘, ‘police‘, ‘AK47‘)     #實例化時，先找實例變量，再找類變量
60 r1.name = "chen"                        #修改實例化的變量
61 r1.bullet_prove = True                  #給r1實例增加新的屬性
62 print(r1.n,r1.name,r1.bullet_prove)
63 print(r1.weapon)
64 #del r1.weapon           #刪除實例變量
65 #print(r1.weapon)
66 #改變類變量
67 #Role.n = ‘從類中改變n變量‘
68 r1.n = ‘改變類變量‘      #其實是在r1的內存中中生成了 r1.n = ‘改變類變量‘的變量，並沒有真正的去改變類變量
69 print(‘r1:‘,r1.n)
70 r2 = Role(‘jack‘,‘police‘,‘m4a1‘)
71 print(‘r2:‘,r2.n)       #發現r2.n的類變量並有改變。
72 #對於列表來說。都是指向了同一個內存地址。所以類變量n_list會發生改變
73 r1.n_list.append("from r1")
74 r2.n_list.append(‘from r2‘)
75 print(r1.n_list)
76 print(r2.n_list)
77 print(Role.n_list)
78 #對於元組來說，元祖是不可變的，所以不會改變，n=123的變量一樣。
79 r1.n_tuple = (‘r1‘,)
80 print(‘r1-tuple‘,r1.n_tuple)
81 print(‘Role-tuple‘,Role.n_tuple)
82 print(‘r2-tuple‘,r2.n_tuple)‘‘‘
83 
84 ‘‘‘
85 #析構函數：在實例釋放，銷毀的時候自動執行的，通常用於做一些收尾工作，如關閉一些數據庫鏈接，打開的臨時文件
86 r1 = Role(‘tom‘, ‘police‘, ‘AK47‘)
87 r1.got_shot()
88 #del r1
89 r2 = Role(‘jack‘,‘a‘,‘b51‘)
90 r2.got_shot()‘‘‘
91 
92 ‘‘‘
93 #私有方法、私有屬性：類的外部不能訪問，但是類的內部可以訪問
94 r1 = Role(‘tom‘, ‘police‘, ‘AK47‘)
95 #print(r1.__life_value)
96 #r1.__siyoufangfa()
97 r1.show_status()    #私有屬性
98 r1.show_siyou()     #私有方法‘‘‘

四、特性

　　封裝、繼承、多態

繼承

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 #繼承的主要作用：就是節省代碼
 4 class Peopel(object):       #加了 object 為新式類
 5     def __init__(self,name,age):
 6         self.name = name
 7         self.age = age
 8         self.freind = []
 9     def eat(self):
10         print("%s is eating"%self.name)
11     def sleep(self):
12         print("%s is sleeping..."%self.name)
13     def talk(self):
14         print(‘%s is taking...‘%self.name)
15 
16 class Relation(object):
17     ‘‘‘交朋友類‘‘‘
18     def make_friends(self,obj): #obj是w1
19         print(‘%s is making friends with %s‘ %(self.name,obj.name))
20         self.freind.append(obj)
21 
22 class Man(Peopel,Relation):
23     def __init__(self,name,age,money):
24         ‘‘‘重構父類構造函數‘‘‘
25         #Peopel.__init__(self,name,age)
26         super(Man,self).__init__(name,age)      #新式類寫法
27         self.money = money
28         #print(‘%s 一出生就有：%s‘%(self.name,self.money))
29     def piao(self):
30         print(‘%s is piaoing...‘%self.name)
31     def sleep(self):
32         ‘‘‘重構父類的方法‘‘‘
33         Peopel.sleep(self)
34         print(‘man is sleeping‘)
35 
36 class Woman(Peopel,Relation):       #多繼承
37     def get_birth(self):
38         print(‘%s is born a baby ..‘%self.name)
39 
40 m1 = Man(‘tom‘,18,10)
41 w1 = Woman(‘jack‘,19)
42 # w1.get_birth()
43 # m1.eat()
44 # m1.piao()
45 # m1.sleep()
46 m1.make_friends(w1)
47 print(m1.freind[0].name)

新式類和經典類繼承的順序區別

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 #python2  經典類是按深度優先來繼承的，新式類是按廣度優先來繼承的
 5 #python3  經典類和新式類中繼承都是廣度優先      D -->B OR C -->A
 6 
 7 class A:
 8     #pass
 9     def __init__(self):
10        print("A")
11 class B(A):
12      pass
13      # def __init__(self):
14      #     print("B")
15 class C(A):
16     #pass
17     def __init__(self):
18         print("C")
19 class D(B,C):
20     pass
21     # def __init__(self):
22     #     print("D")
23 
24 obj = D()

繼承小示例---學校

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 class School(object):
 5     ‘‘‘學校類‘‘‘
 6     def __init__(self,name,addr):
 7         self.name = name
 8         self.addr = addr
 9         self.students = []
10         self.staffs = []
11 
12     def enroll(self,stu_obj):
13         ‘‘‘註冊‘‘‘
14         print(‘為學員%s 辦理註冊手續‘%stu_obj.name)
15         self.students.append(stu_obj)
16 
17     def hire(self,staff_obj):
18         ‘‘‘雇用‘‘‘
19         self.staffs.append(staff_obj)
20         print(‘雇傭新員工%s‘ % staff_obj.name)
21 
22 class SchoolMember(object):
23     ‘‘‘老師和學生類‘‘‘
24     def  __init__(self,name,age,sex):
25         self.name = name
26         self.age =age
27         self.sex = sex
28 
29     def tell(self):
30         ‘‘‘打印自己的個人信息‘‘‘
31         pass
32 
33 class Teacher(SchoolMember):
34     ‘‘‘教師類‘‘‘
35     def __init__(self,name,age,sex,salary,course):
36         super(Teacher,self).__init__(name,age,sex)
37         self.salary = salary
38         self.course = course
39 
40     def tell(self):
41         print(‘‘‘
42         --- info of Teacher: %s ---
43         name:%s
44         age:%s
45         sex:%s
46         salary:%s
47         course:%s
48         ‘‘‘ %(self.name,self.name,self.age,self.sex,self.salary,self.course))
49 
50     def teach(self):
51         print(‘%s is teaching course [%s]‘ %(self.name,self.course))
52 
53 class Student(SchoolMember):
54     ‘‘‘學生類‘‘‘
55     def __init__(self,name,age,sex,stu_id,grade):
56         super(Student,self).__init__(name,age,sex)
57         self.stu_id = stu_id
58         self.grade = grade
59 
60     def tell(self):
61         print(‘‘‘
62         --- info of Student: %s ---
63         name:%s
64         age:%s
65         sex:%s
66         stu_id:%s
67         grade:%s
68         ‘‘‘ %(self.name,self.name,self.age,self.sex,self.stu_id,self.grade))
69 
70     def pay_tuition(self,amount):
71         ‘‘‘交學費‘‘‘
72         print(‘%s has paid tuition for $[%s]‘%(self.name,amount))
73 
74 school = School("老男孩IT",‘沙河‘)                   #實例化一所學校
75 
76 t1 = Teacher(‘oldboy‘,56,‘mf‘,20000000,‘linux‘)     #實例化一個老師
77 t2 = Teacher(‘alex‘,32,‘m‘,3000,‘pythondevops‘)     #實例化一個老師
78 
79 s1 = Student(‘tom‘,22,‘mf‘,1001,‘pythondevops‘)     #實例化一個學生
80 s2 = Student(‘xu‘,19,‘mf‘,1002,‘linux‘)             #實例化一個學生
81 
82 t1.tell()                                           #調用Teacher類tell方法
83 s1.tell()                                           #調用Student類tell方法
84 
85 school.hire(t1)                                     #調用School類hire方法
86 school.enroll(s1)
87 school.enroll(s2)
88 
89 print(school.staffs)                                #查看雇傭了多少老師，這是一個內存地址
90 print(school.students)                              #查看註冊了多少學生，這是一個內存地址
91 print(‘被雇傭的老師名稱：‘,school.staffs[0].name)
92 print(‘註冊學生的名稱：‘,school.students[0].name,school.students[1].name)
93 
94 school.staffs[0].teach() #讓老師開始上課 school.staffs[0] = t1 因為school.hire(t1)中append到了self.students = []
95 t1.teach()
96 
97 for stu in school.students:#school.students = [s1,s2]
98     stu.pay_tuition(5000)
99 print(type(school.students))

多態

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 #多態：一種接口，多種實現
 4 #封裝可以隱藏實現細節，使得代碼模塊化；
 5 #繼承可以擴展已存在的代碼模塊（類）；
 6 #它們的目的都是為了——代碼重用。
 7 #而多態則是為了實現另一個目的——接口重用
 8 
 9 class Animal(object):
10     def __init__(self, name):  # Constructor of the class
11         self.name = name
12 
13     def talk(self):  # Abstract method, defined by convention only
14         #raise NotImplementedError("Subclass must implement abstract method")
15         pass
16 
17     @staticmethod
18     def animal_talk(obj):  # 相當於獨立的接口，一種接口，多種實現
19         obj.talk()
20 
21 class Cat(Animal):
22     def talk(self):
23         print(‘%s: 喵喵喵!‘ % self.name)
24 
25 class Dog(Animal):
26     def talk(self):
27         print(‘%s: 汪！汪！汪！‘ % self.name)
28 
29 # def animal_talk(obj):       #相當於獨立的接口，一種接口，多種實現
30 #     obj.talk()
31 
32 d = Dog(‘tom‘)
33 #d.talk()
34 c =Cat(‘mao‘)
35 #c.talk()
36 
37 # animal_talk(d)
38 # animal_talk(c)
39 Animal.animal_talk(d)       #相當於了一種接口，多種實現了需求
40 Animal.animal_talk(c)

python3自動化學習06