映射类型 --- 字典dict

最新推荐文章于 2023-11-14 22:35:46 发布

hd51cc

最新推荐文章于 2023-11-14 22:35:46 发布

阅读量648

点赞数

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/hd51cc/article/details/123977019

版权

Python 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

class dict(**kwargs)

class dict(mapping, **kwargs)

class dict(iterable, **kwargs)

字典可以通过将以逗号分隔的键:值对列表，包含于花括号之内来创建。

例如: {'jack':4098,'sjoerd':4127} 或 {4098:'jack',4127:'sjoerd'}，也可以通过 dict 构造器来创建。

字典中的键可以是任何不可变的类型，如整数、浮点、字符串、元组等。

即便是字典中没有键，也可以给它赋值，这将创建新项目。

字典可用多种方式来创建:

使用花括号内以逗号分隔键:值对的方式

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(type(dict1))
# output: <class 'dict'>

使用字典推导式

dict1 = {x: x ** 2 for x in range(5)}
print(dict1)
# output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
print(type(dict1))
# output: <class 'dict'>

使用类型构造器

dict1 = dict()
print(dict1)
# output: {}
print(type(dict1))
# output: <class 'dict'>

dict2 = dict([('name','python'), ('vision',310)])
print(dict2)
# output: {'name': 'python', 'vision': 310}
print(type(dict2))
# output: <class 'dict'>

dict3 = dict(name='python', vision=310)
print(dict3)
# output: {'name': 'python', 'vision': 310}
print(type(dict3))
# output: <class 'dict'>

方法

list(d)

返回字典 d 中使用的所有键的列表。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(list(dict1))
# output: ['name', 'vision']

len(d)

返回字典 d 中的项数。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(len(dict1))
# output: 2

d[key]

返回 d 中以 key 为键的项。如果映射中不存在 key 则会引发 KeyError。

如果字典的子类定义了方法 __missing__() 并且 key 不存在，则 d[key] 操作将调用该方法并附带键 key 作为参数。 d[key] 随后将返回或引发 __missing__(key) 调用所返回或引发的任何对象或异常。没有其他操作或方法会发起调用 __missing__()。如果未定义 __missing__()，则会引发 KeyError。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(dict1['name'])
# output: python

d[key] = value

将 d[key] 设为 value。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dict1['name']='C#'
print(dict1['name'])
# output: C#

del d[key]

将 d[key] 从 d 中移除。如果映射中不存在 key 则会引发 KeyError。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
del dict1['name']
print(dict1)
# output: {'vision': 310}

key in d

如果 d 中存在键 key 则返回 True，否则返回 False。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
for k in list(dict1):
    print(k)
# output: name
# output: vision

key not in d

等价于 not key in d。

iter(d)

返回以字典的键为元素的迭代器。这是 iter(d.keys()) 的快捷方式。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
for i in iter(dict1):
    print(i)
# output: name
# output: vision

clear()

移除字典中的所有元素。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(dict1.clear())
# output: None

copy()

返回原字典的浅拷贝。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dict2 = dict1.copy()
print(dict2)
# output: {'name': 'python', 'vision': 310}
dict1['name'] = 'c#'
print(dict1)
# output: {'name': 'c#', 'vision': 310}

classmethod fromkeys(iterable[, value])

使用来自 iterable 的键创建一个新字典，并将键值设为 value。fromkeys() 是一个返回新字典的类方法。

value 默认为 None。所有值都只引用一个单独的实例，因此让 value 成为一个可变对象例如空列表通常是没有意义的。

要获取不同的值，请改用字典推导式。

seq = ('Google', 'Runoob', 'Taobao')

dict1 = dict.fromkeys(seq)
print(dict1)
# output: {'Google': None, 'Runoob': None, 'Taobao': None}

dict2 = dict.fromkeys(seq, 10)
print(dict2)
# output: {'Google': 10, 'Runoob': 10, 'Taobao': 10}

get(key[, default])

如果 key 存在于字典中则返回 key 的值，否则返回 default。如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(dict1.get('name'))
# output: python
print(dict1.get('os', 'key in not exist'))
# output: key in not exist

items()

返回由字典项 ((键, 值) 对) 组成的一个新视图。参见视图对象文档。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(dict1.items())
# output: dict_items([('name', 'python'), ('vision', 310)])

keys()

返回由字典键组成的一个新视图。参见视图对象文档。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(dict1.keys())
# output: dict_keys(['name', 'vision'])

pop(key[, default])

如果 key 存在于字典中则将其移除并返回其值，否则返回 default。如果 default 未给出且 key 不存在于字典中，则会引发 KeyError。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(dict1.pop('name'))
# output: python
print(dict1)
# output: {'vision': 310}

popitem()

从字典中移除并返回一个 (键, 值) 对。键值对会按 LIFO 的顺序被返回。

popitem() 适用于对字典进行消耗性的迭代，这在集合算法中经常被使用。如果字典为空，调用 popitem() 将引发 KeyError。

在 3.7 版更改: 现在会确保采用 LIFO 顺序。在之前的版本中，popitem() 会返回一个任意的键/值对。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(dict1.popitem())
# output: ('vision', 310)
print(dict1)
# output: {'name': 'python'}

reversed(d)

返回一个逆序获取字典键的迭代器。这是 reversed(d.keys()) 的快捷方式。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
for i in reversed(dict1.keys()):
    print(i)
# output: vision
# output: name

setdefault(key[, default])

如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 None。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(dict1.setdefault('name', 'windows'))
# output: python
print(dict1.setdefault('os', 'windows'))
# output: windows

update([other])

使用来自 other 的键/值对更新字典，覆盖原有的键。返回 None。

update() 接受另一个字典对象，或者一个包含键/值对（以长度为二的元组或其他可迭代对象表示）的可迭代对象。如果给出了关键字参数，则会以其所指定的键/值对更新字典: d.update(red=1, blue=2)。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dict1.update(name='windows')
print(dict1)
# output: {'name': 'windows', 'vision': 310}
dict1.update(os='windows')
print(dict1)
# output: {'name': 'windows', 'vision': 310, 'os': 'windows'}

values()

返回由字典值组成的一个新视图。参见视图对象文档。

两个 dict.values() 视图之间的相等性比较将总是返回 False。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print(dict1.values())
# output: dict_values(['python', 310])
print(dict1.values() == dict1.values())
# output: False

d | other

合并 d 和 other 中的键和值来创建一个新的字典，两者必须都是字典。当 d 和 other 有相同键时， other 的值优先。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dict2 = {'OS': 'windows'}
print(dict2)
# output: {'OS': 'windows'}
print(dict1 | dict2)
# output: {'name': 'python', 'vision': 310, 'OS': 'windows'}

d |= other

用 other 的键和值更新字典 d ，other 可以是 mapping 或 iterable 的键值对。当 d 和 other 有相同键时， other 的值优先。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dict2 = {'OS': 'windows'}
print(dict2)
# output: {'OS': 'windows'}
dict1 |= dict2
print(dict1)
# output: {'name': 'python', 'vision': 310, 'OS': 'windows'}

两个字典的比较当且仅当它们具有相同的 (键, 值) 对时才会相等（不考虑顺序）。排序比较 ('<', '<=', '>=', '>') 会引发 TypeError。

字典会保留插入时的顺序。请注意对键的更新不会影响顺序。删除并再次添加的键将被插入到末尾。字典是可逆的。

字典视图对象

由 dict.keys(), dict.values() 和 dict.items() 所返回的对象是 视图对象。该对象提供字典条目的一个动态视图，这意味着当字典改变时，视图也会相应改变。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dictValues = dict1.values()
print(dictValues)
# output: dict_values(['python', 310])
dict1['name'] = 'C#'
print(dictValues)  # 动态改变
# output: dict_values(['C#', 310])

字典视图可以被迭代以产生与其对应的数据，并支持成员检测：

len(dictview)

返回字典中的条目数。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dictValues = dict1.values()
print(len(dictValues))
# output: 2

iter(dictview)

返回字典中的键、值或项（以 (键, 值) 为元素的元组表示）的迭代器。

键和值是按插入时的顺序进行迭代的。这样就允许使用 zip() 来创建 (值, 键) 对: pairs = zip(d.values(), d.keys())。另一个创建相同列表的方式是 pairs = [(v, k) for (k, v) in d.items()].

在添加或删除字典中的条目期间对视图进行迭代可能引发 RuntimeError 或者无法完全迭代所有条目。

在 3.7 版更改: 字典顺序会确保为插入顺序。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dictValues = dict1.values()
for item in iter(dictValues):
    print(item)
# output: python
# output: 310
dictItems = dict1.items()
for item in iter(dictItems):
    print(item)
# output: ('name', 'python')
# output: ('vision', 310)
dictKeys = dict1.keys()
for item in iter(dictKeys):
    print(item)
# output: name
# output: vision

x in dictview

如果 x 是对应字典中存在的键、值或项（在最后一种情况下 x 应为一个 (键, 值) 元组）则返回 True。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dictValues = dict1.values()
for item in dictValues:
    print(item)
# output: python
# output: 310

reversed(dictview)

返回一个逆序获取字典键、值或项的迭代器。视图将按与插入时相反的顺序进行迭代。

在 3.8 版更改: 字典视图现在是可逆的。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dictValues = reversed(dict1.values())   # 逆向
for item in iter(dictValues):
    print(item)
# output: 310
# output: python
dictItems = reversed(dict1.items())   # 逆向
for item in iter(dictItems):
    print(item)
# output: ('vision', 310)
# output: ('name', 'python')
dictKeys = reversed(dict1.keys())   # 逆向
for item in iter(dictKeys):
    print(item)
# output: vision
# output: name

dictview.mapping

返回 types.MappingProxyType 对象，封装了字典视图指向的原始字典。

3.10 新版功能.

键视图类似于集合，因为其条目不重复且可哈希。如果所有值都是可哈希的，即 (键, 值) 对也是不重复且可哈希的，那么条目视图也会类似于集合。（值视图则不被视为类似于集合，因其条目通常都是有重复的。）对于类似于集合的视图，为抽象基类 collections.abc.Set 所定义的全部操作都是有效的 (例如 ==, < 或 ^)。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
dictValues = dict1.values()
dictValuesMapping = dictValues.mapping
print(dictValuesMapping)
# output: {'name': 'python', 'vision': 310}

字符串格式与字典

使用format_map来指出你将通过一个映射来提供所需的信息。

dict1 = {'name': 'python', 'vision': 310}
print(dict1)
# output: {'name': 'python', 'vision': 310}
print('the name is {name}'.format_map(dict1))
# output: the name is python

hd51cc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
映射类型 --- 字典dict

classdict(**kwargs)classdict(mapping,**kwargs)classdict(iterable,**kwargs)字典可以通过将以逗号分隔的键:值对列表，包含于花括号之内来创建。例如:{'jack':4098,'sjoerd':4127}或{4098:'jack',4127:'sjoerd'}，也可以通过dict构造器来创建。字典中的键可以是任何不可变的类型，如整数、浮点、字符串、元组等。即便是字典中没有键，也可以给它赋值，这...
复制链接

扫一扫