关键词：
《Python从小白到大牛》第10章 函数式编程
《Python从小白到大牛》已经上市！
程序中反复执行的代码可以封装到一个代码块中，这个代码块模仿了数学中的函数，具有函数名、参数和返回值，这就是程序中的函数。
Python中的函数很灵活，它可以在模块中，但类之外定义，即函数，作用域是当前模块；也可以在别的函数中定义，即嵌套函数；还可以在类中定义，即方法。
定义函数
在前面的学习过程中也用到了一些函数，如果len()、min()和max()，这些函数都由Python官方提供的，称为内置函数（Built-in
Functions, 缩写BIF）。
注意
Python作为解释性语言函数必须先定义后调用，也就是定义函数必须在调用函数之前，否则会有错误发生。
本节介绍自定义函数，自定义函数的语法格式如下：
def 函数名(参数列表) :
函数体
return 返回值
在Python中定义函数时，关键字是def，函数名需要符合标识符命名规范；多个参数列表之间可以用逗号（,）分隔，当然函数也可以没有参数。如果函数有返回数据，就需要在函数体最后使用return语句将数据返回；如果没有返回数据，则函数体中可以使用return
None或省略return语句。
函数定义示例代码如下：
# coding=utf-8
# 代码文件：chapter10/ch10.1.py
def rectangle_area(width, height): ①
area = width * height
return area ②
r_area = rectangle_area(320.0, 480.0) ③
print("320x480的长方形的面积:0:.2f".format(r_area))
上述代码第①行是定义计算长方形面积的函数rectangle_area，它有两个参数，分别是长方形的宽和高，width和height是参数名。代码第②行代码是通过return返回函数计算结果。代码第③行是调用rectangle_area函数。
函数参数
Python中的函数参数很灵活，具体体现在传递参数有多种形式上。本节介绍几种不同形式参数和调用方式。
使用关键字参数调用函数
为了提高函数调用的可读性，在函数调用时可以使用关键字参数调用。采用关键字参数调用函数，在函数定义时不需要做额外的工作。
示例代码如下：
# coding=utf-8
# 代码文件：chapter10/ch10.2.1.py
def print_area(width, height):
area = width * height
print("0 x 1 长方形的面积:2".format(width, height, area))
print_area(320.0, 480.0) # 没有采用关键字参数函数调用 ①
print_area(width=320.0, height=480.0) # 采用关键字参数函数调用②
print_area(320.0, height=480.0) # 采用关键字参数函数调用 ③
# print_area(width=320.0, height) # 发生错误 ④
print_area(height=480.0, width=320.0) # 采用关键字参数函数调用 ⑤
print_area函数有两个参数，在调用时没有采用关键字参数函数调用，见代码第①行，也可以使用关键字参数调用函数，见代码第②行、第③行和第⑤行，其中width和height是参数名。从上述代码比较可见采用关键字参数调用函数，调用者能够清晰地看出传递参数的含义，关键字参数对于有多参数函数调用非常有用。另外，采用关键字参数函数调用时，参数顺序可以与函数定义时参数顺序不同。
注意
在调用函数时，一旦其中一个参数采用了关键字参数形式传递，那么其后的所有参数都必须采用关键字参数形式传递。代码第④行的函数调用中第一个参数width采用了关键字参数形式，而它后面的参数没有采用关键字参数形式，因此会有错误发生。
参数默认值
在定义函数的时候可以为参数设置一个默认值，当调用函数的时候可以忽略该参数。来看下面的一个示例：
# coding=utf-8
# 代码文件：chapter9/ch10.2.2.py
def make_coffee(name="卡布奇诺"):
return "制作一杯0咖啡。".format(name)
上述代码定义了makeCoffee函数，可以帮助我做一杯香浓的咖啡。由于我喜欢喝卡布奇诺，就把它设置为默认值。在参数列表中，默认值可以跟在参数类型的后面，通过等号提供给参数。
在调用的时候，如果调用者没有传递参数，则使用默认值。调用代码如下：
coffee1 = make_coffee("拿铁") ①
coffee2 = make_coffee() ②
print(coffee1) # 制作一杯拿铁咖啡。
print(coffee2) # 制作一杯卡布奇诺咖啡。
其中第①行代码是传递"拿铁"参数，没有使用默认值。第②行代码没有传递参数，因此使用默认值。
提示
在其他语言中make_coffee函数可以采用重载实现多个版本。Python不支持函数重载，而是使用参数默认值的方式提供类似函数重载的功能。因为参数默认值只需要定义一个函数就可以了，而重载则需要定义多个函数，这会增加代码量。
可变参数
Python中函数的参数个数可以变化，它可以接受不确定数量的参数，这种参数称为可变参数。Python中可变参数有两种，在参数前加*或**形式，*可变参数在函数中被组装成为一个元组，**可变参数在函数中被组装成为一个字典。
- *可变参数
下面看一个示例：
def sum(*numbers, multiple=1):
total = 0.0
for number in numbers:
total += number
return total * multiple
上述代码定义了一个sum()函数，用来计算传递给它的所有参数之和。*numbers是可变参数。在函数体中参数numbers被组装成为一个元组，可以使用for循环遍历numbers元组，计算他们的总和，然后返回给调用者。
下面是三次调用sum()函数的代码：
print(sum(100.0, 20.0, 30.0)) # 输出150.0
print(sum(30.0, 80.0)) # 输出110.0
print(sum(30.0, 80.0, multiple=2)) # 输出220.0 ①
double_tuple = (50.0, 60.0, 0.0) # 元组或列表 ②
print(sum(30.0, 80.0, *double_tuple)) # 输出220.0 ③
可以看到，每次所传递参数的个数是不同的，前两次调用时都省略了multiple参数，第三次调用时传递了multiple参数，此时multiple应该使用关键字参数传递，否则有错误发生。
如果已经有一个元组变量（见代码第②行），能否传递给可变参数呢？这需要使用对元组进行拆包，见代码第③行在元组double_tuple前面加上单星号（*），单星号在这里表示将double_tuple拆包为50.0,
60.0, 0.0形式。另外，double_tuple也可以是列表对象。
注意
*可变参数不是最后一个参数时，后面的参数需要采用关键字参数形式传递。代码第①行30.0,
80.0是可变参数，后面multiple参数需要关键字参数形式传递。
- **可变参数
下面看一个示例：
def show_info(sep=':', **info):
print('-----info------')
for key, value in info.items():
print('0 2 1'.format(key, value, sep))
上述代码定义了一个show_info()函数，用来输出一些信息，其中参数sep信息分隔符号，默认值是冒号（:）。**info是可变参数，在函数体中参数info被组装成为一个字典。
注意 **可变参数必须在正规参数之后，如果本例函数定义改为show_info(**info,sep=’:’)形式，会发生错误。
下面是三次调用show_info()函数的代码：
show_info('->', name='Tony', age=18, sex=True) ①
show_info(sutdent_name='Tony', sutdent_no='1000', sep='-') ②
stu_dict = 'name': 'Tony', 'age': 18 # 创建字典对象
show_info(**stu_dict, sex=True, sep='=') # 传递字典stu_dict ③
上述代码第①行是调用函数show_info()，第一个参数’->'是传递给sep，其后的参数name=‘Tony’,
age=18,
sex=True是传递给info，这种参数形式事实上就是关键字参数，注意键不要用引号包裹起来。
代码第②行是调用函数show_info()，sep也采用关键字参数传递，这种方式sep参数可以放置在参数列表的任何位置，其中的关键字参数被收集到info字典中。
代码第③行是调用函数show_info()，其中字典对象stu_dict，传递时stu_dict前面加上双星号（**），双星号在这里表示将stu_dict拆包为key=value对的形式。
函数返回值
Python函数的返回值也是比较灵活的，主要有三种形式：无返回值、单一返回值和多返回值。前面使用的函数基本都单一返回值，本节重点介绍无返回值和多返回值两种形式。
无返回值函数
有的函数只是为了处理某个过程，此时可以将函数设计为无返回值的。所谓无返回值，事实上是返回None，None表示没有实际意义的数据。
无返回值函数示例代码如下：
# coding=utf-8
# 代码文件：chapter9/ch10.3.1.py
def show_info(sep=':', **info): ①
"""定义**可变参数函数"""
print('-----info------')
for key, value in info.items():
print('0 2 1'.format(key, value, sep))
return # return None 或省略 ②
result = show_info('->', name='Tony', age=18, sex=True)
print(result) # 输出 None
def sum(*numbers, multiple=1): ③
"""定义*可变参数函数"""
if len(numbers) == 0:
return # return None 或省略 ④
total = 0.0
for number in numbers:
total += number
return total * multiple
print(sum(30.0, 80.0)) # 输出110.0
print(sum(multiple=2)) # 输出 None ⑥
上述代码定义了两个函数，这个两个函数事实上是在10.3.2节示例基础上的重构。其中代码第①行的show_info()只是输出一些信息，不需要返回数据，因此可以省略return语句。如果一定要使用return语句，见代码第②行在函数结束前使用return或return
None。
对于本例中的show_info()函数强加return语句显然是多此一举，但是有时使用return或return
None是必要的。代码第③行定义了sum()函数，如果numbers中数据是空的，后面的求和计算也就没有意义了，可以在函数的开始判断numbers中算法有数据，如果没有数据则使用return或return
None跳出函数，见代码第④行。
多返回值函数
有时需要函数返回多个值，实现返回多个值的实现方式有很多，简单实现是使用元组返回多个值，因为元组作为数据结构可以容纳多个数据，另外元组是不可变的，使用起来比较安全。
下面来看一个示例：
# coding=utf-8
# 代码文件：chapter9/ch10.3.2.py
def position(dt, speed): ①
posx = speed[0] * dt ②
posy = speed[1] * dt ③
return (posx, posy) ④
move = position(60.0, (10, -5)) ⑤
print("物体位移：(0, 1)".format(move[0], move[1])) ⑥
这个示例是计算物体在指定时间和速度时的位移。第①行代码是定义position函数，其中dt参数是时间，speed参数是元组类型，speed第一个元素X轴上的速度，speed第二个元素Y轴上的速度。position函数的返回值也是元组类型。
函数体中的第②行代码是计算X方向的位移，第③行代码是计算Y方向的位移。最后，第④行代码将计算后的数据返回，(posx,
posy)是元组类型实例。
第⑤行代码调用函数，传递的时间是60.0秒，速度是(10,
-5)。第⑥行代码打印输出结果，结果如下：
物体位移：(600.0, -300.0)
函数变量作用域
变量可以在模块中创建，作用域是整个模块，称为全局变量。变量也可以在函数中创建，默认情况下作用域是整个函数，称为局部变量。
示例代码如下：
# coding=utf-8
# 代码文件：chapter9/ch10.4.py
# 创建全局变量x
x = 20 ①
def print_value():
print("函数中x = 0".format(x)) ②
print_value()
print("全局变量x = 0".format(x))
输出结果：
函数中x = 20
全局变量x = 20
上述代码第①行是创建全局变量x，全局变量作用域是整个模块，所以在print_value()函数中也可以访问变量x，见代码第②行。
修改上述示例代码如下：
# 创建全局变量x
x = 20
def print_value():
# 创建局部变量x
x = 10 ①
print("函数中x = 0".format(x))
print_value()
print("全局变量x = 0".format(x))
输出结果：
函数中x = 10
全局变量x = 20
上述代码的是print_value()函数中添加x =
10语句，见代码第①行，这会函数中创建x变量，函数中的x变量与全局变量x命名相同，在函数作用域内会屏蔽全局x变量。
函数中创建的变量默认作用域是当前函数，这可以防止程序员少犯错误，因为函数中创建的变量，如果作用域是整个模块，那么在其他函数中也可以访问，Python无法从语言层面定义常量，所以在其他函数中由于误操作修改了变量，这样一来很容易导致程序出现错误。即便笔者不赞同，但Python提供这种可能，通过在函数中将变量声明为global的，可以把变量的作用域变成全局的。
修改上述示例代码如下：
# 创建全局变量x
x = 20
def print_value():
global x ①
x = 10 ②
print("函数中x = 0".format(x))
print_value()
print("全局变量x = 0".format(x))
输出结果：
函数中x = 10
全局变量x = 10
代码第①行是在函数中声明x变量作用域为全局变量，所以代码第②行修改x值，就是修改全局变量x的数值。
生成器
在一个函数中使用return关键字返回数据，但是有时候会使用yield 关键字返回数据。yield 关键字的函数返回的是一个生成器（generator）对象，生成器对象是一种可迭代对象。
如果想计算平方数列，通常的实现代码如下：
def square(num): ①
n_list = []
for i in range(1, num + 1):
n_list.append(i * i) ②
return n_list ③
for i in square(5): ④
print(i, end=' ')
返回结果是：
1 4 9 16 25
首先定义一个函数，见代码第①行。代码第②行通过循环计算一个数的平方，并将结果保存到一个列表对象n_list中。最后返回列表对象，见代码第③行。代码第④行是遍历返回的列表对象。
在Python中还可以有更加好解决方案，实现代码如下：
def square(num):
for i in range(1, num + 1):
yield i * i ①
for i in square(5): ②
print(i, end=' ')
返回结果是：
1 4 9 16 25
代码第①行使用了yield关键字返回平方数，不再需要return关键字了。代码第②行调用函数square()返回的是生成器对象。生成器对象是一种可迭代对象，可迭代对象通过__next__()方法获得元素，代码第②行的for循环能够遍历可迭代对象，就是隐式地调用生成器的__next__()方法获得元素的。
显式地调用生成器的__next__()方法，在Python Shell中运行示例代码如下：
>>> def square(num):
for i in range(1, num + 1):
yield i * i
>>> n_seq = square(5)
<generator object square at 0x000001C8F123CE60>
>>> n_seq.__next__() ①
1
>>> n_seq.__next__()
4
>>> n_seq.__next__()
9
>>> n_seq.__next__()
16
>>> n_seq.__next__()
25
>>> n_seq.__next__() ②
Traceback (most recent call last):
File "<pyshell#33>", line 1, in <module>
n_seq.__next__()
StopIteration
>>>
上述代码第①行~第②行调用了6次__next__()方法，但第6次调用则会抛出StopIteration异常，这是因为已经没有元素可迭代了。
生成器函数是通过yield返回数据，与return不同的是：return语句一次返回所有数据，函数调用结束；而yield语句只返回一个元素数据，函数调用不会结束，只是暂停，直到__next__()方法被调用，程序继续执行yield语句之后的语句代码。这个过程如图10-1所示。
注意
生成器特别适合用于遍历一些大序列对象，它无须将对象的所有元素都载入内存后才开始进行操作。而是仅在迭代至某个元素时才会将该元素载入内存。
嵌套函数
在本节之前定义的函数都是全局函数，并将他们定义在全局作用域中。函数还可定义在另外的函数体中，称作“嵌套函数”。
示例代码：
# coding=utf-8
# 代码文件：chapter10/ch10.6.py
def calculate(n1, n2, opr):
multiple = 2
# 定义相加函数
def add(a, b): ①
return (a + b) * multiple
# 定义相减函数
def sub(a, b): ②
return (a - b) * multiple
if opr == '+':
return add(n1, n2)
else:
return sub(n1, n2)
print(calculate(10, 5, '+')) # 输出结果是30
# add(10, 5) 发生错误 ③
# sub(10, 5) 发生错误 ④
上述代码中定义了两个嵌套函数：add()和sub()，见代码第①行和第②行。嵌套函数可以访问所在外部函数calculate()中的变量multiple，而外部函数不能访问嵌套函数局部变量。另外，嵌套函数的作用域在外部函数体内，因此在外部函数体之外直接访问嵌套函数会发生错误，见代码第③行和第④行。
函数式编程基础
函数式编程（functional
programming）与面向对象编程一样都一种编程范式，函数式编程，也称为面向函数的编程。
Python并不是彻底的函数式编程语言，但是还是提供了一些函数式编程必备的技术，主要有：函数类型和Lambda表达式，他们是实现函数式编程的基础。
函数类型
Python提供了一种函数类型function，任何一个函数都有函数类型，但是函数调用时，就创建了函数类型实例，即函数对象。函数类型实例与其他类型实例一样，在使用场景上没有区别：它可以赋值给一个变量；也可以作为参数传递给一个函数；还可以作为函数返回值使用。
为了理解函数类型，先重构10.6节中嵌套函数的示例，示例代码如下：
# coding=utf-8
# 代码文件：chapter10/ch10.7.1.py
def calculate_fun(opr): ①
# 定义相加函数
def add(a, b):
return a + b
# 定义相减函数
def sub(a, b):
return a - b
if opr == '+':
return add ②
else:
return sub ③
f1 = calculate_fun('+') ④
f2 = calculate_fun('-') ⑤
print(type(f1))
print("10 + 5 = 0".format(f1(10, 5))) ⑥
print("10 - 5 = 0".format(f2(10, 5))) ⑦
输出结果：
<class 'function'>
10 + 5 = 30
10 - 5 = 10
上述代码第①行重构了calculate_fun()函数的定义，现在只接收一个参数opr。代码第②行是在opr
'+'为True时返回add函数名，否则返回sub函数名，见代码第③行。这里的函数名本质上函数对象。calculate_fun()函数与10.5节示例calculate()函数不同之处在于，calculate_fun()函数返回的是函数对象，calculate()函数返回的是整数（相加或相减计算之后的结果）。所以代码第④行的f1是add()函数对象，代码第⑤行的f2是sub()函数对象。
函数对象是可以与函数一样进行调用的。事实上在第⑥行之前没有真正调用add()函数进行相加计算，f1(10,
5)表达式才真的调用了add()函数。第⑦行的f2(10, 5)表达式是调用sub()函数。
Lambda表达式
理解了函数类型和函数对象，学习Lambda表达式就简单了。Lambda表达式本质上一种匿名函数，匿名函数也是函数有函数类型，也可以创建函数对象。
定义Lambda表达式语法如下：
lambda 参数列表 : Lambda体
lambda是关键字声明这是一个Lambda表达式，“参数列表”与函数的参数列表是一样的，但不需要小括号包裹起来，冒号后面是“Lambda体”，Lambda表达式主要的代码在此处编写，类似于函数体。
注意
Lambda体部分不能是一个代码块，不能包含多条语句，只有一条语句，语句会计算一个结果返回给Lambda表达式，但是与函数不同是，不需要使用return语句返回。与其他语言中的Lambda表达式相比，Python中提供Lambda表达式只能处理一些简单的计算。
重构10.7.1节示例，代码如下：
# coding=utf-8
# 代码文件：chapter10/ch10.7.2.py
def calculate_fun(opr):
if opr == '+':
return lambda a, b: (a + b) ①
else:
return lambda a, b: (a - b) ②
f1 = calculate_fun('+')
f2 = calculate_fun('-')
print(type(f1))
print("10 + 5 = 0".format(f1(10, 5)))
print("10 - 5 = 0".format(f2(10, 5)))
输出结果：
<class 'function'>
10 + 5 = 30
10 - 5 = 10
上述代码第①行替代了add()函数，第②行替代了sub()函数，代码变的非常的简单。
三大基础函数
函数式编程本质是通过函数处理数据，过滤、映射和聚合是处理数据的三大基本操作。针对但其中三大基本操作Python提供了三个基础的函数：filter()、map()和reduce()。
- filter()
过滤操作使用filter()函数，它可以对可迭代对象的元素进行过滤，filter()函数语法如下：
filter(function, iterable)
其中参数function是一个函数，参数iterable是可迭代对象。filter()函数调用时iterable会被遍历，它的元素逐一传入function函数，function函数返回布尔值，在function函数中编写过滤条件，如果为True的元素被保留，如果为False的元素被过滤掉。
下面通过一个示例介绍一下filter()函数使用，示例代码如下：
users = ['Tony', 'Tom', 'Ben', 'Alex']
users_filter = filter(lambda u: u.startswith('T'), users) ①
print(list(users_filter))
输出结果：
['Tony', 'Tom']
代码第①行调用filter()函数过滤users列表，过滤条件是T开通的元素，lambda u:
u.startswith(‘T’)是一个Lambda表达式，它提供了过滤条件。filter()函数还不是一个列表，需要使用list()函数转换过滤之后的数据为列表。
再看一个示例：
number_list = range(1, 11)
nmber_filter = filter(lambda it: it % 2 == 0, number_list)
print(list(nmber_filter))
该示例实现了获取1~10数字中的偶数，输出结果如下：
[2, 4, 6, 8, 10]
- map()
映射操作使用map()函数，它可以对可迭代对象的元素进行变换，map()函数语法如下：
map(function, iterable)函数式编程(代码片段)
编程的方法论：面向过程面向对象函数式 函数式编程的定义：函数式=编程语言定义的函数+数学意义上的函数（先想到一个数学模型，再用python上的功能实现这个逻辑） y=x+1defcat():returnx+1 特性：1.不用变量保存状... 查看详情
函数式编程简介-附入门方法(代码片段)
WHAT?什么是函数式编程？函数式编程是一种编程范式。编程范式又是什么？编程范式是一种解决问题的思路。我们熟悉的命令式编程把程序看作一系列改变状态的指令；而函数式编程把程序看作一系列数学函数映射的组合。编程... 查看详情
前端学习之函数式编程—函数式编程概念+头等函数(代码片段)
什么是函数式编程函数式编程（functionprogrammingFP）FP是编程范式之一，我们常听说的还有，面向过程编程，面向对象编程函数式编程的思维方式把现实世界的事物和事物之间的联系抽象到程序世界（对运算... 查看详情
textpython函数式编程(代码片段)
函数式编程(代码片段)
编程的三种方法论：1面向过程2函数式3面向对象---------------------------------------------#把函数当做参数传给另一个函数deffoo(n):print(n)defbar(name):print(‘mynameis%s‘%name)foo(bar(‘alex‘))输出结果：mynameisalexNone------------------------# 查看详情
函数式编程(代码片段)
《Python从小白到大牛》第10章函数式编程定义函数函数参数使用关键字参数调用函数参数默认值可变参数函数返回值无返回值函数多返回值函数函数变量作用域生成器嵌套函数函数式编程基础函数类型上述代码第①行重构了calcula... 查看详情
javascript函数式编程基础(代码片段)
javascript函数式编程基础函数调用引用做返回值/*javascript函数式编程基础*/functionsayHello()return"helloworld";letresult=sayHello();//函数调用letfn=sayHello;//函数引用console.log(fn());//helloworld//函数做返回值functionee( 查看详情
scala学习（函数式编程面向对象编程）(代码片段)
文章目录函数式编程基础函数编程函数定义函数参数函数至简原则高阶函数编程面向对象编程基础面向对象编程高阶面向对象编程函数式编程基础函数编程函数定义packagelearn03objectdemo01defmain(args:Array[String]):Unit=//无参、无返回... 查看详情
scala学习（函数式编程面向对象编程）(代码片段)
文章目录函数式编程基础函数编程函数定义函数参数函数至简原则高阶函数编程面向对象编程基础面向对象编程高阶面向对象编程函数式编程基础函数编程函数定义packagelearn03objectdemo01defmain(args:Array[String]):Unit=//无参、无返回... 查看详情
函数式编程java函数式编程学习(代码片段)
函数式编程-Stream流函数式编程思想概述面向对象思想关注的是用什么对象完成什么事情，而函数式编程思想就类似于数学中的函数，主要关注的是对数据进行了什么操作优点代码简洁，开发快；接近自然语言... 查看详情
函数式编程java函数式编程学习(代码片段)
函数式编程-Stream流函数式编程思想概述面向对象思想关注的是用什么对象完成什么事情，而函数式编程思想就类似于数学中的函数，主要关注的是对数据进行了什么操作优点代码简洁，开发快；接近自然语言... 查看详情
《java8实战》读书笔记12：函数式编程(代码片段)
《Java8实战》读书笔记12：函数式编程第13章函数式的思考13.1实现和维护系统13.1.1共享的可变数据13.1.2声明式编程13.2什么是函数式编程13.2.1函数式Java编程13.2.2引用透明性13.2.3面向对象的编程和函数式编程的对比13.2.4函数式编... 查看详情
玩转javascript面试：何为函数式编程？(代码片段)
函数式编程在JavaScript领域着实已经成为一个热门话题。就在几年前，很多JavaScript程序员甚至都不知道啥是函数式编程，但是就在近三年里我看到过的每一个大型应用的代码库中都包含了函数式编程思想的大规模使用。函数式编... 查看详情
vbscript函数式编程1(代码片段)
小丸子函数式编程初探(代码片段)
小丸子函数式编程初探小丸子函数式编程初探question函数式编程命令式编程vs函数式编程高阶函数实用小栗子1.question前一个项目，顺利完成的时候感觉特别棒。但是后面需求方迭代加需求的时候，甚至代码重构的时候... 查看详情
rxjs入门之函数响应式编程(代码片段)
一.函数式编程1.声明式（Declarativ）和声明式相对应的编程?式叫做命令式编程（ImperativeProgramming），命令式编程也是最常见的?种编程?式。//命令式编程：functiondouble(arr)constresults=[]for(leti=0;i<arr.length;i++)results.push(arr[i]*2)returnresult... 查看详情
函数式编程(代码片段)
...了Haskell这段代码该如何理解？今天突发奇想，尝试一把函数式编程的感觉~最近把bajdcc/jMiniLang继续修整了一下，修了点bug，界面开了抗锯齿，顿时美观度大增哈哈。依照【游 查看详情
php函数式编程(代码片段)
什么是函数式编程与面向对象编程（Object-orientedprogramming）和过程式编程（Proceduralprogramming）并列的编程范式。最主要的特征是，函数是第一等公民。强调将计算过程分解成可复用的函数，典型例子就是map方法和reduce方法组合而... 查看详情