面向对象编程

目录

• 面向对象编程
  • 面向对象编程思想前戏
  • 编程思想
  • 类与对象的概念
  • 类与对象的创建
    • 类的创建
    • 查看名称空间的方法
    • 对象的创建
  • 对象的实例化
  • 绑定方法

面向对象编程

面向对象编程思想前戏

# 人狗大战小游戏
1.描述人和狗
# 描述人和狗的方式1：使用字典一个个描述
dog1 = {'name':'小黑'
       'type': '田园犬',
       'attack_val': 30,
       'life_val': 200}

dog2 = {'name':'小白'
       'type': '细犬',
       'attack_val': 80,
       'life_val': 300}
person1 = {
     'name': '小龙',
     'type': '猛男',
     'attack_val': 10,
     'life_val': 1000
}

# 方法2.封装成函数减少代码冗余
'''定义专门用来描述人和狗的函数'''
def get_person(name,age,gender,t_type,attacck_val,life_val):
    data_dic{
         'name': name,
         'gender': gender,
         'age': age,
         't_type': t_type,
         'attack_val': attack_val,
         'life_val': life_val
    }
    return data_dic

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

person1 = get_person('json','28','male','战士',30,500)
dog1 = get_dog('黑子','田园犬',50,500)

def dog_combat(dog_obj,per_obj):
	print(f"当前人的血量：{per_obj['life_val']}")
    per_obj['life_val'] -= dog_val['attack_val']
    print(f"收到共计后损失血量{dog_val['attack_val']}，当前剩余血量{per_obj['life_val']}")
    
def per_combat(dog_obj,per_obj):
	print(f"当前狗的血量：{dog_obj['life_val']}")
    dog_obj['life_val'] -= per_val['attack_val']
    print(f"收到共计后损失血量{per_val['attack_val']}，当前剩余血量{dog_obj['life_val']}")
    
# 人打狗
per_combat(dog1,per_person1)
# 狗咬人
dog_combat(dog1,person1)
# 人调用狗的动作
dog_combat(person1,dog1)
# 狗调用人的动作
per_combat(person1,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):
        """
        :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.面向过程编程
	将程序执行流程化 及分步操作，分布的过程中解决问题
   '''eg:注册：第一步获取用户名 第二部对比用户数据'''
过程可以看成流水线，面向过程编程 可以理解成是在创建建一条流水线

2.面向对象编程
	核心就是’对象‘
    	对象其实就是一个容器，将数据和功能整合到一起  只要是符合上述描述的事物都可以称之为对象
     eg:
        人狗大战最后将功能和数据写在一起的函数就是一个对象，可以称之为面向对象编程
        模块文件内部含有数据和功能 也可以称之为面向对象编程
python中针对面向对象编程提供了专门的语法 识别度更高，编写更简单
'''
面向对象编程和面向过程编程两者没有优劣之分，要具体结合实际情况，，很多时候两者是混合在一起的
'''

类与对象的概念

对象：数据功能的结合体
类：即类别，种类，相当于主动对象共有的特征（数据、功能）
'''
eg:
	一个人 是 对象
	一群人 是 人类
类，是用来描述多个对象相同的特征的名词，但个体之间又有这差异。类只能描述出公共的特征，不同的特征应该有对象自己描述
'''
ps:其实类也算是对象

类与对象的创建

类的创建

'''在编程中先有类，才能有对象'''
先定义类，后定义对象
class Student:
    # 学生类公共的数据
    school = '清华大学'
    # 学生类公共的功能
    def choose_course(self):
        print('学生选课功能')
'''类体代码无需执行就会执行，产生名称空间'''
语法结构：
'''
class 类名：
	类体代码
1.class是定义类的关键字
2.类名类似于函数名 但是首字母推荐大写 用于区分于函数
3.函数体代码是用于存放对象 公共数据和功能的地方
	数据： 变量名 = 变量值
	功能   函数
'''

查看名称空间的方法

# 可以通过__dict__方法来查看名称空间
print(Student.__dict__)  # 返回值是一个字典
print(Student.__dict__['school'])  # 获取类中的属性
# 简写方式
print(Student.shool)
print(Student.choose_course)

对象的创建

obj1 = Student()  # 类名加括号就是产生一个对象
obj2 = Student()
print(obj1.__dict__, obj2.__dict__)  # {} {}
print(obj1.school,obj1.choose_course())
>>>学生选课功能
>>>清华大学 None
Student.school = '哈哈哈哈'
print(obj1.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__执行
	3.将创建好的对象自动返回
ps:针对括号内第一个形参self 只是一个普通的变量名，可以随意更改，只是默认写成self
'''

绑定方法

'''
在类中定义的函数默认都是绑定给对象的，即对象调用，会将对象当作第一个参数传入
'''
class Student:
    school = '清华大学'
    # __init__方法不要自己去调用 
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def func(self):
        print(f'{self.name}正在调用func方法')

    def index(self):
        print(f'{self.name}正在调用index方法')
        
obj1 = Student('jason', 18)
print(obj1)  #<__main__.Student object at 0x000001878F96F388>
obj2 = Student('kevin', 28)
# 类调用类中函数 有几个参数就需要传几个参数
Student.func(123,222)
# 对象调用类中函数  会将当前调用的对象当作第一个参数自动传入