Python学习笔记——OOP

Posted 2020-06-30 hermanncain

模块

使用模块import 模块名。有的只导入了某个模块的一个类或者函数，使用from 模块名 import 函数或类名实现。为了避免模块名冲突，Python引入了按目录来组织模块的方法，称为包（Package）。则在a目录下的b.py模块名就是a.b。a目录下必须有一个文件__ini__.py，哪怕是文件内容是空。否则a就成了普通目录。

标准模块文件模板：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

‘a test module‘ #任何模块的第一个字符串都被视为模块的文档注释

__author__ = ‘Your Name‘

...
def f():
...

if __name__ == ‘__main__‘:  #从其他地方导入模块，if不会通过。因此可以用来在命令行下进行测试
    f()

• 模块中的非公开函数前缀_，如def _private_1():
• 可以被直接引用的特殊变量一般用__argname__这种前后各两个下划线的形式来表示，自己定义的公开函数或变量一般就用普通的形式def f，不用这种下划线形式。
• 需要注意的是，Python并没有一种方法可以完全限制访问private函数或变量。因此这个得靠自觉了

第三方模块可以使用pip安装pip install numpy，它会从python的官方网站自动下载和安装。也可以自己下载下来之后安装。

面向对象编程

类语法

class Student(object):
    pass

object是默认父类名称。实例的创建使用tom = Student()。作为动态语言，Python支持自由给tom绑定类外的新属性tom.name = ‘Tom‘。如果有需要在创建实例时绑定的属性，一般写在类中的__ini__函数中：

def __ini__(self, arg1, arg2):
    self.__arg1 = ...
    self.arg2 = ...

__ini__的第一个参数永远是self，会自动传入。有了这样的__ini__，创建实例时就需要传入arg1和arg2参数。__arg1的两个前下划线表明这是一个私有属性，不能被外部访问。

鸭子类型：只要看起来像鸭子，跑起来像鸭子，那就可以看做鸭子

Python的动态性也体现在继承的上。假设有个函数中调用了某类的方法，只要传入的对象也有这个方法，都可以执行，而和这个对象是不是该类或该类子类的实例无关。

获取对象信息

• 获取对象的信息可以使用type()，同时如果import types，还可以使用type(对象) == types.type模块中的常量函数类型来判断一个对象是否是某种具体函数类型。

• isinstance(对象，类)的判断方法则如果该对象是参数中类的父类也返回True。能用type判断的基本类型都可以使用isinstance，第二个参数也可以是个list，只要满足是元素之一就返回True。

• dir()可以将一个对象的所有属性和方法都返回

• 当不知道对象细节时，可以使用hasattr(obj, ‘arg‘)得到obj是否有arg属性或方法；getattr(obj, ‘arg‘)返回属性或方法；setattr(obj, ‘arg‘, value)设置属性或方法（没有则直接增加）

面向对象高级编程

使用__slots__

因为Python是动态语言，因此可以随意为类、实例绑定属性或者方法。绑定方法要用到from types import MethodType，s.f = MethodType(f, s)将方法f绑定到类或实例s上。同时要注意f的第一个参数要是self才能绑定。

如果想要限制实例的属性，就需要在定义类的时候定义一个特殊变量__slots__ = (‘name1‘,‘name2‘)来限定给实例绑定的属性名只能是name1或者name2。

辨析：

from types import MethodType

class Student(object):
    __slots__ = (‘name‘, ‘sex‘, ‘set_name‘, ‘set_grade‘)
#允许绑定的在下文中称为内方法和内属性。反之称为外方法和外属性#

#内方法中绑定内属性
def set_name(self, name):
    self.name = name

#内方法中绑定外属性#
def set_grade(self, grade):
    self.grade = grade

#外方法中绑定外属性#
def set_score(self, score):
    self.score = score

#外方法中绑定内属性#
def set_sex(self, sex):
    self.sex = sex

tom = Student()
jane = Student()

（1）给实例绑定属性：

tom.name = ‘Tom‘    #正确，name是内属性
jane.grade = 98    #错误，grade是外属性，不能绑定
print(jane.name)    #错误，没有定义实例jane的name

#第三句可见实例绑定的属性只算各个实例自己的

（2）给类绑定属性：

Student.name = ‘name‘    #内属性可以绑定
Student.grade = 0    #外属性也可以绑定，可见__slots__只作用于实例

tom.name = ‘Tom‘    #错误，可见通过这种方法绑定的属性到实例中为只读
print(jane.name)    #输出为name

（3）给实例绑定方法：

tom.set_name = MethodType(set_name, tom)    #内方法，其中绑定内属性
tom.set_grade = MethodType(set_name, tom)    #内方法，其中绑定外属性，调用方法时会报错
tom.set_score = MethodType(set_score, tom)    #外方法，不可绑定
tom.set_sex = MethodType(set_name, tom)    #外方法，不可绑定

（4）给类绑定方法

#绑定内方法
Student.set_name = MethodType(set_name, Student)

tom.name = ‘Tom‘
print(jane.name)    #报错，可见在调用方法绑定内属性之前，“实例.属性 =”其实回到了第一种辨析的情况

tom.set_name(‘Tom‘)
jane.set_name(‘Jane‘)    #调用内方法，才将内属性绑定到了类
tom.name = ‘Tom‘    #报错，可见上一句绑定的属性和（3）中相同，只读。只能通过类方法修改
print(jane.name)
print(tom.name)    #输出也是Jane，可见通过类方法修改的属性是类属性，各实例的对应属性都是最后一次调用类方法之后的属性值


#绑定内方法，其中绑定外属性
Student.set_grade = MethodType(set_grade, Student)
tom.set_grade(4)    #调用方法绑定了外属性
tom.grade = 4    #类属性只读，不可直接修改
print(tom.grade)    #实例拥有了外属性，不过是类属性，只读，只能通过类方法修改

剩下的两种情况不再赘述，因为__slots__不限制类，因此任何方法和属性都可以被绑定。只不过通过调用方法绑定的属性是只读的，只能通过调用方法修改，不能在实例中直接使用.赋值修改通过以上辨析，总结如下：

__slots__只限制实例的方法或属性绑定，不限制类。对类绑定的方法和属性都可以在实例中调用，但类属性在实例中是只读的，它的值为最后一次调用方法或通过类.属性=赋值的结果，不能在实例中用实例.属性=修改。

使用@property

当需要修改属性时，为了能够检查参数，一般调用方法来设置属性值。但这样的话就略显麻烦。这时候@property装饰器就起作用了。

@property
def name(self):
    return self._name

@name.setter #如果不用下面的部分，则name就变成了只读属性
def name(self,value):
    ...类型检查等
    self._name = value

注意属性_name一定要有下划线来区分属性和方法，否则名字相同变成了方法，上面的代码就成了递归，会报现递归次数溢出错误

多重继承

如果继承的多个父类都有相同的方法，则以第一个为准，后面几个父类的该方法不会起作用。

定制类

诸如__slots__这种两端都有两个下划线的变量或者函数是有特殊用途的，因此可以通过定义这类对象来对类进行定制

__str__(self)：当执行print(类）时，程序会打印出属性和内存地址，如果想要打印出特定的内容，则可以定义一个__str__方法，输出特定的内容。如果不用print而是直接调用类名输出信息，则需要定义__repr__()方法，简单的一种定义方法就是__repr__ = __str__快速定义。

__iter__(self)：如果想要迭代一个类则需要定义__iter__方法返回self，然后再定义一个__next__(self)方法执行迭代中要做的事情

__getitem__(self, n)：把类变成像list那样可以按下标取元素操作。在__getitem__下返回元素值。如果要实现切片等功能，还要再对这个函数进行进一步的细化，比如判断传入的参数是否是slice等一系列后续操作。同样地，将类变为像dict那样，使用__setitem__。使用__delitem__删除元素。以上的这些方法将类变成list或dict的“鸭子”，使类可以像list或dict那样操作。

__getattr__(self, attr)：返回动态属性或方法。这个函数下边对attr进行判断，从而绑定规定的属性或者方法。绑定属性返回属性值，绑定方法则返回lambda函数。如果没有任何限制，显然任何属性或方法都可以绑定，这时候如果返回自身，则就实现了链式调用。利用这一点构造一个针对不同API的SDK。以下的代码就实现了一个GitHub的API的URL输出：

class Chain(object):

    def __init__(self, path =‘‘):
        self._path = path

    def __getattr__(self, path):
        return Chain(‘%s/%s‘ %(self._path, path))

    def __call__(self,name):
        return Chain(‘%s/:%s‘ %(self._path, name))

    def __str__(self):
        return ‘GET ‘ + self._path        

print(Chain().users(‘hermanncain‘).repos)

#输出为GET /users/:hermanncain/repos

__call__(self)：调用实例自身。即调用s()时执行__call__(self)。也可以使用__call__(self, *args, **kw)来传递参数，则调用s(*args, *kw)时执行其中的内容。这样模糊了类和实例的界限。

枚举类

from enum import Enum

Month = Enum(‘Month‘, (‘Jan‘, ‘Feb‘, ‘Mar‘, ‘Apr‘, ‘May‘, ‘Jun‘, ‘Jul‘, ‘Aug‘, ‘Sep‘, 

‘Oct‘, ‘Nov‘, ‘Dec‘))

for name, member in Month.__member__.items():
    print(name, ‘=>‘, member, ‘,‘, member.value)

value为枚举成员对应的int值，默认从1开始

另一种从Enum派生的自定义枚举类，语法就和C++中的枚举类型有些像了：

from enum import Enum, unique

@unique
class Weekday(Enum):
    Sun = 0
    Mon = 1
    ...

@unique装饰器用于检查重复值。

对枚举类的成员有以下几种引用方法：

print(Weekday.Sun)
print(Weekday[‘Sun‘])
print(Weekday(1))
#以上的输出都是Weekday.Sun

print(Weekday.Sun.value)
#输出0

元类*

使用type()创建类

动态语言的函数和类的定义是在运行时动态创建的。写一个a.py的模块，在模块里定义class A，然后在主程序中from a import A，载入模块时执行模块所有语句，结果就是动态创建出一个A的class。type(A)返回值是type，type(A的实例)的返回值则是class ‘__main__‘.A。但是type()也可以用于动态创建类。实际上Python解释器遇到class定义时，也是使用type()动态地将该类创建出来的：

def f(self, ...):
    ...

A = type(‘A‘, (object,), dict(af = f)

这样就动态创建了一个A类，父类是object（注意多重继承父类放在tuple里，如果只有一个父类则tuple只有一个元素，逗号不可少），并且有一个名为af的方法。

metaclass元类*

类相当于元类的实例。metaclass是Python面向对象里最难理解，也是最难使用的魔术代码，一般用不到

*这部分内容先略过，等到用到的时候根据实例来整理