目录
面向对象前戏
编写代码简单的实现人打狗 狗咬人的小游戏：
小潮走在路上被旺财咬了，人狗大战一触即发
使用字典
"""推导步骤1:代码定义出人和狗"""
person_dict = {
'name': '小潮',
'age': 17,
'gender':'female',
'hobby':'吃饭',
'attack_val': 10000,
'life_val':1000,
}
dog_dict = {
'name': '旺财',
'type': '柴犬',
'attack_val': 10,
'life_val': 100,
}
但是这样还不够，如果有一天小潮的妹妹小澪走在路上，窜出一只狗：小黑！！，现在又要求你写代码：
person_dict = {
'name': '小澪',
'age': 17,
'gender':'female',
'hobby':'游泳',
'attack_val': 5,
'life_val':200,
}
dog_dict = {
'name': '小黑',
'type': '哈士奇',
'attack_val': 10,
'life_val': 100,
}
接着写下去要累死了，所以我们使用函数！
使用函数
"""推导步骤2:将产生人和狗的字典封装成函数"""
def create_person(name,age,gender,hobby,attack_val,life_val):
person = {
'name': name,
'age': age,
'gender': gender,
'hobby': hobby,
'attack_val': attack_val,
'life_val': life_val,
}
return person
p1 = create_person('小澪', 17, 'female', '游泳', 5, 200) # 创建小澪
def create_dog(name,type,attack_val,life_val):
person = {
'name': name,
'type': type,
'attack_val': attack_val,
'life_val': life_val,
}
return person
d1 = create_dog('小黑', '哈士奇', 10, 100) # 创建小黑（狗狗）
创建攻击函数
创建简单的攻击函数，我们希望狗可以调用狗的攻击函数，人可以调用人的攻击函数。
def person_attack(person, dog): # 传入一个人的字典 和 一个狗的字典
dog_life = dog.get('life_val') - person.get('attack_val') # 生命值减去攻击力
dog['life_val'] = dog_life
print(f'''{person.get("name")}用拳头锤了{dog.get("name")}一拳,效果拔群!!
造成了{person.get("attack_val")}点伤害, {dog.get("name")}剩余HP={dog_life}''')
person_attack(p1,d1) # 调用两次让小澪锤小黑两拳
person_attack(p1,d1)
确实可以攻击了，但是还有一个问题，如果不看变量名，你怎么知道这个函数是人的攻击函数，我还说这是狗的函数呢？代码在这一点没有交代清楚。为了使逻辑更清晰，代码可读性更强，我们需要让攻击函数和小澪本身建立联系，需要显式的告诉大家，这是只有人才能发出的攻击，毕竟小狗不会用拳头锤人。
封装攻击函数和字典
"""推导步骤3:将产生人和狗的字典封装成函数并封装人和狗的攻击函数"""
def create_person(name, age, gender, hobby, attack_val, life_val):
def person_attack(person, dog): # 1. 人的攻击函数
dog_life = dog.get('life_val') - person.get('attack_val')
dog['life_val'] = dog_life
print(f'''{person.get("name")}锤了{dog.get("name")}一拳,效果拔群!!
造成了{person.get("attack_val")}点伤害, {dog.get("name")}剩余HP={dog_life}''')
person = {
'name': name,
'age': age,
'gender': gender,
'hobby': hobby,
'attack_val': attack_val,
'life_val': life_val,
'person_attack': person_attack, # 2. 放到这里啦
}
return person
通过这个函数，我们还可以创建p2:小潮，小潮攻击力100,一拳就让小黑寄了。
是不是就很方便了，其实这里就体现了面向对象的核心思想：将数据值和功能绑定。
什么是对象？对象就是数据值和功能的结合体。
编程思想
1.面向过程编程
过程即流程 面向过程就是按照固定的流程解决问题
注册功能 登录功能 转账功能
需要列举出每一步的流程 并且随着步骤的深入 问题的解决越来越简单
ps:提出问题 然后制定出该问题的解决方案
2.面向对象编程
对象即容器 数据与功能的结合体 (python中一切皆对象)
eg:游戏人物
亚索 劫 盲僧
面向对象编程有点类似于造物主的感觉 我们只需要造出一个个对象
至于该对象将来会如何发展跟程序员没关系 也无法控制
对象其实就是一个'容器' 将数据与功能整合到一起
只要是符合上述描述的事物，都可以称之为是对象！！！
3.python面向对象
python针对面向对象编程提供了专门的语法 编写更精简
"""
上述两种编程思想没有优劣之分 需要结合实际需求而定
如果需求是注册 登录 人脸识别肯定面向过程更合适
如果需求是游戏人物肯定是面向对象更合适
实际编程两种思想是彼此交融的 只不过占比不同
"""
面向对象之类与对象
对象:数据与功能的结合体 对象才是核心
类:即类别、种类 相当于诸多对象的公有特征 类主要就是为了节省代码
"""
一个人 对象
一群人 人类(所有人相同的特征)
一条狗 对象
一群狗 犬类(所有狗相同的特征)
"""
现实中一般是先有对象再有类
比如出现了一种新的病毒，肯定是有人感染了，我们才会发现。然后才会去总结这个病毒属于什么类型的。、
程序中如果想要产生对象 必须要先定义出类
这个描述是具体的编程过程，后文会讲。
讲道理，对象和类应该是同时产生的。只要对象存在，必然能从对象中总结出对象的特征与功能。即使只有一个对象，那也可以说你是这个类的唯一实例。
类仅仅是为了描述对象公共的特征 黑人、白人、黄种人有差异，但都是人类。
类只能描述出公共的特征，不同的特征应该由对象自己描述。如何描述？从类获得公共特征之后？如何添加新的特征？
python中类和对象
请从抽象层面，回到现实的编程过程中= =，如何在python中创建类和对象？
类的语法结构
class 类名:
'''代码注释'''
对象公共的数据
对象公共的功能
1.class是定义类的关键字
2.类名的命名与变量名几乎一致 推荐类名的'首字母大写'用于区分
3.数据:变量名与数据值的绑定 功能(方法)其实就是函数
类的定义阶段
'''类体代码无需调用就会执行 产生类的名称空间'''
类在定义阶段就会执行类体代码 不需要调用！！ 跟函数不同。
函数产生局部名称空间 类会产生一个类的名称空间 外界无法直接调用
class Person():
name = 'miku'
print(f'{name},你好') # 无需调用就会执行Person类中的print函数喔
print(name) # 无法使用类中的name，这说明类确实会产生名称空间
# NameError: name 'name' is not defined
查看类的名称空间
__dict__
可以用双下dict来查看类的名称空间
class Student:
# 对象公共的数据
student_name = '小澪'
# 对象公共的功能
def choice_course(self):
print('选课功能')
# 1.查看类的名称空间
print(Student.__dict__) # 返回一个看起来是字典的东西 实际不是哦 只是用字典的方式展示给你看
print(type(Student.__dict__)) # <class 'mappingproxy'> # 用起来还是当做字典用 使用get方法
# 2.获取类中的属性和方法
print(Student.__dict__.get('student_name')) # 小澪
print(Student.__dict__.get('choice_course')) # <function Student.choice_course at 0x0000026E014360D0>
获取类中的属性和方法
句点符
class Student:
# 对象公共的数据
student_name = '小澪'
# 对象公共的功能
def choice_course(self):
print('选课功能')
'''在面向对象中 类和对象访问数据或者功能 可以统一采用句点符'''
print(Student.student_name) # 小澪
print(Student.choice_course) # <function Student.choice_course at 0x000001CD875260D0>
双下dict字典取值
class Student:
# 对象公共的数据
student_name = '小澪'
# 对象公共的功能
def choice_course(self):
print('选课功能')
print(Student.__dict__.get('student_name')) # 小澪
print(Student.__dict__.get('choice_course')) # <function Student.choice_course at 0x0000026E014360D0>
类的调用
类的调用也是像函数，加圆括号。类的调用会产生对象。
class Student:
# 对象公共的数据
student_name = '小澪'
# 对象公共的功能
def choice_course(self):
print('选课功能')
# 1.每执行一次都会产生一个全新的对象
obj1 = Student()
obj2 = Student()
obj3 = Student()
print(obj1 == obj2) # False
print(obj1 is obj2) # False
空对象
由类产生的对象，他的内部没有名字，但其可以使用类中的属性和方法。
class Student:
# 对象公共的数据
student_name = '小澪'
# 对象公共的功能
def choice_course(self):
print('选课功能')
obj1 = Student()
# 1.里面一个名字也没有
print(obj1.__dict__) # {}
# 2.但是对象可以调用类中的名字
obj1.choice_course() # 选课功能
print(obj1.student_name) # 小澪
# 3.当类中的属性/功能改变，所有由类产生的所有对象都会改变
obj2 = Student # 再产生一个对象
print(obj2.student_name) # 小澪
Student.student_name = '小潮'
print(obj1.student_name) # 小潮
print(obj2.student_name) # 小潮
对象独有的数据 推导
对象除了从类得到的公共数据，如何让对象有自己的数据？
手动添加
就像往字典里添加键值对一样！
有两种方法:
- 使用双下dict
- 使用句点符
这两种都是当数据存在时可以修改数据的值，当不存在时会新增。类似字典。
class Student:
student_name = '小澪'
def choice_course(self):
print('选课功能')
obj1 = Student()
print(obj1.__dict__) # {}
obj1.__dict__['age'] = 17
obj1.hobby = 'swimming'
print(obj1.__dict__) # {'age': 17, 'hobby': 'swimming'}
# 这是两种不同的语法 产生的效果一样
封装成函数
这样添加太累了，所以封装成函数。
class Student:
student_name = '小澪'
def choice_course(self):
print('选课功能')
obj1 = Student()
def init(obj, age, hobby):
obj.__dict__['age'] = age
obj.__dict__['hobby'] = hobby
init(obj1,17,'swimming')
print(obj1.__dict__) # {'age': 17, 'hobby': 'swimming'}
函数的调用资格
小澪属于学生类，我们希望只有学生类的对象才能调用这个添加属性的函数。防止其他对象调用，容易混淆！
class Student:
student_name = '小澪'
def init(obj, age, hobby):
obj.__dict__['age'] = age
obj.__dict__['hobby'] = hobby
def choice_course(self):
print('选课功能')
stu1 = Student()
Student.init(stu1, 17, 'swimming')
stu2 = Student()
Student.init(stu2, 17, 'kill')
print(stu1.__dict__) # {'age': 17, 'hobby': 'swimming'}
print(stu2.__dict__) # {'age': 17, 'hobby': 'kill'}
__init__（重要）
双下init的函数，在类中会默认执行。这个双下init就是我们之前给对象添加属性的函数。
class Student:
student_name = '小澪'
def __init__(obj, age, hobby): # 专门给学生添加独有数据的功能 类产生对象的过程中自动触发
obj.__dict__['age'] = age
obj.__dict__['hobby'] = hobby
def choice_course(self):
print('选课功能')
# 由于双下init默认执行 现在调用类产生对象 必须要传三个参数了！
obj1 = Student(17, 'swimming') # 为什么这里只有两个？
# 这行代码做了两件事：
1. 产生一个对象
2. 将这个对象和其余两个数值一起传入__init__方法
print(obj1.__dict__) # {'age': 17, 'hobby': 'swimming'}
print(obj1.student_name) # 小澪
print(obj1.choice_course) # <bound method Student.choice_course of <__main__.Student object at 0x0000022587B26670>>
变量名修改
# 1. 将形参obj变成self
# 2. 使用句点法
这样就得到了类的标准写法
class Student:
student_name = '小澪'
def __init__(self, age, hobby):
self.age = age # self.__dict__['age'] = age
self.hobby = hobby
def choice_course(self):
print('选课功能')
# 3. 不同的对象属性不同
stu1 = Student(17, 'swimming')
print(stu1.hobby)
stu2 = Student(17, 'kill')
print(stu2.hobby)
对象独有的功能 推导
全局定义函数
直接在全局定义功能 然后给对象添加这个全局函数 虽然是添加了 但是该函数就不是学生对象独有的了 别的对象也可以添加
class Student:
# 对象公共的数据
student_name = '小澪'
# 专门给学生添加独有数据的功能 类产生对象的过程中自动触发
def __init__(self, age, hobby):
self.age = age # self.__dict__['age'] = age
self.hobby = hobby
# 对象公共的功能
def hobby(self):
print(f'爱好是{self.hobby}')
def eat():
print('吃东西')
stu1 = Student(17, 'swimming')
stu1.eat = eat # 手动添加
print(stu1.__dict__) # {'age': 17, 'hobby': 'swimming', 'eat': <function eat at 0x0000019312447280>}
将函数放在类中（重要）
但是在类中的函数，所有这个类创建的对象都可以调用，怎么办?还是没有实现对象独有的功能。
其实python开发者已经定义好了：
当对象调用类中的函数时，会将对象自己作为第一个参数传入。
class Student:
# 对象公共的数据
food = '草莓'
# 对象公共的功能
def hobby(self):
print(f'爱好是吃{self}') # 爱好是吃<__main__.Student object at 0x000001FE53656670>
print(f'爱好是吃{self.food}') # 爱好是吃草莓
stu1 = Student()
stu1.hobby() # 对象调用类中的函数
print(stu1.food) # 草莓
另外一个例子,反映对象调用类中函数会把自己传进去：
class Student:
# 对象公共的数据
food = '草莓'
# 对象公共的功能
def hobby():
print(f'爱好是吃草莓')
Student.hobby() # 爱好是吃草莓 # 不报错
stu1 = Student()
stu1.hobby() # TypeError: hobby() takes 0 positional arguments but 1 was given # 会报错
更多例子：
# 1.类中 属性和方法 名字冲突的情况
class Student:
# 对象公共的数据
hobby = '草莓'
# 对象公共的功能
def hobby():
print(f'爱好是吃草莓')
# 2. 会得到函数 而不是数据‘草莓’
print(Student.hobby) # <function Student.hobby at 0x000001D4360860D0>
# 3. 用对象调用类中方法
stu1 = Student()
print(stu1.hobby) # <bound method Student.hobby of <__main__.Student object at 0x000001903F656670>>
print(stu1.hobby()) # TypeError: hobby() takes 0 positional arguments but 1 was given
# 为什么类调用出的hobby 和对象调出的hobby不一样 ？
# 因为底层实际上是给对象复制了一份 不是原来的hobby 所以地址当然不一样啦