python学习之老男孩python全栈第九期_day022知识点总结——初识面向对象

一. 面向对象的引入
# 人狗大战

def person(name,HP,aggr,sex):
    person = {
        'name':name,   # 昵称
        'HP':HP,           # 生命值
        'aggr':aggr,           # 攻击力
        'sex':sex
    }
    return person

alex = person('狗剩儿',100,2,'不详')
nezha = person('哪吒',200,1,'不详')

# 代码精简了，方便增加人物，方便修改，人物更加规范      ------  人的模板

print(alex)
def dogs(name,HP,aggr,kind):
    dog = {
        'name':name,
        'HP':HP,
        'aggr':aggr,
        'kind':kind
    }
    return dog
jin = dogs('金老板',1000,1,'泰迪')

# 人：攻击技能（打）
def attack(person,dog):
    dog['HP'] -= person['aggr']
    print('%s被打了，掉了%s滴血'%(dog['name'],person['aggr']))
# 狗：攻击技能（咬人）
def bite(dog,person):
    person['HP'] -= dog['aggr']
    print('%s被咬了，掉了%s滴血'%(person['name'],dog['aggr']))

# dogs函数、person函数都是定义了一类事物
# 直到调用了函数，赋了值之后才真的有了实实在在的人或狗

bite(jin,alex)
print(alex)
bite(nezha,jin)             # 变成了人咬狗了，乱了乱了，怎么办？

于是：

def person(name,HP,aggr,sex):
    person = {
        'name':name,   # 昵称
        'HP':HP,           # 生命值
        'aggr':aggr,           # 攻击力
        'sex':sex,
    }

    # 人：攻击技能（打）
    def attack(dog):
        dog['HP'] -= person['aggr']
        print('%s被打了，掉了%s滴血' % (dog['name'], person['aggr']))

    person['attack'] = attack  # 函数名  攻击技能

    return person

def dogs(name,HP,aggr,kind):
    dog = {
        'name':name,
        'HP':HP,
        'aggr':aggr,
        'kind':kind
    }

    # 狗：攻击技能（咬人）
    def bite(person):
        person['HP'] -= dog['aggr']
        print('%s被咬了，掉了%s滴血' % (person['name'], dog['aggr']))

    dog['bite'] = bite
    return dog

alex = person('狗剩儿',100,2,'不详')
nezha = person('哪吒',200,1,'不详')
jin = dogs('金老板',1000,1,'泰迪')

jin['bite'](alex)
alex['attack'](jin)

# 面向对象编程
# 所谓模板，就是 类 --- 抽象的，我能知道有什么属性，但不能知道属性具体的值
# jin alex nezha 就是对象 --- 有具体的值，属性都是根据 类 规范的

二. 初识面向对象

字典就是一类数据结构，我一说字典你就知道是那个用{}表示，里面由k-v键值对的东西，它还具有一些增删改查的方法。
但是我一说字典你能知道字典里具体存了哪些内容么？不能，所以我们说对于一个类来说，它具有相同的特征属性和方法。

print(list)    # 类
[1,2]    # 对象

自定义一个类      # 类名开头一般大写

定义函数时：
def 函数名():
    pass

定义类
class 类名:       # 可以加括号，可以不加
    属性 = 'a'
print(类名.属性)            # a
类名的作用，就是操作属性，查看属性

# 人狗大战

class Person:                     # 类名
    country = 'China'                  # 创造了一个只要是这个类就一定有的属性，这个属性叫做 类属性 ，也叫 静态属性
    def __init__(self,*args):     # 初始化方法，self是对象，必须有
        print(self.__dict__)            # {} ， self就是一个可以存储很多属性的大字典
        self.name = args[0]             # name 为属性  ，往字典里添加属性的方式发生了一些变化
        self.HP = args[1]               # HP 为属性
        self.aggr = args[2]             # aggr 为属性
        self.sex = args[3]              # sex 为属性
        print(self.__dict__)            # {'name': '狗剩儿', 'HP': 100, 'aggr': 2, 'sex': '不详'}
        print(id(self))                 #

    def walk(self,n):             # 方法，一般情况下，必须传self参数，且必须写在第一个，后面还可以传其他参数
        print('{} 走走走,走了{}步'.format(self.name,n))

alex = Person('狗剩儿',100,2,'不详')     # 对象        # 实例化，，# 类名，可以实例化对象
# print(alex.__dict__)       # {'name': '狗剩儿', 'HP': 100, 'aggr': 2, 'sex': '不详'},查看所有属性
# print(alex)             # <__main__.Person object at 0x0000018EFBBD58D0>
# print(alex.name)        # 狗剩儿
# print(alex.HP)          # 100
# print(id(alex))         # 2085337454856  内存地址一样
print(Person.__dict__)    # Person里面有walk
Person.walk(alex,5)           # 调用方法 ：类名.方法名（对象名）
# alex.walk()         # 相当于 Person.walk(alex)
alex.walk(5)         # 相当于 Person.walk(alex,5)

print(Person.country)       # 类名 ，可以查看类中的属性，不需要实例化就可以查看

print(Person.__dict__['country'])           # China
print(alex.__dict__['name'])                # 狗剩儿

# Person.__dict__['country'] = '印度'           # 报错 对于类的字典，只能看，不能改

对于对象，可不可以修改?，可不可以删除？
　　可以的，可以的

alex.__dict__['name'] = '二哥'
print(alex.__dict__)                        # {'name': '二哥', 'HP': 100, 'aggr': 2, 'sex': '不详'}
# 但一般不这么改。
# 应该这样改：
print(alex.name)                    # 二哥
alex.name = '大哥'
print(alex.name)                    # 大哥
print(alex.__dict__)                # {'name': '大哥', 'HP': 100, 'aggr': 2, 'sex': '不详'}
alex.age = 88                     # 增加一个属性
print(alex.__dict__)                # {'name': '大哥', 'HP': 100, 'aggr': 2, 'sex': '不详', 'age': 88}

总结：

对象 = 类名（）
过程：
    类名() 首先会创造出一个对象，创建了一个self变量
    调用__init__方法，类名括号里的参数会被这里接收
    执行__init__方法
    返回self
对象能做的事：
    查看属性：print(alex.name)、print(alex.HP)
    调用方法
    __dict__  对于对象的增删改查操作都可以通过字典的语法进行
类名能做的事：
    实例化
    调用方法，只不过要自己传递self参数
    调用类中的属性，也就是调用静态属性
    __dict__，对于类中的名字只能看，不能操作