fiche mémo : 2.6. Chaînes et dictionnaires.¶
Travailler avec des chaînes et des dictionnaires, deux types de données Python fondamentaux.¶
Vincent GODARD - V1 - 06/04/2025¶
Cours Introduction à la programmation¶
Département de géographie - L3 - Université de Paris 8¶
Traduction librement (largement) inspirée de : https://www.kaggle.com/code/colinmorris/strings-and-dictionaries
Sources :
Kaggle : https://www.kaggle.com/learn
Python Tutorial : https://www.datacamp.com/fr/tutorial/python-dictionaries
Cours de Python : https://www.docstring.fr/glossaire/dictionnaire/
Téléchargement des documents nécessaires :
Dossier compressé à télécharger => (pas utile ici).
Cette leçon couvrira deux types Python essentiels : les chaînes et les dictionnaires.¶
1. Chaînes de caractères (strings)¶¶
L'un des domaines où Python excelle le plus est la manipulation de chaînes de caractères. Cette section abordera certaines des méthodes de chaînes et opérations de formatage intégrées à Python.
De tels schémas de manipulation de chaînes de caractères sont fréquents dans le contexte des travaux de science des données.
x = 'Pluto is a planet'
y = "Pluto is a planet"
x == y
Les guillemets doubles sont pratiques si votre chaîne contient un guillemet simple (par exemple, une apostrophe).
De même, il est facile de créer une chaîne contenant des guillemets doubles en l'entourant de guillemets simples :
print("Pluto's a planet!")
print('My dog is named "Pluto"')
Si nous essayons de placer un caractère guillemet simple à l'intérieur d'une chaîne entre guillemets simples, Python est confus :
'Pluto's a planet!'
Nous pouvons résoudre ce problème en « échappant » le guillemet simple avec une barre oblique inverse (backslash).
'Pluto\'s a planet!'
Le tableau ci-dessous résume certaines utilisations importantes du caractère barre oblique inverse. | Ce que vous tapez... | Ce que vous obtenez | exemple | print(exemple) | |:-------: |:---:|:-----: |:---:| | \' | ' | 'What\'s up?' | What's up? (Quoi de neuf ?) | | \" | " | "C'est \"cool"" | C'est "cool" | | \ \ | \ | "Signe attention: /!\ \"| Signe attention: /!\ |
Une dernière possibilité, \n, représente le caractère de saut de ligne. Elle force Python à démarrer une nouvelle ligne.
hello = "hello\nworld"
print(hello)
De plus, la syntaxe des triples guillemets de Python pour les chaînes de caractères nous permet d'inclure des sauts de ligne littéralement (c'est-à-dire en appuyant simplement sur « Entrée » au lieu d'utiliser la séquence spéciale « \n »). Nous avons déjà vu cela dans les docstrings que nous utilisons pour documenter nos fonctions, mais nous pouvons les utiliser partout où nous souhaitons définir une chaîne.
# Ici trois sauts de lignes
triplequoted_hello = """hello
world"""
print(triplequoted_hello)
triplequoted_hello == hello
La fonction print() ajoute automatiquement un caractère de nouvelle ligne, sauf si nous spécifions une valeur pour l'argument de mot-clé end autre que la valeur par défaut de '\n' :
print("hello")
print("world")
#print("hello", end='') # Faites ensuite un essai sans commentaire
print("pluto", end='')
# Indexage
planet = 'Pluto'
planet[0]
# Découpage (Slicing)
planet[-3:]
# Quelle est la longueur de cette chaîne ?
len(planet)
# Oui, nous pouvons même les parcourir en boucle
[char+'! ' for char in planet]
Mais leur principale différence avec les listes est qu'elles sont immuables. On ne peut pas les modifier.
planet[0] = 'B'
# planet.append ne fonctionne pas non plus
# EN MAJUSCULES (ALL CAPS)
claim = "Pluto is a planet!" # claim = prétendre, réclamer, exiger...
claim.upper()
# tout en minuscules (all lowercase)
claim.lower()
# Recherche du premier index d'une sous-chaîne (en démarrant de 0 !)
# Signifie : méthode utilisée pour trouver la position de la première occurrence d'une sous-chaîne à l'intérieur d'une chaîne de caractères plus grande.
claim.index('plan')
# claim est la chaîne de caractères principale.
# 'plan' est la sous-chaîne que nous recherchons.
# Commence par "Pluto" est vrai
claim.startswith("Pluto")
# Alors que finit par 'planet' est faux en raison d'un point d'exclamation manquant
claim.endswith('planet')
Passer d'une chaîne à une liste : .split() et .join()¶¶
str.split() transforme une chaîne en une liste de chaînes plus petites, avec un espace par défaut.
Ceci est très utile pour passer d'une grande chaîne à une liste de mots.
words = claim.split()
words
Parfois, vous souhaiterez effectuer une division sur autre chose qu'un espace (whitespace) :¶
# Séparation d'une date en trois entités
datestr = '1956-01-31'
year, month, day = datestr.split('-')
year, month, day
str.join() nous emmène dans l'autre sens, en combinant une liste de chaînes de caractères en une seule longue chaîne, en utilisant la chaîne sur laquelle elle a été appelée comme séparateur.
# Combinaison des trois entités en une date à l'américaine avec un autre séparateur
'/'.join([month, day, year])
# Oui, nous pouvons mettre des caractères Unicode directement dans nos littéraux de chaîne :)
' 👏 '.join([word.upper() for word in words])
Création de chaînes avec .format()¶¶
Python permet de concaténer des chaînes avec l'opérateur +.
planet + ', we miss you.'
Si nous voulons ajouter des objets non-chaîne, nous devons faire attention à appeler str() sur eux en premier.
# Par exemple :
position = 9
planet + ", you'll always be the " + position + "th planet to me."
# Doit être remplacé par [voir => str(position)] :
planet + ", you'll always be the " + str(position) + "th planet to me."
Cela devient difficile à lire et ennuyeux à taper. Appelons le str.format() à la rescousse.
"{}, you'll always be the {}th planet to me.".format(planet, position)
C'est tellement plus propre ! Nous appelons .format() sur une « chaîne de format », où les valeurs Python à insérer sont représentées par des espaces réservés {}.
Remarque : nous n'avons même pas eu besoin d'appeler str() pour convertir la position d'un int. Le format() s'en charge pour nous.
Si format() ne faisait que cela, il serait toujours incroyablement utile. Mais il s'avère qu'il peut faire bien plus. En voici un avant-goût :
pluto_mass = 1.303 * 10**22
earth_mass = 5.9722 * 10**24
population = 52910390
# 2 decimal points 3 decimal points, format as percent separate with commas
"{} weighs about {:.2} kilograms ({:.3%} of Earth's mass). It is home to {:,} Plutonians.".format(
planet, pluto_mass, pluto_mass / earth_mass, population,
)
# Référence aux arguments format() par index, en commençant par 0
s = """Pluto's a {0}.
No, it's a {1}.
{0}!
{1}!""".format('planet', 'dwarf planet')
print(s)
Vous pourriez probablement écrire un petit livre juste sur str.format, donc je vais m'arrêter ici et vous orienter vers pyformat.info (https://pyformat.info/) et les documents officiels (https://docs.python.org/3/library/string.html#formatstrings) pour une lecture plus approfondie.
numbers = {'one':1, 'two':2, 'three':3}
Dans ce cas, « un », « deux » et « trois » sont les clés, et 1, 2 et 3 sont leurs valeurs correspondantes.
L'accès aux valeurs s'effectue via une syntaxe entre crochets, similaire à l'indexation dans les listes et les chaînes.
numbers['one']
Nous pouvons utiliser la même syntaxe pour ajouter une autre paire clé-valeur
numbers['eleven'] = 11
numbers
Ou pour modifier la valeur associée à une clé existante
numbers['one'] = 'Pluto'
numbers
Python dispose de compréhensions de dictionnaire avec une syntaxe similaire aux compréhensions de liste que nous avons vues dans le didacticiel précédent.
# Comment afficher l'initiale de chaînes de caractères dans une liste
planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']
planet_to_initial = {planet: planet[0] for planet in planets}
planet_to_initial
Vérifier la présence d'une clé dans un dictionnaire :¶
L'opérateur in nous indique si quelque chose est une clé dans le dictionnaire.
'Saturn' in planet_to_initial
'Betelgeuse' in planet_to_initial
Une boucle for sur un *dictionnaire* bouclera sur ses clés.
for k in numbers:
print("{} = {}".format(k, numbers[k]))
Nous pouvons accéder à une collection de toutes les clés ou de toutes les valeurs avec dict.keys() et dict.values(), respectivement.
# Obtenez toutes les initiales, triez-les par ordre alphabétique et placez-les dans une chaîne séparée par des espaces.
' '.join(sorted(planet_to_initial.values()))
La méthode dict.items(), très utile, permet d'itérer simultanément sur les clés et les valeurs d'un dictionnaire. (En Python, un élément désigne une paire clé-valeur.)
for planet, initial in planet_to_initial.items():
print("{} commence avec \"{}\"".format(planet.rjust(10), initial))
Pour lire un inventaire complet des méthodes des dictionnaires, exécutez la cellule ci-dessous pour lire la page d'aide complète ou consultez la documentation officielle en ligne (https://docs.python.org/3/library/stdtypes.html#dict).
help(dict)
# Définition des pays et des capitales
countries = ['spain', 'france', 'germany', 'norway']
capitals = ['madrid', 'paris', 'berlin', 'oslo']
# À partir de chaînes pays et capitales, créez un dictionnaire européen
europe = {'spain':'madrid', 'france':'paris', 'germany':'berlin', 'norway':'oslo'}
# Print Europe
print(europe)
Se motiver pour les dictionnaires^^ !¶
Pour comprendre l'utilité des dictionnaires, consultez les deux listes définies à droite.
• countries contient les noms de certains pays européens.
• capitales répertorie les noms correspondants de leurs capitales.
Instructions Utilisez la méthode index() sur pays pour trouver l'index de l'Allemagne (Germany). Enregistrez cet index sous le nom ind_ger. Utilisez ind_ger pour accéder à la capitale de l'Allemagne à partir de la liste des capitales. Affichez-la.
# Définition des pays et des capitales
countries = ['spain', 'france', 'germany', 'norway']
capitals = ['madrid', 'paris', 'berlin', 'oslo']
# Obtenir l'index de « germany » : ind_ger
ind_ger = countries.index('germany')
# Utilisez ind_ger pour imprimer la capitale de l'Allemagne (Germany)
print(capitals[ind_ger])