Python-集合类型

Programing
4.6k 词

列表

列表( list )是多个数据的可变集合，也是最基本的可变类型。

列表写在一对方括号内，元素之间用逗号隔开。和元组一样，列表内部元素顺序存储，每个位置的元素都有自己的索引。可以通过索引访问列表中的元素并修改。如果索引超出列表的范围则引发 IndexError 异常，即越界。

  • 可以通过内置的 len() 函数获取列表内元素的数量。

  • 可以通过内置的 max() 函数获取列表内最大的元素。

  • 可以通过内置的 min() 函数获取列表内最小的元素。

  • 可以通过内置的 list([iterable]) 函数创建空列表或将可迭代类型转为列表。

1
2
3
4
5
6
7
8
9
10
11
#Python

list1 = [1,"2",[3],{4}]
tuple1 = (1,'1',{4},{5:1},[4]) #一个元组
empty_list = ()
empty_list = list()
list3 = list([1,2,3,4])#从列表创建列表
list4 = list(tuple1)#从元组创建列表
print(len(list1))
print(max(list3))
print(min(list3))

列表元素的访问

列表和元组一样，可以访问内部储存的数据的，相比元组，列表可以修改内部的元素。访问列表中的元素通过访问运算符 [] ，以元素的索引为标志： list[index] 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#Python

list1 = [1,"2",[3],{4}]
print(list1[0])#获取第一个元素
print(list1[2])#获取第三个元素
print(list1[-1])#获取最后一个元素
print(list1[-2])#获取倒数第二个元素
list1[2] = 114.514#修改第三个元素
list1[-1] = {5:6}#修改最后一个元素
print(list1)
del list1[1]#删除第二个元素
print(list1)
"""
1
[3]
[4]
[3]
[1, '2', 114.514, {5: 6}]
[1, 114.514, {5: 6}]
"""

列表的拆分

列表支持拆分，和元组一样，可以将一个列表同时赋值给与列表内元素相同数目的变量。变量会按先后顺序依次从获取列表对应位置的元素。

1
2
3
4
5
6
7
8
9
#Python

list1 = [1,"2",[3],{4}]
a,b,c,d = list1
print(a,b,c,d)

"""
1 2 [3] {4}
"""

列表的切片

访问运算符不仅可以用于访问元素，可也有用来获取列表的切片： list[start_index:end_index] ，得到一个新列表，包含原列表从 start_index 到 end_index 的元素，元素顺序不变（且内部元素与原列表为同一个变量，相当于只创建原元素的浅拷贝）。

与元组不同， list[:] 会创建一个包含原列表的浅拷贝，因此得到的不是原数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#Python

list1 = [1,"2",[3],{4}]
print(list1[1:3])#实际包含索引为1、2的元素，索引为3的元素未包含
print(list1[1:-1])#不包括最后一个元素
print(list1[1:])#包括最后一个元素
print(list1[:-2])
list2 = list1[:]
print(id(list1) == id(list2))
list3 = list1[1:3]
print(id(list1[2]) == id(list3[1]))

"""
['2', [3]]
['2', [3], {4}]
[1, '2']
False
True
"""

列表运算符

列表可以像数字一样执行各种运算。

表达式 结果 描述
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 拼接两个列表，得到一个新列表
[1, 2, 3]*2 [1, 2, 3, 1, 2, 3] 重复列表并拼接
list1 = [1, 2, 3]
list1 += [4, 5, 6]
print(list1)		 [1, 2, 3, 4, 5, 6] 向原列表追加列表中的元素
3 in [1, 2, 3] True 判断值是否存在
[1, 2, 3] > [4, 5, 6] False 比较两个列表

列表方法

列表提供了许多内建的方法。

见 集合类型补充

字典

字典（ dict ）是一种可变且无序的容器，存储键值对及其映射关系。每一个键都有对应的值，键不能重复，值可以重复。

字典写在一对花括号内，元素为键值对 key:value ，之间用逗号隔开。字典内部元素无序存储，可以通过键访问字典中对应的只并修改。

  • 可以通过内置的 len() 函数获取字典内键值对的数量。

  • 可以通过内置的 max() 函数获取字典内最大的键。

  • 可以通过内置的 min() 函数获取字典内最小的键。

  • 可以通过内置的 dict([iterable]) 函数创建空字典或将可迭代类型转为列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#Python

dict1 = {1:2,3:4,5:6}
empty_dict = {}
empty_dict = dict()
dict2 = dict(zip([1,2,3,4],[5,6,7,8]))#从两个等长列表创建字典
print(len(dict1))
print(max(dict1))
print(min(dict1))
print(dict2)
"""
3
5
1
{1: 5, 2: 6, 3: 7, 4: 8}
"""

字典元素的访问

字典可以访问并修改内部储存的数据。访问字典中的元素通过访问运算符 [] ，以键为标志： dict[key] 。在 dict[key] 为右值时如果 key 不存在则引发 KeyError 异常；为左值时 key 不存在则会创建键。如果键已存在于字典中则会覆盖原有的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#Python

dict1 = {'1':2,'3':4,'5':6}
print(dict1['1'])
print(dict1['5'])
dict1['1'] = 114.514
dict1['5'] = 10086#添加一个值
print(dict1)
del dict1['3']#删除键即对应的值
print(dict1)
"""
2
6
{'1': 114.514, '3': 4, '5': 10086}
{'1': 114.514, '5': 10086}
"""

字典的拆分

字典支持拆分，和元组一样，可以将一个字典的所有键同时赋值给与字典内键值对相同数目的变量。由于字典是无序的，无法确定每个变量会被分配到的值。

1
2
3
4
5
6
7
8
9
#Python

dict1 = {'1': 114.514, '5': 10086}
a,b = dict1
print(a,b)

"""
1 5
"""

字典运算符

在运算符中，字典支持 in 和 not in 运算符，用于判断值是否存在于字典的键中。

字典方法

字典提供了许多内建的方法。

见 集合类型补充

集合

集合（ set ）是数据的无序可变集合，就像数学中的集合一样，内部元素不重复，也可以进行数学上的集合运算。与其他集合类型不同，集合中的元素必须是值类型的默认类型或者实现了 __hash__ 方法的对象。集合中的元素无法直接访问。

集合写在一对花括号内，元素之间用逗号隔开。

  • 可以通过内置的 len() 函数获取集合内元素的数量。

  • 可以通过内置的 max() 函数获取集合内最大的元素。

  • 可以通过内置的 min() 函数获取集合内最小的元素。

  • 可以通过内置的 set([iterable]) 函数创建空集合或将可迭代类型转为集合。

创建空集合必须使用 set() 函数， {} 会创建一个空字典而不是空集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#Python

set1 = {1,"2",1.1,2.4,1}#重复元素会被忽略
tuple1 = (1,'1',"abababa") #一个元组
empty_set = set()
set3 = set([1,2,3,4])#从列表创建集合
set4 = set(tuple1)#从元组创建集合
print(len(set1))
print(max(set3))
print(min(set3))
"""
4
4
1
"""

集合的拆分

集合支持拆分，和元组一样，可以将一个集合同时赋值给与集合内元素相同数目的变量。由于集合是无序的，无法确定每个变量会被分配到的值。

1
2
3
4
5
6
7
8
9
#Python

set1 = {1,"2",1.1,2.4}
a,b,c,d = set1
print(a,b,c,d)

"""
1 "2" 1.1 2.4
"""

集合运算符

集合可以像数学集合一样执行各种运算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#Python

pos   = {1,2,3,4,5,6,7,8,9,10}
odd   = {1,3,5,7,9,11}
even  = {2,4,6,8,10}
prime = {2,3,5,7,11,13}

print(pos - odd)#差集
print(odd | even)#并集
print(even & prime)#交集
print(odd ^ prime)#不同时包含

"""
{2, 4, 6, 8, 10}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
{2}
{1, 2, 9, 13}
"""

集合方法

集合提供了许多内建的方法。

见 集合类型补充

写在最后

这便是 Python 中三种基本集合，足以应付绝大多数情况。掌握集合内建的方法，避免重复造轮子，事半功倍。

留言