可以先看返回类型，返回类型需要是一个函数（f1() f2() f3()），所以反推return fs中的fs必是一个函数list，返回的是f(1),f(2) f(3),而函数f在闭包里实现定义

定义一个返回函数的函数f，其内部要先定义一个能返回计算结果的函数g，返回该函数g本身。

现在不是很能理解这个返回函数g的作用，既然内部定义了能计算出结果的函数g，为何不直接把这个函数g当做最先定义的那个函数f，那直接调用函数f就可以直接算出结果了，为何还要弄一个f（）。

f1,f2,f3=1,4,9

print f1,f2,f3的结果是1,4,9

fs最终是一个“函数”的列表，而不是数值的列表，所以最后print里的f1f2f3都带括号。

为什么print d没有值输出呢，print d()才有值呢

def c(lst):
    def a():
        def e(x,y):
            return x * y
        return reduce(e,lst,1)
    return a
d = c([1, 2, 3, 4])
print d

2018-07-10源自：python进阶 2-897 浏览2 回答

最佳回答

2018-07-10

首先我们要理解d()和d的区别：

1. d()是调用函数，调用函数后才会返回函数运行的结果

2. d是函数本身

其次我们看d = c([1, 2, 3, 4]) 做了什么，按照顺序：

1.  调用函数c()，并传入参数[1, 2, 3, 4] 使得 lst = [1, 2, 3, 4]

   1. def e(x,y): return x * y 声明函数e(),并表示传入参数x,y后，返回x,y相乘的结果

   2. reduce(e,lst,1) 计算对lst数列元素相乘的结果，从元素1开始

   1. def a(): 声明函数a()，a()实现的功能：

   2. 返回函数a本身（并没有调用函数a()，所以不会返回函数计算的结果）

也就是说d 等价于 c([1, 2, 3, 4]) 返回的结果是a

d() 返回的结果是a() 而a()表示调用函数a()，将得到reduce(e,lst,1) 计算对lst数列元素相乘的结果，从元素1开始

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

def f(x):
    return x * x

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

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

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

• 返回函数的时候，也可以返回匿名函数：

• >>> myabs = lambda x: -x if x < 0 else x 
  >>> myabs(-1)
  1
  >>> myabs(1)
  1

def count():

    fs = []

    for i in range(1, 4):

        def f(j):

            def g():

                return j*j

            return g

        fs.append(f(i)) #

    return fs  #fs= [f(1), f(2), f(3)] 三个函数组成的列表

f1, f2, f3 = count() #count(), 是三个函数还是三个函数值？？？

print f1(), f2(), f3()

它可以正确地返回一个闭包g，g所引用的变量j不是循环变量，因此将正常执行。

在count函数的循环内部，如果借助f函数，就可以避免引用循环变量i。

考察上一小节定义的 calc_sum 函数：

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

注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。

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

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

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

创建实例必定会调用__init__()方法

def gcd(a,b):

    if b == 0:

        return a

    return gcd(b,a % b)

是找公约数的意思

p1.get_grade这是一个函数

p1.get_grade(）是一个方法才可以调用

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

例：

我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算：

def f(x):
    return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

输出结果：

[1, 4, 9, 10, 25, 36, 49, 64, 81]

注意：map()函数不改变原有的 list，而是返回一个新的 list。

利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。

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

Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数！

例如，定义一个函数 f()，我们让它返回一个函数 g，可以这样写：

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

仔细观察上面的函数定义，我们在函数 f 内部又定义了一个函数 g。由于函数 g 也是一个对象，函数名 g 就是指向函数 g 的变量，所以，最外层函数 f 可以返回变量 g，也就是函数 g 本身。

调用函数 f，我们会得到 f 返回的一个函数：

>>> 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)   # 返回函数调用的结果，返回值是一个数值

返回函数可以把一些计算延迟执行。例如，如果定义一个普通的求和函数：

def calc_sum(lst):
    return sum(lst)

调用calc_sum()函数时，将立刻计算并得到结果：

>>> calc_sum([1, 2, 3, 4])
10

但是，如果返回一个函数，就可以“延迟计算”：

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

# 调用calc_sum()并没有计算出结果，而是返回函数:

>>> f = calc_sum([1, 2, 3, 4])
>>> f
<function lazy_sum at 0x1037bfaa0>

# 对返回的函数进行调用时，才计算出结果:

>>> f()
10

由于可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数。

任务

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

• ?不会了怎么办

• 先定义能计算乘积的函数，再将此函数返回。

  参考代码:

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

函数式 编程

函数: function, 

函数式：functional 一种编程范式

函数式编程的特点

把计算视为函数而非指令

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

支持高阶函数，代码简洁

python支持的函数式编程

不是纯的函数式编程 ：支持变量

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

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

有限度的支持匿名函数