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

2022/7/27 14:24:09

编程Tag： get name obj python val Person dog 之类 7.26

本文主要是介绍[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之类与对象基础介绍的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！


相关编程文章

更多>
本站官方QQ
官方QQ:
23002807

沪ICP备2023033072号-1

     

扫一扫关注最新编程教程