python学习 day18 (3月25日)---（ 面向对象浅析）

面向对象思想：

字典表示对象：

　　不是太好 因为 变量 得一个个的赋值改值

{'name':'alex','blood':20,'attack':1,'sex':'不'}
{'name':'太亮','blood':20,'sex':'不'}
{'name':'alex','blood':20,'attack':1,'sex':'不'}

函数表示面向对象：

　　对象赋值

#通过两个模子，捏出两个具体的角色
#抽象 ： 只能知道有那些属性  
#具体 ： 可以描述他的属性的值的

def Person(name,hp,ad,sex):
    dic = {'name':name,'blood':hp,'attack':ad,'sex':sex}
    return dic
alex = Person('liuer',1,1,'Man')

def Dog(name,hp,ad,sex):
    dic = {'name':name,'blood':hp,'attack':ad,'sex':sex}
    return dic
ret = Dog('小黑',3000,10,'哈士奇')
print(ret)

　　对象之间发生关系

人打狗   狗咬人 
#互相打
def fight(dog,person):
    #狗掉血，就是人的攻击力
    dog['blood']-= person['attack']
    print('%s打了%s,%s掉了%s'%(person['name'],dog['name'],dog['name'],person['attack']))
def bite(dog,person):
    person['blood'] -= dog['attack']
    print('%s咬了%s,%s掉了%s'%(person['name'],dog['name'],dog['name'],person['attack']))
hei = Dog('小黑',3000,10,'哈士奇')
# fight(hei['blood'],person_ad=alex['attack'])
fight(hei,alex)
print(hei)
bite(hei,alex)
print(alex)

　　不好的是，bite(a,b) ab两个元素，关系不明确 是 a bite b  还是 b bite a 

改进 对象

　　程序里dic['fight'] = fight    把函数 塞进了字典 可以通过　　

　　alex = Person('alex',20,1,'不详')   alex['fight'](hei) 调用  实现函数的嵌套

　　但是为什么 return dic 返回 None 呢

# 给两个特定的属于特定角色的方法 设置了他的使用范围
# 让其他角色不能随意调用属于固定角色的方法
def Person(name,hp,ad,sex):   # 模子
    dic = {'name':name,'blood':hp,'attack':ad,'sex':sex}
    def fight(dog):  # 攻击  属于人
        # 狗掉血，就是人的攻击力
        dog['blood'] -= dic['attack']
        print('%s打了%s，%s掉了%s血' % (dic['name'], dog['name'], dog['name'], dic['attack']))
    dic['fight'] = fight
    return dic
def Dog(name,hp,ad,kind):
    dic = {'name': name, 'blood': hp, 'attack': ad, 'kind': kind}
    def bite(person):  # 咬 属于狗
        person['blood'] -= dic['attack']
        print('%s咬了%s，%s掉了%s血' % (dic['name'], person['name'], person['name'], dic['attack']))
    dic['bite'] = bite
    return dic
# 互相打
alex = Person('alex',20,1,'不详')
hei = Dog('小黑',3000,10,'哈士奇')
alex['fight'](hei)
hei['bite'](alex)

总结：

# 先思考这个程序中有几个角色
# 然后描述这个角色 属性和动作
# 把这个属性和动作都装到一个角色中
# 面向对象编程

面向对象语法：

# 对象 ： 具有具体的属性值的 实际存在的例子
        #实例
# 类：具有相同方法和属性的一类事物

　　类总是大写字母开头

　　　　两种方法调用类的元素

class 类名:
    pass
#空类
class Dog: # 总是大写开头的
    变量1 = 100
    变量2 = 'abc'
    变量3 = [(1,2),(3,4)]
print(Dog.__dict__)     #{'__module__': '__main__', '变量1': 100, '变量2': 'abc', '变量3': [(1, 2), (3, 4)], '__dict__': <attribute '__dict__' of 'Dog' objects>, '__weakref__': <attribute '__weakref__' of 'Dog' objects>, '__doc__': None}
print(Dog.__dict__['变量1'])  #100
# 第二种方法常用
print(Dog.变量1)  #100
print(Dog)  #<class '__main__.Dog'>
# 每一只狗 都需要自己的属性

　　新建一个完整的类

class Dog:  # 狗模子  --类
    def __init__(self,name,hp,ad,sex):  #固定的  函数有默认参数
        print('执行了')        #self就可以当字典使用
        print(name,hp,ad,sex)
        self.name = name
        self.blood = hp
        self.ad = ad
        self.sex = ad
        # self.__dict__['name']  = name
        # self.__dict__['blood']  = hp
        # self.__dict__['ad']  =ad
        # self.__dict__['sex']  = sex
        print(self.__dict__)#{'name': 'alex', 'blood': 20, 'ad': 10, 'sex': '不祥'}
        #  不用 return self 自己就传出来
# 具体的狗 对象  #自动的调用了Dog(对象) init
alex = Dog('alex',20,10,'不祥')#  默认有一个参数  传了了五个
#_init__() takes 1 positional argument but 5 were given
print(alex.__dict__)#{'name': 'alex', 'blood': 20, 'ad': 10, 'sex': '不祥'}
print(alex.name)
print(alex.blood)

　　实例化

# 狗模子 狗对象 都是一个内存空间 字典
# self 实际上 就是由 python 语法 开辟了 一个属于具体的对象的空间
# 执行 init  想self  自动添加 key等属性
#返回self
# 对象 也是实例
#创建了一个对象 也是创建实例
# 实例化的过程：
    #1，开辟了一块块空间，创造了一个self变量来指向这块空间
    #2，调用init ,自动传self 参数，其他的参数都是按照顺序传进来的
    #3，执行init
    #4, 将self 自动返回调用者

　　用的方法 而不是用函数的方法写 面向对象

class Dog:  # 狗模子  --类
    a = 1000        #静态变量 这个类中的变量 是所有
    def __init__(self,name,hp,ad,sex):  #固定的  函数有默认参数
                    #self就可以当字典使用
        print(name,hp,ad,sex)       #实例变量 对象属性
        self.name = name
        self.blood = hp
        self.ad = ad
        self.type = sex
    def bite(self,person): #定义在类的内部的 动态变量 方法
        person.blood -= self.ad
        # print(self)
        # print(dog)
        print('%s 咬了 %s,%s 掉了 %s血'%(self.name,person.name,person.name,self.ad))
dog1 = Dog('tai',200,20,'贵妇')   # 对象 实例
# print(do.name)
# print(do.type)          #引用实例变量 tai 引用对象的属性
# print(Dog.a)        # 所有的静态变量的值都尽量用类名去操作
# print(alex.a)
class Person:  # 人模子  --类
    a = 1000        #静态变量 这个类中的变量 是所有
    def __init__(self,name,hp,ad,sex):  #固定的  函数有默认参数
        print('执行了')        #self就可以当字典使用
        print(name,hp,ad,sex)       #实例变量 对象属性
        self.name = name
        self.blood = hp
        self.ad = ad
        self.type = sex     # 对象的资源
    def fight(self,dog): #定义在类的内部的 动态变量 方法
        dog.blood -= self.ad
        print('%s 打了 %s , %s 掉了 %s血'%(self.name,dog.name,dog.name,self.ad))

# print('do 是',do)    #do 是 <__main__.Dog object at 0x000000000289DDD8>
taibai = Person('taibai',20,20,'male')
print(taibai.fight(dog1))
taibai.fight(dog1)
dog1.bite(taibai)

　两种调用方法 ：

　　　　函数:ren['fight'](dog)       用fight 引用函数 ()  调用  dog是参数

　　　　类：ren.fight(dog)　　　fight 是类的方法   dog 是另一个类的对象