Polar Snow Documentation

花有重开日 人无再少年

Python的高级特性

发表于 分类于 Disqus：

切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
In [3]: l = list(range(100))

#取前5个元素
In [4]: l[:5]
Out[4]: [0, 1, 2, 3, 4]

#取后5个元素
In [5]: l[-5:]
Out[5]: [95, 96, 97, 98, 99]

#取第11-20的元素
In [6]: l[11:20]
Out[6]: [11, 12, 13, 14, 15, 16, 17, 18, 19]

#取前10个元素，每2个取一个
In [7]: l[:10:2]
Out[7]: [0, 2, 4, 6, 8]

#取第1-10的元素，每2个取一个
In [8]: l[1:10:2]
Out[8]: [1, 3, 5, 7, 9]

#取全部的元素，每10个取一个
In [9]: l[::10]
Out[9]: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

#取得全部元素
In [10]: l[:]

#记住最后一个元素的索引是-1
In [11]: l[-1]
Out[11]: 99

list切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
In [1]: l = ['apple', 'google', 'facebook', 'microsoft', 'linkin']

In [2]: l
Out[2]: ['apple', 'google', 'facebook', 'microsoft', 'linkin']

In [3]: l[0:3]
Out[3]: ['apple', 'google', 'facebook']

In [4]: l[:3]
Out[4]: ['apple', 'google', 'facebook']

In [5]: l[1:3]
Out[5]: ['google', 'facebook']

In [6]: l[-2:]
Out[6]: ['microsoft', 'linkin']

In [7]: l[-2:-1]
Out[7]: ['microsoft']

tuple切片

1
2
In [13]: (0, 1, 2, 3, 4, 5)[:3]
Out[13]: (0, 1, 2)

str切片

1
2
In [14]: 'apple'[:3]
Out[14]: 'app'

迭代

在Python中迭代是通过for ... in ...来实现的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
In [15]: d = {'apple':'pages', 'google':'docs', 'microsoft':'word'}

In [16]: for key in d:
   ....:     print key
   ....:     
google
apple
microsoft

In [17]: for value in d.values():
   ....:     print value
   ....:     
docs
pages
word

In [18]: for k, v in d.items():
   ....:     print k,v
   ....:     
google docs
apple pages
microsoft word

列表、元组、字典和字符串都是可迭代对象
判断一个对象是否是可迭代对象，通过collections模块的Iterable来判断

1
2
3
4
5
6
7
8
9
10
11
12
13
In [22]: from collections import Iterable

In [23]: isinstance('123', Iterable)
Out[23]: True

In [24]: isinstance([1, 2, 3], Iterable)
Out[24]: True

In [25]: isinstance((1, 2, 3), Iterable)
Out[25]: True

In [26]: isinstance({'a':1, 'b':2, 'c':3}, Iterable)
Out[26]: True

enumerate

Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身

1
2
3
4
5
6
In [27]: for i, value in enumerate(['A', 'B', 'C']):
   ....:     print(i, value)
   ....:    
(0, 'A')
(1, 'B')
(2, 'C')

列表生成式

列表生成式有自己的特殊语法
把要生成的元素放到最前面，后跟for循环，就可以创建一个list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
n [29]: [i * i for i in range(1,10)]
Out[29]: [1, 4, 9, 16, 25, 36, 49, 64, 81]

#二层循环实现全排列
In [30]: [m + n for m in 'ABC' for n in 'XYZ']
Out[30]: ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

#列出根目录下的所有文件和文件夹
In [37]: [f for f in os.listdir('/')]
Out[37]: 
['.autorelabel',
 'lib',
 'sbin',
 'proc',
 'dev',
 'lib64',
 'mnt',
 'usr',
 'etc',
 'var',
 'selinux',
 '.autofsck',
 'sys',
 'srv',
 'media',
 'tmp',
 'data',
 'boot',
 'lost+found',
 'home',
 'root',
 'opt',
 'bin']

#列表生成式使用两个变量来生成列表
In [38]: d
Out[38]: {'apple': 'pages', 'google': 'docs', 'microsoft': 'word'}

In [39]: [k + '-->' + v for k,v in d.items()]
Out[39]: ['google-->docs', 'apple-->pages', 'microsoft-->word']

#将列表中的元素全部转为小写或大写
In [42]: l = ['apple', 'google', 'facebook']

In [43]: [s.lower() for s in l]
Out[43]: ['apple', 'google', 'facebook']

In [44]: [s.upper() for s in l]
Out[44]: ['APPLE', 'GOOGLE', 'FACEBOOK']

In [45]: l.append(59)

In [46]: l
Out[46]: ['apple', 'google', 'facebook', 59]

In [47]: [s.upper() for s in l]
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-47-0e109a4f23f3> in <module>()
----> 1 [s.upper() for s in l]

AttributeError: 'int' object has no attribute 'upper'

#上面遇到列表中出现字符串和数字混合的情况，数字对象没有upper()或lower()方法
#这时需要使用判断来排除数字的情况

In [52]: l
Out[52]: ['apple', 'google', 'facebook', 59]

In [53]: [s.upper() for s in l if isinstance(s, str)]
Out[53]: ['APPLE', 'GOOGLE', 'FACEBOOK']

生成器（yield）

生成器返回一个可迭代的对象

生成器的关键字yield，与return的区别是

  • return 立即返回结果并结束函数

  • yield 返回结果并暂停函数，等待next()的下一次调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
In [1]: def my_fun():
   ...:         sum = 1
   ...:         while True:
   ...:                 sum = sum + 1
   ...:                 yield sum
   ...:         

In [2]: m = my_fun()

In [3]: m.next()
Out[3]: 2

In [4]: m.next()
Out[4]: 3

In [5]: m.next()
Out[5]: 4

In [6]: m.next()
Out[6]: 5

In [7]: my_fun()
Out[7]: <generator object my_fun at 0x2767a00>

In [8]: my_fun().next()
Out[8]: 2

In [9]: my_fun().next()
Out[9]: 2

In [10]: my_fun().next()
Out[10]: 2

上面介绍的列表生成式也可以变成生成器生成式

只需把中括号换成小括号就变成了一个生成器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
In [11]: L = [x * x for x in range(10)]

In [12]: L
Out[12]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

In [13]: G = (x * x for x in range(10))

In [14]: G
Out[14]: <generator object <genexpr> at 0x2767aa0>

In [15]: G.next()
Out[15]: 0

In [16]: G.next()
Out[16]: 1

In [17]: G.next()
Out[17]: 4

生成器保存的是算法，在使用时计算结果，节省内存空间

迭代器

可以直接作用于for循环的数据类型有以下几种：

  • 集合数据类型。如list tuple dict set str等

  • generator，包括生成器和带yield的generator function

这些可以直接作用于for循环的对象统称为可迭代对象Iterable

可以使用isinstance()判断一个对象是否是Iterable可迭代对象

1
2
3
4
In [20]: from collections import Iterable

In [21]: isinstance([],Iterable)
Out[21]: True

生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，最后抛出StopIteration异常，表示已经结束，无法返回下一个值

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator

可以使用isinstance()判断一个对象是否是Iterator对象

1
2
3
4
5
6
7
In [24]: from collections import Iterator

In [25]: isinstance((x for x in range(10)), Iterator)
Out[25]: True

In [26]: isinstance([], Iterator)
Out[26]: False

Iterator 和 Iterable的区别

  • 生成器都是Iterator对象，但list dict等是Iterable，但不是Iterator

  • Iterator是迭代器，需要同时具备__iter__和next两个方法，它们表示一个惰性计算的序列

  • Iterable是可迭代对象，列表元组等数据结构同样是可迭代对象，具备__iter__方法，但不具备next方法

使用for循环遍历可迭代对象时，for循环自动调用next()函数，并在接收到结束异常时退出循环

参考文章：http://www.liaoxuefeng.com/

相关文章