面向对象
今日内容概要
- 面向对象前戏
- 编程思想（过程，对象）
- 类与对象的概念
- 类与对象的创建
- 对象的实例化方法
- 对象的绑定方法（独有功能）
快乐的人狗大战
人狗大战
# 人狗大战
dog1 = {
'name': '来福',
'd_type': '大黄',
'attack': 99999,
'life_val': 10000
}
dog2 = {
'name': '旺财',
'd_type': '小黄',
'attack': 1,
'life_val': 10
}
preson1 = {
'name': 'jason',
'd_type': '猛男',
'attack': 1,
'life_val': 100000}
preson2 = {
'name': 'tony',
'd_type': '骚男',
'attack': 3000,
'life_val': 1000}
def preson(name, d_type, attack, life_val):
preson_obj = {
'name': name,
'd_type': d_type,
'attack': attack,
'life_val': life_val}
return preson_obj
def dog(name, d_type, attack, life_val):
dog_obj = {
'name': name,
'd_type': d_type,
'attack': attack,
'life_val': life_val}
return dog_obj
p1 = preson('jason', '猛男', 10, 10000)
p2 = preson('tony', '猛男', 1000, 1000)
d1 = dog('大黄', '猛犬', 10000, 10000)
d2 = dog('小黄', '猛犬', 10, 10000)
def person_attack(get_person1, get_dog1): # 功能
print("""%s当前血量%s""" % (get_dog1['name'], get_dog1['life_val']))
get_dog1['life_val'] -= get_person1['attack']
print("""人锤狗:%s锤了一下狗掉血%s狗当前血量为%s""" % (get_person1['name'], get_person1['attack'], get_dog1['life_val']))
def dog_attack(get_dog1, get_person1): # 功能
print("""%s当前血量%s""" % (get_person1['name'], get_person1['life_val']))
get_person1['life_val'] -= get_dog1['attack'] * 4 # 狗附带魔法伤害很强
print("""狗锤人:%s锤了一下人掉血%s人当前血量为%s""" % (get_dog1['name'], get_dog1['attack'], get_person1['life_val']))
person_attack(p1, d2)
dog_attack(d1, p1)
print(p1, d2)
优化版
def preson(name, d_type, attack, life_val):
def person_attack(get_person1, get_dog1): # 功能
print("""%s当前血量%s""" % (get_dog1['name'], get_dog1['life_val']))
get_dog1['life_val'] -= get_person1['attack']
print("""人锤狗:%s锤了一下狗掉血%s狗当前血量为%s""" % (get_person1['name'], get_person1['attack'], get_dog1['life_val']))
preson_obj = {
'name': name,
'd_type': d_type,
'attack': attack,
'life_val': life_val,
'person_attack':person_attack}
return preson_obj
def dog(name, d_type, attack, life_val):
def dog_attack(get_dog1, get_person1): # 功能
print("""%s当前血量%s""" % (get_person1['name'], get_person1['life_val']))
get_person1['life_val'] -= get_dog1['attack'] * 4 # 狗附带魔法伤害很强
print("""狗锤人:%s锤了一下人掉血%s人当前血量为%s""" % (get_dog1['name'], get_dog1['attack'], get_person1['life_val']))
dog_obj = {
'name': name,
'd_type': d_type,
'attack': attack,
'life_val': life_val,
'dog_attack':dog_attack}
return dog_obj
p1 = preson('jason', '猛男', 10, 10000)
p2 = preson('tony', '猛男', 1000, 1000)
d1 = dog('大黄', '猛犬', 10000, 10000)
d2 = dog('小黄', '猛犬', 10, 10000) # {字典内有函数名可以调用}
p1.get('person_attack')(p1,d1)
d1.get('dog_attack')(d1,p2)
d2.get('person_attack')(d2,p1) # 狗没有该功能无法调用
'''总结'''
将人数据跟人的功能绑到一起
只有人可以调用
将狗的数据跟狗绑定到一起
只有狗可以调用
将数据与功能绑定到一起的操作叫面向对象编程
本质：将特定的数据与特定的功能绑到一起，将来只能彼此使用
编程思想
面向过程编程
截止昨天 我们所编写的代码都是面向过程编程
过程其实就是流程 面向过程编程其实就是在执行一系列的流程
eg: 注册功能 登录功能 冻结账户 ...
就是按照指定的步骤依次执行 最终就可以得到想要的结果
面向对象编程
核心就是'对象'二字
对象其实就是一个容器 里面将数据和功能绑定到了一起
eg: 游戏人物 ...
只负责创造出该人物以及该人物具备的功能 至于后续战绩如何无人知晓
"""
面向过程编程相当于让你给出一个问题的具体解决方案
面向对象编程相当于让你创造出一些事物之后不用你管
"""
上述两种编程思想没有优劣之分 仅仅是使用场景不同
甚至很多时候是两者混合使用
对象与类的概念
对象：数据与功能的结合体
类：多个对象相同的数据和功能的结合体
类主要用于记录多个对象相同的数据和功能
对象主要用于记录多个对象不同的数据和功能
在面向对象编程中类为了节省代码，对象才是核心
- 对象与类的创建
在现实中理论先有个体才有群里，在编程里先有类才能产生对象 - 面向对象编程本质就是将数据与功能绑定，为了突出面向对象编程的形式转门开发了一套语法用于面向对象编程的操作
关键字class 类
class 类名：
# 对象的公共数据
shool ='斯坦福'
#对象公共的功能
def func():
print('你好')
查看类的名称空间名字
print(类名.dict)
- 获取名字
obj_name = 类名.dict[键]
obj_name = 类名.dict.get('键')
obj_name = 类名.名字 - 产生对象 实例化
类名加括号
对象 = 类（）
![image]()
创建类的完整语法
class People:
# 学生对象公共的数据
# 学生对象公共的方法
1.class是定义类的关键字
2.People是类的名字
类名的命名跟变量名一致 并且推荐首字母大写(为了更好的区分)
3.类体代码
公共的数据\公共的方法
ps:类体代码在类定义阶段就会执行!!!
# 查看名称空间的方法
# print(Student.__dict__) # 使用该方法查看名称空间 可以看成是一个字典
# print(Student.__dict__['school']) # 使用字典的取值方式获取名字
# print(Student.__dict__.get('choice_course')) # 使用字典的取值方式获取名字
'''在面向对象编程中 想要获取名称空间中的名字 可以采用句点符'''
# print(Student.school)
# print(Student.choice_course)
'''类实例化产生对象>>>: 类名加括号'''
stu1 = Student()
stu2 = Student()
print(stu1.school)
print(stu2.school)
# print(stu1) # <__main__.Student object at 0x000001D923B04A60>
# print(stu2) # <__main__.Student object at 0x0000025E8A48F130>
# print(stu1.__dict__, stu2.__dict__) # {} {}
# print(stu1.school)
# print(stu2.school)
# print(stu1.choice_course)
# print(stu2.choice_course)
Student.school = '北京大学' # 修改school键对应的值
print(stu1.school)
print(stu2.school)
"""
我们习惯将类或者对象句点符后面的东西称为属性名或者方法名
"""
### 对象独有的数据
```python
# 学生类
# class Student:
# # 学生对象公共的数据
# school = '清华大学'
#
# # 学生对象公共的方法
# def choice_course(self):
# print('正在选课')
'''推导思路1: 直接利用__dict__方法朝字典添加键值对'''
# obj1 = Student()
# obj1.__dict__['name'] = 'jason' # 等价于 obj1.name = 'jason'
# obj1.__dict__['age'] = 18 # 等价于 obj1.age = 18
# obj1.__dict__['gender'] = 'male' # ...
# print(obj1.name)
# print(obj1.age)
# print(obj1.gender)
# print(obj1.school)
# obj2 = Student()
# obj2.__dict__['name'] = 'kevin'
# obj2.__dict__['age'] = 28
# obj2.__dict__['gender'] = 'female'
# print(obj2.name)
# print(obj2.age)
# print(obj2.gender)
# print(obj2.school)
'''推导思路2: 将添加独有数据的代码封装成函数'''
# def init(obj,name,age,gender):
# obj.__dict__['name'] = name
# obj.__dict__['age'] = age
# obj.__dict__['gender'] = gender
# stu1 = Student()
# stu2 = Student()
# init(stu1,'jason',18,'male')
# init(stu2, 'kevin',28,'female')
# print(stu1.__dict__)
# print(stu2.__dict__)
'''推导思路3: init函数是专用给学生对象创建独有的数据 其他对象不能调用>>>:面向对象思想 将数据和功能整合到一起
将函数封装到学生类中 这样只有学生类产生的对象才有资格访问
'''
class Student:
"""
1.先产生一个空对象
2.自动调用类里面的__init__方法 将产生的空对象当成第一个参数传入
3.将产生的对象返回出去
"""
def __init__(self, name, age, gender):
self.name = name # obj.__dict__['name'] = name
self.age = age # obj.__dict__['age'] = age
self.gender = gender # obj.__dict__['gender'] = gender
# 左右两边的名字虽然一样 但是意思不一样 左边的其实是字典的键 右边的其实是实参
# 学生对象公共的数据
school = '清华大学'
# 学生对象公共的方法
def choice_course(self):
print('正在选课')
# stu1 = Student()
# print(stu1.__dict__)
# Student.init(stu1, 'jason', 18, 'male')
# print(stu1.__dict__)
# print(stu1.name)
stu1 = Student('jason', 18, 'male')
print(stu1)
stu2 = Student('kevin', 28, 'female')
print(stu2)
浙公网安备 33010602011771号