当前位置:天才代写 > tutorial > Python教程 > Python中的把戏要领详解

Python中的把戏要领详解

2017-11-01 08:00 星期三 所属: Python教程 浏览:45

先容

  在Python中,所有以“__”双下划线包起来的要领,都统称为“Magic Method”,中文称『把戏要领』,譬喻类的初始化要领 __init__ ,Python中所有的把戏要领均在官方文档中有相应描写,可是对付官方的描写较量杂乱并且组织较量松散。很难找到有一个例子。

结构和初始化

  每个Pythoner都知道一个最根基的把戏要领, __init__ 。通过此要领我们可以界说一个工具的初始操纵。然而,当挪用 x = SomeClass() 的时候, __init__ 并不是第一个被挪用的要领。实际上,尚有一个叫做__new__ 的要领,两个配合组成了“结构函数”。

  __new__是用来建设类并返回这个类的实例, 而__init__只是将传入的参数来初始化该实例。

  在工具生命周期挪用竣事时,__del__ 要了解被挪用,可以将__del__领略为“构析函数”。下面通过代码的看一看这三个要领:

from os.path import join
class FileObject:
    '''给文件工具举办包装从而确认在删除时文件流封锁'''
    def __init__(self, filepath='~', filename='sample.txt'):
        #读写模式打开一个文件
        self.file = open(join(filepath, filename), 'r+')
    def __del__(self):
        self.file.close()
        del self.file

节制属性会见

  很多从其他语言转到Python的人会诉苦它缺乏类的真正封装。(没有步伐界说私有变量,然后界说民众的getter和setter)。Python其实可以通过把戏要领来完成封装。我们来看一下:

__getattr__(self, name):

  界说当用户试图获取一个不存在的属性时的行为。这合用于对普通拼写错误的获取和重定向,对获取一些不发起的属性时候给出告诫(假如你愿意你也可以计较而且给出一个值)可能处理惩罚一个 AttributeError 。只有当挪用不存在的属性的时候会被返回。

__setattr__(self, name, value):

  与__getattr__(self, name)差异,__setattr__ 是一个封装的办理方案。无论属性是否存在,它都答允你界说对对属性的赋值行为,觉得这你可以对属性的值举办本性定制。实现__setattr__时要制止"无限递归"的错误。

__delattr__:

  与 __setattr__ 沟通,可是成果是删除一个属性而不是配置他们。实现时也要防备无限递归现象产生。

__getattribute__(self, name):

  __getattribute__界说了你的属性被会见时的行为,对较量,__getattr__只有该属性不存在时才会起浸染。因此,在支持__getattribute__的Python版本,挪用__getattr__前肯定会挪用 __getattribute__。__getattribute__同样要制止"无限递归"的错误。需要提醒的是,最好不要实验去实现__getattribute__,因为很少见到这种做法,并且很容易出bug。

  在举办属性会见节制界说的时候很大概会很容易引起“无限递归”。如下面代码:

#  错误用法
def __setattr__(self, name, value):
    self.name = value
    # 每当属性被赋值的时候(如self.name = value), ``__setattr__()`` 会被挪用,这样就造成了递归挪用。
    # 这意味这会挪用 ``self.__setattr__('name', value)`` ,每次要了解挪用本身。这样会造成措施瓦解。
#  正确用法
def __setattr__(self, name, value):
    self.__dict__[name] = value  # 给类中的属性名分派值
    # 定制特有属性

Python的把戏要领很强大,可是用时却需要慎之又慎,相识正确的利用要领很是重要。

建设自界说容器

  有许多要领可以让你的Python类行为向内置容器范例一样,好比我们常用的list、dict、tuple、string等等。Python的容器范例分为可变范例(如list、dict)和不行变范例(如string、tuple),可变容器和不行变容器的区别在于,不行变容器一旦赋值后,不行对个中的某个元素举办修改。

  在讲建设自界说容器之前,应该先相识下协议。这里的协议跟其他语言中所谓的"接口"观念很像,它给你许多你必需界说的要领。然而在Python中的协议是很不正式的,不需要明晰声明实现。事实上,他们更像一种指南。

自界说容器的magic method

#p#分页标题#e#

  下面细致相识下界说容器大概用到的把戏要领。首先,实现不行变容器的话,你只能界说 __len__ 和 __getitem__ (下面会讲更多)。可变容器协议则需要所有不行变容器的所有,别的还需要 __setitem__ 和 __delitem__ 。假如你但愿你的工具是可迭代的话,你需要界说 __iter__ 会返回一个迭代器。迭代器必需遵循迭代器协议,需要有 __iter__(返回它自己) 和 next。

__len__(self):

  返回容器的长度。对付可变和不行变容器的协议,这都是个中的一部门。

__getitem__(self, key):

  界说当某一项被会见时,利用self[key]所发生的行为。这也是不行变容器和可变容器协议的一部门。假如键的范例错误将发生TypeError;假如key没有符合的值则发生KeyError。

__setitem__(self, key, value):

  当你执行self[key] = value时,挪用的是该要领。

__delitem__(self, key):

  界说当一个项目被删除时的行为(好比 del self[key])。这只是可变容器协议中的一部门。当利用一个无效的键时应该抛出适当的异常。

__iter__(self):

  返回一个容器迭代器,许多环境下会返回迭代器,尤其是当内置的iter()要领被挪用的时候,以及当利用for x in container:方法轮回的时候。迭代器是它们自己的工具,它们必需界说返回self的__iter__要领。

__reversed__(self):

  实现当reversed()被挪用时的行为。应该返回序列反转后的版本。仅当序列可以是有序的时候实现它,譬喻对付列表可能元组。

__contains__(self, item):

  界说了挪用in和not in来测试成员是否存在的时候所发生的行为。你大概会问为什么这个不是序列协议的一部门?因为当__contains__没有被界说的时候,假如没有界说,那么Python会迭代容器中的元素来一个一个较量,从而抉择返回True可能False。

__missing__(self, key):

  dict字典范例会有该要领,它界说了key假如在容器中找不到时触发的行为。好比d = {'a': 1}, 当你执行d[notexist]时,d.__missing__['notexist']就会被挪用。

实例

  下面是书中的例子,用把戏要领来实现Haskell语言中的一个数据布局。

# -*- coding: utf-8 -*-
class FunctionalList:
    ''' 实现了内置范例list的成果,并富厚了一些其他要领: head, tail, init, last, drop, take'''
    def __init__(self, values=None):
        if values is None:
            self.values = []
        else:
            self.values = values
    def __len__(self):
        return len(self.values)
    def __getitem__(self, key):
        return self.values[key]
    def __setitem__(self, key, value):
        self.values[key] = value
    def __delitem__(self, key):
        del self.values[key]
    def __iter__(self):
        return iter(self.values)
    def __reversed__(self):
        return FunctionalList(reversed(self.values))
    def append(self, value):
        self.values.append(value)
    def head(self):
        # 获取第一个元素
        return self.values[0]
    def tail(self):
        # 获取第一个元素之后的所有元素
        return self.values[1:]
    def init(self):
        # 获取最后一个元素之前的所有元素
        return self.values[:-1]
    def last(self):
        # 获取最后一个元素
        return self.values[-1]
    def drop(self, n):
        # 获取所有元素,除了前N个
        return self.values[n:]
    def take(self, n):
        # 获取前N个元素
        return self.values[:n]

  

  其实在collections模块中已经有了许多雷同的实现,好比Counter、OrderedDict等等。

反射

#p#分页标题#e#

  你也可以节制怎么利用内置在函数sisinstance()和issubclass()要领 反射界说把戏要领. 这个把戏要领是:

__instancecheck__(self, instance):

  查抄一个实例是不是你界说的类的实例

__subclasscheck__(self, subclass):

  查抄一个类是不是你界说的类的子类

  这些把戏要领的用例看起来很小, 而且确实很是实用. 它们回响了关于面向工具措施上一些重要的对象在Python上,而且总的来说Python: 老是一个简朴的要领去找某些工作, 纵然是没有须要的. 这些邪术要领大概看起来不是很有用, 可是一旦你需要它们,你会感想名誉它们的存在。

可挪用的工具

  你也许已经知道,在Python中,要领是第一流的工具。这意味着他们也可以被通报到要领中,就像其他工具一样。这是一个很是惊人的特性。

  在Python中,一个非凡的把戏要领可以让类的实例的行为表示的像函数一样,你可以挪用它们,将一个函数当做一个参数传到别的一个函数中等等。这是一个很是强大的特性,其让Python编程越发舒适甜美。

__call__(self, [args...]):

  答允一个类的实例像函数一样被挪用。实质上说,这意味着 x() 与 x.__call__() 是沟通的。留意 __call__ 的参数可变。这意味着你可以界说 __call__ 为其他你想要的函数,无论有几多个参数。

  __call__ 在那些类的实例常常改变状态的时候会很是有效。挪用这个实例是一种改变这个工具状态的直接和优雅的做法。用一个实例来表达最好不外了:

# -*- coding: UTF-8 -*-
class Entity:
    """
    挪用实体来改变实体的位置
    """
def __init__(self, size, x, y):
    self.x, self.y = x, y
    self.size = size
def __call__(self, x, y):
    """
    改变实体的位置
    """
    self.x, self.y = x, y

上下文打点

  with声明是从Python2.5开始引进的要害词。你应该遇过这样子的代码:

with open('foo.txt') as bar:
    # do something with bar

  在with声明的代码段中,我们可以做一些工具的开始操纵和退出操纵,还能对异常举办处理惩罚。这需要实现两个把戏要领: __enter__ 和 __exit__。

__enter__(self):

  界说了当利用with语句的时候,会话打点器在块被初始建设时要发生的行为。请留意,__enter__的返回值与with语句的方针可能as后的名字绑定。

__exit__(self, exception_type, exception_value, traceback):

  界说了当一个代码块被执行可能终止后,会话打点器应该做什么。它可以被用来处理惩罚异常、执行清理事情或做一些代码块执行完毕之后的日常事情。假如代码块执行乐成,exception_type,exception_value,和traceback将会为None。不然,你可以选择处理惩罚这个异常可能是直接交给用户处理惩罚。假如你想处理惩罚这个异常的话,请确保__exit__在所有语句竣事之后返回True。假如你想让异常被会话打点器处理惩罚的话,那么就让其发生该异常。

建设工具描写器

  描写器是通过获取、配置以及删除的时候被会见的类。虽然也可以改变其它的工具。描写器并不是独立的。相反,它意味着被一个所有者类持有。当建设面向工具的数据库可能类,内里含有彼此依赖的属相时,描写器将会很是有用。一种典范的利用要领是用差异的单元暗示同一个数值,可能暗示某个数据的附加属性。

  为了成为一个描写器,一个类必需至少有__get__,__set__,__delete__要领被实现:

__get__(self, instance, owner):

#p#分页标题#e#

界说了当描写器的值被取得的时候的行为。instance是拥有该描写器工具的一个实例。owner是拥有者自己

__set__(self, instance, value):

界说了当描写器的值被改变的时候的行为。instance是拥有该描写器类的一个实例。value是要配置的值。

__delete__(self, instance):

界说了当描写器的值被删除的时候的行为。instance是拥有该描写器工具的一个实例。

  下面是一个描写器的实例:单元转换。

# -*- coding: UTF-8 -*-
class Meter(object):
    """
    对付单元"米"的描写器
    """
    def __init__(self, value=0.0):
        self.value = float(value)
    def __get__(self, instance, owner):
        return self.value
    def __set__(self, instance, value):
        self.value = float(value)
class Foot(object):
    """
    对付单元"英尺"的描写器
    """
    def __get__(self, instance, owner):
        return instance.meter * 3.2808
    def __set__(self, instance, value):
        instance.meter = float(value) / 3.2808
class Distance(object):
    """
    用米和英寸来暗示两个描写器之间的间隔
    """
    meter = Meter(10)
    foot = Foot()
  利用时:
>>>d = Distance()
>>>print d.foot
>>>print d.meter
32.808
10.0

复制

  有时候,尤其是当你在处理惩罚可变工具时,你大概想要复制一个工具,然后对其做出一些改变而不但愿影响本来的工具。这就是Python的copy所发挥浸染的处所。

__copy__(self):

  界说了当对你的类的实例挪用copy.copy()时所发生的行为。copy.copy()返回了你的工具的一个浅拷贝——这意味着,当实例自己是一个新实例时,它的所有数据都被引用了——譬喻,当一个工具自己被复制了,它的数据仍然是被引用的(因此,对付浅拷贝中数据的变动仍然大概导致数据在原始工具的中的改变)。

__deepcopy__(self, memodict={}):

  界说了当对你的类的实例挪用copy.deepcopy()时所发生的行为。copy.deepcopy()返回了你的工具的一个深拷贝——工具和其数据都被拷贝了。memodict是对之前被拷贝的工具的一个缓存——这优化了拷贝进程而且阻止了对递归数据布局拷贝时的无限递归。当你想要举办对一个单独的属性举办深拷贝时,挪用copy.deepcopy(),并以memodict为第一个参数。

其他要领

用于较量的把戏要领

__cmp__(self, other)    是较量要领内里最根基的的邪术要领

__eq__(self, other) 界说相等标记的行为,==

__ne__(self,other)  界说不等标记的行为,!=

__lt__(self,other)  界说小于标记的行为,<

__gt__(self,other)  界说大于标记的行为,>

__le__(self,other)  界说小于便是标记的行为,<=

__ge__(self,other)  界说大于便是标记的行为,>=

数值计较的把戏要领

单目运算符和函数

__pos__(self)   实现一个取正数的操纵

__neg__(self)   实现一个取负数的操纵

__abs__(self)   实现一个内建的abs()函数的行为

__invert__(self)    实现一个取反操纵符(~操纵符)的行为

__round__(self, n)  实现一个内建的round()函数的行为

__floor__(self) 实现math.floor()的函数行为

__ceil__(self)  实现math.ceil()的函数行为

__trunc__(self) 实现math.trunc()的函数行为

双目运算符或函数

__add__(self, other)    实现一个加法

__sub__(self, other)    实现一个减法

__mul__(self, other)    实现一个乘法

__floordiv__(self, other)   实现一个“//”操纵符发生的整除操纵()

__div__(self, other)    实现一个“/”操纵符代表的除法操纵

__truediv__(self, other)    实现真实除法

__mod__(self, other)    实现一个“%”操纵符代表的取模操纵

__divmod__(self, other) 实现一个内建函数divmod()

__pow__ 实现一个指数操纵(“**”操纵符)的行为

__lshift__(self, other) 实现一个位左移操纵(<<)的成果

__rshift__(self, other) 实现一个位右移操纵(>>)的成果

__and__(self, other)    实现一个按位举办与操纵(&)的行为

__or__(self, other) 实现一个按位举办或操纵的行为

__xor__(self, other)    __xor__(self, other)

增量运算

__iadd__(self, other)   加法赋值

__isub__(self, other)   减法赋值

__imul__(self, other)   乘法赋值

__ifloordiv__(self, other)  整除赋值,地板除,相当于 //= 运算符

__idiv__(self, other)   除法赋值,相当于 /= 运算符

__itruediv__(self, other)   真除赋值

__imod_(self, other)    模赋值,相当于 %= 运算符

__ipow__    乘方赋值,相当于 **= 运算符

__ilshift__(self, other)    左移赋值,相当于 <<= 运算符

__irshift__(self, other)    左移赋值,相当于 >>= 运算符

__iand__(self, other)   与赋值,相当于 &= 运算符

__ior__(self, other)    或赋值

__ixor__(self, other)   异或运算符,相当于 ^= 运算符

范例转换

__int__(self)   转换成整型

__long__(self)  转换生长整型

__float__(self) 转换成浮点型

__complex__(self)   转换成 复数型

__oct__(self)   转换成八进制

__hex__(self)   转换成十六进制

__index__(self) 假如你界说了一个大概被用来做切片操纵的数值型,你就应该界说__index__

__trunc__(self) 当 math.trunc(self) 利用时被挪用__trunc__返回自身范例的整型截取

__coerce__(self, other) 执行殽杂范例的运算

发送
用户评级
0 (0 票)
评论评分 0 (0 人点评)
 

    关键字:


天才代写-代写联系方式