面向对象思想

面向对象编程思想前戏#

人狗大战小游戏#

描述人和狗

方式1:使用一个字典一个个描述#

dog1 = {
    'name': '小黑',
    'type': '田园犬',
    'attack_val': 30,
    'life_val': 200
}
dog2 = {
    'name': '小白',
    'type': '恶霸犬',
    'attack_val': 180,
    'life_val': 500
}
person1 = {
    'name': '小龙',
    'type': '猛男',
    'attack_val': 10,
    'life_val': 1000
}

方式2:封装成函数 减少代码冗余#

def get_person(name, gender, age, t_type, attack_val, life_val):
    data = {
        'name': name,
        'gender': gender,
        'age': age,
        't_type': t_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return data
def get_dog(name, t_type, attack_val, life_val):
    data = {
        'name': name,
        't_type': t_type,
        'attack_val': attack_val,  # 攻击
        'life_val': life_val  # 生命值
    }
    return data
p1 = get_person('tuzi', 'male', '20', '开挂的猛男', 666, 1500)
d1 = get_dog('泡面(狗名)', '中华田园犬', 100, 600)

思考如何做到人和狗只能调用属于自己的攻击动作#

其实就是想让人的数据跟人的功能绑定 狗的数据跟狗的功能绑定

def get_person(name, gender, age, t_type, attack_val, life_val):
    # 将人的攻击动作放在产生人的函数内
    def person_attack(person_obj, dog_obj):
        """
        :param person_obj: 接收一个人
        :param dog_obj: 接收一条狗
        """
        print('当前狗的血量是:%s' % dog_obj['life_val'])
        dog_obj['life_val'] -= person_obj['attack_val']
        print(f"人{person_obj['name']}打了狗{dog_obj['name']}一下,剩余血量{dog_obj['life_val']}")


    data_dict = {
        'name': name,
        'gender': gender,
        'age': age,
        't_type': t_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'person_attack':person_attack
    }
    return data_dict
def get_dog(name, t_type, attack_val, life_val):
    # 将狗的攻击动作放在产生人的函数内
    def dog_attack(dog_obj, person_obj):
        """
        :param dog_obj: 接收一条狗
        :param person_obj: 接收一个人
        """
        # 使用最简答的掉血逻辑  血量减去对方攻击力
        print('当前狗的血量是:%s' % dog_obj['life_val'])
        dog_obj['life_val'] -= person_obj['attack_val']
        print(f"人{person_obj['name']}打了狗{dog_obj['name']}一下,剩余血量{dog_obj['life_val']}")
    data_dict = {
        'name': name,
        't_type': t_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'dog_attack':dog_attack
    }
    return data_dict
p1 = get_person('jason','male',18,'猛男',800, 1000)
d1 = get_dog('泡面(狗名)', '中华田园犬', 100, 600)
p1['person_attack'](p1,d1)

# 上述操作就是把数据和对应的功能绑定在一起了,不再是所有的数据都可以调用任意的功能了
# 上述讲数据与功能整合到一起的操作其实就是面向对象编程的思想

编程思想#

面向过程编程#

将程序的执行流程化，即分步操作，分步的过程中解决问题
eg:注册、登录、结算购物车...
      """注册:第一步获取用户名 第二步比对用户名数据 ..."""
      """结算:第一步获取购物车数据 第二步计算钱数   ..."""
过程可以理解成是流水线 面向过程编程可以理解成是在创建一条流水线

面向对象编程#

'对象'就是面向对象编程的核心
对象其实就是一个'容器'将数据与功能整合到一起,只要是符合上述描述的事物都可以称之为是对象
eg:
    人狗大战最后的函数内部有数据和功能,可以称之为面向对象编程
    模块文件内部含有数据和功能,也可以称之为面向对象编程
'''细想一下,python中一切皆为对象'''
python针对面向编程提供了专门的语法,识别度更高,编写更精简
eg:人、动物、游戏角色
"""
面向过程与面向对象两者没有优劣之分 具体要结合实际情况
甚至很多时候两者是混合在一起的!!! 思想占据的比例不同而已
"""

类与对象的概念#

什么是类与对象#

对象：数据与功能的结合体
类：即类别、种类、相当于诸多对象公有的特征(数据、功能)
'''
在现实生活中
人		对象
一群人	   人类

狗 		对象
一群狗	   犬类
上述的人类、犬类就是用来描述多个对象'相同'特征的名词
人分为黄种人、黑种人、白种人，都属于人类，但是彼此也有不同的特征
类只能描述公共的特征，不同的特征应该由对象自己描述
'''
🐖：类其实也算对象>>>:一切皆对象

类与对象的创建#

定义类#

'''
在代码编程中是现有类才能有对象
'''
# 定义类
# 学生类
class Student:
    school = '清华大学'
    def choise_course(self):
        print('学生选课功能')
'''类体代码无序调用就会执行，产生类的名称空间'''
'''
语法结构
class 类名：
	类体代码
1.class 是定义类的关键字
2.类名类似于函数名，但是首字母推荐大写，用于区分
3.类体代码就是存放对象公共数据和功能的地方
	数据：变量名 = 变量值
	功能：函数
'''

语法结构#

class 类名：
	类体代码
1.class 是定义类的关键字
2.类名类似于函数名，但是首字母推荐大写，用于区分
3.类体代码就是存放对象公共数据和功能的地方
	数据：变量名 = 变量值
	功能：函数
'''

查看名称空间的方法:__dict__#

# 查看名称空间的方法>>>>:__dict__
# print(Student.__dict__)  # 返回值是一个字典
# print(Student.__dict__['school'])  # 获取类中的属性
# 清华大学
# print(Student.__dict__['choise_course'])  # 获取类中的属性
# <function Student.choise_course at 0x000002CDFFC4CA60>
'''类获取数据和功能有一个简便的方式>>>>:句点符'''
# print(Student.school)
# 清华大学
# print(Student.choise_course)
# <function Student.choise_course at 0x000002CDFFC4CA60>

如何产生对象：类名加括号#

'''如何产生对象:类名加括号'''
obj1 = Student()  # 类名加括号就是在产生一个对象
obj2 = Student()  # 类名加括号就是在产生一个对象
print(obj1.__dict__,obj2.__dict__)  # {} {}
print(obj1.school)  # 清华大学
print(obj2.school)  # 清华大学
print(obj1.choise_course)  # <bound method Student.choise_course of <__main__.Student object at 0x00000266787F7438>>
print(obj2.choise_course)  # <bound method Student.choise_course of <__main__.Student object at 0x00000266787F7470>>
Student.school = '北京大学'  # Student.__dict__['school'] = '北京大学'  修改名字与值的对应关系
print(obj1.school)  # 北京大学
print(obj2.school)  # 北京大学

对象的实例化#

class Student:
    # 方案三函数
    # def set_info(self,name,age,gender):
    #     """该方法就一个功能>>>:给对象添加独有的数据"""
    #     self.name = name  # self.__dict__['name'] = name
    #     self.age = age  # self.__dict__['age'] = age
    #     self.gender = gender  # self.__dict__['gender'] = gender
    # 方案四函数
    def __init__(self,name,age,gender):
        """该方法就一个功能>>>:给对象添加独有的数据"""
        self.name = name  # self.__dict__['name'] = name
        self.age = age  # self.__dict__['age'] = age
        self.gender = gender  # self.__dict__['gender'] = gender
    # 学生类公共的数据
    school = '清华大学'
    # 学生类公共的功能
    def choose_coures(self):
        print('学生选课功能')
# obj1 = Student()  # 目前对象没有自己独有的属性
# print(obj1.__dict__)  # 大白话就是给字典添加键值对
'''方案1:逐步给对象添加独有的数据'''
# obj1.__dict__['name'] = 'tuzi'
# obj1.__dict__['age'] = 18
# obj1.__dict__['gender'] = 'male'
# print(obj1.__dict__)  # {'name': 'tuzi', 'age': 18, 'gender': 'male'}
# print(obj1.name)  # tuzi
'''方案2:将冗余的添加步骤封装成函数'''
# def init(obj,name,age,gender):
#     obj.name = name  # obj.__dict__['name'] = name
#     obj.age = age  # obj.__dict__['age'] = age
#     obj.gender = gender  # obj.__dict__['gender'] = gender
# init(obj1,'tuzi',18,'male')
# print(obj1.name)  # tuzi
'''方案3:简单的封装成函数没有提现出面向对象整合的精髓>>>:讲函数写到类中去'''
# obj1  = Student()
# Student.set_info(obj1,'jason',18,'male')
# print(obj1.name)  # jason
'''方案4:类中针对给对象创建,独有数据的函数名,专门定义了一个固定的方法'''
obj1 = Student('tuzi',18,'male')
print(obj1.__dict__)  # {'name': 'tuzi', 'age': 18, 'gender': 'male'}

__init__与self#

类中的__init__方法会在类产生对象的时候执行
类产生对象的具体步骤
1.先创建一个没有独有数据的空对象{}
2.将空对象和类括号内传入的数据一般交给__init__执行
	__init__的第一参数就是对象本身
    __init__(obj,name,age,gender)
    obj 就是对象的本身
3.将创建好的对象自动返回
给你提供这种方式能够减少代码的编写
# self说明
针对括号内第一个形参self其实就是一个普通的变量名而已
只不过该变量名将来专门接收对象的,所以给他起了个固定的名字叫self

绑定方法#

在类中定义的函数默认都是绑定给对象使用的,即对象来调 会自动将对象当做第一个参数传入

class Student:
    school = '清华大学'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(f'{self.name}正在调用func方法')

    def index(self):
        print(f'{self.name}正在调用index方法')

#
obj1 = Student('jason',18)
# print(obj1)
obj2 = Student('kevin',28)
# print(obj2)
obj1.func()  # jason正在调用func方法
obj2.func()  # kevin正在调用func方法
print(obj1.func)  # <bound method Student.func
print(obj2.func)  # <bound method Student.func
'''所以应该能理解为什么类中所有的函数第一个参数都是self'''