数组笔记

元祖

元祖不仅仅是不可变列表，元祖其实是对数据的记录：元祖的每个元素都存放了记录中一个字段的数据，外加这个字段的位置。正是这个位置信息给数据赋予了意义。

for循环可以分别提取元祖里的元素，也叫作拆包。

lax_coordinates = (33, -118)
city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)
# 所有的赋值只用一行代码声明就能写完
travel_ids = [('US','3119676'),('BRA','CE37760'),('ESP','XDA7653')]
for passport in sorted(travel_ids):
    print('%s/%s' % passport)
    
for country,_ in travel_ids:
	# 因为第二个元素无用，所以它赋值给‘_’占位符，占位符可处理不感兴趣的元素
    print(country)    
import os
_, filename = os.path.split('/home/chh/.ssh/test.py')
print(filename)

输出：
BRA/CE37760
ESP/XDA7653
US/3119676

US
BRA
ESP
test.py

用 * 运算符把一个可迭代对象拆开作为函数的参数；

print(divmod(20,8))
t = (20,8)
print(divmod(*t))
# divmod函数需要传入两个参数，但是对象t是一个参数
quotient, remainder = divmod(*t)
print(quotient, remainder)

输出：
(2, 4)
(2, 4)
2 4

用 * 来获取不确定数量的参数算是一种经典做法

a, b, *rest = range(5)
print(a, b, rest)
a, b, *rest = range(3)
print(a, b, rest)
a, b, *rest = range(2)
print(a, b, rest)

*rest, a, b = range(5)
print(a, b, rest)
a, *rest, b, c = range(5)
print(a, b, c, rest)

输出：
0 1 [2, 3, 4]
0 1 [2]
0 1 []

3 4 [0, 1, 2]
0 3 4 [1, 2]

具名元祖。

collections.namedtuple是一个工厂函数，可以用来构建一个带字段名的元祖和一个有名字的类。

import collections
City = collections.namedtuple('City', 'name country population coordinates')
# 创建一个具名元祖需要两个参数，一个是类名，另一个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是有空格分隔开的字段名组成的字符串
# 等同于City = collections.namedtuple('City', ['name', 'country', 'population', 'coordinates'])
tokyo = City('Tokyo','JP',36.933,(35,139))
print(tokyo)
# 可以通过字段名或者位置来读取一个字段的信息
print(tokyo.population)
print(tokyo.coordinates)
print(tokyo[1])

# 具名元祖的属性和方法
print(City._fields)  # 输出所有字段名
LatLong = collections.namedtuple('LatLong',['lat','long'])
delhi_data = City('Delhi NCR','IN',21.935,(28,77))
delhi = City._make(delhi_data) # 接受一个可迭代对象生成这个类的实例，等同于 City(*delhi_data）
print(delhi._asdict())  # 呈现元祖里的信息

输出：
City(name='Tokyo', country='JP', population=36.933, coordinates=(35, 139))
36.933
(35, 139)
JP

('name', 'country', 'population', 'coordinates')
OrderedDict([('name', 'Delhi NCR'), ('country', 'IN'), ('population', 21.935), ('coordinates', (28, 77))])

给切片赋值。

如果赋值的对象是一个切片，那么赋值语句的右侧必须是个可迭代对象。即便只有单独一个值，也要把它转换成可迭代的序列。

l = list(range(10))
l[2:5] = 100

输出：
Traceback (most recent call last):
  File "D:/GZRobort/General_DBAI/test.py", line 18, in <module>
    l[2:5] = 100
TypeError: can only assign an iterable

l = list(range(10))
print(l)
l[2:5] = [100]
print(l)

输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 100, 5, 6, 7, 8, 9]

不要把可变对象放进元组里；

list.sort和sorted

list.sort方法是就地排序，不会把原列表复制一份，返回的值是None；sorted函数会新建一个列表作为返回值。

双向队列。

利用.append和.pop方法，我们可以把列表当做栈或者队列来用（比如，把.append和.pop(0)合起来用可以模拟队列的“先进先出”特点）。但是删除列表的第一个元素或是在第一个与元素之前添加一个元素都是很耗时的，因为这些操作会牵扯到移动列表里的所有元素。
collections.queue类（双向队列）是一个线程安全、可以快速从两端添加或者删除元素的数据类型。而且，如果想要有一种数据类型来存放“最近用到的几个元素”，deque也是一个很好的选择。这是因为在新建一个双向队列的时候，可以指定这个队列的大小，如果这个队列满员了，还可以从反向端删除过期元素，然后再尾端添加新的元素。

from collections import deque
dq = deque(range(10),maxlen=10)
print(dq)
dq.rotate(3)
print(dq)
dq.rotate(-4) # 队列的旋转操作接受参数n，当n>0，队列最右边的n个元素会被移动到队列的左边。当n<0，最左边的n个元素会被移动到右边
print(dq)
dq.appendleft(-1)
print(dq)
dq.extend([11,22,33])
print(dq)
dq.extendleft([10,20,30,40])
print(dq)

输出：
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], maxlen=10)
deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
deque([3, 4, 5, 6, 7, 8, 9, 11, 22, 33], maxlen=10)
deque([40, 30, 20, 10, 3, 4, 5, 6, 7, 8], maxlen=10)

从队列中间删除的操作会慢一点，因为它只对在头尾的操作进行了优化。

字典

setdefault

• 可以用d.get(k,default来替代d[k]，给找不到的键一个默认的返回值，这比处理KeyError要方便的多；
• 用setdefault处理找不到的键可以更高效

my_dict.setdefault(key,[]).append(new_value)

等同于

if key not in my_dict:
	my_dict[key] = []
my_dict[key].append(new_value)

二者的效果是一样的，只不过后者要进行两次键查询——如果键不存在的话，就要查询三次，但是用setdefault只需要一次就可以完成整个操作。

MappingProxyType

type模块引入了一个封装类名叫MappingProxyType。如果给这个类一个映射，它会返回一个只读的映射视图。虽然只是个只读视图，但它是动态的。这意味着对原映射做出了改动，通过这个视图可以观察到，但是无法通过这个视图对原映射做出修改。

from types import MappingProxyType
d = {1:'A'}
d_proxy = MappingProxyType(d)
print(d_proxy)
print(d_proxy[1])

d_proxy[2] = 'x'

d[2] = 'x'
print(d_proxy)
print(d_proxy[2])

输出：
{1: 'A'}
A

Traceback (most recent call last):
  File "D:/GZRobort/General_DBAI/test.py", line 21, in <module>
    d_proxy[2] = 'x'
TypeError: 'mappingproxy' object does not support item assignment

{1: 'A', 2: 'x'}
x

典型的空间换时间

由于字典使用了散列表，而散列表又必须是稀疏的，这导致它在空间上的效率低下。字典类型有着巨大的内存开销，但它提供了无视数据量大小的快速访问——只要字典能被存在内存里。

集合

集合中的元素必须是可散列的，set本身是不可散列的，但frozenset可以。
集合可用于求两者之间的交并补差。利用这些操作，不仅可以让代码行数减少，还能减少程序运行时间。

集合字面量

• 空集：set()
• s = {1，2，3，4}
• s = set([1，2，3，4])