面向对象编程

前戏

人狗大战小游戏 
# 人狗大战小游戏
# 1.描述人和狗
'''描述人和狗的方式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_dict = {
#         'name': name,
#         'gender': gender,
#         'age': age,
#         't_type': t_type,
#         'attack_val': attack_val,
#         'life_val': life_val
#     }
#     return data_dict
# def get_dog(name, t_type, attack_val, life_val):
#     data_dict = {
#         'name': name,
#         't_type': t_type,
#         'attack_val': attack_val,
#         'life_val': life_val
#     }
#     return data_dict
# p1 = get_person('jason', 'male', 18, '猛男', 800, 1000)
# p2 = get_person('kevin', 'female', 28, '淑女', 5, 100)
# dog1 = get_dog('小黑', '松狮犬', 300, 500)
# dog2 = get_dog('小白', '泰迪犬', 50, 200)

# def dog_attack(dog_obj, person_obj):
#     """
#     :param dog_obj: 接收一条狗
#     :param person_obj: 接收一个人
#     """
#     # 使用最简答的掉血逻辑  血量减去对方攻击力
#     print('当前人的血量是:%s' % 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['life_val']))

# def person_attack(person_obj, dog_obj):
#     """
#     :param person_obj: 接收一个人
#     :param dog_obj: 接收一条狗
#     """
#     print('当前狗的血量是:%s'%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['life_val']))
# 狗咬人
# dog_attack(dog2,p1)
# print(p1)
# 人锤狗
# person_attack(p2, dog1)
# print(dog1)
'''人调用了狗的攻击动作'''
# dog_attack(p1, dog1)
'''狗调用了人的攻击工作'''
# person_attack(dog2,p2)


"""如何做到只有人可以调用人的攻击动作 狗调用狗的攻击动作"""
# 其实就是想让人的数据跟人的功能绑定 狗的数据跟狗的功能绑定
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.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['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' % 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['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)
p2 = get_person('kevin','female',28,'淑女',10,100)
dog1 = get_dog('小黑', '松狮犬', 300, 500)
dog2 = get_dog('小白', '泰迪犬', 50, 200)
p1['person_attack'](p1,dog1)
dog1['dog_attack'](dog1,p2)
"""
上述操作其实就是将数据与功能进行绑定 
    不再是所有的数据都可以调用任意的功能
"""
# 上述将数据与功能整合到一起的操作其实就是 面向对象编程的思想

编程思想

1.面向过程编程

  核心在于'过程'  将程序的执行流程化  即分布操作 先做什么然后再做什么
    '''
      注册: 1.输入用户名 2.输入密码 3.将用户名与数据库的的用户名做对比判断是否已存在 4.不存在则新建并保存数据 ...
      结算购物车： 1.获取购物车数据 2.统计购物车的总价 3.将总价与现有余额对比 4.余额够实现扣费 ...
    '''
  '过程'好比是流水线 要有一个先后顺序 需要先完成上一步才能开始下一步 面向过程编程可以看作是创建在一条流水线上

2.面向对象编程

  核心在于'对象'  
    对象其实就是一个"容器" 将数据与功能整合到一起
      只要是符合上述描述的事物都可以称之为是对象
  '''
    人狗大战中最后的函数内部含有数据和功能 可以称之为面向对象编程
    模块文件内部含有数据和功能 也可以称之为面向对象编程
      python中一切皆对象
  
  '''

类与对象的概念

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

          狗      是      对象
        一群狗      是      狗类

    类只能描述公共的特征    依据参照物不同 
                          如人与狗对比 人类则存有 对象 人 共有的部分  狗类则为狗共有的

                          而人有不同的姓名 性别 分不同肤色  黄 黑 白  就需要由对象自己去描述
            
  '''
ps:类其实也算对象>>>:一切皆对象

类与对象的创建


"""
在代码编程中是先有类才能有对象
"""
# 先定义类 后产生对象
# 学生类
class Student:
    school = '清华'
    """类体代码无需调用就会执行 产生类的名称空间"""
    # print(school)  # 无需调用 运行py就执行输出

    def choose_course(self):
        print('选课')

"""类体代码无需调用就会执行 产生类的名称空间"""
"""
语法结构
class 类名:
    类体代码
1.class是定义类的关键字
2.类名类似于函数名 但是首字母推荐大写 用于区分
3.类体代码就是存放对象公共数据和功能的地方
    数据: 变量名 = 变量值
    功能: 函数
"""


# 查看名称空间的方法>>>:__dict__
# print(Student.__dict__)     # 返回值是一个字典 {'__module__': '__main__', 'school': '清华', 'choose_course': <function Student.choose_course at 0x00000221FF0463A0>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}

# print(Student.__dict__['school'])   # 获取类中的属性   清华
# print(Student.__dict__['choose_course'])   # 获取类中的属性 <function Student.choose_course at 0x00000216E9CE63A0>
"""类获取数据和功能有一个简便的方式>>>:句点符"""
print(Student.school)       # 清华
print(Student.choose_course)    # <function Student.choose_course at 0x000002032CA263A0>


"""如何产生对象:类名加括号"""
obj1 = Student()    # 类名加括号就是在产生一个对象
obj2 = Student()
# print(obj1.__dict__, obj2.__dict__)     # {} {}
# print(obj1.school)      # 清华
# print(obj2.school)      # 清华
# print(obj1.choose_course)       # bound method
# print(obj2.choose_course)
print(obj1.school)      # 清华
print(obj2.school)      # 清华
Student.school = '北大'  # Student.__dict__['school'] = '北大'  修改名字与值的对应关系
print(Student.school)   # 修改后为北大
print(obj1.school)      # 北大
print(obj2.school)      # 北大

对象的实例化


class Card:
    # 共同的数据
    card_type = 'monster card'

    # 共同的功能
    def card_attack(self):
        print('攻击表示')

    def card_defense(self):
        print('防御表示')


obj11 = Card()  # 目前对象没有自己独有的属性
obj22 = Card()  # 目前对象没有自己独有的属性
print(obj11.__dict__)  # {}  
print(obj22.__dict__)  # {}

'''方案1:逐步给对象添加独有的数据'''
print(obj11.__dict__)
print(obj22.__dict__)
obj11.__dict__['name'] = '青眼白龙'
obj11.__dict__['level'] = 8
obj11.__dict__['attrivute'] = '光'

obj22.__dict__['name'] = '黑魔导'
obj22.__dict__['level'] = 7
obj22.__dict__['attrivute'] = '闇'
print(obj11.__dict__,obj22.__dict__)    # {'name': '青眼白龙', 'level': 8, 'attrivute': '光'} {'name': '黑魔导', 'level': 7, 'attrivute': '闇'}
print(obj11.name, obj22.name)   # 青眼白龙 黑魔导

class Card:
    # 共同的数据
    card_type = 'monster card'

    # 共同的功能
    def card_attack(self):
        print('攻击表示')

    def card_defense(self):
        print('防御表示')
'''方案2:将冗余的添加步骤封装成函数'''
def init(obj, name, level, attribute):
    obj.name = name
    obj.level = level
    obj.attribute = attribute
obj1 = Card()
obj2 = Card()
init(obj1, '青眼白龙', 8, '光')
init(obj2, '黑魔导', 7, '闇')
print(obj1.name)
print(obj2.name, obj2.level)

'''方案3:简单的封装成函数没有提现出面向对象整合的精髓>>>:将函数写到类中去'''
class Card:
    def init(self, name, level, attribute):
        self.name = name            # 卡名
        self.level = level          # 等级
        self.attribute = attribute  # 属性

    # 共同的数据
    card_type = 'monster card'

    # 共同的功能
    def card_attack(self):
        print('攻击表示')

    def card_defense(self):
        print('防御表示')

obj1 = Card()
obj2 = Card()
Card.init(obj1,'青眼白龙', '8', '光')
Card.init(obj2,'黑魔导', '7', '闇')
print(obj1.name)
print(obj2.name, obj2.level)


'''方案4:类中针对给对象创建独有数据的函数名 专门定义了一个固定的方法'''
class Card:
    def __init__(self, name, level, attribute, attack, defense):
        '''该方法就一个功能>>>:给对象添加独有的数据'''
        self.name = name            # 卡名
        self.level = level          # 等级
        self.attribute = attribute  # 属性
        self.attack = attack        # 攻击力
        self.defense = defense      # 防御力

    # 共同的数据
    card_type = 'monster card'

    # 共同的功能
    def card_attack(self):
        print('攻击表示')

    def card_defense(self):
        print('防御表示')


obj1 = Card('青眼白龙', '8', '光', 3000, 2500)  
obj2 = Card('黑魔导', '7', '闇', 2500, 2100)

print(obj1.__dict__)  # {'name': '青眼白龙', 'level': '8', 'attribute': '光', 'attack': 3000, 'defense': 2500}
print(obj2.__dict__)  # {'name': '黑魔导', 'level': '7', 'attribute': '闇', 'attack': 2500, 'defense': 2100}

"""
类中的__init__方法会在类产生对象的时候自动执行
类产生对象的具体步骤
    1.先创建一个没有独有数据的空对象  {}
    2.将空对象和类括号内传入的数据一并交给__init__执行
        __init__的第一个参数就是对象本身
            __init__(obj,name,age,gender)
    3.将创建好的对象自动返回
给你提供这种方式能够减少代码的编写

ps:针对括号内第一个形参self其实就是一个普通的变量名而已
只不过该变量名将来专门接收对象的 所以给它起了个固定的名字叫self
"""

绑定方法

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

class Card:
    def __init__(self, name, level, attribute, attack, defense):
        '''该方法就一个功能>>>:给对象添加独有的数据'''
        self.name = name            # 卡名
        self.level = level          # 等级
        self.attribute = attribute  # 属性
        self.attack = attack        # 攻击力
        self.defense = defense      # 防御力

    # 共同的数据
    card_type = 'monster card'

    # 共同的功能
    def card_attack(self):
        print('攻击表示')

    def card_defense(self):
        print('防御表示')

# 类调用类中函数 有几个参数就需要传几个参数
  Card.card_attack(1)
  '''card_attack() 必须要传一个参 此处任意传参不影响输出'''

# 对象调用类中函数  会将当前调用的对象当做第一个参数自动传入
    obj1 = Card('青眼白龙', '8', '光', 3000, 2500)  
     '''def __init__(self, name, level, attribute, attack, defense):
      这里看似  self, name, level, attribute, attack, defense 6个参数
      实际第一个self参数会将当前的对象自动传入 即自动将obj1传给self
'''
    # obj1.card_attack()  # 攻击表示
posted @   扶我上码  阅读(878)  评论(0)  编辑  收藏  举报
（评论功能已被禁用）
相关博文：
·  面向对象编程——动静态方法、继承、属性查找、多继承、派生类
·  面向对象编程——双下方法、元类
·  面向对象编程
·  面向对象编程
·  Day25
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？
点击右上角即可分享
微信分享提示
SQL AI 助手