函数
定义函数需要用def关键字实现，具体的语法格式如下：
def 函数名(形参列表):
//由零条到多条可执行语句组成的代码块
[return [返回值]]
其中，用[]括起来的为可选择部分，即可以使用，也可以省略。
此格式中，各部分参数的含义如下：
- 函数名：从语法角度来看，函数名只要是一个合法的标识符即可；从程序的可读性角度来看，函数名应该由一个或多个有意义的单词连缀而成，每个单词的字母全部小写，单词与单词之间使用下画线分隔。
- 形参列表：用于定义该函数可以接收的参数。形参列表由多个形参名组成，多个形参名之间以英文逗号
（,）隔开。一旦在定义函数时指定了形参列表，调用该函数时就必须传入相应的参数值，也就是说，谁调用函数谁负责为形参赋值。
函数的调用
函数调用的基本语法格式如下所示：
函数名([形参值])
其中，函数名即指的是要调用的函数的名称；形参值指的是当初创建函数时要求传入的各个形参的值。需要注意的是，创建函数有多少个形参，那么调用时就需要传入多少个值，且顺序必须和创建函数时一致。即便该函数没有参数，函数名后的小括号也不能省略。
def my_max(x, y) :
# 定义一个变量z，该变量等于x、y中较大的值
z = x if x > y else y
# 返回变量z的值
return z
# 定义一个函数，声明一个形参
def say_hi(name) :
print("===正在执行say_hi()函数===")
return name + "，您好！"
a = 6
b = 9
# 调用my_max()函数，将函数返回值赋值给result变量
result = my_max(a , b)
print("result:", result)
# 调用say_hi()函数，直接输出函数的返回值
print(say_hi("孙悟空"))
"""输出结果
result: 9
===正在执行say_hi()函数===
孙悟空，您好！
"""
函数说明文档
只要把一段字符串放在函数声明之后、函数体之前，这段字符串将被作为函数的部分，这个文档就是函数的说明文档。
def my_max(x, y) :
'''
获取两个数值之间较大数的函数。
my_max(x, y)
返回x、y两个参数之间较大的那个
'''
# 定义一个变量z，该变量等于x、y中较大的值
z = x if x > y else y
# 返回变量z的值
return z
# 使用help()函数查看my_max的帮助文档
help(my_max)
#或者 print(my_max.__doc__)
"""
Help on function my_max in module __main__:
my_max(x, y)
获取两个数值之间较大数的函数。
my_max(x, y)
返回x、y两个参数之间较大的那个
"""
参数传递
在使用函数时，经常会用到形式参数（简称“形参”）和实际参数（简称“实参”），二者都叫参数，之间的区别是：
- 形式参数：在定义函数时，函数名后面括号中的参数就是形式参数
- 实际参数：在调用函数时，函数名后面括号中的参数称为实际参数，也就是函数的调用者给函数的参数。
#定义函数时，这里的函数参数 obj 就是形式参数
def demo(obj)
print(obj)
a = "我的世界"
#调用已经定义好的 demo 函数，此时传入的函数参数 a 就是实际参数
demo(a)
Python中，根据实际参数的类型不同，函数参数的传递方式可分为2种，分别为值传递和引用（地址）传递：
- 值传递：适用于实参类型为不可变类型（字符串、数字、元组）；
- 引用（地址）传递：适用于实参类型为可变类型（列表，字典）；
值传递和引用传递的区别是，函数参数进行值传递后，若形参的值发生改变，不会影响实参的值；而函数参数继续引用传递后，改变形参的值，实参的值也会一同改变。
def demo(obj) :
obj += obj
print("形参值为：",obj)
print("-------值传递-----")
a = "我的世界"
print("a的值为：",a)
demo(a)
print("实参值为：",a)
print("-----引用传递-----")
a = [1,2,3]
print("a的值为：",a)
demo(a)
print("实参值为：",a)
"""
-------值传递-----
a的值为： 我的世界
形参值为： 我的世界我的世界
实参值为： 我的世界
-----引用传递-----
a的值为： [1, 2, 3]
形参值为： [1, 2, 3, 1, 2, 3]
实参值为： [1, 2, 3, 1, 2, 3]
"""
- 不管什么类型的参数，在
Python函数内部对形式参数直接使用“=”符号赋值是没用的，直接使用“=”符号赋值并不能改变实际参数。 - 如果需要让函数修改某些数据，则可以通过把这些数据包装成列表、字典等可变对象，然后把列表、字典等可变对象作为参数传入函数，在函数中通过列表、字典的方法修改它们，这样才能改变这些数据。
位置参数
位置参数，有时也称必备参数，指的是必须按照正确的顺序将实际参数传到函数中，也就是说，调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致。
实参和形参数量必须一致
在调用函数，指定的实际参数的数量，必须和形式参数的数量一致（传多传少都不行），否则Python解释器会抛出TypeError异常，并提示缺少必要的位置参数。
def girth(width , height):
return 2 * (width + height)
#调用函数时，必须传递 2 个参数，否则会引发错误
print(girth(3))
#调用函数时，必须传递 2 个参数，否则会引发错误
print(girth(3,2,4))
实参和形参位置必须一致
在调用函数时，传入实际参数的位置必须和形式参数位置一一对应，否则会产生以下 2 种结果：
-
抛出
TypeError异常 当实际参数类型和形式参数类型不一致，并且在函数种中，这两种类型之间不能正常转换，此时就会抛出TypeError异常。def area(height,width): return height*width/2 print(area("我的世界",3)) """ Traceback (most recent call last): File "C:\Users\mengma\Desktop\1.py", line 3, in <module> print(area("我的世界",3)) File "C:\Users\mengma\Desktop\1.py", line 2, in area return height*width/2 TypeError: unsupported operand type(s) for /: 'str' and 'int' """ -
产生的结果和预期不符调用函数时，如果指定的实际参数和形式参数的位置不一致，但它们的数据类型相同，那么程序将不会抛出异常，只不过导致运行结果和预期不符。
def area(upper_base,lower_bottom,height): return (upper_base+lower_bottom)*height/2 print("正确结果为：",area(4,3,5)) print("错误结果为：",area(4,5,3)) """ 正确结果为： 17.5 错误结果为： 13.5 """
关键字参数
关键字参数是指使用形式参数的名字来确定输入的参数值。通过此方式指定函数实参时，不再需要与形参的位置完全一致，只要将参数名写正确即可。
# 定义一个函数
def girth(width , height):
print("width: ", width)
print("height: ", height)
return 2 * (width + height)
# 传统调用函数的方式，根据位置传入参数
print(girth(3.5, 4.8))
# 根据关键字参数来传入参数
print(girth(width = 3.5, height = 4.8))
# 使用关键字参数时可交换位置
print(girth(height = 4.8, width = 3.5))
# 部分使用关键字参数，部分使用位置参数
print(girth(3.5, height = 4.8))
#=============================================
# 位置参数必须放在关键字参数之前，下面代码错误
print(girth(width = 3.5, 4.8))
"""
SyntaxError: positional argument follows keyword argument
"""
#=============================================
默认参数
定义带有默认值参数的函数，其语法格式如下：
def 函数名(...，形参名=默认值)：
代码块
在使用此格式定义函数时，指定有默认值的形式参数必须在所有没默认值参数的最后，否则会产生语法错误。
由于Python要求在调用函数时关键字参数必须位于位置参数的后面，因此在定义函数时指定了默认值的参数（关键字参数）必须在没有默认值的参数之后。
# 为两个参数指定默认值
def say_hi(name = "孙悟空", message = "欢迎来到掌中佛国"):
print(name, ", 您好")
print("消息是：", message)
# 全部使用默认参数
say_hi()
# 只有message参数使用默认值
say_hi("白骨精")
# 两个参数都不使用默认值
say_hi("白骨精", "欢迎进入三打白骨精剧情")
# 只有name参数使用默认值
say_hi(message = "欢迎进入三打白骨精剧情")
可变参数
可变参数，又称不定长参数，即传入函数中的实际参数可以是任意多个。
1) 可变参数：形参前添加一个'*'
此种形式的语法格式如下所示：
*args
其中，args表示创建一个名为args的空元组，该元组可接受任意多个外界传入的非关键字实参。
# 定义了支持参数收集的函数
def test(a, *books) :
print(books)
# books被当成元组处理
for b in books :
print(b)
# 输出整数变量a的值
print(a)
# 调用test()函数
test(5 , "我的世界" , "你的世界")
# 个数可变的形参不是在形参列表最后位置，
# 则调用时普通参数必须以关键字实参的形式传值。
# 定义了支持参数收集的函数
def test(*books ,num) :
print(books)
# books被当成元组处理
for b in books :
print(b)
print(num)
# 调用test()函数
test("我的世界", "你的世界", num = 20)
2) 可变参数：形参前添加两个**
这种形式的语法格式如下：
**kwargs
*kwargs表示创建一个名为kwargs的空字典。该字典可以接收任意多个以关键字参数赋值的实际参数。
# 定义了支持参数收集的函数
def test(x, y, z=3, *books, **scores) :
print(x, y, z)
print(books)
print(scores)
###第一种调用
test(1, 2, 3, "我的世界" , "你的世界", 语文=89, 数学=94)
"""
1 2 3
('我的世界', '你的世界')
{'语文': 89, '数学': 94}
"""
###第二种调用
test(1, 2, "我的世界" , "你的世界", 语文=89, 数学=94)
"""
1 2 我的世界
('Python教程',)
{'语文': 89, '数学': 94}
"""
###第三种调用
test(1, 2, 语文=89, 数学=94)
"""
1 2 3
()
{'语文': 89, '数学': 94}
"""
逆向参数收集
所谓逆向参数收集，指的是在程序己有列表、元组、字典等对象的前提下，把它们的元素“拆开”后传给函数的参数。逆向参数收集需要在传入的列表、元组参数之前添加一个星号，在字典参数之前添加两个星号。例如如下代码：
def test(name, message):
print("用户是: ", name)
print("欢迎消息: ", message)
my_list = ['小明', '欢迎来我的世界']
test(*my_list)
"""
用户是: 小明
欢迎消息: 欢迎来我的世界
"""
def bar(book, price, desc):
print(book, "VIP价格是:", price)
print('描述信息', desc)
my_dict = {'price': 159, 'book': '我的世界', 'desc': '这是一个精美而实用的书籍'}
# 按逆向收集的方式将my_dict的多个key-value传给bar()函数
bar(**my_dict)
"""
我的世界 VIP价格是: 159
描述信息 这是一个精美而实用的书籍
"""
即使是可变参数，如果程序需要将一个元组传给该参数，那么同样需要使用逆向收集。例如如下代码：
def foo(name, *nums):
print("name参数: ", name)
print("nums参数: ", nums)
my_tuple = (1, 2, 3)
# 使用逆向收集，将my_tuple元组的元素传给nums参数
foo('fkit', *my_tuple)
"""
name参数: fkit
nums参数: (1, 2, 3)
"""
# 使用逆向收集，将my_tuple元组的第一个元素传给name参数，剩下参数传给nums参数
foo(*my_tuple)
"""
name参数: 1
nums参数: (2, 3)
"""
# 不使用逆向收集，my_tuple元组整体传给name参数
foo(my_tuple)
"""
name参数: (1, 2, 3)
nums参数: ()
"""
return函数返回值
Python中，用 def 语句创建函数时，可以用return语句指定应该返回的值，该返回值可以是任意类型。需要注意的是，return 语句在同一函数中可以出现多次，但只要有一个得到执行，就会直接结束函数的执行。
函数中，使用return语句的语法格式如下：
return [返回值]
其中，返回值参数可以指定，也可以省略不写（将返回空值 None）。
def add(a,b):
c = a + b
return c
#函数赋值给变量
c = add(3,4)
print(c)
#函数返回值作为其他函数的实际参数
print(add(3,4))
"""
7
7
"""
函数多个返回值
如果程序需要有多个返回值，则既可将多个值包装成列表之后返回，也可直接返回多个值。如果 Python函数直接返回多个值，Python会自动将多个返回值封装成元组。
def sum_and_avg(list):
sum = 0
count = 0
for e in list:
# 如果元素e是数值
if isinstance(e, int) or isinstance(e, float):
count += 1
sum += e
return sum, sum / count
my_list = [20, 15, 2.8, 'a', 35, 5.9, -1.8]
# 获取sum_and_avg函数返回的多个值，多个返回值被封装成元组
tp = sum_and_avg(my_list)
print(tp)
# 使用序列解包来获取多个返回值
s, avg = sum_and_avg(my_list)
print(s)
print(avg)
函数递归
在一个函数体内调用它自身，被称为函数递归。函数递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
def fn(n) :
if n == 0 :
return 1
elif n == 1 :
return 4
else :
# 函数中调用它自身，就是函数递归
return 2 * fn(n - 1) + fn(n - 2)
# 输出fn(10)的结果
print("fn(10)的结果是:", fn(10))
当一个函数不断地调用它自身时，必须在某个时刻函数的返回值是确定的，即不再调用它自身；否则，这种递归就变成了无穷递归，类似于死循环。因此，在定义递归函数时有一条最重要的规定： 递归一定要向已知方向进行。
变量作用域
在程序中定义一个变量时，这个变量是有作用范围的，变量的作用范围被称为它的作用域。换句话说，变量的作用域指的是程序代码能够访问该变量的区域，如果超过该区域，将无法访问该变量。
根据定义变量的位置（有效范围），可以将变量分为局部变量和全局变量。
局部变量
局部变量是指在函数内部定义并使用的变量，它只在函数内部有效。
def text():
demo = '我的世界'
print(demo)
text()
#此处获取局部变量值会引发错误
print('局部变量 demo 的值为：',demo)
"""输出结果
我的世界
Traceback (most recent call last):
File "C:\Users\mengma\Desktop\1.py", line 5, in <module>
print('局部变量 demo 的值为：',demo)
NameError: name 'demo' is not defined
"""
全局变量
和局部变量相对应，全局变量指的是能作用于函数内外的变量，即全局变量既可以在各个函数的外部使用，也可以在各函数内部使用。
定义全局变量的方式有以下 2 种：
-
在函数体外定义的变量，一定是全局变量，例如：
demo = "我的世界" def text(): print("函数体内访问：",demo) text() print('函数体外访问：',demo) """ 函数体内访问： 我的世界 函数体外访问： 我的世界 """ -
在函数体内定义全局变量。即使用 global 关键字对变量进行修饰后，该变量就会变为全局变量。例如：
def text(): global demo #在使用 global 关键字修饰变量名时，不能直接给变量赋初值，否则会引发语法错误。 demo = "我的世界" print("函数体内访问：",demo) text() print('函数体外访问：',demo) """ 函数体内访问： 我的世界 函数体外访问： 我的世界 """
函数中使用全局变量
在函数中声明全局变量。为了避免在函数中对全局变量赋值（不是重新定义局部变量），可使用global语句来声明全局变量。因此，可将程序改为如下形式：
name = 'Charlie'
def test ():
# 声明name是全局变量，后面的赋值语句不会重新定义局部变量
global name
# 直接访问name全局变量
print(name) # Charlie
name = '孙悟空'
test()
print(name) # 孙悟空
增加了“global name”声明之后，程序会把name变量当成全局变量，这意味着test()函数后面对name赋值的语句只是对全局变量赋值，而不是重新定义局部变量。
局部函数
Python还支持在函数体内定义函数，这种被放在函数体内定义的函数称为局部函数。
在默认情况下，局部函数对外部是隐藏的，局部函数只能在其封闭（enclosing）函数内有效，其封闭函数也可以返回局部函数，以便程序在其他作用域中使用局部函数。
def get_math_func(type, nn) :
# 定义一个计算平方的局部函数
def square(n) : #
return n * n
# 定义一个计算立方的局部函数
def cube(n) : #
return n * n * n
# 定义一个计算阶乘的局部函数
def factorial(n) : #
result = 1
for index in range(2, n + 1) :
result *= index
return result
# 调用局部函数
if type == "square" :
return square(nn)
elif type == "cube":
return cube(nn)
else:
return factorial(nn)
print(get_math_func("square", 3)) # 输出9
print(get_math_func("cube", 3)) # 输出27
print(get_math_func("", 3)) # 输出6
Python高级用法
使用函数变量
Python的函数也是一种值：所有函数都是function对象，这意味着可以把函数本身赋值给变量，就像把整数、浮点数、列表、元组赋值给变量一样。
当把函数赋值给变量之后，接下来程序也可通过该变量来调用函数。 例如如下代码：
# 定义一个计算乘方的函数
def pow(base, exponent) :
result = 1
for i in range(1, exponent + 1) :
result *= base
return result
# 将pow函数赋值给my_fun，则my_fun可当成pow使用
my_fun = pow
print(my_fun(3 , 4)) # 输出81
# 定义一个计算面积的函数
def area(width, height) :
return width * height
# 将area函数赋值给my_fun，则my_fun可当成area使用
my_fun = area
print(my_fun(3, 4)) # 输出12
使用函数作为函数形参
Python支持像使用其他参数一样使用函数参数，例如如下程序：
# 定义函数类型的形参，其中fn是一个函数
def map(data, fn) :
result = []
# 遍历data列表中每个元素，并用fn函数对每个元素进行计算
# 然后将计算结果作为新数组的元素
for e in data :
result.append(fn(e))
return result
# 定义一个计算平方的函数
def square(n) :
return n * n
# 定义一个计算立方的函数
def cube(n) :
return n * n * n
# 定义一个计算阶乘的函数
def factorial(n) :
result = 1
for index in range(2, n + 1) :
result *= index
return result
data = [3 , 4 , 9 , 5, 8]
print("原数据: ", data)
# 下面程序代码3次调用map()函数，每次调用时传入不同的函数
print("计算数组元素的平方")
print(map(data , square))
print("计算数组元素的立方")
print(map(data , cube))
print("计算数组元素的阶乘")
print(map(data , factorial))
"""计算结果
原数据: [3, 4, 9, 5, 8]
计算数组元素的平方
[9, 16, 81, 25, 64]
计算数组元素的立方
[27, 64, 729, 125, 512]
计算数组元素的阶乘
[6, 24, 362880, 120, 40320]
"""
使用函数作为返回值（闭包）
Python还支持使用函数作为其他函数的返回值。例如如下程序：
def get_math_func(type) :
# 定义一个计算平方的局部函数
def square(n) : # ①
return n * n
# 定义一个计算立方的局部函数
def cube(n) : # ②
return n * n * n
# 定义一个计算阶乘的局部函数
def factorial(n) : # ③
result = 1
for index in range(2 , n + 1):
result *= index
return result
# 返回局部函数
if type == "square" :
return square
if type == "cube" :
return cube
else:
return factorial
# 调用get_math_func()，程序返回一个嵌套函数
math_func = get_math_func("cube") # 得到cube函数
print(math_func(5)) # 输出125
math_func = get_math_func("square") # 得到square函数
print(math_func(5)) # 输出25
math_func = get_math_func("other") # 得到factorial函数
print(math_func(5)) # 输出120
闭包
闭包，又称闭包函数或者闭合函数，其实和前面讲的嵌套函数类似，不同之处在于，闭包中外部函数返回的不是一个具体的值，而是一个函数。一般情况下，返回的函数会赋值给一个变量，这个变量可以在后面被继续执行调用。
#闭包函数，其中 exponent 称为自由变量
def nth_power(exponent):
def exponent_of(base):
return base ** exponent
return exponent_of # 返回值是 exponent_of 函数
square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方
print(square(2)) # 计算 2 的平方
print(cube(2)) # 计算 2 的立方
"""计算结果
4
8
"""
# 上面函数等同于
def nth_power_rewrite(base, exponent):
return base ** exponent
# 不使用闭包
res1 = nth_power_rewrite(base1, 2)
res2 = nth_power_rewrite(base2, 2)
res3 = nth_power_rewrite(base3, 2)
# 使用闭包
square = nth_power(2)
res1 = square(base1)
res2 = square(base2)
res3 = square(base3)
使用闭包方式表达更为简洁，在每次调用函数时，都可以少输入一个参数。
匿名函数(lambda表达式)
lambda表达式（又称匿名函数）是现代编程语言争相引入的一种语法，如果说函数是命名的、方便复用的代码块，那么 lambda 表达式则是功能更灵活的代码块，它可以在程序中被传递和调用。
def get_math_func(type) :
# 定义三个局部函数
...
# 返回局部函数
if type == "square" :
return square
if type == "cube" :
return cube
else:
return factorial
由于局部函数的作用域默认仅停留在其封闭函数之内，因此这三个局部函数的函数名的作用太有限了，即仅仅是在程序的 if 语句中作为返回值使用。一旦离开了 get_math_func()函数体，这三个局部函数的函数名就失去了意义。
既然局部函数的函数名没有太大的意义，那么就考虑使用 lambda 表达式来简化局部函数的写法。
lambda表达式的语法格式如下：
lambda [parameter_list] : 表达式
从上面的语法格式可以看出lambda表达式的几个要点：
lambda表达式必须使用lambda关键字定义。- 在
lambda关键字之后、冒号左边的是参数列表，可以没有参数，也可以有多个参数。如果有多个参数，则需要用逗号隔开，冒号右边是该lambda表达式的返回值。
def get_math_func(type) :
result=1
# 该函数返回的是Lambda表达式
if type == 'square':
return lambda n: n * n # ①
elif type == 'cube':
return lambda n: n * n * n # ②
else:
return lambda n: (1 + n) * n / 2 # ③
# 调用get_math_func()，程序返回一个嵌套函数
math_func = get_math_func("cube")
print(math_func(5)) # 输出125
math_func = get_math_func("square")
print(math_func(5)) # 输出25
math_func = get_math_func("other")
print(math_func(5)) # 输出15.0
lambda表达式依然有如下两个用途：
- 对于单行函数，使用
lambda表达式可以省去定义函数的过程，让代码更加简洁。 - 对于不需要多次复用的函数，使用
lambda表达式可以在用完之后立即释放，提高了性能。
# 传入计算平方的lambda表达式作为参数
x = map(lambda x: x*x , range(8))
print([e for e in x]) # [0, 1, 4, 9, 16, 25, 36, 49]
# 传入计算平方的lambda表达式作为参数
y = map(lambda x: x*x if x % 2 == 0 else 0, range(8))
print([e for e in y]) # [0, 0, 4, 0, 16, 0, 36, 0]
函数式编程
所谓函数式编程，是指代码中每一块都是不可变的，都由纯函数的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出。
def multiply_2(list):
for index in range(0, len(list)):
list[index] *= 2
return list
list=[1,2,3,4,5]
list2=multiply_2(list)
print(list)
list3=multiply_2(list)
print(list)
print(list2)
print(list3)
需要注意的是，这段代码不是一个纯函数的形式，因为列表中元素的值被改变了，如果多次调用multiply_2()函数，那么每次得到的结果都不一样。
想让multiply_2()成为一个纯函数的形式，就得重新创建一个新的列表并返回，也就是写成下面这种形式：
def multiply_2_pure(list):
new_list = []
for item in list:
new_list.append(item * 2)
return new_list
纯粹的函数式编程语言（比如Scala），其编写的函数中是没有变量的，因此可以保证，只要输入是确定的，输出就是确定的；而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出。
Python允许使用变量，所以它并不是一门纯函数式编程语言。Python 仅对函数式编程提供了部分支持，主要包括map()、filter()和reduce()这 3 个函数，它们通常都结合lambda匿名函数一起使用。
map()函数
map()函数的基本语法格式如下：
map(function, iterable)
其中，function参数表示要传入一个函数，其可以是内置函数、自定义函数或者lambda匿名函数；iterable表示一个或多个可迭代对象，可以是列表、字符串等。map()函数的功能是对可迭代对象中的每个元素，都调用指定的函数，并返回一个map对象。
listDemo = [1, 2, 3, 4, 5]
listDemo1 = [1, 2, 3, 4, 5]
listDemo2 = [3, 4, 5, 6, 7]
new_list1 = map(lambda x: x * 2, listDemo)
print(list(new_list1))
new_list2 = map(lambda x,y: x + y, listDemo1,listDemo2)
print(list(new_list2))
filter()函数
filter()函数的基本语法格式如下：
filter(function, iterable)
此格式中，funcition参数表示要传入一个函数，iterable表示一个可迭代对象。filter()函数的功能是对iterable中的每个元素，都使用function函数判断，并返回 True或者False，最后将返回True 的元素组成一个新的可遍历的集合。
listDemo = [1, 2, 3, 4, 5]
new_list = filter(lambda x: x % 2 == 0, listDemo)
print(list(new_list))
"""计算结果
[2, 4]
"""
listDemo1 = [1, 2, 3, 4, 5]
new_list1 = map(lambda x,y: x-y>0,[3,5,6],[1,5,8] )
print(list(new_list1))
"""计算结果
[True, False, False]
"""
reduce()函数
reduce()函数通常用来对一个集合做一些累积操作，其基本语法格式为：
reduce(function, iterable)
其中，function规定必须是一个包含 2 个参数的函数；iterable表示可迭代对象。注意，由于reduce()函数在Python 3.x中已经被移除，放入了functools模块，因此在使用该函数之前，需先导入functools模块。
import functools
listDemo = [1, 2, 3, 4, 5]
product = functools.reduce(lambda x, y: x * y, listDemo)
print(product)
"""
120
"""