|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
def
person(name,age,sex,job):
data
=
{
'name'
:name,
'age'
:age,
'sex'
:sex,
'job'
:job
}
return
data
def
dog(name,dog_type):
data
=
{
'name'
:name,
'type'
:dog_type
}
return
data
|
上面兩個方法至關於造了兩個模子，遊戲開始，你得生成一我的和狗的實際對象吧，怎麼生成呢？html
|
1
2
3
4
5
|
d1
=
dog(
"李磊"
,
"京巴"
)
p1
=
person(
"嚴帥"
,
36
,
"F"
,
"運維"
)
p2
=
person(
"林海峯"
,
27
,
"F"
,
"Teacher"
)
|
兩個角色對象生成了，狗和人還有不一樣的功能呀，狗會咬人，人會打狗，對不對? 怎麼實現呢，。。想到了， 能夠每一個功能再寫一個函數，想執行哪一個功能，直接 調用 就能夠了，對不？python
|
1
2
3
4
5
6
|
def
bark(d):
print
(
"dog %s:wang.wang..wang..."
%
d[
'name'
])
def
walk(p):
print
(
"person %s is walking..."
%
p[
'name'
])<br><br>
|
|
1
2
3
|
d1
=
dog(
"李磊"
,
"京巴"
)
p1
=
person(
"嚴帥"
,
36
,
"F"
,
"運維"
)
p2
=
person(
"林海峯"
,
27
,
"F"
,
"Teacher"
)
|
|
1
|
walk(p1) bark(d1)
|
上面的功能實現的簡直是完美！linux
可是仔細玩耍一會，你就不當心幹了下面這件事程序員
|
1
2
|
p1
=
person(
"嚴帥"
,
36
,
"F"
,
"運維"
)
bark(p1)
#把人的對象傳給了狗的方法
|
事實 上，這並沒出錯。很顯然，人是不能調用狗的功能的，如何在代碼級別實現這個限制呢？算法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
def
person(name,age,sex,job):
def
walk(p):
print
(
"person %s is walking..."
%
p[
'name'
])
data
=
{
'name'
:name,
'age'
:age,
'sex'
:sex,
'job'
:job,
'walk'
:walk
}
return
data
def
dog(name,dog_type):
def
bark(d):
print
(
"dog %s:wang.wang..wang..."
%
d[
'name'
])
data
=
{
'name'
:name,
'type'
:dog_type,
'bark'
:bark
}
return
data
|
|
1
2
3
|
d1
=
dog(
"李磊"
,
"京巴"
)
p1
=
person(
"嚴帥"
,
36
,
"F"
,
"運維"
)
p2
=
person(
"林海峯"
,
27
,
"F"
,
"Teacher"
)<br><br>
|
|
1
|
d1[
'bark'
](p1)
#把人的對象傳給了狗的方法
|
你是如此的機智，這樣就實現了限制人只能用人本身的功能啦。數據庫
但，個人哥，不要高興太早，剛纔你只是阻止了兩個徹底 不一樣的角色 以前的功能混用， 但有沒有可能 ，同一個種角色，但有些屬性是不一樣的呢？ 好比 ，你們都打過cs吧，cs裏有警察和恐怖份子，但由於都 是人， 因此你寫一個角色叫 person(), 警察和恐怖份子都 能夠 互相射擊，但警察不能夠殺人質，恐怖分子能夠，這怎麼實現呢？ 你想了說想，說，簡單，只須要在殺人質的功能里加個判斷，若是是警察，就不讓殺不就ok了麼。 沒錯， 這雖然 解決了殺人質的問題，但其實你會發現，警察和恐怖分子的區別還有不少，同時又有不少共性，若是 在每一個區別處都 單獨作判斷，那得累死。 編程
你想了想說， 那就直接寫2個角色吧， 反正 這麼多區別， 個人哥， 不能寫兩個角色呀，由於他們還有不少共性 ， 寫兩個不一樣的角色，就表明 相同的功能 也要重寫了，是否是個人哥？ 。。。數據結構
好了， 話題就給你點到這， 再多說你的智商 也理解不了了！運維
編程是 程序 員 用特定的語法+數據結構+算法組成的代碼來告訴計算機如何執行任務的過程 ， 一個程序是程序員爲了獲得一個任務結果而編寫的一組指令的集合，正所謂條條大路通羅馬，實現一個任務的方式有不少種不一樣的方式， 對這些不一樣的編程方式的特色進行概括總結得出來的編程方式類別，即爲編程範式。 不一樣的編程範式本質上表明對各類類型的任務採起的不一樣的解決問題的思路， 大多數語言只支持一種編程範式，固然也有些語言能夠同時支持多種編程範式。 兩種最重要的編程範式分別是面向過程編程和麪向對象編程。編程語言
面向過程編程(Procedural Programming)
Procedural programming uses a list of instructions to tell the computer what to do step-by-step.
面向過程編程依賴 - 你猜到了- procedures，一個procedure包含一組要被進行計算的步驟， 面向過程又被稱爲top-down languages， 就是程序從上到下一步步執行，一步步從上到下，從頭至尾的解決問題 。基本設計思路就是程序一開始是要着手解決一個大的問題，而後把一個大問題分解成不少個小問題或子過程，這些子過程再執行的過程再繼續分解直到小問題足夠簡單到能夠在一個小步驟範圍內解決。
舉個典型的面向過程的例子， 數據庫備份， 分三步，鏈接數據庫，備份數據庫，測試備份文件可用性。
代碼以下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
def
db_conn():
print
(
"connecting db..."
)
def
db_backup(dbname):
print
(
"導出數據庫..."
,dbname)
print
(
"將備份文件打包，移至相應目錄..."
)
def
db_backup_test():
print
(
"將備份文件導入測試庫，看導入是否成功"
)
def
main():
db_conn()
db_backup(
'my_db'
)
db_backup_test()
if
__name__
=
=
'__main__'
:
main()
|
這樣作的問題也是顯而易見的，就是若是你要對程序進行修改，對你修改的那部分有依賴的各個部分你都也要跟着修改， 舉個例子，若是程序開頭你設置了一個變量值 爲1 ， 但若是其它子過程依賴這個值 爲1的變量才能正常運行，那若是你改了這個變量，那這個子過程你也要修改，假如又有一個其它子程序依賴這個子過程 ， 那就會發生一連串的影響，隨着程序愈來愈大， 這種編程方式的維護難度會愈來愈高。
因此咱們通常認爲， 若是你只是寫一些簡單的腳本，去作一些一次性任務，用面向過程的方式是極好的，但若是你要處理的任務是複雜的，且須要不斷迭代和維護 的， 那仍是用面向對象最方便了。
OOP編程是利用「類」和「對象」來建立各類模型來實現對真實世界的描述，使用面向對象編程的緣由一方面是由於它可使程序的維護和擴展變得更簡單，而且能夠大大提升程序開發效率 ，另外，基於面向對象的程序可使它人更加容易理解你的代碼邏輯，從而使團隊開發變得更從容。
面向對象的幾個核心特性以下
Class 類
一個類便是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具有的屬性（variables(data)）、共同的方法
Object 對象
一個對象便是一個類的實例化後實例，一個類必須通過實例化後方可在程序中調用，一個類能夠實例化多個對象，每一個對象亦能夠有不一樣的屬性，就像人類是指全部人，每一個人是指具體的對象，人與人以前有共性，亦有不一樣
Encapsulation 封裝
在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，裏面包含着類的數據和方法
Inheritance 繼承
一個類能夠派生出子類，在這個父類裏定義的屬性、方法自動被子類繼承
Polymorphism 多態
多態是面向對象的重要特性,簡單點說:「一個接口，多種實現」，指一個基類中派生出了不一樣的子類，且每一個子類在繼承了一樣的方法名的同時又對父類的方法作了不一樣的實現，這就是同一種事物表現出的多種形態。
編程其實就是一個將具體世界進行抽象化的過程，多態就是抽象化的一種體現，把一系列具體事物的共同點抽象出來, 再經過這個抽象的事物, 與不一樣的具體事物進行對話。
對不一樣類的對象發出相同的消息將會有不一樣的行爲。好比，你的老闆讓全部員工在九點鐘開始工做, 他只要在九點鐘的時候說：「開始工做」便可，而不須要對銷售人員說：「開始銷售工做」，對技術人員說：「開始技術工做」, 由於「員工」是一個抽象的事物, 只要是員工就能夠開始工做，他知道這一點就好了。至於每一個員工，固然會各司其職，作各自的工做。
多態容許將子類的對象看成父類的對象使用，某父類型的引用指向其子類型的對象,調用的方法是該子類型的方法。這裏引用和調用方法的代碼編譯前就已經決定了,而引用所指向的對象能夠在運行期間動態綁定
|
1
2
3
4
5
6
7
8
9
10
11
|
#role 1
name
=
'Alex'
role
=
'terrorist'
weapon
=
'AK47'
life_value
=
100
#rolw 2
name2
=
'Jack'
role2
=
'police'
weapon2
=
'B22'
life_value2
=
100
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
#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
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
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
|
|
1
2
3
4
5
6
7
8
9
10
11
|
def
shot(by_who):
#開了槍後要減子彈數
pass
def
got_shot(who):
#中槍後要減血
who[‘life_value’]
-
=
10
pass
def
buy_gun(who,gun_name):
#檢查錢夠不夠,買了槍後要扣錢
pass
...
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
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’)
#生成一個角色
|
|
1
2
3
4
5
6
7
8
9
|
class
Dog(
object
):
print
(
"hello,I am a dog!"
)
d
=
Dog()
#實例化這個類，
#此時的d就是類Dog的實例化對象
#實例化，其實就是以Dog類爲模版，在內存裏開闢一塊空間，存上數據，賦值成一個變量名
|
上面的代碼其實有問題，想給狗起名字傳不進去。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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? 此時的你一臉蒙逼，相信不畫個圖，你的智商是理解不了的！
畫圖以前， 你先註釋掉這兩句
|
1
2
3
4
|
# d = Dog('LiChuang', "京巴")
# d.sayhi()
print
(Dog)
|
沒實例直接打印Dog輸出以下
|
1
|
<
class
'__main__.Dog'
>
|
這表明什麼?表明 即便不實例化，這個Dog類自己也是已經存在內存裏的對不對， yes, cool，那實例化時，會產生什麼化學反應呢？
根據上圖咱們得知，其實self,就是實例自己！你實例化時python會自動把這個實例自己經過self參數傳進去。
你說好吧，僞裝懂了， 但下面這段代碼你又不明白了， 爲什麼sayhi(self),要寫個self呢？
|
1
2
3
4
5
|
class
Dog(
object
):
...
def
sayhi(
self
):
print
(
"hello,I am a dog, my name is "
,
self
.name)
|
這個緣由，我課上在講。。。
|
1
|
<br><br><br><br>
|
|
1
2
3
4
5
6
7
|
class
Role(
object
):
#定義一個類， class是定義類的語法，Role是類名，(object)是新式類的寫法，必須這樣寫，之後再講爲何
def
__init__(
self
,name,role,weapon,life_value
=
100
,money
=
15000
):
#初始化函數，在生成一個角色時要初始化的一些屬性就填寫在這裏
self
.name
=
name
#__init__中的第一個參數self,和這裏的self都 是什麼意思？ 看下面解釋
self
.role
=
role
self
.weapon
=
weapon
self
.life_value
=
life_value
self
.money
=
money
|
|
1
2
|
r1
=
Role(
'Alex'
,
'police'
,'AK47’)
#生成一個角色 , 會自動把參數傳給Role下面的__init__(...)方法
r2
=
Role(
'Jack'
,
'terrorist'
,'B22’)
#生成一個角色
|
咱們看到，上面的建立角色時，咱們並無給__init__傳值，程序也沒未報錯，是由於，類在調用它本身的__init__(…)時本身幫你給self參數賦值了，
|
1
2
|
r1
=
Role(
'Alex'
,
'police'
,
'AK47’) #此時self 至關於 r1 , Role(r1,'
Alex
','
police
','
AK47’)
r2
=
Role(
'Jack'
,
'terrorist'
,
'B22’)#此時self 至關於 r2, Role(r2,'
Jack
','
terrorist
','
B22’)
|
|
1
2
|
def
buy_gun(
self
,gun_name):
print
(「
%
s has just bought
%
s」
%
(
self
.name,gun_name) )
|
|
1
2
|
r1
=
Role(
'Alex'
,
'police'
,
'AK47'
)
r1.buy_gun(
"B21」) #python 會自動幫你轉成 Role.buy_gun(r1,」B21"
)
|
封裝最好理解了。封裝是面向對象的特徵之一，是對象和類概念的主要特性。
封裝，也就是把客觀事物封裝成抽象的類，而且類能夠把本身的數據和方法只讓可信的類或者對象操做，對不可信的進行信息隱藏。
面向對象編程 (OOP) 語言的一個主要功能就是「繼承」。繼承是指這樣一種能力：它可使用現有類的全部功能，並在無需從新編寫原來的類的狀況下對這些功能進行擴展。
經過繼承建立的新類稱爲「子類」或「派生類」。
被繼承的類稱爲「基類」、「父類」或「超類」。
繼承的過程，就是從通常到特殊的過程。
要實現繼承，能夠經過「繼承」（Inheritance）和「組合」（Composition）來實現。
在某些 OOP 語言中，一個子類能夠繼承多個基類。可是通常狀況下，一個子類只能有一個基類，要實現多重繼承，能夠經過多級繼承來實現。
繼承概念的實現方式主要有2類：實現繼承、接口繼承。
OO開發範式大體爲：劃分對象→抽象類→將類組織成爲層次化結構(繼承和合成) →用類與實例進行設計和實現幾個階段。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
#!_*_coding:utf-8_*_
#__author__:"Alex Li"
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()
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
#_*_coding:utf-8_*_
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)
|
好了，你如今會了面向對象的各類語法了， 那請看下本章最後的做業需求，我相信你多是矇蔽的， 不少同窗都是學會了面向對象的語法，卻依然寫不出面向對象的程序，緣由是什麼呢？緣由就是由於你還沒掌握一門面向對象設計利器， 你說我讀書少別騙我， 什麼利器？
答案就是:領域建模。 從領域模型開始,咱們就開始了面向對象的分析和設計過程,能夠說,領域模型是完成從需求分析到面向 對象設計的一座橋樑。
領域模型,顧名思義,就是需求所涉及的領域的一個建模,更通俗的講法是業務模型。 參考百度百科(http://baike.baidu.cn/view/757895.htm ),領域模型定義以下:
從這個定義咱們能夠看出,領域模型有兩個主要的做用:
領域模型如此重要,不少同窗可能會認爲領域建模很複雜,須要很高的技巧。然而事實上領域建模很是簡 單,簡單得有點難以讓人相信,領域建模的方法歸納一下就是「找名詞」! 許多同窗看到這個方法後估計都會笑出來:太假了吧,這麼簡單,找個初中生都會啊,那咱們公司那些分 析師和設計師還有什麼用哦?
分析師和設計師固然有用,後面咱們會看到,即便是簡單的找名詞這樣的操做,也涉及到分析和提煉,而 不是簡單的摘取出來就可,這種狀況下分析師和設計師的經驗和技能就可以派上用場了。但領域模型分析 也確實相對簡單,即便沒有豐富的經驗和高超的技巧,至少也能完成一個能用的領域模型。
雖然咱們說「找名詞」很簡單,但一個關鍵的問題尚未說明:從哪裏找? 若是你還記得領域模型是「需求到面向對象的橋樑」,那麼你確定一會兒就能想到:從需求模型中找,具 體來講就是從用例中找。
概括一下域建模的方法就是「從用例中找名詞」。 固然,找到名詞後,爲了可以更加符合面向對象的要求和特色,咱們還須要對這些名詞進一步完善,這就 是接下來的步驟:加屬性,連關係!
最後咱們總結出領域建模的三字經方法:找名詞、加屬性、連關係。
找名詞
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序列化保存到文件裏