面向对象编程，类与对象、代码编写和产生对象

今日总结

一、面向对象编程思想前戏

二、编程思想

三、类与对象的概念

四、类与对象的创建

五、对象实例化

六、绑定方法

一、面向对象编程思想前戏

人狗大战
先定义人和狗的各个资料
dog1 = {
    'name': '大黄',
    'type': '中华田园犬',
    'attack_avl':100,
    'life_val': 1000
}

dog2 = {
    'name': '发财',
    'type': '恶霸犬',
    'attack_avl': 150,
    'lif_val': 1200
}

person1 = {
    'name': '小龙',
    'type': '猛男',
    'attack_val': 45,
    'life_val': 3000
}
# 我们这样一个一个输入效率太低，所以创建一个人的函数和狗的函数

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('小龙','male', '18', '小白脸', 500, 1000)
p2 = get_person('mary', 'female', 20, '猛女', 800, 1200)

dog1 = get_dog('发财', '恶霸犬', 150, 1200)
dog2 = get_dog('大黄', '中华田园犬', 100, 1000)


def dog_attack(dog_obj, person_obj):  # dog接收狗的信息， person接收人的信息
    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']))

# 狗咬人
dog_attack(dog2,p1)
print(p1)
# 人锤狗
person_attack(p2, dog1)
print(dog1)

# 这样谁都可以调用，所以我们想要创建人可以调用人的函数，狗调用狗的函数
# 也就是人的数据和人的函数绑定，狗的数据跟狗的功能绑定
def get_person(name, gender, age, t_type,attack_val, 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']))
    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):  # dog接收狗的信息， person接收人的信息
        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('小龙','male', '18', '小白脸', 500, 1000)
p2 = get_person('mary', 'female', 20, '猛女', 800, 1200)

dog1 = get_dog('发财', '恶霸犬', 150, 1200)
dog2 = get_dog('大黄', '中华田园犬', 100, 1000)
p1['person_attack'](p1, dog1)
dog1['dog_attack'](dog1,p2)

二、编程思想

# 面向过程编程
   将程序的执行流程化，也就是分步操作 ，在这个过程中来解决单个问题
    eg: 注册，登录，结算购物车...
"""
注册：第一步获取用户名，然后进行比对用户名数据  """
"""  
结算：第一步获取购物车的数据，第二步计算购物车需要金额
"""

# 面相对象编程
  核心——'对象'
    对象就是一个'容器' ，用来将数据与功能整合到一块
 # 我们之前写的人狗大战，最后的函数含有数据和功能，可以称之为面向对象编程
"""模块文件内部含有数据与功能,也可以称之为面向对象编程"""
python针对面向对象编程提供了专门的语法，识别度更高，编写更精简
   eg：人、动物、游戏里面的校色等
    
"""
 面向过程与面向对象两者没有优劣之分，具体要结合实际情况，甚至很多时候两者都是混合一起的，思想占据的比例不用而已。
"""

三、类与对象的概念

对象：数据与功能的结合体
类： 类别、种类——相当于诸多对象共有的特征(例如：数据、功能等)
eg:
    一个人是对象， 一群人是人类
    一只狗是对象， 一群狗是犬类
    # 相当于个体是对象，群体是类
""" 之所以称之为类，就是因为他们有共同的功能，但也有不同的特征,
类只能描述公共的特征，不同的特征应该有对象自己描述!!!
"""

四、类与对象的创建

"""
代码编程中是先有类，才能有对象，也就是先定义类，后产生对象
"""
#  学生类
class Student:
    school = '安徽大学'
    def choose_course(self):
        print('学生选课功能')
  # 类体代码无需调用就会执行，产生类的名称空间

# 语法结构
class 类名:
    类体代码
1、class是定义类的关键字
2、类名类似于函数名，但是首字母推荐大写，用来区分
3、类体代码就是存放对象公共数据和功能的地方
数据:变量名 = 变量值
功能: 函数

# 查看名称空间的方法：__dict__(双下dict)
print(Student.__dict__)  # 返回值是一个字典
print(Student.__dict__['school'])  # 获取类中的属性
print(Student.__dict__['choose_course'])

获取数据和功能有一个简便的方式: 句点符
    print(Student.school)
    print(Student.choose_course)

"""   如何产生对象：类名加括号  """
obj1 = Student()
obj2 = Student()
#  {} {}

print(obj1.school)  # 安徽大学
print(obj2.school)  # 安徽大学
print(obj1.choose_course)  # <bound method Student.choose_course of <__main__.Student object at 0x00000225EA139208>>  形成绑定的关系

print(obj2.choose_course)  # <bound method Student.choose_course of <__main__.Student object at 0x00000225EA139208>>  形成绑定的关系


# 修改名字与值得对应
Student.school = '安徽师范大学'  
print(obj1.school)

五、对象的实例化

# 学生类
class Student:
    def __init__(self, name, age, gender):
        self.name = name  # 相当于obj.__dict__['name'] = name
        self.age = age
        self.gender = gender
       school = '安徽大学'
obj1 = Student()  # 当前前对象没有自己独有的属性
obj2 = Student() 
print(obj1.__dict__)  # 大白话就是给字典添加键值对
print(obj2.__dict__) 
# 得到的是空字典，所以我们就是需要给字典增加键值对

'''方式一：逐步给对象增加独有的数据'''
obj1 = Student()  # 目前对象没有自己独有的属性

obj1.__dict__['name'] = 'owen'
obj1.__dict__['age'] = 20
obj1.__dict__['gender'] = 'male'


print(obj1.__dict__)
print(obj1.name)

'''方式二：将冗余的添加步骤封装成函数'''
class Student:
    school = '安徽大学'
    def choose_course(self):
        print('学生学习管理系统')

def init(obj, name, age, gender):
    obj.name = name  # 相当于obj.__dict__['name'] = name
    obj.age = age
    obj.gender = gender
obj1 = Student
init(obj1,'owen', 20, 'male' )
print(obj1.name)

'''方式三:简单的封装成函数没有体现出面向对象整合的精髓，所以我们将函数写到类里面'''
class Student:
    def init(obj, name, age, gender):
        obj.name = name  # 相当于obj.__dict__['name'] = name
        obj.age = age
        obj.gender = gender
    school = '安徽大学'
    def choose_course(self):
        print('学生学习管理系统')


obj1 = Student()
Student.init(obj1,'owen', 20, 'male')

print(obj1.age)

''' 方法四：类中针对给对象创建独有数据的函数名，专门定义了一个固定的方法 '''
class Student:
    def __init__(obj, name, age, gender):
        obj.name = name  # 相当于obj.__dict__['name'] = name
        obj.age = age
        obj.gender = gender
    school = '安徽大学'
    def choose_course(self):
        print('学生学习管理系统')

obj1 = Student('owen', 20, 'male')
print(obj1.gender)

"""
 类中的__init__方法会在产生对象的时候自动执行类产生对象的具体步骤
  1、先创建一个没有独有数据的空对象
  2、将空对象和类括号内传入的数据一并交给__init__执行
  __init__的第一个参数就是对象本身
  __init__(obj, name, age, gender)
  3、将创建好的对象自动返回
  第一个形参self其实就是一个变量名，用来接收对象，所以给它起了一个固定的名字self
"""

六、绑定方法

# 在类中定义的函数默认都是绑定给对象使用的，所以会将对象当成第一个对象当成第一个参数传入
class Student:
    school = '安徽大学'
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def func(self):
        print('%s正在调用func方法'%self.name)

    def index(self):
        print('%s正在调用index方法'%self.name)
        
obj1 = Student('owen', 20)
obj2 = Student('mary', 18)
obj1.func()
obj2.func()
print(obj1.func)  # bound method 绑定
print(obj2.index)  # bound method 绑定