补充
最近读了一本名叫Intermediate Python的书，对应的中文版是Python进阶，本文是读完之后的笔记。
列表
调试器
Python也有调试器，和gdb的指令基本一致。进入debug有两种方法，一种是运行程序的时候执行python -m pdb xxxx.py；另一种是使用pdb模块的set_trace()方法在函数中间设置断点。
有没有用？求同存异吧。
可迭代对象、迭代器、迭代
Python中任意对象，只要实现了可以返回一个迭代器的__iter__方法，或定义了可以支持下标索引的__getitem__方法，那么它就是一个可迭代对象。
任何对象，只要定义了__next__方法，它就是一个迭代器。
当我们是使用一个循环来遍历某个东西时，这个过程就是迭代。
Map, Filter, Reduce
通常和lambda表达式结合一起使用，但也可以是一个函数地址。格式均为：
Map/Filter/Reduce((lambda expression)|fn, items)
其中items必须是个可迭代的对象。
Map是将expression作用于items每个成员上，并返回一个新的可迭代对象。其lambda式或fn一般是一个参数。Map还可以这样写：
def multiply(x):
return (x*x)
def add(x):
return (x+x)
funcs = [multiply, add]
for i in range(5):
value = map(lambda x: x(i), funcs)
print (list(value))
Filter是过滤器，将符合lambda式或函数的值过滤出来形成新的返回对象。
Reduce是迭代处理一个迭代对象，因此其lambda式或函数一般带有两个参数，它首先作用于迭代对象的第一第二个元素，生成一个中间值，然后处理中间值和第三个元素，之后生成新的中间值，并和下一值结对处理，最后一般返回一个值。Python里Reduce被收到了functools模块里，需要像from functools import reduce这样调用。
三元运算符
除了一般的：
is_fat = True
state = "fat" if is_fat else "not fat"
还可以这样写：
fat = True
fitness = ("skinny", "fat")[fat]
print("Ali is ", fitness)
但不推荐，有隐患：
condition = True
print(2 if condition else 1/0)
# 输出2
print((1/0, 2)[condition])
# 输出ZeroDivisionError异常
装饰器
补充两个关于装饰器的代码。
使用functools.wraps保存原函数的名字和注释文档
from functools import wraps
def a_new_decorator(a_func):
@wraps(a_func)
def wrapTheFunction():
print ("I am doing some boring work before executing a_func()")
a_func()
print ("I am doing some boring work after executing a_func()")
return wrapTheFunction
@a_new_decorator
def a_function_requiring_decoration():
"""Hey yo! Decorate me!"""
print("I am the function which needs some decoration to remove my foul smell")
print(a_function_requiring_decoration.__name__)
print(a_function_requiring_decoration.__doc__)
装饰器模板
from functools import wraps
def decorator_name(f):
@wraps(f)
def decorated(*args, **kwargs):
if not can_run:
return "Function will not run"
return f(*args, **kwargs)
return decorated
@decorator_name
def func():
return("Function is running")
can_run = True
print(func())
装饰器的使用场景
授权
from functools import wraps
def requires_auth(f):
@wraps(f)
def decorated(*args, **kwargs):
auth = request.authorization
if not auth or not check_auth(auth.username, auth.password):
authenticate()
return f(*args, **kwargs)
return decorated
日志
from functools import wraps
def logit(func):
@wraps(func)
def with_logging(*args, **kwargs):
print(func.__name__ + " was called")
return func(*args, **kwargs)
return with_logging
@logit
def addition_func(x):
"""Do some math."""
return x + x
result = addition_func(4)
__slots__魔法
在Python中，每个类都有实例属性。默认情况下Python用⼀个字典来保存⼀个对象的实例属性。这非常有用，因为它允许我们在运⾏时去设置任意的新属性。
class MyClass(object):
__slots__ = ['name', 'identifier']
def __init__(self, name, identifier):
self.name = name
self.identifier = identifier
self.set_up()
这样写可以打打减少实例对象的内存使用，另外一款检测内存的模块ipython_memory_usage
虚拟环境
Virtualenv 是⼀个⼯具，它能够帮我们创建⼀个独⽴(隔离)的Python环境。
Collections模块
- defaultdict，高级字典，可以处理key重复的情况而不是抛出异常。
- counter，计数器，针对某项数据进行计数。
- deque，双端队列
- namedtuple，高级元组，可以生成一个带名字和字段的元组（但只是元组，这意味着值不能改变）
from collections import namedtuple
Animal = namedtuple('Animal', 'name age type') # 元组名称和参数（用空格分隔）
perry = Animal(name="perry", age=31, type="cat")
print(perry)
print(perry[0])
print(perry.name, perry.age, perry.type) # 进行类字典访问
print(perry._asdict()) # 转换为字典
- enum.Enum (Python 3.4+)
from enum import Enum
class Species(Enum):
cat = 1
dog = 2
horse = 3
aardvark = 4
butterfly = 5
owl = 6
platypus = 7
dragon = 8
unicorn = 9
print (Species(1))
print (Species['cat'])
print (Species.cat)
枚举 Enumerate
enumerate可以带参数，注意参数不是表示从第几个元素开始，是指从数字几开始枚举。
my_list = ['apple', 'banana', 'grapes', 'pear']
for c, value in enumerate(my_list, 2):
print(c, value)
# 输出，注意不是从第几个元素开始，是指从数字几开始枚举
# 4 apple
# 5 banana
# 6 grapes
# 7 pear
对象自省 Introspection
dir
返回一个列表，表示一个对象所拥有的全部属性和方法。如果我们运行dir()而传⼊参数，那么它会返回当前作⽤域的所有名字。
type和id
type函数返回一个对象的类型。id返回任意对象的唯一ID。
inspect模块
推导式（即之前所述的生成式）
列表推导式
它的结构是在⼀个中括号⾥包含⼀个表达式，然后是⼀个for语句，然后是0个或多个for或者if语句。
variable = [out_exp for out_exp in input_list if out_exp == 2]
字典推导式
mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = {
k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)
for k in mcase.keys()
}
这个例子是把a和A的值合并到a里面了。
集合推导式
{x**2 for x in [1, 1, 2]}
处理多个异常
try:
file = open('test.txt', 'rb')
except (IOError, EOFError) as e:
print("An error occurred. {}".format(e.args[-1]))
或者
try:
file = open('test.txt', 'rb')
except EOFError as e:
print("An EOF error occurred.")
raise e
except IOError as e:
print("An error occurred.")
raise e
或者用Exception处理所有的异常。
lambda表达式
列表排序
a = [(1, 2), (4, 1), (9, 10), (13, -3)]
a.sort(key=lambda x: x[1])
列表并行排序
data = zip(list1, list2)
data.sort()
list1, list2 = map(lambda t: list(t), zip(*data))
for-else
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print( n, 'equals', x, '*', n/x)
break
else:
# loop fell through without finding a factor
print(n, 'is a prime number')
Python2+3
Future模块导入
它可以帮你在Python2中导⼊Python3的功能。
模块重命名
try:
import urllib.request as urllib_request # for Python 3
except ImportError:
import urllib2 as urllib_request # for Python 2
urllib_request.XXXXXXX
失效Python2的内置功能
from future.builtins.disabled import *
apply()
协程
def grep(pattern):
print("Searching for", pattern)
while True:
line = (yield)
if pattern in line:
print(line)
search = grep('coroutine')
print (next(search))
print (search.send("Don't you love me?"))
print (search.send("I love coroutine instead!"))
search.close()
函数缓存
函数缓存允许我们将⼀个函数对于给定参数的返回值缓存起来。当⼀个I/O密集的函数被频繁使⽤相同的参数调⽤的时候，函数缓存可以节约时间。在Python 3.2版本以前我们只有写⼀个⾃定义的实现。在Python 3.2以后版本，有个lru_cache的装饰器，允许我们将⼀个函数的返回值快速地缓存或取消缓存。
from functools import lru_cache
@lru_cache(maxsize=32)
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)
print([fib(n) for n in range(10)])