[Python知识库]Python 基础学习06 字典与集合

字典对象的创建与索引

列表是有序的可变容器，元组是有序的不可变容器，而字典则是无序的可变容器。字典类型对象的元素组织和查找的方法都和现实中的字典完全一致，这也是该类型对象名称的由来。字典类型对象是Python开发中非常常用的对象类型

1.字典的创建

Python中的字典和真实环境中的字典类似，字典是由一个个键值对（Key-value）构成，键就相当于字典的目录，在键中存储由一个内存地址（相当于页码），然后我们在内存地址中查找到这个键对应的值（也就相当于这一个页面中存储的单词的详细讲解），字典也被称作关联数组或者哈希表。

1.1一般创建方法

字典由键（key）和对应值（value）成对组成的特殊元素构成，外侧则使用大括号圈定。如：

d={'A':1,'B':2,'C':3}
type(d)
dict

Point:

dict即表示字典，其中'A'、'B'、'C'为字典中的键（Key），并且键值一一对应，用冒号表示对应关系;

一个字典可以包括多个键值对，每个键值对可看成是字典中的一个元素，每隔元素彼此之间用都好进行分隔；

字典中的Key智能使用不可变类型对象充当，且一个字典中的Key必须是独一无二的，而Value可用任意类型对象；

不可变类型包括数字、字符串和元组；

可变类型包括列表、字典和集合。

d1={1:1,'a':2,(1,):1}
print (d1)
{1: 1, 'a': 2, (1,): 1}

?当然，若把字典看成一种特殊的容器，字典理所当然可用创建空字典。

1.2 使用dict函数创建字典

和列表、元组类似，字典也可以用类型同名函数dict来进行创建。由于字典数据结构比较特殊，在使用dict函数创建的过程也较为特殊，dict函数必须输入若干长度为2的元组组成的列表，才能顺利的转化为字典

dict([(1,4),(2,3)])
{1: 4, 2: 3}

必须输入长度为二的元组组成的列表，在转化的过程中长度为2的元组中的第一个元素将变为Key，第二个元素将变为Value；

正是因为二院元组中第一个元素会对应转化为字典的Key，因此该元素对象类型必须是不可变类型对象，否则会报错。

dict还有特殊用法，能将赋值过程转化为字典的对应关系

dict(a=1,b=2)
{'a': 1, 'b': 2}

赋值过程转化为字典时，变量名称将会变成字典的Key，并且会转化为字符串；

利用该方法创建字典时，只能创建Key为字符串型的字典。

2.字典的索引

字典的无序特性导致字典的索引和字符串、列表以及元组都不一样。在实际使用中，我们是根据字典元素的二元性（Key-Value）进行索引，即通过输入Key来查找对应的Value，而非利用索引值进行索引。

2.1 一般索引方法

基本索引格式为dict[key],仍然是利用中括号进行索引，知识括号内不再是索引值而是要查找的key的名称。同时，索引返回结果也不是整个Key-Value元素，而是Key对应的Value值。

索引值不存在时会报错。

d['A']
1
同时，由于字典是可变类型对象，因此索引出来结果即可修改
d['A']=2
print(d)
{'A': 2, 'B': 2, 'C': 3}
当然，还可以进一步添加元素
d['D']=4
print(d)
{'A': 2, 'B': 2, 'C': 3, 'D': 4}

2.2 get方法

除了一般索引方法外，对于字典这类比较特殊的对象，通常我们还会考虑使用get方法来进行索引。和一般索引方法不同，get方法可指定当对应的key不存在时返回的结果。

d1.get((1,))
1
#当对应key不存在时，不会返回任何结果
d1.get(3)
#通过对第二个参数的输入，可指定输出key不存在时返回的结果
d1.get(3,'Error')
'Error'

字典的常用方法?

1.Keys/Values方法

面对字典对象，我们可以使用Keys或values方法选取字典中的keys或者values。

# values方法，挑选字典中的values组成新的对象
d.values()
dict_values([1, 2, 3])
# 和range类似，返回结果是原对象，若要显式显示其内容，则可使用list或者tuple函数对其进行转化
type(d.values())
dict_values
dv=d.values()
# 放入list容器
list(dv)
[1, 2, 3]
# 放入tuple容器
tuple(dv)
(1, 2, 3)
d.keys()
dict_keys(['A', 'B', 'C'])
list(d.keys())
['A', 'B', 'C']
tuple(d.keys())
('A', 'B', 'C')

2.items方法

keys和values方法都是将key或者value单独返回，而items方法则是将每个key-value键值对元素打包返回。

# 打包返回键值对，返回结果为由每个键值对构成的元组，并有这些元组所共同构成的列表，该结果仍然属于原类型
d.items()
dict_items([('A', 1), ('B', 2), ('C', 3)])
di=d.items()
list(di)
[('A', 1), ('B', 2), ('C', 3)]
tuple(di)
(('A', 1), ('B', 2), ('C', 3))
注：实际上，keys/values也好，items也好，都是希望能够完成由不可变类型的字典转化为可变类型的转化过程。

3.update方法? ? ?

顾名思义，update函数是用于更新字典的方法，是一种非常灵活的对字典进行修改的方法。

d
{'A': 1, 'B': 2, 'C': 3}
d1=dict(B=2,C=4,D=5)
print(d1)
{'B': 2, 'C': 4, 'D': 5}
d.update(d1)
d
{'A': 1, 'B': 2, 'C': 4, 'D': 5}

更新原则是，有新的部分则更换或添加新的部分，其他部分保留；

更新是有方向的，d.update(d1)和d1.update(d)有本质上的区别；? ??

更新过程会在原来对象基础上对其进行修改。

4.setdefault方法?

setdefault方法会根据键值对原本是否存在，进行有选择的修改。

d=dict(A=1,B=2,C=3)
print(d)
{'A': 1, 'B': 2, 'C': 3}
setdefault方法使用过程中，第一个参数位输入备选Key，第二个参数位置输入备选value

# 若该备选Key在原字典中存在，则返回该Key对应的Value，第二个参数位输入的Value无任何作用
d.setdefault('A',5)
1
#原字典不会被修改
d
{'A': 1, 'B': 2, 'C': 3}
# 若该备选key在原字典中不存在，则返回该key对应的value，备选key-value将被添加至字典中
d.setdefault('D',5)
5
d
{'A': 1, 'B': 2, 'C': 3, 'D': 5}

集合的创建

集合是一类非常特殊的对象，其既有前面提到的列表、元组等容器的功能特点，是一种无序且不可变类型容器，但只用简单形象的容器角度理解集合又会有所欠缺。一个比较合适的理解集合的角度，是将其看作字典的一种特殊形式——由字典的Keys所组成的列表。由此我们可知，集合内的元素和字典中的keys一样，其一是必须为不可变对象类型，其二是元素之间不能重复。

1.基本方法

和其他容器创建过程一样，集合也有一个一般创建方法，使用{}进行标注。

{1,2,3}
{1, 2, 3}
#无序性的体现
{1,2,'Hi',(1,2,3)}
{(1, 2, 3), 1, 2, 'Hi'}

字典key值特性

#集合中不可出现可变对象
#集合中不可出现重复对象
{1,1,2}
{1, 2}
type({1,2})
set

2.set函数创建法

#list转set
set([1,2,3])
{1, 2, 3}
#set转list
#set转list
list({1,2,3})
[1, 2, 3]
#set转tuple
tuple({1,2,3})
(1, 2, 3)
#str转set
set('Hello')
{'H', 'e', 'l', 'o'}
#range转set
set(range(5))
{0, 1, 2, 3, 4}
d=dict(A=1,B=2,C=3)
print(d)
{'A': 1, 'B': 2, 'C': 3}
d.keys()
dict_keys(['A', 'B', 'C'])
set(d.keys())
{'A', 'B', 'C'}
这里需要注意的是，集合转化为列表或元组，本质上都是无序变量转化为有序变量，此过程需要注意输入顺序和最终输出顺序的区别

# 无序变量生成过程会自动跳转顺序
{1,3,2}
{1, 2, 3}
# 最终输出顺序实际上已经发生了改变
list(set([1,3,2]))
[1, 2, 3]8

注意：由于{ }表示空字典，因此若要创建空集合，则必须借助set函数。

type({})
dict
s=set()
print(s)
set()
type(s)
set

3.利用集合去重?

集合的不可变包含重复值的特性，使得我们可以借助集合来进行去重操作。

l1=[1,1,2,3]
s1
s1=set(l1)
s1
{1, 2, 3}
ls1
ls1=list(s1)
ls1
[1, 2, 3]
l2=[2,3,1,1]
s2
#去重也需要注意顺序调整
s2=set(l2)
s2
{1, 2, 3}
ls2
ls2=list(s2)
ls2
[1, 2, 3]

集合的常用方法

作为不可变对象类型，但我们无法利用索引切片对其进行内部元素修改，只能利用一些通用方法修改集合。同时，Python中的集合还可进行数学意义的集合运算，如交集、并集、补集、差集等

1.集合元素增加、删除方法

1.1 add方法

s1={1,3,2}
print(s1)
{1, 2, 3}
s1.add(4)
print(s1)
{1, 2, 3, 4}

1.2 remove方法

常用于删除集合中的指定元素，由于集合本身是无序对象，且元素没有key-value二元属性，因此只能通过指定的方法对元素进行删除。

print(s1)
{1, 2, 3, 4}
s1.remove(4)
s1
{1, 2, 3}

1.3 pop方法

随机删除一个元素（实际是按照重排列后的集合显示顺序进行删除），根本原因仍然是集合的无序性。

s2={(1,2),'Hi',1,2}
print(s2)
{'Hi', 2, (1, 2), 1}
s2.pop()
'Hi'
s2
{(1, 2), 1, 2}
s2.pop()
2
s2
{(1, 2), 1}
s2.pop()
(1, 2)
s2
{1}
s2.pop()
1
s2
set()

2.集合的数学运算

2.1 交集运算

#准备集合
s1={1,2,3}
s2={2,3,4}
s2
#使用运算符&进行交集运算
s1&s2
{2, 3}
# 使用intersection方法进行交集运算
s1.intersection(s2)
{2, 3}
s2.intersection(s1)
{2, 3}
# 使用intersection_update方法进行交集运算并覆盖原值
s1.intersection_update(s2)
s1
s1
{2, 3}

2.2 并集运算

准备集合
s1={1,2,3}
s2={2,3,4}
#利用运算符|进行并集运算
s1|s2
{1, 2, 3, 4}
#利用union方法进行并集运算
s1.union(s2)
{1, 2, 3, 4}
# 使用update进行并集运算并更新原集合
s1.update(s2)
s1
{1, 2, 3, 4}

2.3 差集运算

#准备集合
s1={1,2,3}
s2={2,3,4}
# 使用-运算符进行差集计算
s1-s2
{1}
# 使用difference方法求差集
s1.difference(s2)
{1}
# 使用difference_update方法求差集并更新原集合
s1.difference_update(s2)
s1
s1
{1}

2.4 补集运算

#准备集合
s1={1,2,3}
s2={2,3,4}
s1|s2
{1, 2, 3, 4}
s1&s2
s1&s2
{2, 3}
(s1|s2)-(s1&s2)
{1, 4}
s1^s2
# 利用运算符^进行补集运算
s1^s2
{1, 4}
# 利用symmetric_difference方法进行补集运算
s1.symmetric_difference(s2)
{1, 4}
# 利用symmetric_difference_update方法进行补集运算并更新原集合\n",
s1.symmetric_difference_update(s2)
s1
{1, 4}

2.5 集合关系判断

#准备集合
s1={1,2,3}
s2={2,3}
# 使用issubset判断是否为子集
s2.issubset(s1)
True
# 使用issuperset判断是否为超集合
s1.issuperset(s2)
True
# 使用isdisjoint判断是否包含相同元素，若有相同元素，则返回false
s1.isdisjoint(s2)
False
s3={1,2}
s4={3}
s3.isdisjoint(s4)
True

冻集合的创建与使用

冻集合不可变

1.创建

冻集合只支持利用函数来进行创建，创建函数为frosenset。

#将列表转化为冻集合
frozenset([1,2,3])
frozenset({1, 2, 3})
#将集合转化为冻集合
frozenset({1,2,3})
frozenset({1, 2, 3})
#将元组转化为冻集合
frozenset((1,2,3))
frozenset({1, 2, 3})
#验证冻集合本身不可变性
set([1,2,frozenset([1,2])])
{1, 2, frozenset({1, 2})}

冻集合和集合的元素都必须是不可变类型对象

2.冻集合的常用方法

由于冻集合本身不可变性，冻集合不支持集合的增、删方法，只支持一些基本集合运算。

fr1=frozenset([1,2,3])
fr2=frozenset([2,3,4])
fr1&fr2
frozenset({2, 3})
2
fr1|fr2
frozenset({1, 2, 3, 4})
fr1-fr2
frozenset({1})