python是面向对象语言，一切皆对象。
面向过程：
变量和函数。 “散落” 在文件的各个位置，甚至是不同文件中。看不出变量与函数的相关性，非常不利于维护，设计模式不清晰。
经常导致程序员，忘记某个变量的相关性，而导致无法检测的错误。
面向对象：
相关的变量和函数都“封装” 在对象里，以对象为单位来管理代码。变量与函数的相关性清晰，利于维护，设计模式清晰。
程序员可以配合“继承” 来提高代码的可重用性，加强合作开发。
类与实例之间的关系：
例如：小明是个人类，小明是真实存在的，而人这个属性是个抽象的类。所以小明是人类里面的具体的实例。
类：是一类事物的抽象，不是真是存在的。描绘了该类事物的共性，例如：“人”、“动物”、“家具”。
实例：某类事物的具体个体，是该类事物的具体表现，它是真实存在的。例如：“小明”是具体的某个“人”， “加菲猫”是具体的某个“动物”。
创建类：
class Person: #使用class关键字定义一个类，这里定义一个Person类。
pass #使用pass占位，保证不会出现语法错误。
创建实例：
>>> class Person:
pass >>> p1 = Person() #类似于函数调用，返回一个具体的实例（实例化一个具体的人）
>>> p2 = Person() #在实例化一个人
>>> print(p1 is p2) #比较两个人是不是同一个。明显不是同一个。
False
>>>
isinstance 判别函数
想象一下，当你不确定一个变量是什么类的实例时，如何确定你的猜测呢？
方法：isinstance(obj, class_or_tuple, /) #同时比较多个类，如：isinstance(d1,(Person,Dog))
详细用法： help(isinstance)
>>> class Person: #定义一个Person类
pass >>> class Dog: #定义一个Dog类
pass >>> p1 = Person() #实例化一个人类p1
>>> d1 = Dog() #实例化一个狗类d1
>>> print(isinstance(p1,Person)) #使用isinstance判断p1这个实例是不是Person实例化来的
True
>>> print(isinstance(d1,Person)) #使用isinstance判断p1这个实例是不是Person实例化来的，这个d1是Dog实例化的。
False
>>> print(isinstance(d1,(Person,Dog))) #可以同时判断多个，只要属于其中一个就可以。
True
封装变量：
类就是一个独立存放变量的空间与属性查找。
>>> class Person: #本身是一个独立的空间
var2 = '变量2' #赋值语句，将变量封装在这个类空间里（封装变量）
pass >>> Person.var1 = '变量1' #这种方式使用的少
>>> print(Person.var1)
变量1
>>> print(Person.var2) #也可以是
变量2
>>>
属性查找规则：
属性就是封装在“实例”里面的变量，表征了实例的特点或特征。
查找变量时，先在实例中查找，然后再到类里面去查找（先实例再类）。
>>> p =Person() #实例也是一个独立的变量空间
>>> print(p.var2) #尽管这个实例 p 里面没有变量 var2，但是这个实例也可以看到对应类里面封装的变量。
变量2
>>>
>>> class Person:
var2 = '变量2' >>> p = Person()
>>> p.var2 = '变量'
>>> print(p.var2) #它会打印 '变量'，而不是 '变量2'，因为它查找var2时先在实例p里面的空间查找，找到之后 就不去类里面查找了。
变量
>>>
实例也是一个独立存放变量的空间
每个实例都是一个独立的变量空间。不同实例之间的空间互相不可见。
>>> class Person: #定义一个类，里面没有任何变量。
pass >>> p1 = Person() #实例化对象 p1
>>> p2 = Person() #实例化对象 p2
>>> p1.var1 = '变量1' #实例 p1 里面添加一个变量 var1
>>> p2.var2 = '变量2' #实例 p2 里面添加一个变量 var2
>>> print(p1.var1) #变量 var1 在实例 p1 这个空间里。
变量1
>>> print(p1.var2) #变量 var2 不在实例p1这个空间里。然后它会去Person类里面去找，所以最终报错是 ”提示类的问题“。
Traceback (most recent call last):
File "<pyshell#52>", line 1, in <module>
print(p1.var2)
AttributeError: 'Person' object has no attribute 'var2'
>>>
一个“实例”的“特征”（注意：不是类的特征），就是“属性”
小明是人，tom也是人。但是小明是小明，tom是tom。
>>> class Person:
pass >>> p1 = Person() #实例化对象p1，每个实例的属性是不同的。如：每个人的姓名和年龄不同。
>>> p2 = Person()
>>> p1.name = '小明' #实例p1的特征 name
>>> p2.name = 'tom'
>>> p1.age = 18 #实例p1的特征 age
>>> p2.age = 25
>>>
实例方法：
就是封装在类里的一种特殊的函数。
>>> class Person: #定义一个类
def func(): #在类中封装一个函数
print('Just do a test!') >>> Person.func() #通过变量空间的方式调用函数。使用类调用函数不会报错，不会把类当作参数传到函数中。
Just do a test!
>>> p = Person() #声明一个实例
>>> p.func() #通过实例调用函数，结果会报错，因为实例调用封装在类里面的函数时会把实例自己 "p" 当作一个参数传到函数func()里面去,结果就是 "func(p)"
Traceback (most recent call last):
File "<pyshell#67>", line 1, in <module>
p.func() #通过实例调用函数
TypeError: func() takes 0 positional arguments but 1 was given
>>>
使用实例调用函数：
通过实例调用函数时，会把实例本身当成一个参数传入到封装在类中的函数。如：p.fun()，最终结果是fun(p).
如果使用类直接调用函数，是不会把类自己当成一个参数传入到函数中。
>>> class Person:
def func(a):
print(a) #打印出参数，方便鉴定这个参数是啥？ >>> p = Person() #实例化对象p
>>> p.func(123) #按照正常思维，调用函数func(a)时应该传个参数进去；结果却报错？这是因为使用实例p调用函数func(a)时，
它会把实例 p 当成第一个参数参数，传入到函数func(a)中。
Traceback (most recent call last):
File "<pyshell#91>", line 1, in <module>
p.func(123)
TypeError: func() takes 1 positional argument but 2 were given
>>>
>>> p.func() #使用实例 p 调用函数func(a)时，它会把自己当成第一个参数，传入到函数func(a)中。
<__main__.Person object at 0x0000029252E5CCF8>
>>> print(p) #验证这个参数是不是实例p。
<__main__.Person object at 0x0000029252E5CCF8>
>>> class Person:
def func(a):
print(id(a)) #打印出参数的 id >>> p = Person() #实例化一个对象 p
>>> p.func() #使用实例p 调用函数func(a)
2827479273312
>>> print(id(p)) #单独打印实例p 的id，发现和函数参数里面的id 一样；说明实例p在调用函数func(a)时，把自己当成第一个参数传入到函数。
2827479273312
>>> Person.func() #使用类调用函数func(a)时，类不会把自己当成参数传入到函数中，所以报错缺少参数。通过类调用函数和普通调用函数是一样的。
Traceback (most recent call last):
File "<pyshell#85>", line 1, in <module>
Person.func()
TypeError: func() missing 1 required positional argument: 'a' >>> Person.func(123) #使用类调用函数func(a)时，手动传个参数就不会报错。
1450736928
如何利用实例调用函数时，会自动把自己当成第一个参数传入到函数里？
>>> class Person:
def eat(a):
print(a.name,'在eating...') #注意这里的a.name，其实就是实例的属性。 >>> p1 =Person() #实例化对象p1
>>> p1.name = '小明' #实例p1的属性
>>> p2 =Person()
>>> p2.name = '花花'
>>> p1.eat() #使用实例p1调用函数 eat(a)，它会自动把p1当成第一个参数传入到函数eat(a)中。最终是eat(p1)。所以a.name就是p1.name
小明 在eating...
>>> p2.eat()
花花 在eating...
>>>
“实例方法” 的调用过程：
实例.方法(参数)
类.方法(实例，参数)
self：
因为实例调用函数时会把自己当成第一个参数传进函数func()，所以这里第一个参数的变量名就使用约定俗成的 self
>>> class Person:
def func(self,w): #因为实例调用函数时会把自己当成第一个参数传进函数func()，所以这里第一个参数的变量名就使用约定俗成的 self
print(self.name,'在eating：',w) >>> p1 =Person() #实例化对象
>>> p1.name = '小明' #实例p1的属性
>>> p1.func('apple') #使用实例.方法(参数)调用实例方法。
小明 在eating： apple
>>> Person.func(p1,'apple') #使用类.方法(实例，参数)调用实例方法。
小明 在eating： apple
>>>