**python中列表 元组 字典 集合

列表 元组 字典 集合的区别是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}