python学习笔记（四）——面向对象编程

python 支持面向过程编程和面向对象编程。

传统面向过程编程，也叫函数式编程，通过我们的需求设计成一个一个的函数来完成，对一些小规模程序来说面向过程确实简单方便不少。而随着互联网的发展，对于一些大型的项目来说，使用面向对象编程更具有优势，在后期的维护上也更加容易。

面向对象编程有三大特性：封装、继承、多态。

类的创建

class 类名(父类名称):
    类体

# 其中类体包括 类成员，方法，数据属性等
# object 是所有类的祖父类
# 类体也可以用 pass

简单类的组成

class per(object):
    "注释"                    #类文档字符串 '*' "*" """"*""
    var=1.1                   #类变量、类属性。成员变量
    def __init__(self):       #构造方法
        print("构造 ……")
    def __del__(self):        #析构方法
        print("析构 ……")
    def run(self):            #类成员方法
        print("run ……")

tmp=per()               #实例化对象
tmp.run()               #调用类对象方法
print(tmp.__doc__)      #打印注释字符串

输出:
构造 ……
run ……
注释
析构 ……

封装

主要是以类的方式将我们的需求抽象为实体后所共有的特性组成的集合，通过将属性与方法封装在一个对象中，只对外提供所需接口。是我们的程序结构、逻辑层次上更加清晰，便于程序的开发和后期维护。

类属性和实例属性

在python的类中，属性主要分为两种，一种是类属性，它直接分布在类中，不需要我们的实例就可以调用。

另一种是实例属性，实例属性只能依赖实例调用。

其中

• 实例属性和实例方法只能被该类的实例访问
• 类变量可以直接被类和类所创建的实例访问
• 类变量只能通过类去修改，不可以通过类的实例去修改

class per(object):
    var = 1.1			#类变量
    def run(self):
        print("runing ……")

tmp=per()				#实例1 tmp
tmp2=per()				#实例2 tmp2
print(per.var)			#直接通过类访问类变量
print(tmp.var,tmp2.var)	#通过实例1，实例2访问类变量
tmp.name = "张三"		#实例1 tmp.name
tmp2.age = 18			#实例2 tmp2.age
print(tmp.name)			#输出实例1 的name
print(tmp2.age)			#输出实例2 的age

输出:
1.1			#类变量 var 的值
1.1 1.1		#
张三			# tmp.name 的值
18			# tmp2.age 的值

实例拥有自己的空间，我们通过类外绑定属性的方式生成的实例属性不是所有实例（对象）所共有的，实例1不具有实例2的属性 age，实例2也不具有实例1的属性 name。同时类也拥有自己的空间，保存着类和对象所共有的属性 如 var，但是类不可以调用实例方法，如per.run() 就是不允许的。

只能通过类修改类变量。

print("var =",per.var)
per.var = 100
print("var =",per.var)

输出:
var = 1.1
var = 100

可以通过构造函数定义实例变量。其中通过 self 修饰就可以定义实例变量

class per(object):
    var = 1.1
    def __init__(self,myname,myage):
        self.name = myname  #name 实例属性
        self.age = myage    #age  实例属性
    def run(self):
        print("runing ……")

tmp=per("张三",18)				#实例1 tmp
tmp2=per("李四",20)				#实例2 tmp2
print(tmp.name,tmp.age)			#输出实例1 的name，age
print(tmp2.name,tmp2.age)		#输出实例2 的name，age

总结：

类属性，可以简单理解为定义在类方法外的属性。

实例属性，在__init__构造函数内定义的属性。

类属性可以直接用类名访问，修改，也可以用实例名访问，只读。并且，当实例访问类不存在的属性时，会在实例中新建属性

公有方法和私有方法

在python 中通过在实例属性或者实例方法前加上 __xx 会改变其对外方式，即被声明为私有模式。正常情况下所有实例属性默认为公有状态。

class per(object):
    var = 1.1
    def run(self):
        print("run ……")
    def __runing(self):
        print("runing ……")

tmp=per()				#实例 tmp
tmp.run()				#调用公有的实例方法
#tmp.runing()			#私有的实例方法不可以在类外访问
#tmp.__rining()			#

同样的，在实例变量例如 self.__name 是私有的实例变量，在类外也不可以访问。私有属性只可以在类内访问。

class per(object):
    __var = 1.1         #私有类属性
    def run(self):
        print("run ……","\nvar = ",self.__var)
    def __runing(self):
        print("runing ……")
    def getRuning(self):
        self.__runing()

tmp=per()				#实例 tmp
tmp.run()				#run() 方法内部访问私有属性
tmp.getRuning()			#使用对外接口访问私有方法

继承

class 类名(父类1.父类2 . . . )
	类体

子类继承父类的方法

设计 mylist类，继承我们的列表类

class mylist(list):
    pass

lst=mylist()
lst.append(11)
print(lst)

输出:
[11]

子类继承了父类的属性和方法。可以直接使用父类的方法，也可以对父类的方法进行再包装形成新的方法。

class mylist(list):
    def headinsert(self,val):
        """实现头部插入"""
        self.insert(0,val)

lst=mylist()
lst.append(11)
lst.headinsert(1)
print(lst)

输出:
[1,11]

子类重写父类方法

如果父类方法不能满足的需求，可以在子类重写父类的方法。在子类方法与父类方法重名时，会优先调用子类的方法。

class mylist(list):
    def headinsert(self,val):
        """实现头部插入"""
        self.insert(0,val)
    def copy(self):
        """重写list的copy方法"""
        print("this is mylist.copy")

lst=mylist()
lst.append(11)
lst.headinsert(1)
print(lst)
lst.copy()

输出:
[1, 11]
this is mylist.copy

扩展父类的方法

可以在子类中使用 super().xxx 调用父类的方法，比如我们想实现插入数据后提示 “ok” 的功能。

class mylist(list):
    def append(self,val):
        """扩展list的append方法"""
        super().append(val)
        print("ok")

lst=mylist()
lst.append(1)
lst.append(11)
print(lst)

输出:
ok
ok
[1, 11]

多继承

python中继承可以继承父类的构造函数，并且多继承是可以使用每个父类的方法的。

class  A():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def print_A(self):
        print(self.name,self.age)

class B():
    def print_B(self):
        print("this is B")

class C(A,B):
    """多继承"""
    pass

c=C("张三",18)
c.print_A()
c.print_B()

如果继承的父类中存在同名方法，会从左至右、深度优先搜索第一个方法名。比如

 A         B
C(A)      D(B)
    E(C,D)

在这种关系的继承中，调用一个名为 func() 的方法，会依次从 C、A、D、B中搜索对应方法名。

多态

简单来讲就是一种方法在调用时呈现出不同的状态（不同的功能）。前面也讲到了，在子类中存在同名方法会优先调用子类的方法。下面的 Dog类，Cat类均继承自 Animal类，我们通过调用 todo() 方法来实现一种多态的方式。

class Animal():
    def do(self):
        print("我是动物 ")

class Dog(Animal):
    def do(self):
        print("我是狗，汪~ ")

class Cat(Animal):
    def do(self):
        print("我是猫，咪~")

def todo(animal):
    animal.do()

a=Animal()
todo(a)
d=Dog()
todo(d)
c=Cat()
todo(c)

输出:
我是动物
我是狗，汪~
我是猫，咪~

todo()方法通过传入的参数类型不同，从而实现不同的功能，表现出多种状态。