序列是一种概念，而不是一个具体的类型。
内置序列包括：list、set、tuple、str、range，字典不是序列哦。
序列是一个实现了__getitem__(self, key)和__len__(self)的 iterable，且只能用 int 作为下标（而不是 str）访问元素的对象
内置序列与字典的特点
- str：有序，元素不可重新赋值，长度不可变，非异构
- list：有序，元素可重新赋值，长度可变，异构
- tuple：有序，元素不可重新赋值，长度不可变，异构
- dict：无序，元素可重新赋值，长度可变，异构
- set：无序不重复，元素不可重新赋值（因为是无序的），长度可变，异构
set 和 dict 是无序的，所以不能用数字做下标访问，但是可迭代
set 和 dict 的键中保存的值必须是可哈希的，或者我理解为不可变的，他们可以保存 tuple，但是不能保存 list
切片
切片产生的是一个新的对象，这个对象中的元素是原序列中的元素句柄的副本
seq[n:m]：取出下标n到m之间的元素，不包括m
seq[:m]：前m个元素
seq[-1]：最后一个元素
切片默认的是正向取出元素的，即使使用负数作为下标
seq[-3:-1]可以取出倒数第三个到倒数第一个（不包括）的元素
但是seq[-1:-3]不能够反向取出倒数第一个到倒数第三个（不包括）的元素
seq[::2]：不指定起始和结束索引就是所有元素，步长为2就是每两个一组，取出每组的第一个元素
seq[9:4:-1]：使用步长可以反向输出元素
给切片赋值，就像可以通过下标给元素赋值一样，也可以通过切片给元素赋值，ll[3::2] = [11, 22]
要求是值的数量必须与切片元素的数量相等，且值必须是一个可迭代对象，即使它只有一个元素
用del关键字配合切片可以删除原序列中的元素
直接对切片操作（ll[3::2] = [11, 22]）会影响原序列，而把切片赋值给变量（a=ll[3::2]），将产生新序列，新序列包含原序列的元素的句柄副本
下标访问就是把 int 传给__getitem(self,key)__，而切片是把切片转成 slice 对象后，把 slice 对象传给__getitem(self,key)__
切片中的数字超出序列范围也不会越界，而是返回空seq，但是单个下标是会越界的
浅拷贝与深拷贝
等号（=）：复制原有的引用
浅拷贝：序列的 copy 方法或 copy 模块的 copy(x) 函数，它会返回复制出来的对象
复制对象，但是对于对象包含的成员（比如绑定到对象数据 self.value，序列中的元素），仅仅是创建一个引用，该引用指向原对象中的成员
深拷贝：copy 的 deepcopy(x) 函数，复制对象及其成员
列表 list
l = [1,2,3,4]
l = list(iterable)
l1+l2 # l1,l2 都必须是 list
l1+=l2 # l2 必须是 iterable
l1*3 # 扩展列表，实际上是复制了原列表中的元素的引用；如果原列表中的元素可变，请使用列表推导式来扩展列表
del l[i]
obj in l # 判断某个对象是否在这个 list 中
常用方法
append(obj)：追加一个元素到末尾
extend(seq)：追加一个序列到末尾
insert(index,obj)
remove(obj)：删除一个元素，不是根据下标哦
pop(index)：取出元素，默认取出最后一个
clear()：清空列表
copy()：浅拷贝
index(value,[start,[stop]])：找到第一个与 value 相同的元素的下标，参数可以只有 start，没有 stop
count(obj)
sort([key,reverse])：对原列表排序
reverse()：对原列表反向
元组 tuple
t = (1,2,3)
t = tuple(iterable)
# 同样支持 + 和 +=，但操作符两边的变量都必须是 tuple
# 也支持 * 和 *=
del t # 虽然不能删除元素，但删除整个变量还是可以的
# 支持的方法参考 list，当然，凡是对 tuple 做修改的，都不支持
字典 dict
d={'integer':1,'string':'hello'}
print(d['string']) #取出的方式同 list，只不过 index 变成 key
{} # 空字典，同 dict()
dict(a=1,b=2) # 任意数量关键字参数
dict([['a',123]]) # 元素为二元组的序列/迭代器
dict((i,i) for i in range(5))
键不一定是字符串，也可以是数字或元组；键唯一且不可变
创建 dict 或者扩展 dict 时，如果有同样的键，那取后一个键的值
不支持*和+操作！但是支持min()、max()、len()、del
用d[k]为不存在key赋值时，自动创建该key并赋值，读取不存在的key的值时，抛出异常
支持的方法
clear()
copy()
pop(key[,default])：取出指定 key 的值，还可以指定一个默认 key，前面的 key 不存在就取出默认 key 的值，都不存在就抛异常
popitem()：取出一个键值对（元组形式），一般是取出最前面的一个，但是 dict 是无序的，所以无从得知会取出哪一个
get(key, default=None)：与下标取值不同的是它可以有默认值
setdefault(key, default=None)：如果字典中没有这个 key，就把这个 key 添加到字典中，值就是 default；如果 key 存在，就啥都不做
update(dict)：扩充列表
这三个iterable支持交集并集等集合操作！集合操作后返回一个set
values()->dict_values：返回所有值，iterable
keys()->dict_keys：返回所有键，iterable
items()->dict_items：用元组封装每个键值对，iterable
dict.fromkeys(seq[, value]))->dict：静态方法，创建字典，seq 中的值为字典的键，value 为新字典的所有键的初始值
这个字典中所有 key 的值都是同一个 value 的引用的拷贝！所以如果 value 是一个可变对象，就要小心了
set
set 就像是只有 key 的 dict
s={'a','b','c'}：没有值，只有键，就是 set；也可以用 set(iterable) 函数
d={}，这是创建空的 dict，而不是空的 set
add(obj) 同 list 的 append
update(itertor) 同 list 的 extend()
remove(obj) 元素不存在抛出 KeyError
discard(obj) 效果同 remove，不过不抛异常
pop() 无序，故不知道取出的是什么元素
clear()
支持集合的计算
-
并集：set.union(s),也可以用 a|b 计算
-
交集：set.intersection(s)，也可以用 a&b 计算
-
差集：set.difference(s)，也可以用 a-b 计算
-
set.isdisjoint(s)：判断两个集合是不是不相交
-
set.issuperset(s)：判断集合是不是包含其他集合，等同于 a>=b
-
set.issubset(s)：判断集合是不是被其他集合包含，等同于 a<=b
列表/字典推导式
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = [x ** 3 for x in a if x % 2 == 0]
# 列表推导式得到的是一个list，如果将中括号改为小括号，那得到的是一个生成器表达式，而不是一个元祖
l=[(i,j) for i in a for j in b]
ll=[(i,j) for i,j in zip(a,b)]
# 上面两个是不同的，l中的元素数量是 len(a)*len(b)，ll中的是 min(len(a),len(b))
# 字典推导式
# 字典不能直接迭代，必须使用 items 方法
# 字典推导式不能换小括号变成生成器表达式
{v: k for k, v in mcase.items()}
容器类型转换
字典转其它
d = {'name': 'Zara', 'age': 7, 'class': 'First'}
# 转成的字符串的数据就是 '{'name': 'Zara', 'age': 7, 'class': 'First'}'
# 这里用切片拿前三个字符，拿到的是 '{'n'
# list/set/tuple 也是如此
print(str(d)[:3])
# 下面三种方法都是可行的，只不过拿到的数据都是 key
print(list(d))
print(tuple(d))
print(set(d))
# 如果要拿 value 或者键值对
print(d.keys())
print(d.items())
print(d.values())
# 可以把拿到的 value 转成 list
print(list(d.values()))
列表/元祖/set 转其它
l=[1,2,3,4,5,6]
print(set(l))
print(tuple(l))
print(dict.fromkeys(l,'default'))
# 如果 iterable 的每个元素都是一个包含两个元素的序列，比如 [['a',1],['b',2]]
# 可以直接用 dict(iterable) 转成字典
# 直接 join 是不行的，必须把所有元素都转成 str
print(''.join(str(_) for _ in l))
字符串转其它
s='hello'
print(set(s))
print(list(s))
print(tuple(s))
print(dict.fromkeys(s,'default'))
网友评论