列表 元组 字典 集合的区别是python面试中最常见的一个问题。这个问题虽然很基础，但确实能反映出面试者的基础水平。
1.列表
列表是以方括号“[]”包围的数据集合，不同成员以“,”分隔。
列表的特点：有序，数据可变，数据可重复，数据类型可不同，可嵌套。
创建一个列表：tl = [1, 'Hello', 1, "你好", [2, 'World']]
初步可以看到它的语法、数据可重复、数据类型可不同、可嵌套等特点，如果用print函数多输出几次就会发现它是有序的，下面我们看一下列表的常用操作，同时也证明列表数据可变。
（1）list.append()追加成员，添加到末尾
tl = [1, 'Hello', 1, "你好", [2, 'World']]
print(tl)
tl.append('test')
print(tl)
输出：
[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, '你好', [2, 'World'], 'test']
（2）list.pop(i)删除第i个成员，并可将删除的数据赋值给变量
tl = [1, 'Hello', 1, "你好", [2, 'World']] print(tl) a = tl.pop(3) print(tl) print(a)
输出：
[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, [2, 'World']]
你好
（3）list.remove(s)直接删除值为s的成员，如果该值有多个只删除第一个，注意与pop的区别
tl = [1, 'Hello', 1, "你好", [2, 'World']]
print(tl)
tl.remove("你好")
print(tl)
输出：
[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, [2, 'World']]
（4）list.index(x)获得参数x在列表中的位置
tl = [1, 'Hello', 1, "你好", [2, 'World']] print(tl.index([2, 'World']))
输出：
4
（5）list.insert(a,b)向列表中的a位置插入数据b
tl = [1, 'Hello', 1, "你好", [2, 'World']] tl.insert(2, '位置二') print(tl)
输出：
[1, 'Hello', '位置二', 1, '你好', [2, 'World']]
（6）list.copy()拷贝列表，两者互相独立
tx = [1, 'Hello', 1, "你好", [2, 'World']] ty = tx.copy() print(tx) print(ty) tx.pop(4) print(tx) print(ty)
输出：
[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, '你好']
[1, 'Hello', 1, '你好', [2, 'World']]
（7）list.extend(L)向列表中追加另一个列表L
tx = [1, 'Hello', 1, "你好", [2, 'World']] ty = [9, 8, 7, 6] tx.extend(ty) print(tx)
输出：
[1, 'Hello', 1, '你好', [2, 'World'], 9, 8, 7, 6]
（8）list.count(y)计算列表中参数y出现的次数，想知道列表长度可以用len(L)
ty = [9, 8, 7, 6, 8] print(ty.count(8))
输出：
2
（9）list.sort()将列表中的成员排序，前提是成员数据类型一致
tx = ['1', 'Hello', '1', "你好"] ty = [9, 8, 7, 6, 8] ty.sort() print(ty) tx.sort() print(tx)
输出：
[6, 7, 8, 8, 9]
['1', '1', 'Hello', '你好']
（10）list.reverse()将列表中成员的顺序颠倒
（11）list.clear()将列表清空
2.元组
元组是以圆括号“()”包围的数据集合，不同成员以“,”分隔。
元组的特点：有序，数据不可变，数据可重复，数据类型可不同，可嵌套。元组通常在需要一组安全稳定的值的时候使用。
元组和列表的区别除了语法就只有一个：数据不可变，也正是这个特点导致元组没有操作数据的方法，比列表要掌握的东西少得多。
（1）tuple.index(x)获得参数x在列表中的位置
（2）tuple.count(y)计算列表中参数y出现的次数
3.字典
字典是以大括号“{}”包围的数据集合，成员内部用“：”分隔，不同成员以“,”分隔。
元组的特点：无序，数据可变，键不可重复，数据类型可不同，可嵌套。通过键来访问成员。
创建一个字典：td = {'k': 'v', 'g': 'd'}，下面我们看一下字典的常用操作：
（1）dict.get('k') 获取键为'k'的值
（2）dict.copy() 拷贝字典，两者互相独立
（3）dict.pop('k') 删除键为'k'的值，并可将删除的值赋值给变量
（4）dict.popitem() 随机删除一对键值，并可将删除的键值赋给变量，注意此时变量的类型将变成元组
td = {'k': 'v', 'g': 'd'}
print(td)
x = td.popitem()
print(td)
print(x, type(x))
输出：
{'g': 'd', 'k': 'v'}
{'k': 'v'}
('g', 'd') <class 'tuple'>
（5）dict.values() 获取字典中所有的“值”
td = {'k': 'v', 'g': 'd'}
print(td)
x = td.values()
for i in x:
print(i)
输出：
{'g': 'd', 'k': 'v'}
d
v
（6）dict.keys() 获取字典中所有的“键”
（7）dict.items() 获取字典的所有键值对，以元组返回
td = {'k': 'v', 'g': 'd'}
print(td)
x = td.items()
for i in x:
print(i)
输出：
{'g': 'd', 'k': 'v'}
('g', 'd')
('k', 'v')
（8）dict.fromkeys(seq[, value])) 用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
a = ('d', 'g', 's')
b = {}
b = b.fromkeys(a, 'test')
print(a, b)
td = {'k': 'v', 'g': 'd'}
print(td)
x = td.fromkeys('k')
print(x)
y = td.fromkeys(td.values(), 1000)
print(y)
输出：
('d', 'g', 's') {'s': 'test', 'd': 'test', 'g': 'test'}
{'g': 'd', 'k': 'v'}
{'k': None}
{'v': 1000, 'd': 1000}
（9）dict.setdefault('k','v') 和get()方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.setdefault('Age', 10))
print("Value : %s" % dict.setdefault('Sex', 'f'))
print(dict)
输出：
Value : 7
Value : f
{'Name': 'Zara', 'Sex': 'f', 'Age': 7}
（10）dict.update(dict2) 函数把字典dict2的键/值对更新到dict里，即dict2中的成员是一定会保留的。
dict1 = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female', 'Age': 11}
dict1.update(dict2)
print("Value : %s" % dict1)
输出：
Value : {'Sex': 'female', 'Age': 11, 'Name': 'Zara'}
（11）dict.clear() 清空
4.集合
集合的特点：无序，数据可变，数据不可重复，数据类型可不同，不可嵌套。集合最好的应用是去重和关系操作（交集、并集等）。集合没有特殊的表示方法，而是通过一个set函数转换成集合。
创建一个字典：t = set("Hello")：
a = set('asdsf')
b = set([8, 5, 7,'xx', 10, 'asdf'])
print(a)
print(b)
输出：
{'d', 's', 'f', 'a'}
{'xx', 5, 7, 8, 10, 'asdf'}
可以看到将一个字符串转换为集合，会把字符串每个字符分开，最终成为一个集合。
下面我们看一下字典的常用操作:
（1）set.add(x) 添加x元素到集合。
a = set(['asdsf', 10])
a.add('iis')
print(a)
输出：
{'iis', 'asdsf', 10}
（2）set.remove(y) 删除集合中的y元素，如果y不存在会报错
a = set(['asdsf', 10])
a.remove('asdsf')
print(a)
输出：
{10}
（3）set.discard(x) 删除集合中的x元素，如果x不存在，不会报错，注意和remove的区别
b = set([8, 5, 7,'xx', 10, 'asdf']) b.discard(9) print(b)
输出：
{5, 7, 8, 10, 'asdf', 'xx'}
（4）set.pop() 随机删除一个集合元素，可将删除的元素赋值给变量
a = set(['asdsf', 10]) x = a.pop() print(a) print(x)
输出： #注意：删除是随机的，多执行几次结果会有变化
{'asdsf'}
10
（5）set.copy() 拷贝一个集合
a = set(['asdsf', 10])
x = a.copy()
print(a)
print(x)
a.remove(10)
print(a, x)
x.remove('asdsf')
print(a, x)
输出：
{10, 'asdsf'}
{10, 'asdsf'}
{'asdsf'} {10, 'asdsf'}
{'asdsf'} {10}
可见，对两个集合的操作互不影响
（6）set.union()和set.update() 将两个集合取并集，这两个方法效果一样，但是union字面意思好理解一些。
b = set([8, 5, 7,'xx', 10, 'asdf']) a = ['kk','vv'] b.update(a) print(b) b.union(a) print(b)
输出：
{'asdf', 5, 7, 8, 10, 'vv', 'xx', 'kk'}
{'asdf', 5, 7, 8, 10, 'vv', 'xx', 'kk'}
（7）set.intersection() 将两个集合取交集。
s = set([3, 5, 9,'asdsf', 10, 'asdf']) b = set([8, 5, 7,'xx', 10, 'asdf']) xx = b.intersection(s) print(xx)
输出：
{10, 'asdf', 5}
（8）b.intersection_update(s) 将两个集合取交集，并将所取的交集覆盖到集合b中
s = set([3, 5, 9,'asdsf', 10, 'asdf']) b = set([8, 5, 7,'xx', 10, 'asdf']) b.intersection_update(s) print(b)
输出：
{10, 'asdf', 5}
（9）yy = b.difference(s) 将b中存在但s中不存在的元素放到集合yy中
s = set([3, 5, 9,'asdsf', 10, 'asdf']) b = set([8, 5, 7,'xx', 10, 'asdf']) yy = b.difference(s) print(yy)
输出：
{8, 'xx', 7}
（10）b.difference_update(s) 将b中存在但s中不存在的元素覆盖到集合b中
s = set([3, 5, 9,'asdsf', 10, 'asdf']) b = set([8, 5, 7,'xx', 10, 'asdf']) b.difference_update(s) print(b)
输出：
{'xx', 7, 8}
（11）b.issunset(s) 判断b是不是s的子集
s = set([3, 5, 9,'asdsf', 10, 'asdf']) b = set([5, 10, 'asdf']) x = b.issubset(s) y = s.issubset(b) print(x) print(y)
输出：
True
False
（12）set.issuperset() 和上一个相反，判断超集
（13）x = s.isdisjoint(b) 判断s和b没有交集，没有返回True，有返回False。
s = set([3, 5, 9,'asdsf', 10, 'asdf']) b = set([6, 10, 'asdf']) c = set([6, 8, 0]) x = s.isdisjoint(b) y = s.isdisjoint(c) print(x) print(y)
输出：
False
True
（14）x = s.symmetric_difference(b) 将s和b两个集合的非重复项合并为一个新的集合。
s = set([3, 5, 9,'asdsf', 10, 'asdf']) b = set([6, 10, 'asdf']) x = s.symmetric_difference(b) print(x)
输出：
{3, 5, 6, 'asdsf', 9}
（15）s.symmetric_difference_update(b) 将s和b两个集合的非重复项合并为一个新的集合并赋值给s。
s = set([3, 5, 9,'asdsf', 10, 'asdf']) b = set([6, 10, 'asdf']) s.symmetric_difference_update(b) print(s)
输出：
{3, 5, 6, 'asdsf', 9}
