python 19 days

python 19 days

_init_、面向对象、初始面向对象、面向对象的命名空间

例题：

人狗大战

角色：人和狗

人：名字、性别、血量（hp）、攻击力（ad）

狗：名字、品种（kind）、血量（hp）、攻击力（ad）

 def Person(name,sex,hp,ad):
    # 创造了一个模子
    # 约束了一个人必须拥有的属性
    # 规范了这些属性的名字
    # 简化了用户的操作
    person = {
        'name': name,
        'sex': sex,
        'hp': hp,
        'ad': ad
    }
    def attack(dog):  # 人攻击狗
        # 狗掉血，是人的攻击力
        # 狗的血 人的攻击力
        print('%s攻击了%s' % (person['name'], dog['name']))
        dog['hp'] -= person['ad']
        print('%s掉了%s点血，%s剩余血量%s' %
              (dog['name'], person['ad'], dog['name'], dog['hp']))
    person['attack'] = attack
    return person

def Dog(name,kind,hp,ad):
    dog = {
        'name': name,
        'kind': kind,
        'hp': hp,
        'ad': ad
    }
    def bite(person):  # 狗咬人
        print('%s咬了%s' % (dog['name'], person['name']))
        if person['hp'] <= dog['ad']:
            person['hp'] = 0
            print('%s剩余血量已为0，game over' % person['name'])
        else:
            person['hp'] -= dog['ad']
            print('%s掉了%s点血，%s剩余血量%s' % (person['name'], dog['ad'], person['name'], person['hp']))
    dog['bite'] = bite
    return dog


alex = Person('alex',None,10,1)
egon = Person('egon',None,20,2)
taibai= Dog('哮天犬','teddy',100,50)
alex['attack'](taibai)
taibai['bite'](alex)

alex攻击了哮天犬
哮天犬掉了1点血，哮天犬剩余血量99
哮天犬咬了alex
alex剩余血量已为0，game over

面向对象的思路：

不着急直接去计算/操作代码获取结果；

从一个大的问题中 要到要描述的角色；

将角色的属性和行为抽象出来；

形成一个模子；

后期用到角色的时候 都围绕这个模子来操作。

类 ：

一类抽象的事务，是描述了一类事务有哪些属性或者行为，但是不具体 —— 模子

实例=对象：

就是一个依托于类的规范存在的，被赋予了具体属性值的实际存在的物体

实例化：

由一个类产生一个对象/实例的过程。

初始面向对象

创造一个函数              用 def

创造一个类                 用class
class Person:
    Country = 'China'   # 静态属性
    def __init__(self,name,sex,hp,ad):
        print('self -->',self)

obj = Person('alex', None, 10, 1)  # 对象 = 类名()
print('obj -->', obj)

Person 是一个类名
Person 中可以放两个东西：
    静态属性        变量
    动态属性(方法)  函数,自带一个叫做self的形参
类名可以做两件事情
    查看静态属性和动态属性
print(Person.Country) # 变量的值
print(Person.func)    # 函数的地址
Person.func(0)  # Person调用方法：self也是一个需要传的参数

 

print(Person.__dict__)
    创造一个对象object 对象 = 类名()
        首先要创造一个对象
        会自动的触发__init__，将创造出来的对象的地址传给self
        执行init中的代码
        将self指向的地址再返回给调用者

class Person:
    def __init__(self,name,sex,hp,ad):  # 初始化方法
        self.user = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
    def attack(self,dog):
        print('%s攻击了%s'%(self.user,dog.user))
        dog.hp -= self.ad
        print('%s掉了%s点血，当前血量为%s'%(dog.user,self.ad,dog.hp))
#
class Dog:
    def __init__(self,name,kind,hp,ad):  # 初始化方法
        self.user = name
        self.kind = kind
        self.hp = hp
        self.ad = ad
    def bite(self,person):
        print('%s咬了%s' % (self.user, person.user))
        person.hp -= self.ad
        if person.hp>0:
            print('%s掉了%s点血，当前血量为%s' % (person.user, self.ad, person.hp))
        else:
            person.hp = 0
            print('%s掉了%s点血，当前血量已为0' % (person.user, self.ad))
alex = Person('alex', None, 10, 1)  # 实例化
egon = Person('egon', None, 10, 1)  # 实例化
taibai = Dog('哮天犬','teddy', 100, 50)  # 实例化
# print(alex.user)
# print(egon.user)
# print(taibai.user)
alex.attack(taibai)   # <==>Person.attack(alex,taibai)
print(taibai.hp)

alex攻击了哮天犬
哮天犬掉了1点血，当前血量为99
99

Person Dog 类

alex egon taibai 对象 实例

面向对象的命名空间：

对象名可以调用静态属性

对象名可以调用方法
class Person:
    Country = 'China'
    def __init__(self,name):
        self.name = name
    def attack(self):
        print('attack')

类
静态属性
动态属性 ： 特殊的__init__方法，attack方法

对象
对象属性 name

class Person:
    Country = 'China'
    def __init__(self,name):
        self.name = name
alex = Person('alex')
egon = Person('egon')
alex.Country = '印度'  # 往alex的对象内存中存了一个印度
print(alex.Country)
print(egon.Country)
print(Person.Country)
class Person:
    Country = ['China']
    def __init__(self,name):
        self.name = name
alex = Person('alex')
egon = Person('egon')
alex.Country[0] = '印度'
print(Person.Country)
print(egon.Country)

印度
China
China
['印度']
['印度']

首先静态变量之所以出现 ： 所有的对象都共享的值

调整静态变量的值 ： 直接用类名去调整 是最准确的
对象对一个静态变量重新赋值的过程
    实际上是在对象所在的内存空间中添加了一个同名属性而已
方法并没有真正存储在对象的空间中
    之所以能找到，是因为每一个对象在创建之初都有一个执行类的指针

类名
    查看修改静态属性
    实例化
对象名
    查看对象的属性
    调用方法
对象使用名字的特点 ： 自己有的时候用自己的 自己没有的时候用类中的