一，通過函數寫人狗大戰這個故事

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 #1.函數  人模子
 5 def person(name,level,life_value):
 6     p_dic = {
 7         ‘name‘:name,
 8         ‘level‘:level,
 9         ‘life_value‘:life_value
10     }
11     return p_dic
12 joker = person(‘joker‘,100,4000)
13 
14 #函數  狗模子
15 def
 
 dog(name,breed,live_value):
16     d_dic = {
17         ‘name‘: name,
18         ‘breed‘: breed,  #(品種)
19         ‘live_value‘: live_value
20     }
21     return d_dic
22 dahei = dog(‘dahei‘,‘狼‘,10000)
23 
24 #函數  定義人的攻擊
25 def attack(person):   #定義人攻擊
26     print(‘%s在攻擊‘%person[‘name‘])
27 attack(joker)      #
 
將Joker的返回值的字典傳入，獲取字典相應的值
28 
29 #函數  定義狗的攻擊
30 def bite(dog):      #定義狗攻擊
31     print(‘%s在咬‘%dog[‘name‘])
32 bite(dahei)        #將dahei的返回值的字典傳入，獲取字典相應的值
33 
34 #上面的調用很完美但是如果出現下面的情況的話，你會分不清楚誰攻擊，誰咬死
35 attack(dahei)   #這個攻擊是人的屬性，狗也可以了
36 bite(joker)     #這個攻擊時狗的屬性，人也可以了

二，嵌套函數去寫

 1 #!/usr/bin/env python
 

 2 #_*_coding:utf-8_*_
 3 
 4 def person(name,level,life_value):
 5     def attack():                             #把這個攻擊定義在人裏面
 6         print(‘%s在攻擊‘ %p_dic[‘name‘])
 7     p_dic = {
 8         ‘name‘:name,
 9         ‘level‘:level,
10         ‘life_value‘:life_value,
11         ‘attack‘:attack
12     }
13     return p_dic
14 
15 def dog(name,breed,live_value):
16     def bite():                               #把這個攻擊定義在狗裏面
17         print(‘%s在咬‘ % d_dic[‘name‘])
18     d_dic = {
19         ‘name‘:name,
20         ‘breed‘:breed,
21         ‘live_value‘:live_value,
22         ‘bite‘:bite
23     }
24     return d_dic
25 
26 joker = person(‘joker‘,100,4000)
27 dahei = dog(‘dahei‘,‘狼‘,10000)
28 joker[‘attack‘]()        #這樣調用的話就沒有問題了，字典方式調用
29 dahei[‘bite‘]()
30 
31 #上面的函數嵌套很完美但是如果我想現在定義個吃，玩的屬性，難道你要在每個嵌套函數裏面加字典的kev麽
32 # 註意：實現吃，玩的屬性，不能在外面單獨寫吃的函數，因為不能確定誰去吃，寫在裏面又會出現代碼重復的情況

三，面向對象的定義

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3 
 4 class Person:
 5     role = ‘中國人‘    #屬性—— 靜態屬性--類屬性  例子中用不到
 6     def __init__(self,name):  #傳參
 7         print(‘there here‘)
 8         print(name)
 9     def attack(self):  #方法——動態屬性
10         print(‘攻擊‘)
11 # print(Person.role)   #類名.屬性
12 # print(Person.attack) #類名.方法  打印出來的是內存地址
13 # joker = Person()  #調用，首先執行init方法（構造函數） self就是joker
14 # joker = Person(‘joker‘)   #有參數，init也是相對應得需要參數

3.1 上面代碼解釋成函數為

 1 #!/usr/bin/env python
 2 #_*_coding;utf-8_*_
 3 
 4 def Person(*args,**kwargs):
 5     self = {}
 6     def __init__(name,life_value,aggr):
 7         self[‘name‘] = name
 8         self[‘life_value‘] = life_value
 9         self[‘aggr‘] = aggr
10         return self
11     self_ret =  __init__(*args,**kwargs)
12     return self_ret
13 # joker =Person(‘joker‘,1000,500)

3.2 人人大戰

 1 #!/usr/bin/env python
 2 #_*_coding;utf-8_*_
 3 
 4 class Person:
 5     role = ‘中國人‘    #屬性—— 靜態屬性
 6     def __init__(self,name,life_value,aggr):
 7         self.name = name
 8         self.life_value = life_value
 9         self.aggr = aggr
10     def attack(self,enemy):  #方法——動態屬性，enemy對象，攻擊誰
11         enemy.life_value = enemy.life_value - self.aggr
12 # egon = Person(‘egon‘,1000,50)
13 # alex = Person(‘alex‘,250,5)
14 # print(alex.life_value)
15 # egon.attack(alex)
16 # egon.attack(alex)        #egon攻擊alex,alex血會減少，相當於改了實例裏面的value
17 # print(alex.life_value)
18 # alex.attack(egon)        #alex攻擊egon,egon血量會減少

四，面向對象人狗大戰

 1 #!/usr/bin/env python
 2 #_*_coding;utf-8_*_
 3 
 4 class Person:
 5     role = ‘中國人‘    #屬性—— 靜態屬性
 6     def __init__(self,name,life_value,aggr):
 7         self.name = name
 8         self.life_value = life_value
 9         self.aggr = aggr
10     def attack(self,dog):  #方法——動態屬性，enemy對象，攻擊誰
11         dog.life_value = dog.life_value - self.aggr
12 
13 class Dog:
14     def __init__(self,name,breed,aggr,life_value):
15         self.nickname = name
16         self.breed = breed
17         self.aggr = aggr
18         self.life_value = life_value
19     def bite(self,person):
20         person.life_value = person.life_value - self.aggr
21 
22 alex = Person(‘alex‘,250,500)
23 egon = Person(‘egon‘,22,10)
24 dahei = Dog(‘dahei‘,‘狼‘,30,2000)
25 
26 print(dahei.life_value)   #alex攻擊dog，要打印狗的血
27 alex.attack(dahei)
28 print(dahei.life_value)
29 
30 print(alex.life_value)    #dog攻擊alex，要打印alex的血
31 dahei.bite(alex)
32 print(alex.life_value)
33 
34 print(dahei.life_value)   #egon攻擊dog，要打印狗的血
35 egon.attack(dahei)
36 print(dahei.life_value)

python開發面向對象基礎：人狗大戰學面向對象