面向对象(1)

初始面向对象

 

• 面向对象编程思想前戏

• 面向过程编程与面向对象编程

• 类与对象的概念

• 代码编写类

• 代码产生对象

• 类与对象的具体操作

 

面向对象编程思想前戏

# 人狗大战小游戏
# 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.面向过程编程
    将程序的执行流行化 即分布操作 分步的过程中解决问题
    
    过程可以理解成流水线 面向过程编程可以理解成是创建一条流水线
    
2.面向对象编程
    核心就是'对象'二字
        对象其实就是一个"容器"将数据与功能整合到一起
        模块文件内容含有数据和功能 也可以称之为面向对象编程
     python针对面向对象编程提供了专门的语法 识别度更高 编写更精简
    """
    面向过程与面向对象两者没有优劣之分 具体要结合实际情况
    甚至很多时候两者是混合在一起的  思想占据的比例不同而已
    
    """

类与对象的概念

对象：数据与功能的结合体
类：即类别、种类 相当于诸多对象公有的特征(数据、功能)
"""
python中一切皆为对象，所谓对象：我自己就是一个对象 我玩的电脑就是对象 养的狗也是对象
我们通过描述属性(特征)和行为来描述一个对象 比如养的小狗，它的颜色 大小 年龄 体重等是它的属性或特征 它会狗叫 摇尾巴等是它的行为
​
我们在描述一个真实对象时包括两个方面：
    它可以做什么(行为)
    他是怎么样的(属性或特征)
在python中，一个对象的特征也称为属性，它所具有的的行为也称为方法
结论：对象 = 属性 + 方法
​
在python中 吧具有相同属性和方法的对象归为一个类
"""

类与对象的创建

"""
在代码编程中是先有类才能有对象
"""
先定义类 后产生对象
# 学生类
class Stduent:
    # 学生类公共的数据
    school = '五道口职业技术学院'
    # 学生类公共的功能
    del choose_course(self):
        print('学生逃课系统')
"""
类型代码无需调用就会执行 产生类的名称空间
"""
语法结构
class 类名：
    类型代码
1.class是定义类的关键字
2.类名类似于函数名 但是首字母推荐大写 用于区分
3.类体代码就是存放对象公共数据和功能的地方
    数据：变量名 = 变量值
    功能：函数
# 查看名称空间的方法：__dict__
# print(Student.__dict__)  # 返回值是一个字典
# print(Student.__dict__['school'])  # 获取类的属性
# print(Student.__dict__['choose_course']) # 获取类的属性
"""类获取数据和功能有一个简便的方法：句点符"""
​
"""如何产生对象：类型加括号"""
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)  # bound method
print(obj1.school)  # 五道口职业技术学院
print(obj2.school)  # 五道口职业技术学院
Student.school = '野鸡大学'  # Student.__dict__['school'] = '野鸡大学'  修改名字与值的对应关系
print(obj1.school)  # 野鸡大学
print(obj2.school)  # 野鸡大学

对象的实例化

# 学生类
class Student:
    def __init__(self,name,age,gender):
        """该方法就一个功能：给对象添加独有的数据"""
        self.name = name  # obj.__dict__['name'] = name
        self.age = age  # obj.__dict__['age'] = age
        self.gender = gender  # obj.__dict__['gender'] = gender
        
        # 学生类公共的数据
        school = '五道口职业技术学院'
        
        # 学生类公共的功能
        def choose_course(self)
            print('学生逃课系统')
​
# obj1 = Student()  # 目前对象没有自己独有的属性
# obj2 = Student()  # 目前对象没有自己独有的属性
# print(obj1.__dict__)  # 大白话就是给字典添加键值对
# print(obj2.__dict__)  # 大白话就是给字典添加键值对
'''方案1:逐步给对象添加独有的数据'''
# obj1.__dict__['name'] = 'jason'  # obj1.name = 'jason'
# obj1.__dict__['age'] = 18  # obj1.age = 18
# obj1.__dict__['gender'] = 'male'  # obj1.gender = 'male'
​
# obj2.__dict__['name'] = 'kevin'  # obj2.name = 'kevin'
# obj2.__dict__['age'] = 2  # obj2.age = 28
# obj2.__dict__['gender'] = 'female'  # obj2.gender = 'female'
# print(obj1.__dict__,obj2.__dict__)
# print(obj1.name)  # jason
# print(obj2.name)  # kevin
'''方案2:将冗余的添加步骤封装成函数'''
# def init(obj,name,age,gender):
#     obj.name = name  # obj.__dict__['name'] = name
#     obj.age = age  # obj.__dict__['age'] = age
#     obj.gender = gender  # obj.__dict__['gender'] = gender
# init(obj1,'jason',18,'male')
# init(obj2,'kevin',28,'female')
# print(obj1.name)
# print(obj2.name)
'''方案3:简单的封装成函数没有提现出面向对象整合的精髓>>>:将函数写到类中去'''
# obj1 = Student()
# obj2 = Student()
# Student.set_info(obj1,'jason',18,'male')
# Student.set_info(obj2,'kevin',28,'female')
# print(obj1.name)  # jason
# print(obj2.name)  # kevin
'''方案4:类中针对给对象创建独有数据的函数名 专门定义了一个固定的方法'''
# obj1 = Student('jason', 18, 'male')
# obj2 = Student('kevin', 28, 'female')
# print(obj1.__dict__)
# print(obj2.__dict__)
"""
类中的__init__方法会在类产生对象的时候自动执行
类产生对象的具体步骤
    1.先创建一个没有独有数据的空对象 {}
    2.将空对象和类括号内传入的数据一并交给__init__执行
        __init__的第一个参数就是对象本身
            __init__(obj,name,age,gender)
    3.将创建好的对象自动返回
​
ps：针对括号内第一个形参self其实就是一个普通的变量名而已
只不过该变量名将来专门接收对象的 所有给它起了个固定的名self
​

绑定方法

"""在类中定义的函数默认都是绑定给对象使用的
        即对象来调用 会自动将对象当做第一个参数传入
"""
class Student:
    school = '五道口职业技术学院'
    # __init__方法不要自己去调用
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def choose(self):
        print(self)
        
    def func(self):
        print('%s正在调用func方法'%self.name)
​
    def index(self):
        print('%s正在调用index方法'%self.name)
​
obj1 = Student('jason', 18)
# print(obj1)
obj2 = Student('kevin', 28)
# 类调用类中函数 有几个参数就需要传几个参数
# Student.choose(22)  # 22
# 对象调用类中函数  会将当前调用的对象当做第一个参数自动传入
# obj1.func()  # jason正在调用func方法
# obj2.func()  # kevin正在调用func方法
# print(obj1.func)
# print(obj2.index)
'''所以应该能理解为什么类中所有的函数第一个参数都是self'''