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
>>>
