python's seventeenth day for me 面向对象

用函数做一个简单的游戏：

def Person(name,sex,hp,ad):
    self = {'name':name,'sex':sex,'hp':hp,'ad':ad}
    def attack(dog): # 闭包
        # 人攻击狗
        print('%s攻击%s' % (self['name'],dog['name']))
        # 狗掉血：狗的血量-人的攻击力
        dog['hp'] -= self['ad']
        print('%s还剩%s血量' % (dog['name'],dog['hp']))
    self['attack'] = attack
    return self

def Dog(name,kind,hp,ad):
    self = {'name':name,'kind':kind,'hp':hp,'ad':ad}
    def bite(person):
        print('%s咬%s' % (self['name'],person['name']))
        # 人掉血：人的血量-狗的攻击力
        person['hp'] -= self['ad']
        print('%s还剩%s血量' % (person['name'], person['hp']))
        if person['hp'] <= 0:
            print('%s被%s咬死了\n game over\n%s win' % (person['name'],self['name'],self['name']))
    self['bite'] = bite
    return self
person = Person('alex','男',100,20)
dog = Dog('wangwang','male',200,100)
person['attack'](dog)
dog['bite'](person)

面向对象编程：

　　类的概念：具有相同属性和技能的一类事物。

　　对象：就是对一个类具体的描述。

使用面向对象的好处：

　　1，使得代码之间的角色关系更加明确。

　　2，增强了代码的可扩展性。

　　3，规范了对象的属性和技能。

面向对象的特点：结局的不确定性。

查看静态变量的方法：

　　第一种方法（只能查，不能进行删改）：

class Person:
    静态变量 = 123
print(Person.__dict__)  # 内置的双下方法
# 查看静态变量的第一种方式：
print(Person.__dict__['静态变量'])
# Person.__dict__['静态变量'] = 456    # 不能这样更改，会报错。

　　第二种方法（可查，可删( del )，可改）：

class Person:
    静态变量 = 123
# 查看静态变量的第二种方法：
print(Person.静态变量)      #
Person.静态变量 = 456  # 这种方式可以更改静态变量。
print(Person.静态变量)      #
del Person.静态变量
print(Person.静态变量)    # 这步会报错，因为查不到'静态变量'（已被删除）

引用动态变量：

　　1，类名.方法名　　查看这个方法的内存地址。

　　2，类名.方法名(实参)　　调用了这个方法，必须传一个实参，这个实参传给了self.

class Person:
    def func(self):  # self 是默认带的，可以不带，但约定俗成都要带上。
        print(666)
# print(Person.func)  # <function Person.func at 0x0000018ED6EA2400>  打印的是方法的内存地址。
print(Person.func(1))   # 有self就必须传入参数才能执行类里面的函数。
#
#  None        # 因为没有返回值，所以打印了None

创造一个对象 — 实例化。

　　　　1，  产成一个实例（对象）的过程。

　　　2，对象 = 类型()

实例化的过程：

　　1，创造一个实例，将会作为一个实际参数。

　　2，自动触发一个__init__的方法，并且把示例以参数的形式传递给__init__方法中的self形参。

　　3，执行完__init__方法之后，会将self自动返回给alex.

class Person:
    def __init__(self):     # 动态属性 方法（函数）   默认带一个参数self
        print('执行了')
alex = Person()     # 创造一个对象
# alex 是对象，实例
# Person 是类
# 对象 = 类名()

__init__方法：

　　初始化方法，给一个对象添加一些基础属性的方法，一般情况下是针对self的赋值。

　　对象：

　　　　在类的内部  self是本类的一个对象

　　　　在类的外部，每一个对象都对应着一个名字，这个对象只想一个对象的内存空间。

　　　　属性的调用：

　　　　　　对象名.属性名　　　　第一种调用方法

　　　　　　对象名.__dict__['属性名']　　　　第二种调用方法

　　　　方法的调用：

　　　　　　类名.方法名(对象名)　　方法中的self参数就指向这个对象。

　　　　　　对象名.方法名()　　这样相当于 方法中的self参数直接指向这个对象。

class Person:
    role = 'person'     # 静态属性
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
    def attack(self):
        print('%s发起了一次攻击' % self.name)
alex = Person('a_sb','不详',1,5)
Person.attack(alex)     #类名.方法名(对象名)   方法中的self参数就指向这个对象。
# a_sb发起了一次攻击
alex.attack()       # 对象名.方法名()   这样写相当于方法中的self参数直接指向这个对象。
# a_sb发起了一次攻击
# print(alex.name)    # a_sb
# print(alex.sex)     # 不详
# print(alex.hp)      # 1
# print(alex.ad)      # 5