25

今日内容概要

面向对象前戏

'''使用代码模拟双方打架的过程 自定义攻击力和hp(类似于宝可梦)'''
#过程一 模拟出两个东西来互打  这里使用人狗来模拟
	person1 = {'name':'xxx',
              'age':20
               'attack_val':1000,
               'HP':10000}
    dog1 = {'name':'小黄',
            'attack_val':100,
            'HP':2000}
#过程二 假设出现许多人和狗 则必须要一个一个的输入
	'''在不同地方使用相同的代码可以使用函数的方式'''
    def creat_person(name,age,attack_val,HP):
        return {'name':name,
              'age':age,
               'attack_val':attack_val,
               'HP':HP}
    def creat_gog(name,attack_val,HP):
        return {'name':'小黄',
            'attack_val':100,
            'HP':2000}
    现在在需要使用的时候直接调用函数添加即可
    p1 = creat_person('aaa',18,100,1000)
    d1 = creat_person('小黑',50,200)
    '''现在有了两边的人 就可以准备打架了 👊 '''
    定义出两边发起攻击的函数
    def person_attack(person_dict,dog_dict):
        print(f"{person_dict.get('name')}准备攻击{dog_attack.get('name')}")
        dog_dict['HP'] -= person_dict.get('attack_val')
        print(f"{dog_attack.get('name')}扣除 {person_dict.get('attack_val')} 剩余血量{dog_attack.get('HP')}")
    我们调取这个函数就可以使人攻击狗  eg： person_attack(p1,d1)
    但我们如果使用 person_attack(d1,p1) 就混乱了

面向对象核心思路前戏

'''续上 为了避开混乱的情况 我们可以限定人攻击的函数只有人才可以调用'''
#推导过程三 
	将攻击函数放到创造人的函数中 就可以做到
    def creat_person(name,age,attack_val,HP):
        def person_attack(person_dict,dog_dict):
        print(f"{person_dict.get('name')}准备攻击{dog_attack.get('name')}")
        dog_dict['HP'] -= person_dict.get('attack_val')
        print(f"{dog_attack.get('name')}扣除 {person_dict.get('attack_val')} 剩余血量{dog_attack.get('HP')}")
        return {'name':name,
              'age':age,
               'attack_val':attack_val,
               'HP':HP}
    使用：
    	p1 = creat_person('xxx',18,10,1000)
        p1.get('person_attack')(p1,d1)

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

编程思想

#1.面向过程编程
	过程就是流程 面向过程就是按照固定的流程解决问题
    eg：之前所学的 几乎都是过程编程
    注册功能 登录功能 转账功能
    需要列举出每一步的流程 并且随着步骤的深入 问题解决的越简单
    
    
#2.面向对象编程
	对象就是容器 数据与功能的结合体 (在python中万物皆对象)
   	 例如MOBA游戏中的角色 我们负责创造 而在游戏中的表现是我们无法控制的

  
'''
上面的两种关系并不是对立的
没有优劣之分 结合实际需求使用
两种编程思想融会贯通 只不过在不同的地方占比不同
'''

面向对象之类与对象

对象:数据与功能的结合体
类：多个对象相同数据和相同功能的结合体
'''
有点绕 我们可以这么理解:
	每一个人都是不一样的 但我们都是人类 所以在我们去定义是不是人类的时候就会拿出人类的相同的特质
'''
#在我们实际生活中肯定是先有个体再有群体
#但是在程序中如果想要产生对象 必须要先定义类(反着记)

类与对象的创建

面向对象并不是一门新的技术 但是为了区分开 针对面向对象设计了专门的语法结构
python中一定要先定义类 才能创建对象

#类的语法结构
	class 类名:
        '''代码注解'''
        对象的公共数据
        对象的公共功能
    1.class是定义类的关键字
    2.类名与变量名的命名几乎一致 需要区分的是类名的首字母要是大写(方便区分)
    3.数据：变量名与数据值的绑定 功能(方法)其实就是函数
#类的使用和调用
	类在定义阶段就会执行类体代码 但是属于类的局部名称空间 外界无法直接使用
    '''需求：清华大学的选课系统'''
    class Student:
        #对象的公共数据
        school_name = '清华大学'
        
        #对象的公共功能
        def choice_course(self):
            print('学生的选课系统')
#查看名称空间
	print(Student.__dict__) '''将此名称空间的变量名以字典的形式展示'''
    print(Student.__dict__.get('school_name'))
    对于名称空间中的变量名我们可以使用句点式来调用变量名
    print(Student.school_name)
#类的调用>>>产生对象
'''类名加括号就会产生对象 并且每一次的执行都会产生一个全新的对象'''
obj1 = Student()
obj2 = Student()
print(obj1,obj2) 获得的是两个不一样的地址
print(obj1.__dict__) 此时里面为空
print(obj1.school_name) # 清华大学
#如果想要修改名称空间变量名所绑定的值
Student.school_name = '家里蹲大学'
print(obj1.school_name) # 家里蹲大学
'''数据和功能  可以统称为属性    数据>>>属性名   功能>>>方法'''

对象独有的数据

class Student:
    # 对象的公共数据
    school_name = '清华大学'
    
    # 对象公共的功能
    def choice_course(self):
        print('学生选课系统')
     
 obj1 = Student()
 obj2 = Student()
'''推导过程一 每个对象手动添加独有的数据'''
 obj1.__dict__['name'] = 'xiapchen'
 obj1.__dict__['age'] = 18
 obj1.__dict__['hobby'] = 'play'
 obj2.__dict__['name'] = 'sss'
 obj2.__dict__['age'] = 19
 obj2.__dict__['hobby'] = 'read'
'''推导过程二 假设有许多的人 我们可以把这个封装成函数'''
def init(obj,name,age,hobby)
	obj.__dict__['name'] = name
	obj.__dict__['age'] = age
	obj.__dict__['hobby'] = hobby
    
 stu1 = Student()
 stu2 = Student()
 init(stu1,'xiaochen',19,'play')
 init(stu2,'xxx',18,'read')
'''推导过程三 此功能只有学生有资格调用'''
class Student:
    # 对象的公共数据
    school_name = '清华大学'
    
    #学生特有的功能
    def init(obj,name,age,hobby)
	obj.__dict__['name'] = name
	obj.__dict__['age'] = age
	obj.__dict__['hobby'] = hobby
    
    # 对象公共的功能
    def choice_course(self):
        print('学生选课系统')
        
 stu1 = Student()
 Student.init(stu1, 'jason', 18, 'music')
 stu2 = Student()
 Student.init(stu2, 'kevin', 29, 'read')
 print(stu1.__dict__, stu2.__dict__)
'''推导过程四 对init进行变形处理'''
class Student:
     # 对象公共的数据
     school_name = '清华大学'

    # 专门给学生添加独有数据的功能  类产生对象的过程中自动触发
     def __init__(obj, name, age, hobby):
         obj.__dict__['name'] = name
         obj.__dict__['age'] = age
         obj.__dict__['hobby'] = hobby

     # 对象公共的功能
     def choice_course(self):
         print('学生选课功能')

 stu1 = Student('jason', 18, 'read')  # 在类中默认将空对象作为第一个参数传入
 print(stu1.__dict__)
 print(stu1.name)
 print(stu1.school_name)
'''推导过程五 变量名修改'''
class Student:
    # 对象公共的数据
    school_name = '清华大学'

    # 专门给学生添加独有数据的功能  类产生对象的过程中自动触发
    def __init__(self, name, age, hobby):
        self.name = name  # self.__dict__['name'] = name
        self.age = age
        self.hobby = hobby

    # 对象公共的功能
    def choice_course(self):
        print('学生选课功能')

stu1 = Student('jason', 18, 'read')
print(stu1.name)
print(stu1.school_name)

对象独有的功能

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

    # 专门给学生添加独有数据的功能  类产生对象的过程中自动触发
    def __init__(self, name, age, hobby):
        self.name = name  # self.__dict__['name'] = name
        self.age = age
        self.hobby = hobby

    # 对象公共的功能
    def choice_course(self):
        print(f'学生{self.name}正在选课')
        
stu1 = Student('xiaochen', 18, 'music')
stu2 = Student('kevin', 28, 'read')
# 1.直接在全局定义功能  该函数就不是学生对象独有的了
# def eat():
#     print('吃东西')
# stu1.eat = eat
# print(stu1.__dict__)
# stu1.eat()
# 2.只能将函数放在类中 但是类中的函数又是对象公共的
'''定义在类中的功能 默认就是绑定给对象使用的 谁来调谁就是主人公'''
# Student.choice_course(123)  # 类调用需要自己传参数
# stu1.choice_course()  #  choice_course(stu1)  对象调用会自动将对象当做第一个参数传入

# stu1.choice_course()
# stu2.choice_course()

# 对象修改数据值
stu1.name = 'tony'  # 当点的名字已经存在的情况下 则修改对应的值
# 对象新增数据值
stu1.pwd = 123  # 当点的名字不存在的情况下 则新增数据
print(stu1.__dict__)