流畅的python笔记

#使用鸭子类型处理单个字符串或由字符串组成的可迭代对象
try:
    field_names = field_names.replace(',',' ').split()
except AttributeError:
    pass
field_names = tuple(field_names)

#将字符串转化成对应的ascll字符
symbols = 'abcdef'
#列表推导
codes = [ord(symbol) for symbol in symbols]
#列表生成
codes = tuplle(ord(symbol) for symbol in symbols)

#将列表转化为字典
DIAL_CODES = [(86,'CHINA'),(91,'INDIA'),(1,'UNITED STATE')]
country_code = {country:code for code,country in DIAL_CODES}

#把编码在32～255之间的字符的名字里有”SIGN“单词的挑出来，放在一个集合中
{chr(i) for i in range(32,256) if 'SIGN' in name(chr(i),'')}

fruits = ['grape','raspberry','apple','banana']

#list.sort方法
fruits.sort(key=len,reverse=False)

#内置的sorted方法
sorted(fruits,key=len)

#bisect(haystack, needle)：在haystack（干草垛）中搜索needle（针）的位置
import bisect
HAYSTACK = [1,4,5,6,7,12,20,21,23,26,29,30]
NEEDLES = [0,1,2,5,8,10,22,23,29,30,31]

ROW_FMT = '{0:2d} {1:2d}	{2}{0:<2d}'
for needle in reversed(NEEDLES):
    position = bisect(HAYSTACK,needle)
   	offset = position * '	|'
    print(ROW_FMT.format(needle,position,offset))

#insort可以保持有序序列的顺序
import bisect
import random

SIZE = 7
random.seed(1729)
my_list = []
for i in range(SIZE):	
    new_item = random.randrange(SIZE*2)
    bisect.insort(my_lsit,new_item)
    print('%2d ->' % new_item,my_lsit)

#计算移动平均值
def make_averager():
    count = 0
    total = 0
  	
    def averager(new_value):
        nonlocal count, total
        count += 1
        total += new_value
        return total / count 
    return averager
#test
ave = make_averager()
ave(10)
ave(20)

#一个简单的装饰器，支持处理关键字参数
import time

DEFAULT_FMT = '[{elasped:0.8f}s] {name} {name}({args}) -> {result}'

def clock(fmt=DEFAULT_FMT):
    def decorate(func):
        def clocked(*_args):
            t0 = time.time()
            _result = func(*_args)
            elasped = time.time() - t0
            name = func.__name__
            args = ', '.join(repr(arg) for arg in _args)
            result = repr(_result)
            print(fmt.format(**locals()))
            return _result
        return clocked
    return decorate

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

for i in range(3):
   snooze(.123)

#functools.singledspatch装饰器可以把整体方案拆分为多个模块，使用@singledspatch装饰的普通函数会变为泛函数：根据第一个参数的类型，以不同的方式执行相同的操作的一组函数
from functools import singledspatch
from collections import abc
from numbers
from html

@singledspatch
def htmlize(obj):
    content = html.escape(repr(obj))
    return '<pre>{}</pre>'.format(content)

@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>

#为了便于启用或禁用register执行的函数注册功能，我们为它提供了一个可选的active参数，设为False时，不注册被装饰的函数
registry = set()
def register(active=False):
    def decorator(func):
        print('running register(active=%s) -> decorator(%s)'
             % (active,func))
        if active:
            registry.add(func)
        else:
            registry.discard(func)
        return func
    return decorator

@register(active=False)
def f1():
    print('running f1')
   
@register(active=True)
def f2(active=True):
    print('running f2')
    
def f3():
    print('runing f3')

#test
registry
#为了接受新参数，新的register装饰器必须作为函数调用
register(active=True)(f3)
registry
    
register(active=False)(f2)
registry

#实现鸭子模型
from array import array
import math

class Vector2d:
    
    typecode = 'd'
    
#     def __init__(self,x,y):
#         self.x = float(x)
#         self.y = float(y)
#为了实现类可散列的特性，需要将类变量设成不可变类型也就是加上只读特性（1、设为私有，2、getter方法），最后实现可散列特性
#增加__hash__()
    def __init__(self,x,y):
        self.__x = float(x)
        self.__y = float(y)
    
    @property
    def x(self):
        return self.__x
    @property
    def y(self):
        return self.__y
    
    def __hash__(self):
        return hash(self.x) ^ hash(self.y)
    
    def __iter__(self):
        return (i for i in (self.x,self.y))
    
    def __repr__(self):
        class_name = type(self).__name__
        return '{}({!r},{!r})'.format(class_name,*self)
    
    def __str__(self):
        return str(tuple(self))
    
    def __bytes__(self):
        return (bytes([ord(self.typecode)])+bytes(array(self.typecode,self)))
    
    def __eq__(self,other):
        return tuple(self) == tuple(other)
    
    def __abs__(self):
        return math.hypot(self.x,self.y)
    
    def __bool__(self):
        return bool(abs(self))
    
    #添加备选构造方法
    @classmethod
    def frombytes(cls,octets):
        typecode = chr(octets[0])
        memv = memoryview(octets[1:].cast(typecode))
        return cls(*memv)
    
    
    
    def ang(self):
        return math.atan2(self.y,self.x)
    #实现format方法
#     def __format__(self,fmt_spec=''):
#         components  = (format(c,fmt_spec)for c in self)
#         return '({},{})'.format(*components)
    #对format方法拓展极坐标的表示方法
    def __format__(self,fmt_spec=''):
        if fmt_spec.endswith('p'):
            fmt_spec = fmt_spec[:-1]
            coords = (abs(self),self.ang())
            outer_fmt = '<{},{}>'
        else:
            coords = self
            outer_fmt = '({},{})'
        components = (format(c,fmt_spec) for c in coords)
        return outer_fmt.format(*components)

#可迭代对象和迭代器一定不能在一个对象中同时实现,一下为典型的迭代器
import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence:
    
    def __init__(self,text):
        self.text = text
        self.words = RE_WORD.findall(text)
    def __iter__(self):
        return SentenceIterator(self.words)
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)
    
#实现迭代器
class SentenceIterator(self,words):
    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

#使用生成器yield代替SentenceIterator类
import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence:
    
    def __init__(self,text):
        self.text = text
        self.words = RE_WORD.findall(text)
    def __iter__(self):
        for word in self.words:
            yield word
        return 
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

#使用生成器表达式简化生成器函数,并且对__iter__函数惰性实现
import re
import reprlib

RE_WORD = re.compile('\w+')

class Sentence:
    
    def __init__(self,text):
        self.text = text
    def __iter__(self):
        return (match.group() for match in RE_WORD.finditer(self.text))
    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

#使用协程实现记忆性计算平均值的函数
def average():
    total = 0.0
    count = 0
    average = None
    while True:
        msg = ''
        try:
            term = yield average
        except ZeroDivisionError:
            msg = 'Please enter number'
        else:
            total += term
            count += 1
            average = total/count

#yield from可以简化for循环中的yield表达式，例如：
def gen():
    for c in 'AB':
        yield c
    for i in range(1,3):
        yield i
#可以改写为：
def gen():
    yield from 'AB'
    yield from range(1,3)
    
    
#使用yield from链接可迭代的对象
def chain(*iterables):
    for it in iterables:
        yield from it      

from collections import namedtuple

Result = namedtuple('Result','count average')

#子生成器
def averager():

    average = None
    total = 0.0
    count = 0
    while True:
        item = yield
        if item is None:
            break
        total += item
        count += 1
        average = total/count
    return Result(count,average)



#委派生成器
```
grouper发送的每个值都会经yield from处理，通过管道传给averager实例。grouper会在yield from表达式处暂停，等待averager实例处理客户端发来的值。averager实例运行完毕后，返回的值绑定到results[key]上。while循环会不断创建averager实例，处理更多的值
```
def grouper(results,key):
    while True:
        results[key] = yield from averager()

#调用方
def main(data):
    results = {}
    for key,values in data.items():
        group = grouper(results,key)
        next(group)
        for value in values:
            group.send(value)
        group.send(None)
    print(results)

def report(results):
    for key, result in sorted(results.items()):
        group, unit = key.split(';')
        print('{:2} {:5} averaging {:.2f}{}'.format(
            result.count,group,result.average,unit
        ))

data = {
    'girls;kg':
        [40.9,38.5,44.3,42.2,45.2,41.7,44.5,38,40.6,44.5],
    'girls;m':
        [1.6,1.51,1.4,1.3,1.41,1.39,1.33,1.46,1.45,1.43],
    'boys;kg':
        [39.0,40.8,43.2,40.8,43.1,38.6,41.4,40.6,36.3],
    'boys;m':
        [1.38,1.5,1.32,1.25,1.37,1.48,1.25,1.49,1.46]
}

if __name__ == '__main__':
    main(data)