Instructions et blocs d'instructions

Dans le langage Python, chaque instruction occupe une ligne : il n'y a pas de symbole de fin, nous passons simplement à la ligne après chaque instruction. C'est la règle générale mais nous verrons qu'il est possible d'écrire une chaîne de caractères ou une condition sur plusieurs lignes pour une meilleure lisibilité du code Python.

Les blocs d'instructions ne sont pas délimités eux non plus par un symbole particulier mais répérés par l'indentation des instructions :

• des instructions qui sont dans le même bloc ont le même nombre d'espaces à leur gauche,
• pour marquer le début d'un nouveau bloc, on va rajouter quelques espaces par rapport à l'instruction précédente.

Idéalement, il faut utiliser un éditeur qui, après un appui sur la touche tabulation du clavier, amène le curseur à l'endroit adéquat en produisant le nombre d'espaces nécessaires.

Types et variables

Python autorise la manipulation de types classiques : booléens (bool), entiers (int), réels (float) et chaîne de caractères (str). À noter que les noms des types indiqués sont aussi des opérateurs de conversion.

Ni les variables ni leurs types n'ont besoin d'être déclarés.

msg = "toto"  # déclaration et affectation d'une chaîne de caractères
pi  = 3.14    # déclaration et affectation d'un nombre

Notons la syntaxe permettant d'écrire des commentaires dans le code Python : le signe # indique que la suite de la ligne n'est pas destinée à Python mais à un lecteur humain. Nous verrons que des commentaires bien formatés permettent aussi la production de commentaires et des tests automatiques.

Comme suggéré ci-dessus, le symbole = est réservé à l'affectation d'une valeur à une variable. Le symbole ==, lui, permet d'exprimer un test d'égalité qui ne modifie en rien les variables.

Comme déjà évoqué, lorsque nous souhaiterons des conversions explicites d'un type à l'autre, nous utiliserons str pour obtenir une chaîne de caractères (à partir d'un nombre) et int pour obtenir un entier (à partir d'un texte par exemple).

pitxt    = str(pi)         # obtention de la chaîne de caractères "3.14"
sixtxt   = "6"             # une chaîne de caractères
résultat = 7 * int(sixtxt) # ... convertie en entier pour calcul
réponse  = str(résultat)   # ... et retour en chaîne pour affichage

Opérateurs

Nous disposons en Python des opérateurs arithmétiques classiques : +, -, *, /, // pour la division entière et % pour l'opération modulo (reste de la division).

salaire      = 2000
augmentation = 7 * salaire / 100

Nous retrouvons également les habituels opérateurs logiques (and, or et not) pour manipuler les booléens qui, en Python, sont notés True et False.

Premières chaînes de caractères et instruction d'affichage

En Python, les chaînes de caractères doivent être délimitées, au choix, par des apostrophes ou des guillemets.

"coucou hé !"
'ça va ?'

Nous reviendrons en détail sur la manipulation des chaînes de caractères en Python dans une section dédiée.

Les affichages sont réalisés à l'aide de l'instruction print() : elle affiche les éléments qui lui sont confiés puis passe à la ligne, les éléments sont séparés par un espace.

print("coucou hé !")  # affiche et passe à la ligne
print("toto","titi")  # titi suit toto, passage à la ligne
print()               # simple passage à la ligne

Le passage à la ligne en fin d'affichage et l'espace séparateur sont des paramètres de print que l'on peut modifier. Voici quelques exemples qui illustrent différentes utilisations possibles de print.

print("toto",end="!")        # termine par un ! et pas par un passage à la ligne
print("titi")                # titi colle à toto et passage à la ligne
print("lulu","lala",sep="+") # affiche lulu+lala et passe à la ligne

Par ailleurs, l'instruction print nous permet deux observations sur les procédures en Python :

1. un paramètre peut être optionnel avec une valeur par défaut,
2. les paramètres peuvent être nommés au moment de l'appel à une procédure, on s'affranchit ainsi de l'ordre fixé dans la définition de la procédure.

Structures de contrôle en Python

Nous retrouvons en Python les structures de contrôle classiques, en particulier celles vues en cours d'algorithmique.

Structure conditionnelle : le si alors sinon

Le si alors sinon introduit une condition et deux blocs d'instructions : le premier bloc sera exécuté si la condition est vraie, le second si la condition est fausse. C'est l'occasion d'observer le délimitation des blocs en Python qui utilise l'indentation, c'est-à-dire le décalage et l'alignement des instructions d'un même bloc vers la droite.

# forme générale
if (une condition ici):
    # ...
    # des instructions ici
    # ...
else:
    # ...
    # des instructions ici
    # ...

# affichages distincts selon un test
temperature = 28
if temperature>25:
    print('il fait chaud !')
else:
    print('il fait frais...')

Si le second bloc ne contient pas d'instructions, on peut se dispenser du else :

# affichage si un test est vrai
temperature = 28
if temperature>25:
    print('il fait chaud !')

La condition doit être interprétée à vrai ou à faux, c'est-à-dire comme un booléen. On peut donc y trouver des variables booléennes et des opérateurs booléens.

if (temperature>25) and (temps=="ensoleillé") :
    print("il fait chaud !")
else:
    print("c'est mitigé")

Si l'on doit enchaîner plusieurs tests, Python propose elif en plus de if et de else :

# enchaînement de tests
temperature = 28
if temperature>25:
    print('il fait chaud !')
elif temperature>20:
    print('il fait bon.')
else:
    print('il fait frais...')

Les elif peuvent être utilisés en nombre quelconque, ce qui permet de limiter l'imbrication du code et donc d'augmenter sa lisibilité.

En Python, une condition doit s'exprimer sur une seule ligne mais, encore une fois pour faciliter la lisibilité du code, il est possible de masquer la fin de ligne à l'aide du caractère d'échappement backslash (signe \) et ainsi étaler des tests sur plusieurs lignes.

if    (lettre == 'a') or (lettre == 'e') \
   or (lettre == 'i') or (lettre == 'o') \
   or (lettre == 'u') or (lettre == 'y') :

    print("«",lettre,"» est une voyelle.")
	
else :

    print("«",lettre,"» N'est PAS une voyelle.")
	

Structure itérative : la boucle tant que

On retrouve la boucle tant que avec sa condition et le bloc d'instructions à exécuter tant que la condition est vraie, bloc indenté vers la droite.

# forme générale
while (une condition ici):
    # ...
    # des instructions ici
    # ...

# exemple : on compte de 1 à 10
i = 1
while i<=10:
    print(i)
    i = i + 1

Structure itérative : la boucle pour

Dans une utilisation courante, la boucle for ... in ... parcourt un intervalle défini par l'instruction range.

• range peut prendre jusqu'à trois arguments entiers : début, fin et pas.
• range va fournir les entiers depuis min, avancer de pas en pas et s'arrêter avant fin.
• début et pas sont optionnels, ils valent par défaut respectivement 0 et 1.
• pas peut être négatif mais pas nul.

# forme générale
for i in range(début,fin,pas):
    # ...
    # des instructions ici
    # ...

# on compte de 0 à 4
for i in range(5):
    print(i)

# on compte de 1 à 10
for i in range(1,11):
    print(i)

# on compte à rebours 5 à 0
for i in range(5,-1,-1):
    print(i)

# affichage de 10 étoiles
for i in range(10):
    print('*')

Une utilisation plus générale de cette boucle est possible, lorsque l'objet donné après le in est itérable. C'est le cas du range et il en sera de même pour les chaînes de caractères et pour les listes.

Procédures et fonctions

Les procédures et les fonctions ont en commun de rassembler des instructions pour des réutilisations futures. Elles utilisent des paramètres pour généraliser le code. Une fonction doit toujours se terminer par le renvoi d'un résultat (à l'aide du mot-clef return en Python), ce qui n'est jamais le cas pour une procédure. Cela signifie en particulier qu'un appel à une fonction se trouvera souvent dans la partie droite d'une affectation, en revanche un appel à une procédure ne pourra pas être à cette position.

# forme générale d'une procédure
def nom_de_la_procédure (paramètres):
    # ...
    # des instructions ici
    # ...

# procédure qui affiche entre étoiles un texte donné
def affiche_joliment (msg):
    print('***',msg,'***')

# on appelle la procédure et on renseigne son paramètre
affiche_joliment('coucou')

En Python un paramètre peut être optionnel, il convient alors de préciser la valeur à utiliser si elle n'est pas précisée lors de l'appel. De plus, les paramètres peuvent être nommés au moment de l'appel à une procédure, on se dispense ainsi de respecter l'ordre fixé dans la définition de la procédure.

# procédure qui affiche un carré
def carré (taille, symbole="*"):
       for l in range(taille):
           for c in range(taille):
               print(symbole,end="")
           print()

# appels à la procédure
carré(10,"·")
carré(5)
carré(symbole="o",taille=7)

Comme indiqué, une fonction se doit de renvoyer un résultat avec l'instruction return.

# forme générale d'une fonction
def nom_de_la_fonction (paramètres):
    # ...
    # des instructions ici
    # ...
    return(résultat)

# fonction qui calcule la somme de deux entiers et la renvoie
def addition (a,b):
    s = a+b
    return(s)

L'appel à cette fonction pourra se trouver dans la partie droite d'une affectation ou être impliqué dans un test.

# on appelle la fonction en renseignant ses paramètres et on récupère le résultat
somme = addition(2,2)
print('le résultat est',somme)
print('le résultat est',addition(1,3))

# appel dans un test
if addition(20,42)>50:
    print("c'est grand !")
else:
    print("c'est petit")

Enfin, il est possible en Python d'associer aux procédures et aux fonctions des commentaires bien formatés qui permettent la production de documentation et des tests automatiques.

Accès aux éléments d'un module

Un module est un fichier qui regroupe des variables, des procédures et des fonctions, pour que celles-ci puissent être utilisées dans des scripts Python différents. Plusieurs syntaxes sont possibles pour charger ces modules et utiliser les procédures/fonctions en provenance de ces modules.

# nous précisons la fonction qui nous intéresse dans le module
from module import fonction
...
# appel de la fonction sans rappeler le nom du module
fonction()
...
# plusieurs fonctions sont récupérées et appelées
from module import f1,f2
...
f1()
...
f2()
...
# toutes les fonctions du module sont récupérées et appelées
from module import *
...
f1()
...
f2()
...
f3()
...

Il peut devenir délicat de comprendre l'exécution d'un code Python si l'on importe une variable ou une fonction depuis un module alors que notre propre code définit un objet du même nom, avant ou après l'importation du module. Il est préférable d'utiliser les espaces de noms (comme en XML) pour préciser systématiquement le module d'origine d'une variable ou d'une fonction.

# on va utiliser des fonctions du module
import module
...
# on précise à nouveau le nom du module
# avec chaque utilisation d'une fonction de ce module
module.fonction()
...

Voyons un exemple avec les fonctions mathématiques proposées par Python à travers le module math.

import math         # importation du module mathématique de Python

math.sqrt(2)        # utilisation de la fonction racine carrée du module math
math.floor(math.pi) # arrondi de la valeur de π

Il est possible, à l'aide du mot-clef as, de définir alias au nom du module, plus court ou plus informatif.

import math as mth # importation du module mathématique sous le nom « mth »
mth.sqrt(2)        # utilisation de la racine carrée du module« mth »

import math as mathématiques # importation sous le nom « mathématiques »
mathématiques.sqrt(2)        # utilisation de la racine carrée du module « mathématiques »

Nous verrons plus loin, en détail, des modules Python d'utilisation courante.

Syntaxe objet

En programmation objet, les variables embarquent en elles des caractéristiques qui les décrivent (les propriétés de l'objet) et des procédures et fonctions qui permettent de les traiter (les méthodes de l'objet).

Nous n'étudions pas dans le cadre de ce cours les techniques de programmation orientée objet que permettent Python. Cependant, nous sommes contraints d'utiliser la syntaxe objet pour manipuler certaines variables Python, qui de fait sont des objets. La syntaxe pour appeler une méthode d'un objet est : le nom de la variable, suivi d'un point, suivi d'un appel à la procédure ou à la fonction propre à l'objet.

Sur l'exemple suivant, nous voyons que les chaînes de caractères sont en Python des objets, et que l'on peut s'adresser à leurs méthodes.

prénom = "Fabien"  # création d'un objet chaîne de caractères
prénom.upper()     # demande à l'objet de fournir une version en majuscules de lui-même

Nous retrouvons la syntaxe pointée et les espaces de noms vus avec les modules, mais objet et module sont bien deux notions différentes.

Écriture des chaînes de caractères en Python

Le langage Python permet de délimiter les chaînes de caractères soit par des apostrophes, soit par des guillemets. Il est pratique d'utiliser les guillemets lorsque le texte contient une apostrophe, et vice-versa.

prénom = 'Toto'
print("salut",prénom)
print("ça va aujourd'hui ?")

Il est aussi possible d'utiliser le caractère d'échappement backslash (signe \) pour changer la signification Python du caractère qui le suit. Cela permet d'indiquer qu'un guillemet ou une apostrophe ne sont pas des délimitations de fin de chaînes mais des caractères quelconques à l'intérieur de la chaîne. Cela permet également d'ajouter des instructions dans les chaînes de caractères comme le passage à la ligne (\n) ou la tabulation (\t).

print('oui, ça va aujourd\'hui !')  # échappement de l'apostrophe grâce au backslash
print("\t super !")                 # ajout d'une tabulation en début de ligne

En conséquence, le caractère backslash a une signification particulière et doit être lui aussi protégé (par un backslash !) si l'on veut simplement l'inclure dans une chaîne de caractère. Python propose une autre solution, les raw strings ou chaînes brutes dans lesquelles il est convenu que le backslash n'a pas de signification particulière et n'ont donc pas besoin d'être protégés. Ces chaînes sont préfixées par la lettre « r ».

# deux variables qui contiennent la même chaîne de caractère : 'Voici un backslash protégé : \\ ok ?'
info_1 = "Voici un backslash protégé : \\ ok ?"
info_2 = r"Voici un backslash protégé : \ ok ?"

# print donne des affichages identiques
print(info_1) # affichage : Voici un backslash protégé : \ ok ?
print(info_2) # affichage : Voici un backslash protégé : \ ok ?

texte_1 = r"\n" # définition d'une chaîne de caractères brute
texte_1         # contient \\n
len(texte_1)    # donne la valeur 2
print(texte_1)  # affiche \n

texte_2 = "\n"  # définition d'une chaîne de caractères ordinaire
texte_2         # contient \n
len(texte_2)    # donne la valeur 1
print(texte_2)  # affiche une ligne vide (deux passages à la ligne)

Ces raw strings seront particulièrement pertinentes quand nous aurons à écrire des expressions régulières.

Il y aussi en Python les chaînes formatées, préfixées par la lettre f. Elles permettent d'abord d'embarquer des expressions Python dans les chaînes de caractères. Ces expressions sont placées entre accolades, elles sont évaluées et le résultat remplace les accolades et leur contenu dans la chaîne. À noter les expressions particulières qui se terminent par le symbole égal (=).

f"essai 1 : {2+2}"    # "essai 1 : 4"
f"essai 2 : {2+2 = }" # "essai 2 : 2+2 = 4"

prénom = "Fabien"
f"Je m'appelle {prénom}."         # "Je m'appelle Fabien."
f"Je m'appelle {prénom.upper()}." # "Je m'appelle FABIEN."
f"{prénom.lower() = }"            # "prénom.lower() = 'fabien'"

Dans les chaînes formatées, il est possible d'ajouter des indications de formatage pour chaque expression entre accolades. Le format souhaité se place lui aussi dans les accolades : à la suite de l'expression à évaluer, en les séparant par le caractère « deux points » (:). Ces formats permettent de spécifier des alignements, des séparateurs, des places occupées, des conversions, etc.

Certains formats sont dédiés aux textes...

f"Prénom : {'Fabien':<10} !"  # "Prénom : Fabien     !"
f"Prénom : {'Fabien':>10} !"  # "Prénom :     Fabien !"
f"Prénom : {'Fabien':^10} !"  # "Prénom :   Fabien   !"

... et d'autres aux nombres.

f"Résultat : {1/4:+}"         # "Résultat : +0.25"
f"Résultat : {-1/4:+}"        # "Résultat : -0.25"

f"Prix : {45000:,} €."        # "Prix : 45,000 €."
    
f"Pourcentage : {0.225:5.2%}" # "Pourcentage : 22.50%"

f"Entier : {2*12:10d} !"      # "Entier :         24 !"
f"Entier : {2*12:<10d} !"     # "Entier : 24         !"

f"Réel : {1/3:6.2f} !"        # "Réel :   0.33 !"
f"Réel : {1/3:<6.2f} !"       # "Réel : 0.33   !"										  

Enfin, Python autorise les chaînes de caractères sur plusieurs lignes : la convention est d'encadrer ces chaînes par des triples guillemets (""").

"""coucou
ça va ?
ou bien ?
"""
# c'est la chaîne de caractères 'coucou\nça va ?\nou bien ?\n'

Opérations sur les chaînes de caractères en Python

Codage et décodage des caractères en Python. Il est possible de repérer un caractère par son numéro UNICODE. Par exemple, les lettres de a à z en minuscules correspondent aux codes de 97 à 122. La fonction Python chr permet de passer de l'entier au caractère correspondant, la fonction ord réalise la conversion inverse.

print(chr(100)) # affichage du caractère 100 : "d"
print(chr(425)) # affichage du caractère 425 : "Ʃ"

print(ord("m")) # affiche le code UNICODE du "m" : 109
print(ord("œ")) # affiche le code UNICODE du "œ" : 339

De premières comparaisons entre chaînes de caractères peuvent être réalisées avec < et >... mais ces comparaisons sont basées sur les codes UNICODE des caractères !

ord("a"), ord("b"), ord("â"), ord("z") #(97, 98, 226, 122)

"a" < "b" # True
"â" < "z" # False

Nous verrons plus loin une méthode plus pertinente, basée sur l'ordre alphabétique de la langue manipulée.

Sur les chaînes de caractères, nous trouvons l'opérateur de concaténation noté par un plus (symbole +, comme pour l'addition entre entiers) et un opérateur de répétition des chaînes avec un fois (symbole *, comme pour la multiplication entre entiers).

température = 25
    
texte       = 'La variable « température » vaut ' + str(température)
texte       = "\n" + texte + "\n"
print(texte)

print("coucou ! " * 3) # répéter une chaîne : coucou ! coucou ! coucou !

La longueur d'une chaîne de caractères est obtenue à l'aide de la fonction len.

len("héhéhé")               # 6
len("coucou")+len("Fabien") # 12
len("coucou"+"Fabien")      # 12

température = 25
texte       = 'La variable « température » vaut ' + str(température)
len(texte)  # 35

Pour accéder à un caractère d'une chaînes de caractères, Python propose la syntaxe « crochets » ([]), laquelle permet de préciser la position du caractère qui nous intéresse. La numérotation des caractères commence à 0.

prénom = "Fabien"
print(prénom[0]) # "F"
print(prénom[5]) # "n"

Cette notation se généralise en Python pour permettre l'extraction de sous-chaînes de caractères, on parle alors de slices (des « tranches »).

# syntaxe générale pour les slices
chaîne[début:fin:pas]
# construit une nouvelle chaîne avec les caractères extraits entre début et fin, en avançant de pas en pas

prénom = "Fabien"

print(prénom[0:2]) # "Fa"
print(prénom[5:6]) # "n"

# un caractère sur deux, dans un sens puis dans un autre
print(prénom[0:6:2])  # "Fbe"
print(prénom[5:0:-2]) # "nia"

# début et fin sont optionnels et ont donc des valeurs par défaut
print(prénom[2:])   # "ien"
print(prénom[:3])   # "Fab"
print(prénom[:])    # "Fabien"
print(prénom[::-1]) # "neibaF"

# on peut se repérer par rapport à la longueur de la chaîne...
print(prénom[len(prénom)-2:]) # "en"
# ... et, en raccourci, indiquer des positions négatives
print(prénom[-2:])            # "en"

Les chaînes de caractères en Python ne sont pas modifiables. Il est donc impossible d'utiliser la syntaxe « crochets » pour modifier un caractère particulier dans une chaîne. Toute modification implique alors la création d'une nouvelle chaîne de caractères. Ainsi, modifications/suppressions dans les chaînes de caractères passent par les opérations déjà vues (concaténation et multiplication), ou par l'extraction des parties à conserver avec des slices suivie de la construction d'une nouvelle chaîne. Éventuellement, la nouvelle chaîne peut être stockée dans la variable d'origine.

question = "ça va"
question = question + " ?"    # ajout d'un caractère en fin : "ça va ?"

question = "Ç" + question[1:] # changement de la première lettre : "Ça va ?"

nq = question[:5] + " ou bien" + question[5:] # nouvelle question : "Ça va ou bien ?"

Ci-dessous, quelques méthodes des chaînes de caractères qui nous seront utiles.

• lower, upper, capitalize et title : passent des caractères de la chaîne en minuscules ou majuscules,
• strip, rstrip et lstrip : suppriment les caractères spécifiés, par défaut des espaces au sens large (espace, tabulation, passage à la ligne, etc.), en début ou en fin de chaîne,
• replace : remplace toutes les occurrences d'une sous-chaîne dans une chaîne,
• find : fournit la position de la première occurrence d'une sous-chaîne (-1 si la cible n'est pas présente).

# jeux sur les majuscules/minuscules
phrase = "Je m'appelle Fabien."
phrase.upper()      # "JE M'APPELLE FABIEN."
phrase.lower()      # "je m'appelle fabien."
phrase.title()      # "Je M'Appelle Fabien."
phrase.capitalize() # "Je m'appelle fabien."

# la chaîne de caractères d'origine n'a pas été modifiée
phrase # "Je m'appelle Fabien."

# texte sur plusieurs lignes puis nettoyage des espaces au début ou à la fin
texte = """
    coucou
bonjour chez vous !

"""
texte.strip()  # "coucou\nbonjour chez vous !"
texte.lstrip() # "coucou\nbonjour chez vous !\n\n"
texte.rstrip() # "\n    coucou\nbonjour chez vous !"

# nettoyage du début et de la fin des caractères précisés
phrase.strip("eJn. ") # "m'appelle Fabi"

# remplacement
phrase.replace("e","X") # "JX m'appXllX FabiXn.

# trouve la position d'une sous-chaîne
phrase.find("a")    # 5
phrase.find("e ")   # 1
phrase.find("rien") # -1

La méthode rsrtip sera particulièrement utile lors de la lecture d'un fichier, pour enlever les caractères de fin de ligne.

# boucle tant que sur les lignes du flux
while ligne := flux_in.readline():
    ligne = ligne.rstrip() # on débarrasse la ligne de son retour chariot
    print(ligne)

Pour effectuer, le parcours d'une chaîne de caractères nous retrouvons une boucle for ... in ... :

# définition d'une chaîne de caractères
mot = "coucou"

# parcours d'une chaîne caractère par caractère
for lettre in mot:
    print(lettre)
# chaque lettre du mot est affichée sur une ligne différente

Plus proche de la méthode algorithmique, il est possible de boucler sur les indices des caractères et d'y accéder à l'aide de la notation « crochets » ([]). Mais cela est jugé peu « pythonique ».

# autre parcours caractère par caractère
for i in range(0,len(mot)):
    print(mot[i],end="-")
print()
# affiche "c-o-u-c-o-u-" et passe à la ligne

Nous avons vu en cours d'algorithmique différentes méthodes qui parcourt une chaîne de caractères (ou un tableau d'éléments quelconques), afin de déterminer si un caractère particulier est présent dans la chaîne ou non. En Python, nous pouvons naturellement implémenter ces algorithmes mais il existe déjà à cette fin l'opérateur Python in (lequel est probablement basé sur un algorithme étudié).

"a" in "Fabien" # True
"z" in "Fabien" # False

# opérateur in dans un if
mot = "chanter"
if "a" in mot:
    print("«",mot,"» contient un a.")
else:
    print("«",mot,"» NE contient PAS de a.")

Nous verrons d'autres instructions qui utilisent les chaînes des caractères au cours de l'apprentissage des listes.

Manipulation des ensembles Python

Un ensemble, set en Python, est comme son nom l'indique une collection d'éléments, non ordonnée et sans doublon.

En Python, on obtient un ensemble, au choix :

• avec le constructeur set() pour définir un ensemble vide ou à partir d'un objet d'un autre type,
• avec les accolades (symboles {}) pour définir explicitement un ensemble d'au moins un élément.

# définitions d'ensembles Python
set()         # ensemble vide : { }
set("coucou") # à partir d'une chaîne de caractères : {'c', 'o', 'u'}

{ "coucou" , "salut"} # ensemble de deux éléments

Python met à disposition des méthodes sur les ensembles pour ajouter et supprimer des éléments. Naturellement, nous avons aussi les opérations ensemblistes usuelles. Enfin, nous retrouvons len pour connaître le nombre d'éléments présents dans un ensemble.

# ajouts et suppressions dans les ensembles
lettres = set("coucou") # {'u', 'o', 'c'}
lettres.add("x")        # {'x', 'u', 'o', 'c'}
lettres.add("x")        # {'x', 'u', 'o', 'c'}, pas de doublon dans un ensemble
lettres.remove("u")     # {'x', 'o', 'c'}

# accès à la taille de l'ensemble
len(lettres) # 3

# méthodes ensemblistes qui produisent de nouveaux ensembles
s1 = {1,2,3}
s2 = {3,4,5}
s1.intersection(s2) # {3}
s1.union(s2)        # {1, 2, 3, 4, 5}
s1.difference(s2)   # {1, 2}
s2.difference(s1)   # {4, 5}

Nous pouvons parcourir les ensembles Python, simplement avec une boucle for ... in ..., mais sans garantie sur l'ordre d'apparition des éléments.

# forme générale d'une boucle parcourant un ensemble
for élément in ensemble:
    print(élément)

Terminons avec l'opérateur in qui permet ici de tester si un élément est présent un ensemble.

amis = {'Lili', 'Toto', 'Baba'}
    
"Toto" in amis # True
"Lulu" in amis # False

Dans la section suivante, nous discutons de cet opérateur in dans le contexte des ensembles, ainsi que d'une utilisation possible.

Test d'existence rapide à l'aide des ensembles Python

Rappelons que l'opérateur in fonctionne sur les chaînes de caractères, sur les listes et sur les ensembles. De plus, la syntaxe Python seule ne permet pas toujours de distinguer au premier coup d'œil si l'opérateur in travaille sur une liste ou sur un ensemble. Cependant, ce sont des algorithmes bien distincts qui sont utilisés dans chacun de ces cas et les performances sont bien différentes.

Illustrons cela avec le cas où l'on souhaite tester la présence d'un mot dans une liste de mots. Il s'agit par exemple de faire de la vérification orthographique. Dans ce cas, nous avons besoin d'une liste de mots français autorisés. Si celle-ci est stockée dans un fichier, il suffit de la lire et de la charger dans un ensemble Python.

liste_mots = set() # création d'un ensemble vide

flux_dico = open('liste-mots.txt',mode='r',encoding="utf-8")

while ligne := flux_dico.readline():
    mot = ligne.rstrip().lower() # nettoyage et normalisation du mot
    liste_mots.add(mot)          # ajout du mot à l'ensemble

flux_dico.close()

Nous pouvons maintenant tester simplement l'existence d'un mot dans l'ensemble créé, à l'aide de l'opérateur in.

if mot in liste_mots : # on teste l'existence
    print("«",mot,"» est connu et correct.")
 else :
    print("«",mot,"» est inconnu.")

Remarquons que ce code est exactement le même, que liste_mots soit une liste Python ou un ensemble Python (avec des temps de calcul bien différents comme on l'a dit).

Premiers dictionnaires Python

Nous proposons, comme premier exemple d'utilisation des dictionnaires Python, la définition d'un carnet d'adresses mails : les clefs du dictionnaire sont les noms des personnes et les contenus des cases correspondent aux mails.

# définition d'un dictionnaire vide
mails = {}

# définition du mail de Titi
mails['Titi'] = 'titi@univ.fr'

# définition du mail de Toto
mails['Toto']  = 'toto.machin@free.fr'

# affichage du mail de Toto
print('Mail de toto :',mails['Toto']);

Autre exemple de dictionnaire Python, l'implémentation d'un type abstrait « produit », ou « enregistrement » vu en cours d'algorithmique : ici, un type « livre ».

# définition d'un premier livre
livre1 = {}
livre1['titre'] = 'Apprendre Python'
livre1['année'] = 2010
print(livre1['titre'])

# autre syntaxe pour un second livre
livre2 = { 'titre': 'Algorithmique' , 'année': 1970 }

# procédure d'affichage dédiée à ce type livre
def affiche_livre (l):
  print('titre :',l['titre'])
  print('année :',l['année'])

# appel à la procédure sur le livre1
affiche_livre(livre1)

Opérations Python sur les dictionnaires

Nous retrouvons des fonctions déjà vues sur les listes :

• len : donne le nombre de couples dans le dictionnaire,
• del : permet de supprimer une entrée du dictionnaire.

D'autres méthodes Python sont spécifiques aux dictionnaires :

• keys : donne la liste des clefs d'un dictionnaire,
• values : donne la liste des valeurs d'un dictionnaire,
• items : fournit le contenu du dictionnaire sous la forme d'une liste de couples clef-valeur,
• get : extrait la valeur associée à une clef, comme le fait la notation crochets mais permet de prévoir une valeur par défaut pour le cas où la clef n'existe pas dans le dictionnaire.

# définition d'un dictionnaire
carnet = { 'Titi':'titi@univ.fr' , 'Toto':'toto.truc@free.fr' }

print(carnet.keys())   # ['Toto', 'Titi']
print(carnet.values()) # ['toto.truc@free.fr', 'titi@univ.fr'] 
print(carnet.items())  # [('Toto','toto.truc@free.fr') , ('Titi','titi@univ.fr')]

print(len(carnet)) # affiche la valeur 2

print(carnet['Toto']) # toto.truc@free.fr
print(carnet['Lulu']) # KeyError: 'Lulu'

print(carnet.get("Toto","contact inconnu")) # toto.truc@free.fr
print(carnet.get("Lulu","contact inconnu")) # contact inconnu

del(carnet['Toto']) # suppression des infos sur Toto
print(carnet.get("Toto","contact inconnu")) # contact inconnu

Voyons maintenant comment parcourir les dictionnaires Python.

# parcours des clefs et affichage des couples clef/valeur (nom/mail)
for nom in mails:
    print(nom,':',d[nom])

# parcours direct des couples clef/valeur (nom/mail)
for nom, mail in mails.items():
    print(nom,":",mail)

Terminons avec l'opérateur in qui permet ici de tester si une clef existe dans un dictionnaire.

"Titi" in carnet # True
"Lulu" in carnet # False

Comptage à l'aide des dictionnaires Python

Nous terminons avec une utilisation possible des dictionnaires Python : compter les occurrences des mots dans un corpus. Nous voulons donc obtenir un compteur associé à chaque mot. Nous utilisons à cette fin un dictionnaire Python avec les mots en clefs et les compteurs comme valeurs. À la rencontre d'un mot, nous allons mettre à jour son compteur comme suit.

# première occurrence    : on initialise la case à 1
# si la case existe déjà : on lui ajoute 1

compteurs[mot] = compteurs.get(mot,0) + 1

Comme nous le voyons, la méthode get permet en une même ligne de gérer deux situations distinctes :

• si le mot est rencontré pour la première fois, il est absent des clefs du dictionnaire Python, get fournit alors la valeur par défaut 0, à laquelle nous ajoutons 1 et finalement le dictionnaire mémorise que nous avons vu ce mot une fois ;
• lors des rencontres ultérieures du même mot, get trouve le mot parmi les clefs et fournit la valeur associée dans le dictionnaire, valeur qui est incrémentée pour noter que le mot a été vu une fois de plus.

Nous notons avec cet exemple que le get commence par un test d'existence semblable au in (sur les dictionnaires, donc notre comptage bénéficie de la rapidité de cet opérateur).