Python面向對象

	自從存在以來，Python一直是面向對象的語言。 因此，創建和使用類和對象是非常容易的。 下面將學習
如何使用Python面向對象編程。

1. 面向過程與面向對象

編程範式
	特定的語法+數據結構+算法，一個程序是程序員爲了得到一個任務結果而編寫的一組指令的集合。
	
	正所謂條條大路通羅馬，實現一個任務的方式有很多種不同的方式， 對這些不同的編程方式的特點
進行歸納總結得出來的編程方式類別，即爲編程範式。 

	兩種最重要的編程範式分別是面向過程編程和麪向對象編程。

1.1 面向過程編程(Procedural Programming)

	Procedural programming uses a list of instructions to tell the computer 
what to do step-by-step. 

	面向過程編程依賴 - 你猜到了- procedures，一個procedure包含一組要被進行計算的步驟， 面向過程
又被稱爲top-down languages， 就是程序從上到下一步步執行，一步步從上到下，從頭到尾的解決問題 。
基本設計思路就是程序一開始是要着手解決一個大的問題，然後把一個大問題分解成很多個小問題或子過程，
這些子過程再執行的過程再繼續分解直到小問題足夠簡單到可以在一個小步驟範圍內解決。

面向過程的簡單例子：
#連接數據庫
def db_conn():
    print("connecting db...")

#數據庫備份
def db_backup(dbname):
    print("導出數據庫...",dbname)
    print("將備份文件打包，移至相應目錄...")

#數據庫備份測試 
def db_backup_test():
    print("將備份文件導入測試庫，看導入是否成功")

#main函數 
def main():
    db_conn()
    db_backup('my_db')
    db_backup_test()

#調用main函數
if __name__ == '__main__':
    main()
	這樣做的問題也是顯而易見的，就是如果你要對程序進行修改，對你修改的那部分有依賴的各個部分
你都也要跟着修改。 舉個例子，如果程序開頭你設置了一個變量值 爲1 ，但如果其它子過程依賴這個值
爲1的變量才能正常運行，那如果你改了這個變量，那這個子過程你也要修改，假如又有一個其它子程序依
賴這個子過程 ， 那就會發生一連串的影響，隨着程序越來越大， 這種編程方式的維護難度會越來越高。

1.2 面向對象編程

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

面向對象的幾個核心特性如下:
Class 類
	一個類即是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具備的屬性
（variables(data)）、共同的方法

Object 對象 
	一個對象即是一個類的實例化後實例，一個類必須經過實例化後方可在程序中調用，一個類可以實例化多個
對象，每個對象亦可以有不同屬性，就像人類是指所有人，每個人是指具體的對象，人與人之間有共性也有不同

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

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

Polymorphism 多態
	多態是面向對象的重要特性,簡單點說:“一個接口，多種實現”，指一個基類中派生出了不同的子類，且每個
子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是同一種事物表現出的多種形態。

	編程其實就是一個將具體世界進行抽象化的過程，多態就是抽象化的一種體現，把一系列具體事物的共同點
抽象出來, 再通過這個抽象的事物, 與不同的具體事物進行對話。

2. 面向對象編程介紹


無論用什麼形式來編程，我們都要明確記住以下原則：
1.	寫重複代碼是非常不好的低級行爲
2.	你寫的代碼需要經常變更 

	開發正規的程序跟那種寫個運行一次就扔了的小腳本一個很大不同就是，你的代碼總是需要不斷的更改，
不是修改bug就是添加新功能等，所以爲了日後方便程序的修改及擴展，你寫的代碼一定要遵循易讀、易改的
原則（專業數據叫可讀性好、易擴展）

相信大家都打過CS遊戲吧，我們就自己開發一個簡單版的CS來玩一玩。
	暫不考慮開發場地等複雜的東西，我們先從人物角色下手， 角色很簡單，就倆個，恐怖份子、警察，他們
除了角色不同，其它基本都 一樣，每個人都有生命值、武器等。 咱們先用非OOP的方式寫出遊戲的基本角色。
#role 1
name = 'Alex'
role = 'terrorist'
weapon = 'AK47'
life_value = 100
 
#rolw 2
name2 = 'Jack'
role2 = 'police'
weapon2 = 'B22'
life_value2 = 100

	上面定義了一個恐怖份子Alex和一個警察Jack,但只2個人不好玩呀，一干就死了，沒意思，那我們再分別
加入一個恐怖分子和警察吧
#role 1
name = 'Alex'
role = 'terrorist'
weapon = 'AK47'
life_value = 100
money = 10000
 
#rolw 2
name2 = 'Jack'
role2 = 'police'
weapon2 = 'B22'
life_value2 = 100
money2 = 10000
 
#role 3
name3 = 'Rain'
role3 = 'terrorist'
weapon3 = 'C33'
life_value3 = 100
money3 = 10000
 
#rolw 4
name4 = 'Eric'
role4 = 'police'
weapon4 = 'B51'
life_value4 = 100
money4 = 10000

	4個角色雖然創建好了，但是有個問題就是，每創建一個角色，我都要單獨命名，name1,name2,name3,
name4…，後面的調用的時候這個變量名你還都得記着，要是再讓多加幾個角色，估計調用時就很容易弄混啦，
所以我們想一想，能否所有的角色的變量名都是一樣的，但調用的時候又能區分開分別是誰？ 
 
當然可以，我們只需要把上面的變量改成字典的格式就可以啦。
roles = {
    1:{'name':'Alex',
       'role':'terrorist',
       'weapon':'AK47',
       'life_value': 100,
       'money': 15000,
       },
    2:{'name':'Jack',
       'role':'police',
       'weapon':'B22',
       'life_value': 100,
        'money': 15000,
       },
    3:{'name':'Rain',
       'role':'terrorist',
       'weapon':'C33',
       'life_value': 100,
       'money': 15000,
       },
    4:{'name':'Eirc',
       'role':'police',
       'weapon':'B51',
       'life_value': 100,
       'money': 15000,
       },
}
 
print(roles[1]) #Alex
print(roles[2]) #Jack

	很好，這個以後調用這些角色時只需要roles[1],roles[2]就可以啦，角色的基本屬性設計完了後，我們
接下來爲每個角色開發以下幾個功能
1.	被打中後就會掉血的功能
2.	開槍功能
3.	換子彈
4.	買槍
5.	跑、走、跳、下蹲等動作
6.	保護人質（僅適用於警察）
7.	不能殺同伴
8.	。。。
	我們可以把每個功能寫成一個函數，類似如下：
def shot(by_who):
    #開了槍後要減子彈數
    pass
def got_shot(who):
    #中槍後要減血
    who[‘life_value’] -= 10
    pass
def buy_gun(who,gun_name):
    #檢查錢夠不夠,買了槍後要扣錢
    pass
...
	繼續按照這個思路設計，再完善一下代碼，遊戲的簡單版就出來了，但是在往下走之前，我們來看看上面
的這種代碼寫法有沒有問題，至少從上面的代碼設計中，我看到以下幾點缺陷：

	每個角色定義的屬性名稱是一樣的，但這種命名規則是我們自己約定的，從程序上來講，並沒有進行屬性
合法性檢測，也就是說role 1定義的代表武器的屬性是weapon, role 2 ,3,4也是一樣的，不過如果我在新增
一個角色時不小心把weapon 寫成了wepon , 這個程序本身是檢測 不到的。

	terrorist 和police這2個角色有些功能是不同的，比如police是不能殺人質的，但是terrorist可能，
隨着這個遊戲開發的更復雜，我們會發現這2個角色後續有更多的不同之處， 但現在的這種寫法，我們是沒辦
法 把這2個角色適用的功能區分開來的，也就是說，每個角色都可以直接調用任意功能，沒有任何限制。

	我們在上面定義了got_shot()後要減血，也就是說減血這個動作是應該通過被擊中這個事件來引起的,
我們調用get_shot()，got_shot（）這個函數再調用每個角色裏的life_value變量來減血。 但其實我不通
過got_shot()，直接調用角色roles[role_id][‘life_value’] 減血也可以呀，但是如果這樣調用的話，
那可以就是簡單粗暴啦，因爲減血之前其它還應該判斷此角色是否穿了防彈衣等，如果穿了的話，傷害值肯定
要減少，got_shot()函數裏就做了這樣的檢測，你這裏直接繞過的話，程序就亂了。 因此這裏應該設計成除了
通過got_shot(),其它的方式是沒有辦法給角色減血的，不過在上面的程序設計裏，是沒有辦法實現的。
	
	現在需要給所有角色添加一個可以穿防彈衣的功能，那很顯然你得在每個角色裏放一個屬性來存儲此角色
是否穿了防彈衣，那就要更改每個角色的代碼，給添加一個新屬性，這樣太low了，不符合代碼可複用的原則

之前的代碼改成用OOP中的“類”來實現的話如下：
class Role(object):
    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
    def shot(self):
        print("shooting...")
    def got_shot(self):
        print("ah...,I got shot...")
    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)

r1 = Role('Alex', 'police','AK47')  #生成一個角色
r2 = Role('Jack', 'terrorist','B22')#生成一個角色

先不考慮語法細節，相比靠函數拼湊出來的寫法，上面用面向對象中的類來寫最直接的改進有以下2點：
1.	代碼量少了近一半
2.	角色和它所具有的功能可以一目瞭然看出來

在真正開始分解上面代碼含義之之前，我們現來了解一些類的基本定義

2.1 類的語法

class Dog(object):
    print("hello,I am a dog!")
    
d = Dog() #實例化這個類，
#此時的d就是類Dog的實例化對象
#實例化，其實就是以Dog類爲模版，在內存裏開闢一塊空間，存上數據，賦值成一個變量名

上面的代碼其實有問題，想給狗起名字傳不進去。
class Dog(object):
    def __init__(self, name, dog_type):
        self.name = name
        self.type = dog_type
    def sayhi(self):
        print("hello,I am a dog, my name is ", self.name)

d = Dog('LiChuang', "京巴")
d.sayhi()

爲什麼有__init__? 爲什麼有self? 此時的你一臉蒙逼，相信不畫個圖，你的智商是理解不了的！　　
畫圖之前， 你先註釋掉這兩句
# d = Dog('小白', "京巴")
# d.sayhi()
print(Dog)

沒實例直接打印Dog輸出如下
<class '__main__.Dog'>
這代表什麼?代表 即使不實例化，這個Dog類本身也是已經存在內存裏的對不對， yes, cool，那實例化時，
會產生什麼化學反應呢？

根據上圖我們得知，其實self,就是實例本身！你實例化時python會自動把這個實例本身通過self參數傳進去。
你說好吧，假裝懂了， 但下面這段代碼你又不明白了， 爲何sayhi(self),要寫個self呢？

好了，明白 了類的基本定義，接下來我們一起分解一下上面的代碼分別 是什麼意思。
#定義一個類， class是定義類的語法，Role是類名，(object)是新式類的寫法，必須這樣寫，以後講爲什麼
class Role(object):
    # 初始化函數，在生成一個角色時要初始化的一些屬性就填寫在這裏
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        # __init__中的第一個參數self,和這裏的self都 是什麼意思？ 看下面解釋
        self.name = name 
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
上面的這個__init__()叫做初始化方法(或構造方法)， 在類被調用時，這個方法(雖然它是函數形式，但在
類中就不叫函數了,叫方法)會自動執行，進行一些初始化的動作，所以我們這裏寫的
__init__(self,name,role,weapon,life_value=100,money=15000)就是要在創建一個角色時給它設置
這些屬性，那麼這第一個參數self是幹毛用的呢？

初始化一個角色，就需要調用這個類一次：
r1 = Role('Alex', 'police','AK47')  #生成一個角色，會自動把參數傳給Role下面的__init__(...)
r2 = Role('Jack', 'terrorist','B22')#生成一個角色

我們看到，上面的創建角色時，我們並沒有給__init__傳值，程序也沒未報錯，是因爲，類在調用它自己的
__init__(…)時自己幫你給self參數賦值了，
r1 = Role('Alex','police','AK47’) #此時self 相當於 r1 ,  Role(r1,'Alex','police','AK47’)
r2 = Role('Jack','terrorist','B22’)#此時self 相當於 r2, Role(r2,'Jack','terrori

爲什麼這樣子？你拉着我說你有些猶豫，怎麼會這樣子？
你執行r1 = Role('Alex','police','AK47’)時，python的解釋器其實幹了兩件事：
1.	在內存中開闢一塊空間指向r1這個變量名
2.	調用Role這個類並執行其中的__init__(…)方法，相當於
Role.__init__(r1,'Alex','police',’AK47’),
這麼做是爲什麼呢？ 是爲了把'Alex','police',’AK47’這3個值跟剛開闢的r1關聯起來，是爲了把'Alex',
'police',’AK47’這3個值跟剛開闢的r1關聯起來，是爲了把'Alex','police',’AK47’這3個值跟剛開闢的
r1關聯起來，重要的事情說3次， 因爲關聯起來後，你就可以直接r1.name, r1.weapon 這樣來調用啦。
所以，爲實現這種關聯，在調用__init__方法時，就必須把r1這個變量也傳進去，否則__init__不知道要把
那3個參數跟誰關聯呀。
3.	所以這個__init__(…)方法裏的，self.name = name , self.role = role 等等的意思就是要把這幾
個值存到r1的內存空間裏。

爲了暴露自己的智商，此時你假裝懂了，但又問， __init__(…)我懂了，但後面的那幾個函數，噢 不對，
後面那幾個方法 爲什麼也還需要self參數麼？ 不是在初始化角色的時候 ，就已經把角色的屬性跟r1綁定
好了麼？ 

good question, 先來看一下上面類中的一個buy_gun的方法：
    def buy_gun(self, gun_name):
        print("% s has just bought % s" % (self.name, gun_name))

上面這個方法通過類調用的話要寫成如下：
r1 = Role('Alex','police','AK47')
r1.buy_gun("B21”) #python 會自動幫你轉成 Role.buy_gun(r1,”B21")
執行結果
#Alex has just bought B21 
依然沒給self傳值 ，但Python還是會自動的幫你把r1 賦值給self這個參數， 爲什麼呢？ 因爲，你在
buy_gun(..)方法中可能要訪問r1的一些其它屬性呀， 比如這裏就訪問了r1的名字，怎麼訪問呢？你得告訴
這個方法呀，於是就把r1傳給了這個self參數，然後在buy_gun裏調用 self.name 就相當於調用r1.name啦，
如果還想知道r1的生命值 有多少，直接寫成self.life_value就可以了。 說白了就是在調用類中的一個方法
時，你得告訴人家你是誰。
 
好啦， 總結一下2點：
1.	上面的這個r1 = Role('Alex','police','AK47’)動作，叫做類的“實例化”， 就是把一個虛擬的抽象
的類，通過這個動作，變成了一個具體的對象了， 這個對象就叫做實例。
2.	剛纔定義的這個類體現了面向對象的第一個基本特性，封裝，其實就是使用構造方法將內容封裝到某個具體
對象中，然後通過對象直接或者self間接獲取被封裝的內容。

2.2 面向對象的特性

1. 封裝
	封裝最好理解了。封裝是面向對象的特徵之一，是對象和類概念的主要特性。
	封裝，也就是把客觀事物封裝成抽象的類，並且類可以把自己的數據和方法只讓可信的類或者對象操作，
對不可信的進行信息隱藏。

2. 繼承
	面向對象編程 (OOP) 語言的一個主要功能就是“繼承”。繼承是指這樣一種能力：它可以使用現有類的
所有功能，並在無需重新編寫原來的類的情況下對這些功能進行擴展。

	通過繼承創建的新類稱爲“子類”或“派生類”。
	被繼承的類稱爲“基類”、“父類”或“超類”。
	繼承的過程，就是從一般到特殊的過程。
	要實現繼承，可以通過“繼承”（Inheritance）和“組合”（Composition）來實現。
	在某些 OOP 語言中，一個子類可以繼承多個基類。但是一般情況下，一個子類只能有一個基類，要實現
多重繼承，可以通過多級繼承來實現。

	繼承概念的實現方式主要有2類：實現繼承、接口繼承。
	Ø 實現繼承是指使用基類的屬性和方法而無需額外編碼的能力；
	Ø 接口繼承是指僅使用屬性和方法的名稱、但是子類必須提供實現的能力(子類重構爹類方法)；
	
	在考慮使用繼承時，有一點需要注意，那就是兩個類之間的關係應該是“屬於”關係。例如，Employee 是
一個人，Manager 也是一個人，因此這兩個類都可以繼承 Person 類。但是 Leg 類卻不能繼承 Person 類，
因爲腿並不是一個人。
 
抽象類僅定義將由子類創建的一般屬性和方法。
OO開發範式大致爲：
	劃分對象→抽象類→將類組織成爲層次化結構(繼承和合成) →用類與實例進行設計和實現幾個階段。

繼承實例：
class SchoolMember(object):
    members = 0  # 初始學校人數爲0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def tell(self):
        pass

    def enroll(self):
        '''註冊'''
        SchoolMember.members += 1
        print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m "\
              % (self.name, SchoolMember.members))

    def __del__(self):
        '''析構方法'''
        print("\033[31;1mmember [%s] is dead!\033[0m" % self.name)


class Teacher(SchoolMember):
    def __init__(self, name, age, course, salary):
        super(Teacher, self).__init__(name, age)
        self.course = course
        self.salary = salary
        self.enroll()

    def teaching(self):
        '''講課方法'''
        print("Teacher [%s] is teaching [%s] for class [%s]" \
              % (self.name, self.course, 's12'))

    def tell(self):
        '''自我介紹方法'''
        msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' \
              %(self.name, 'Oldboy', self.course)
        print(msg)


class Student(SchoolMember):
    def __init__(self, name, age, grade, sid):
        super(Student, self).__init__(name, age)
        self.grade = grade
        self.sid = sid
        self.enroll()

    def tell(self):
        '''自我介紹方法'''
        msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' \
              % (self.name, self.grade, 'Oldboy')
        print(msg)


if __name__ == '__main__':
    t1 = Teacher("Alex", 22, 'Python', 20000)
    t2 = Teacher("TengLan", 29, 'Linux', 3000)

    s1 = Student("Qinghua", 24, "Python S12", 1483)
    s2 = Student("SanJiang", 26, "Python S12", 1484)

    t1.teaching()
    t2.teaching()
    t1.tell()

3. 多態
	多態性（polymorphisn）是允許你將父對象設置成爲和一個或更多的他的子對象相等的技術，賦值之後，
父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作。簡單的說，就是一句話：允許將子類類型
的指針賦值給父類類型的指針。
	那麼，多態的作用是什麼呢？我們知道，封裝可以隱藏實現細節，使得代碼模塊化；繼承可以擴展已存在
的代碼模塊（類）；它們的目的都是爲了——代碼重用。而多態則是爲了實現另一個目的——接口重用！多態的作
用，就是爲了類在繼承和派生的時候，保證使用“家譜”中任一類的實例的某一屬性時的正確調用。
 
	Pyhon 很多語法都是支持多態的，比如 len(),sorted(), 你給len傳字符串就返回字符串的長度，傳列表
就返回列表長度。
多態示例：
class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):  # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")


class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)


class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)

def func(obj):  # 一個接口，多種形態
    obj.talk()

c1 = Cat('小晴')
d1 = Dog('李磊')

func(c1)
func(d1)

4. 領域模型
	好了，你現在會了面向對象的各種語法了， 那請看下本章最後的作業需求，我相信你可能是矇蔽的， 很多
同學都是學會了面向對象的語法，卻依然寫不出面向對象的程序，原因是什麼呢？原因就是因爲你還沒掌握一門
面向對象設計利器， 你說我讀書少別騙我， 什麼利器？ 
	答案就是:領域建模。 從領域模型開始,我們就開始了面向對象的分析和設計過程,可以說,領域模型是完成
從需求分析到面向 對象設計的一座橋樑。 
 
	領域模型,顧名思義,就是需求所涉及的領域的一個建模,更通俗的講法是業務模型。 參考百度百科
(https://baike.baidu.com/item/%E9%A2%86%E5%9F%9F%E6%A8%A1%E5%9E%8B/1022567?fr=aladdin ),
領域模型定義如下: 
從這個定義我們可以看出,領域模型有兩個主要的作用:
1.	發掘重要的業務領域概念
2.	建立業務領域概念之間的關係 

領域建模三字經 
	領域模型如此重要,很多同學可能會認爲領域建模很複雜,需要很高的技巧。然而事實上領域建模非常簡單,
簡單得有點難以讓人相信,領域建模的方法概括一下就是“找名詞”! 許多同學看到這個方法後估計都會笑出來:
太假了吧,這麼簡單,找個初中生都會啊,那我們公司那些分 析師和設計師還有什麼用哦?
	分析師和設計師當然有用,後面我們會看到,即使是簡單的找名詞這樣的操作,也涉及到分析和提煉,而不是
簡單的摘取出來就可,這種情況下分析師和設計師的經驗和技能就能夠派上用場了。但領域模型分析 也確實相對
簡單,即使沒有豐富的經驗和高超的技巧,至少也能完成一個能用的領域模型。 
	雖然我們說“找名詞”很簡單,但一個關鍵的問題還沒有說明:從哪裏找? 如果你還記得領域模型是“需求到面
向對象的橋樑”,那麼你肯定一下子就能想到:從需求模型中找,具 體來說就是從用例中找。 
 
	歸納一下域建模的方法就是“從用例中找名詞”。 當然,找到名詞後,爲了能夠更加符合面向對象的要求和
特點,我們還需要對這些名詞進一步完善,這就 是接下來的步驟:加屬性,連關係! 

最後我們總結出領域建模的三字經方法:找名詞、加屬性、連關係。

找名詞
 
who : 學員、講師、管理員
用例：
1. 管理員 創建了 北京 和 上海 兩個校區
2. 管理員 創建了 Linux \ Python \ Go 3個課程 
3. 管理員 創建了 北京校區的Python 16期， Go開發第一期，和上海校區的Linux 36期 班級
4. 管理員 創建了 北京校區的 學員 小晴 ，並將其 分配 在了 班級  python 16期 
5. 管理員 創建了 講師 Alex , 並將其分配 給了 班級 python 16期 和全棧脫產5期
6. 講師 Alex 創建 了一條 python 16期的 上課紀錄 Day6 
7. 講師 Alex 爲Day6這節課 所有的學員 批了作業 ，小晴得了A, 李磊得了C-, 嚴帥得了B
8. 學員小晴 在 python 16 的 day6裏 提交了作業 
9. 學員李磊 查看了自己所報的所有課程 
10 學員 李磊  在 查看了 自己在 py16期 的 成績列表 ，然後自殺了
11. 學員小晴  跟 講師 Alex 表白了

名詞列表：
管理員、校區、課程、班級、上課紀錄、作業、成績、講師、學員

加屬性

連關係 
	有了類,也有了屬性,接下來自然就是找出它們的關係了。

作業

本節作業: 選課系統
角色:學校、學員、課程、講師
要求:
1. 創建北京、上海 2 所學校
2. 創建linux , python , go 3個課程 ， linux\py 在北京開， go 在上海開
3. 課程包含，週期，價格，通過學校創建課程 
4. 通過學校創建班級， 班級關聯課程、講師
5. 創建學員時，選擇學校，關聯班級
5. 創建講師角色時要關聯學校， 
6. 提供兩個角色接口
6.1 學員視圖， 可以註冊， 交學費， 選擇班級，
6.2 講師視圖， 講師可管理自己的班級， 上課時選擇班級， 查看班級學員列表 ， 修改所管理的學員的成績 
6.3 管理視圖，創建講師， 創建班級，創建課程
7. 上面的操作產生的數據都通過pickle序列化保存到文件裏

9. 面向對象-1

Python面向對象

1. 面向過程與面向對象

1.1 面向過程編程(Procedural Programming)

1.2 面向對象編程

2. 面向對象編程介紹

2.1 類的語法

2.2 面向對象的特性

作業

推薦2款開源、美觀的WinForm UI控件庫

NET9 AspnetCore將整合OpenAPI的文檔生成功能而無需三方庫

1. 基礎

數學常數e

3. 循環

2. 判斷

Django學習筆記-2

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結