Day31面向对象

• Day31面向对象
• • 1、面向对象前戏
  • • 1.1、人狗大战案例
    • 1.2、代码优化
    • 1.3总结
  • 2、编程思想
  • 3、对象与类的概念
  • 4、对象与类的创建
  • • 4.1、查看名称空间的方法
    • 4.2、对象 独有的数据

案例：人狗大战

需求：用我们所学的知识，用代码模拟人狗大战

推到步骤1

#手写人和狗的数据

# 使用字典模拟人
person1 = {  
     'name': 'jason',
     'p_type': '猛男',
     'attack_val': 800,
     'life_val': 2000
 }
 person2 = {  
     'name': 'kk',
     'p_type': '快男',
     'attack_val': 100,
     'life_val': 1200
 }
    
# 使用字典模拟狗
dog1 = {  
     'name': '黑狗',
     'd_type': '捷克',
     'attack_val': 800,
     'life_val': 800
 }
dog2 = {  
     'name': '舔狗',
     'd_type': '战狼',
     'attack_val': 80,
     'life_val': 8000
 }

推导步骤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
    
#创造 生产狗的函数
def get_dog(naem,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

#创造 人
p1 = get_person('jason','male','20','猛男',800,1000)
p2 = get_person('kk','male','20','淑女',80,10)

#创造 狗
d1=get_dog('黑狗','捷克',888,600)
d2=get_dog('白狗','蓝湾',800,500)

推导步骤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')))
    
person_attack(p1,d2)
dog_attack(d1,p2)

人和狗的攻击函数 可以被任意调用，人可以调用狗的攻击方式，狗可以调用人的攻击方式。

推导步骤4：

# 人攻击的函数
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')))

person_attack(d2,p1)
dog_attack(p2,d1)

推导步骤5：

实现人跟人攻击狗的函数绑定，狗跟狗攻击人的函数绑定

# 将狗的攻击 函数装入 创造狗的函数中 再通过 狗的数据字典 添加一个键 作为值返回到全局
def get_person(name,gender,age,p_type,attack_val,life_val):
    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')))
    person_obj = {
        'name': name,
        'gender': gender,
        'age': age,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val
        'attack':person_attack
    }
    return person_obj

#将 人的攻击方式放入创造人的函数中 通过人的数据 中以值得形式 从函数返回 人攻击函数得函数名
#创造 生产狗的函数
def get_dog(name,d_type,attack_val,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')))

    dog_obj = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val
        'attack':dog_attack
    }
    return dog_obj

# 可以在创造人或狗后直接调用 内部攻击函数
d1=get_dog('杰克','捷克狼犬',800,1000)
p1=get_person('kk','female',20,'淑女',100,10)
d1.get('attack')(d1,d2)

将人的数据跟人的功能绑定到一起，只有人可以调用人的功能
将狗的数据跟狗的功能绑定到一起，只有狗可以调用狗的功能

我们将数据与功能绑定到一起的操作起名为：面向对象编程

• 将特定的数据与特定的功能绑定到一起，将来只能彼此调用

面向过程编程

• 我们之前所学所写的代码都是面向过程编程
• 过程其实就是流程，面向过程编程其实就是在执行一系列的流程
  • 注册功能 登录功能 冻结账户 ···
• 按照指定的步骤依次执行 最终 就可以得到想要的结果

面向对象编程

• 核心就是 对象 二字

  • 对象其实就是一个 容器 ，里面改将数据和功能绑定到一起

• 例如 游戏人物

  只负责 创造出该人物以及 该人物 具备的功能 至于 后续战机如何 无人 知晓

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

面向 对象 编程 相当于让你创造出一些 事物之后 不用你管

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

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

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

类比学习法

类主要用于 记录多个对象 相同的 数据 和功能

对象则用于 记录多个对象 不同的数据 和功能

在面向对象编程中 类仅仅是用于节省代码 对象 才是核心

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

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

创建类的完整语法

class People:
    学生对象的公共数据
    学生对象的公共数据
    ···

class是定义类的关键字

people是类的名字

类名的命名跟变量名一致 并且 推荐首字母大写（为了更好的区分）

类体代码:
公共的数据 和 公共的方法

类体代码 在类定义阶段 就会执行

print(People.__dict__)  #使用 该方法 查看名称空间 可以看成 是一个字典
print(People.__ditc__['school'])  # 使用 字典的取值 方式 获取名字
print(People.__dict__.get('choose_course'))  使用字典的取值 方式 获取名字

在面向对象 编程中 想要 获取 名称空间中的名字 可以采用 句点符

print(People.school)
print(People.choose_couerse)

类实例化产生对象>>>:类名加括号

s1=People()
s2=People()
print(s1.school)
print(s1,s2)
#获取的对象 不是同一个
>>>>>>>>>>>>>>>>>>>>>>
哈佛
<__main__.People object at 0x0000017480F9AC88> <__main__.People object at 0x0000017480F9AE48>

print(s1.__dict__)
print(s2.__dict__)
# 对象
>>>>>>>>>>>>>>>>>>>>>>>>>>>
{}
{}

• 我们习惯 将类或对象 后面的东西称之为属性或方法名

推导思路1:

直接利用 __dict__方法朝字典添加 键值对

s1.__dict__['age']=20   # s1.age=20
s1.__dict__['name']='kk'  # s1.name='kk'
print(s1.age)
print(s1.naem)
>>>>>>>>>>>>>
20  
kk

推导思路2：

将添加独有数据的代码封装成函数

def init(obj,name,age,gender):
    obj.name=name
    obj.age=age
    obj.gender=gender

#取出对象 传入 函数 对其添加 属性
s1=People()
init(s1,'kk',18,'female')

print(s1.__dict__)
>>>>>>>>>>>>>>>>>>>
{'name': 'kk', 'age': 18, 'gender': 'female'}

推导思路3：

init函数是专门赋给学生对象 创建独有数据的 其他对象 不能调用>>>面向对象思想 将数据和功能整合到一起

将函数封装到学生类中 这样只有学生类产生的对象 才有资格访问

class People:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
	
    #学生 对象 公共数据
    school='哈佛'
    # 学生对象 公共方法
    def choose_course(self):
        print('选课成功')

s1=People('kk',18,'femal')
print(s1.__dict__)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
{'name': 'kk', 'age': 18, 'gender': 'femal'}

1. 先产生一个空对象
2. 自动调用 类里面的__init__方法 将产生的空对象 当成第一个参数 传入
3. 将产生的对象返回出去