变量可以指向函数；

2.函数名实际上就是一个指向函数的一个变量；函数名和普通的而变量没有区别；

3.高阶函数就是可以接受一个函数作为变量的函数。变量可以指向函数，函数的参数可以接收变量，一个函数可以接受另一个函数作为参数。

functional 函数式编程

函数式编程：非纯，允许有变量。支持高阶，函数可以作为变量；支持闭包，有了闭包就能返回函数

Python

1不是纯函数式编程：允许有变量

2支持高阶函数：函数也可以作为变量传入

3支持闭包：有了闭包就能返回函数

4有限度地支持匿名函数

functional 函数式编程

函数式编程：非纯，允许有变量。支持高阶，函数可以作为变量；支持闭包，有了闭包就能返回函数

http://blog.csdn.net/u012759878/article/details/49007869

特点；简单、方便测试、

把计算视为函数而非指令

纯函数式编程：不需要变量（也可以有变量），没有副作用，测试简单

支持高阶函数，代码简洁

高 python ---->函数式 计算

C语言 ---->函数

汇编语言

低 计算机硬件-->指令 计算机

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

所谓闭包其实就是返回值为函数。比如调用function A时，A返回一个函数B，B就叫做闭包

http://blog.csdn.net/acs713/article/details/6863360

匿名函数lambda：

# lambda 参数: 表达式
lambda x: x * x
lambda x: -x if x < 0 else x
lambda s: s and len(s.strip()) > 0

闭包（Closure）：内层函数引用外层函数的变量（包括参数变量），并且在外层函数返回内层函数的情况。

正确使用闭包需要保证内层函数引用的变量在函数返回后不变。

请编写一个函数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 calc_prod(lst):

    def c_prod():

        return reduce(prod, lst)

    def prod(x1, x2):

        return x1 * x2

    return c_prod

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

print f()

def gcd(a,b):

    if a%b==0:

        return b

    return gcd(b,a%b)

class Rational(object):

    def __init__(self, p, q):

        self.p = p

        self.q = q

    def __add__(self, r):

        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)

    def __sub__(self, r):

        return Rational(self.p * r.q - self.q * r.p, self.q * r.q)

    def __mul__(self, r):

        return Rational(self.p * r.p,self.q * r.q)

    def __div__(self, r):

        return Rational(self.p * r.q,self.q * r.p)

    def __str__(self):

        g = gcd(self.p, self.q)

        return '%s/%s' % (self.p/g,self.q/g)

    __repr__ = __str__

r1 = Rational(1, 2)

r2 = Rational(1, 4)

print r1 + r2

print r1 - r2

print r1 * r2

print r1 / r2

有理数 → Rational类

加法运算 → __add__

减法运算 → __sub__

乘法运算 → __mul__

除法运算 → __div__

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

匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。

好抽象，是真的看不懂？

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

一个类表现得像一个list，要获取有多少个元素，就得用 len() 函数。

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

class Fib(object):

    def __init__(self, num):

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

        for n in range(num):

            L.append(a)

            a,b=b,a+b

        self.numbers=L

    def __str__(self):

        return str(self.numbers)

    __repr__=__str__

    def __len__(self):

        return len(self.numbers)

f = Fib(10)

print f

print len(f)

关联性方法统一一起实现

特殊方法示例

python中多态

类具有继承关系，并且子类类型可以向上转型看做父类类型，如果我们从 Person 派生出 Student和Teacher ，并都写了一个 whoAmI() 方法：

import json

class Students(object):

    def read(self):

        return r'["Tim", "Bob", "Alice"]'

    pass

s = Students()

print json.load(s)