在python类块或者函数块中如果没想好要写什么，可以在块中用pass代替空内容：

class Person(object):
    pass

在旧版本中使用新版本与旧版本不兼容的特性：

from __future__ import xxx

注意：字符串前+u方法在3.x版本已废弃，所有str均为unicode编码

导入模块结合异常处理：

try:
    import moduel1
except ImportError:
    import moduel2

意义是尝试导入moduel1，如果不存在此模块则导入moduel2

类比java：

python中的模块相当于java中的包

python中的函数相当于java中的类

导入模块：
import moduel（导入了moduel中包含的所有函数）

from moduel import function(只导入了moduel中的function函数）

from moduel import function as f(导入函数后重命名为f）

偏函数functools.partial(f,parameter=default_parameter)

给函数以默认的参数，调用f时不写出parameter则默认为偏函数中给出的default_parameter

import functools

sorted_ignore_case = functools.partial(sorted,cmp=lambda x,y:cmp(x.upper(),y.upper()))

print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])

python中自带的比较字符串函数：cmp（str1，str2）

返回-1,0,1

使用过decorator之后原函数的部分参数会丢失，为了补救此情形，引入@functools.wraps(f)，使用在最内层的decorator的上一行

import time, functools

def performance(unit):
    def dec_perf(f):
        @functools.wraps(f)
        def wrapper(*args,**kw):
            t1=time.time()
            r=f(*args,**kw)
            t2=time.time()
            if unit=='s':
                print("call "+f.__name__+"() in "+str(t2-t1)+"s")
            if unit=='ms':
                print("call "+f.__name__+"() in "+str(1000*(t2-t1))+"ms")
            return r
        return wrapper
    return dec_perf

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial.__name__

执行含参数的decorator：

三层嵌套函数定义

在内部两层与无参数decorator的区别是使用到最外层的参数

import time

def performance(unit):
    def dec_per(f):
        def dec_perf(*args,**kw):
            t1=time.time()
            tmp=f(*args,**kw)
            t2=time.time()
            if(unit=='s'):
                print("call "+f.__name__+"() in "+str(t2-t1)+"s")
            if(unit=='ms'):
                print("call "+f.__name__+"() in "+str(100*(t2-t1))+"ms")
            return tmp
        return dec_perf
    return dec_per

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

高阶函数应用：decorator

@yourDecoratorName 使用在欲加函数的上一行

使得函数被永久更改为装饰后的函数

如果希望装饰器函数适配各种参数数量的函数，则在装饰器内部定义子函数fn(*args,**kw),在此函数内部建立指向f的变量并返回f

import time

def performance(f):
    def fn(*args,**kw):
        t1=time.time()
        tmp=f(*args,**kw)
        t2=time.time()
        print("call "+f.__name__+"() in "+str(t2-t1))
        return tmp
    return fn

@performance
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

python中的匿名函数就是lambda表达式：
格式：lambda parameters:expression

这里 expression就是匿名函数的返回值

解释这段代码：

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        r=f(i)
        fs.append(r)
    return fs

f1, f2, f3 = count()
print f1(), f2(), f3()

为了避免在闭包中子函数定义时使用循环变量，在子函数f中再定义一个子函数g，用g实现乘方的功能

之后再写一个变量r指向f，f在执行时使用到循环变量是允许的

解释一下这段返回函数的代码：

def calc_prod(lst):
    def prod():
        cnt=1.0
        for x in lst:
            cnt*=x
        return cnt
    return prod

f = calc_prod([1, 2, 3, 4])
print f()

在最外的函数calc_prod(lst)中包含了一个函数prod(),因为最后print f(),可见f指向的函数并不含参数，所以prod作为calc_prod返回的函数也不应含有参数（而calc_prod的参数lst在prod的定义中是可用的）

sorted(list,f)自定义排序函数

按照f(elem1,elem2)的返回值作为排序依据

elem1在elem2前，f返回-1

elem1在elem2后，f返回1

如果相等，f返回0

filter（f，list）

要求f函数返回bool值，作为list值是否满足要求的依据

filter返回包含符合f函数要求的元素的list

reduce(f,list,initElem)(第三个参数可以没有）

f函数必须接受两个参数：第一个参数是上次执行的结果，第二个参数是list元素

也就是说，list元素鱼贯执行f