python的oop概述

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", "53")  
>>> 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",29)  #实例化一个对象
>>> a.pos = "singer"                #给对象添加一个pos属性
>>> a.pos                           #对象a具有pos属性
'singer'

>>> B = People("UKA","king",80)   #再实例化一个对象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()函数只是接受一个参数对象，然后返回这个参数对象的长度。也可以理解为多态的一种使用。