一，通过函数写人狗大战这个故事
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__)
