Dictionnaires avancés Python

Introduction

Vous vous êtes déjà familiarisé avec les dictionnaires, mais tout comme les autres structures de données prises en charge par Python, il existe des méthodes et des moyens plus puissants de les utiliser. Il n’y a pas autant de méthodes pour travailler avec les dictionnaires que pour les listes, mais c’est parce que les dictionnaires n’en ont tout simplement pas besoin. De plus, la plupart de ceux qui existent travaillent à décomposer les dictionnaires en listes et en tuples pour les rendre plus faciles à gérer. Ainsi, ces méthodes de liste peuvent être utilisées en conjonction avec celles du dictionnaire pour créer une machine efficace pour le traitement des données.

Méthodes du dictionnaire

Objets, clés et valeurs

Ces méthodes permettent de décomposer les dictionnaires en d’autres structures de données afin de rendre leur utilisation beaucoup plus facile à gérer. Cela donne également accès aux méthodes de ces structures de données. Grâce à ces combinaisons de méthodes et de boucles, vous pouvez accéder aux données et les manipuler facilement.

La première méthode est items(). Il décompose chaque entrée du dictionnaire en un tuple et les stocke toutes dans une liste.


distro_install_command = {'Debian': 'apt-get',
                        'Ubuntu': 'apt-get',
                        'Fedora': 'dnf',
                        'CentOS': 'yum',
                        'OpenSUSE': 'zypper',
                        'Arch': 'pacman',
                        'Gentoo': 'emerge'
}
distro_install_list = distro_install_command.items()
print(distro_install_list)
print(distro_install_list[3][1])

Tout se décompose exactement comme vous vous y attendez.

La méthode suivante vous donne accès aux clés du dictionnaire sous la forme d’une liste.


distro_install_command = {'Debian': 'apt-get',
                        'Ubuntu': 'apt-get',
                        'Fedora': 'dnf',
                        'CentOS': 'yum',
                        'OpenSUSE': 'zypper',
                        'Arch': 'pacman',
                        'Gentoo': 'emerge'
}
distro_names = distro_install_command.keys()

for distro in distro_names:
	print(distro)

La nouvelle liste de distro_names se comporte comme n’importe quelle autre et peut être parcourue en boucle de la même manière.

La dernière méthode est la même que celle qui la précède, mais au lieu de récupérer les clés, celle-ci récupère les valeurs. Il devrait être assez évident maintenant qu’il s’appelle values().


distro_install_command = {'Debian': 'apt-get',
                        'Ubuntu': 'apt-get',
                        'Fedora': 'dnf',
                        'CentOS': 'yum',
                        'OpenSUSE': 'zypper',
                        'Arch': 'pacman',
                        'Gentoo': 'emerge'
}
distro_commands = distro_install_command.values()

for command in distro_commands:
    print(command)

Valeurs de dictionnaire dans les chaînes de caractères

Ce n’est pas une méthode ou quelque chose de trop complexe, mais des situations se présenteront lorsque vous voudrez insérer des valeurs directement d’un hachage dans une chaîne, et cela ne fonctionne pas tout à fait comme vous le pensez. L’opérateur % examine en fait le dictionnaire dans son ensemble et extrait les valeurs des clés qu’il contient pour les substituer dans une chaîne.


book_info = { 'title': 'Learning Python',
			'pages': 342,
			'pub_date': 'November 2016',
			'chapters': 14,
}
print("The book is called %(title)s, and it was released on %(pub_date)s.  It is %(pages)d pages long with %(chapters)d chapters." % book_info)

Comme vous pouvez le voir, il s’agit simplement d’une méthode plus pratique pour gérer l’insertion des valeurs d’un dictionnaire. L’utilisation de la méthode habituelle peut devenir très répétitive et fastidieuse, même avec seulement quelques entrées.

Itération sur les dictionnaires

Parcourir des dictionnaires n’est pas aussi simple que vous le pensez probablement. Étant donné que les dictionnaires fonctionnent à l’aide de paires de valeurs, la méthode numérique permettant de parcourir les listes ne fonctionne pas tout à fait. Essayez-le et voyez ce qui se passe.


distro_install_command = {'Debian': 'apt-get',
                        'Ubuntu': 'apt-get',
                        'Fedora': 'dnf',
                        'CentOS': 'yum',
                        'OpenSUSE': 'zypper',
                        'Arch': 'pacman',
                        'Gentoo': 'emerge'
}
for distro in distro_install_command:
	print(distro)

Alors, que s’est-il passé ? Cela a fonctionné en quelque sorte, mais les seules choses qui sortaient étaient les touches. Vous pouvez probablement deviner une façon d’obtenir les valeurs aussi, et cela fonctionnera, mais ce n’est pas une solution si élégante.


distro_install_command = {'Debian': 'apt-get',
                        'Ubuntu': 'apt-get',
                        'Fedora': 'dnf',
                        'CentOS': 'yum',
                        'OpenSUSE': 'zypper',
                        'Arch': 'pacman',
                        'Gentoo': 'emerge'
}
for distro in distro_install_command:
    print("The distro is %s, and it uses the command %s." % (distro, distro_install_command[distro]))

Il existe une meilleure façon de gérer cela, et elle utilise la méthode items(). Si vous vous souvenez d’avant, la méthode items() crée une liste de tuples contenant les clés et les valeurs du dictionnaire.


distro_install_command = {'Debian': 'apt-get',
                        'Ubuntu': 'apt-get',
                        'Fedora': 'dnf',
                        'CentOS': 'yum',
                        'OpenSUSE': 'zypper',
                        'Arch': 'pacman',
                        'Gentoo': 'emerge'
}
for distro, command in distro_install_command.items():
    print("The distro is %s, and it uses the command %s." % (distro, command))

Cela semble aller à l’encontre de quelque chose que vous avez appris précédemment, n’est-ce pas ? Comment se fait-il que cette boucle crée deux variables temporaires pour accéder aux éléments d’une liste bidimensionnelle ? Eh bien, il s’agit en fait d’une fonctionnalité intégrée à Python pour ce genre de chose. Malheureusement, cela ne fonctionne pas toujours bien avec les listes multidimensionnelles, car cela nécessite que toutes les listes de la liste multidimensionnelle soient de la même taille. Avec un dictionnaire, vous savez que vous allez toujours travailler avec des paires de valeurs, mais les listes multidimensionnelles peuvent contenir des listes de n’importe quelle taille. C’est pourquoi ce n’est vraiment qu’une excellente solution lorsque vous travaillez avec des dictionnaires.

Conclusion

En utilisant des méthodes et des itérations, vous pouvez décomposer les dictionnaires sous une forme beaucoup plus facile à utiliser. En combinant les fonctionnalités des dictionnaires avec les fonctionnalités disponibles pour les listes et les tuples, vous obtenez des outils incroyablement puissants pour la gestion des données.

Table des matières

Guide d’introduction et d’installation de Python
Les fichiers Python et l’interpréteur
Expérimenter avec des nombres et du texte en Python
Variables Python
Travailler avec des variables numériques en Python
Principes de base des chaînes Python
Chaînes Python avancées
Commentaires sur Python
Listes Python
Méthodes de liste Python
Listes multidimensionnelles Python
Tuples Python
Opérateurs booléens Python
Instructions Python If
Boucles Python While
Python pour les boucles
Dictionnaires Python
Dictionnaires avancés Python
Fonctions Python