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