Python字典与集合

最新推荐文章于 2024-06-28 16:42:10 发布
最新推荐文章于 2024-06-28 16:42:10 发布
阅读量869 收藏 17
点赞数 22
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongxiao_highgo/article/details/136301771
版权

1.字典

字典通过键值对（key:value）的方式，把key映射到value，key必须是可hash的（hashable），由于python中所有内置的不可变类型（immutable）都是可以hash的，所以都可以用作字典的key，比如字符串（str）、数字（int，float）和只包含不可变类型元素的元组（tuple），如果元组直接或间接的包含了可变类型的元素，也不能作为字典的key，value则可以是任意类型。
字典中元素是无序的，并不会按照插入的顺序排序，可能会是任意的顺序，如果想要有序的字典，可以使用collections.OreredDict。但是从Python3.7开始，字典默认是按照插入顺序排序的了。

1.1字典的创建
创建一个字典可以通过以下3种方式：

  • 大括号{}方式：
>>> d = {'name':'lili','age':18}
>>> d
{'name': 'lili', 'age': 18}
  • dict关键字方式：
    dict的定义如下：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

根据定义dict接受如下形式的参数进行初始化：

>>> dict(one=1, two=2) # 关键字参数形式（**kwargs）
{'one': 1, 'two': 2}
>>> dict({'one':1, 'two':2}) # 字典形式（mapping）
{'one': 1, 'two': 2}
>>> dict([('one',1), ['two',2]]) # 可迭代类型中内嵌2个元素的可迭代类型（iterable）
{'one': 1, 'two': 2}
>>> dict({'one':1}, two=2) # 字典+关键字参数形式（mapping + **kwargs）
{'one': 1, 'two': 2}
>>> dict([('one',1)], two=2) # 可迭代类型+关键字参数形式（iterable + **kwargs）
{'one': 1, 'two': 2}
  • 字典推导式（dict comprehension）：
>>> {x: x**2 for x in (2,4,6)}
{2: 4, 4: 16, 6: 36}

1.2字典操作

  • len(d)
    返回字典d的长度，即包含多少个键值对
>>> d = {'one':1, 'two':2}
>>> len(d)
2
  • d[key]
    返回key对应的value，如果key不存在，则抛出KeyError异常
>>> d = {'one':1, 'two':2}
>>> d['one']
1
>>> d['three']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'three'
  • d[key] = value
    设置key对应的value，如果key不存在则自动添加
>>> d = {'one':1, 'two':2}
>>> d['two'] = 2.0
>>> d['three'] = 3
>>> d
{'one': 1, 'two': 2.0, 'three': 3}
  • del d[key]
    删除key对应的项，如果key不存在则抛出KeyError异常
>>> d = {'one':1, 'two':2}
>>> del d['two']
>>> d
{'one': 1}
  • pop(key[,default])
    删除key对应的项，并返回对应的value，如果key不存在并且传入了default参数，那么返回default，否则抛出KeyError异常
>>> d = {'one':1, 'two':2}
>>> d.pop('two')
2
>>> d.pop('three',0)
0
>>> d
{'one': 1}
  • popitem()
    任意删除并返回一个项，由于字典是无序的，所以删除的项是不确定的
>>> d = {'one':1, 'two':2}
>>> d.popitem()
('two', 2)
>>> d
{'one': 1}

从python3.7开始字典是有序的（按照插入顺序排序），所以popitem()会按照LIFO规则删除，即相当于删除最后一个项

  • key in d
    如果key存在于字典d中，则返回True，否则返回False
>>> d = {'one':1, 'two':2}
>>> 'one' in d
True
>>> 'three' in d
False
  • key not in d
    如果key不存在于字典d中，则返回True，否则返回False
>>> d = {'one':1, 'two':2}
>>> 'one' not in d
False
>>> 'three' not in d
True
  • iter(d)
    返回一个包含字典d的所有key的迭代器（iterator）
>>> d = {'one':1, 'two':2}
>>> for k in iter(d):
...     print(k)
...
one
two
  • clear()
    清空字典
>>> d = {'one':1, 'two':2}
>>> d.clear()
>>> d
{}
  • copy()
    返回字典的浅拷贝
>>> d1 = {'one':1, 'two':2}
>>> d2 = d1.copy()
>>> d2
{'one': 1, 'two': 2}
  • classmethod fromkeys(seq[, value])
    返回一个新的字典，字典的keys来自参数seq，并且所有key的value为参数value，value参数默认值为None。
>>> dict.fromkeys(['three','four'])
{'three': None, 'four': None}
>>> dict.fromkeys(['three','four'],0)
{'three': 0, 'four': 0}
  • get(key[, default])
    返回key对应的value，如果key不存在则返回default，default默认为None
>>> d = {'one':1, 'two':2}
>>> d.get('one')
1
>>> d.get('three',0)
0
  • items()
    返回一个包含所有项的字典视图（view），每一项是2个元素的tuple。分别为key和value
>>> d = {'one':1, 'two':2}
>>> for k,v in d.items():
...     print('%s = %s' % (k,v))
...
one = 1
two = 2
  • keys()
    返回一个包含所有key的字典视图
>>> d = {'one':1, 'two':2}
>>> for k in d.values():
...     print(k)
...
one
two
  • values()
    返回一个包含所有value的字典视图
>>> d = {'one':1, 'two':2}
>>> for v in d.values():
...     print(v)
...
1
2
  • setdefault(key[, default])
    如果key存在于字典中，则返回其对应的value，否则插入key，并且将其value设置为default，default默认为None
>>> d = {'one':1, 'two':2}
>>> d.setdefault('two')
2
>>> d.setdefault('three',3)
3
>>> d
{'one': 1, 'two': 2, 'three': 3}
  • update([other])
    更新字典中的项，可接受参数类型与dict关键字一样
>>> d = {'one':1, 'two':2}
>>> d.update({'two':2.0,'three':3}) # mapping形式
>>> d
{'one': 1, 'two': 2.0, 'three': 3}
>>> d.update([('three',3.0),('four',4)]) # iterable形式
>>> d
{'one': 1, 'two': 2.0, 'three': 3.0, 'four': 4}
>>> d.update(five=5,six=6) # **kwargs形式
>>> d
{'one': 1, 'two': 2.0, 'three': 3.0, 'four': 4, 'five': 5, 'six': 6}
>>> d.update({'six':6.0},seven=7) # mapping + **kwargs形式
>>> d
{'one': 1, 'two': 2.0, 'three': 3.0, 'four': 4, 'five': 5, 'six': 6.0, 'seven': 7}
>>> d.update([('one',1.0),('four',4.0)],five=5.0,seven=7.0) # iterable + **kwargs形式
>>> d
{'one': 1.0, 'two': 2.0, 'three': 3.0, 'four': 4.0, 'five': 5.0, 'six': 6.0, 'seven': 7.0}

1.3字典视图
上面提到的d.keys()、d.values()和d.items()等方法返回的都是一个视图类型（view object），通过这些视图可以访问字典d的keys、values或items，并且视图会随着字典的变化而自动更新。

>>> d = {'one':1, 'two':2}
>>> keys = d.keys()
>>> values = d.values()
>>> items = d.items()
>>> keys
dict_keys(['one', 'two'])
>>> values
dict_values([1, 2])
>>> items
dict_items([('one', 1), ('two', 2)])

# 视图随着字典变化而动态更新
>>> d.update(three=3)
>>> keys
dict_keys(['one', 'two', 'three'])
>>> values
dict_values([1, 2, 3])
>>> items
dict_items([('one', 1), ('two', 2), ('three', 3)])
>>>
>>> for k in keys:
...     print(k)
...
one
two
three

1.4字典比较
字典只支持==比较操作符，仅当所有项都相等时才相等，对于<、>、<=、>=比较操作符都不支持，如果使用会抛TypeError错误。

2.集合

集合（set）是一些无序、无重复并且可hash元素的组合。通常用于是否包含某个成员的检测、去除重复元素等操作。同时也支持数学上的集合运算，比如交集、并集、差集和对称差集。
Python内置2中类型集合，set和frozenset，set是可变类型，frozenset是不可变类型。

2.1集合创建
集合创建可以通过以下2种方式：

  • 大括号{}方式
>>> s = {'a','b','c','a'}
>>> s
{'a', 'b', 'c'} # 元素相等只能保留一个
  • set或frozenset关键字方式
    set和frozenset的定义如下：
class set([iterable])
class frozenset([iterable])

根据以上定义可以通过下面的方式创建集合：

>>> s = set(['a','b','c'])
>>> fs = frozenset(['a','b','c'])
>>> s
{'a', 'b', 'c'}
>>> fs
frozenset({'a', 'b', 'c'})
>>> s.add('d') # set是可变类型
>>> s
{'a', 'b', 'd', 'c'}
>>> fs.add('d') # frozenset是不可变类型
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add
  • 集合推导式
>>> {x for x in range(1,11)}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

集合中的元素必须是可以hash的：

# str、number和tuple类型都是可以hash的
>>> {'one',2,(3,4)}
{'one', 2, (3, 4)}

# list是不可hash（unhashable）类型
>>> {1,[2]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

# 间接包含unhashable也不行
>>> {1,(2,[3])}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

如果要创建空集合，必须使用set或frozenset关键字，不能使用大括号，因为{}创建的是一个空字典。

>>> s = set()
>>> s
set()
>>> fs = frozenset()
>>> fs
frozenset()
>>> d = {}
>>> d
{}
>>> type(d)
<class 'dict'>

2.2集合操作
以下是set和frozenset都支持的操作：

  • len(s)
    返回结合中元素的个数
>>> s = {1,2}
>>> len(s)
2
  • x in s
    判断x是否被包含于集合s中
>>> s = {1,2}
>>> 1 in s
True
>>> 3 in s
False
  • x not in s
    判断x是否不被包含于集合s中
>>> s = {1,2}
>>> 1 not in s
False
>>> 3 not in s
True
  • isdisjoint(other)
    判断当前集合是否与其它集合other没有交集
>>> s = {1,2}
>>> s.isdisjoint({3,4})
True
>>> s.isdisjoint({2,3})
False
  • issubset(other)
    set <= other
    判断当前集合是否为其它集合other的子集
    子集：指一个集合中的所有元素都属于另一个集合
>>> s = {1,2}
>>> other = {1,2,3}
>>> s.issubset(other)
True
>>> s <= other
True
>>> other = {1,4,3}
>>> s.issubset(other)
False
>>> s <= other
False
  • set < other
    判断当前集合是否为其它集合other的真子集
    真子集：指一个集合中的所有元素都属于另一个集合，但这两个集合并不完全相同
>>> {1,2} < {1,2,3}
True
>>> {1,2} < {1,2}
False
  • issuperset(other)
    set >= other
    判断当前集合是否为其它集合other的超集。
    如果一个集合S2中的每一个元素都在集合S1中，且集合S1中可能包含S2中没有的元素，则集合S1就是S2的一个超集，反过来，S2是S1的子集。
>>> s = {1,2,3}
>>> other = {1,2}
>>> s.issuperset(other)
True
>>> s >= other
True
  • set > other
    判断当前集合是否是其它集合other的真超集
    S1是S2的超集，若S1中一定有S2中没有的元素，则S1是S2的真超集，反过来S2是S1的真子集。
>>> {1,2,3} > {1,2}
True
>>> {1,2} > {1,2}
False
  • union(*others)
    set | other | …
    当前集合与其它一个或多个集合求并集
>>> s = {1,2}
>>> other = {2,3}
>>> s.union(other)
{1, 2, 3}
>>> s | other
{1, 2, 3}
  • intersection(*others)
    set & other & …
    当前集合与其它一个或多个集合求交集
>>> s = {1,2}
>>> other = {2,3}
>>> s.intersection(other)
{2}
>>> s & other
{2}
  • difference(*others)
    set - other - …
    当前集合与其它一个或多个集合求差集
>>> s = {1,2}
>>> other = {2,3}
>>> s.difference(other)
{1}
>>> s - other
{1}
  • symmetric_difference(other)
    set ^ other
    当前集合与其它集合other求对称差集
>>> s = {1,2}
>>> other = {2,3}
>>> s ^ other
{1, 3}
>>> s.symmetric_difference(other)
{1, 3}
  • copy()
    返回当前集合的一个浅拷贝
>>> s = {1,2}
>>> s.copy()
{1, 2}

需要注意的是以上的比较方法union()、intersection()、difference()、symmetric_difference()、issubset()和issuperser()，接受的参数除了集合类型外，还可以是可迭代类型（iterable）。相比之下，对应的比较运算符只能接受集合类型参数。

>>> {1,2}.union([3,4]) # union方法可以接受iterable类型
{1, 2, 3, 4}
>>> {1,2} | [3,4] # | 运算符不能接受iterable类型
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'set' and 'list'

以下是只有set支持的操作：

  • update(*others)
    set |= other |= …
    将当前集合与其它一个或多个集合求并集，然后更新到当前集合
>>> s = {1,2}
>>> other = {2,3}
>>> s.update(other)
>>> s
{1, 2, 3}
>>> s |= {3,4}
>>> s
{1, 2, 3, 4}
  • intersection_update(*other)
    set &= other &= …
    将当前集合与其它一个或多个集合求交集，然后更新到当前集合
>>> s = {1,2}
>>> other = {2,3}
>>> s.intersection_update(other)
>>> s
{2}
>>> s &= {3,4}
>>> s
set()
  • add(elem)
    添加一个元素elem到当前集合
>>> s = {1,2}
>>> s.add(3)
>>> s
{1, 2, 3}
  • remove(elem)
    从当前集合删除元素elem，如果elem不存在则抛KeyError异常
>>> s = {1,2}
>>> s.remove(2)
>>> s
{1}
>>> s.remove(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 2
  • discard(elem)
    从当前集合删除元素elem，如果elem不存在也不抛异常
>>> s = {1,2}
>>> s.discard(2)
>>> s
{1}
>>> s.discard(2)
>>> s
{1}
  • pop()
    从当前集合任意删除一个元素并返回，由于集合是无序的，所以删除哪个元素不确定，如果当前集合为空，则抛KeyError异常
>>> s = {1,2}
>>> s.pop()
1
>>> s.pop()
2
>>> s.pop()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'pop from an empty set'
  • clear()
    清空当前集合
>>> s = {1,2}
>>> s.clear()
>>> s
set()

同样的以上的update()、intersection_update()和symmetric_difference_update()也可以接受可迭代类型参数，但对应的运算符只能接受集合类型参数。

3.immutable和hashable

Python中不可变类型immutable都是hashable类型的，但是hashable类型并不一定都是immutable的，因为默认所有自定义类的实例都是hashable类型的，其hash值通常就是id()函数的计算结果，由于用户自定义类型不一定是不可变类型，所以hashable类型不一定都是immutable类型的。

dxiao2016
关注
  • 22
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python字典与集合
ZP_202109181008的博客
11-20 739
字典的创建和删除 定义字典时，每个元素都包含两个部分“键”和“值”，并且在“键”和“值” 之间使用冒号分隔,相邻两个元素使用逗号分隔，所有元素放在一个大括号“{}” 史。一一谚法格一武如其一 dictionary = {'keyl':'valueV,,key2,:,value2*J ,keyn,:*valuen\} 参数说明： 0 dictionary：表示字典名称； 0 keyl. key2...keyn：表示元素的键，必须是唯一的，并且不可变，例如可 以是字符串、数字或者元组； 0 valu.
Python字典与集合练习题
qq674185559的博客
03-08 1517
.统计需要取快递人员的名单：“双十一”过后，某公司每天都能收到很多快递，门卫小李想编写一个程序统计收到快递人员的名单，以便统一通知。要求：编写一段Python程序，统计出需要来取快递的人员名单。
python 字典与集合
qq_52109814的博客
12-02 891
字典 字典是python中的一种数据结构。 它的内容由**键-值(key-value)**的方式存在。 dict拥有良好的查询速度，dict中值可以是任意python对象，对此对一个key赋value，后面的value会把前面的value覆盖。 字典的相关操作 # 字典中的内容放在大括号{}里，键值之间用冒号分隔，键值队之间用逗号 # method 1 myd = {'name': 'lmy', 'age': '19'} l = [('name', 'lmy'), ('age', '19')] myd =
python 字典与集合详解
叁木大数据
12-02 1801
字典&集合一、基础二、性能 一、基础     字典：是一系列由健和值配对组成的元素的集合。在python3.7+版本中字典是有序的，在3.6之前是无序的     集合：和字典基本相同，唯一的区别在于集合没有键和值的配对，是一系列无序的、唯一的元素组合 基础方法（键和值都是混合类型） # 创建 # 字典创建 d1 = {'name':'liuyi','age':18,'gender':'male'} d2 = dict({'name':'liuyi','age':18,'gender':'male
Python 字典与集合
billy的博客
08-07 5382
作者：billy 版权声明：著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处 字典 字典的创建和删除 访问字典 遍历字典 添加、修改和删除字典 字典推导式 集合 创建集合 向集合中添加和删除元素 集合的交集、并集和差集运算 ...
Python: 字典与集合
小孙的博客
10-24 1993
1.1字典的使用 字典中每一个成员以“键：值”对的形式成对存在的。字典是以大括号“{}”包围并且以“键：值”对的方式声明和存在的数据集合。字典与列表比较最大的不同是字典是无序的，其成员的位置是象征性的，在字典中通过键来访问成员，而不能通过其他的方式来访问该成员。 1.1.1创建并使用字典 在Python程序中，字典可以储存任意类型的对象。字典的每一对键值对“key:value”之间必须用冒号“：”分隔，每一对之间用“，”分隔，整个字典在“{}”中。所有的 key 都是唯...
Python字典与集合的应用实例
半岛铁盒的博客
04-14 3572
字典的合并 班级学籍信息统计如下：女生籍贯分布是江苏3人，浙江2人，吉林1人；男生籍贯分布是江苏8人，浙江5人，山东5人，安徽4人，福建2人。编写程序将统计结果合并并输出。 male = {"江苏": 8, "浙江": 5, "山东": 5, "安徽": 4, "福建": 2} female = {"江苏": 3, "浙江": 2, "吉林": 1} dic = male.copy() //复制其中的一个空表 for k, v in female.items(): dic[k] = dic.get(
Python字典与集合的异同点
小白皮皮
10-16 8177
字典与集合的异同点 不同点 字典 集合 创建 {key:value} set([key]) 或 {} 主要用途 需要对元素进行标记的对象（不需要记住对应位置） 去重、计算交集，并集，差集，反交集等 是否可以索引 可以 不可以 是否有value 每个key对应一个value 无对应的value 相同点 均有key值，且key值不重复 不可放入可变的...
python字典与集合还有数据类型转换
码云仓库地址：https://gitee.com/lance-gyq
09-30 1278
返回的结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是元迭代对象对象的数据。当查找的key不存在则返回第二个参数（默认值），如果省略的第二个参数，则返回None。(可遍历对象，tart=0)——start参数用来设置遍历数据的下标的起始值，默认为0。里面的数据是元组，元组数据1是字典key，元组数据2是key对应的值。set()——转换成集合，集合没有顺序，不支持下标，有自动去重功能。len统计数据少的列表数据个数不会报错。修改字典数据——通过已有的键修改数据，不然就成了添加数据。
python的字典与集合
qq_46490950的博客
06-19 1504
1.集合 首先记住：集合是一个无序的不重复元素序列。 集合的元素必须时不可变数据类型！ 空集合不能使用{}, 而要使用set() 只显示一次出现过的数字！ 1,2,3,4,1,2,3，4，3，2 = 1,2,3,4 接下来创建一个集合！ s = {1, 2, 3, 1, 2, 3} print(s, type(s)) 结果如下： 若在集合里面加入可变元素就会报错！ 空集合不能使用{}，它会显示是个字典！ 而要使用set() 结果如下： 集合的特点 ...
python字典与集合.pdf
05-13
python字典与集合
python实验三、字典和集合 .doc
09-29
（1） 掌握字典的创建方法 （2） 掌握字典元素的访问方法 （3） 掌握字典的基本操作 （4） 掌握集合的创建方法 （5） 掌握集合的基本运算 二、实验题目 1．学生基本信息如下表，请编写程序分别统计男、女生的人数，...
Python3.9字典集合.pptx
05-03
Python3.9字典集合.pptx
Python 基础课程《7.字典与集合》
05-28
6.1 字典 6.1.1 字典的创建方法 6.1.2 通过“键值对”访问字典 6.1.3 通过 get()方法获取指定键的值 6.1.4 遍历字典 6.1.5 向字典中添加元素和修改元素 ...6.3 列表、元组、字符串、字典、集合的区别
力扣第214题“最短回文串”
10年数据\经营分析经验，现任大厂数据分析负责人
06-28 622
本文详细解读了力扣第214题“最短回文串”，通过使用 KMP 算法的方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
【Python】在 VS Code 里面绘制动图不显示动画的解决办法
Suasy小易的博客
06-25 422
VS Code 中使用 matplotlib 的动画功能，需要配置适当的绘图后端。
小红书商家电话采集软件使用指南
qq_34629423的博客
06-24 465
步骤一：安装Python和相关库 首先，确保你的电脑已经安装了Python运行环境（建议安装Python3版本）。步骤三：编写代码 在你喜欢的编辑器中创建一个新的Python文件，例如"shangjia_phone_crawler.py"。步骤二：获取商家列表页面URL 在小红书App中，进入你想要采集的商家列表页面，并复制该页面的URL地址。然后，按照提示输入商家列表页面的URL地址，回车确认。使用小红书商家电话采集软件可以提高商家电话的采集效率，以下是使用指南及附带代码。
Java的异常处理体系
最新发布
落日的博客
06-28 822
ControllerAdvice 注解用于定义全局控制器建议，在 Spring MVC 中，控制器建议由控制器中的 @ExceptionHandler 方法、@InitBinder 方法和 @ModelAttribute 方法组成。①、CheckedException （检查异常 必须在代码中显式处理 使用try catch捕获 或者 在方法上使用 throws 抛出 除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常 ）

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值