Python之元组、字典和集合详解

一、元组

列表的功能虽然很强大，但负担也很重，在很大程度上影响了运行效率。有时候我们并不需要那么多功能，很希望能有个轻量级的列表，元组（tuple）正是这样一种类型。

1、创建元组

从形式上，元组的所有元素放在一对圆括号中，元素之间使用逗号分隔，如果元组中只有一个元素则必须在最后增加一个逗号

x=(1,2,3)   #直接把元组赋值给一个变量
print(type(x))  #使用type（）函数查看变量类型

print(x[0])     #元组支持使用下标访问特定的位置元素

print(x[-1])    #最后一个元素，元素也支持双向索引
#x[1]=4
x=(3)           #int类型
print(x)
x=(3,)          #如果元组中只有一个元素，必须在后面多写一个逗号
print(x)
x=()            #空元组
x=tuple()       #空元组
print(tuple(range(5))) #将其他迭代对象转换为元组

<class 'tuple'>
1
3
3
(3,)
(0, 1, 2, 3, 4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

很多内置函数的返回值也是包含了若干元组的可迭代对象，例如enumerate（）、zip（）等

enumerate()函数返回包含若干下标和值的迭代对象
zip()函数用于将多个列表中元素重新组合为元组并返回包含这些元组的zip对象

x=list(enumerate(range(5)))
print(x)

y=list(zip(range(3),'abcdefg'))
print(y)

[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
[(0, 'a'), (1, 'b'), (2, 'c')]
1
2
3
4
5
6
7
8

2、元组与列表的异同

1. 列表和元组都属于有序序列，都支持使用双向索引访问其中的元素，以及使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引，len()、map()、filter()等大量内置函数和+、+=、in等运算符也都可以作用于列表和元组
2. 元组属于不可变（immutable）序列，不可以直接修改元组中元素的值，也无法为元组增加或删除元素。
3. 元组没有提供append()、extend()和insert()等方法，无法向元组中添加元素；同样，元组也没有remove()和pop()方法，也不支持对元组元素进行del操作，不能从元组中删除元素，而只能使用del命令删除整个元组。
4. 元组也支持切片操作，但是只能通过切片来访问元组中的元素，而不允许使用切片来修改元组中元素的值，也不支持使用切片操作来为元组增加或删除元素。

3、生成器推导式

使用生成器对象__next__()方法或内置函数next()进行遍历

>>> g = ((i+2)**2 for i in range(10))  #创建生成器对象
>>> g
<generator object <genexpr> at 0x0000000003095200>
>>> tuple(g)                           #将生成器对象转换为元组
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> list(g)             #生成器对象已遍历结束，没有元素了
[] 
>>> g = ((i+2)**2 for i in range(10))  #重新创建生成器对象
>>> g.__next__()        #使用生成器对象的__next__()方法获取元素
4
>>> g.__next__()        #获取下一个元素
9
>>> next(g)             #使用函数next()获取生成器对象中的元素
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14

二、字典

字典（dictionary）是包含若干==“键:值”元素的无序可变序列，字典中的每个元素包含用冒号分隔开的“键”和“值”两部分，表示一种映射或对应关系，也称关联数组。定义字典时，每个元素的“键”和“值”之间用冒号分隔，不同元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。
字典中元素的“键”可以是Python中任意不可变数据，例如整数、实数、复数、字符串、元组等类型等可哈希数据==，但不能使用列表、集合、字典或其他可变类型作为字典的“键”。另外，字典中的“键”不允许重复，而“值”是可以重复的。

3.1、字典创建与删除

使用赋值运算符“=”将一个字典赋值给一个变量即可创建一个字典变量。
>>> aDict = {'server': 'db.diveintopython3.org', 'database': 'mysql'}

也可以使用内置类dict以不同形式创建字典。
>>> x = dict()                               #空字典
>>> type(x)                                  #查看对象类型
<class 'dict'>
>>> x = {}                                   #空字典
>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> dictionary = dict(zip(keys, values))     #根据已有数据创建字典
>>> d = dict(name='Dong', age=39)            #以关键参数的形式创建字典
>>> aDict = dict.fromkeys(['name', 'age', 'sex'])
                             #以给定内容为“键”，创建“值”为空的字典
>>> aDict
{'age': None, 'name': None, 'sex': None}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.2、字典元素访问

字典中的每个元素表示一种映射关系或对应关系，根据提供的“键”作为下标就可以访问对应的“值”，如果字典中不存在这个“键”会抛出异常。

>>> aDict = {'age': 39, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
>>> aDict['age']                     #指定的“键”存在，返回对应的“值”
39
>>> aDict['address']                 #指定的“键”不存在，抛出异常
KeyError: 'address'
1
2
3
4
5

字典对象提供了一个get()方法用来返回指定“键”对应的“值”，并且允许指定该键不存在时返回特定的“值”。例如：

>>> aDict.get('age')                    #如果字典中存在该“键”则返回对应的“值”
39
>>> aDict.get('address', 'Not Exists.') #指定的“键”不存在时返回指定的默认值
'Not Exists.'
1
2
3
4

使用字典对象的items()方法可以返回字典的键、值对。
使用字典对象的keys()方法可以返回字典的键。
使用字典对象的values()方法可以返回字典的值。

使用for循环直接迭代生成器对象中的元素

>>> g = ((i+2)**2 for i in range(10))
>>> for item in g:                #使用循环直接遍历生成器对象中的元素
        print(item, end=' ')
4 9 16 25 36 49 64 81 100 121 
1
2
3
4

案例1：首先生成包含1000个随机字符的字符串，然后统计每个字符的出现次数

>>> import string
>>> import random
>>> x = string.ascii_letters + string.digits + string.punctuation
>>> y = [random.choice(x) for i in range(1000)]
>>> z = ''.join(y)
>>> d = dict()                  #使用字典保存每个字符出现次数
>>> for ch in z:
    d[ch] = d.get(ch, 0) + 1
1
2
3
4
5
6
7
8

3.3、字典元素添加、修改和删除

当以指定“键”为下标为字典元素赋值时，有两种含义：
1）若该“键”存在，则表示修改该“键”对应的值；
2）若不存在，则表示添加一个新的“键:值”对，也就是添加一个新元素。

>>> aDict = {'age': 35, 'name': 'Dong', 'sex': 'male'}
>>> aDict['age'] = 39                  #修改元素值
>>> aDict
{'age': 39, 'name': 'Dong', 'sex': 'male'}
>>> aDict['address'] = 'SDIBT'         #添加新元素
>>> aDict
{'age': 39, 'address': 'SDIBT', 'name': 'Dong', 'sex': 'male'}
1
2
3
4
5
6
7

使用字典对象的update()方法可以将另一个字典的“键:值”一次性全部添加到当前字典对象，如果两个字典中存在相同的“键”，则以另一个字典中的“值”为准对当前字典进行更新。

>>> aDict = {'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
>>> aDict.update({'a':97, 'age':39})  #修改’age’键的值，同时添加新元素’a’:97
>>> aDict
{'score': [98, 97], 'sex': 'male', 'a': 97, 'age': 39, 'name': 'Dong'}
1
2
3
4

如果需要删除字典中指定的元素，可以使用del命令。

>>> del aDict['age']               #删除字典元素
>>> aDict
{'score': [98, 97], 'sex': 'male', 'a': 97, 'name': 'Dong'}
1
2
3

也可以使用字典对象的pop()和popitem()方法弹出并删除指定的元素，例如：
>>> aDict = {'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
>>> aDict.popitem()                #弹出一个元素，对空字典会抛出异常
('age', 37)
>>> aDict.pop('sex')               #弹出指定键对应的元素
'male'
>>> aDict
{'score': [98, 97], 'name': 'Dong'}
1
2
3
4
5
6
7
8

三、集合

集合（set）属于Python 无序可变序列，使用一对大括号作为定界符，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的，元素之间不允许重复。

集合中只能包含数字、字符串、元组等不可变类型（或者说可哈希）的数据，而不能包含列表、字典、集合等可变类型的数据。

3.1、集合对象的创建与删除

直接将集合赋值给变量即可创建一个集合对象。

>>> a = {3, 5}                         #创建集合对象
>>> type(a)                            #查看对象类型
<class 'set'>
1
2
3

也可以使用函数set()函数将列表、元组、字符串、range对象等其他可迭代对象转换为集合，如果原来的数据中存在重复元素，则在转换为集合的时候只保留一个；如果原序列或迭代对象中有不可哈希的值，无法转换成为集合，抛出异常。

>>> a_set = set(range(8, 14))                     #把range对象转换为集合
>>> a_set
{8, 9, 10, 11, 12, 13}
>>> b_set = set([0, 1, 2, 3, 0, 1, 2, 3, 7, 8])   #转换时自动去掉重复元素
>>> b_set
{0, 1, 2, 3, 7, 8}
>>> x = set()                                     #空集合
1
2
3
4
5
6
7

1）集合元素增加与删除
使用集合对象的add()方法可以增加新元素，如果该元素已存在则忽略该操作，不会抛出异常；update()方法用于合并另外一个集合中的元素到当前集合中，并自动去除重复元素。例如：

>>> s = {1, 2, 3}
>>> s.add(3)                          #添加元素，重复元素自动忽略
>>> s
{1, 2, 3}
>>> s.update({3,4})                   #更新当前字典，自动忽略重复的元素
>>> s
{1, 2, 3, 4}
1
2
3
4
5
6
7

pop()方法用于随机删除并返回集合中的一个元素，如果集合为空则抛出异常；
remove()方法用于删除集合中的元素，如果指定元素不存在则抛出异常；
discard()用于从集合中删除一个特定元素，如果元素不在集合中则忽略该操作；
clear()方法清空集合删除所有元素。

>>> s.discard(5)                     #删除元素，不存在则忽略该操作
>>> s
{1, 2, 3, 4}
>>> s.remove(5)                      #删除元素，不存在就抛出异常
KeyError: 5
>>> s.pop()                          #删除并返回一个元素
1
1
2
3
4
5
6
7

2）集合运算

>>> a_set = set([8, 9, 10, 11, 12, 13])
>>> b_set = {0, 1, 2, 3, 7, 8}
>>> a_set | b_set                     #并集
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set.union(b_set)                #并集
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set & b_set                     #交集
{8}
>>> a_set.intersection(b_set)         #交集
{8}
>>> a_set.difference(b_set)           #差集
{9, 10, 11, 12, 13}
>>> a_set - b_set
{9, 10, 11, 12, 13}
>>> a_set.symmetric_difference(b_set) #对称差集
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
>>> a_set ^ b_set
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19