- 列表生成式
- 函数的参数类型
- lambda函数
- map, reduce, filter, sorted函数
- eval, exec, join, zip函数
- itertools中的函数
- copy与deepcopy函数
- 模块
- os、sys模块
- 迭代器
- 生成器
- 迭代器
参考网站：
- Python3教程： https://www.python-course.eu/python3_course.php
- Python之函数参数的使用：https://blog.csdn.net/jclian91/article/details/78309522
- 廖雪峰Python教程: https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000
- Python之浅谈exec函数： https://blog.csdn.net/jclian91/article/details/80076512
- Python官网的itertools说明： https://docs.python.org/3.6/library/itertools.html
- Python-copy()与deepcopy()区别: https://blog.csdn.net/qq_32907349/article/details/52190796
- copy模块官网：https://docs.python.org/3.5/library/copy.html
列表生成式
列表生成式即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):\n\treturn 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
itertools模块中的函数
Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数。
itertools模块提供的全部是处理迭代功能的函数，它们的返回值不是list，而是Iterator，只有用for循环迭代的时候才真正计算。
无穷迭代器
| Iterator | Arguments | Results | Example |
|---|---|---|---|
| count() | start, [step] | start, start+step, start+2*step, ... | count(10) --> 10 11 12 13 14 ... |
| cycle() | p | p0, p1, ... plast, p0, p1, ... | cycle('ABCD') --> A B C D A B C D ... |
| repeat() | elem [,n] | elem, elem, elem, ... endlessly or up to n times | repeat(10, 3) --> 10 10 10 |
“有限”迭代器
| Iterator | Arguments | Results | Example |
|---|---|---|---|
| accumulate() | p [,func] | p0, p0+p1, p0+p1+p2, ... | accumulate([1,2,3,4,5]) --> 1 3 6 10 15 |
| chain() | p, q, ... | p0, p1, ... plast, q0, q1, ... | chain('ABC', 'DEF') --> A B C D E F |
| chain.from_iterable() | iterable | p0, p1, ... plast, q0, q1, ... | chain.from_iterable(['ABC', 'DEF']) --> A B C D E F |
| compress() | data, selectors | (d[0] if s[0]), (d[1] if s[1]), ... | compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F |
| dropwhile() | pred, seq | seq[n], seq[n+1], starting when pred fails | dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1 |
| filterfalse() | pred, seq | elements of seq where pred(elem) is false | filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8 |
| groupby() | iterable[, keyfunc] | sub-iterators grouped by value of keyfunc(v) | |
| islice() | seq, [start,] stop [, step] | elements from seq[start:stop:step] | islice('ABCDEFG', 2, None) --> C D E F G |
| starmap() | func, seq | func(seq[0]), func(seq[1]), ... | starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000 |
| takewhile() | pred, seq | seq[0], seq[1], until pred fails | takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4 |
| tee() | it, n | it1, it2, ... itn splits one iterator into n | |
| zip_longest() | p, q, ... | (p[0], q[0]), (p[1], q[1]), ... | zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D- |
groupby()函数
groupby()把迭代器中相邻的重复元素挑出来放在一起：
for key, group in itertools.groupby('AAABBBCCAAA'):
print(key, list(group))
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']
实际上挑选规则是通过函数完成的，只要作用于函数的两个元素返回的值相等，这两个元素就被认为是在一组的，而函数返回值作为组的key。
另一个例子
# 按身高归类
from itertools import *
def height_class(h):
if h>180:
return 'tall'
elif h<160:
return 'short'
else:
return 'middle'
friends = [191, 158, 159, 165, 170, 177, 181, 182, 190]
for m,n in groupby(friends,key = height_class):
print(m)
print(list(n))
作业： 对于一组身高的数据（list），利用上面代码给出的身高标准，将所以的tall, short, middle归为一类。注意与groupby()函数的区别。
tee()函数
把一个迭代器分为n个迭代器, 返回一个元组.默认是两个
from itertools import *
a = "hello"
c, d, e = tee(iter(a), 3)
for i, j, k in zip(c, d, e):
print(i, j, k)
组合生成器
| Iterator | Arguments | Results |
|---|---|---|
| product() | p, q, ... [repeat=1] | cartesian product, equivalent to a nested for-loop |
| permutations() | p[, r] | r-length tuples, all possible orderings, no repeated elements |
| combinations() | p, r | r-length tuples, in sorted order, no repeated elements |
| combinations_with_replacement() | p, r | r-length tuples, in sorted order, with repeated elements |
| product('ABCD', repeat=2) | AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD | |
| permutations('ABCD', 2) | AB AC AD BA BC BD CA CB CD DA DB DC | |
| combinations('ABCD', 2) | AB AC AD BC BD CD | |
| combinations_with_replacement('ABCD', 2) | AA AB AC AD BB BC BD CC CD DD |
copy与deepcopy函数
copy: 浅拷贝(shallow copy), deepcopy: 深拷贝(deep copy).
- 我们寻常意义的复制就是深复制，即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。
- 而浅复制并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。这就和我们寻常意义上的复制有所不同了。
- 对于简单的 object，用 shallow copy 和 deep copy 没区别
- 复杂的 object， 如 list 中套着 list 的情况，shallow copy 中的 子list，并未从原 object 真的「独立」出来。也就是说，如果你改变原 object 的子 list 中的一个元素，你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。
例子：
from copy import copy, deepcopy
#origin 里边有三个元素：1,2,[3, 4]
origin = [1, 2, [3, 4]]
# cop1为浅拷贝，cop2为深拷贝
cop1 = copy(origin)
cop2 = deepcopy(origin)
# cop1是否与cop2内容相同
print(cop1 == cop2)
# cop1是否与cop2为同一个引用
print(cop1 is cop2)
# 改变origin中嵌套列表中的元素
origin[2][0] = "hey"
# 查看输出
print(origin)
print(cop1)
print(cop2)
# 改变origin中嵌套列表中的元素
origin[1] = "hello"
# 查看输出
print(origin)
print(cop1)
print(cop2)
输出结果：
True
False
[1, 2, ['hey', 4]]
[1, 2, ['hey', 4]]
[1, 2, [3, 4]]
[1, 'hello', ['hey', 4]]
[1, 2, ['hey', 4]]
[1, 2, [3, 4]]
模块
在Python中，一个Python文件就是一个模块。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
一个简单的模块例子：
hello.py
def say_hello(name):
s = 'hello, %s!'%name
return s
使用模块：
- import module
- from module import ...
import hello
print(hello.say_hello("Lee"))
from hello import say_hello
print(say_hello("Jack"))
os、sys模块
os模块
os模块包含普遍的操作系统功能。
os常用方法及属性
os.sep 可以取代操作系统特定的路径分隔符。windows下为 “\”
os.name字符串指示你正在使用的平台。比如对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'。
os.getcwd() 函数得到当前工作目录，即当前Python脚本工作的目录路径。
os.getenv() 获取一个环境变量，如果没有返回none
os.putenv(key, value) 设置一个环境变量值
os.listdir(path) 返回指定目录下的所有文件和目录名。
os.remove(path) 函数用来删除一个文件。
os.system(command) 函数用来运行shell命令。
os.linesep 字符串给出当前平台使用的行终止符。例如，Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'。
os.curdir: 返回当前目录（'.')
os.chdir(dirname): 改变工作目录到dirname
os.path常用方法：
os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。
os.path.existe()函数用来检验给出的路径是否真地存在
os.path.getsize(name):获得文件大小，如果name是目录返回0L
os.path.abspath(name):获得绝对路径
os.path.normpath(path):规范path字符串形式
os.path.split(path) ：将path分割成目录和文件名二元组返回。
os.path.splitext():分离文件名与扩展名
os.path.join(path,name):连接目录与文件名或目录;使用“\”连接
os.path.basename(path):返回文件名
os.path.dirname(path):返回文件路径
sys模块
sys模块提供了一系列有关Python运行环境的变量和函数。
sys模块的常用方法
sys.argv: 实现从终端向程序传递参数。
sys.exit([arg]): 程序中间的退出，arg=0为正常退出。
sys.getdefaultencoding(): 获取系统当前编码，一般默认为ascii。
sys.setdefaultencoding(): 设置系统默认编码，执行dir（sys）时不会看到这个方法，在解释器中执行不通过，可以先执行reload(sys)，在执行 setdefaultencoding('utf8')，此时将系统默认编码设置为utf8。（见设置系统默认编码 ）
sys.getfilesystemencoding(): 获取文件系统使用编码方式，Windows下返回'mbcs'，mac下返回'utf-8'.
sys.path: 获取指定模块搜索路径的字符串集合，可以将写好的模块放在得到的某个路径下，就可以在程序中import时正确找到。
sys.platform: 获取当前系统平台。
sys.stdin, sys.stdout, sys.stderr: stdin , stdout , 以及stderr 变量包含与标准I/O 流对应的流对象. 如果需要更好地控制输出,而print 不能满足你的要求, 它们就是你所需要的. 你也可以替换它们, 这时候你就可以重定向输出和输入到其它设备( device ), 或者以非标准的方式处理它们
生成器
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
创建generator的办法：
- 把一个列表生成式的[]改成()
- yield关键字
将列表的[]改成()的例子：
# 列表生成式
L = [x * x for x in range(10)]
print(type(L))
# 创建生成器
g = (x * x for x in range(10))
print(type(g))
# 获取下一个返回值
# 当没有更多元素时，会抛出StopIteration错误
print(next(g))
print(next(g))
print(next(g))
# for循环
for n in g:
print(n)
通过yield创建生成器
# 普通方法生成斐波拉契数列
# 前几个斐波拉契数
def fib1(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return 'done'
fib1(6)
# 通过yield创建生成器
# 注意yield的执行流程
def fib2(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
# 将生成器函数赋值给变量f
f = fib2(6)
print(type(f))
for n in f:
print(n)
generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
generator执行流程的理解：
def odd():
print('step 1')
yield 1
print('step 2')
yield(3)
print('step 3')
yield(5)
o = odd()
print(next(o))
print(next(o))
print(next(o))
迭代器
可以直接作用于for循环的数据类型有以下几种：
集合数据类型，如list、tuple、dict、set、str等；
generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：==Iterable==。
可以使用isinstance()判断一个对象是否是Iterable对象：
from collections import Iterable
# 判断空列表是否为Iterable对象
# True
print(isinstance([], Iterable))
# 判断空集合是否为Iterable对象
# True
print(isinstance({}, Iterable))
# 判断字符是否为Iterable对象
# True
print(isinstance('abc', Iterable))
# 判断生成器是否为Iterable对象
# True
print(isinstance((x for x in range(10)), Iterable))
# 判断数字否为Iterable对象
# False
print(isinstance(100, Iterable))
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用isinstance()判断一个对象是否是Iterator对象：
from collections import Iterator
# 判断生成器是否为Iterator对象
# True
print(isinstance((x for x in range(10)), Iterator))
# 判断空列表是否为Iterator对象
# False
print(isinstance([], Iterator))
# 判断空集合是否为Iterator对象
# False
print(isinstance({}, Iterator))
# 判断字符串是否为Iterator对象
# False
print(isinstance('abc', Iterator))
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数。