面向对象基础
今日内容概要
- 面向对象前戏之人狗大战
- 面向对象编程思想
- 面向对象重要理论
- 面向对象代码实操
- 对象的独有数据
- 对象的独有方法
今日内容详细
人狗大战
# 编写代码简单实现人打狗 狗咬人的小游戏(剧情需要 请勿模仿)
"""推导步骤1：代码定义出人和狗"""
person1 = {
'name': 'jason',
'age': 18,
'gender': 'male',
'p_type': '猛男',
'attack_val': 8000,
'life_val': 99999
}
person2 = {
'name': 'kevin',
'age': 28,
'gender': 'female',
'p_type': '淑女',
'attack_val': 80,
'life_val': 1000
}
dog1 = {
'name': '小黑',
'd_type': '泰迪',
'attack_val': 100,
'life_val': 8000
}
dog2 = {
'name': '小白',
'd_type': '恶霸',
'attack_val': 5,
'life_val': 80000
}
# ps：如果想要定义出多个人和多条狗 上述的字典需要反复编写很多次
"""推导步骤2：将产生人和狗的字典封装成函数并封装人和狗的攻击函数"""
def create_person(name, age, gender, p_type, attack_val, life_val):
person_dict = {
'name': name,
'age': age,
'gender': gender,
'p_type': p_type,
'attack_val': attack_val,
'life_val': life_val
}
return person_dict
def create_dog(name, d_type, attack_val, life_val):
dog_dict = {
'name': name,
'd_type': d_type,
'attack_val': attack_val,
'life_val': life_val
}
return dog_dict
p1 = create_person('jason', 18, 'male', '猛男', 8000, 99999)
p2 = create_person('kevin', 28, 'female', '淑女', 100, 800)
d1 = create_dog('小黑', '恶霸', 800, 900000)
d2 = create_dog('小白', '泰迪', 100, 800000)
# 定义出人打狗的动作 狗咬人的动作
def person_attack(person_dict, dog_dict):
print(f"人{person_dict.get('name')}准备揍{dog_dict.get('name')}狗")
dog_dict['life_val'] -= person_dict.get('attack_val')
print(f"人{person_dict.get('name')}揍了狗一拳 狗掉血:{person_dict.get('attack_val')} 狗剩余血量:{dog_dict.get('life_val')}")
def dog_attack(dog_dict, person_dict):
print(f"{dog_dict.get('name')}狗准备咬人{person_dict.get('name')}")
person_dict['life_val'] -= dog_dict.get('attack_val')
print(f"{dog_dict.get('name')}狗咬了人一口 人掉血:{dog_dict.get('attack_val')} 人剩余血量:{person_dict.get('life_val')}")
# 正常传参，传入对应位置人和狗没有问题
person_attack(p1, d1)
dog_attack(d2, p2)
"""推导步骤3：人和狗的攻击混乱"""
# 需要传入人的位置传狗的数据，需要传入狗的位置传入人的数据
person_attack(d1, p1)
dog_attack(p1, d2)
# 这个时候就会发生混乱，因为你不能控制别人传值
面向对象核心思路前戏
"""推导步骤4：如何实现只有人才能调用人的攻击动作 狗才能调用狗的攻击动作>>>:数据与功能的绑定"""
def get_person(name, age, gender, p_type, attack_val, life_val):
# 产生人的函数(功能)
def person_attack(person_dict, dog_dict):
print(f"人{person_dict.get('name')}准备揍狗{dog_dict.get('name')}")
dog_dict['life_val'] -= person_dict.get('attack_val')
print(f"人揍了狗一拳 狗掉血{person_dict.get('attack_val')}狗剩余血量{dog_dict.get('life_val')}")
# 表示人的数据
person_dict = {
'name': name,
'age': age,
'gender': gender,
'p_type': p_type,
'attack_val': attack_val,
'life_val': life_val,
'person_attack': person_attack
}
return person_dict
def get_dog(name, d_type, attack_val, life_val):
def dog_attack(dog_dict, person_dict):
print(f"狗:{dog_dict.get('name')}准备咬人:{person_dict.get('name')}")
person_dict['life_val'] -= dog_dict.get('attack_val')
print(f"狗咬了人一口 人掉血:{dog_dict.get('attack_val')} 人剩余血量:{person_dict.get('life_val')}")
dog_dict = {
'name': name,
'd_type': d_type,
'attack_val': attack_val,
'life_val': life_val,
'dog_attack': dog_attack
}
return dog_dict
person1 = get_person('jason', 18, 'male', '猛男', 8000, 99999999)
dog1 = get_dog('小黑', '恶霸', 800, 900000)
person1.get('person_attack')(dog1, person1)
面向对象核心思想：数据与功能的绑定
编程思想
1.面向过程编程
过程即流程 面向过程就是按照固定的流程解决问题
eg：截止ATM为止 使用的几乎都是面向过程编程
注册功能 登录功能 转账功能
需要列举出每一步的流程 并且随着步骤的深入 问题的解决越来越简单
ps:提出问题 然后制定出该问题的解决方案
2.面向对象编程
对象即容器 数据与功能的结合体（python中一切皆对象）
eg：各种游戏人物
面向对象编程有点类似于造物主的感觉 我们只需要造出一个个对象
至于该对象将来会如何发展跟程序员没关系 也无法控制
"""
上述两种编程思想没有优劣之分 需要结合实际需求而定
如果需求是注册 登录 人脸识别肯定面向过程更合适
如果需求是游戏人物 肯定是面向对象更合适
实际编程两种思想是彼此交融的 只不过占比不同
"""
面向对象值类与对象
对象：数据与功能的结合体 对象才是核心
类：多个对象相同数据和功能的结合体 类主要就是为了节省代码
"""
一个人 对象
一群人 人类(所有人相同的特征)
一条狗 对象
一群狗 犬类(所有狗相同的特征)
"""
现实中一般是先有对象再有类
程序中如果想要产生对象 必须先定义出类
类与对象的创建
面向对象并不是一门新的技术 但是为了很好的一眼区分开 针对面向对象设计了新的语法格式
python中一定要有类 才能借助于类产生对象
1.类的语法结构
class 类名:
'''代码注释'''
对象公共的数据
对象公共的功能
1.class是定义类的关键字
2.类名的命名与变量名几乎一致 需要注意的是首字母推荐大写用于区分
3.数据：变量名与数据值的绑定 功能（方法）其实就是函数
2.类的定义与调用
类在定义阶段就是执行类体代码 但是属于类的局部名称空间 外界无法直接调用
# 需求：清华大学学生选课系统
# 定义类
class Student:
# 对象公共的数据
school_name = '清华大学'
# 对象公共的功能
def choice_course(self):
print('学生选课系统')
# 查看名称空间
# print(Student.__dict__)
# print(Student.__dict__.get('school_name')) # 清华大学
# print(Student.__dict__.get('choice_course')) # <function Student.choice_course at 0x0000022CA427F2F0>
'''在面向对象中 类和对象访问数据或者功能 可以统一采用句点符'''
# print(Student.school_name) # 清华大学
# print(Student.choice_course) # <function Student.choice_course at 0x0000021F693CEC80>
# 类的调用>>>:产生对象
'''类名加括号就会产生对象 并且每执行一次都会产生一个全新的对象'''
obj1 = Student() # 变量名obj1接收类名加括号之后的返回值(结果）
obj2 = Student()
obj3 = Student()
# print(obj1, obj2, obj3) # 三个看起来一样，其实内存地址不一样，不是同一个内存地址的东西
# print(obj1.__dict__) # 对象自己目前什么都没有 {}
# print(obj2.__dict__) # {}
# print(obj3.__dict__) # {}
print(obj1.school_name) # 清华大学
print(obj2.school_name) # 清华大学
print(obj3.school_name) # 清华大学
Student.school_name = '家里蹲大学'
print(obj1.school_name) # 家里蹲大学
print(obj2.school_name) # 家里蹲大学
print(obj3.school_name) # 家里蹲大学
'''数据和功能 也可以统称为属性 数据>>>:属性名 功能>>>:方法'''
对象独有的数据
class Student:
# 对象公共的数据
school_name = '清华大学'
# 对象公共的功能
def choice_course(self):
print('学生选课系统')
obj1 = Student()
obj2 = Student()
'''推导流程1：每个对象手动添加独有的数据'''
print(obj1.__dict__) # {}
obj1.__dict__['name'] = 'jason'
obj1.__dict__['age'] = 18
obj1.__dict__['hobby'] = 'study'
print(obj1.__dict__) # {'name': 'jason', 'age': 18, 'hobby': 'study'}
print(obj1.name) # jason
print(obj1.age) # 18
print(obj1.hobby) # study
print(obj2.__dict__) # {}
obj2.__dict__['name'] = 'kevin'
obj2.__dict__['age'] = 28
obj2.__dict__['hobby'] = 'music'
print(obj2.__dict__) # {'name': 'kevin', 'age': 28, 'hobby': 'music'}
print(obj2.name) # kevin
print(obj2.age) # 28
print(obj2.hobby) # music
'''推导流程2：将添加对象独有数据的代码封装成函数'''
def init(obj, name, age, hobby):
obj.__dict__['name'] = name
obj.__dict__['age'] = age
obj.__dict__['hobby'] = hobby
stu1 = Student() # 类中掉出来的第一个对象
stu2 = Student() # 类中调出来的第二个对象
init(stu1, 'jason', 18, 'music')
init(stu2, 'kevin', 28, 'read')
print(stu1.__dict__) # {'name': 'jason', 'age': 18, 'hobby': 'music'}
print(stu2.__dict__) # {'name': 'kevin', 'age': 28, 'hobby': 'read'
'''推导流程3：给学生对象添加独有数据的函数只有学生对象有资格调用'''
class Student:
# 对象公共的数据
school_name = '清华大学'
# 专门给学生添加独有数据的功能
def init(obj, name, age, hobby):
obj.__dict__['name'] = name
obj.__dict__['age'] = age
obj.__dict__['hobby'] = hobby
# 对象公共的功能
def choice_course(self):
print('学生选课功能')
stu1 = Student() # 调用出来的第一个对象
stu2 = Student() # 调用出来的第二个对象
Student.init(stu1, 'jason', 18, 'music') # 第一个对象填入数据
Student.init(stu2, 'kevin', 28, 'read') # 第二个对象填入数据
print(stu1.__dict__, stu2.__dict__) # 两个对象字典
'''推导步骤4：init方法变形'''
class Student:
# 对象公共的数据
school_name = '清华大学'
# 专门给学生添加独有数据的功能 变成__init__之后类产生对象的过程中自动触发
def __init__(obj, name, age, hobby):
obj.__dict__['name'] = name
obj.__dict__['age'] = age
obj.__dict__['hobby'] = hobby
# 对象公共的功能
def choice_course(self):
print('学生选课功能')
stu1 = Student('jason', 18, 'read')
print(stu1.__dict__) # {'name': 'jason', 'age': 18, 'hobby': 'read'}
print(stu1.name) # jason
print(stu1.school_name) # 清华大学
'''推导步骤5：变量名修改'''
class Student:
# 对象公共的数据
school_name = '清华大学'
# 专门给学生添加独有数据的功能 变成__init__之后类产生对象的过程中自动触发
def __init__(self, name, age, hobby):
self.name = name
self.age = age
self.hobby = hobby
# 对象公共的功能
def choice_course(self):
print('学生选课功能')
stu1 = Student('jason', 18, 'read')
print(stu1.__dict__) # {'name': 'jason', 'age': 18, 'hobby': 'read'}
print(stu1.name) # jason
print(stu1.school_name) # 清华大学
对象独有的功能
class Student:
# 对象公共的数据
school_name = '清华大学'
# 专门给学生添加独有数据的功能 变成__init__之后类产生对象的过程中自动触发
def __init__(self, name, age, hobby):
self.name = name
self.age = age
self.hobby = hobby
# 对象公共的功能
def choice_course(self):
print(f'学生{self.name}正在选课')
stu1 = Student('jason', 18, 'music')
stu2 = Student('kevin', 28, 'read')
# 1.直接在全局定义功能 该函数就不是学生对象独有的了
def eat():
print('吃东西') # 吃东西
stu1.eat = eat # 这个eat就是一个函数地址
print(stu1.__dict__) # {'name': 'jason', 'age': 18, 'hobby': 'music', 'eat': <function eat at 0x000001ACD8792EA0>}
stu1.eat()
# 2.只能将函数放在类中 但是类中的函数又是对象公共的
'''定义在类中的功能 默认就是绑定给对象使用的 谁来调谁就是主人公'''
Student.choice_course(stu1) # 类调用需要自己传参数 学生jason正在选课
stu1.choice_course() # choice_course(stu1) 对象调用会自动将对象当做第一个参数传入
stu1.choice_course() # 学生jason正在选课
stu2.choice_course() # 学生kevin正在选课
# 对象修改数据值
stu1.name = 'tony' # 当点的名字以及存在的情况下 则修改对应的值
# 对象新增数据值
stu1.pwd = 123 # 当点的名字不存在的情况下 则新增键值对
print(stu1.__dict__) # {'name': 'tony', 'age': 18, 'hobby': 'music', 'pwd': 123}
