python是面向对象的语言，那么究竟什么是面向对象？
首先理解类
类：在中文中的定义，许多相同或相似事物的综合。根据这个定义，类是许多相同或相似的实物聚在一起的。譬如，人类，鸟类，花类等。
面向对象的三个特征
类的单个具体实例可以称之为对象，把类具体化单个实体的过程，这个过程称为类的实例化！
面向对象程序设计中的术语对象基本上可以看做数据(特性)以及由一系列可以存取，操作这些数据的方法所组成的集合。
面向对象的三个基本特征：封装，继承，多态。
创建对象的过程称之为实例化，当一个对象被创建之后，包含三个方面的特性：对象的句柄，属性和方法。对象的句柄用于区分不同的对象，当对象被创建后，该对象会获取一块存储空间，存储空间的地址即为对象的标识。
- 多态：对不同的类的对象使用同样的操作。
- 封装：对外部世界隐藏对象的工作细节。
- 继承：以普通的类为基础类建立专门的类对象。
通过实例理解面向对象的一些术语和三个基本特征：
构造方法与析构函数
- 构造方法：在实例化时做的一些初始化工作。
- 析构函数：在实例销毁时，执行的一些操作。
class People(object):
def __init__(self,country, name,age=23): #构造方法
self.country = country #实例属性
self.name = name
self.__age = age #私有属性 def __del__(self): #析构函数
print("%s has died" % self.name) def get_info(self): #实例方法
print("The %s info".center(50,"-") % self.name)
print("The %s comes from %s, is %d old" % (self.name, self.country, self.__age))
实例化上面的类，
>>> a = People("China","hitler",20) #实例化一个类时，这时候构造函数会自动执行
>>> a.get_info() #通过实例访问类中的实例方法
-------------------The hitler info--------------------
The hitler comes from China, is 20 old
在类中定义属性时，若属性是以双下划线开始的则为私有属性，例如self.__age属性，而像self.country和self.name属性则是公有属性，无论是私有属性还是公有属性，每个通过实例化得到的类都有这些属性。
在实例化时，我们可以像给函数传入参数那样，给类传入参数，而这些参数的最终被赋值的操作就是在构造函数中执行的。构造函数在类实例化的时候会自动执行。
注意私有属性和实例属性的访问方法的不同：
>>> a.name #访问实例属性
'hitler'
>>> a.country #访问实例属性
'China'
>>> a.__age #方位私有属性
Traceback (most recent call last):
File "<input>", line 1, in <module>
AttributeError: 'People' object has no attribute '__age'
>>> a._People__age #私有属性的访问方法，实例化名._类名__私有属性名
20
>>> del a #删除一个实例，这时候，析构函数会自动执行
hitler has died
#析构函数：在实例销毁的时候自动执行的，通常用于做一些收尾的工作，关闭一些数据库连接或者关闭打开的临时文件。
析构函数：在实例销毁的时候自动执行的，通常用于做一些收尾的工作，关闭一些数据库连接或者关闭打开的临时文件。
在上面的例子中，使用del删除了实例a，然后会自动返回析构函数执行的结果。
可以对实例进行增加，删除，修改操作：
对象属性的增删改
>>> A = People("USA", "jobs", "")
>>> A.country #可以通过实例修改对应的属性值
'USA'
>>> A.country = "UKA"
>>> A._People__age = 55
>>> A.get_info() ##可以看到实例的属性值已经修改
-------------------The jobs info--------------------
The jobs comes from UKA, is 55 old
#可以通过del删除某个属性
>>> del A.country
>>> A.get_info() #报错，没有对应的country属性
Traceback (most recent call last):
File "<input>", line 1, in <module>
File "E:\pycharm\class_method.py", line 14, in get_info
print("The %s comes from %s, is %d old" % (self.name, self.country, self.__age))
AttributeError: 'People' object has no attribute 'country'
-------------------The jobs info-------------------- >>> A.country = "China" #添加属性
>>> A.get_info() #可以看到属性添加成功
-------------------The jobs info--------------------
The jobs comes from China, is 55 old
注意上面的通过实例对属性的增加，删除，修改操作仅对当前的实例有效；而对于类的其余实例则没有效果。可以做如下测试以证明：
>>> a = People("USA","swift",) #实例化一个对象
>>> a.pos = "singer" #给对象添加一个pos属性
>>> a.pos #对象a具有pos属性
'singer'
>>> B = People("UKA","king",) #再实例化一个对象B
>>> B.pos
Traceback (most recent call last): #对象B没有pos属性
File "<input>", line 1, in <module>
AttributeError: 'People' object has no attribute 'pos'
>>> a.get_info()
-------------------The swift info--------------------
The swift comes from USA, is 29 old
>>> b.get_info()
-------------------The king info--------------------
The king comes from UKA, is 80 old
解释：
创建类的时候python会在内存中为类开辟一段内存空间，实例化的时候，python会为每一个实例开辟一段内存空间，每个实例的内存空间都是相互独立的，因此更改了a的内存空间，并不会影响B的内存空间。
若想使更改的效果，对类的每一个实例都生效，可以使用类变量。
在类变量之前，先说一下self参数。在类中定义的方法，每个方法都有一个self参数，那么self参数该如何理解？
- 在上面的实例中，通过类实例化了两个对象a和b，那么这两个对象都有get_info()方法，但是在调用的时候并没有出错，我们只能通过某一个具体对象得到这个对象的信息，也就是说我们只能通过a的get_info()方法得到对象a的相关信息，而不是得到b的信息。这个的实现就是因为self参数的作用。
- 在实例化的过程时，python会执行构造函数，做一些初始化的工作，这时候python会为这个实例开辟一段内存空间，会把这个实例名（通过self参数传递）和一些属性信息一起存入内存，这样调用的时候，通过self参数来区分不同的实例可以准确的调用到对应的属性信息。
类变量：
首先满足上面提到的，让更改对每一个实例都生效。
class People(object):
addr = "Earth" # 类变量 def __init__(self, country, name, age=23):
self.country = country
self.name = name
self.__age = age
然后对上面的类进行实例化操作，如下：
>>> a = People("USA","swift", 29) #实例化两个类
>>> b = People("China","wxz", 24)
>>> a.addr #这两个类都有一个addr属性，注意addr类变量在类中定义的方法
'Earth'
>>> b.addr
'Earth'
>>> a.addr = "Moon" #注意这样做只是在实例a中添加了实例属性addr，而不是修改类变量addr。
>>> a.addr #实例a访问的是实例属性中的addr。
'Moon'
>>> b.addr #而实例b访问的是类变量addr。因此结果不同
'Earth'
>>> People.addr = "Moon" #修改类变量，这时候实例a仍然访问的是实例属性addr，而实例b访问的是类变量addr。
>>> a.addr
'Moon'
>>> b.addr
'Moon'
#再实例化一个实例对象c,可以发现c的addr属性已经是修改之后的属性。
>>> c = People("UKA", "King",88)
>>> c.addr #实例对象c访问的是类变量addr。
'Moon'
在上面的实例中，我们给实例a添加一个实例属性addr，而这时候类变量也有一个属性addr，那么在访问的时候实例会怎么去调用对应的值呢？
通过以上的例子可以得出如下结论：属性查找，首先查找实例本身是否有对应的属性，若找到则返回结果，停止查找；否则就继续查找类中的属性变量。
在这里实例a因为添加了add实例r属性，因此实例a只会返回实例本身的addr结果；而实例b和实例c，因为本身的没有addr实例属性(构造函数中没有定义)，因此会返回类变量addr的值。
类变量是类的各个实例共有的属性。当然这个属性也可以放在构造函数中，在每个实例初始化的时候，就会自动生成这个属性。
但是上面提到过python会为每个实例开辟一个内存空间，因此当实例非常巨大的时候，这样做会占用存储空间。采用类变量的形式更节省空间。
封装：
在这个实例中有一个简单的方法就是get_info()。对于一个对象也就是实例来说，要想得到这个对象的具体信息，只需要调用get_info()这个方法即可，然后就会返回对象的具体信息。但是具体是怎么样得到这些信息的，这个实例是不知道的。这种形式就是封装。把一些功能实现的细节不对外暴露，隐藏起来就是封装。
经典类与新式类：
- python2中默认创建的都是经典类，但创建类时使用object参数时，就是新式类。
- python3中创建的类都是新式类，但习惯上使用object参数。
- 经典类与新式类的区别在多种继承中可以用到，附上一片博文链接，经典类与新式类的异同。
继承：
- 继承就是一个类继承了另一个类，继承的新类拥有父类属性和方法，实现代码的重复使用和代码的扩展。
- 再继承时，可以对父类的一些属性和方法进行重写。
- 需要特别注意的是构造方法的重写。
class People(object):
def __init__(self,name,pos=None):
self.name = name
self.pos = pos def get_info(self):
print("My name is %s, I have not a work" % self.name) class Teacher(People):
def __init__(self,name, pos, school):
super(Teacher,self).__init__(name, pos) #重写构造方法的两种形式，推荐使用super的形式，构造方法重写时注意参数传递。
# People.__init__(self, name, pos)
self.school = school
def get_info(self):
print("My name is %s, I am a %s" % (self.name, self.pos))
print("The colleage is %s" % self.school) class Student(People):
def __init__(self,name,pos, score, course):
super(Student, self).__init__(name, pos)
self.score = score
self.course = course def get_info(self):
print("My name is %s, I am a %s" % (self.name, self.pos))
print("My score is %d" % self.score)
print("I have learned the %s %s %s" % self.course)
上面定义了一个父类People，两个子类teacher和student，都继承了people。
实例化操作：
a = People("wxz")
b = Teacher(name="steve", pos="teacher", school="Peking university")
d = Student(name="job", pos="Stuent", score=88, course=("数学","语文","物理"))
In [6]: a.get_info()
My name is wxz, I have not a work
In [7]: b.get_info()
My name is steve, I am a teacher
The colleage is Peking university
In [8]: d.get_info()
My name is job, I am a Stuent
My score is 88
I have learned the 数学 语文 物理
实例化的每一个对象都可以调用get_info()方法，得到其对应的信息。这三个对象是不一样的，分别为people， teacher，student对象。
若有一个函数，只要传入对应的对象，然后就可以调用函数得到对应的信息。如下这种形式：
In [9]: def print_info(obj): ##在只要传入对象信息，我们不知道这个对象是什么类型，但是他依然可以得到对象的信息
...: obj.get_info()
...: In [10]: print_info(a)
My name is wxz, I have not a work In [11]: print_info(b)
My name is steve, I am a teacher
The colleage is Peking university In [12]: print_info(d)
My name is job, I am a Stuent
My score is 88
I have learned the 数学 语文 物理
在这个例子中，并不知道a,b,d是什么样的对象，要做的只是把这三个对象传入了print_intfo函数，然后函数会自动返回对应的对象信息。
这里只有一个print_info的接口，但是不同的对象都可以调用这个接口，这种行为就叫做多态。
多态就是一种接口的多种使用。
下面一个简单的多态实例
list1
Out[22]: ['a', 'f', 'd', 's', 'f', 'a', 's', 'd', 'f'] #列表 tuple1
Out[23]: ('f', 'g', 'a', 'g', 'f', 'd', 'g', 'd', 'f') #元组 len(list1)
Out[24]: 9 len(tuple1)
Out[25]: 9
对于len()函数来说并不知道list1是列表，tuple1是元组，len()函数只是接受一个参数对象，然后返回这个参数对象的长度。也可以理解为多态的一种使用。
面向对象的三个基本特征：封装，继承，多态。
面向的对象的属性：
- 静态属性
- 私有属性
- 实例属性
- 类属性(类变量)
- 动态属性(就是方法)
- 实例方法
- 私有方法--和私有属性一样是双下划线开始的，调用形式和私有属性一样，只能通过类中的方法调用