面向对象
目录- 面向对象前戏之人狗大战
- 面向对象编程思想
- 面向对象之类与对象
- 面向对象之类与对象的创建
- 面向对象之对象独有的数据
- 面向对象之对象独有的功能
面向对象前戏之人狗大战
1.推导步骤一， 用字典模拟人和狗
person1 = {
'name': 'jason',
'age': 18,
'gender': 'male',
'p_type': '猛男',
'attack_val': 8000,
'life_val': 99999999
}
person2 = {
'name': 'kevin',
'age': 28,
'gender': 'female',
'p_type': '淑女',
'attack_val': 1,
'life_val': 100
}
dog1 = {
'name': '小黑',
'd_type': '泰迪',
'attack_val': 100,
'life_val': 8000
}
dog2 = {
'name': '小白',
'd_type': '恶霸',
'attack_val': 2,
'life_val': 80000
}
'''如果想要定义出多个人或者多个狗 上述字典就需要反复的编写很多次'''
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, 99999999)
p2 = create_person('kevin', 28, 'female', '淑女', 100, 800)
d1 = create_dog('小黑', '恶霸', 800, 900000)
d2 = create_dog('小白', '泰迪', 100, 800000)
print(p1, p2)
print(d1, d2)
3.推导步骤三，二者具有攻击的能力（定义两个函数供人和狗调用）
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')}")
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')}")
person_attack(p1, d1)
dog_attack(d2, p2)
'''缺陷：人和狗攻击的函数，可以被任意调用，人可以调用狗攻击的功能，狗也可以调用人的攻击的功能'''
4.人和狗攻击乱套，两者函数可以随意调用
person_attack(d1, p1) # 人：小黑 准备揍狗 jason
dog_attack(p1, d2)
5.将人与人攻击狗的函数绑定，狗与狗攻击人的函数绑定
面向对象的核心思想就是数据和功能的绑定
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')(person1, dog1)
6.总结
1.将人的数据与人的功能绑定在一起，只有人可以调用人的功能
2.将狗的数据与狗的功能绑定在一起，只有狗可以调用狗的功能
3.我们将数据与功能绑定在一起的操作称为：'面向对象编程'，本质就是将特定的数据与特定的功能绑定在一起，将来只能批次互相使用
编程思想
1.面向过程编程
1.就是按照指定的步骤依次执行，最终就可以得到想要的结果，过程就像我们之前写的ATM+购物车，就是在执行一系列的流程
2.面向过程编程，核心就是'过程'俩个字，在做一件事情的时候，将这个事情划分为好几个步骤，然后一步一步的去实现，最终结合起来，形成了整件事，
3.例如:我俩在做ATM+购物车的时候，我们先构思里它能实现的功能，然后将功能一个个的写出来，然后再结合起来，就是一个项目。
2.面向对象编程
1.核心就是'对象'俩个字，对象其实就是一个容器，里面将数字和功能绑定到了一起
2.例子一：人狗大战中对数据和功能的整合
3.例子二：模块文件内含有数据和功能函数
2.例子三：将风扇可以是一个对象。如果我们把风扇当作一个对象，那么它的属性就是——颜色、型号、价格、品牌等等，它的行为（函数）是换挡、转动。
3.例子四：如果我们把狗当作一个对象，那么它的属性就是——它的颜色、品种、名字、生命力等，而它的行为（函数）是行走、叫、吃喝等
4.不同的功能被归纳到不同的类中。然后由类产生出对象，这些对象之间的相互作用
3.总结
1.面向过程编程相当于让你给出一个问题的具体解决方案
2.面向对象编程相当于让你创造出一些事物之后不用你管
面向对象之类与对象
1.如何去理解对象
1.数据与功能的结合体，主要用于记录多个对象相同的数据和功能
2.对象就是具体的，可以有它的姓名、颜色、品种，它是一个实实在在存在的东西
2.如何理解类
1.多个对象相同的数据和功能的结合体，主要用于记录多个对象不同的数据和功能
2也可以理解为类里面装着对象，类比较抽象，只是笼统的概括一下，就比如'学生类'，没有具体的指谁，里面可以有张三，也可以有李四。
3简单来说就是某一类事物，它们具有相同的属性和行为或者说是方法，在代码中我们将这些行为或者方法定
义成函数。
ps:对象是核心，类的使用仅仅是为了节省代码
面向对象之类与对象的创建
1.理论知识
面向对象并不是一门新的技术 但是为了很好的一眼区分开 针对面向对象设计了新的语法格式
python中一定要有类 才能借助于类产生对象
2.类的基本语法
class Student
# 学生对象公共的数据
# 学生对象公共的方法
'''
对语法的解释说明：
class是定义类的关键字
People是类的名字，类名的命名跟变量名一致，为了更好的区分推荐首字母大写
类体代码 公共的数据，或者公共的方法
可以创建空的类
类体最常见的是变量的定义和函数的定义，但其实类体可以包含任意Python代码，类体的代码在类定义阶段
3.类的定义与调用
类在定义阶段就会执行类体代码 但是属于类的局部名称空间 外界无法直接调用
3.1查看名称空间的方法>>>:使用.__dict__ ,使用该方法查看名称空间，可以看作是一个字典
class Student: # 类的命名应该使用“驼峰体”
school='清华大学' # 数据
def choice_course(self): # 功能
print('学生选课功能')
print(Student.__dict__)
'''{..., 'school': '清华大学', 'choice_course': <function Student.choose at 0x1018a2950>,...}'''
3.2使用字典的取值方式取值
print(Student.__dict__.get('school_name'))
print(Student.__dict__.get('choice_course'))
3.3在面向对象编程中，想要获取名称空间的名字，可以用句点符
print(Student.school_name)
print(Student.choice_course)
3.4类实例化产生对象
类的调用>>>:产生对象 也称为实例化
'''类名加括号就会产生对象 并且每执行一次都会产生一个全新的对象'''
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)
'''我们习惯将类或者对象句点符后面的东西称为属性名或者方法名
每实例化一次Student类就得到一个学生对象，每一次都不一样'''
面向对象之对象独有的数据
class Student:
# 对象公共的数据
school_name = '清华大学'
# 对象公共的功能
def choice_course(self):
print('学生选课功能')
obj1 = Student()
obj2 = Student()
1.推导流程1，通过利用__dict__的方法来向字典添加键值对
print(obj1.__dict__)
obj1.__dict__['name'] = 'jason'
obj1.__dict__['age'] = 18
obj1.__dict__['hobby'] = 'study'
print(obj1.__dict__)
print(obj1.name)
print(obj1.age)
print(obj1.hobby)
print(obj2.__dict__)
obj2.__dict__['name'] = 'kevin'
obj2.__dict__['age'] = 28
obj2.__dict__['hobby'] = 'music'
print(obj2.__dict__)
print(obj2.name)
print(obj2.age)
print(obj2.hobby)
2.推导流程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', 29, 'read')
print(stu1.__dict__)
print(stu2.__dict__)
3.推导流程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()
Student.init(stu1, 'jason', 18, 'music')
stu2 = Student()
Student.init(stu2, 'kevin', 29, 'read')
print(stu1.__dict__, stu2.__dict__)
4.推导步骤4:init方法变形
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('jason', 18, 'read')
print(stu1.__dict__)
print(stu1.name)
print(stu1.school_name)
5.推导步骤5:变量名修改
class Student:
# 对象公共的数据
school_name = '清华大学'
# 专门给学生添加独有数据的功能 类产生对象的过程中自动触发
def __init__(self, name, age, hobby):
self.name = name # self.__dict__['name'] = name
self.age = age
self.hobby = hobby
# 对象公共的功能
def choice_course(self):
print('学生选课功能')
stu1 = Student('jason', 18, 'read')
print(stu1.name)
print(stu1.school_name)
面向对象之对象独有的功能
class Student:
# 对象公共的数据
school_name = '清华大学'
# 专门给学生添加独有数据的功能 类产生对象的过程中自动触发
def __init__(self, name, age, hobby):
self.name = name # self.__dict__['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
print(stu1.__dict__)
stu1.eat()
# 2.只能将函数放在类中 但是类中的函数又是对象公共的
'''定义在类中的功能 默认就是绑定给对象使用的 谁来调谁就是主人公'''
Student.choice_course(123) # 类调用需要自己传参数
stu1.choice_course() # choice_course(stu1) 对象调用会自动将对象当做第一个参数传入
stu1.choice_course()
stu2.choice_course()
# 对象修改数据值
stu1.name = 'tony' # 当点的名字已经存在的情况下 则修改对应的值
# 对象新增数据值
stu1.pwd = 123 # 当点的名字不存在的情况下 则新增数据
print(stu1.__dict__)