python 字典的操作方法

最新推荐文章于 2024-10-31 23:07:40 发布

原创最新推荐文章于 2024-10-31 23:07:40 发布 · 531 阅读

1 ·

CC 4.0 BY-SA版权

python 专栏收录该内容

74 篇文章

订阅专栏

本文介绍了Python字典的各种操作，包括删除、更改值、复制、查询、返回布尔值和新增值等。字典是Python中唯一的映射类型，其键必须是可哈希的，而值可以是任意对象。常用方法有`clear()`、`pop()`、`setdefault()`、`update()`、`copy()`、`fromkeys()`、`get()`等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述
There is currently only one standard mapping type, the dictionary.
目前为止在python中唯一一个映射类型是Dict 。所谓映射就是把这里面的内容强制的和另外的内容联系起来，指向另外的内容。其他类型都不是一一对应的关系。别的语言如C语言也没有这种映射的关系，c语言的指针的作用类似与python的字典，也是把一个内容指向另外一个内容。
A mapping object maps hashable values to arbitrary objects.
映射一个哈希值到任意对象。所以key是可哈希的，不可变数据类型。values是任意对象，字典的键是用哈希的方法创建的随机值，每次哈希值都不一样。
list，set，tuple，dict在python中属于容器类型。
以下三种方法可创建字典：

dict(**kwarg) 直接传键值对可以返回一个字典，如果是传的参数是空的话，返回一个空字典例：

>>>
print(dict(one=1, two=2, three=3))  # 传的实参不能用引号，类似于变量名标准
>>>
{'one': 1, 'two': 2, 'three': 3}

dict(mapping, **kwarg)
例

print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))
print((zip(['one', 'two', 'three'], [1, 2, 3])))   #  通过zip把两个列表一一映射成一个由二元元组组mapping对象，

运行结果

{'one': 1, 'two': 2, 'three': 3}
zip object at 0x000001D5CA27CEC8

dict(iterable, **kwarg)

print(dict([('two', 2), ('one', 1), ('three', 3)]))  # 如果不传关键字参数的话，也可以传一个可迭代对象。

运行结果

{'two': 2, 'one': 1, 'three': 3}

dict类定义的方法

删

def clear(self): # real signature unknown; restored from doc

    """ D.clear() -> None.  Remove all items from D. """
    pass

def pop(self, k, d=None): # real signature unknown; restored from doc

    """
    D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
    If key is not found, d is returned if given, otherwise KeyError is raised
    """
    pass

def delitem(self, *args, **kwargs): # real signature unknown

    """ Delete self[key]. """
    pass

def popitem(self): # real signature unknown; restored from doc

    """
    D.popitem() -> (k, v), remove and return some (key, value) pair as a
    2-tuple; but raise KeyError if D is empty.
    """
    pass

更改值

def setdefault(self, k, d=None): # real signature unknown; restored from doc

    """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
    pass

def update(self, E=None, **F): # known special case of dict.update

    """
    D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
    If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
    If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
    In either case, this is followed by: for k in F:  D[k] = F[k]
    """
    pass

例：

c1 = {'a': 1, 'b': 2, 'c': 3}

c2 = {'a': 11, 'b': 22, 'e': 5}

c1.update(c2) 

print(c1)   # {'a': 11, 'b': 22, 'c': 3, 'e': 5}

复制

def copy(self): # real signature unknown; restored from doc

    """ D.copy() -> a shallow copy of D """
    pass

@staticmethod # known case

def fromkeys(*args, **kwargs): # real signature unknown

    """ Returns a new dict with keys from iterable and values equal to value. """
    pass

查询

def get(self, k, d=None): # real signature unknown; restored from doc

    """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
    pass

def items(self): # real signature unknown; restored from doc

    """ D.items() -> a set-like object providing a view on D's items """
    pass

def keys(self): # real signature unknown; restored from doc

    """ D.keys() -> a set-like object providing a view on D's keys """
    pass

def values(self): # real signature unknown; restored from doc

    """ D.values() -> an object providing a view on D's values """
    pass

def getitem(self, y): # real signature unknown; restored from doc

    """ x.__getitem__(y) <==> x[y] """
    pass

返回布尔值

def contains(self, *args, **kwargs): # real signature unknown

    """ True if D has a key k, else False. """
    pass

def eq(self, *args, **kwargs): # real signature unknown

    """ Return self==value. """
    pass

def ge(self, *args, **kwargs): # real signature unknown

    """ Return self>=value. """
    pass

def gt(self, *args, **kwargs): # real signature unknown

    """ Return self>value. """
    pass

def le(self, *args, **kwargs): # real signature unknown

    """ Return self<=value. """
    pass

def lt(self, *args, **kwargs): # real signature unknown

    """ Return self<value. """
    pass

def ne(self, *args, **kwargs): # real signature unknown

    """ Return self!=value. """
    pass

返回可迭代对象

def iter(self, *args, **kwargs): # real signature unknown

    """ Implement iter(self). """
    pass

返回数字

def len(self, *args, **kwargs): # real signature unknown

    """ Return len(self). """
    pass

新增值

def setitem(self, *args, **kwargs): # real signature unknown

    """ Set self[key] to value. """
    pass

查看在内存中占多少个字节

def sizeof(self): # real signature unknown; restored from doc

    """ D.__sizeof__() -> size of D in memory, in bytes """
    pass

这里写图片描述

字典的操作方法

len(d)
d[key] = value 设置一个新的值
key in d
Return True or False
key 是否在键中
key not in d
iter(d) 返回由key组成的迭代器
例

a = {'jack': 4938, 'sj': 8546}
print(iter(a))
print(next(iter(a)))

运行结果

<dict_keyiterator object at 0x000001A22BAFC908>
jack

del d[key]
clear()
copy()

a = {'jack': 4938, 'snaj': {'andy': 5764}, 'sj': 8546}
b = a.copy()   # 浅复制，和list的浅复制原理是一样的，复制的是内层的地址，其他的是俩个地址
print(b)        
b['snaj']['andy'] = 0
print(a)
print(b)
c = dict.fromkeys(a, 0)  # 初始化字典，重新给字典赋新值。
print(c)
c['jack'] = 4
print(c)

运行结果

{'jack': 4938, 'snaj': {'andy': 5764}, 'sj': 8546}
{'jack': 4938, 'snaj': {'andy': 0}, 'sj': 8546}
{'jack': 4938, 'snaj': {'andy': 0}, 'sj': 8546}
{'jack': 0, 'snaj': 0, 'sj': 0}
{'jack': 4, 'snaj': 0, 'sj': 0}

get(key[,default]) 返回健的值，如果不存在可以返回指定值，默认为None

a = {'jack': 4938, 'snaj': {'andy': 5764}, 'sj': 8546}
print(a.get('s'))
print(a.get('jack'))
print(a.get('j','not exist'))

运行结果

None
4938
not exist

items() 返回键值元组视图，
keys()
pop(key) 如果不设置返回值的话，会报错
popitem() 3.6后默认删除最后一个
setdefault(key[,default])
update([other])
values()
get
pop