Les bases de Python : variables, listes, dictionnaires, conditions, boucles et fonctions

Python est un langage de programmation qui permet d’automatiser des tâches, d’analyser des données et de développer des applications. Apprendre les bases de Python, c’est comprendre comment écrire des instructions et vérifier ce qu’elles produisent. Dans cette leçon, vous partirez de valeurs simples pour apprendre à utiliser des variables, organiser des informations et contrôler l’exécution d’un programme.

Vous pouvez télécharger le notebook BasesPython.ipynb et son guide (ZIP) ou saisir les cellules au fil de la leçon. Décompressez l’archive dans projet-ia ; si vous avez déjà commencé un notebook du même nom, sauvegardez-le avant l’extraction. Les valeurs utilisées proviennent de Student Performance Factors et sont fournies directement dans les cellules : aucun fichier Excel n’est nécessaire pour réaliser ces exercices.

Bases de Python : variables et types

Une variable est un nom auquel vous associez une valeur. L’instruction score_examen = 67 se lit « associer la valeur 67 au nom score_examen ». Le signe = réalise cette affectation ; il ne teste pas l’égalité. Un nom permet ensuite de retrouver cette valeur sans la recopier dans chaque calcul.

Une valeur possède un type, qui détermine les opérations possibles. Voici quatre types courants, décrits dans la documentation des types Python.

# Définir les valeurs utilisées dans cet exemple
score_examen = 67
presence = 84
implication_parentale = "Low"

# Convertir le score entier en nombre décimal
score_decimal = float(score_examen)

# Afficher les valeurs et leurs types
print(score_examen, type(score_examen).__name__)
print(score_decimal, type(score_decimal).__name__)
print(implication_parentale, type(implication_parentale).__name__)

67 int
67.0 float
Low str

Ici, 67 et 84 sont des entiers. L’appel float(score_examen) convertit le score en flottant : 67.0 représente la même quantité avec un autre type. Dans le code Python, la partie décimale s’écrit avec un point. Les guillemets font de "Low" du texte.

print affiche une valeur sous la cellule. type renseigne son type ; le suffixe .__name__ donne ici le nom court de ce type. Ces deux opérations sont des fonctions déjà disponibles dans Python : vous les appelez avec des parenthèses. La documentation des fonctions intégrées précise leur rôle.

Choisissez des noms qui indiquent ce que la valeur représente, comme score_examen ou presence. Ils sont sensibles aux majuscules : presence et Presence sont deux noms différents. Un nom ne commence pas par un chiffre. La convention usuelle utilise des minuscules et des traits de soulignement pour séparer les mots, conformément à la PEP 8. Une nouvelle affectation au même nom remplace sa valeur ; il n’est pas nécessaire de déclarer son type à l’avance.

Effectuer des calculs avec les nombres

Python utilise + pour additionner, - pour soustraire, * pour multiplier et / pour diviser. La division avec / donne un float, même lorsque le résultat mathématique est entier.

# Diviser le score par 10
print("Score divisé par 10 :", score_examen / 10)

# Effectuer la division entière
print("Quotient entier :", score_examen // 10)

# Calculer le reste de la division
print("Reste :", score_examen % 10)

# Élever le score au carré
print("Score au carré :", score_examen ** 2)

Score divisé par 10 : 6.7
Quotient entier : 6
Reste : 7
Score au carré : 4489

67 / 10 donne 6.7. Les opérateurs // et % donnent respectivement le quotient arrondi vers le bas et le reste d’une division : avec ces entiers positifs, 67 contient six dizaines et un reste de sept. ** élève un nombre à une puissance ; le carré de 67 vaut 4 489.

Les opérations numériques du tutoriel Python présentent ces règles. Un commentaire commence par # : Python ignore ce qui le suit sur cette ligne. Vous pouvez ainsi expliquer un calcul sans ajouter de sortie.

Manipuler les chaînes de caractères

Une chaîne de caractères, ou str, contient du texte entre guillemets simples ou doubles. Les catégories du fichier, comme Low, sont des textes, même si elles décrivent une caractéristique d’une ligne. Une chaîne n’est donc pas un nombre sur lequel on peut directement calculer une moyenne.

# Convertir le texte en minuscules
print("En minuscules :", implication_parentale.lower())

# Compter les caractères du texte
print("Nombre de caractères :", len(implication_parentale))

# Convertir le score en chaîne de caractères
score_texte = str(score_examen)
print("Score converti :", score_texte, type(score_texte).__name__)

# Assembler le libellé et le score converti
print("Score : " + score_texte)

En minuscules : low
Nombre de caractères : 3
Score converti : 67 str
Score : 67

len compte les caractères de la chaîne. lower() renvoie une nouvelle chaîne en minuscules : c’est une méthode, une opération appelée à partir d’une valeur avec le point. Les chaînes sont immuables : cette méthode ne modifie pas la chaîne d’origine.

Avec deux chaînes, + réalise une concaténation, c’est-à-dire qu’il les assemble. str(score_examen) convertit le score en texte pour l’insérer dans cette expression. À l’inverse, int et float peuvent convertir un texte numérique compatible en nombre ; un texte comme Low ne peut pas devenir un entier. Les opérations sur les chaînes décrivent ces comportements.

Présenter les résultats avec une f-string

Une f-string est une chaîne précédée de f. Les expressions placées entre accolades sont évaluées puis insérées dans le texte. Cela évite d’assembler plusieurs morceaux avec + et de convertir chaque nombre explicitement.

# Insérer les valeurs dans une chaîne formatée
print(f"Premier élève : score {score_examen}, présence {presence} %.")

# Afficher le résultat avec une décimale
print(f"Score divisé par 10 : {score_examen / 10:.1f}")

Premier élève : score 67, présence 84 %.
Score divisé par 10 : 6.7

Dans {score_examen / 10:.1f}, les deux-points introduisent un format : .1f affiche une décimale. Le calcul produit ici 6.7. Le symbole % placé après {presence} dans le premier message est simplement du texte : il indique l’unité du taux 84, sans effectuer une conversion. La présentation ne modifie pas les valeurs conservées dans les variables. Le tutoriel des chaînes formatées explique cette notation.

Les listes : conserver plusieurs valeurs dans un ordre

Une liste rassemble des valeurs dans un ordre donné. Elle s’écrit entre crochets, avec des virgules entre les éléments. Pour travailler sur plusieurs scores, nous reprenons les cinq premières valeurs de la colonne Exam_Score : 67, 61, 74, 71 et 70. Nous conserverons cet ordre dans les exemples et dans l’exercice final.

# Créer une liste de scores
notes_examens = [67, 61, 74, 71, 70]

print("Scores :", notes_examens)

# Lire le premier élément, à l’indice 0
print("Premier :", notes_examens[0])

# Lire le dernier élément avec un indice négatif
print("Dernier :", notes_examens[-1])

# Sélectionner les indices 1 et 2 ; la borne 3 est exclue
print("Tranche [1:3] :", notes_examens[1:3])

# Compter les éléments de la liste
print("Nombre de scores :", len(notes_examens))

Scores : [67, 61, 74, 71, 70]
Premier : 67
Dernier : 70
Tranche [1:3] : [61, 74]
Nombre de scores : 5

L’indice est la position d’un élément. Les cinq éléments ont ici les indices 0 à 4. notes_examens[-1] désigne le dernier ; les indices négatifs comptent depuis la fin. len donne le nombre d’éléments, donc 5. notes_examens[1:3] est une tranche : une nouvelle liste allant de l’indice 1 inclus à l’indice 3 exclu, soit [61, 74]. Voir les listes du tutoriel Python.

Une liste est modifiable. La méthode append ajoute un élément à la fin. Pour préserver les cinq scores des exemples suivants, appliquons-la à une copie. Le score 71 ajouté ci-dessous correspond à la sixième ligne du classeur.

# Créer une copie indépendante de la liste
notes_etendues = notes_examens.copy()
sixieme_score = 71

# Ajouter un score à la copie
notes_etendues.append(sixieme_score)

# Comparer la copie et la liste d’origine
print("Six scores :", notes_etendues)
print("Cinq scores d'origine :", notes_examens)

# Obtenir une liste triée sans modifier la liste d’origine
print("Scores triés :", sorted(notes_examens))

Six scores : [67, 61, 74, 71, 70, 71]
Cinq scores d'origine : [67, 61, 74, 71, 70]
Scores triés : [61, 67, 70, 71, 74]

copy() crée ici une nouvelle liste de nombres. sorted renvoie aussi une nouvelle liste, dans l’ordre croissant, sans modifier notes_examens. Pour inverser l’ordre (décroissant ) , nous pouvons ajouter le paramètre reverse=True de la fonction sorted ansi : print(« Scores triés (décroissant) : », sorted(notes_examens, reverse=True))

Une simple affectation autre_liste = notes_examens aurait donné deux noms à la même liste : ajouter un élément par l’un des noms serait alors visible par l’autre. Cette différence entre une copie et une autre référence devient utile dès que vous transformez des données. Les méthodes des listes précisent les opérations disponibles.

Les dictionnaires : retrouver une information par sa clé

Un dictionnaire associe des clés à des valeurs. Les paires s’écrivent entre accolades ; les deux-points séparent chaque clé de sa valeur. Au lieu de demander « la valeur en position 0 », vous pouvez demander « la valeur associée à Attendance ». Cette organisation convient pour représenter plusieurs informations de la première ligne.

# Regrouper les informations dans un dictionnaire
eleve = {
    "Hours_Studied": 23,
    "Attendance": presence,
    "Exam_Score": score_examen,
}
print(eleve)

# Lire la valeur associée à la clé Exam_Score
print("Score :", eleve["Exam_Score"])

# Prévoir une valeur de remplacement pour une clé absente
print("Identifiant :", eleve.get("Student_ID", "Absent du fichier"))

{'Hours_Studied': 23, 'Attendance': 84, 'Exam_Score': 67}
Score : 67
Identifiant : Absent du fichier

La clé "Exam_Score" donne accès à 67. get fournit ici un texte de remplacement pour la clé absente "Student_ID" qui n’existe pas dans le dictionnaire . Les clés sont uniques : affecter une valeur à une clé déjà présente remplace la valeur associée. Python conserve leur ordre d’insertion. Voir la présentation des dictionnaires.

Comparer des valeurs et combiner des tests

Une comparaison produit un booléen : True si le test est vrai, False sinon. == teste l’égalité, != la différence, > et < un ordre strict, >= et <= un ordre qui inclut l’égalité. Ne confondez pas == avec le signe = de l’affectation.

# Comparer le score au seuil de 70
atteint_seuil = score_examen >= 70

# Comparer la présence au seuil de 80
presence_elevee = presence >= 80

print("Score >= 70 :", atteint_seuil)
print("Présence >= 80 :", presence_elevee)

# Vérifier que les deux conditions sont vraies
print("Les deux :", atteint_seuil and presence_elevee)

# Vérifier qu’au moins une condition est vraie
print("Au moins une :", atteint_seuil or presence_elevee)

# Inverser le résultat de la comparaison du score
print("Score < 70 :", not atteint_seuil)

Score >= 70 : False
Présence >= 80 : True
Les deux : False
Au moins une : True
Score < 70 : True

67 n’est pas au moins égal à 70 : le premier test donne False. 84 est au moins égal à 80 : le deuxième donne True. Les opérateurs logiques permettent de combiner ces résultats. and demande que les deux tests soient vrais ; or demande qu’au moins l’un le soit ; not inverse la valeur de vérité. La documentation des opérations booléennes présente leur fonctionnement ; utilisez des parenthèses si plusieurs tests combinés deviennent difficiles à lire.

Choisir des instructions avec if, elif et else

Une condition choisit les instructions à exécuter selon le résultat d’un test. if examine un premier cas ; elif examine un autre si les précédents sont faux ; else traite les cas restants. Nous répartissons le score dans trois intervalles à l’aide des seuils 70 et 60, choisis pour cet exercice.

# Choisir la tranche du score avec if, elif et else
if score_examen >= 70:
    tranche_score = "70 ou plus"
elif score_examen >= 60:
    tranche_score = "Entre 60 et 69"
else:
    tranche_score = "Sous 60"

# Afficher la tranche retenue
print(tranche_score)

Entre 60 et 69

Python teste dans l’ordre et exécute le premier bloc dont la condition est vraie. Commencer par score_examen >= 60 inclurait aussi les scores de 70 et plus dans cette première branche : l’ordre fait partie de la règle. Les instructions if du tutoriel Python expliquent ce fonctionnement.

Les deux-points(:) annoncent un bloc. L’indentation, c’est-à-dire les espaces au début des lignes, indique quelles instructions lui appartiennent. Utilisez quatre espaces, conformément à la PEP 8, et gardez la même indentation à l’intérieur du bloc. Le print final revient au bord gauche : il s’exécute après le choix de l’intervalle.

Répéter des instructions avec les boucles

Parcourir les valeurs avec for

Une boucle répète des instructions. for parcourt les éléments d’une collection. À chaque tour, le nom score reçoit la valeur suivante de la liste, jusqu’à la dernière. Voici comment additionner les cinq scores sans écrire cinq instructions séparées.

# Initialiser le total avant la boucle
total = 0

# Parcourir les scores et les ajouter au total
for score in notes_examens:
    total += score
    print("Score :", score)

print("Total :", total)

# Diviser le total par le nombre de scores pour calculer la moyenne
print("Moyenne :", total / len(notes_examens))

Score : 67
Score : 61
Score : 74
Score : 71
Score : 70
Total : 343
Moyenne : 68.6

total vaut 0 au départ. total += score ajoute la valeur courante au total déjà obtenu ; cette écriture équivaut à total = total + score. Après cinq tours, le total vaut 343. Le calcul total / len(notes_examens) le divise par le nombre de scores et donne leur moyenne : 68,6. Python propose aussi sum pour additionner directement les valeurs d’une liste, comme dans la fonction qui suivra.

Retrouver à la fois l’indice et la valeur

Si vous avez besoin de la position en plus de la valeur, enumerate fournit les deux à chaque tour sous la forme d’un couple appelé tuple. Un tuple est une collection ordonnée dont les éléments ne sont pas modifiables. Les deux noms séparés par une virgule reçoivent respectivement l’indice et le score : cette répartition s’appelle le décompactage. L’indice commence à 0 par défaut.

# Parcourir chaque score avec son indice
for indice, score in enumerate(notes_examens):
    print(f"Indice {indice} : {score}")

Indice 0 : 67
Indice 1 : 61
Indice 2 : 74
Indice 3 : 71
Indice 4 : 70

La boucle produit cinq lignes, avec les indices 0 à 4. Vous n’avez pas à tenir un compteur à jour pour cette tâche. enumerate est une fonction intégrée de Python, comme len et sum.

Répéter tant qu’une condition reste vraie

while répète un bloc tant qu’une condition reste vraie. Nous pouvons aussi parcourir les cinq valeurs à l’aide d’un indice, en le faisant avancer nous-mêmes.

# Commencer au premier indice de la liste
indice = 0

# Continuer tant que l’indice reste dans la liste
while indice < len(notes_examens):
    print(f"Indice {indice} : {notes_examens[indice]}")
    # Avancer à l’indice suivant pour terminer la boucle
    indice += 1

Indice 0 : 67
Indice 1 : 61
Indice 2 : 74
Indice 3 : 71
Indice 4 : 70

indice += 1 fait avancer l’indice jusqu’à 5. Le test indice < len(notes_examens) devient alors faux et la boucle s’arrête. Oublier cette augmentation produirait une boucle sans fin. Interrompez alors la cellule avec le bouton d’arrêt du notebook. Pour parcourir une liste, for reste plus direct ; while est utile lorsque l’arrêt dépend d’une condition qui évolue. Les deux formes figurent dans la documentation des structures de contrôle.

Les fonctions : nommer un calcul réutilisable

Une fonction regroupe des instructions sous un nom. Elle reçoit ici une liste par son paramètre scores et transmet le résultat à l’appelant avec return. def crée la définition ; le calcul n’est effectué que lorsque nous appelons la fonction avec une valeur entre parenthèses.

# Définir une fonction qui calcule la moyenne d’une liste non vide
def calculer_moyenne(scores):
    """Renvoie la moyenne d'une liste non vide."""
    return sum(scores) / len(scores)

# Appeler la fonction avec la liste de scores
moyenne = calculer_moyenne(notes_examens)
print("Moyenne :", moyenne)

# Vérifier le type du résultat
print("Type :", type(moyenne).__name__)

Moyenne : 68.6
Type : float

Le paramètre est le nom inscrit dans la définition ; l’argument est la valeur fournie lors de l’appel, ici la liste notes_examens. La phrase entre triples guillemets est une docstring : elle décrit le rôle de la fonction. Le nom scores est local à la fonction ; il ne remplace pas notes_examens dans le reste du notebook. Pour aller plus loin , consultez la documentation des fonctions .

La fonction suppose une liste non vide de nombres : avec une liste vide, len(scores) vaut 0 et la division échoue. Cette condition d’utilisation doit rester visible. return fournit une valeur réutilisable, tandis que print affiche un message. Ici, nous rangeons le résultat dans moyenne avant de l’afficher.

Comprendre les nombres à virgule et l’arrondi

Un float représente généralement un nombre par une approximation binaire. Certaines valeurs décimales ne sont donc pas stockées exactement. Pour le constater dans notre moyenne, demandons plus de chiffres que ceux habituellement affichés.

# Afficher la moyenne avec 17 décimales
print(f"Moyenne à 17 décimales : {moyenne:.17f}")

# Limiter l’affichage à deux décimales
print(f"Moyenne à 2 décimales : {moyenne:.2f}")

# Arrondir la valeur à une décimale
print("Arrondi à une décimale :", round(moyenne, 1))

Moyenne à 17 décimales : 68.59999999999999432
Moyenne à 2 décimales : 68.60
Arrondi à une décimale : 68.6

Le résultat mathématique vaut 68,6, mais son écriture interne approchée devient visible avec de nombreuses décimales. .2f restitue un affichage lisible, 68.60 ; il ne rend pas la représentation interne exacte. La documentation sur les nombres à virgule flottante explique pourquoi ce phénomène est normal.

round donne une valeur arrondie. Lorsqu’un nombre est exactement à mi-chemin entre deux résultats possibles, Python choisit le résultat pair. Il faut distinguer cette règle de l’approximation du nombre initial. Pour la suite du parcours, retenez surtout qu’un arrondi d’affichage sert à la lecture et que la précision requise dépend du calcul ; nous n’allons pas arrondir chaque étape intermédiaire. Voir la définition de round.

Exercice corrigé : résumer cinq scores avec Python

Dans une nouvelle cellule de BasesPython.ipynb, utilisez notes_examens et calculer_moyenne pour :

1. afficher le nombre de scores, leur moyenne avec une décimale et leur maximum ;
2. construire avec for et if la liste des scores au moins égaux à 70 ;
3. afficher cette liste et le nombre de valeurs qu’elle contient.

max renvoie la plus grande valeur de cette liste non vide. Vous devez travailler sur les cinq valeurs de notes_examens, sans ajouter la sixième valeur utilisée pour illustrer append. Cherchez d’abord votre solution. La correction figure aussi dans la dernière cellule du notebook téléchargeable.

# Préparer une liste pour les scores retenus
scores_retenus = []

# Ne retenir que les scores supérieurs ou égaux à 70
for score in notes_examens:
    if score >= 70:
        scores_retenus.append(score)

# Afficher les statistiques et les scores retenus
print("Nombre de scores :", len(notes_examens))
print(f"Moyenne : {calculer_moyenne(notes_examens):.1f}")
print("Maximum :", max(notes_examens))
print("Scores >= 70 :", scores_retenus)
print("Nombre de scores >= 70 :", len(scores_retenus))

Nombre de scores : 5
Moyenne : 68.6
Maximum : 74
Scores >= 70 : [74, 71, 70]
Nombre de scores >= 70 : 3

Reconnaître et corriger les erreurs fréquentes

Une erreur s’affiche sous la cellule qui l’a produite. Lisez d’abord sa dernière ligne : elle indique le type d’erreur et un message. Remontez ensuite à la ligne de code désignée. Corrigez la cause et relancez la cellule avant de poursuivre avec des variables qui n’ont peut-être pas été créées.

NameError : une variable n’existe pas dans le noyau

Si notes_examens ou calculer_moyenne n’est pas défini, vérifiez l’orthographe et exécutez d’abord la cellule qui le crée. Après un redémarrage, les anciennes sorties peuvent rester affichées alors que les variables ont disparu de la mémoire. Relancez les cellules de haut en bas.

TypeError : texte et nombres ont été mélangés

"Moyenne : " + moyenne tente d’assembler une chaîne et un nombre sans conversion. Utilisez une f-string, comme print(f"Moyenne : {moyenne:.1f}"), ou convertissez le nombre avec str. Un texte ne devient pas numérique simplement parce qu’il ressemble à un nombre : contrôlez son type et son contenu avant de calculer.

IndexError et KeyError : position ou clé absente

Pour une liste de cinq éléments, les indices à partir de zéro vont de 0 à 4 : notes_examens[5] provoque une IndexError. Les indices négatifs permettent de compter depuis la fin ; utilisez notes_examens[-1] pour le dernier élément. Dans un dictionnaire, eleve["attendance"] échoue avec une KeyError si la clé est "Attendance" : les majuscules comptent. Si une clé peut manquer, get permet de fournir une valeur de remplacement.

IndentationError : un bloc est mal délimité

Après if, for, while ou def, placez les instructions du bloc quatre espaces plus à droite. Vérifiez les deux-points et évitez de mélanger espaces et tabulations. Une instruction revenue au bord gauche n’appartient plus au bloc.

À retenir et prochaine étape du projet

Vous avez commencé par nommer une valeur et comprendre son type, puis appris à calculer et à présenter un résultat. Les listes gardent un ordre ; les dictionnaires relient des clés à des informations. Les comparaisons produisent des booléens, les conditions choisissent des instructions, les boucles les répètent et les fonctions regroupent un calcul réutilisable. L’exercice final réunit ces notions pour résumer et filtrer une liste de scores.

Enregistrez BasesPython.ipynb après avoir redémarré le noyau et exécuté toutes ses cellules. Vous devez retrouver les cinq scores et la moyenne 68.6. Les sorties présentées ont été calculées dans un noyau neuf avec Python 3.14.8. Cette leçon utilise uniquement les fonctions et les types intégrés de Python : aucune bibliothèque supplémentaire ni lecture de fichier n’est nécessaire.

Ressources pour poursuivre

• Pour revoir une instruction : le tutoriel officiel de Python, notamment les nombres, les structures de données et les fonctions.
• Pour retrouver l’origine des valeurs des exemples : Student Performance Factors — Lai Ng., Kaggle.