列表

列表除了支持索引访问，切片外，还有自己的方法

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'

列表作为栈

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

列表作为队列

和作为栈类似，列表通过append(), pop()可以作为队列使用，虽然列表在尾部放入或移除元素很快，但是在头部放入或移除元素却比较慢，所以不太适合作为队列使用，python有内建的队列实现collections.deque。

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

列表推导式

列表推导式提供了从一系列元素创建一个新列表的一种简洁方式。

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

用列表推导式重写，变得简洁明了，同时消除了x在循环结束后还存在的副作用

squares = [x**2 for x in range(10)]

列表推导式方括号中的第一个元素是生成的列表元素的求值表达式，随后是一个必须的for，之后是可选的for(可是有多个),以及可选的if。

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

等价于

>>> combs = []
>>> for x in [1,2,3]:
...         for y in [3,1,4]:
...             if x != y:
...                 combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

列表推导式中，元组必须用()声明。
官方手册的额外的一些例子：

>>> vec = [-4, -2, 0, 2, 4]
>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # create a list of 2-tuples like (number, square)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)] 
File "<stdin>", line 1, in <module> [x, x**2 for x in range(6)] ^SyntaxError: invalid syntax
>>> # flatten a list using a listcomp with two 'for'>
>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

列表推导式可以被嵌套

>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

通过列表推导式实现了矩阵转置

del语句

del可用于通过索引删除列表的一个元素， 一个切片， 或者清空列表

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

del也可用于删除整个变量

>>> del a

元组

因为字符串和列表都是序列，所以他们有许多共同的性质，元组是另一种序列类型。
元组和列表类似，由一组逗号分隔的值组成

扫描二维码关注公众号，回复： 9951326 查看本文章

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

元组声明时包围元素的括号在单独声明元组时可以省略，但是元组本身是一个更大的表达式中的一部分时，括号却是必须的。元组是不可变的，但是可以包括可变对象。

声明空元组或只包含一个元素的元组

>>> empty = ()
>>> singleton = 'hello', # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

元组封包和序列解包

t = 12345, 54321, 'hello!'

多个值被打包进一个元组，即元组封包

元组封包的反向操作就是序列解包

>>> x, y, z = t

序列解包支持任意序列 ，要求是序列中的元素和左边的变量数一致。
多重赋值本质是元组封包和序列解包的组合。

比较序列类型

同类型的序列可以比较，比较使用词典顺序，从开始的两个元素开始比较，如果不相等，则这两个元素的大小决定了序列的大小，如果相等则比较接下来的元素，
依次类推，直到所有元素都比较完或者其中一个序列不再有元素，此时提前没有元素可比较的序列是较小的序列。

(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

如果比较的对象类型不同，但是对象实现了相应的比较方法，则比较也是可以进行的。

集合

集合是一种无序无重复的数据结构。集合支持包含测试，重复元素过滤，交，并，差，对称差。

集合通过大括号"{}"或set()函数声明。

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # fast membership testing
True
>>> 'crabgrass' in basket
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in either a or b
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

空集合

空集合需要用set()声明。

集合推导式

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

字典

字典是无序的键值对存储。key必须是任意不可变类型，如果元组中不包含可变类型原始，元组也可以作为key，key必须唯一。

空的大括号“{}”定义空的字典，在其中使用“key:value”的形式定义键值对，通过“,”分隔多个键值对。

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

空字典

通过dict()也可以定义字典

dict() #空字典
{} #空字典

用key，value对的列表创建字典

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

如果key时字符串，则可以通过关键词参数初始化字典

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

字典推导式

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

容器结构的循环

字典的循环

通过dict.items()可以在循环时让key和value都同时获得

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave

序列的循环

序列的索引和值可以通过enumerate()同时获得

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

循环反向序列

通过reversed()反向循环序列

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

循环排序序列

通过使用sorted()返回一个新的排序了的序列

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

同时循环多个序列

通过zip()配对多个序列元素后循环

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

循环时对被循环对象修改

循环时对被循环对象修改是不安全的，安全的做法是循环一个原始对象的副本，或者创建一个新的对象存储循环逻辑产生的新值

import math
raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
filtered_data = []
for value in raw_data:
    if not math.isnan(value):
        filtered_data.append(value)
filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]