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

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

>>> f1()
9     # 因为f1现在才计算i*i，但现在i的值已经变为3

改写如下：

def count():

    fs = []

    for i in range(1, 4):

        def f():

            return i*i

        r=f()

        fs.append(r)

    return fs

f1, f2, f3 = count()

print f1, f2, f3

只是此时返回的不再是函数

Python内置的 sorted()函数可对list进行排序：

>>>sorted([36, 5, 12, 9, 21])

[5, 9, 12, 21, 36]

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

filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

import math

def is_sqr(x):

    r = int(math.sqrt(x))

    return r*r == x

print filter(is_sqr, range(1, 101))

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：

先计算头两个元素：f(1, 3)；
再把结果和第3个元素计算：f(4, 5)；
再把结果和第4个元素计算：f(9, 7)；
再把结果和第5个元素计算：f(16, 9)；
由于没有更多的元素了，计算结束

# reduce()函数类似于map(),传入一个函数和一个list
# 与map不同，reduce()是将 元素i 与 元素i+1发生关系
#  map()返回的是 一个新的list ,reduce()返回的是一个具体的值

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回

由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型

# map()函数可以针对于list的每个元素（list数据源）按照指定的计算方式(函数)进行运算，返回一个新的list,
# 不改变原list的数据

实例属性的优先级更高  比类属性高！

如果要把一个类的实例变成 str，就需要实现特殊方法__str__() 

def __str__(self):

        return '(Student:%s,%s,%s)' %(self.name,self.gender,self.score)

def __cmp__(self, s):    

if isinstance(s,int):          

return -cmp(self.score,s)      

if False == isinstance(s,Student):            

return -1      

return -cmp(self.score,s.score) or cmp(self.name,s.name)

L = [Student('Tim', 99), Student('Bob', 88), Student('Alice', 99),100]

print sorted(L)

len() 函数工作正常，类必须提供一个特殊方法__len__()，它返回元素的个数。

class Fib(object):

    def __init__(self, num):

        a,b,L = 0,1,[]

        self.num = num

        for i in range(num):

       L.append(a)

            a,b = b,a+b

        self.numbers = L

    def __str__(self):

        return str

(self.numbers)

    def __len__(self):

        return len(self.numbers)

f = Fib(10)

print f

print len(f)

>>> int(12.34)

12

>>> float(12)

12.0

class Rational(object):

    def __init__(self, p, q):

        self.p = p

        self.q = q

    def __int__(self):

        return self.p // self.q

因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用：

class Student(object):

    def __init__(self, name, score):

        self.name = name

        self.__score = score

    @property

    def score(self):

        return self.__score

    @score.setter

    def score(self, score):

        if score < 0 or score > 100:

            raise ValueError('invalid score')

        self.__score = score

注意: 第一个score(self)是get方法，用@property装饰，第二个score(self, score)是set方法，用@score.setter装饰，@score.setter是

前一个@property装饰后的副产品。

，__slots__是指一个类允许的属性列表

 __slots__ = ('name', 'gender', 'score')

__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用__slots__也能节省内存

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()

  def __call__(self, friend):

        print 'My name is %s...' % self.name

 p('Tim')

My name is Bob...

My friend is Tim...

        print 'My friend is %s...' % friend

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

变量可以指向函数，而函数的参数可以接受变量，因此可以以一个函数作为另一个函数的参数。包含函数的函数又称为高阶函数。

def __init__(self,name,gender,birth,**kw):    #这里的**kw表示可以接受任意数量的关键字参数
       .............................
       for k , v in kw.iteritems():      #这里提取输入的参数，K,V分别是键值对的键和值，即key和value
           setattr(self,k,v)             #这里即是把k设为 self对象的属性，v就是k属性的值

在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：

class Person(object):    def __init__(self, name, gender, birth):
        self.name = name
        self.gender = gender
        self.birth = birth

cmp是内置的比较函数，接收两个参数

sorted 是python的内置函数

第一个参数接受一个list，第二个包含一个匿名函数，其中，匿名函数自定义参数的返回方式。