python 进阶案例_Python进阶笔记

列表生成式

函数的参数类型

lambda函数

map, reduce, filter, sorted函数

eval, exec, join, zip函数

itertools中的函数

copy与deepcopy函数

模块

os、sys模块

迭代器

生成器

迭代器

参考网站：

列表生成式

列表生成式即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使用'rn'，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()函数。