#!/use/bin/python
# -*- conding:utf-8 -*-
def Person(name,sex,hp,dps):#人模子
dic = {'name':name,'sex':sex,'hp':hp,'dps':dps,'bag':[]}
def attack( dog):
dog['hp'] -= dic['dps']
print('%s打了%s，%s掉了%s血,剩余了%s血' % (dic['name'], dog['name'], dog['name'], dic['dps'], dog['hp']))
dic['attack'] = attack
return dic
def dog(name,kind,hp,dps):#狗模子
dic = {'name':name,'kind':kind,'hp':hp,'dps':dps,'bag':[]}
def bite( person):
person['hp'] -= dic['dps']
print('%s咬了%s，%s掉了%s血,剩余了%s血' % (dic['name'], person['name'], person['name'], dic['dps'], person['hp']))
dic['bite'] = bite
return dic
alex = Person('alex','不详0',250,5)
ha2 = dog('哈士奇','藏獒',15000,200)
# print(alex)
# print(ha2)
#人打狗
print(ha2)
#狗咬人
print(alex)
print(alex['attack'])
alex['attack'](ha2)
ha2['bite'](alex)
print(alex['hp'])
#运用面向对象编程思想
# 人狗大战
# 创建一个人
# 创建一个狗
# 人打狗——函数
# 狗咬人——函数
#
# 造模子————面向对象
#规范了一类角色的属性项目，属性的名字，技能，技能的名字
#权限 有一些行数智能是这个角色才能调用
#!/use/bin/python
# -*- conding:utf-8 -*-
# 类：具有相同属性和相同动作的一类事物 组成的一个类
# 对象：具体的某一个具有实际属性 和具体动作的一个实体
#
# 类是抽象的
# 对象是具体的
# 类被创造出来就是模子，是用来描述对象的
# class 类名：
# 静态属性 = None
# def 动态属性（self）：pass #可以增删改查
# #只要是卸载类名中的名字，不管是变量还是函数，都不能在类的外面调用
# #只能通过类名来使用它
# #类的第一个功能是——查看静态属性
# print（类名.静态属性）
# 类名.静态属性 = 456
# print（类名，静态属性）
# 类名.静态属性 = abc
# print（类名.静态属性）
# print（类名.__dict__) 类中的默认值之外，程序员在类中定义的所有名字
#
# #类名可以查看某个方法，但是一般情况下 我们不直接使用类来调用方法，用对象执行
# print（类名.动态属性）
#
# #类的第二个功能——实例化（创造对象）
# class Person:pass
#
# alex = Person('alex','不详',250,5)
# #实列化 创建一个对象，对象= 类名（）
# print(alex)
# print(Person)
#alex name hp dps bag sex
# print(alex.__dict__)
# alex.__dict__['name'] = 'alex'
# alex.__dict__['sex'] = '不详'
# alex.__dict__['hp'] = '250'
# alex.__dict__['dps'] = '5'
# alex.__dict__['bag'] = []
# print(alex.__dict__)
# alex.name = 'alex'
# alex.hp = 250
# alex.dps = 5
# alex.sex = '不详'
# alex.bag = []
# print(alex.__dict__)
#class 初始化方法
# class Person:
# def __init__ (self,name,hp,dps,sex):
# self.name = name
# self.hp = hp
# self.dps = dps
# self.sex = sex
# self.bag = []
# def attack(self,dog):
# print(self,dog)
# dog.hp -= self.dps
# print('%s打了%s，%s掉了%s血,剩余了%s血' % (self.name, dog.name, dog.name, self.dps, dog.hp))
# class Dog:
# def __init__ (self,name,kind,hp,dps):
# self.name = name
# self.hp = hp
# self.dps = dps
# self.sex = kind
# self.name = name
# self.hp = hp
# self.dps = dps
# self.kind = kind
# self.bag = []
# def bite(self,person):
# print(self,person)
# person.hp -= self.dps
# print('%s咬了%s，%s掉了%s血,剩余了%s血' % (self.name, person.name, person.name, self.dps, alex.hp))
# return 123
#
#
# alex = Person('alex',250,5,'N/A')
# ha2 = Dog('哈士奇','藏獒',15000,200)
# # Person.attack(alex)
#简化的调用方式
# alex.attack(ha2)
# alex.attack(ha2)
# alex.attack(ha2)
# print(ha2.hp)
# ret = ha2.bite(alex)
# print(alex.hp)
# print(ret)
# print('alex:',alex)
# print(alex.__dict__)
# print(alex.name)
#执行init中内容原因,实例化的过程
# 1创建了一个对象
# 2自动调用__init__方法
# 这个对象会呗当做实际参数，传到__init__方法，并且第一个参数为self
# 3执行__init__方法中的内容
# 4自动的吧self作为返回值 返回给实例化的地方
# 对象名 方法名 相当于调用一个函数，默认吧对象名作为第一个参数传入函数
#已只半径，求周长和面积
# pi*r**2
# 2*pi*r
# from math import pi
# class Circle:
# def area(self,r):
# self.r = r
# return pi*self.r**2
# def perimeter(self):
# return 2*pi*self.r
#
# c1 = Circle(5)
# 每一个角色都有属于自己的属性和方法
#可扩展性，可读性，规范性都比较函数强
#结局不可控
#类有自己的命名空间
#对象也有自己的命名空间
#对象可以访问类的命名空间，类不可以访问命名对象
# class Person:
# COUNTRY = '中国人'
# def __init__(self,name):
# self.name = name
# def eat(self):
# print('%s在吃泔水')
#
# alex = Person('alex')
# egon = Person('egon')
#
# print(alex.name)
# print(egon.name)
# print(alex.COUNTRY)
# print(Person.name)
# alex.eat() #Person.eat(alex)
#当一个类在创建一个实例的时候 就产生了一个实例和类的联系
#可以通过实例 对象 找到实例化的类
#但是 类不可能找到它的实例化
# class Person:
# COUNTRY = '中国人'
# def __init__(self,name):
# self.name = name
# def eat(self):
# print('%s在吃泔水')
#
# alex = Person('alex')
# egon = Person('egon')
# print(alex.COUNTRY)
# alex.COUNTRY = '印度人'
# print(alex.COUNTRY)
# print(egon.COUNTRY)
# print(Person.COUNTRY)
# alex.COUNTRY[0]='印度人'
# print(egon.COUNTRY)
# print(Person.COUNTRY)
#在访问变量的时候，都先使用自己命名空间中的，如果自己的命名空间没有，再到类中去找
#在使用对象修改静态变量的过程中，相当于在自己的空间中创建一个新的变量
class Foo:
count = 0
def __init__(self):
Foo.count += 1
f1 = Foo()
f1 = Foo()
print(Foo.count)
