python基础知识-面向对象

面向对象前戏

"""推导步骤1：直接手写字典模拟一个个人和狗"""
person1 = {  # 使用字典模拟人
    'name': 'jason',
    'p_type': '猛男',
    'attack_val': 800,
    'life_val': 2000
}
person2 = {  # 使用字典模拟人
    'name': 'curry',
    'p_type': '闷骚',
    'attack_val': 100,
    'life_val': 1200
}
dog1 = {  # 使用字典模拟狗
    'name': '小黑狗',
    'd_type': '泰迪',
    'attack_val': 50,
    'life_val': 800
}
dog2 = {  # 使用字典模拟狗
    'name': '小舔狗',
    'd_type': '比特',
    'attack_val': 800,
    'life_val': 8000
}
"""推理步骤2：由于定义人和狗的字典基本不变 但是很多地方又需要反复使用 所以封装成函数 """


def get_person(name, gender, age, p_type, attack_val, life_val):
    """
    专用用于产生用户字典（创造人）
    :param name: 姓名
    :param gender: 性别
    :param age: 年龄
    :param p_type: 类型
    :param attack_val:攻击力
    :param life_val: 生命值
    :return: 人的字典（人）
    """
    psrson_obj = {
        'name': name,
        'gender': gender,
        'age': age,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return psrson_obj


p1 = get_person('jason', 'male', 18, '猛男', 8000, 80000)
p2 = get_person('kevin', 'female', 28, '淑女', 10, 80)


def get_dog(name, d_type, attack_val, life_val):
    """
    专门用于产生狗字典（狗）
    :param name:狗的名字
    :param d_type:狗的类型
    :param attack_val:狗的攻击力
    :param life_val:狗的生命值
    :return:狗的字典（狗）
    """
    dog_obj = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return dog_obj


d1 = get_dog('小黄狗', '中华田园犬', 800, 5000)
d2 = get_dog('小奶狗', '哈士奇', 100, 200)
"""推导步骤3：让人和狗具备攻击的能力 本质其实就是定义两个函数供人和狗调用"""


def person_attack(person_obj, dog_obj):
    """
    专门提供给人调用 攻击狗
    :param person_obj: 传人数据（字典）
    :param dog_obj: 传狗数据（字典）
    """
    print('即将被攻击的狗：%s 当前血量%s' % (dog_obj.get('name'),
                                 dog_obj.get('life_val')))  # 先展示当前狗的状态
    dog_obj['life_val'] -= person_obj.get('attack_val')  # 人锤狗 直接用狗的生命值减去人的攻击力
    print('人:%s 锤了 狗:%s 狗掉血:%s 剩余血量:%s' % (
        person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj.get('life_val')))


def dog_attack(dog_obj, person_obj):
    """
    专门提供给狗调用 攻击人
    :param dog_obj:
    :param person_obj:
    :return:
    """
    print('即将被攻击的人:%s 当前血量:%s' % (person_obj.get('name'), person_obj.get('life_val')))  # 先展示当前人的状态
    person_obj['life_val'] -= dog_obj.get('attack_val')  # 狗咬人 直接用人的生命值减去狗的攻击力
    print('狗:%s 咬了 人:%s 人掉血:%s 剩余血量:%s' % (
    dog_obj.get('name'), person_obj.get('name'), dog_obj.get('attack_val'), person_obj.get('life_val')))

# 调用人和狗的函数
p1 = get_person('jason','male',18,'猛男',800,9000)
p2 = get_person('kevin','female',28,'淑女',10,200)
d1 = get_dog('小黄狗','恶霸犬',800,8000)
d2 = get_dog('小黑狗','巴哥犬',200,500)
# 调用攻击彼此的函数
person_attack(p1,d1)
dog_attack(d2,p2)

代码优化


"""推导步骤1：直接手写字典模拟一个个人和狗"""
person1 = {  # 使用字典模拟人
    'name': 'jason',
    'p_type': '猛男',
    'attack_val': 800,
    'life_val': 2000
}
person2 = {  # 使用字典模拟人
    'name': 'curry',
    'p_type': '闷骚',
    'attack_val': 100,
    'life_val': 1200
}
dog1 = {  # 使用字典模拟狗
    'name': '小黑狗',
    'd_type': '泰迪',
    'attack_val': 50,
    'life_val': 800
}
dog2 = {  # 使用字典模拟狗
    'name': '小舔狗',
    'd_type': '比特',
    'attack_val': 800,
    'life_val': 8000
}
"""推理步骤2：由于定义人和狗的字典基本不变 但是很多地方又需要反复使用 所以封装成函数 """


def get_person(name, gender, age, p_type, attack_val, life_val):
    """
    专用用于产生用户字典（创造人）
    :param name: 姓名
    :param gender: 性别
    :param age: 年龄
    :param p_type: 类型
    :param attack_val:攻击力
    :param life_val: 生命值
    :return: 人的字典（人）
    """
    psrson_obj = {
        'name': name,
        'gender': gender,
        'age': age,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return psrson_obj


p1 = get_person('jason', 'male', 18, '猛男', 8000, 80000)
p2 = get_person('kevin', 'female', 28, '淑女', 10, 80)


def get_dog(name, d_type, attack_val, life_val):
    """
    专门用于产生狗字典（狗）
    :param name:狗的名字
    :param d_type:狗的类型
    :param attack_val:狗的攻击力
    :param life_val:狗的生命值
    :return:狗的字典（狗）
    """
    dog_obj = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return dog_obj


d1 = get_dog('小黄狗', '中华田园犬', 800, 5000)
d2 = get_dog('小奶狗', '哈士奇', 100, 200)
"""推导步骤3：让人和狗具备攻击的能力 本质其实就是定义两个函数供人和狗调用"""


def person_attack(person_obj, dog_obj):
    """
    专门提供给人调用 攻击狗
    :param person_obj: 传人数据（字典）
    :param dog_obj: 传狗数据（字典）
    """
    print('即将被攻击的狗：%s 当前血量%s' % (dog_obj.get('name'),
                                 dog_obj.get('life_val')))  # 先展示当前狗的状态
    dog_obj['life_val'] -= person_obj.get('attack_val')  # 人锤狗 直接用狗的生命值减去人的攻击力
    print('人:%s 锤了 狗:%s 狗掉血:%s 剩余血量:%s' % (
        person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj.get('life_val')))


def dog_attack(dog_obj, person_obj):
    """
    专门提供给狗调用 攻击人
    :param dog_obj:
    :param person_obj:
    :return:
    """
    print('即将被攻击的人:%s 当前血量:%s' % (person_obj.get('name'), person_obj.get('life_val')))  # 先展示当前人的状态
    person_obj['life_val'] -= dog_obj.get('attack_val')  # 狗咬人 直接用人的生命值减去狗的攻击力
    print('狗:%s 咬了 人:%s 人掉血:%s 剩余血量:%s' % (
    dog_obj.get('name'), person_obj.get('name'), dog_obj.get('attack_val'), person_obj.get('life_val')))

# 调用人和狗的函数
p1 = get_person('jason','male',18,'猛男',800,9000)
p2 = get_person('kevin','female',28,'淑女',10,200)
d1 = get_dog('小黄狗','恶霸犬',800,8000)
d2 = get_dog('小黑狗','巴哥犬',200,500)
# 调用攻击彼此的函数
person_attack(p1,d1)
dog_attack(d2,p2)

总结

将有人的数据跟人的功能绑定到一起
	只有人可以调用人的功能
将狗的数据跟狗的功能绑定到一起
	只有狗可以调用狗的功能
我们将数据与功能绑定到一起的操作起名为：'面向对象编程'
本质：将待定的数据与特定的功能绑定到一起 将来只能彼此相互使用

编程思想

面向过程编程
	截止博客到现在 所编写的代码都是面向过程编程
    过程其实就是流程 面向过程编程其实就是在执行一系列的流程
    eg：注册功能 登录功能 冻结账户...
    按照指定的步骤依次执行 最终就可以得到想要的结果
面向对象编程
	核心就是'对象'二字
    	对象其实就是一个容器 里面将数据和功能绑定到了一起
     eg：游戏人物...
    只负责创造出该人物以及该人物具备的功能 至于后续战绩如何无人知晓
"""
面向过程编码相当于让你给出一个问题的具体解决方案
面向对象编程相当于让你创造出一些事物之后不用你管
"""
上述两种编程思想没有优劣之分 仅仅是使用场景不同
甚至很多时候是两者混合使用

对象与类的概念

对象：数据与功能的结合体
类：多个对象相同的数据与功能的结合体
类比学习法
	一个人		对象
    多个人		人类
    一条狗		对象
    多条狗		犬类
类主要用于记录多个对象相同的数据和功能
对象则用于记录多个对象不同的数据和功能
ps：在面向对象编程中 类仅仅是用于节省代码 对象才是核心

对象与类的创建

在现实生活中理论是应该先有一个个的个体(对象)
再有一个个的群体(类)
在编程世界中必须要先有类才能产生对象

面向对象编程本质就是将数据和功能绑定到一起
但是为了突出面向对象编程的形式
python特地开发了一套语法专门用于面向对象编程的操作

创建类的完整语法


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)
"""
我们习惯将类或者对象句点符后面的东西称为属性名或者方法名
"""

对象独有的数据

# 学生类
# 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)
posted @   初学者-11  阅读(39)  评论(1)  编辑  收藏  举报
编辑推荐：
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
· 理解Rust引用及其生命周期标识（上）
· 浏览器原生「磁吸」效果！Anchor Positioning 锚点定位神器解析
· 没有源码，如何修改代码逻辑？
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· DeepSeek 开源周回顾「GitHub 热点速览」
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
点击右上角即可分享
微信分享提示