python集合中的元素可以是元组 也可以是列表_**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')

(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}