一、面向對象入門

概述

• 面向過程：根據業務邏輯從上到下寫壘代碼
• 函數式：將某功能代碼封裝到函數中，日後便無需重復編寫，僅調用函數即可
• 面向對象：對函數進行分類和封裝，讓開發“更快更好更強...”

面向對象初識

創建類和對象

面向對象編程是一種編程方式，此編程方式的落地需要使用 “類” 和 “對象” 來實現，所以，面向對象編程其實就是對 “類” 和 “對象” 的使用。

　　類就是一個模板，模板裏可以包含多個函數，函數裏實現一些功能

　　對象則是根據模板創建的實例，通過實例對象可以執行類中的函數

• class是關鍵字，表示類
• 創建對象，類名稱後加括號即可

總結：函數式的應用場景 --> 各個函數之間是獨立且無共用的數據

　　　面向對象的應用場景 ：

1. 1. 如果多個函數須傳入多個共同的參數時
   2. 根據一個模板創建某些東西時
   3. 需要執行很多重復的操作時　　

面向對象三大特性

面向對象的三大特性是指：封裝、繼承和多態。

一、封裝

封裝，顧名思義就是將內容封裝到某個地方，以後再去調用被封裝在某處的內容。

 1 class Role(object):
 2 
 3     nationality = "China"  # 公有靜態字段
 4 
 5     def __init__(self, name, sex, age):
 
 6         self.name = name  # 公有字段
 7         self.sex = sex
 8         self.age = age
 9         self.__life_value = 100  # 私有字段
10 
11     def eat(self, food):  # 普通方法
12         print("%s is eating %s" % (self.name, food))
13 
14     def talk(self, msg):
15         print("%s is talking:%s" % (self.name, msg))
 
16 
17 
18 r1 = Role("Profhua", "M", 25)
19 r2 = Role("Wolf", "M", 25)
20 r1.eat("包子")
21 r1.nationality = "JP"  # 相當於在對象r1中克隆了一個nationality
22 print(r1.nationality)
23 print(r2.nationality)
24 Role.nationality = "US"  # 改變了公有靜態字段
25 print(r1.nationality)
26 print(r2.nationality)

類的組合：

 1 class F1:
 2     def __init__(self, n):
 3         self.N = n
 4         print(‘F1‘)
 5 
 6 
 7 class F2:
 8     def __init__(self, arg1):
 9         self.a = arg1
10         print(‘F2‘)
11 
12 
13 class F3:
14     def __init__(self, arg2):
15         self.b = arg2
16         print(‘F3‘)
17 
18 
19 o1 = F1(‘alex‘)
20 
21 o2 = F2(o1)
22 
23 o3 = F3(o2)
24 
25 # ###### 輸出Alex:o3.b.a.N #######
26 
27 print(o3.b.a.N)

總結：對於面向對象的封裝來說，其實就是使用構造方法將內容封裝到 對象 中，然後通過對象直接或者self間接獲取被封裝的內容

二、繼承

通過父類 ===》子類的方式以最小代碼量的方式實現不同角色的共同點和不同點同時存在

 1 class Person(object):
 2 
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6 
 7     def talk(self):
 8         print("Person [%s] is talking" % self.name)
 9 
10     def eat(self):
11         print("Person [%s] is eating" % self.name)
12 
13 
14 class BlackPerson(Person):
15 
16     def __init__(self, name, age, strength):
17         Person.__init__(self, name, age)
18         self.strength = strength
19 
20     def talk(self):
21         print("BlackPerson [%s] is talking" % self.name)
22 
23 
24 b = BlackPerson("小黑", 25, "Strong")
25 b.talk()
26 print(b.strength)

所以，對於面向對象的繼承來說，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而不必一一實現每個方法。

多繼承

 1 class A:
 2 
 3     def __init__(self):
 4         self.n = "A"
 5 
 6 
 7 class B(A):
 8     pass
 9     # def __init__(self):
10     #     self.n = "B"
11 
12 
13 class C(A):
14     def __init__(self):
15         self.n = "C"
16 
17 
18 class D(B, C):
19     pass
20     # def __init__(self):
21     #     self.n = "D"
22 d = D()
23 print(d.n)

1、Python的類可以繼承多個類，Java和C#中則只能繼承一個類

2、Python的類如果繼承了多個類，那麽其尋找方法的方式在Pyhton3中是廣度優先

註：在Python3中不管是新式類還是經典類在多繼承時都是廣度優先 ； 在Python2中經典類多繼承是深度優先，新式類是廣度優先

三、多態

Pyhon不支持Java和C#這一類強類型語言中多態的寫法，但是原生多態

Python多態示例

 1 class Animal(object):
 2     def __init__(self, name):  # Constructor of the class
 3         self.name = name
 4 
 5     def talk(self):  # Abstract method, defined by convention only
 6         raise NotImplementedError("Subclass must implement abstract method")
 7 
 8 
 9 class Cat(Animal):
10     def talk(self):
11         print(‘%s: 喵喵喵!‘ % self.name)
12 
13 
14 class Dog(Animal):
15     def talk(self):
16         print(‘%s: 汪！汪！汪！‘ % self.name)
17 
18 
19 def func(obj):  # 一個接口，多種形態
20     obj.talk()
21 
22 
23 c1 = Cat(‘小晴‘)
24 d1 = Dog(‘李磊‘)
25 
26 func(c1)
27 func(d1)

總結

以上就是本節對於面向對象初級知識的介紹，總結如下：

• 面向對象是一種編程方式，此編程方式的實現是基於對 類 和 對象 的使用
• 類 是一個模板，模板中包裝了多個“函數”供使用
• 對象，根據模板創建的實例（即：對象），實例用於調用被包裝在類中的函數
• 面向對象三大特性：封裝、繼承和多態

二、作業

選課系統：

角色:學校、學員、課程、講師
要求:
1. 創建北京、上海 2 所學校
2. 創建linux , python , go 3個課程 ， linux\py 在北京開， go 在上海開
3. 課程包含，周期，價格，通過學校創建課程
4. 通過學校創建班級， 班級關聯課程、講師
5. 創建學員時，選擇學校，關聯班級
5. 創建講師角色時要關聯學校，
6. 提供兩個角色接口
6.1 學員視圖， 可以註冊， 交學費， 選擇班級，
6.2 講師視圖， 講師可管理自己的班級， 上課時選擇班級， 查看班級學員列表 ， 修改所管理的學員的成績
6.3 管理視圖，創建講師， 創建班級，創建課程

7. 上面的操作產生的數據都通過pickle序列化保存到文件裏

Python Day6