一，通过函数写人狗大战这个故事
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)
时间： 2024-10-19 21:50:07