一份很实在的Python进阶笔记，耐住性子开始好好学习吧！

编程梦工厂 2018-10-10 13:29:19

目录

1. 列表生成式
2. 函数的参数类型
3. lambda函数
4. map, reduce, filter, sorted函数
5. eval, exec, join, zip函数

列表生成式（私信小编007即可自动获取Python学习视频资料以及各类PDF！）

列表生成式即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 s
print(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 s
print(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 sum
print(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*x
f(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 * x
r = 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 reduce
def add(x, y):
 return x + y
reduce(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 reduce
a = ['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 zip
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
print(list(zipped))
# zip for loops
for i,j in zip(x,y):
 print(i, "->", j)
# unzip the list
a = [(1,2,3), (3,4,5)]
x2, y2, z2 = zip(*a)
print(x2)
print(y2)
print(z2)
# transpose a matrix
mtx = [(1, 2),
 (3, 4),
 (5, 6)]
print(list(zip(*mtx)))
# clustering a data series into n-length groups idiom
seq = range(1, 10)
print(list(zip(*[iter(seq)]*3)))
# dict and zip
keys = ['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 = 12
j = 13
exec("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 = 10
expr = """
z = 30
sum = x + y + z
print(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