当前位置:天才代写 > tutorial > Python教程 > 深入探究Python中的字典容器

深入探究Python中的字典容器

2017-11-01 08:00 星期三 所属: Python教程 浏览:94

字典(dictionary)

我们都曾经利用过语言辞书来查找不认识的单词的界说。语言辞书针对给定的单词(好比 python)提供一组尺度的信息。这种系统将界说和其他信息与实际的单词关联(映射)起来。利用单词作为键定位器来寻找感乐趣的信息。这种观念延伸到 Python 编程语言中,就成了非凡的容器范例,称为 字典(dictionary)。

字典(dictionary) 数据范例在很多语言中都存在。它有时候称为关联 数组(因为数据与一个键值相关联),可能作为散列表。可是在 Python 中,字典(dictionary) 是一个很好的工具,因此纵然是编程新手也很容易在本身的措施中利用它。凭据正式的说法,Python 中的 字典(dictionary) 是一种异构的、易变的映射容器数据范例。

建设字典

本系列中前面的文章先容了 Python 编程语言中的一些容器数据范例,包罗 tuple、string 和 list(拜见 参考资料)。这些容器的相似之处是它们都是基于序列的。这意味着要按照元素在序列中的位置会见这些荟萃中的元素。所以,给定一个名为 a 的序列,就可以利用数字索引(好比 a[0] )或片断(好比 a[1:5])来会见元素。Python 中的 字典(dictionary) 容器范例与这三种容器范例的差异之处在于,它是一个无序的荟萃。不是凭据索引号,而是利用键值来会见荟萃中的元素。这意味着结构字典(dictionary)容器比 tuple、string 或 list 要巨大一些,因为必需同时提供键和相应的值,如清单 1 所示。

清单 1. 在 Python 中建设字典,第 1 部门

>>> d = {0: 'zero', 1: 'one', 2 : 'two', 3 : 'three', 4 : 'four', 5: 'five'}
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
>>> len(d)
>>> type(d)     # Base object is the dict class
<type 'dict'>
>>> d = {}      # Create an empty dictionary
>>> len(d)
>>> d = {1 : 'one'} # Create a single item dictionary
>>> d
{1: 'one'}
>>> len(d)
>>> d = {'one' : 1} # The key value can be non-numeric
>>> d
{'one': 1}
>>> d = {'one': [0, 1,2 , 3, 4, 5, 6, 7, 8, 9]}
>>> d
{'one': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}

如这个例子所示,在 Python 中建设字典(dictionary)要利用花括号和以冒号脱离的键-值组合。假如没有提供键-值组合,那么就会建设一个空的 dictionary。利用一个键-值组合,就会建设具有一个元素的 dictionary,以此类推,直至您需要的任何局限。与任何容器范例一样,可以利用内置的 len 要领查明荟萃中元素的数量。

前面的示例还演示了关于字典(dictionary)容器的另一个重要问题。键并不限制为整数;它可以是任何不易变的数据范例,包罗 integer、float、tuple 或 string。因为 list 是易变的,所以它不能作为字典(dictionary)中的键。可是字典(dictionary)中的值可以是任何数据范例的。

最后,这个示例说明白 Python 中字典(dictionary)的底层数据范例是 dict 工具。要进一步相识如何利用 Python 中的 字典(dictionary),可以利用内置的辅佐表明器来相识 dict 类,如清单 2 所示。

清单 2. 得到关于字典(dictionary)的辅佐

>>> help(dict)on class dict in module __builtin__:
   dict(object)
| dict() -> new empty dictionary.
| dict(mapping) -> new dictionary initialized from a mapping object's
|   (key, value) pairs.
| dict(seq) -> new dictionary initialized as if via:
|   d = {}
|   for k, v in seq:
|     d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
|   in the keyword argument list. For example: dict(one=1, two=2)
| 
| Methods defined here:
| 
| __cmp__(...)
|   x.__cmp__(y) <==> cmp(x,y)
| 
| __contains__(...)
|   x.__contains__(y) <==> y in x
| 
| __delitem__(...)
|   x.__delitem__(y) <==> del x[y]
...

#p#分页标题#e#

关于 dict 类的辅佐指出,可以利用结构函数直接建设字典(dictionary),而不利用花括号。既然与其他容器数据范例对比,在建设字典(dictionary)时必需提供更多的数据,那么这些建设要领较量巨大也就不敷为奇了。可是,在实践中利用字典(dictionary)并不难,如清单 3 所示。

清单 3. 在 Python 中建设字典(dictionary),第 2 部门

>>> l = [0, 1,2 , 3, 4, 5, 6, 7, 8, 9] 
>>> d = dict(l)(most recent call last):
 File "<stdin>", line 1, in ?: can't convert dictionary 
 update sequence element #0 to a sequence
  
>>> l = [(0, 'zero'), (1, 'one'), (2, 'two'), (3, 'three')]
>>> d = dict(l)
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> l = [[0, 'zero'], [1, 'one'], [2, 'two'], [3, 'three']]
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d = dict(l)
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d = dict(zero=0, one=1, two=2, three=3) 
>>> d
{'zero': 0, 'three': 3, 'two': 2, 'one': 1}
>>> d = dict(0=zero, 1=one, 2=two, 3=three): keyword can't be an expression

可以看到,建设字典(dictionary)需要键值和数据值。第一次从 list 建设字典(dictionary)的实验失败了,这是因为没有匹配的键-数据值对。第二个和第三个示例演示了如何正确地建设 字典(dictionary):在第一种环境下,利用一个 list,个中的每个元素都是一个 tuple;在第二种环境下,也利用一个 list,可是个中的每个元素是另一个 list。在这两种环境下,内层容器都用于得到键到数据值的映射。

直接建设 dict 容器的另一个要领是直接提供键到数据值的映射。这种技能答允显式地界说键和与其对应的值。这个要领其实用处不大,因为可以利用花括号完成沟通的任务。别的,如前面的例子所示,在回收这种方法时对付键不能利用数字,不然会导致抛出一个异常。

会见和修改字典(dictionary)

建设了 dictionary 之后,需要会见个中包括的数据。会见方法与会见任何 Python 容器数据范例中的数据相似,如清单 4 所示。

清单 4. 会见 dictionary 中的元素

>>> d = dict(zero=0, one=1, two=2, three=3)
>>> d
{'zero': 0, 'three': 3, 'two': 2, 'one': 1}
>>> d['zero']
>>> d['three']
>>> d = {0: 'zero', 1: 'one', 2 : 'two', 3 : 'three', 4 : 'four', 5: 'five'}
>>> d[0]
'zero'
>>> d[4]
'four'
>>> d[6](most recent call last):
 File "<stdin>", line 1, in ?: 6
>>> d[:-1](most recent call last):
 File "<stdin>", line 1, in ?: unhashable type

可以看到,从字典(dictionary)中获取数据值的进程险些与从任何容器范例中获取数据完全一样。在容器名后头的方括号中放上键值。虽然,字典(dictionary)可以具有非数字的键值,假如您以前没有利用过这种数据范例,那么适应这一点需要些时间。因为在字典(dictionary)中序次是不重要的(dictionary 中数据的序次是任意的),所以可以对其他容器数据范例利用的片断成果,对付 字典(dictionary)是不行用的。试图利用片断可能试图从不存在的键会见数据就会抛出异常,指出相关的错误。

#p#分页标题#e#

Python 中的字典(dictionary)容器也是易变的数据范例,这意味着在建设它之后可以修改它。如清单 5 所示,可以添加新的键到数据值的映射,可以修改现有的映射,还可以删除映射。

清单 5. 修改字典(dictionary)

>>> d = {0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d[0]
'zero'
>>> d[0] = 'Zero'
>>> d
{0: 'Zero', 1: 'one', 2: 'two', 3: 'three'}
>>> d[4] = 'four'
>>> d[5] = 'five'
>>> d
{0: 'Zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
>>> del d[0]
>>> d
{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
>>> d[0] = 'zero'
>>> d
{0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}

清单 5 演示了几个重点。首先,修改数据值是很简朴的:将新的值分派给适当的键。其次,添加新的键到数据值的映射也很简朴:将相关数据分派给新的键值。Python 自动举办所有处理惩罚。不需要挪用 append 这样的非凡要领。对付 dictionary 容器,序次是不重要的,所以这应该好领略,因为不是在字典(dictionary)后头附加映射,而是将它添加到容器中。最后,删除映射的步伐是利用 del 操纵符以及应该从容器中删除的键。

在清单 5 中有一个环境看起来有点儿怪,键值是凭据数字序次显示的,并且这个序次与插入映射的序次沟通。不要误解 —— 环境不老是这样的。Python 字典(dictionary)中映射的序次是任意的,对付差异的 Python 安装大概会有变革,甚至多次利用同一 Python 表明器运行沟通代码也会有变革。假如在一个字典(dictionary)中利用差异范例的键和数据值,那么就很容易看出这一点,如清单 6 所示。

清单 6. 异构的容器

>>> d = {0: 'zero', 'one': 1}   
>>> d
{0: 'zero', 'one': 1}
>>> d[0]
'zero'
>>> type(d[0])
<type 'str'>
>>> d['one']
>>> type(d['one'])
<type 'int'>
>>> d['two'] = [0, 1, 2] 
>>> d
{0: 'zero', 'two': [0, 1, 2], 'one': 1}
>>> d[3] = (0, 1, 2, 3)
>>> d
{0: 'zero', 3: (0, 1, 2, 3), 'two': [0, 1, 2], 'one': 1}
>>> d[3] = 'a tuple'
>>> d
{0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}

如这个例子所示,可以在一个字典(dictionary)中利用差异数据范例的键和数据值。还可以通过修改字典(dictionary)添加新的范例。最后,发生的 dictionary 的序次并不与插入数据的序次匹配。本质上,字典(dictionary)中元素的序次是由 Python 字典(dictionary)数据范例的实际实现节制的。新的 Python 表明器很容易改变这一序次,所以必然不要依赖于元素在字典(dictionary)中的特定序次。

用字典(dictionary)举办编程

作为正式的 Python 数据范例,字典(dictionary)支持其他较简朴数据范例所支持的大大都操纵。这些操纵包罗一般的干系操纵符,好比 <、> 和 ==,如清单 7 所示。

清单 7. 一般干系操纵符

>>> d1 = {0: 'zero'}
>>> d2 = {'zero':0}
>>> d1 < d2
>>> d2 = d1
>>> d1 < d2
>>> d1 == d2
>>> id(d1)
>>> id(d2)
>>> d2 = d1.copy()
>>> d1 == d2
>>> id(d1)
>>> id(d2)

前面的示例建设两个字典(dictionary)并利用它们测试 < 干系操纵符。尽量很少以这种方法较量两个字典(dictionary);可是假如需要,可以这样做。

#p#分页标题#e#

然后,这个示例将赋值给变量 d1 的字典(dictionary)赋值给另一个变量 d2。留意,内置的 id() 要领对付 d1 和 d2 返回沟通的标识符值,这说明这不是复制操纵。要想复制字典(dictionary) ,可以利用 copy() 要领。从这个示例中的最后几行可以看出,副本与本来的字典(dictionary)完全沟通,可是容纳这字典(dictionary)的变量具有差异的标识符。

在 Python 措施中利用字典(dictionary)时,很大概但愿查抄字典(dictionary)中是否包括特定的键或值。如清单 8 所示,这些查抄很容易执行。

清单 8. 条件测试和字典(dictionary)

>>> d = {0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
>>> d.keys()
[0, 3, 'two', 'one']
>>> if 0 in d.keys():
...   print 'True'
... 
>>> if 'one' in d:
...   print 'True'
... 
>>> if 'four' in d:
...   print 'Dictionary contains four'
... elif 'two' in d:
...   print 'Dictionary contains two'
... contains two

测试字典(dictionary)中键或数据值的成员干系是很简朴的。dictionary 容器数据范例提供几个内置要领,包罗 keys() 要领和 values() 要领(这里没有演示)。这些要领返回一个列表,个中别离包括举办挪用的字典(dictionary)中的键或数据值。

因此,要判定某个值是否是字典(dictionary)中的键,应该利用 in 操纵符查抄这个值是否在挪用 keys() 要领所返回的键值列表中。可以利用相似的操纵查抄某个值是否在挪用 values() 要领所返回的数据值列表中。可是,可以利用字典(dictionary)名作为简写暗示法。这是有意义的,因为一般但愿知道某个数据值(而不是键值)是否在字典(dictionary)中。

在 “Discover Python, Part 6” 中,您看到了利用 for 轮回遍历容器中的元素是何等容易。同样的技能也合用于 Python 字典(dictionary),如清单 9 所示。

清单 9. 迭代和字典(dictionary)

>>> d = {0: 'zero', 3: 'a tuple', 'two': [0, 1, 2], 'one': 1}
>>> for k in d.iterkeys():
...   print d[k]
... tuple
[0, 1, 2]
>>> for v in d.itervalues():
...   print v
... tuple
[0, 1, 2]
>>> for k, v in d.iteritems():
...   print 'd[',k,'] = ',v
... [ 0 ] = zero[ 3 ] = a tuple[ two ] = [0, 1, 2][ one ] = 1

这个示例演示了遍历字典(dictionary)的三种方法:利用从 iterkeys()、itervalues() 或 iteritems() 要领返回的 Python 迭代器。(顺便说一下,可以通过在字典(dictionary)上直接挪用适当要领,好比 d.iterkeys(),从而查抄这些要领是否返回一个迭代器而不是容器数据范例。)iterkeys() 要领答允遍历字典(dictionary)的键,而 itervalues() 要领答允遍历字典(dictionary)包括的数据值。另一方面,iteritems() 要领答允同时遍历键到数据值的映射。

字典(dictionary):另一种强大的 Python 容器

本文接头了 Python 字典(dictionary)数据范例。字典(dictionary)是一种异构的、易变的容器,依赖键到数据值的映射(而不是特定的数字序次)来会见容器中的元素。会见、添加和删除字典(dictionary)中的元素都很简朴,并且字典(dictionary)很容易用于复合语句,好比 if 语句或 for 轮回。可以在字典(dictionary)中存储所有差异范例的数据,可以凭据名称或其他复合键值(好比 tuple)会见这些数据,所以 Python 字典(dictionary)使开拓人员可以或许编写简捷而又强大的编程语句。

 

    关键字:


天才代写-代写联系方式