f()的参数是变量，因此结果也会跟着变化
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
f1,f2,f3的结果均为9

内层函数引用了外层函数的变量，然后返回内层函数的情况，称为闭包（Closure）
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()
f1,f2,f3的结果分别为1,4,9

sorted()函数可对list进行排序,它也可以接收一个比较函数来实现自定义排序（写在list之后），比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

filter(f,[1,2,3,4,5,6……]):

f()为判断函数，filter()使list中的每个元素进行f(1),f(2)……的判断，并过滤掉结果为false的元素，保留结果为ture的元素组成新的list。

s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')

map(f,[1,2,3,4……]):

map将list的元素依次进行f()运算，得到新list:[f(1),f(2),f(3)……]

reduce(f,[1,2,3,4……],N):

f()必须能接受两个参数，reduce是取list的第1,2个元素进行f(1,2)的运算，然后结果再和第3个元素进行运算。

当reduce存在第三个参数N时，先取N与list的第1个参数进行f(N,1)运算，然后再取结果和第2个元素运算。

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()

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：

# 希望一次返回3个函数，分别计算1x1,2x2,3x3:def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

第一个score(self)是get方法，用@property装饰，第二个score(self, score)是set方法，用@score.setter装饰，@score.setter是前一个@property装饰后的副产品

用 @property 修饰 grade 的 get 方法即可实现只读属性

s[0].upper()+s[1:].lower()首字母大写 后面字母小写

 r1 = Rational(1, 3) = 1 / 3
 
 a，b的最大公约数记为（a，b）

math.sqrt计算平方根

class Fib(object):

    def __init__(self, num):

        l=[]

        for n in range(num):

            if n ==0:

                l.append(0)

            elif n==1 or n==2:

                l.append(1)

            else:

                l.append(l[n-1] + l[n-2])

                self.num =l

    def __str__(self):

        return str(self.num)

    __repr__ = __str__

    def __len__(self):

        return len(self.num)

f = Fib(10)

print f

print len(f)

def calc_prod(lst):
    def lazy_prod():
        def f(x, y):
            return x * y
        return reduce(f, lst, 1)
    return lazy_prod
f = calc_prod([1, 2, 3, 4])
print f()

def f():
    print 'call f()...'    # 定义函数g:
    def g():
        print 'call g()...'    # 返回函数g:
    return g

>>> x = f()   # 调用f()call f()...
>>> x   # 变量x是f()返回的函数：<function g at 0x1037bf320>
>>> x()   # x指向函数，因此可以调用call g()...   # 调用x()就是执行g()函数定义的代码

def myabs():
    return abs   # 返回函数def myabs2(x):
    return abs(x)   # 返回函数调用的结果，返回值是一个数值