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

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

-->1,4,9  √

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

f1, f2, f3 = count()

f1()

-->9  ×

原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：

因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。

闭包：一个函数，内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称称为闭包（Closure）

可见闭包的特点是返回的函数还引用了外层函数的局部变量，正确使用闭包，就要确保引用的局部变量在函数返回后不能变

特别注意，返回函数不要引用任何循环变量，或者后续会发生变化的变量

return lambda : i*i  返回的是一个函数，并把函数存进列表，分别传递给f1, f2,f3,之后的f1()，f2(), f3()表示调用返回的lambda函数，而去掉lambda后返回的是一个值（即 i*i的值），此时f1 ,f2, f3为数值，数值无法被当做函数调用（即不存在  1() 这种写法）...

直接把 lambda 函数赋值给 self.get_grade 和绑定方法有所不同，函数调用不需要传入 self，但是方法调用需要传入 self。

class Person(object):

    count = 0

    def __init__(self,name):

        self.name = name

        Person.count += 1

类每被实例过一次，就会执行一次初始化函数，所以count就会加一。这样就能统计被实例化过几次了

Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。看例子：

class Person(object):
    def __init__(self, name):
        self.name = name
        self._title = 'Mr'

除了可以直接使用self.name = 'xxx'设置一个属性外，还可以通过 setattr(self, 'name', 'xxx') 设置属性。
（1）*argv就是可变参数元组（tuple），可以表示任何多个无名参数（tuple）。
（2）**kwargv则是可变参数字典（dict），可以表示任意多个关键字参数（dict）
实例的初始属性中接受一个dict，用{key,values}表示，所以job=‘Student’表示为{"job":"Student"}

类里面的构造函数def __init__(self, ***)第一项参数固定为self，剩余的为其他自定义属性，创建实例时都要赋值，空值用None替代。访问时用‘.’操作符。

函数任意参数：*args表示元数据参数，无名，为tuple类；**kw表示关键字key-word参数，有key值，为dict类。*args在**kw前。

通过对比可以看出，匿名函数 lambda x: x * x 实际上就是：

def f(x):
    return x * x

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

如：

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

返回闭包不能引用循环变量

增加一层嵌套，从而去掉循环

map()----返回一个List列表,接收单个参数map(f(*),List)列表每个参数运用函数

reduce()---返回一个List列表,接收两个参数reduce(f(*,*),List)列表每个参数累加或累剩

filter()---返回一个筛选之后List,接收单个参数filter(f(*),List)  

sorted()---自然排序返回List列表，可以接收多个参数，sorted(List,cmp,key)

请编写一个函数calc_prod(lst)，它接收一个list，返回一个函数，返回函数可以计算参数的乘积。

def calc_prod(lst):

    def prod():

        return reduce(lambda x, y : x * y, lst)

    return prod

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

print f()

类属性和实例属性名字冲突:
当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问.

def performance(f):

    def fn(*args,**kw):

        t1 = time.time()

        j = f(*args,**kw)

        t2 = time.time()

        print 'call %s() in %fs' % (f.__name__, (t2 - t1))

        return j

    return fn

可以计算两者之间的时间差

Python获取并输出当前日期时间

详解：

取得时间相关的信息的话，要用到python time模块,python time模块里面有很多非常好用的功能，你可以去官方
文档了解下，要取的当前时间的话，要取得当前时间的时间戳，时间戳好像是1970年到现在时间相隔的时间。

你可以试下下面的方式来取得当前时间的时间戳：
import time
print time.time()
输出的结果是：
1357723206.31

但是这样是一连串的数字不是我们想要的结果，我们可以利用time模块的格式化时间的方法来处理：
time.localtime(time.time())
用time.localtime()方法，作用是格式化时间戳为本地的时间。
输出的结果是：
time.struct_time(tm_year=2010, tm_mon=7, tm_mday=19, tm_hour=22, tm_min=33, tm_sec=39, tm_wday=0, tm_yday=200, tm_isdst=0)

现在看起来更有希望格式成我们想要的时间了。
time.strftime('%Y-%m-%d',time.localtime(time.time()))

最后用time.strftime()方法，把刚才的一大串信息格式化成我们想要的东西，现在的结果是：
2013-01-09

输出日期和时间：

time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))

time.strftime里面有很多参数，可以让你能够更随意的输出自己想要的东西：
下面是time.strftime的参数：
strftime(format[, tuple]) -> string
将指定的struct_time(默认为当前时间)，根据指定的格式化字符串输出
python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12） 
%M 分钟数（00=59）
%S 秒（00-59）

%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）