一. 面向对象的引入
# 人狗大战
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] # 对象
自定义一个类 # 类名开头一般大写
定义类
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__，对于类中的名字只能看，不能操作
