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