python人狗兽 python人狗大战编程

一，通过函数写人狗大战这个故事

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的返回值的字典传入，获取字典相应的值

 **上面的调用很完美但是如果出现下面的情况的话，你会分不清楚谁攻击，谁咬死

attack(dahei)   #这个攻击是人的属性，狗也可以了
　　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']()

 **上面的函数嵌套很完美但是如果我想现在定义个吃，玩的属性，难道你要在每个嵌套函数里面加字典的kev么
 **注意：实现吃，玩的属性，不能在外面单独写吃的函数，因为不能确定谁去吃，写在里面又会出现代码重复的情况

三，面向对象的定义

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)

五，人狗大战，人民币版本

1 #!/usr/bin/env python
 2 #_*_coding;utf-8_*_
 3 
 4 #人狗大战，人民币版本
 5 class Person:
 6     '''
 7     这是一个游戏里人物的数据类型
 8     '''
 9     role = '中国人'    #类属性—— 静态属性
10     def __init__(self,name,life_value,aggr):
11         self.name = name #名字    #对象属性
12         self.life_value = life_value #生命值 对象属性
13         self.aggr = aggr #攻击力 对象属性
14     def attack(self,enemy):  #攻击方法——动态属性
15         enemy.life_value = enemy.life_value - self.aggr
16 
17 class Dog:
18     def __init__(self,name,breed,aggr,life_value):
19         self.nickname = name #昵称
20         self.breed = breed   #品种
21         self.aggr = aggr     #攻击力
22         self.life_value = life_value  #生命值
23     def bite(self,person):  #咬
24         person.life_value = person.life_value - self.aggr
25 egon = Person('egon',1000,50)
26 dahei = Dog('dahei','狼',30,20000)
27 egon.money = 200    #加入新的属性,也可以重写对象属性，这里因为是实例化后加入
28 print(egon.money)
29 
30 class Weapon:  #武器类
31     def __init__(self,name,aggr,life_value,price,attack_force):
32         self.price = price
33         self.name = name
34         self.aggr = aggr   #伤害加成
35         self.life_value = life_value #生命加成
36         self.attack_force = attack_force #攻击力
37     def update(self,person):  #带装备，人
38         person.money = person.money - self.price
39         person.aggr = person.aggr + self.aggr
40         person.life_value = person.life_value + self.life_value
41     def kill(self,obj):  #装备：主动技能
42         obj.life_value = obj.life_value - self.attack_force
43 r = Weapon('sword_soul',50,250,199,10000)
44 
45 if egon.money > r.price:
46     r.update(egon)     #给egon装备上武器，相当于方法，然后有些对象属性增加，但是不会拥有所有属性
47     egon.weapon = r    #所有的属性方法你都可以调用了
48 
49 # print(dahei.life_value)
50 # print(egon.aggr)
51 # egon.attack(dahei)
52 # print(dahei.life_value)
53 
54 # egon.weapon.kill(dahei)   #调用武器的技能
55 # print(dahei.life_value)
56 # egon.weapon.kill(dahei)
57 # print(dahei.life_value)

六，命名空间问题

1 #!/usr/bin/env python
 2 #_*_coding;utf-8_*_
 3 
 4 # 命名空间
 5 # 属性(类属性，静态属性)，引用都是一样的,id一样
 6 print(id(egon.role))     #可以共享
 7 print(id(alex.role))
 8 print(id(Person.role))
 9 
10 # 方法(动态属性)
11 print(egon.name)
12 print(alex.name)
13 print(egon.attack)
14 print(alex.attack)
15 print(Person.attack)
16 
17 # 对象改变属性(静态属性，类属性)  对象修改属性是把属性拿下来之后改的，只对自己的米命名空间起作用
18 egon.role = '印度人'
19 print(egon.role,id(egon.role))
20 print(alex.role,id(alex.role))
21 print(Person.role,id(Person.role))
22 # 如果属性改变，那就是都改变了
23 Person.role = '印度人'
24 print(alex.role)
25 print(egon.role)

七，总结

1 #!/usr/bin/env python
 2 #_*_coding;utf-8_*_
 3 
 4 class 类名:
 5     类属性 = None
 6     def __init__(self,对象属性):
 7         self.对象属性 = 对象属性
 8     def 方法名(self):
 9         pass
10 实例 = 类名(10)
11 实例.方法名()
12 # #类名
13 # 类名.类属性
14 # 类名.方法名
15 
16 # 实例 = 类名(参数，参数)  #实例就是对象
17 
18 # #实例
19 # 实例.方法名()
20 # 实例.对象属性
21 
22 # #实例增加属性
23 # 实例.新的属性名 = 1000
24 # print(实例.新的属性名)
25 
26 #dir(类) #返回类中的所有名字列表
27 #isinstance(对象，类) #判断对象是否为类的实例
28 # print(Person.__doc__)  打印类的注释消息
29 # print(Person.__dict__) # 返回一个字典 key是属性名，value是属性值
30 # print(Person.__module__)  #person类所在的模块
31 # print(Person.__name__,type(Person.__name__)) #字符串数据类型的类名
32 # from collections import namedtuple
33 # p = namedtuple('Point',['x','y'])
34 # p1 = p(1,2)
35 # print(p.__name__)