面向对象编程

1、对象的概念

对象就是容器，把数据与功能集合装起来的容器，这个容器就是对象。

以学生信息为例：
在学习对象概念之前，数据与功能是分开的如下：

# 学生的数据
stu_name='egon'
stu_age=18
stu_gender='male'

# 学生的功能
def tell_stu_info():
    print('学生信息：名字：%s 年龄：%s 性别：%s' %(stu_name,stu_age,stu_gender))

def set_info(x,y,z):
    stu_name=x
    stu_age=y
    stu_gender=z

我们学习了对象，那么就得到了一个容器，可以将上面散装的信息装起来。由于数据与功能都被装在一个容器中，那么无论我们需要什么直接将容器整体拿过来用就好。需要功能，容器内有功能，需要数据容器内有数据，用起来很方便。

2、类与对象

如果有多个对象有相似的数据和功能，那么该多个对象就属于同一类。
可以将同一类对象中的相同功能与数据存放到类中，那么就不用每个
对象中都重复存一份，这样每个对象中只需要存自己独有的数据即可。

2.1、先定义类

类是对象相似数据与功能的集合体：
所以类体中最常见的是变量与函数的定义，但是类体其实是可以包含任意其他代码的
注意：类体代码是在类定义阶段就会立即执行，会产生类的名称空间

class Student:
    # 1、变量的定义
    stu_school='oldboy'

    # 2、功能的定义
    def tell_stu_info(stu_obj): #传入一个字典，包含需要的数据
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj['stu_name'],
            stu_obj['stu_age'],
            stu_obj['stu_gender']
        ))

    def set_info(stu_obj,x,y,z):  #传入一个字典与变量，进行需数据的修改
        stu_obj['stu_name']=x
        stu_obj['stu_age']=y
        stu_obj['stu_gender']=z

    # print('========>')
    
我们可以通过类中__dict__这个属性，得到类内部的所有的属性名与属性值组成的字典
print(Student.__dict__)  #打印字典，包含类中相对应的属性名与属性值

Student.__dict__['stu_school'] #得到类中属性名'stu_school'对应的属性值'oldby'
# 属性访问的语法
访问数据属性
print(Student.stu_school) # Student.__dict__['stu_school']
访问函数属性
print(Student.set_info) # Student.__dict__['set_info']

Student.x=1111 #Student.__dict__['x]=111 可以为类中增加新值，与字典赋值方式一样
print(Student.__dict__)  #运行结果可以看到 x：1111已经写入字典

2.2、调用类产生对象

为对象定制自己独有的属性
问题1：代码重复
问题2：属性的查找顺序
stu1_obj=Student()  #进行类的调用
stu2_obj=Student()
stu3_obj=Student()


print(stu1_obj.__dict__)  #会输出一个空字典
print(stu2_obj.__dict__)
print(stu3_obj.__dict__)
#设置对象独有功能
stu1_obj.stu_name='egon'   # stu1_obj.__dict__['stu_name']='egon'
stu1_obj.stu_age=18        # stu1_obj.__dict__['stu_age']=18
stu1_obj.stu_gender='male' #  stu1_obj.__dict__['stu_gender']='male'
# print(stu1_obj.__dict__)

stu2_obj.stu_name='lili'
stu2_obj.stu_age=19
stu2_obj.stu_gender='female'
# print(stu2_obj.__dict__)

stu3_obj.stu_name='jack'
stu3_obj.stu_age=20
stu3_obj.stu_gender='male'
# print(stu2_obj.__dict__)


解决问题一：
以上方法，每次都要重复调用，有点代码冗余，所以需要优化
解决方案一：
def init(obj,x,y,z):
    obj.stu_name=x
    obj.stu_age=y
    obj.stu_gender=z

init(stu1_obj,'egon',18,'male')#将字典与值传入函数进行赋值操作
init(stu2_obj,'lili',19,'female')
init(stu2_obj,'jack',20,'male')

解决方案二：
# 一：先定义类
class Student:
    # 1、变量的定义
    stu_school='oldboy'

    # 空对象,'egon',18,'male'
    def __init__(obj,x,y,z):
        obj.stu_name=x # 空对象.stu_name='egon'
        obj.stu_age=y  # 空对象.stu_age=18
        obj.stu_gender=z # 空对象.stu_gender='male'
        # return None

    # 2、功能的定义
    def tell_stu_info(stu_obj):
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj['stu_name'],
            stu_obj['stu_age'],
            stu_obj['stu_gender']
        ))

    def set_info(stu_obj,x,y,z):
        stu_obj['stu_name']=x
        stu_obj['stu_age']=y
        stu_obj['stu_gender']=z


#二：再调用类产生对象
#调用类的过程又称之为实例化，发生了三件事
#1、先产生一个空对象
#2、python会自动调用类中的__init__方法然将空对象已经调用类时括号内传入的参数一同传给#__init__方法
#3、返回初始完的对象
stu1_obj=Student('egon',18,'male') # Student.__init__(空对象,'egon',18,'male')
stu2_obj=Student('lili',19,'female')
stu3_obj=Student('jack',20,'male')

print(stu1_obj.__dict__)
print(stu2_obj.__dict__)
print(stu3_obj.__dict__)


总结__init__方法
1、会在调用类时自动触发执行，用来为对象初始化自己独有的数据
2、__init__内应该存放是为对象初始化属性的功能，但是是可以存放任意其他代码，想要在
   类调用时就立刻执行的代码都可以放到该方法内
3、__init__方法必须返回None

3、属性的查找

class Student:
    # 1、变量的定义
    stu_school='oldboy'
    count=0

    # 空对象,'egon',18,'male'
    def __init__(self,x,y,z):
        Student.count += 1

        self.stu_name=x # 空对象.stu_name='egon'
        self.stu_age=y  # 空对象.stu_age=18
        self.stu_gender=z # 空对象.stu_gender='male'
        # return None

    # 2、功能的定义
    def tell_stu_info(self):
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            self.stu_name,
            self.stu_age,
            self.stu_gender
        ))

    def set_info(self,x,y,z):
        self.stu_name=x
        self.stu_age=y
        self.stu_gender=z

    def choose(self,x):
        print('正在选课')
        self.course=x

stu1_obj=Student('egon',18,'male') # Student.__init__(空对象,'egon',18,'male')
stu2_obj=Student('lili',19,'female')
stu3_obj=Student('jack',20,'male')

print(stu1_obj.count)
print(stu2_obj.count)
print(stu3_obj.count)

类中存放的是对象共有的数据与功能
一：类可以访问：
1、类的数据属性
print(Student.stu_school)
2、类的函数属性
print(Student.tell_stu_info)
print(Student.set_info)

二：但其实类中的东西是给对象用的
1、类的数据属性是共享给所有对象用的，大家访问的地址都一样
print(id(Student.stu_school))  #2356762115632

print(id(stu1_obj.stu_school)) #2356762115632
print(id(stu2_obj.stu_school)) #2356762115632
print(id(stu3_obj.stu_school)) #2356762115632

Student.stu_school='OLDBOY'  #如果类中的数据属性值变了，那么实例中的数据也会变
stu1_obj.stu_school='OLDBOY'#如果一个实例的数据属性变了，对类与其他实例没影响，相当于在实例stu1_obj中进行了字典数据的添加
print(stu1_obj.stu_school)

print(Student.stu_school)
print(stu2_obj.stu_school)
print(stu3_obj.stu_school)

2、类中定义的函数主要是给对象使用的，而且是绑定给对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法，内存地址各不相同

类调用自己的函数属性必须严格按照函数的用法来，将需要的参数写全
print(Student.tell_stu_info)
print(Student.set_info)

Student.tell_stu_info(stu1_obj)
Student.tell_stu_info(stu2_obj)
Student.tell_stu_info(stu3_obj)

Student.set_info(stu1_obj,'EGON',19,'MALE')
Student.tell_stu_info(stu1_obj)

绑定方法的特殊之处在于：谁来调用绑定方法就会将谁当做第一个参数自动传入
print(Student.tell_stu_info)  #<function Student.tell_stu_info at 0x000001522B5AA0D0>
print(stu1_obj.tell_stu_info) #<bound method Student.tell_stu_info of <__main__.Student object at 0x000001522B594B50>>
print(stu2_obj.tell_stu_info)#<bound method Student.tell_stu_info of <__main__.Student object at 0x000001522B538760>>
print(stu3_obj.tell_stu_info)#<bound method Student.tell_stu_info of <__main__.Student object at 0x000001522B564A30>>

stu1_obj.tell_stu_info() #tell_stu_info(stu1_obj)
stu2_obj.tell_stu_info() #tell_stu_info(stu2_obj)
stu3_obj.tell_stu_info() #tell_stu_info(stu3_obj)


stu1_obj.choose('python全栈开发')
print(stu1_obj.course)

stu2_obj.choose('linux运维')
print(stu2_obj.course)

stu3_obj.choose('高级架构师')
print(stu3_obj.course)