Python基础练习与代码示例之dict

dict是我非常喜欢的一种数据类型,我甚至基于这种映射的概念发明了新的词组:KV编程论(后期有时间再说)。
dict在Python的代码中用途非常广泛,类似武术中的马步,好好练习,习以为常,能助你以后在代码编写过程中如鱼得水,风生水起。

废话少说,今天我们就来看看dict的基础练习与代码示例。

DE8UG的代码环境为:

  • Windows10
  • python3.7

概念

字典的基本创建格式:{键1: 值1,键2: 值2。。。},例如: {'jack': 4098, 'sjoerd': 4127} 或 {4098: 'jack', 4127: 'sjoerd'},大括号是必须的,里面的各种符号,逗号,引号,冒号等都是英文符号。

注意:键的内容不能重复。且可变类型的值不能作为键。因为键的位置是需要唯一的,需要用它去映射后面的值。
更专业的说法是键需要是可hashable的。对于hashable,在官方文档有解释:

hashable -- 可哈希
一个对象的哈希值如果在其生命周期内绝不改变,就被称为 可哈希 (它需要具有 hash() 方法),并可以同其他对象进行比较(它需要具有 eq() 方法)。可哈希对象必须具有相同的哈希值比较结果才会相同。
可哈希性使得对象能够作为字典键或集合成员使用,因为这些数据结构要在内部使用哈希值。
大多数 Python 中的不可变内置对象都是可哈希的;可变容器(例如列表或字典)都不可哈希;不可变容器(例如元组和 frozenset)仅当它们的元素均为可哈希时才是可哈希的。 用户定义类的实例对象默认是可哈希的。 它们在比较时一定不相同(除非是与自己比较),它们的哈希值的生成是基于它们的 id()。

除了使用{}创建字典,还可以用字典的类dict来生成新的字典对象。

dict类的构造形式有:

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

于是,我们用{"one": 1, "two": 2, "three": 3}举例,还可以有以下几种格式建立新的字典

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True    # 这里直接用==判断前面几个字典变量是相同的

函数

下面我们先定义一个字典d,然后介绍字典的相关操作和代码示例。

d = dict([('two', 2), ('one', 1), ('three', 3)])

操作 含义
list(d) 返回字典 d 中使用的所有键的列表。
len(d) 返回字典 d 中的项数
d[key] 返回 d 中以 key 为键的项。 如果映射中不存在 key 则会引发 KeyError。
d[key] = value 将 d[key] 设为 value。
del d[key] 将 d[key] 从 d 中移除。 如果映射中不存在 key 则会引发 KeyError。
key in d 如果 d 中存在键 key 则返回 True,否则返回 False。
key not in d 等价于 not key in d。
iter(d) 返回以字典的键为元素的迭代器。 这是 iter(d.keys()) 的快捷方式。
clear() 移除字典中的所有元素。
copy() 返回原字典的浅拷贝。
get(key[, default]) 如果 key 存在于字典中则返回 key 的值,否则返回 default。 如果 default 未给出则默认为 None,因而此方法绝不会引发 KeyError。
items() 返回由字典项 ((键, 值) 对) 组成的一个新视图。 参见 视图对象文档。
keys() 返回由字典键组成的一个新视图。 参见 视图对象文档。
pop(key[, default]) 如果 key 存在于字典中则将其移除并返回其值,否则返回 default。 如果 default 未给出且 key 不存在于字典中,则会引发 KeyError。
popitem() 从字典中移除并返回一个 (键, 值) 对。 键值对会按 LIFO 的顺序被返回。在 3.7 版更改: 现在会确保采用 LIFO 顺序。 在之前的版本中,popitem() 会返回一个任意的键/值对。
reversed(d) 返回一个逆序获取字典键的迭代器。 这是 reversed(d.keys()) 的快捷方式。注意,这个在python3.8才支持
setdefault(key[, default]) 如果字典存在键 key ,返回它的值。如果不存在,插入值为 default 的键 key ,并返回 default 。 default 默认为 None。
update([other]) 使用来自 other 的键/值对更新字典,覆盖原有的键。 返回 None。update() 接受另一个字典对象,或者一个包含键/值对(以长度为二的元组或其他可迭代对象表示)的可迭代对象。 如果给出了关键字参数,则会以其所指定的键/值对更新字典: d.update(red=1, blue=2)。
values() 返回由字典值组成的一个新视图,在 3.7 版更改: 字典顺序会确保为插入顺序

代码示例:

这里主要是两种调用方式:

  • d作为参数。比如func(d),表示python内置函数把字典作为参数。
  • d作为对象,调用字典自己的方法。比如d.func(...)
In [1]: d = dict([('two', 2), ('one', 1), ('three', 3)])

In [2]: list(d)
Out[2]: ['two', 'one', 'three']

In [3]: len(d)
Out[3]: 3

In [4]: d['two']
Out[4]: 2

In [5]: d['two']=222

In [6]: d['two']
Out[6]: 222

In [7]: del d['two']

In [8]: d
Out[8]: {'one': 1, 'three': 3}

In [9]: 'two' in d
Out[9]: False

In [10]: 'one' in d
Out[10]: True

In [11]: iter(d)
Out[11]: 

In [12]: dd=d.copy()

In [13]: dd
Out[13]: {'one': 1, 'three': 3}

In [14]: d.get('one')
Out[14]: 1

In [15]: d.keys()
Out[15]: dict_keys(['one', 'three'])

In [16]: d.items()
Out[16]: dict_items([('one', 1), ('three', 3)])

In [17]: d.pop()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in 
----> 1 d.pop()

TypeError: pop expected at least 1 arguments, got 0

In [18]: d.pop('one')
Out[18]: 1

In [19]: d
Out[19]: {'three': 3}

In [20]: d['name']='de8ug'

In [21]: d['city']='beijing'

In [22]: d
Out[22]: {'three': 3, 'name': 'de8ug', 'city': 'beijing'}

In [23]: d.popitem()
Out[23]: ('city', 'beijing')

In [24]: d
Out[24]: {'three': 3, 'name': 'de8ug'}

In [25]: reversed(d)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in 
----> 1 reversed(d)

TypeError: 'dict' object is not reversible

注意,这里的reversed函数出错了,因为我当前环境是python3.7,这个新的功能是在python3.8才生效。具体在:https://docs.python.org/3.8/whatsnew/3.8.html

Guido在信中有介绍:
reversed() is supported for both dicts and dictviews since version 3.8 (14.10.2018).

这样就让字典变得有序,可以逆转了。参考代码:

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(reversed(d))
['four', 'three', 'two', 'one']
>>> list(reversed(d.values()))
[4, 3, 2, 1]
>>> list(reversed(d.items()))
[('four', 4), ('three', 3), ('two', 2), ('one', 1)]

你可以安装python3.8试一下。

ok,希望上面的代码你都自己练习一遍,这样在以后用到某个方法时候才能知道怎么回事儿。

有任何问题欢迎留言,wx搜索:python随身听,【在看】一下,下期见。

本篇文章由一文多发平台ArtiPub自动发布

你可能感兴趣的:(Python基础练习与代码示例之dict)