今日内容学习

今天学习的主要是面向对象以及类与对象的概念

'总体概述'
1、面向过程：c语言

2、面向对象：所谓面向对象，其实就是说，站在上帝的视角下，世界万物一切皆对象。把拥有共同属性的归为一类，这就是class的由来

3、类的定义：
（1）类的关键字：class
（2）类中有属性、方法（就是之前学习过的函数），类里面的属性（类有三种属性：字段、方法、特性）及方法，调用的前提是首先要对类进行实例化处理。类的实例化处理必须调用__init__初始化方法
（3）类的名称首字母必须是大写的
class Student:
    school = '金职院'
    def get_id():
        print('学号是')

4、函数与方法的区别
（1）定义位置
	A、函数：Python的函数是直接写在Python模块中的，即在.py文件中直接定义
	B、方法：只能定义在class类中。
（2）定义方式
	A、函数：函数定义的方式 def 函数名()，括号里面写形参，也可以省略不写形参
	B、方法：方法定义的方式， 首先方法是定义在类中的，其他大体和函数定义差不多，这里需要注意的一点就是方法必须带一个默认参数self，self指的是类自己
（3）调用方式
	A、函数：直接使用函数名(参数1，参数2，…)调用
	B、方法：方法：方法是通过 对象.方法 的方式调用的（这里是指对象方法）

'最主要要知道的是数据与功能进行绑定'
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.面向对象编程
	核心是'对象'
    对象其实就像是一个'容器'，将数据和功能整合到一起
    面向对象编程是把构成问题的事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为
    面向对象是按功能的来划分问题，而不是步骤
    假如要改动一个功能，按照面向过程编程就要重写,而按照面向对象编程就只用改动局部先相关的对象
    
# 区别：	
'面向过程:'
    优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源 
	缺点：没有面向对象易维护、易复用、易扩展
    
'面向对象:'
    优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护 
	缺点：性能比面向过程低

类和对象的概念

'对象:'数据与功能的结合体
'类:'即类别、种类 相当于诸多对象公有的特征(数据、功能)
简单来说就是某一类事物，它们具有相同的属性

'二者的关系:'对象是由类派生的、创建的。一个类可以创建无穷多个对象，每个对象都属于类。

例子：
类：猫
对象：橘猫，布偶猫，加菲猫

'类':其实就是某一类事物，具有相同的属性
'对象':就是类的实例
# 类也算是对象>>>一切皆对象

类与对象的创建

'在代码中是先有类才能有对象'
# 因为要先定义类，然后才能产生对象

# 学生类
class Student:
    # 学生类公共数据
    school = '金职院'
    # 学生类公共的功能
    def choose_course(self):
        print('学生选课功能')
'类体代码无需调用就会执行 产生类的名称空间'
上面就是一个大致的类

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

# 查看名称空间的方法就是双下dict>>>:__dict__
print(Student.__dict__)  # 返回值是一个字典

print(Student.__dict__['school'])  # 获取类中的属性
等同于
print(Student.school)  # 金职院

print(Student.__dict__['choose_course'])  # 获取类中的属性
等同于
print(Student.choose_course)

'如何产生对象: 类名加括号'
# 对象1 : obj1
obj1 = Student()  # 类名加括号就是在产生一个对象
# 对象2 : obj2
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(绑定方法)

# 可以直接修改类中公共数据
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__) 
'开始给对象添加数据'
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__(obj,name,age,gender)
    __init__的第一个参数就是对象本身
	3.将创建好的对象自动返回
'括号内第一个形参self其实就是一个普通的变量名,就像是默认的名字self'

绑定方法

'在类中定义的函数默认都是绑定给对象使用的,就是对象来调会自动将对象当做第一个参数传入'
class Student:
    school = '清华大学'
    # __init__方法不要自己去调用 
    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('jason', 18)
# print(obj1)
obj2 = Student('kevin', 28)
# 类调用类中函数，有几个参数就需要传几个参数
Student.func(123,222)
# 对象调用类中函数，会将当前调用的对象当做第一个参数自动传入
obj1.func()
obj2.func()
print(obj1.func)
print(obj2.index)


1.凡是类中的方法和函数，都是绑定给对象使用的
2.绑定方法都有自动传值的功能。传递进去的值，就是对象本身
3.如果类想调用绑定方法，就必须遵循函数的参数规则，有几个参数，就必须传递几个参数

今天学的对象和类的概念还可以理解，但是ATM还是没有完全掌握，所以要多去练习了