Une explication approfondie des conteneurs de dictionnaire en Python

Dictionnaire

Nous avons tous utilisé un dictionnaire de langue pour rechercher la définition d'un mot que nous ne connaissons pas. Un dictionnaire de langue fournit un ensemble standard d'informations pour un mot donné (comme python). Ce système associe (cartes) les définitions et autres informations aux mots réels. Utilisez des mots comme localisateurs clés pour trouver des informations intéressantes. Ce concept s'étend au langage de programmation Python et devient un type de conteneur spécial appelé dictionnaire.

Le type de données Dictionnaire existe dans de nombreuses langues. On l'appelle parfois tableau associatif (car les données sont associées à une valeur clé) ou table de hachage. Mais en Python, un dictionnaire est un objet intéressant, donc même un programmeur novice peut facilement l'utiliser dans ses propres programmes. Officiellement parlant, un dictionnaire en Python est un type de données de conteneur de cartographie hétérogène et mutable.

Création d'un dictionnaire

Les articles précédents de cette série ont présenté certains des types de données de conteneur dans le langage de programmation Python, notamment les tuples, les chaînes et les listes (voir Ressources). Ces conteneurs sont similaires dans le sens où ils sont basés sur des séquences. Cela signifie que les éléments de ces collections sont accessibles en fonction de leur position dans la séquence. Ainsi, étant donné une séquence nommée a , vous pouvez accéder aux éléments en utilisant soit des index numériques (tels que a[0] ) soit des fragments (tels que a[1:5] ). Le type de conteneur de dictionnaire en Python diffère de ces trois types de conteneurs en ce sens qu'il s'agit d'une collection non ordonnée. Au lieu d'utiliser des numéros d'index, vous utilisez des valeurs clés pour accéder aux éléments de la collection. Cela signifie que la construction d'un conteneur de dictionnaire est un peu plus complexe qu'un tuple, une chaîne ou une liste car les clés et les valeurs correspondantes doivent être fournies, comme le montre le listing 1.

Listing 1. Création d'un dictionnaire en Python, partie 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 &#39;dict&#39;>
>>> d = {}      # Create an empty dictionary
>>> len(d)
>>> d = {1 : &#39;one&#39;} # Create a single item dictionary
>>> d
{1: &#39;one&#39;}
>>> len(d)
>>> d = {&#39;one&#39; : 1} # The key value can be non-numeric
>>> d
{&#39;one&#39;: 1}
>>> d = {&#39;one&#39;: [0, 1,2 , 3, 4, 5, 6, 7, 8, 9]}
>>> d
{&#39;one&#39;: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}

Comme le montre cet exemple, la création d'un dictionnaire en Python utilise des accolades et une combinaison clé-valeur séparées par des deux-points. Si aucune combinaison clé-valeur n'est fournie, un dictionnaire vide est créé. L'utilisation d'une combinaison clé-valeur crée un dictionnaire avec un élément, et ainsi de suite, jusqu'à la taille dont vous avez besoin. Comme pour tout type de conteneur, vous pouvez connaître le nombre d’éléments de la collection à l’aide de la méthode len intégrée.

L'exemple précédent démontre également un autre problème important concernant les conteneurs de dictionnaires. La clé n'est pas limitée à un entier ; il peut s'agir de n'importe quel type de données immuable, notamment un entier, un flottant, un tuple ou une chaîne. La liste étant mutable, elle ne peut pas être utilisée comme clé dans un dictionnaire. Mais les valeurs d'un dictionnaire peuvent être de n'importe quel type de données.

Enfin, cet exemple illustre que le type de données sous-jacent d'un dictionnaire en Python est un objet dict. Pour en savoir plus sur l'utilisation des dictionnaires en Python, vous pouvez utiliser l'interpréteur d'aide intégré pour en savoir plus sur la classe dict, comme indiqué dans le listing 2.

Listing 2. Obtenir de l'aide sur le dictionnaire

>>> 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]
...

L'aide sur la classe dict indique que vous pouvez créer un dictionnaire directement en utilisant le constructeur sans utiliser d'accolades. Étant donné que plus de données doivent être fournies lors de la création d'un dictionnaire que pour les autres types de données de conteneur, il n'est pas surprenant que ces méthodes de création soient complexes. Cependant, il n'est pas difficile d'utiliser un dictionnaire en pratique, comme le montre le listing 3.

Listing 3. Création d'un dictionnaire en Python, Partie 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&#39;t convert dictionary 
 update sequence element #0 to a sequence
  
>>> l = [(0, &#39;zero&#39;), (1, &#39;one&#39;), (2, &#39;two&#39;), (3, &#39;three&#39;)]
>>> d = dict(l)
>>> d
{0: &#39;zero&#39;, 1: &#39;one&#39;, 2: &#39;two&#39;, 3: &#39;three&#39;}
>>> l = [[0, &#39;zero&#39;], [1, &#39;one&#39;], [2, &#39;two&#39;], [3, &#39;three&#39;]]
>>> d
{0: &#39;zero&#39;, 1: &#39;one&#39;, 2: &#39;two&#39;, 3: &#39;three&#39;}
>>> d = dict(l)
>>> d
{0: &#39;zero&#39;, 1: &#39;one&#39;, 2: &#39;two&#39;, 3: &#39;three&#39;}
>>> d = dict(zero=0, one=1, two=2, three=3) 
>>> d
{&#39;zero&#39;: 0, &#39;three&#39;: 3, &#39;two&#39;: 2, &#39;one&#39;: 1}
>>> d = dict(0=zero, 1=one, 2=two, 3=three): keyword can&#39;t be an expression

Comme vous pouvez le constater, la création d'un dictionnaire nécessite des valeurs clés et des valeurs de données. La première tentative de création d’un dictionnaire à partir de la liste échoue car il n’existe aucune paire clé-donnée-valeur correspondante. Les deuxième et troisième exemples montrent comment créer correctement un dictionnaire : dans le premier cas, utilisez une liste dans laquelle chaque élément est un tuple ; dans le deuxième cas, utilisez également une liste, mais chaque élément qu'elle contient est une autre liste ; Dans les deux cas, le conteneur interne est utilisé pour obtenir un mappage des clés aux valeurs de données.

Une autre façon de créer directement un conteneur dict consiste à fournir directement un mappage des clés aux valeurs de données. Cette technique permet de définir explicitement les clés et leurs valeurs correspondantes. Cette méthode est en réalité moins utile car la même tâche peut être accomplie en utilisant des accolades. De plus, comme le montre l'exemple précédent, vous ne pouvez pas utiliser de chiffres pour les clés lorsque vous utilisez cette méthode, sinon une exception sera levée.

Accès et modification du dictionnaire

Après avoir créé le dictionnaire, vous devez accéder aux données qu'il contient. L'accès est similaire à l'accès aux données dans n'importe quel type de données de conteneur Python, comme le montre le listing 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）是不可用的。试图使用片段或者试图从不存在的键访问数据就会抛出异常，指出相关的错误。

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 &#39;str&#39;>
>>> d[&#39;one&#39;]
>>> type(d[&#39;one&#39;])
<type &#39;int&#39;>
>>> d[&#39;two&#39;] = [0, 1, 2] 
>>> d
{0: &#39;zero&#39;, &#39;two&#39;: [0, 1, 2], &#39;one&#39;: 1}
>>> d[3] = (0, 1, 2, 3)
>>> d
{0: &#39;zero&#39;, 3: (0, 1, 2, 3), &#39;two&#39;: [0, 1, 2], &#39;one&#39;: 1}
>>> d[3] = &#39;a tuple&#39;
>>> d
{0: &#39;zero&#39;, 3: &#39;a tuple&#39;, &#39;two&#39;: [0, 1, 2], &#39;one&#39;: 1}

如这个例子所示，可以在一个字典（dictionary）中使用不同数据类型的键和数据值。还可以通过修改字典（dictionary）添加新的类型。最后，产生的 dictionary 的次序并不与插入数据的次序匹配。本质上，字典（dictionary）中元素的次序是由 Python 字典（dictionary）数据类型的实际实现控制的。新的 Python 解释器很容易改变这一次序，所以一定不要依赖于元素在字典（dictionary）中的特定次序。

用字典（dictionary）进行编程

作为正式的 Python 数据类型，字典（dictionary）支持其他较简单数据类型所支持的大多数操作。这些操作包括一般的关系操作符，比如 f539a70d3ea090bac4faa80192f58ccc 和 ==，如清单 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）；但是如果需要，可以这样做。

然后，这个示例将赋值给变量 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）使开发人员能够编写简洁而又强大的编程语句。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!