一份很实在的Python进阶笔记，耐住性子开始好好学习吧！
目录
列表生成式
函数的参数类型
lambda函数
map, reduce, filter, sorted函数
eval, exec, join, zip函数
列表生成式
列表生成式即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
