转载自百家号作者：空手忆岁月
目录
列表生成式函数的参数类型lambda函数map, reduce, filter, sorted函数eval, exec, join, zip函数如果你感觉学不会？莫慌，小编推荐大家加入群，
前面548中间377后面875，群里有志同道合的小伙伴，
互帮互助，还可以拿到许多视频教程！
列表生成式
列表生成式即list comprehensions，是python内置的非常简单却强大的可以用来创建list的生成式。一般是利用原有的数据结构来生成新的列表。
# 利用range()生成[1,2,...,9,10]list(range(1,11))# 生成[1x1, 2x2, 3x3, ..., 10x10][x * x for x in range(1, 11)]# 可以通过占位符_代表列表中的元素[_*_ for _ in range(1,11)]# 筛选出仅偶数的平方, 在for循环后加上if判断语句[x * x for x in range(1, 11) if x % 2 == 0]# 利用占位符简化[_*_ for _ in range(1, 11) if not _%2]# 两层循环，三层循环，....[m + n for m in 'abc' for n in 'xyz'][x+y+z for x in 'ab' for y in 'cd' for z in 'ef']# 遍历字典，生成列表d = {'x': 'a', 'y': 'b', 'z': 'c' }[k + '=' + v for k, v in d.items()]
函数的参数类型
在python中定义函数，其参数类型有：
位置参数默认参数可变参数关键字参数
这4种参数都可以一起使用，或者只用其中某些，但是请注意，参数定义的顺序必须是：位置参数、默认参数、可变参数和关键字参数。
可变参数以*开头，允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。关键字参数以**开头，允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个dict。若默认参数与可变参数放在一起，则接受完默认参数后，其后参数为可变参数。
位置参数
位置参数指定名称的必须放在未指定名称的后面
def person(name,age,city):s = info: name=%s, age=%s, city=%s%(name,age,city) return sprint(person('jack', 25, 'ny'))print(person(name='jack', age=25, city='ny'))print(person('jack', 25, city='ny'))# 下面的参数使用有误，位置参数指定名称的必须放在未指定名称的后面print(person(name='jack', 25, 'ny'))
默认参数
默认参数必须放在非默认参数的后面,可以该表默认参数的值
def person(name, city, age=18):s = info: name=%s, age=%s, city=%s%(name,age,city) return sprint(person('jack', 'ny'))print(person('jack', 'ny', 20))
可变参数
可变参数以*开头，允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。函数参数的长度是可以变化的， 例如内置的sum, min, max等
def var_sum(*args):sum = 0 for i in args: sum += i return sumprint(var_sum(1,2,3))print(var_sum(1,2,3,4))# 利用*号来分解参数print(var_sum(*[1,2,3,4,5]))
若位置参数或默认参数与可变参数放在一起，则接受完位置参数或默认参数后，其后参数为可变参数。
def var_sum(a, *args):sum = 0 for i in args: sum += i print('a is %s, sum is %s'%(a,sum))var_sum(1,2)var_sum(1,2,3)
关键字参数
关键字参数以**开头，允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个dict。
def test_args(**kwargs):print('-'*20) for key in kwargs: print('key:', key, ',value:', kwargs[key]) print()test_args(a=1,b=2)test_args(a=1,b=2,c=3)
lambda函数
lambda函数即为匿名函数，用关键字lambda表示，冒号（：）前面的为参数，后面为返回值,不用写return.
如：
lambda x: x*x
匿名函数有个限制，就是只能有一个表达式，一般一行代码，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数，即函数也是变量，此为函数式编程(functional programming)思想。
f = lambda x: x*xf(5)
map, reduce, filter, sorted函数
map函数
map()函数接收两个参数，一个是函数，一个是iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的iterator返回。
可以直接作用于for循环的对象统称为可迭代对象：iterable.
举例说明，比如我们有一个函数f(x)=x^2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：
# map函数： 一一映射def f(x):return x * xr = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])list(r)# 利用lambda简化上述代码list(map(lambda x: x*x, range(1, 11)))
再例如： 把list所有数字转为字符串：
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
reduce函数
reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，一个是函数，一个是iterable. reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
比方说对一个序列求和，就可以用reduce实现：
# 导入reduce, 这很重要from functools import reducedef add(x, y):return x + yreduce(add, [1, 3, 5, 7, 9])# 利用lambda函数简化reduce(lambda x,y: x+y, range(1,10,2))
作业： 利用reduce将序列[1, 3, 5, 7, 9]转化为整数13579.
map, reduce的一个复杂例子：
将字符串列表['1', '3', '5', '7', '9']转化为整数13579
from functools import reducea = ['1', '3', '5', '7', '9']t = reduce(lambda x,y: 10*x+y, map(int, a))print(t)
filter函数
python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是true还是false决定保留还是丢弃该元素。
例如，在一个list中，删掉偶数，只保留奇数，可以这么写：
list(filter(lambda x: x%2 == 1, [1, 2, 4, 5, 6, 9, 10, 15]))
sorted函数
python内置的sorted()函数就可以对list进行排序。
sorted([36, 5, -12, 9, -21])
此外，sorted()函数还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：
sorted([36, 5, -12, 9, -21], key=abs)sorted(['bob', 'about', 'zoo', 'credit'], key=str.lower, reverse=true)
高阶函数，就是让函数的参数能够接收别的函数。map, reduce, filter, sorted都是高阶函数。
join, zip, eval, exec函数
join函数
python中的join函数有两个，分别为: join()和os.path.join()，具体作用如下：
join()： 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串os.path.join()： 将多个路径组合后返回
字符串中的join()函数的使用方法：
'sep'.join(seq)
sep：分隔符。可以为空。 seq：要连接的元素序列。 返回一个新的字符串。
seq = ['hello','good','boy','dido']print(' '.join(seq))print('*'.join(seq))
zip函数
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
# basic use of zipx = [1, 2, 3]y = [4, 5, 6]zipped = zip(x, y)print(list(zipped))# zip for loopsfor i,j in zip(x,y):print(i, ->, j)# unzip the lista = [(1,2,3), (3,4,5)]x2, y2, z2 = zip(*a)print(x2)print(y2)print(z2)# transpose a matrixmtx = [(1, 2), (3, 4), (5, 6)]print(list(zip(*mtx)))# clustering a data series into n-length groups idiomseq = range(1, 10)print(list(zip(*[iter(seq)]*3)))# dict and zipkeys = ['spam', 'eggs']vals = [42, 1729]d = dict(zip(keys, vals))print(d)
eval函数
eval()函数用来计算字符串表达式的值
t = eval(23)print(t)print(type(t))print(eval((1+2)*(3+4)))
exec函数
exec()函数是python的内置函数，不同于eval()函数只能执行计算数学表达式的结果的功能，exec()能够动态地执行复杂的python代码，能够十分强大。
简单例子：
# 执行简单的python语句i = 12j = 13exec(answer=i*j)print(answer is %s%answer)# 执行复杂的python语句func = def fact(n): return 1 if n==1 else n*fact(n-1)exec(func)a = fact(5)print(a)
exec函数还可以执行储存在其他文件中的python代码，例如位于e盘的eg.txt,如下：
def fact(n):if n==1: return 1 else: return n*fact(n-1)t = fact(6)print(t)
利用exec函数执行eg.txt中的代码：
with open('e://eg.txt', 'r') as f:s = f.read()exec(s)
还可以在exec()函数中加入参数,参数的传递可以写成字典(dict)形式。
x = 10expr = z = 30sum = x + y + zprint(sum)def func():y = 20 exec(expr) exec(expr, {'x': 1, 'y': 2}) exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})func()
输出结果为：
60 33 34