Python学习笔记07——面向对象编程

时间：2021-07-30 17:23:24

前言

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的 函数。

面向过程的程序设计 把 计算机程序 视为一系列的 命令集合，即一组函数的顺序执行。为简化程序设计，面向过程把函数继续切分为子函数。

面对对象的程序设计 把 计算机程序 视为一组 对象的集合，而每个对象都可以接收其他对象发来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。
假如要处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个dict表示：

>>> std1 = {'name':'Mojian', 'score':98}
>>> def print_score(std):
    print('%s: %s' % (std['name'], std['score']))

而处理学生成绩可以通过函数实现，比如打印学生成绩：

>>> print(std1)
{'score': 98, 'name': ‘Mojian'}

如果采用面向对象的程序设计思想，我们首先思考的不是程序的执行流程，而是student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。
如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。

class Student(object):

def __init__(self, name, score):
        self.name = name
        self.score = score

def print_score(self):
        print('%s: %s' % (self.name, self.score))

给对象发消息实际上就是调用对象对应的关联函数，称之为对象的方法（Method）。面向对象程序写出来就像这样：

>>> bart = Student('Bart Simpson', 81)
>>> bart.print_score()

类（Class）和实例（Instance）的概念是很自然的，Class是一种抽象概念，比如上面定义的Student，是指学生这个概念。而实例（Instance）则是一个个具体的Student，比如Bart Simpson是个具体的Student。
所以，面向对象的设计思想是抽象出Class，根据Class创建Instance。
面向对象的抽象程度要比函数高，因为Class既包含数据，又包含操作数据的方法。

类和实例

类是抽象的模版，而实例是根据类创建出来的一个具体的“对象”，每个对象都有相同的方法，但各自的数据可能不同。
在Python中，定义类是通过class关键字：

class Student(object):
pass

class后面紧接的是类名，即Student，类名通常是大写开头的单词，然后是(object)，表示类是从哪个类继承下来的，通常，没有合适的继承类，就是用object类，这是所有类最终都会继承的类。
定义好类后，就可以根据类创建出其实例，创建实例是通过 类名 加 （）实现的：

>>> bart = Student()
>>> bart
<__main__.Student object at 0x105598b00>
>>> Student
<class '__main__.Student'>

变量bart指向的是一个Student的实例，后面的0x105598b00是内存地址，每个object的地址都不一样，而Student本身则是一个类。
可以*地给一个实例变量绑定属性，如给实例bart 绑定一个name属性：

>>> bart.name = 'Bart Simpson'
>>> bart.name
'Bart Simpson’

由于类可以起到一个模版的作用，因此，可以在创建实例时，把一些必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法：

class Student(object):
def __init__(self, name, score):            #注意：init前后有两个下划线！
        self.name = self.name
        self.score = slf.score

__init__方法的第一个参数就是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需传，Python解释器自己会把实例变量传进去：

>>> bart = Student('Bart Simpson', 59)
>>> bart.name
'Bart Simpson’

在类中定义的函数第一个参数永远是实例变量self，并且调用时，不用传递该参数。除此外和普通函数没区别，故仍可以使用默认参数，可变参数，关键字参数及命名关键字参数。

数据封装
在上面的Student类中，每个实例就拥有各自的name和score这些数据。我们可以通过函数来访问这些数据，比如打印一个学生的成绩：

>>> bart = Student('Bart Simpson', 59)
>>>def print_score(std):
    print(‘%s: %s’ % (std.name, std.score))
>>>print_score(bart)
Bart Simpson: 59

既然Student实例本身就拥有这些数据，可以直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：

class Student(object):

def __init__(self, name, score):
        self.name = name
        self.score = score

def print_score(self):
        print('%s: %s' % (self.name, self.score))

要定义一个方法，除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需在实例变量上直接调用，除了self不用传递，其他参数正常传入：

>>>bart = Student('Bart permsion', 89)
>>> bart.print_score()
Bart permsion: 89

从外部看Student类，就只需知道，创建实例需给出name和score，如何打印都是在Student内部定义的，这些数据和逻辑都被“封装”起来了，调用很容易，但却不知道内部的实现的细节。
封装的另外一个好处是可以给Student类增加新方法，比如get_grade:

…..
def get_grade(self):
if self.score >= 90:
return 'A'
elif self.score >=60:
return 'B'
else:
return ‘C'

get_grade方法可以直接在实例变量上调用，不需要知道内部实现细节：

>>> bart.get_grade()
‘B'

小结：
类是创建实例的模版，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；
方法 就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；
通过在实例上调用 方法 ，我们就直接操作了对象内部的数据，但无需知道 方法 内部的实现细节
和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们是同一个类的不同实例，但拥有的变量名称都有可能不同。

访问限制

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__,在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。

class Student(object):
def __init__(self, name, score):
        self.__name = name
        self.__score = score
def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

改完后，对于外部代码来说，没什么变的，但是已经无法从外部访问 实例变量.__name 和 实例变量.__score 了。这样确保了外部代码不能随意修改对象内部的状态。

如果外部代码要获取name和score，可以给Student类增加get_name和get_score 方法：

…
def get_name(self):
return self.__name
def get_score(self):
return self.__score

如果要允许外部代码修改score，可以给Student类增加set_score 方法,另在 方法 中，可以对参数做检查，避免无效参数的输入：

…
def set_score(self, score):
if 0 <= score <= 100:
            self.__score = score
else:
raise ValueError('bad score’)

需注意，在Python中，变量名以双下划线开头和双下划线结尾的 __xxx__，是特殊变量。特殊变量可以直接访问，不是private变量，故不能用__name__,__score__这样的变量名。
以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，故仍可以通过_Student__name来访问__name变量。

>>> bart._Student__name
'Bart Simpson’

因为不同的Python版本会把__name改成不同的变量名，所以不建议这么做。

错误写法：

>>> bart = Student('Bart Simpson', 100)
>>> bart.get_name()
'Bart Simpson'
>>> bart.__name = 'New Name'
>>> bart.__name
'New Name'

表面上看，外部代码成功设置了__name变量，但实际上这个__name变量和class内部的__name变量不是一个变量：
内部的变量被Python解释器改为了_Student__name,而外部代码是新增了一个__name变量。

继承和多态

在OOP程序设计中，当我们定义一个class时，可以从某个现有的类（class）继承，新的class称为子类（Subclass），而被继承的class称为基类、父类、或超类（Base clas 、Superc class）。
继承最大的好处是Subclass获得了父类的全部功能，包括方法。另外也可以对Subclass增加一些方法（函数）：

class Animal(object):
def run(self):
        print('Animal is running...')

class Dog(Animal):
def run(self):
        print('Dog is running…')
def eat(self):
        print('Eating meat...')

继承的第二个好处就是多态：当Subcalss和父类都存在相同的方法时（如：run() ），子类的run()覆盖了父类的run()，在代码运行时，总会调用子类的run()。

当我们定义一个calss时，实际上就定义了一种数据类型，和Python自带的数据类型没什么不同。
判断一个变量是否是某个类型可以用isinstance()判断：
a = list() #a是list类型

>>>isinstance(a, list)
True

在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类，反之则不行。

新增一个Animal的子类，任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行，原因就在于多态。

因为Animal类型有run()方法，传入的任意类型，只要是Animal类或子类，就会自动调用实际类型的run()方法。
对于一个变量，我们只需知道它是Animal类型，无需确定它的子类型，就可以调用run()方法，而具体调用的run()方法的作用对象由运行时该对象的确切类型决定。
调用方只管调用，不管细节，当我们新增一种Animal等子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的，这就是著名的“开闭”原则：

对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

继承还可一级一级地继承下来。而任何类，最终都可以追溯到根类object，这些继承关系看上去就像一颗倒着的树。

静态语言 vs 动态语言
对于静态语言（如Java），如果需要传入Animal类型，传入的对象必须是Animal类型或者它的子类，否则将无法调用run()方法。
对于Python这样的动态语言，不一定需要传入Animal类型。只需保证传入的对象有一个run()方法就行：
class Timer(object):
def run(self):
print(’Start…’)

这就是动态语言的“鸭子特性”：不要去严格的继承体系，一个对象只要“走起来像鸭子，看起来像鸭子”，那它就可以被看成鸭子。
Python的“file-like object”就是一种鸭子类型。对真正的文件对象，它有一个read()方法，返回其内容。但是，许多对象，只要有read()方法，都被视为“file-like object”。

获取对象信息

使用type()
使用type()函数，来判断对象类型。基本类型都可以用type()判断。
一个变量指向函数或者类，也可以用type()判断：

>>> type(abs)
<class 'builtin_function_or_method’>

type()函数返回 对应的Class类型。如果要在if语句中判断，就需比较两个变量的type是否相同：

>>> type('abc') == str
True
>>> type('abc') ==type(123)
False

判断基本数据类型可以直接写int,str等，但要判断一个对象是否是函数，可以使用types模块中定义的量：

>>> import types
>>> def fn():
pass

>>> type(fn) == types.FunctionType
True
>>> type(abs) == types.BuiltinFunctionType
True
>>> type(lambda x: x) == types.LambdaType
True
>>> type((x for x in range(10))) == types.GeneratorType
True

使用isinstance()
要判断class的类型，可以使用isinstance()函数。
isinstance()判断的是：一个对象是否是该类型本身，或者位于该类型的父继承链上。
能用type()判断的也可以用isinstance()判断：

>>> isinstance('a', str)
True
>>> isinstance(123,int)
True
>>> isinstance(b'a', bytes)
True

还可以判断一个变量是否是某些类型中的一种，如下的代码可判断是否是list或tuple：

>>> isinstance([1, 2, 3], (list, tuple))
True
>>> isinstance((1, 2, 3), (list, tuple))
True

使用dir()
dir()函数可以获得一个对象的所有属性和方法，它返回一个包含字符串的list:
类似__xxx__的属性和方法在Python中都是有特殊用途的，比如__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数的内部，它自动去调用该对象的__len()__方法，故下面的代码是等价的：

>>> len('ABC')
3
>>> 'ABC'.__len__()
3

自己写的类，若也想用len(myObj)的话，就写一个__len__()方法：

>>> class MyDog(object):
def __len__(left):
return 100
>>> dog = MyDog()
>>> len(dog)
100

剩下的都是普通属性或方法，比如lower()返回小写的字符串：

>>>’ABC’.lower()
‘abc’

仅仅把属性和方法列出来是不行的，配合getattr()、setattr()、hasattr()，可以直接操作一个对象的状态：

>>> class MyObject(object):
def __init__(self):
        self.x = 9
def power(self):
return self.x * self.x
>>>obj = MyObject()

然后，可以测试对象的属性:

>>> hasattr(obj, 'x’) #obj有属性’x'吗？
True
>>> obj.x                    
9
>>> hasattr(obj,'y’) #有属性’y’吗？
False
>>> setattr(obj, 'y', 19) #设置一个属性’y’
>>> hasattr(obj, 'y’) #有属性’y’吗
True
>>> getattr(obj,'y’) #获取属性’y'
19
>>> obj.y                    #获取属性’y'
19

使用getattr()获取不存在的属性，会报AttributeError的错误。
可以传入一个default参数，如果属性不存在，就返回默认值：

>>> getattr(obj, 'z', 404)    # 获取属性’z’，不存在就返回默认值404
404

getattr()也可以返回 对象的 方法：

>>> hasattr(obj,'power’) #有属性’power’吗
True
>>> getattr(obj, 'power’)       #获取属性’power'
<bound method MyObject.power of <__main__.MyObject object at 0x105491d30>>
>>> fn = getattr(obj, 'power’)    #获取属性’power’并赋值到变量fn
>>> fn                            #fn指向obj.power
<bound method MyObject.power of <__main__.MyObject object at 0x105491d30>>
>>> fn() #调用fn()与调用obj.power()一样
81

小结
通过内置的一系列函数，可以对任意一个Python对象进行剖析，拿到其内部的数据。
注意：只有在不知道对象信息的情况下，才会去获取对象信息。
若可以写：

sum = obj.x + obj.y

就不要写：

sum = getattr(obj, ‘x’) + getattr(obj, ‘y’)

一个正确用法的例子如下：

def readImage(fp):
if hasattr(fp, 'read'):
return readData(fp)
return None

注意，在Python这类动态语言中，根据鸭子类型，有read()方法，不代表fp就是一个文件流，它也可能是网络流或内存中的一个字节流，但只要read()方法返回的是有效的图像数据，就不影响读取图像的功能。

实例属性和类属性

因为Python是动态语言，根据类创建的实例可以任意绑定属性。

class Styudent(object):
def __init__(self, name):
        self.name = name

给实例绑定属性的方法是通过实例或变量，或者通过self变量：

s = Student(‘Bob’)
s.score = 90

如果Student类本身需要绑定一个属性，可以直接在class中定义属性，这种属性是类属性，归Student类所有：

class Student(object):
    name = ’Student'

一个类属性可以被该类的所有实例访问到：

>>> class Student(object):
name = 'Student'

>>> s = Student()    #创建实例s
>>> print(s.name)    #打印name属性，因为实例没有name属性，所以会继续查找class的name属性
Student
>>> print(Student.name)    #打印类的name属性
Student
>>> s.name = 'Mojian’      #给实例绑定name属性
>>> print(s.name)          #由于实力属性优先级比类属性高，所以，它会屏蔽掉类的name属性
Mojian
>>> print(Student.name)    #但是类属性并没消失，用Student.name仍然可以访问
Student
>>> del s.name             #如果删除实例的name属性
>>> print(s.name)          #再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
Student

在编写程序时，千万不要把实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是删除这个实例属性后，再使用相同的名称，访问到的会是类属性。
标签：

相关文章