字典集合数据类型

字典

  • 字典以键值对形式存在:{ key: value }
  • 其中key值会进行hash运算,生成hash表,所以字典的访问效率优于普通序列数据类型(列表,元组)
  • key值由于需要通过hash,则一些可变数据类型不可以key值,而value的类型没有限制,可以是任意数据类型
  • 由于进行了hash运算,那么在内存中字典其中的数据元素是无序的,没有办法进行一些像索引切片一样的操作
    (但是在Python3.6后,字典数据类型已经被更改为有序数据类型查阅地址;(from collections import OrderedDict))
  • 字典中的key值是唯一
  • 字典为可变数据类型

字典的创建方式

  • 大括号包裹键值对:mydict = {1:’a’ , 2:’b’ }
1
2
3
>>> mydict = {1:'a',2:'b'}
>>> mydict
{1: 'a', 2: 'b'}

  • 工厂方法创建:mydict = dict(([1,’a’],[2,’b’]))
1
2
3
>>> mydict = dict(([1,'a'],[2,'b']))
>>> mydict
{1: 'a', 2: 'b'}

  • 字典内建方法:mydict = dict.fromkeys([1,2],’a’)
1
2
3
4
>>> mydict = dict.fromkeys([1,2],'a')
>>> mydict
{1: 'a', 2: 'a'}
#这样可以批量创建key值,但是缺点也暴露出来无法单独分配value值

访问字典

  • 获得所有key值:dict.keys()
1
2
3
>>> mydict = {1:'a',2:'b'}
>>> mydict.keys()
dict_keys([1, 2])

  • 获取所有value值:dict.values()
1
2
3
>>> mydict = {1:'a',2:'b'}
>>> mydict.values()
dict_values(['a', 'b'])

  • 通过key值获取value dict[key] ,这个操作类似索引和切片,但实际为字典访问value值,所以不要混淆
    • 注意:在访问一个不存在的key值会引发KeyError的错误
1
2
3
4
5
6
7
8
9
>>> mydict = {1:'a',2:'b'}
>>> mydict[1]
'a'
>>> mydict[2]
'b'
>>> mydict[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 3

  • 迭代获取其中key值:for key in dict: 迭代访问到的数据为key
1
2
3
4
5
6
7
8
>>> for key in mydict:
... print(key)
... print(mydict[key])
...
1
a
2
b

判断某个key值是否存在字典中

  • 使用 in 还有 not in 判断是否在字典中有对应Key值,返回值为bool类型
1
2
3
4
5
6
>>> mydict = {1:'a',2:'b'}
>>> 1 in mydict
True
>>> 3 in mydict
False
#由于value值是可以重复的,所以判断value是没有意义的

更新字典

  • 通过对应key值访问到value值之后,重新赋值给它则可进行更新
1
2
3
4
>>> mydict = {1:'a',2:'b'}
>>> mydict[1] = 'c'
>>> mydict
{1: 'c', 2: 'b'}

删除字典中的值

  • 使用del语句删除对应key值所关联的value值,会把这个键值对删除掉
1
2
3
4
>>> mydict = {1:'a',2:'b'}
>>> del mydict[1]
>>> mydict
{2: 'b'}

  • pop(obj) 函数删除字典中的某个值,并将被删除值返回
1
2
3
4
5
>>> mydict = {1:'a',2:'b'}
>>> mydict.pop(1)
'a'
>>> mydict
{2: 'b'}

清空字典

  • dict.clear() 函数会将这个字典重新成为一个新的空字典
1
2
3
4
>>> mydict = {1:'a',2:'b'}
>>> mydict.clear()
>>> mydict
{}
  • del语句直接删除字典变量,这也是最粗暴的方式
1
2
3
4
5
6
7
>>> mydict = {1:'a',2:'b'}
>>> del mydict
>>> mydict
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'mydict' is not defined
#字典被删除之后连变量都不见了

集合

  • 集合:把不同元素组合在一起形成的一个数据集合
  • 集合分为两种:可变集合(set),不可变集合(frozenset)
  • 集合的内部结构和字典类似,但是不存储value,其中的元素也会进行hash运算,可以称的上是一个没有value的字典
  • 集合中数据元素不能为可变数据对象
1
2
3
4
5
>>> myset = {[1,2,3]}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
#可变数据对象不可hash,所以不能成为集合中数据元素

创建集合

  • 可变集合
1
2
3
4
5
6
>>> myset = {1,2,3,4,5}
#直接通过大括号创建
>>> myset = set([1,2,3,1,2,3])
>>> myset
{1, 2, 3}
#通过工厂函数接收一个可迭代对象

  • 不可变集合
1
2
3
>>> myset = frozenset([1,2,3,1,2,3])
>>> myset
frozenset({1, 2, 3})

访问集合

  • 迭代访问集合
1
2
3
4
5
6
7
8
>>> myset  = {1,2,3}
>>> for var in myset:
... print(var)
...
1
2
3
#集合虽然无序,但是可以通过for循环迭代访问

更新集合

  • set.add():更新可hash数据类型到集合中,并维持数据类型
    • 由于集合中的数据元素需要进行hash运算,可变数据类型是不可以进行hash运算的,也就不能传递进来被更新
1
2
3
4
5
6
7
8
9
10
11
>>> myset = {1,2}
>>> myset.add('abc') #更新字符串到集合中
>>> myset
{1, 2, 'abc'}
>>> myset.add((1,2,3)) #更新元组到集合中
>>> myset
{1, 2, 'abc', (1, 2, 3)}
>>> myset.add([1,2,3]) #更新列表到集合中报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

  • set.update():如果传入的是一个序列,将被拆分成单个元素,并且去重
1
2
3
4
5
6
7
8
9
10
>>> myset = {1,2}
>>> myset.update('abc') #更新字符串
>>> myset
{1, 2, 'b', 'c', 'a'} #字符串被拆开
>>> myset.update([1,2,3]) #更新列表
>>> myset
{1, 2, 3, 'b', 'c', 'a'} #这里列表支持更新是因为存储的数据已经不再是列表,而是列表中的每一个实际数据
>>> myset.update((3,4,5)) #更新元组
>>> myset
{1, 2, 3, 4, 'b', 5, 'c', 'a'} #元组中的每一个数据都被拿出更新到集合中,并且去重

  • 可变集合支持更新操作,不可变集合不支持更新操作
1
2
3
4
5
6
7
8
9
10
11
12
13
>>> myset = frozenset('abc')
>>> myset
frozenset({'a', 'b', 'c'})
>>> myset.add()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
#不可变集合不支持add更新
>>> myset.update()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'update'
#不可变集合不支持update更新

删除集合中的元素

  • s.remove(obj):删除obj元素从集合s
    - 该函数在删除一个不存在的数据时会引发KeyError
1
2
3
4
5
6
7
8
>>> myset = {1,2,3}
>>> myset.remove(3)
>>> myset
{1, 2}
>>> myset.remove(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 5

  • s.discard(obj) :如果obj是集合s中的元素,从集合s中删除对象obj
    • 该函数在删除一个不存在的数据时不会报错
1
2
3
4
5
6
7
8
>>> myset = {1,2}
>>> myset.discard(1)
>>> myset
{2}
>>> myset = {1,2}
>>> myset.discard(3)
>>> myset
{1, 2}

  • del myset:删除这个集合变量
1
2
3
4
5
6
>>> myset = {1,2,3}
>>> del myset
>>> myset
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'myset' is not defined

集合类型操作符

  • innot in可以判断某个元素是否在集合中
1
2
3
4
5
6
7
>>> myset = {1,2}
>>> 1 in myset
True
>>> 3 in myset
False
>>> 2 not in myset
False

  • 子集和超集:
    • a < ba是否是b子集a.issubset(b)
      • a的元素b都有
    • a > ba是否是b超集a.issuperset(b)
      • 超集就代表a中的元素囊括了所有b的集合元素
1
2
3
4
5
6
>>> a = {1,2}
>>> b = {1,2,3,4}
>>> a < b
True
>>> a.issubset(b)
True

集合的交、并、补操作

  • 联合:在a集合中和b集合去重数据元素,剩下的组合到一起返回一个新的集合
    • 操作符:a | b
    • 函数:a.union(b)
1
2
3
4
>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a | b
{1, 2, 3, 'c', 'b', 'a'}

  • 交集:在a集合和b集合中,共同含有的集合成员去掉重复数据,组成到一起返回一个新的集合
    • 操作符:a &b
    • 函数:a.intersection(b)
1
2
3
4
>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a & b
{'a', 1}

  • 差补:在a集合中去掉所有与b集合中相同的元素,只在a中保留b中没有的集合成员
    • 操作符:a – b
    • 函数:a.difference(b)
1
2
3
4
>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a - b
{2, 'b'}

  • 对称差分:找出两个集合中,只属于集合a或集合b的元素;也就是去掉共有元素后,返回一个新的集合
    • 操作符:a ^ b
    • 函数:a.symmetric_differenc(b)
1
2
3
4
>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a ^ b
{2, 3, 'b', 'c'}

转载请注明原文地址

您的支持将被用作发行更高质量原创技术!