Property and Iterator

[eziceice]

构造函数

• 在Python3中将不会存在旧式类,所有的类都将隐式地继承object.

• __init__是Python中的构造函数,它将会在函数创建后被自动调用.

class Test:
    def __init__(self, value=42):
        print('12345',value)

t = Test('kkk') #输出12345 kkk

• 析构函数(destructor)的方法在Python中也被提供了,这个方法可以在对象被销毁前调用,但需要准确的知道调用时间,否则容易引起错误.

class Test:
    def __init__(self, value=42):
        print('12345',value)
    def __del__(self):
        print('123456')
t = Test('kkk') #输出12345 kkk 123456 - 说明t被销毁了

• 覆盖重写子类的constructor的时候,必须先调用超类的constructor,否则有可能无法正确地初始化. 通常是使用super()方法,不过对于一些老版本的Python代码,也可以直接调用超类的constructor.

class Bird:
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            self.hungry = False
            print('I am Full now')
        else:
            print('I am not hungry')

class SongBird(Bird):
    def __init__(self):
        super().__init__()
        # Bird.__init__(self) 旧版方法-通过类调用方法,就不会有实例与其相关联,因此便可以随意设置参数self.
        # 这种方法调用的模式称为未关联方法调用.
s = SongBird()
s.eat()
s.eat()

• 使用super()方法的优点是显而易见的. 即使一个类有多个超类,也只需要调用super()一次(条件是所有超类的构造函数也使用super).同时,super()将返回一个超类的对象(类似于包含所有超类的合集的对象),当你尝试去访问super()返回的对象的某个属性或者方法时,Python将会在所有的超类中进行查找,直到找到该属性或者引发AttributeError异常.

[eziceice]

元素访问

• 在Python中,协议(protocol)通常指的是规范行为的规则,其指定应实现哪些方法以及这些方法应该做什么(类似于Java中的接口). 只要该类实现了某种协议,便可以遵从该种协议具有一系列相同的行为.

• list和dict基本上都是item的集合,要实现它们的基本协议,不可变对象需要实现2个方法,而可变对象需要实现4个方法.

  1. __len__(self): 集合包含的项数,对序列来说为元素的个数,对映射来说是键值对的数量.
  2. __getitem__(self, key): 返回对应的值,根据序列位置对应的元素或者dict的key.
  3. __setitem__(self, key, value): 添加元素,根据序列的位置或者dict的键值对. - 只有可变对象需要
  4. __delitem__(self, key): 删除元素,根据提供的key或序列的位置. - 只有可变对象需要

def check_index(key):
    if not isinstance(key, int):
        raise TypeError
    if key < 0:
        raise IndexError

class ArithmeticSequence:
    def __init__(self, start = 0, step = 1):
        self.start = start
        self.step = step
        self.changed = {}

    def __getitem__(self, key):
        check_index(key)
        try:
            return self.changed[key]
        except KeyError:
            return self.start + key * self.step

    def __setitem__(self, key, value):
        check_index(key)
        self.changed[key] = value
s = ArithmeticSequence()
#以上的类建立之后可以使用s[0], s[1]来访问元素,类似list或者dict的行为

• 有时候需要重写的方法太多,工作量很大,而如果仅仅是想实现list或者dict的行为,可以直接使用继承.

class CouterList(list):
    def __init__(self, *args):
        super().__init__(*args)
        self.counter = 0
    def __getitem__(self, index):
        self.counter += 1
        return super().__getitem__(index)

[eziceice]

Property - 特性

• property()函数可以将一个类中通过计算的值很容易的通过instance.field的表现形式进行获取. property()函数只可以运用于新式类,否则setter可能会不正常,getter依然可以正常运行.

class Rectangle:
    def __init__(self):
        self.width = 10
        self.height = 5
    def set_size(self, size):
        self.width, self.height = size
    def get_size(self):
        return self.width, self.height
    size = property(get_size,set_size) #getter在前,setter在后

r = Rectangle()
print(r.width)
print(r.height)
print(r.size)

r.size = (200,300)
print(r.width)
print(r.height)
print(r.size)

• property()函数可以不指定参数到指定一个参数/两个/三个/四个参数.如果没有指定参数,则特性不可读也不可写,一个参数(getter)只可以读.第三个参数可选的,为删除属性的方法.第四个参数也是可选的,指定一个文档字符串. property()参数的名字分别为fget, fset, fdel和doc. 如果需要创建一个只可写并且带文档的property,只需要使用以上关键字参数即可.

[eziceice]

静态方法和类成员方法

• 静态方法和类成员方法分别在创建时被装入staticmethod类型和classmethod类型的对象中.静态方法的定义没有self参数,且能够被类本身直接调用.类方法在定义时需要名为cls的类似于self的参数,类成员方法可以直接用类的具体对象调用-但cls参数是自动绑定到类的. 可以使用annotation直接绑定静态方法或者class方法.

class MyClass:
    @staticmethod
    def smeth():
        print('this is a static method')
    @classmethod
    def cmeth(cls):
        print('this is a class method')
MyClass.smeth()
MyClass.cmeth()

• Intercept(拦截)是指对对象的访问特性访问的时候进行一定的规则并且得到一系列处理后的值(不再是简单的获取想要的值).常用的拦截方法为:

  1. __getattribute__(self, name):当特性name被访问时自动被调用.(只能在新式类中使用)
  2. __getattr__(self, name):当特性name被访问时且对象没有相应的property时被自动调用.
  3. __setattr__(self, name, value): 当试图给特性name赋值时会被自动调用.
  4. __delattr__(self, name): 当试图删除特性name时被自动调用.

尽量避免在getattribute, getattr和setattr中使用self,会让程序产生死循环.在使用setattr是注意使用特殊方法__dict__,该特殊方法包含一个字典,字典里是所有实例的属性.在使用getattribute时,会拦截所有特性的访问,同时也拦截对__dict__的访问,因此安全的做法是访问super().getattribute(*args)方法

class People:
    def __init__(self, age, name):
        self.age = age
        self.name = name

    def __getattribute__(self, obj):
        if obj == 'age':
            print("被询问了年龄:")
            return super().__getattribute__(obj) #使用超类的getattribute方法,避免死循环
        elif obj == 'name':
            print('被询问了名字')
            return super().__getattribute__(obj)
        else:
            return super().__getattribute__(obj)
     def __setattr__(self, obj, value):
         if obj == 'size':
            self.age, self. name = value
         else:
            self.__dict__[obj] = value #避免死循环,将不为同名的键值对放入字典中

p = People(17, 'Test')
print(p.age)
print(p.name)

[eziceice]

迭代器 - Iterator

• __iter__返回一个迭代器,它是包含方法__next__的对象,调用这个方法是可以不提供参数.当调用next方法时,迭代器返回其下一个值.如果迭代器没有提供可返回的值,应引发StopIteration异常. 如果只想每次获取一个值,那么使用iterator比使用列表方便,因为使用列表你需要一次性初始化所有的值,占用内存较多.如果需要获取的值为无穷大的,list更加无法使用.

class Fibs:
    def __init__(self):
        self.a = 0
        self.b = 1
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        return self.a
    def __iter__(self):
        return self

• 比较正式的说法是,一个实现了__iter__()的对象是可迭代的,一个实现了next方法的对象则是迭代器. iter方法和next方法通常需要一起实现的.否则并不能进行迭代.

#内置函数iter()也可以在可迭代对象中获得迭代器
it = iter([1,2,3])

• 序列和可迭代对象基本可以互相转换. 在大部分情况下,两者可以互相替换.

class TestIterator:
    value = 0
    def __next__(self):
        self.value += 1
        if self.value > 10:
            raise StopIteration
        return self.value
    def __iter__(self):
        return self

t = TestIterator()
print(list(t))

[eziceice]

生成器 - Generator

• 任何包含yield语句的函数被称为生成器.yield和普通函数的区别是它不像return那样返回值,而是每次产生多个值.每次使用yield语句,函数就会被冻结:即函数停在那点等待被重新唤醒,函数被重新唤醒后就从停止的那点开始执行.

def flatten(nested):
    for sublist in nested:
        for element in sublist:
            yield element

nested = [[1,2],[3,4],[5]]
for num in flatten(nested):
    print(num)

• 在python中,对字符串进行迭代实际上会导致无穷递归,因为一个字符串的第一个元素是另一个长度为1的字符串,而长度为1的字符串的第一个元素就是字符串本身.

def flatten(nested):
    try:
        try:
            nested + '' #其他类型和字符串相加会报错-python特性
        except TypeError:
            pass
        else:
            raise TypeError('No String')
        for sublist in nested:
            for element in flatten(sublist):
                yield element
    except TypeError:
        yield nested

• 生成器是一个包含yield关键字的函数.当它被调用时,在函数体中的代码不会被执行,而会返回一个迭代器.每次请求一个值,就会执行生成器中的代码,直到遇到一个yield或者return语句,yield语句意味着应该生成一个值,而return语句意味着生成器停止执行. 换句话说,生成器是有两部分组成的-生成器的函数和生成器的迭代器.生成器的函数是用def语句定义的,包含yield部分,生成器的迭代器是这个函数的返回的部分.

def simplegenerator():
    yield print(1)

print(simplegenerator()) #<generator object simplegenerator at 0x104574eb8> 调用返回迭代器
for i in simplegenerator(): #当迭代器被使用时,代码会被执行,同时yield将会被记录位置
    pass

• 生成器方法 基本上来说就是一个方法如果有yield函数,调用时首先只返回一个生成器(可迭代),使用next函数时开始执行函数体,遇到yield返回.下一次执行函数体(需要调用next或者send方法)时从上一次执行的yield处可是继续执行,直到遇到下一个yield或者代码执行完毕.

  • 外部作用域访问生成器的send方法,就像访问next方法一样,只不过send方法需要提供一个参数(要发送的消息,可以是任意对象).

  • 在内部则挂起生成器, yield现在作为表达式而不是语句使用,换句话说,当生成器重新运行的时候,yield方法返回一个值.也就是外部通过send方法发送的值.如果next方法被使用,那么yield方法返回None.

  • 注意,使用send方法只有在生成器挂起之后才有意义(也就是说yield函数第一次被执行之后).如果在此前需要给生成器提供更多信息,那么只需要使用生成器函数的参数即可.

def repeater(value):
    while True:
        new = (yield value) # 使用yield返回值当做语句时,请务必添加括号
        if new is not None:
            value = new

r = repeater(50) #获得生成器(可迭代)
print(r.send(None)) #发送None可以获得默认值,通常为参数
print(r) #生成器对象
print(r.__next__()) #在yield处停止,返回value
print(r.send('hello')) #从上一个yield处开始执行,遇到yield然后返回hello
                       #此处是一个infinite loop因此必须在下一个yield处停止

• 生成器还包含另外两个方法, throw()和close().

  1. throw(): 用于在生成器中(yield表达式处)引发异常,调用时可以提供一个异常类型,一个可选值和一个traceback对象.
  2. close(): 用于停止生成器,调用时无需提供任何参数 - 该方法实际上也是基于异常的,在yield处引发GeneratorExit的异常.因此如果要在生成器中提供一些清理代码,可以将yield放在一条try/finally语句中. 调用close()后如果再次试图从generator获取值将会获得RuntimeError异常.

[eziceice]

八皇后 - Generator

• 首先,使用tuple或者list来表示当前皇后的状态. state[0] = 3表示第一个皇后的位置位于第一行第四列.

def conflict(state, nextX):
    nextY = len(state)
    for i in range(nextY):
        '''
           判断新增加的皇后和之前的是否冲突:
           冲突条件1: 在同一行 state[i] = state[nextX]
           冲突条件2: 在同一对角线 abs(state[i] - state[nextX]) = nextX - i
        '''
        if state[i] == state[nextX] or abs(state[i] - state[nextX]) == nextX - i:
            return True
    return False

#如果只剩下一个皇后没有位置,遍历所有可能的位置并且返回最后皇后可以放得位置.
def queens(num, state):
    if len(state) == num - 1:
        for pos in range(num):
            if not conflict(state, pos):
                yield pos

• 递归解法 - 程序从前面的皇后得到了包含位置信息的元组,并且要为后面的皇后提供当前皇后的每种合法的位置信息.

def queensrecurision(num=8,state=()):
    for pos in range(num):
        if not conflict(state, pos):
            if len(state) == num - 1:
                yield (pos,)
            else:
                #将当前皇后可能的位置传给下一个皇后
                for result in queensrecurision(num, state + (pos,)):
                    yield (pos,) + result

[eziceice]

总结

• property()方法可以将内部方法获取的值转换为在外界调用时类的内部的属性.

• 构造方法__init()__.

• 实现list或者dict只需要在类中定义__getitem__和__setitem__特殊方法,或者直接继承list和dict.

• 迭代器需要在类中实现__next__和__iter__方法. 迭代器可以在循环语句中使用.

• 生成器是指包含yield函数的类,注意生成器中代码的运行顺序. 单纯调用生成器只会获得生成器的instance, 需调用next或者send方法来使生成器类运行.生成器类运行时会运行至yield然后暂停函数,下次执行时会从上一个yield处继续.