Fluent Python | 函数装饰器、迭代器和生成器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import time
from clockedeco import clock
from functools import lru_cache


@clock
def snooze(seconds):
    time.sleep(seconds)

    
    
#@clock    
#def factorial(n):
#    return 1 if n < 2 else factorial(n-1)

def factorial(n):
    return 1 if n < 2 else factorial(n-1)
factorial = clock(factorial)

@lru_cache()
@clock
def fibonacci(n):
    if n < 2 :
        return n
    else:
        return fibonacci(n-2) + fibonacci(n-1)

if __name__ == '__main__':
#    print('*' * 40, 'Calling snooze(.123)')
#    snooze(.123)                                # 此时调用的已经是被装饰过的函数
#    print('*' * 40, 'Calling factorial(6)')
#    print('6!=', factorial(6))
    print(fibonacci(6))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
registry = []

# 定义装饰器
def register(func):
    print('running register(%s)' % func)
    registry.append(func)
    return func

# 定义被装饰的函数
@register
def f1():
    print('running f1()')

def f3():
    print('runing f3()')

def main():
    print('running main()')
    print('registry->', registry)
    f1()    # 调用被装饰的函数
    f3()

if __name__ == '__main__':
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from functools import singledispatch
from collections import abc
import numbers
import html

@singledispatch
def htmlize(obj):
    """处理Object类型的基函数"""
    content = html.escape(repr(obj))
    return '<pre>{}</pre>'.format(content)

# 以下各个专门函数使用@《base_function》.register()装饰
@htmlize.register(str)
def _(text):    # 专门函数的名称无关紧要
    content = html.escape(text).replace('n', '<br>n')
    return '<p>{0}</p>'.format(content)

@htmlize.register(numbers.Integral)
def _(n):
    return '<pre>{0} (0x{0:x})</pre>'.format(n)
    
@htmlize.register(tuple)
@htmlize.register(abc.MutableSequence)
def _(seq):
    inner = '</li>n<li>'.join(htmlize(item) for item in seq)
    return '<ul>n<li>' + inner + '</li>n</ul>'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import re                   # 使Python具有正则表达式功能
import reprlib

RE_WORD = re.compile('w+') # 用于匹配一个或者多个 字母、数字、下划线
class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)  # 返回正则表达式非重叠匹配的字符串列表
         
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text) # 生成简略字符串表示形式
    
    def __iter__(self):
        return SentenceIterator(self.words) # 实例化并返回迭代器



class SentenceIterator:
    def __init__(self, words):
        self.words = words
        self.index = 0
    
    def __next__(self):
        try:
            word = self.words[self.index]
        except IndexError:
            raise StopIteration()
        self.index += 1
        return word
    
    def __iter__(self):
        return self                         # 返回迭代器对象本身

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import re                   # 使Python具有正则表达式功能
import reprlib

RE_WORD = re.compile('w+') # 用于匹配一个或者多个 字母、数字、下划线
class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)  # 返回正则表达式非重叠匹配的字符串列表
         
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text) # 生成简略字符串表示形式
    
    def __iter__(self):     # 使用了yield关键字-->生成器函数
        for word in self.words:
            yield word
        return

1
2
3
4
5
6
7
8
9
10
11
# 生成器函数
def gen_AB():
    print('start')
    yield 'A'
    print('continue')
    yield 'B'
    print('end')

for c in gen_AB():
    print('-->', c)

1
2
3
4
5
6
7
8
9
10
# 生成器表达式和列表推导
# 列表推导-->迫切迭代gen_AB()生成的生成器对象产出的元素
res1 = [x*3 for x in gen_AB()]
print(res1)

# 生成器表达式-->生成器对象 这里gen_AB()并没有真正执行
res2 = (x*3 for x in gen_AB())
for i in res2:      # for 循环迭代隐式调用next(res2),gen_AB()才会真正执行
    print('-->', i)