[7.26] python之类与对象基础介绍

2022/7/27 14:24:09

本文主要是介绍[7.26] python之类与对象基础介绍,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

今日学习内容

  • 面向对象
  • 编程思想(面向过程、面向对象)
  • 类与对象的概念
  • 类与对象的创建
  • 对象的实例化方法(独有数据)
  • 对象的绑定方法(独有功能)

面向对象铺垫

  • 需求:

    ​ 模拟人和狗相互攻击的过程以及结果

    • 推导步骤1: 直接手写字典模拟一个个人和狗
    person_1= {  # 使用字典模拟人的各种状态
        'name': 'jason',
        'person_type': '肌肉男',
        'attack_val': 1000,
        'life_val': 2000 }
    
    person_2= {  # 使用字典模拟人的各种状态
        'name': 'make',
        'person_type': '宅男',
        'attack_val': 300,
        'life_val': 1000 }
    
    dog_1 = {  # 使用字典模拟狗的各种状态
        'name': '黑狗',
        'd_type': '泰迪',
        'attack_val': 100,
        'life_val': 500 }
    
    dog_2 = {  # 使用字典模拟狗的各种状态
        'name': '黄狗',
        'd_type': '藏獒',
        'attack_val': 1000,
        'life_val': 1200 }
    
    
    
    • 推导步骤2: 由于定义人和狗的字典基本不变 但是在很多地方又需要反复使用 所以封装成函数
    def get_person(name,gender, age, p_type, attack_val, life_val):
    
        person_obj = {
            'name': name,
            'gender': gender,
            'age': age,
            'p_type': p_type,
            'attack_val': attack_val,
            'life_val': life_val    }
        return person_obj
    # 这样直接调用人的传参就比较方便使用了
    
    p1 = get_person('jason','man',18,'肌肉男',1000,2000)
    p2 = get_person('nana','woman',28,'淑女',100,800)
    
    
    def get_dog(name, d_type, attack_val, life_val):
        
        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):
        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):
        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','man',18,'肌肉男',1000,2000)
    p2 = get_person('nana','woman',28,'淑女',100,800)
    d1 = get_dog('小黄狗','中华田园犬',800, 5000)
    d2 = get_dog('小奶狗','哈士奇',100, 200)
    
    person_attack(p1, d1)  # 即将被攻击的狗:小黄狗 当前血量:5000
    # 人:jason 锤了 狗:小黄狗 狗掉血:1000 剩余血量:4000
    dog_attack(d2, p2)  # 即将被攻击的人:nana 当前血量:800
    # 狗:小奶狗 咬了 人:nana 人掉血:100 剩余血量:700
    
    &&&:人和狗攻击的函数 可以被任意调用
    person_attack(d1, p1)  # 即将被攻击的狗:jason 当前血量:2000
    # 人:小黄狗 锤了 狗:jason 狗掉血:800 剩余血量:1200
    """
    上述结果基于在调用函数时  按照函数形参的对应对象 传的实参   
    很容易把参数对象弄反   人和狗攻击的函数 可以被任意调用
    """
    
    • 推导步骤4: 人跟人攻击狗的函数绑定 狗跟狗攻击人的函数绑定
      我们定义的函数默认情况下都是可以被任意调用的 但是现在我们想实现定义的函数只有特定的东西才可以调用
    def get_person(name, gender, age, p_type, attack_val, life_val):
        """
        专用用于产生用户字典(创造人)
        :param name: 姓名
        :param gender: 性别
        :param age: 年龄
        :param d_type: 类型
        :param attack_val:攻击力
        :param life_val: 生命值
        :return: 人的字典(人)
        """
        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')))
        person_obj = {
            'name': name,
            'gender': gender,
            'age': age,
            'p_type': p_type,
            'attack_val': attack_val,
            'life_val': life_val,
            'person_attack':person_attack
        }
        return person_obj
    
    
    def get_dog(name, d_type, attack_val, life_val):
        """
        专门用于产生狗字典(狗)
        :param name: 狗的名字
        :param d_type: 狗的类型
        :param attack_val: 狗的攻击力
        :param life_val: 狗的生命值
        :return: 狗的字典(狗)
        """
        def dog_attack(dog_obj, person_obj):
            """
            专用提供给狗调用 攻击人
            :param dog_obj: 传狗数据(字典)
            :param person_obj: 传人数据(字典)
            """
            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')))
        dog_obj = {
            'name': name,
            'd_type': d_type,
            'attack_val': attack_val,
            'life_val': life_val,
            'dog_attack':dog_attack
        }
        return dog_obj
    d1 = get_dog('小黄狗','中华田园犬',800, 5000)
    p1 = get_person('jason','man',18,'肌肉男',1000,2000)
    
    p1.get('person_attack')(p1, d1)  # 可以执行
    p1.get('person_sttcak')(d1,p1)  # 调换了参数 直接报错
    
    • 总结:

      将人的数据跟人的功能绑定到一起
      只有人可以调用人的功能
      将狗的数据跟狗的功能绑定到一起
      只有狗可以调用狗的功能
      我们将数据与功能绑定到一起的操作起名为:'面向对象编程'

      本质:将特定的数据与特定的功能绑定到一起 将来只能彼此相互使用

    • 编程思想

    面向过程编程
    之前所学的所有的编程都是面向过程编程

    面向过程就是编写执行一系列的流程 按照流程步骤依次去执行 最终得出结果

    • 面向对象编程

    核心就是 【对象】二字

    对象就像一个容器一样 里面将数据和功能绑定在一起

    • 区别

    面向过程编程相当于让你给出一个问题的具体解决方案

    面向对象编程相当于让你创造出一些具体的事物 后就不需要在去操作了

    上述两种编程思想没有优劣之分 仅仅是使用场景不同
    甚至很多时候是两者混合使用

对象与类的概念

对象:数据与功能的结合体

类:多个对象相同的数据和功能的结合体

类主要用于记录多个对象相同的数据和功能
对象则用于记录多个对象不同的数据和功能
提醒:在面向对象编程中 类仅仅是用于节省代码 对象才是核心

对象与类的创建

1.建类的完整语法
class Student:
2.Student是类的名字
	类名的命名跟变量名一致 并且推荐首字母大写(为了更好的区分)
3.类体代码
	公共的数据\公共的方法
ps:类体代码在类定义阶段就会执行!!!

    
# class Student:
#     school = '清华大学'
#
#     def choice_course(self):
#         print('正在选课')

# 查看名称空间的方法
# print(Student.__dict__)  # 使用该方法查看名称空间 可以看成是一个字典
# print(Student.__dict__['school'])  # 使用字典的取值方式获取名字
# print(Student.__dict__.get('choice_course'))  # 使用字典的取值方式获取名字
'''在面向对象编程中 想要获取名称空间中的名字 可以采用句点符'''

print(Student.school)  # 清华大学
print(Student.choice_course)  # <function Student.choice_course at 0x0237B028>

'''类实例化产生对象: 类名加括号'''
stu = Student()
print(stu)  # <__main__.Student object at 0x0151A2F8>
print(stu.school)  # 清华大学
# print(stu1)  # <__main__.Student object at 0x000001D923B04A60>
# print(stu2)  # <__main__.Student object at 0x0000025E8A48F130>
# print(stu1.__dict__, stu2.__dict__)  # {} {}
Student.school = '复旦大学'  # 修改school键对应的值
stu = Student()
stu1 = Student()
print(stu.school)  # 复旦大学
print(stu1.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.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male'}
stu2 = Student('kevin', 28, 'female')
print(stu2.__dict__)  # {'name': 'kevin', 'age': 28, 'gender': 'female'}


这篇关于[7.26] python之类与对象基础介绍的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程