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也是相对应得需要参数

 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)

 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 =http://www.mamicode.com/ life_value
 9         self.aggr = aggr
10     def attack(self,enemy):  #方法——动态属性，enemy对象，攻击谁
11         enemy.life_value = http://www.mamicode.com/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 =http://www.mamicode.com/ life_value
 9         self.aggr = aggr
10     def attack(self,dog):  #方法——动态属性，enemy对象，攻击谁
11         dog.life_value = http://www.mamicode.com/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 =http://www.mamicode.com/ life_value
19     def bite(self,person):
20         person.life_value = http://www.mamicode.com/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)