python面向对象推导流程

举例：猫狗大战

# 1.例如我们要编写一个猫狗对战小游戏
#  首先我们要定义一个猫，和一只狗

cat1 = {
    'name': '小白猫',
    'type': '宠物猫',
    'attack_val': 20,
    'life_val': 120}

dog1 = {
    'name': '小黑狗',
    'type': '流浪狗',
    'attack_val': 60,
    'life_val': 240}


# 由于考虑多我们只会可能要多次使用并且创作多个 猫 狗 所以函数封装

def get_cat(name, type, attack_val, life_val):
    cat = {
        'name': name,
        'type': type,
        'attack_val': attack_val,
        'life_val': life_val}
    return cat


def get_dog(name, type, attack_val, life_val):
    dog = {
        'name': name,
        'type': type,
        'attack_val': attack_val,
        'life_val': life_val}
    return dog


# 创造一个猫攻击的函数，和狗攻击的函数
def dog_attack(dog_obj, 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):
    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']))


# 创造出来 猫和狗
c1 = get_cat('小白','宠物',100,500)
d1 =get_dog('小黑','流浪狗',300,2000)

# 开始攻击
dog_attack(c1,d1)
dog_attack(c1,d1)
dog_attack(c1,d1)

数据与功能的绑定，使攻击动作绑定对于对象，

1.函数嵌套

# 把猫攻击动作 放到 猫的函数里

def get_cat(name, type, attack_val, life_val):
    def cat_attack(cat, dog):
        # 使用最简答的掉血逻辑  血量减去对方攻击力
        print('当前猫的血量是:%s' % dog.get('life_val'))
        dog['life_val'] -= cat.get('attack_val')
        print("""猫:%s 挠了狗:%s 一口 狗掉血:%s 剩余血量:%s""" % (
        cat.get('name'), dog.get('name'), cat.get('attack_val'), dog['life_val']))

    cat = {
        'name': name,
        'type': type,
        'attack_val': attack_val,
        'life_val': life_val,
        'cat_attack':cat_attack   #通过生成猫后形成的字典 来调用猫攻击动作
        }
    return cat


def get_dog(name, type, attack_val, life_val):
    def dog_attack(person_obj, 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 = {
        'name': name,
        'type': type,
        'attack_val': attack_val,
        'life_val': life_val,
        'dog_attack':dog_attack
    }
    return dog


# 创造出来 猫和狗
c1 = get_cat('小白','宠物',100,500)  # 先 生成 一个猫
d1 = get_dog('小黑','流浪狗',300,2000)

c1['cat_attack'](c1,d1) #这样就相当于 先生成一个猫，然后发动猫的攻击
d1['dog_attack'](d1,c1)
d1['dog_attack'](d1,c1) # 这样就相当于 狗 和 狗攻击绑定了 不生成狗 就无法使用狗攻击

#！！！面向对象核心思想！！！ 数据与功能的绑定！！

编程思想

1. 面向过程编程 
过程即流程 面向过程就是按照固定的流程解决问题
eg: 例如我们常用的 注册功能 登录功能 等
    都是一步一步的流程慢慢写出来的，随着步骤的深入 问题就慢慢的解决了
    是通过过程从来解决问题的，过程是可控制的
    
2. 面向对象编程
   对象即是容器， 就是数据与功能的结合体(python中一切都可以是对象)
   eg： 游戏人物
   王者荣耀中的英雄，后裔 小乔等 都可以称之为对象
   面向对象就是创造一个对象  至于对象接下来的发展和程序员无关，也无法控制
    
"""
上述两种编程思想没有优劣之分 需要结合实际需求而定
	如果需求是注册 登录 人脸识别肯定面向过程更合适
	如果需求是游戏人物肯定是面向对象更合适
实际编程两种思想是彼此交融的 只不过占比不同
"""

面向对象中的类与对象

对象：数据和功能的结合体，对象才是核心
类；多个对象具有相同的数据和功能的集合体  类主要的作用就是节约代码

"""
一个人					对象
一群人					人类(所有人相同的特征)

一条狗					对象
一群狗					犬类(所有狗相同的特征)
"""
现实中一般是先有对象再有类
程序中如果想要产生对象  ！！必须要先定义出类！！

与对象的创建

面向对象并不是一门新的技术 但是为了很好的一眼区分开 针对面向对象设计了新的语法格式
python中一定要有类 才能借助于类产生对象

1.如果创建一个类  关键词 class!
  语法结构：
  class 类名:
       '''类的注释'''
      对象公共的数据
      对象公共的功能
      
2. 类名的命名和变量名方法一致，尽量做到见面知意，类的命名首字母需要大写
3. 数据： 变量名与数据值的绑定
4. 功能： 其实就是函数方法

2.类的定义与调用
  类在定义阶段就会执行类里面的子代码，类里面的变量名属于局部空间，外界无法直接使用，类不需要调用，定义好以后 类里面的子代码自动生效。
  
  
 举例： #需求清华大学的学生选课系统
class Student:
    # 先填写所有对象的公共数据
    school_name = '清华大学'

    # 填写对象的公共功能
    def choice_course(self):
        print('欢迎进入学生选课系统')


# print(Student.school_name)
# 类定义好之后 就可以直接调用 类名.的方式进行使用类里面的变量名

# 如何基于类 生成一个对象
student = Student()
student1 = Student()

'''类名加括号就会产生对象 并且每执行一次都会产生一个全新的对象'''
print(student)

#查看对象里面有什么
print(student.__dict__)
#发现通过类创造的对象 暂时没有内容，其实这个对象已经包含了类里面的公用数据和方法


'''在面向对象中 类和对象访问数据或者功能 可以统一采用句点符'''
print(student.school_name)  # 清华大学  公共的数据和方法会默认添加如对象中
Student.school_name = '北京大学'  # 更改类里面的公共数据
print(student.school_name)  # 北京大学 通过类创造的对象，获取的是类里面的公共数据和方法 当类里面的数据或方法发生改变后，对应这里也会变化
print(student1.school_name)  # 北京大学 通过类创造的对象，获取的是类里面的公共数据和方法 当类里面的数据或方法发生改变后，对应这里也会变化

！！当类里面的公共数据或方法有变动后，则会影响到接下来所有的类对象！！
！！！得到理论，当通过类创造出来的对象，该对象会拥有类里面的公共数据和方法 可以调用！！
  

对象添加独有数据

class Student:
    # 对象的公共数据
    school_name = '清华大学'

    # 对象的公共功能
    def choice_course(self):
        print('欢迎进入学生选课系统')


student = Student()
# 通过类 创建出一个对象
student1 = Student()
# 通过类 创建出一个对象 每个对象都是不同的内存地址

'''推导流程1:每个对象手动添加独有的数据'''

student1.__dict__['name'] = '张无忌'
# 给对象添加独有的数据
student1.__dict__['age'] = 19
print(student1.name)
print(student1.age)

student.__dict__['name'] = '赵敏'
student.__dict__['age'] = 18
# 给对象添加独有的数据
print(student.name)
print(student.age)

'''推导流程2:将添加对象独有数据的代码封装成函数'''

def init(object,name,age):
    object.__dict__['name'] = name
    object.__dict__['age'] = age

init(student,'张三丰',68)
print(student.name)
print(student.age)
# 通过给函数传参的方式 实现了添加对象独有数据

'''推导流程3:给学生对象添加独有数据的函数只有学生对象有资格调用'''

class Student:
    # 对象的公共数据
    school_name = '清华大学'

    def init(object, name, age):
        object.__dict__['name'] = name
        object.__dict__['age'] = age

    # 对象的公共功能
    def choice_course(self):
        print('欢迎进入学生选课系统')
student2 = Student()
Student.init(student2,'金毛狮王',56)
# 这样就可以直接进行对象独有数据添加，并且是专属于这个类来调用的
print(student2.__dict__)



'''推导步骤4:init方法变形'''


class Student:
    # 对象的公共数据
    school_name = '清华大学'

    # __init__可以使类产生对象的过程中自动触发
    def __init__(object, name='暂未填写', age ='暂未填写'):
        object.__dict__['name'] = name
        object.__dict__['age'] = age

    # 对象的公共功能
    def choice_course(self):
        print('欢迎进入学生选课系统')


student = Student('张无忌')
student2 = Student('金毛狮王',56)
print(student2.__dict__)

# 未使用__init__   student2= Student()
# Student.init(student2,'金毛狮王',56)
# 使用后  student2 = Student('金毛狮王'，'56')
#  类产生对象的过程中自动触发
print(student.__dict__)

'''推导步骤5:变量名修改'''
class Student:
    # 对象的公共数据
    school_name = '清华大学'

    # __init__可以使类产生对象的过程中自动触发
    def __init__(self, name='暂未填写', age='暂未填写'):
        self.__dict__['name'] = name
        self.__dict__['age'] = age

    # 对象的公共功能
    def choice_course(self):
        print('欢迎进入学生选课系统')

student2 = Student('周芷若',17)
# 可以通过直接赋值的方法改变对象里面的数据
print(student2.__dict__)
print(student2.school_name)
del student2.name
# 删除对象中的数据
print(student2.__dict__)

对象添加独有方法/功能

class Student:
    school_name = '清华大学'

    # __init__可以使类产生对象的过程中自动触发
    def __init__(self, name='暂未填写', age='暂未填写'):
        self.name = name
        self.age = age

    # 对象的公共功能  self参数 等于默认传入对象本身
    def choice_course(self):
        print(f'欢迎 {self.name} 选课系统')
        # 可以利用本身类对象的变量名 不同的类对象 变量名对应的数据也不同

student = Student('张无忌', 22)
student1 = Student('赵敏', 22)

student.choice_course()  # = choice_course(student)
student1.choice_course()  # = choice_course(student)
# 类的对象 可以直接调用 类里面的方法，不需要传参，默认传参就是对象本身

student1.name = '赵敏'
# 更改对象中的数据，直接通过.的方式 再次赋值即可

student1.nation = '蒙古族'
# 新增对象数据，有则更改 无则新增