正文
list，tuple，dict，set的使用方法
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
list
list是一种有序的集合，可以随时添加和删除其中的元素
classmates = ['Michael', 'Bob', 'Tracy']
len()函数可以获得list元素的个数。list长度比索引小1.
list的索引是从0开始的，-1做索引，获取最后一个元素。索引超出范围，会报IndexError的错误。
例：（切片）
>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2] 'Taobao'
>>> L[-2] 'Runoob'
>>> L[1:] ['Runoob', 'Taobao']
append方法可以将元素追加到列表末尾
例：
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
也可以将元素插入到指定的位置insert()
例：
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
删除list末尾的元素，pop()方法
例：
classmates.pop()
'Adam'>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
删除指定位置的元素，pop(i)方法
例：
>>> classmates.pop(1)
'Jack'>>> classmates
['Michael', 'Bob', 'Tracy']
删除元素还有一个方法del
例:
>>> list = ['Google', 'Runoob', 1997, 2000]
>>> del list[2]
>>> print(list)
['Google', 'Runoob', 2000]
要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：
例：
>>> classmates[1] = 'Sarah'>>> classmates
['Michael', 'Sarah', 'Tracy']
list里面的数据类型可以是不同的，list的元素也可以是另外一个list。
例：
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4
例：
>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'
空的list的长度为0
列表脚本操作符：
Python 表达式 结果 描述
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合，列表拼接
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重复
3 in [1, 2, 3] True 元素是否存在于列表中（not in相反）
for x in [1, 2, 3]: print(x, end=" ") 1 2 3 迭代
列表的一些方法
max(list) 返回列表元素最大值
min(list) 返回列表元素最小值
list(seq) 将元组转化为列表
list.count(obj) 统计某个元素在列表中出现的次数
list.clear() 清空列表
list.sort([func]) 对列表进行排序 func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
list.reverse() 反向列表中元素
list.remove(obj)移除列表中某个值的第一个匹配项
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
tuple
另一种有序列表叫做元组。tuple一旦初始化就不能修改。不能被改变会更安全。
例：
>>> classmates = ('Michael', 'Bob', 'Tracy')
取classmates中的值 classmates[-1],classmates[1]，通过下标
当tuple中只有一个元素时，要这样定义：t = (1,),多加一个逗号来消除歧义，不加逗号。t=（1）（）相当于小括号，赋值。
“可变”的tuple：
例：
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'>>> t[2][1] = 'Y'>>> t
('a', 'b', ['X', 'Y'])
表面上元素变了，但tuple一开始指向的list并没有改成别的list，对于tuple来说还是没变。指向不变。
# 创建一个新的元组
tup3 = tup1 + tup2
del tup3 #删除tup3
Python 表达式 结果 描述
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 组合，列表拼接
('Hi!') * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') 重复
3 in (1, 2, 3) True 元素是否存在于列表中（not in相反）
for x in (1, 2, 3]) print(x) 1 2 3 迭代
内置函数
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。
dict
dict 字典，全称dictionary，使用键-值（key-value）存储。字典的每个键值对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
例：
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
除了初始化时指定外，还可以通过key放入：
>>> d['Adam'] = 67
>>> d['Adam']
67
由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉
key不存在，会报错。可以使用两种方法，一是通过in来判断key是否存在
例：
>>> 'Thomas' in d
False
二是通过get（）方法，如果key不存在，返回None，或者自己指定的value
例：
>>> d.get('Thomas') #None交互环境不显示结果
>>> d.get('Thomas', -1)
-1
要删除一个key，用po(key)方法，对应的value也会从dict中删除。
例：
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较，dict有以下几个特点：
- 查找和插入的速度极快，不会随着key的增加而变慢；
- 需要占用大量的内存，内存浪费多。
而list相反：
- 查找和插入的时间随着元素的增加而增加；
- 占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
dict的key必须是不可变对象，通过key计算位置的算法称为哈希算法
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
内置函数
len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典，以可打印的字符串表示。
type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
内置方法
序号 函数及描述
1 radiansdict.clear() 删除字典内所有元素
2 radiansdict.copy() 返回一个字典的浅复制
3 radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5 key in dict 如果键在字典dict里返回true，否则返回false
6 radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
7 radiansdict.keys() 以列表返回一个字典所有的键
8 radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10 radiansdict.values() 以列表返回字典中的所有值
11 pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12 popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。
set
set是一组key的集合，key不能重复。
要创建一个set，需要提供一个list作为输入集合
例：
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
set不是有序的
重复元素在set中自动过滤
add(key)方法添加元素到set中，可以重复添加，但不会有效果。
例：
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
通过remove(key)可以删除元素
例：
>>> s.remove(4)
>>> s
{1, 2, 3}
set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
set中不能放入可变对象。
#关系测试
#交集(两个列表里面都有的值，这里是4、6)：
print(list_1.intersection(list_2))
#并集（把两个列别合并起来，然后去重）：
print(list_1.union(list_2))
#差集（把list_1里面有的而list_2里面没有的取出来）：
print(list_1.difference(list_2))
#对称差集（两个列表里面，互相没有的取出来，也就是只去掉那些互相都有的值）
print(list_1.symmetric_difference(list_2))
#子集（判断list_1是否包含了list_3里面的所有值）
print(list_3.issubset(list_1))
#父集（判断list_1是否为list_3的父集）
print(list_1.issuperset(list_3))
#无交集（判断list_3和list_4是否完全没有任何交集）
list_4 = set([5,6,8])
print(list_3.isdisjoint(list_4))
#-----------------------关系测试的另一种写法：
'''
s = set([3,5,9,10]) #创建一个数值集合
t = set("Hello") #创建一个唯一字符的集合
a = t | s # t 和 s的并集
b = t & s # t 和 s的交集
c = t – s # 求差集（项在t中，但不在s中）
d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）
基本操作：
t.add('x') # 添加一项
s.update([10,37,42]) # 在s中添加多项
使用remove()可以删除一项：
t.remove('H') #有就删除，没有就报错
t.pop() #随机弹出一个
t.discard('H') #有就删除，没有也不会报错
len(s)
set 的长度
x in s
测试 x 是否是 s 的成员
x not in s
测试 x 是否不是 s 的成员
s.issubset(t)
s <= t
测试是否 s 中的每一个元素都在 t 中
s.issuperset(t)
s >= t
测试是否 t 中的每一个元素都在 s 中
s.union(t)
s | t
返回一个新的 set 包含 s 和 t 中的每一个元素
s.intersection(t)
s & t
返回一个新的 set 包含 s 和 t 中的公共元素
s.difference(t)
s - t
返回一个新的 set 包含 s 中有但是 t 中没有的元素
s.symmetric_difference(t)
s ^ t
返回一个新的 set 包含 s 和 t 中不重复的元素
s.copy()
返回 set “s”的一个浅复制
参考：https://www.liaoxuefeng.com
http://www.runoob.com
