Python --字典

qq_25500415

已于 2023-09-11 11:30:44 修改

阅读量33

点赞数

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

于 2023-07-06 17:27:51 首次发布

本文链接：https://blog.csdn.net/qq_25500415/article/details/131578248

版权

python 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

1，什么是字典?

字典是一种映射数据类型， key值必须可哈希的，且key不能重复

是无序排列的，所以不能通过索引和切片访问其元素

2，字典操作

2-1，创建字典

2-1-1，字典操作符{}

通过字典操作符{}进行创建，即my_dict = {key1: value1, key2: value2, ...}

In [90]: my_dict = {'a':1, 'b': 2}

2-1-2，工厂方法dict()

2-1-2-1，入参为键值对

通过工厂方法dict(), 即my_dict = dict(((k1, v1), (k2, v2), ...))

# 其中键值对可以用()括起来, 也可用[]括起来
In [7]: my_dict = dict((('a', 1), ('b', 2)))
In [8]: my_dict
Out[8]: {'a': 1, 'b': 2}

In [16]: my_dict = dict((['a', 1], ['b', 2]))
In [17]: my_dict
Out[17]: {'a': 1, 'b': 2}

2-1-2-2，入参为关键字参数

通过工厂方法dict(k1=v1, k2=v2, ...)的方式进行创建

# 键值对为参数形式
In [3]: my_dict = dict(a=1, b=2)
In [4]: my_dict
Out[4]: {'a': 1, 'b': 2}

# 不传参数，生成一个空字典
In [82]: my_dict = dict()
In [83]: my_dict
Out[83]: {}

2-1-2-3，入参为字典

# 入参是个字典，则返回该字典的浅拷贝， 比dict.copy()方法慢
In [80]: my_dict1 = dict(my_dict)

In [81]: my_dict1
Out[81]: {'a': 1, 'b': 1}

2-1-3，通过fromkeys()

通过内建函数fromkeys()，即my_dict = {}.fromkeys((key1, key2, ...), value=xxx), 若没有指定value，则生成的字典所有值为None

# 因为fromkeys, 只能接受两个参数，所以键的序列需要括起来
In [25]: my_dict = {}.fromkeys(('a', 'b', 'c'), 1)
In [26]: my_dict
Out[26]: {'a': 1, 'b': 1, 'c': 1}

# 如果没有指定值， 则所有的值默认为None
In [27]: my_dict = {}.fromkeys(('a', 'b', 'c'))

In [28]: my_dict
Out[28]: {'a': None, 'b': None, 'c': None}

2-2，查询字典元素

2-2-1，单个查询

通过my_dict[键]，可单个查询字典元素

In [3]: my_dict['b']
Out[3]: 2

2-2-2，遍历字典

# for中的my_dict，可以遍历字典的键
In [35]: for k in my_dict:
    ...:     print(my_dict[k])

2-2-3，成员判断

通过in, not in运算符，可判断某个键是否在字典中，返回bool值

In [37]: 'a' in my_dict
Out[37]: True

In [38]: 'd' not in my_dict
Out[38]: True

2-3，修改字典

2-3-1，修改某个元素

通过my_dict[键]=值， 可修改字典的元素，若指定的键不存在，则表示添加该元素

# 修改字典元素的值
In [42]: my_dict['a'] = 2

In [43]: my_dict
Out[43]: {'a': 2, 'b': 1, 'c': 1}


# 因为键'd'在my_dict中不存在，此时表示添加新的元素
In [44]: my_dict['d'] = 1

In [45]: my_dict
Out[45]: {'a': 2, 'b': 1, 'c': 1, 'd': 1}

2-4，删除字典元素

2-4-1，删除字典元素(del)

通过del my_dict[键]，删除字典指定元素，无返回值

# 删除my_dict键为'a'的元素， 无返回值
In [50]: del my_dict['a']

2-4-2，删除字典元素(pop)

通过my_dict.pop[键]，删除字典指定元素，返回对应的值

# 删除my_dict中键为'b'的元素，返回对应的值
In [52]: my_dict.pop('b')
Out[52]: 1

2-5，字典参数简化print语句

通过%(键)s的方式，进行简化

# print中输出两个参数，使用这种方式，入参只写上字典就可以了
In [48]: print('a: %(a)s , c:%(c)s' % my_dict)
a: 2 , c:1

3，字典比较算法

1，先比较字典长度， 长的位大

2，长度不相等则逐个比较字典key， key的比较顺序为key()方法放回的键顺序，key大的为大

3，若1， 2均相等，则逐个比较字典value， value大的为大

4，若1， 2， 3都相等，则字典相等

In [73]: d1 = {}
In [74]: d2 = {'host': 'earth', 'port': 80}

# 比较字典是否相等，返回bool值
In [75]: d1 == d2
Out[75]: False

4，相关函数和内建方法

4-1，相关函数

通过len(my_dict)，返回字典的长度

# 表示字典d1的长度为3
In [91]: len(d1)
Out[91]: 3

通过hash(key)， 计算入参是否可哈希，可哈希返回一个整数，不可hash则报错

# 入参'a'， 可hash, 返回一个整数
In [93]: hash('a')
Out[93]: -2758487174922364598

# 不可hash，会抛错
In [94]: hash([])
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-94-4c7351eba020> in <module>
----> 1 hash([])

TypeError: unhashable type: 'list'

4-2，内建方法

通过my_dict.get(key，默认值)， 获取键对应的值， 若指定键不存在，则返回默认值

# 获取键为a的值
In [97]: my_dict.get('a', 'opps')
Out[97]: 1

# 因为这里的键'd'， 不在字典中，所有返回默认值'opps'
In [98]: my_dict.get('d', 'opps')
Out[98]: 'opps'

# 若获取的键不存在，也没有给定默认值，则返回None
In [100]: my_dict.get('d')

通过my_dict.items()， 返回一个由(key, value)组成的dict_iterm对象

# 返回my_dict字典的dict_items对象
In [102]: my_dict.items()
Out[102]: dict_items([('a', 1), ('b', 1), ('c', 1)])

# 通过内建函数list, 可将其转换为列表
In [103]: list(my_dict.items())
Out[103]: [('a', 1), ('b', 1), ('c', 1)]

通过my_dict.keys()， 返回字典键组成的dict_keys对象

# 返回my_dict的dict_keys对象
In [104]: my_dict.keys()
Out[104]: dict_keys(['a', 'b', 'c'])

# 通过内建方法list：将dict_keys对象转换为列表
In [107]: list(my_dict.keys())
Out[107]: ['a', 'b', 'c']

通过my_dict.values()， 返回字典值组成的dict_keys对象

# 返回my_dict的dict_values对象
In [108]: my_dict.values()
Out[108]: dict_values([1, 1, 1])

# 通过内建方法list：将dict_values对象转换为列表
In [109]: list(my_dict.values())
Out[109]: [1, 1, 1]

通过my_dict.setdefault(key, value)， 设置my_dict中键为key的值为value，若key存在，则值不变，如果不存在，则在字典中新增该键值对；均返回key对应的value值

# 'a'在my_dict中存在，返回对应的值
In [117]: my_dict.setdefault('a', 'hehe')
Out[117]: 1

# 'e'在my_dict中不存在，则在my_dict中新增该键值对{'e': 'aaaa'}
In [119]: my_dict.setdefault('e', 'aaaa')
Out[119]: 'aaaa'

In [120]: my_dict
Out[120]: {'a': 1, 'c': 1, 'd': 'fads', 'e': 'aaaa'}

通过my_dict.update(dict1)， 将dict1的值添加到my_dict中，如果my_dict和dict1存在重复的键，则dict1的值覆盖my_dict中原来的值

In [121]: my_dict
Out[121]: {'a': 1, 'c': 1, 'd': 'fads', 'e': 'aaaa'}

In [122]: my_dict1 = {'a':2, 'b': 3}

In [123]: my_dict.update(my_dict1)

In [124]: my_dict
Out[124]: {'a': 2, 'c': 1, 'd': 'fads', 'e': 'aaaa', 'b': 3}