一 对象的概念
程序 = 数据 + 功能
面向过程：
核心是'过程'二字
过程的终极奥义就是将程序流程化
过程是'流水线'，用来分步骤解决问题的
面向对象：
核心是'对象'二字
对象的终极奥义就是将程序"整合"
对象是'容器'，用来盛放数据与功能的
示例：
学生容器 = 学生的数据 + 学生的功能
课程r容器 = 课程的数据 + 课程的功能
二 类与对象
1 类的概念
类也是"容器"，该容器用来存放同类对象共有的数据与功能
产生对象的类与对象之间存在关联，这种关联指的是：对象可以访问到类中共有的数据与功能，所以类中的内容仍然是属于对象的，类只不过是一种节省空间、减少代码冗余的机制，面向对象编程最终的核心仍然是是去使用对象。
类体代码，在类的定义阶段就运行了，产生类的名称空间(可以通过类.__ dict __ 查看)
写程序：先想哪些数据整合到一起。
在程序，必须事先定义好类，然后再调用类产生对象（调用类拿到的返回值就是对象）
注：类体代码是在类定义阶段就会立即执行，会产生类的名称空间
定义类
class Student: #类的命名应该使用'驼峰体'
#1、变量的定义
stu_school= 'oldboy'
# 空对象，'egon', 18, 'male'
def __init__(self, x, z):
self.stu_name = x #空对象.stu_name = 'egon'
self.stu_age = y #空对象.stu_age= 18
self.stu_gender = z #空对象.stu_gender = 'male'
#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
类是对象相似数据与功能的集合体，所以类体中最常见的是变量与函数的定义，但是类体其实可以包含任意其他代码的
可以通过 类. __ dict__ 来查看类这个容器内盛放的东西
如：
print(Student.__dict__)
#{..., 'stu_school': 'oldboy', 'choose': <function Student.choose at 0x128b6850>, ...}
2 对象
1、类实例化（调用类产生对象）
stu1_obj= Student('egon', 18, 'male') #自动调用 __init__ 方法，Student.__init__(空对象,'egon',18,'male')
stu2_obj=Student('lili',19,'female')
stu3_obj=Student('jack',20,'male')
通过调用类产生的对象的名称空间(可以通过对象. __ dict __ 查看)，调用类会自动触发类下面的__ init __ 方法
2、调用类的过程又称之为实例化，发生了三件事
1、先产生一个空对象（python 底层做了，是看不到的）
2、python 会自动调用类的__ init __ 方法，然后将空对象和已经调用类时括号内传入的参数一起传给 __ init __方法
3、返回初始完的对象
3、总结 __ init __ 方法
1、会在调用类时自动触发执行， 用来为对象初始化自己独有的数据
2、 __ init __ 内应该存放是为对象初始化属性的功能，但是是可以存放任意其他代码，想要在类调用时就立刻执行的代码都可以放到该方法内
3、__ init __方法必须返回 None(默认就是返回 None)
3、属性访问
1、类属性访问
在类中定义的名字，都是类的属性，类有两种属性：数据属性和函数属性，可以通过 __ dict __ 访问属性的值，比如 Student.__ dict __ ['stu _ school'], 但 python 提供了专门的属性访问语法
1、访问数据属性
print(Student.stu_school) #oldboy
2、访问函数属性
print(Student.tell_stu_info) #<function Student.tell_stu_info at 0x10fd4c1e0>
print(Student.set_info) #<function Student.set_info at 0x10fd4c378>
1）当通过类.方法来修改类的属性时，调用类的对象属性都会随之改变
Student.stu_school='OLDBOY'
print(stu1_obj.stu_school) #OLDBOY
print(stu2_obj.stu_school) #OLDBOY
2）当对象的属改变时，类的属性和其他调用该类的属性不会被改变
stu1_obj.stu_school='OLDBOY'
print(stu1_obj.stu_school) #OLDBOY
print(Student.stu_school) #oldboy
print(stu2_obj.stu_school) # #oldboy
print(stu3_obj.stu_school) # #oldboy
原因就是类中定义的函数主要是给对象使用的，而且是绑定给对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法，内存地址各不相同。
3）类调用自己的函数属性必须严格按照函数的用法来(有几个参数就必须传几个)
#类实例化产生对象
stu1_obj= Student('egon', 18, 'male') #自动调用 __init__ 方法，Student.__init__(空对象,'egon',18,'male')
stu2_obj=Student('lili',19,'female')
stu3_obj=Student('jack',20,'male')
#通过类调用方法
Student.tell_stu_info(stu1_obj) #学生信息：名字：egon 年龄：18 性别：male
Student.tell_stu_info(stu2_obj) #学生信息：名字：lili 年龄：19 性别：female
Student.tell_stu_info(stu3_obj) #学生信息：名字：jack 年龄：20 性别：male
2、对象属性访问
类通过实例化产生对象，这时对象就有了对象的绑定方法，绑定方法的特殊之处在于：谁(对象)来调用绑定方法就会将谁当做第一个参数传入
#类实例化产生对象
stu1_obj= Student('egon', 18, 'male') #自动调用 __init__ 方法，Student.__init__(空对象,'egon',18,'male')
stu2_obj=Student('lili',19,'female')
stu3_obj=Student('jack',20,'male')
stu1_obj.tell_stu_info() #tell_stu_info(stu1_obj) #学生信息：名字：egon 年龄：18 性别：male
stu2_obj.tell_stu_info() #tell_stu_info(stu2_obj)
stu3_obj.tell_stu_info() #tell_stu_info(stu3_obj)
3、操作对象的属性
print(stu1_obj.__dict__) #{'stu_name': 'egon', 'stu_age': 18, 'stu_gender': 'male'}
#查看
stu1_obj.stu_name #egon 等同于 stu1_obj.__dict__['stu_name']
#新增
stu1_obj.stu_hobby = 'play basketball'
print(stu1_obj.__dict__) #{'stu_name': 'egon', 'stu_age': 18, 'stu_gender': 'male'}
#修改
stu1_obj.stu_gender = 'female'
print(stu1_obj.__dict__) #{'stu_name': 'egon', 'stu_age': 18, 'stu_gender': 'female', 'stu_hobby': 'play basketball'}
#删除
del stu1_obj.stu_hobby
print(stu1_obj.__dict__) #{'stu_name': 'egon', 'stu_age': 18, 'stu_gender': 'female'}
4、属性查找顺序与绑定方法
对象的名称空间里只存放着对象独有的属性，而对象相似的属性是存放于类中的。对象在访问属性时，会优先从对象本身的__ dict __ 中查找，未找到，则取类中的__ dict __ 中查找
类的属性是共享给所有对象用，所以大家访问的地址都是一样的
print(id(stu1_obj.stu_school)) # #4494520136
print(id(stu2_obj.stu_school)) # #4494520136
print(id(stu3_obj.stu_school)) # #4494520136
绑定到对象的方法特殊之处在于，绑定给谁就应该由谁来调用，谁来调用，就会将’谁’本身当做第一个参数自动传入（方法__ init __也是一样的道理），在使用对象的绑定方法时，python 会默认将对象本身当做第一个参数自动传入，因此无需我们再传入。
绑定到不同对象的 choose 技能，虽然都是选课，但是学生 1 选的课不会选给学生 2，这正是'绑定'二字的精髓所在
stu1_obj.choose('python全栈开发')
print(stu1_obj.course)
stu2_obj.choose('linux运维')
print(stu2_obj.course)
stu3_obj.choose('高级架构师')
print(stu3_obj.course)
注：绑定到对象方法的这种自动传值特征，决定了在类中定义的函数都要默认写一个参数 self,self 可以是任意的名字，但是命名为 self 是约定俗成的
python 中一切皆为对象，且 python3中类与类型是一个概念
#类型list就是类
>>> list
<class 'list'>
#实例化得到 3个对象l1,l2,l3
>>> l1=list([1,2,3])
>>> l2=list(['a','b','c'])
>>> l3=list(['x','y'])
#三个对象都有绑定方法append,是相同的功能,但内存地址不同
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>
#操作绑定方法l1.append(4),就是在往l1添加4,绝对不会将4添加到l2或l3
>>> l1.append(4) #等同于list.append(l1,4)
>>> l1
[1,2,3,4]
>>> l2
['a','b','c']
>>> l3
['x','y']