python开发面向对象基础：人狗大战学面向对象

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

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 #1.函数  人模子
 def person(name,level,life_value):
     p_dic = {
         'name':name,
         'level':level,
         'life_value':life_value
     }
     return p_dic
 joker = person('joker',100,4000)

 #函数  狗模子
 def dog(name,breed,live_value):
     d_dic = {
         'name': name,
         'breed': breed,  #(品种)
         'live_value': live_value
     }
     return d_dic
 dahei = dog('dahei','狼',10000)

 #函数  定义人的攻击
 def attack(person):   #定义人攻击
     print('%s在攻击'%person['name'])
 attack(joker)      #将Joker的返回值的字典传入，获取字典相应的值

 #函数  定义狗的攻击
 def bite(dog):      #定义狗攻击
     print('%s在咬'%dog['name'])
 bite(dahei)        #将dahei的返回值的字典传入，获取字典相应的值

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

　　attack(dahei)   #这个攻击是人的属性，狗也可以了
　　bite(joker)     #这个攻击时狗的属性，人也可以了

二，通过嵌套函数去写

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 def person(name,level,life_value):
     def attack():                             #把这个攻击定义在人里面
         print('%s在攻击' %p_dic['name'])
     p_dic = {
         'name':name,
         'level':level,
         'life_value':life_value,
         'attack':attack
     }
     return p_dic

 def dog(name,breed,live_value):
     def bite():                               #把这个攻击定义在狗里面
         print('%s在咬' % d_dic['name'])
     d_dic = {
         'name':name,
         'breed':breed,
         'live_value':live_value,
         'bite':bite
     }
     return d_dic

 joker = person('joker',100,4000)
 dahei = dog('dahei','狼',10000)
 joker['attack']()        #这样调用的话就没有问题了，字典方式调用
 dahei['bite']()

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

三，面向对象的定义

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 class Person:
     role = '中国人'    #属性—— 静态属性--类属性  例子中用不到
     def __init__(self,name):  #传参
         print('there here')
         print(name)
     def attack(self):  #方法——动态属性
         print('攻击')
 # print(Person.role)   #类名.属性
 # print(Person.attack) #类名.方法  打印出来的是内存地址
 # joker = Person()  #调用，首先执行init方法（构造函数） self就是joker
 # joker = Person('joker')   #有参数，init也是相对应得需要参数

3.1 上面代码解释成函数为

 #!/usr/bin/env python
 #_*_coding;utf-8_*_

 def Person(*args,**kwargs):
     self = {}
     def __init__(name,life_value,aggr):
         self['name'] = name
         self['life_value'] = life_value
         self['aggr'] = aggr
         return self
     self_ret =  __init__(*args,**kwargs)
     return self_ret
 # joker =Person('joker',1000,500)

3.2 人人大战

 #!/usr/bin/env python
 #_*_coding;utf-8_*_

 class Person:
     role = '中国人'    #属性—— 静态属性
     def __init__(self,name,life_value,aggr):
         self.name = name
         self.life_value = life_value
         self.aggr = aggr
     def attack(self,enemy):  #方法——动态属性，enemy对象，攻击谁
         enemy.life_value = enemy.life_value - self.aggr
 # egon = Person('egon',1000,50)
 # alex = Person('alex',250,5)
 # print(alex.life_value)
 # egon.attack(alex)
 # egon.attack(alex)        #egon攻击alex,alex血会减少，相当于改了实例里面的value
 # print(alex.life_value)
 # alex.attack(egon)        #alex攻击egon,egon血量会减少

四，面向对象人狗大战

 #!/usr/bin/env python
 #_*_coding;utf-8_*_

 class Person:
     role = '中国人'    #属性—— 静态属性
     def __init__(self,name,life_value,aggr):
         self.name = name
         self.life_value = life_value
         self.aggr = aggr
     def attack(self,dog):  #方法——动态属性，enemy对象，攻击谁
         dog.life_value = dog.life_value - self.aggr

 class Dog:
     def __init__(self,name,breed,aggr,life_value):
         self.nickname = name
         self.breed = breed
         self.aggr = aggr
         self.life_value = life_value
     def bite(self,person):
         person.life_value = person.life_value - self.aggr

 alex = Person('alex',250,500)
 egon = Person('egon',22,10)
 dahei = Dog('dahei','狼',30,2000)

 print(dahei.life_value)   #alex攻击dog，要打印狗的血
 alex.attack(dahei)
 print(dahei.life_value)

 print(alex.life_value)    #dog攻击alex，要打印alex的血
 dahei.bite(alex)
 print(alex.life_value)

 print(dahei.life_value)   #egon攻击dog，要打印狗的血
 egon.attack(dahei)
 print(dahei.life_value)

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

 #!/usr/bin/env python
 #_*_coding;utf-8_*_

 #人狗大战，人民币版本
 class Person:
     '''
     这是一个游戏里人物的数据类型
     '''
     role = '中国人'    #类属性—— 静态属性
     def __init__(self,name,life_value,aggr):
         self.name = name #名字    #对象属性
         self.life_value = life_value #生命值 对象属性
         self.aggr = aggr #攻击力 对象属性
     def attack(self,enemy):  #攻击方法——动态属性
         enemy.life_value = enemy.life_value - self.aggr

 class Dog:
     def __init__(self,name,breed,aggr,life_value):
         self.nickname = name #昵称
         self.breed = breed   #品种
         self.aggr = aggr     #攻击力
         self.life_value = life_value  #生命值
     def bite(self,person):  #咬
         person.life_value = person.life_value - self.aggr
 egon = Person('egon',1000,50)
 dahei = Dog('dahei','狼',30,20000)
 egon.money = 200    #加入新的属性,也可以重写对象属性，这里因为是实例化后加入
 print(egon.money)

 class Weapon:  #武器类
     def __init__(self,name,aggr,life_value,price,attack_force):
         self.price = price
         self.name = name
         self.aggr = aggr   #伤害加成
         self.life_value = life_value #生命加成
         self.attack_force = attack_force #攻击力
     def update(self,person):  #带装备，人
         person.money = person.money - self.price
         person.aggr = person.aggr + self.aggr
         person.life_value = person.life_value + self.life_value
     def kill(self,obj):  #装备：主动技能
         obj.life_value = obj.life_value - self.attack_force
 r = Weapon('sword_soul',50,250,199,10000)

 if egon.money > r.price:
     r.update(egon)     #给egon装备上武器，相当于方法，然后有些对象属性增加，但是不会拥有所有属性
     egon.weapon = r    #所有的属性方法你都可以调用了

 # print(dahei.life_value)
 # print(egon.aggr)
 # egon.attack(dahei)
 # print(dahei.life_value)

 # egon.weapon.kill(dahei)   #调用武器的技能
 # print(dahei.life_value)
 # egon.weapon.kill(dahei)
 # print(dahei.life_value)

六，命名空间问题

 #!/usr/bin/env python
 #_*_coding;utf-8_*_

 # 命名空间
 # 属性(类属性，静态属性)，引用都是一样的,id一样
 print(id(egon.role))     #可以共享
 print(id(alex.role))
 print(id(Person.role))

 # 方法(动态属性)
 print(egon.name)
 print(alex.name)
 print(egon.attack)
 print(alex.attack)
 print(Person.attack)

 # 对象改变属性(静态属性，类属性)  对象修改属性是把属性拿下来之后改的，只对自己的米命名空间起作用
 egon.role = '印度人'
 print(egon.role,id(egon.role))
 print(alex.role,id(alex.role))
 print(Person.role,id(Person.role))
 # 如果属性改变，那就是都改变了
 Person.role = '印度人'
 print(alex.role)
 print(egon.role)

七，总结

 #!/usr/bin/env python
 #_*_coding;utf-8_*_

 class 类名:
     类属性 = None
     def __init__(self,对象属性):
         self.对象属性 = 对象属性
     def 方法名(self):
         pass
 实例 = 类名(10)
 实例.方法名()
 # #类名
 # 类名.类属性
 # 类名.方法名

 # 实例 = 类名(参数，参数)  #实例就是对象

 # #实例
 # 实例.方法名()
 # 实例.对象属性

 # #实例增加属性
 # 实例.新的属性名 = 1000
 # print(实例.新的属性名)

 #dir(类) #返回类中的所有名字列表
 #isinstance(对象，类) #判断对象是否为类的实例
 # print(Person.__doc__)  打印类的注释消息
 # print(Person.__dict__) # 返回一个字典 key是属性名，value是属性值
 # print(Person.__module__)  #person类所在的模块
 # print(Person.__name__,type(Person.__name__)) #字符串数据类型的类名
 # from collections import namedtuple
 # p = namedtuple('Point',['x','y'])
 # p1 = p(1,2)
 # print(p.__name__)