对象与类

面对面对象

前戏

'第一步:直接手写英雄和反派的字典'
hero1 = {'name': '闪电侠',
         'ability': '神速力',
         'attack': 500,
         'hit_points': 800}
hero2 = {'name': '蝙蝠侠',
         'ability': '钱',
         'attack': 100,
         'hit_points': 300}

villain1 = {'name': '逆闪电',
            'ability': '逆神速力',
            'attack': 300,
            'hit_points': 500}
villain2 = {'name': '小丑',
            'ability': '笑气',
            'attack': 100,
            'hit_points': 100}


'第二步:定义英雄和反派的字典基本不变且要反复使用，所以用函数包起来'
def func_hero(name, ability, attack, hit_points):
    '''
    产生英雄的字典
    :param name: 名字
    :param ability: 能力
    :param attack: 攻击力
    :param hit_points: 生命值
    :return: 英雄的字典
    '''
    hero_obl = {
        'name': name,
        'ability': ability,
        'attack': attack,
        'hit_points': hit_points}
    return hero_obl


def func_villain(name, ability, attack, hit_points):
    '''
    产生反派的字典
    :param name: 名字
    :param ability: 能力
    :param attack: 攻击力
    :param hit_points: 生命值
    :return: 反派的字典
    '''
    villain_obl = {
        'name': name,
        'ability': ability,
        'attack': attack,
        'hit_points': hit_points}
    return villain_obl


h1 = func_hero('闪电侠', '神速力', 500, 800)
v1 = func_villain('逆闪电侠', '逆神速力', 300, 500)
print(h1)
# {'name': '闪电侠', 'ability': '神速力', 'attack': 500, 'hit_points': 800}
print(v1)
# {'name': '逆闪电侠', 'ability': '逆神速力', 'attack': 300, 'hit_points': 500}


'第三步:让英雄和反派互相攻击'
def hero_attack(hero_obj,  villain_obj):
    '''
    用于英雄攻击反派
    :param hero_obj: 传英雄数据
    :param villain_obj: 传反派数据
    '''
    print('将被攻击的反派:%s 目前生命值还有%s' % (villain_obj.get('name'), (villain_obj.get('hit_points'))))
    villain_obj['hit_points'] -= hero_obj['attack']
    print('英雄:%s 攻击 反派:%s 掉血:%s 剩余血量:%s' %
          (hero_obj.get('name'), villain_obj.get('name'), hero_obj.get('attack'), villain_obj.get('hit_points')))


def villain_attack(hero_obj, villain_obj):
    '''
    用于反派攻击
    :param hero_obj: 传英雄数据
    :param villain_obj: 传反派数据
    '''
    print('将被攻击的英雄:%s 目前生命值还有%s' % (hero_obj.get('name'), hero_obj.get('hit_points')))
    hero_obj['hit_points'] -= villain_obj['attack']
    print('反派:%s 攻击 英雄:%s 掉血:%s 剩余血量:%s' %
          (villain_obj.get('name'), hero_obj.get('name'),  villain_obj.get('attack'), hero_obj.get('hit_points')))


h1 = func_hero('闪电侠', '神速力', 500, 800)
h2 = func_hero('蝙蝠侠', '钱', 100, 300)
v1 = func_villain('逆闪电侠', '逆神速力', 300, 500)
v2 = func_villain('小丑', '笑气', 100, 100)
hero_attack(h1, v1)
# 将被攻击的反派:逆闪电侠 目前生命值还有500
# 英雄:闪电侠 攻击 反派:逆闪电侠 掉血:500 剩余血量:0
villain_attack(h2, v2)
# 将被攻击的英雄:蝙蝠侠 目前生命值还有300
# 反派:小丑 攻击 英雄:蝙蝠侠 掉血:100 剩余血量:200

优化

'问题:英雄可以使用反派攻击英雄的函数，反派也可以使用英雄攻击反派的函数'
hero_attack(v1, h1)
# 将被攻击的反派:闪电侠 目前生命值还有800
# 英雄:逆闪电侠 攻击 反派:闪电侠 掉血:300 剩余血量:500


'第四步:英雄和英雄攻击反派的函数绑定，反派和反派攻击英雄的函数绑定，让函数只有特定'
def func_hero(name, ability, attack, hit_points):
    '''
    产生英雄的字典
    :param name: 名字
    :param ability: 能力
    :param attack: 攻击力
    :param hit_points: 生命值
    :return: 英雄的字典
    '''
    def hero_attack(hero_obj, villain_obj):
        '''
        用于英雄攻击反派
        :param hero_obj: 传英雄数据
        :param villain_obj: 传反派数据
        '''
        print('将被攻击的反派:%s 目前生命值还有%s' % (villain_obj.get('name'), (villain_obj.get('hit_points'))))
        villain_obj['hit_points'] -= hero_obj['attack']
        print('英雄:%s 攻击 反派:%s 掉血:%s 剩余血量:%s' %
              (hero_obj.get('name'), villain_obj.get('name'), hero_obj.get('attack'), villain_obj.get('hit_points')))
    hero_obl = {
        'name': name,
        'ability': ability,
        'attack': attack,
        'hit_points': hit_points,
        'hero_attack': hero_attack}
    return hero_obl


def func_villain(name, ability, attack, hit_points):
    '''
    产生反派的字典
    :param name: 名字
    :param ability: 能力
    :param attack: 攻击力
    :param hit_points: 生命值
    :return: 反派的字典
    '''
    def villain_attack(hero_obj, villain_obj):
        '''
        用于反派攻击
        :param hero_obj: 传英雄数据
        :param villain_obj: 传反派数据
        '''
        print('将被攻击的英雄:%s 目前生命值还有%s' % (hero_obj.get('name'), hero_obj.get('hit_points')))
        hero_obj['hit_points'] -= villain_obj['attack']
        print('反派:%s 攻击 英雄:%s 掉血:%s 剩余血量:%s' %
              (villain_obj.get('name'), hero_obj.get('name'), villain_obj.get('attack'), hero_obj.get('hit_points')))
    villain_obl = {
        'name': name,
        'ability': ability,
        'attack': attack,
        'hit_points': hit_points,
        'villain_attack': villain_attack}
    return villain_obl


h1 = func_hero('闪电侠', '神速力', 500, 800)
h2 = func_hero('蝙蝠侠', '钱', 100, 300)
v1 = func_villain('逆闪电侠', '逆神速力', 300, 500)
v2 = func_villain('小丑', '笑气', 100, 100)
h1.get('hero_attack')(h1, v1)
# 将被攻击的反派:逆闪电侠 目前生命值还有500
# 英雄:闪电侠 攻击 反派:逆闪电侠 掉血:500 剩余血量:0
v2.get('villain_attack')(h2, v2)
# 将被攻击的英雄:蝙蝠侠 目前生命值还有300
# 反派:小丑 攻击 英雄:蝙蝠侠 掉血:100 剩余血量:200

结论

'''
把英雄的数据与英雄的功能绑定起来，只有英雄可以调用英雄的功能
把反派的数据与反派的功能绑定起来，只有反派可以调用反派的功能
将数据和功能绑定到一起被称为:面像对象编程
本质上是将数据和对应的功能绑定到一起，使其只能互相使用
'''

编程思想

1.面向过程编程
面向过程编程是一种以过程为中心的编程思想，过程就是流程的意思，面向过程编程其实就是在执行流程，也就是按照步骤依次执行，最终达到结果
eg：注册功能		登录功能

2.面向对象编程
面向对象编程其实就是一个容器，将数据和功能绑定到了一起
eg：游戏人物(只负责创造出人物以及人物具备的功能)
'''
面向过程编程相当于让你给出问题的具体解决方法
面向对象编程相当于创造事物之后的事使用管
这两种编程思想没有优劣之分，只是使用场景的不同，很多时候是两者共用
'''

对象与类的概念

对象：数据与功能的结合体
类：多个对象相同的数据与功能的结合体
'''
类比：
	对象：人	人类：多个人
	对象：狗	犬类：多条犬
'''
对象用于记录多个对象不同的数据与功能
类用于记录多个对象相同的数据与功能

对象与类的创建

1.在编程中必须要先有类才能产生对象

2.创建类的语法：
class Student:
    # 学生对象公共的数据
    # 学生对象公共的方法
class是定义类的关键字
Student是类名，和变量名一样，首字母最好大写，便于区分
类体代码：英雄对象公共的数据/英雄对象公共的方法
类体代码在定义阶段就会执行

3.查看名称空间的方法
class Student:
    # 学生对象公共的数据
    school = '霍格沃兹魔法学院'
    # 学生对象公共的方法
    def watch_games(self):
        print('正在看魁地奇比赛')

# 可以使用字典的取值方式获取数据值
print(Student.__dict__)
print(Student.__dict__['school'])  # 霍格沃兹魔法学院

# 也可以使用句点符
print(Student.school)  # 霍格沃兹魔法学院

# 类名加括号
res1 = Student()
res2 = Student()
print(res1.school)  # 霍格沃兹魔法学院
print(res2.school)  # 霍格沃兹魔法学院
print(res1)  # <__main__.Student object at 0x000001706EA83B50>
print(res2)  # <__main__.Student object at 0x000001706EA83AF0>
print(res1.__dict__, res2.__dict__)  # {} {}

# 修改school键对应的值
Student.school = '德姆斯特朗魔法学院'
print(res1.school)  # 德姆斯特朗魔法学院
print(res2.school)  # 德姆斯特朗魔法学院

对象独有的数据

class Student:
    # 学生对象公共的数据
    school = '霍格沃兹魔法学院'

    # 学生对象公共的方法
    def watch_games(self):
        print('正在看魁地奇比赛')


'步骤1：用__dict__方法朝字典添加键值对'
res1 = Student()
res1.__dict__['name'] = 'harry'  # res1.name = 'harry'
res1.__dict__['strong_point'] = '黑魔法防御术'
res1.__dict__['position'] = '魔法部法律执行司司长'
print(res1.name)  # harry
print(res1.strong_point)  # 黑魔法防御术
print(res1.position)  # 魔法部法律执行司司长
res2 = Student()
res2.__dict__['name'] = 'hermione'
res2.__dict__['strong_point'] = '学习'
res2.__dict__['position'] = '魔法部部长'
print(res2.name)  # hermione
print(res2.strong_point)  # 学习
print(res2.position)  # 魔法部部长


'步骤2：将添加独有数据的代码封装成函数'
class Student:
    # 学生对象公共的数据
    school = '霍格沃兹魔法学院'

    # 学生对象公共的方法
    def watch_games(self):
        print('正在看魁地奇比赛')


def init(res, name, strong_point, position):
    res.__dict__['name'] = name
    res.__dict__['strong_point'] = strong_point
    res.__dict__['position'] = position


res1 = Student()
res2 = Student()
init(res1, 'harry', '黑魔法防御术', '魔法部法律执行司司长')
init(res2, 'hermione', '学习', '魔法部部长')
print(res1.__dict__)
# {'name': 'harry', 'strong_point': '黑魔法防御术', 'position': '魔法部法律执行司司长'}
print(res2.__dict__)
# {'name': 'hermione', 'strong_point': '学习', 'position': '魔法部部长'}


'步骤3：init函数是用来创造独有的数据，其他对象不能调用>>>面向对象思想：将数据和功能绑定到一起'


class Student:
    '''
    先产生一个空对象
    自动调用类里面的__init__方法，将产生的空对象当成第一个参数传入

    '''

    def init(res, name, strong_point, position):
        res.name = name  # res.__dict__['name'] = name
        res.strong_point = strong_point  # res.__dict__['strong_point'] = strong_point
        res.position = position  # res.__dict__['position'] = position
    # 学生对象公共的数据
    school = '霍格沃兹魔法学院'

    # 学生对象公共的方法
    def watch_games(self):
        print('正在看魁地奇比赛')


res1 = Student()
Student.init(res1, 'harry', '黑魔法防御术', '魔法部法律执行司司长')
print(res1.__dict__)
# {'name': 'harry', 'strong_point': '黑魔法防御术', 'position': '魔法部法律执行司司长'}
print(res1.name)
# harry