在Python中，最基本的数据结构是序列（sequence）。
序列中的每个元素被分配一个序号——即元素的位置，也称为索引。第一个索引是 0，第二个则是 1，以此类推。序列中的最后一个元素标记为 -1，倒数第二个元素为 -2，一次类推。
Python包含 6 中内建的序列，包括列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。列表和元组的主要区别在于，列表可以修改，元组则不能。
解压序列赋值多个变量
通过赋值语句把一个序列中（元组列表字典等均可以）的多个元素分别赋值给多个变量。
数量要相同，如果不同则会异常。
>>> p = (4,6)
>>> p
(4, 6)
>>> x, t = p
>>> x
4
>>> t
6
>>>
任何可以迭代的对象都是可以的，包括字符串，文件对象，迭代器生成器。
如果数量不同会报错
>>> a = 'hei'
>>> z, x, c =a
>> z
'h'
>>> x
'e'
>>> c
'i'
>>> z, x = a
Traceback (most recent call last):
File "", line 1, in
z, x = a
ValueError: too many values to unpack (expected 2)
>>>
有时候，你可能只想解压一部分，丢弃其他的值。对于这种情况 Python 并没有提
供特殊的语法。但是你可以使用任意变量名去占位，到时候丢掉这些变量就行了。
解压可迭代对象赋值多个变量
>>> c = (1,2,3,4,5)
>>> q, *w, e = c
>>> q
1
>>> w
[2, 3, 4]
>>> e
5
>>>
中间的*w代替了去除第一个和最后一个元素以后的其他元素
同理：
>>> re = ('name', 'age', 12345, 454654)
>>> a, e, *t = re
>>> a
'name'
>>> e
'age'
>>> t
[12345, 454654]
这就是星号表达式！！！星号表达式解压出来的都是列表类型。
值得注意的是，星号表达式在迭代元素为可变长元组的序列时是很有用的。
re = [
('f',1,2),
('t','r'),
('f',5,6),
]
for tag, *args in re:
print(tag)
print(args)
输出的是：
f
[1, 2]//星号表达式解压出来的都是列表类型
t
['r']
f
[5, 6]
使用星号表达式可以接收序列中的值以后再丢弃。单数必须要加上一名称，例如：*name。
保留最后的N个元素
我们在写查询元素的代码时，通常会使用包含 yield 表达式的生成器函数。这样可以将搜索过程代码和使用搜索结果代码解耦。
使用 deque(maxlen=N) 构造函数会新建一个固定大小的队列。deque是一个类。需要导入。
from collections import deque
q = deque(maxlen=3)
q.append(1)
q.append(2)
q.append(3)
deque的操作方法和列表的类似。可以用append。maxlen是设定最大的个数。
当再添加的时候，最先被添加的元素会被移除。
>>> from collections import deque
>>> q = deque(maxlen=4)
>>> type(q)
>>> q = deque(maxlen=3)
>>> q
deque([], maxlen=3)
>>> q.append(1)
>>> q.append(2)
>>> q.append(3)
>>> q
deque([1, 2, 3], maxlen=3)
>>> q.appendleft(4)
>>> q
deque([4, 1, 2], maxlen=3)
>>> q.pop()
2
>>> q
deque([4, 1], maxlen=3)
>>> q.pop()
1
>>> q
deque([4], maxlen=3)
>>> q.appendright(5)
Traceback (most recent call last):
File "", line 1, in
q.appendright(5)
AttributeError: 'collections.deque' object has no attribute 'appendright'
>>>
后面的maxlen是设定长度。添加的方式和列表的操作方式一样。
只有appendleft方法，从前面添加后面移除。
没有appendright方法。
pop（）是删除，从后面开始移除元素，并且返回。
查找最大或最小的N个元素
heapq模块中的两个函数：nlargest（）和nsmllest（）
>>> import heapq
>>> nums =[1,2,4,545,23,213,3,54,65765,7,4214,231,0]
>>> heapq.nlargest(3, nums)
[65765, 4214, 545]
>>> heapq.nsmallest(3, nums)
[0, 1, 2]
>>>
例子：
portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
cheap = heapq.nsmallest(3, portfolio, key=lambda s:s['price'])
print(cheap)
输出：
[
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75}
]
#cheap = heapq.nsmallest(3, portfolio, key=lambda s:s['price'])
这句是以price为一句进行对比大小。key=lambda s:s['price']是选取price为依据。
nums = [1,2,3,4,45,5,4,4,6565,453,22]
heapq.heapify(nums)
# print(nums)
print(heapq.heappop(nums))
print(nums)
print(heapq.heappop(nums))
print(nums)
输出：
1
[2, 4, 3, 4, 22, 5, 4, 45, 6565, 453]
2
[3, 4, 4, 4, 22, 5, 453, 45, 6565]
heappop()实际也就相当于删除最小的元素了。
堆数据结构最重要的特征是 heap[0] 永远是最小的元素。并且剩余的元素可以很
容易的通过调用 heapq.heappop() 方法得到，该方法会先将第一个元素弹出来，然后
用下一个最小的元素来取代被弹出元素 (这种操作时间复杂度仅仅是 O(log N)， N 是
堆大小)。
要查找的元素个数相对比较小的时候，函数 nlargest() 和 nsmallest() 是很
合适的。如果你仅仅想查找唯一的最小或最大 (N=1) 的元素的话，那么使用 min() 和
max() 函数会更快些。类似的，如果 N 的大小和集合大小接近的时候，通常先排序这
个集合然后再使用切片操作会更快点 ( sorted(items)[:N] 或者是 sorted(items)[-
N:] )。需要在正确场合使用函数 nlargest() 和 nsmallest() 才能发挥它们的优势 (如果
N 快接近集合大小了，那么使用排序操作会更好些)。
位置参数和关键字参数
ifelse的表达式写法：
c = a if a>b else b
如果a>b,则执行c = a ,否则执行c= b
ifelse二维列表写法：
c = [b,a][a>b]
>>> a = 10
>>> b = 9
>>> c =[a,b][a>b]
>>> c
9
>>> c = [b,a][a>b]
>>> c
10
>>> c = [b,a][b>a]
>>> c
9
>>>
后面的成立的时候，输出的是前以列表中的后面的值。不成立则是输出的前一列表的第一个元素。