Python 3.x--面向對象編程

面向對象的幾個核心特性以下：

Class 類
一個類便是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具有的屬性（variables(data)）、共同的方法

Object 對象 
一個對象便是一個類的實例化後實例，一個類必須通過實例化後方可在程序中調用，一個類能夠實例化多個對象，每一個對象亦能夠有不一樣的屬性，就像人類是指全部人，每一個人是指具體的對象，人與人以前有共性，亦有不一樣

Encapsulation 封裝
在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，裏面包含着類的數據和方法

Inheritance 繼承
一個類能夠派生出子類，在這個父類裏定義的屬性、方法自動被子類繼承

Polymorphism 多態
多態是面向對象的重要特性,簡單點說:「一個接口，多種實現」，指一個基類中派生出了不一樣的子類，且每一個子類在繼承了一樣的方法名的同時又對父類的方法作了不一樣的實現，這就是同一種事物表現出的多種形態。
編程其實就是一個將具體世界進行抽象化的過程，多態就是抽象化的一種體現，把一系列具體事物的共同點抽象出來, 再經過這個抽象的事物, 與不一樣的具體事物進行對話。
對不一樣類的對象發出相同的消息將會有不一樣的行爲。好比，你的老闆讓全部員工在九點鐘開始工做, 他只要在九點鐘的時候說：「開始工做」便可，而不須要對銷售人員說：「開始銷售工做」，對技術人員說：「開始技術工做」, 由於「員工」是一個抽象的事物, 只要是員工就能夠開始工做，他知道這一點就好了。至於每一個員工，固然會各司其職，作各自的工做。
多態容許將子類的對象看成父類的對象使用，某父類型的引用指向其子類型的對象,調用的方法是該子類型的方法。這裏引用和調用方法的代碼編譯前就已經決定了,而引用所指向的對象能夠在運行期間動態綁定

 

面向對象編程的相關概念：

 1 #定義一個類
 2 class role:
 3     n = 'abc'   #類變量
 4     l = []
 5     #構造函數
 6     #self至關於實例化的變量名
 7     def __init__(self,name,role,job,lifetime = 30,money = 1500):
 8         self.name = name   #實例變量（靜態屬性），做用於實例自己
 9         self.role = role
10         self.job = job
11         self.__lifetime = lifetime   #私有屬性
12         self.money = money
13     #私有屬性在內部能夠調用
14     def private_arg(self):
15         print('%s is %s years old'%(self.name,self.__lifetime))
16     #私有方法
17     def __private_fun(self):
18         pass
19 
20     #析構函數，用於實例調用結束或刪除時，處理一些數據庫關閉，臨時文件等
21     def __del__(self):
22         pass
23 
24     def shopping(self,thing_name):   #方法（動態屬性），類的方法
25         print('%s is buy a %s'%(self.name,thing_name))
26 
27     def exercise(self):
28         print('%s is playing basketball'%self.name)
29 
30 
31 r1 = role('coco','police','patrol')   #實例化一個對象r1
32 r1.l.append(r1.name)   #處理列表時使用同一個內存空間，則一個實例調用list，進行處理，其餘實例也能展現處理後的結果
33 r2 = role('yoyo','seller','sell')   #實例化一個對象r2
34 r1.name = 'feifei'   #修改傳入變量
35 r1.salary = 2000   #增長一個變量
36 #del r1.salary   #刪除變量
37 r1.n = 'ef'   #修改類變量，只做用於該實例，至關於從新生成一個變量
38 
39 r1.shopping('bag')
40 r1.exercise()
41 print(r1.name,r1.salary,r1.n,r2.n)
42 print(r1.l,r2.l)
43 #print(r1.__lifetime)   #私有後不能直接調用
44 r1.private_arg()   #從新定義一個函數能夠調用私有屬性

 

單繼承實例：

 1 #class people:   #經典類
 2 class people(object):   #新式類
 3     def __init__(self,name,age):
 4         self.name = name
 5         self.age = age
 6 
 7     def eat(self):
 8         print('%s is eating food...'%self.name)
 9 
10     def sleep(self):
11         print('%s is sleeping'%self.name)
12 
13     def talk(self):
14         pass
15 
16 #Man繼承people類
17 class Man(people):
18     #對構造函數的重構
19     def __init__(self,name,age,tool):
20         #people.__init__(self,name,age)  #調用父類的方法（經典類）
21         super(Man,self).__init__(name,age)#調用父類另外一種方法（新式類）
22         self.tool = tool
23         print("%s use %s hunt"%(self.name,self.tool))
24 
25     #本身定義的一個方法
26     def hunting(self):
27         print("%s is fond of hunting..."%self.name)
28 
29     #重構一個父類的方法
30     def sleep(self):
31         people.sleep(self)   #調用父類的方法
32         print("%s is sleeping on the stone..."%self.name)
33 
34 #Woman繼承people類
35 class Woman(people):
36     def sweep(self):
37         print("%s is cleaning the house..."% self.name)
38 
39 m1 = Man('LiMing',22,'bow')
40 m1.eat()
41 m1.hunting()
42 m1.sleep()
43 
44 w1 = Woman('MeiMei',18)
45 w1.sweep()

 

多繼承實例：

 1 #class people:   #經典類
 2 class people(object):   #新式類
 3     def __init__(self,name,age):
 4         self.name = name
 5         self.age = age
 6 
 7     def eat(self):
 8         print('%s is eating food...'%self.name)
 9 
10     def sleep(self):
11         print('%s is sleeping'%self.name)
12 
13     def talk(self):
14         pass
15 
16 class Relation(object):
17     def marry(self,obj):
18         print("%s had married %s"%(self.name,obj.name))
19 
20 #Man繼承people類
21 class Man(people,Relation):
22     #對構造函數的重構
23     def __init__(self,name,age,tool):
24         #people.__init__(self,name,age)  #調用父類的方法（經典類）
25         super(Man,self).__init__(name,age)#調用父類另外一種方法（新式類）
26         self.tool = tool
27         print("%s use %s hunt"%(self.name,self.tool))
28 
29     #本身定義的一個方法
30     def hunting(self):
31         print("%s is fond of hunting..."%self.name)
32 
33     #重構一個父類的方法
34     def sleep(self):
35         people.sleep(self)   #調用父類的方法
36         print("%s is sleeping on the stone..."%self.name)
37 
38 #Woman繼承people類
39 class Woman(people,Relation):
40     def sweep(self):
41         print("%s is cleaning the house..."% self.name)
42 
43 m1 = Man('LiMing',22,'bow')
44 w1 = Woman('MeiMei',18)
45 
46 m1.marry(w1)

 

繼承順序：

 1 '''
 2 python2.X:經典類使用深度優先，新式類使用廣度優先
 3 python3.X:都是使用廣度優先
 4 '''
 5 class A:
 6     def __init__(self):
 7         print("from A")
 8 
 9 class B(A):
10     pass
11     # def __init__(self):
12     #     print("from B")
13 
14 class C(A):
15     pass
16     # def __init__(self):
17     #     print("from C")
18 
19 class D(C,B):
20     pass
21     # def __init__(self):
22     #     print("from D")
23 
24 obj = D()

 

多態：

 

 1 class Animal:
 2     def __init__(self,name):
 3         self.name = name
 4 
 5     @staticmethod
 6     def animal_bark(obj):
 7         obj.bark()
 8 
 9 class Cat(Animal):
10     def bark(self):
11         print("aaa...")
12 
13 class Dog(Animal):
14     def bark(self):
15         print("bbb...")
16 
17 #外部調用同一接口
18 # def animal_bark(obj):
19 #     obj.bark()
20 
21 c = Cat("MiMi")
22 #c.bark()
23 d = Dog("DuoDuo")
24 #d.bark()
25 
26 Animal.animal_bark(c)
27 Animal.animal_bark(d)