Lernzettel: Maîtriser la gestion des variables en Python

📋 Plan du Cours

1. Définition et rôle des variables en Python
2. Syntaxe pour définir une variable en Python
3. Exemple d'exécution et affichage des variables
4. Règles et bonnes pratiques de nommage des variables en Python
5. Sensibilité à la casse des noms de variables
6. Erreurs fréquentes liées aux variables non définies
7. Exercice pratique de création et affichage de variable
8. Utilité et importance des variables dans la programmation

📖 1. Définition et rôle des variables en Python

🔑 Notions clés & Définitions

• Variable : Un conteneur nommé qui stocke une seule valeur à la fois, cette valeur pouvant changer au cours de l'exécution du programme.

📝 Points essentiels

• La valeur d'une variable peut changer au cours de l'exécution du programme.
• Chaque variable est identifiée par un nom unique dans le programme.

💡 À retenir

Les variables sont des entités dynamiques essentielles pour stocker et manipuler des données dans un programme.

📖 2. Syntaxe pour définir une variable en Python

🔑 Notions clés & Définitions

• Variable : variable est une zone de stockage dans la mémoire qui permet de conserver une valeur, associée à un nom choisi par l’utilisateur. La variable sert à représenter une donnée dont la valeur peut évoluer ou être réutilisée dans le programme.

• Expression d'assignation : expression d'assignation est une instruction qui associe un nom de variable à une valeur spécifique. Elle se compose du nom de la variable, suivi du symbole égal (=), puis de la valeur à stocker. Cette syntaxe établit une liaison entre le nom et la valeur dans la mémoire de l’interpréteur Python.

📝 Points essentiels

• Pour définir une variable, on écrit : nom_de_la_variable = valeur_de_la_variable. Cela signifie que le nom choisi pour la variable doit respecter la syntaxe propre à Python, c’est-à-dire qu’il ne doit contenir aucun caractère spécial autre que le soulignement (_). Par exemple, un nom valide pourrait être age, nom_utilisateur, ou encore score_final. La valeur assignée peut être de tout type supporté par Python, comme un nombre, une chaîne de caractères ou une autre variable.

• La syntaxe d'assignation associe un nom à une valeur en utilisant le symbole égal (=). La partie à gauche du symbole est le nom de la variable, qui doit respecter les règles de nommage (pas commencer par un chiffre, pas contenir d’espaces, etc.), tandis que la partie à droite est la valeur que l’on souhaite stocker. Par exemple, écrire x = 10 crée une variable x contenant la valeur 10. La syntaxe doit respecter cette structure pour que l’interpréteur Python comprenne qu’il s’agit d’une opération d’assignation.

• La définition d'une variable crée une liaison entre le nom et la valeur dans la mémoire. Cela signifie que, après l’assignation, chaque fois que le nom de la variable est utilisé, Python fait référence à la valeur qui lui est associée. Par exemple, si l’on écrit nom = "Alice", alors chaque utilisation de nom dans le programme renverra la chaîne "Alice". La liaison est dynamique : si l’on réaffecte une nouvelle valeur à la variable, la liaison est mise à jour, et le nom pointe désormais vers cette nouvelle valeur.

💡 À retenir

Maîtriser la syntaxe d’assignation simple en Python consiste à associer un nom de variable à une valeur en utilisant le symbole égal, en respectant les règles de nommage. Cette opération fondamentale permet de stocker et de manipuler des données dans le programme.

📖 3. Exemple d'exécution et affichage des variables

🔑 Notions clés & Définitions

• Instruction print : instruction qui affiche la valeur actuelle d'une variable dans la console. Elle permet de visualiser le contenu d'une variable à un moment précis de l'exécution du programme, facilitant ainsi le suivi de l'évolution des données.

• Réaffectation de variable : opération consistant à assigner une nouvelle valeur à une variable déjà existante. Elle modifie la valeur stockée dans la variable, sans créer une nouvelle variable, ce qui permet de faire évoluer les données au cours du programme.

• Exécution séquentielle : mode d'exécution où le programme suit l'ordre des instructions telles qu'elles sont écrites. Chaque instruction est exécutée l'une après l'autre, ce qui influence directement les valeurs affichées ou modifiées à chaque étape.

📝 Points essentiels

• La fonction print() affiche la valeur actuelle d'une variable dans la console, permettant de voir le contenu précis de cette variable à un instant donné. Lorsqu'une variable est créée ou modifiée, l'instruction print() peut être utilisée pour vérifier cette valeur.

• Une variable peut être réaffectée à une nouvelle valeur à tout moment dans le programme. Cela signifie qu'il est possible de changer la donnée stockée dans une variable déjà existante, sans en créer une nouvelle. Par exemple, après avoir assigné une valeur à une variable, on peut lui donner une nouvelle valeur, et cette nouvelle valeur sera celle affichée lors du prochain print().

• L'exécution du programme suit l'ordre des instructions, affectant ainsi les valeurs affichées ou modifiées. Si une variable est réaffectée avant un print(), c'est la nouvelle valeur qui sera affichée. La séquence des opérations détermine la progression des valeurs dans le programme, permettant de suivre comment les variables évoluent au fil de l'exécution.

💡 À retenir

Visualiser concrètement comment les variables évoluent et s'affichent lors de l'exécution d'un programme permet de mieux comprendre leur rôle et leur importance. La lecture des valeurs affichées par print() à chaque étape offre une représentation claire de la dynamique des données dans le programme.

📖 4. Règles et bonnes pratiques de nommage des variables en Python

🔑 Notions clés & Définitions

• Noms de variables : désignent les identifiants utilisés pour représenter des données ou des objets dans le code Python. Ils doivent respecter des règles précises pour assurer leur validité et leur lisibilité.
• Bonnes pratiques de nommage : ensemble de recommandations visant à choisir des noms de variables explicites, lisibles et cohérents, facilitant la compréhension et la maintenance du code.
• Convention snake_case : méthode de nommage où les mots sont séparés par des underscores (_), favorisée en Python pour améliorer la lisibilité des noms de variables.

📝 Points essentiels

• Les noms de variables doivent contenir uniquement des lettres (minuscules ou majuscules), des chiffres et des underscores (_). Cela signifie que tout autre caractère, comme des espaces, des tirets ou des symboles spéciaux, est interdit. Par exemple, ma_variable1 est valide, tandis que ma-variable ou ma variable ne le sont pas.
• Un nom de variable doit commencer par une lettre ou un underscore (_). Il ne peut pas débuter par un chiffre, ce qui évite les ambiguïtés avec les nombres ou les constantes numériques. Par exemple, _compteur ou nombre1 sont corrects, mais 1compteur ne l’est pas.
• Il est recommandé d’utiliser des noms explicites, c’est-à-dire des noms qui décrivent clairement la fonction ou la nature de la variable. Par exemple, total_prix est plus compréhensible que tp.
• Pour améliorer la lisibilité, il est conseillé de séparer les mots dans un nom de variable par des underscores (_). Par exemple, nombre_utilisateurs est préféré à nombreUtilisateurs, car la séparation par underscores facilite la lecture.
• En plus des règles obligatoires, il existe des bonnes pratiques non obligatoires mais fortement recommandées, telles que l’utilisation de noms explicites et la cohérence dans le style de nommage tout au long du code.

💡 À retenir

Adopter des noms de variables clairs, conformes aux règles et à la convention snake_case permet d’écrire un code Python plus lisible, compréhensible et facile à maintenir.

📖 5. Sensibilité à la casse des noms de variables

🔑 Notions clés & Définitions

• Sensibilité à la casse : caractéristique du langage de programmation qui fait que la reconnaissance et l’identification d’un nom de variable dépendent de la différence entre les lettres majuscules et minuscules. En d’autres termes, la casse influence directement l’unicité et la distinction des noms dans le code.

• Différenciation des variables par casse : principe selon lequel deux noms de variables qui diffèrent uniquement par leur utilisation de majuscules ou minuscules sont considérés comme deux entités distinctes. Par exemple, 'age' et 'AGE' désignent deux variables différentes, ce qui implique que leur contenu, leur déclaration et leur utilisation doivent être séparément gérés.

• Nom distinct selon majuscules/minuscules : règle selon laquelle la reconnaissance d’un nom de variable est strictement liée à sa casse. La modification de la casse d’un nom modifie son identité dans le programme, ce qui peut entraîner des erreurs si cette distinction n’est pas respectée.

📝 Points essentiels

• Les noms de variables en Python sont sensibles à la casse : cela signifie que 'age' et 'AGE' sont deux variables différentes. Lors de leur déclaration ou de leur utilisation, il faut faire attention à la manière dont on écrit ces noms, car une erreur de casse peut conduire à des erreurs d’exécution ou à des valeurs inattendues. Par exemple, si l’on définit une variable 'age' puis qu’on tente de l’utiliser sous la forme 'AGE', le programme ne reconnaîtra pas cette dernière comme étant la même variable, ce qui peut provoquer une erreur ou un comportement erroné.

• Il faut faire attention à la cohérence des majuscules et minuscules lors de l’utilisation des variables : utiliser systématiquement la même casse pour nommer une variable permet d’éviter des confusions et des erreurs. Par exemple, si l’on choisit d’écrire 'nombre_de_chats' lors de la déclaration, il faut continuer à utiliser cette même forme dans tout le programme. La cohérence facilite la lecture, la maintenance et la correction du code.

• La casse influence la reconnaissance et la liaison des noms dans le programme : c’est-à-dire que la manière dont les noms sont écrits détermine leur identification par l’interpréteur ou le compilateur. Une différence de casse peut faire que deux noms, qui semblent similaires, soient traités comme deux variables distinctes, ce qui peut impacter la logique du programme, notamment lors de l’affectation ou de la récupération de valeurs.

💡 À retenir

La casse des lettres dans les noms de variables modifie leur identité et impacte directement le comportement du programme. Il est essentiel de respecter la cohérence de la casse pour assurer une reconnaissance correcte des variables et éviter des erreurs difficiles à diagnostiquer.

📖 6. Erreurs fréquentes liées aux variables non définies

🔑 Notions clés & Définitions

• Variable non définie : catégorie de variable qui n’a pas été déclarée ou initialisée avant son utilisation dans le programme. Elle n’a pas de valeur assignée, ce qui empêche le programme de connaître son contenu ou son type.

• Erreur NameError : erreur spécifique qui survient lorsqu’une variable non définie est appelée ou utilisée dans le code. Elle indique que le programme ne peut pas reconnaître la variable car elle n’a pas été déclarée ou initialisée au préalable.

• Réinitialisation des variables : processus par lequel toutes les variables déclarées dans un programme sont remises à zéro ou à leur état initial lors de chaque relance ou exécution du programme. Cela signifie que toute variable non redéfinie après la réinitialisation entraîne une erreur si elle est utilisée sans nouvelle déclaration.

📝 Points essentiels

• Utiliser une variable non définie génère une erreur NameError, qui indique que le programme ne peut pas continuer car il ne connaît pas la variable invoquée. Par exemple, si l’on écrit x = x + 1 sans avoir préalablement défini x, le programme renverra une erreur NameError. Il est donc crucial de s’assurer qu’une variable est déclarée et initialisée avant toute utilisation. Cela implique de vérifier que la déclaration de la variable a été effectuée dans le code, par exemple par une instruction du type x = 0 ou toute autre valeur pertinente.

• Il faut également veiller à ce que chaque variable utilisée ait été déclarée dans le contexte actuel du programme. Si une variable est utilisée dans une fonction ou un bloc de code, elle doit être déclarée dans cette même portée ou être accessible par une déclaration préalable.

• Les variables sont réinitialisées à chaque relance du programme, ce qui signifie que leur état ou leur valeur précédente est perdu. Si une variable n’est pas redéfinie après chaque relance, son utilisation ultérieure entraînera une erreur. Par exemple, si dans un script on définit compteur = 10 puis que le programme est relancé, la variable compteur n’aura plus de valeur sauf si elle est redéfinie explicitement dans le nouveau lancement.

• Il est donc essentiel de rappeler que toute variable utilisée doit être déclarée et initialisée dans chaque nouvelle exécution pour éviter des erreurs dues à une variable non définie. La pratique recommandée consiste à toujours vérifier que la variable a été déclarée avant de l’utiliser, notamment en utilisant des conditions ou en structurant le code pour que chaque variable soit initialisée dans le même bloc ou la même fonction.

💡 À retenir

La reconnaissance et la prévention des erreurs liées aux variables non définies reposent sur la vérification systématique que chaque variable est déclarée et initialisée avant utilisation, en tenant compte du fait que toutes les variables sont réinitialisées à chaque relance du programme.

📖 7. Exercice pratique de création et affichage de variable

🔑 Notions clés & Définitions

• Exercice de programmation : démarche permettant de mettre en pratique des concepts informatiques en écrivant un code qui réalise une tâche spécifique, ici la création et l’affichage d’une variable. Il s’agit d’un exercice pratique visant à appliquer concrètement les notions de base de la programmation.

• Création de variable : opération consistant à réserver un espace mémoire pour stocker une donnée, en lui attribuant un nom représentatif. La variable sert à conserver une valeur, ici un nombre, pour pouvoir la manipuler ou l’afficher par la suite. La sélection d’un nom clair et cohérent est essentielle pour la compréhension du programme, par exemple choisir un nom descriptif comme "nombre_de_freres_sœurs" plutôt qu’un nom vague ou ambigu.

• Affichage de variable : étape qui consiste à présenter la valeur stockée dans une variable à l’aide d’une instruction spécifique, comme print(), pour vérifier ou montrer cette valeur. L’affichage permet de confirmer que la variable contient la donnée attendue et facilite le débogage ou la présentation des résultats dans le programme.

📝 Points essentiels

• L’exercice demande de créer une variable destinée à stocker un nombre, par exemple le nombre de frères et sœurs. La démarche commence par le choix d’un nom clair et cohérent pour cette variable, évitant toute ambiguïté ou confusion. Une fois la variable déclarée et initialisée avec une valeur numérique, il faut utiliser la fonction d’affichage, généralement print(), pour afficher la valeur de cette variable. Cela permet de vérifier que la variable a bien été créée et qu’elle contient la donnée correcte. La simplicité de cet exercice repose sur la compréhension que la création de variable consiste à lui donner un nom et une valeur, puis à utiliser une instruction d’affichage pour la rendre visible à l’écran. La vérification de la valeur affichée est une étape essentielle pour s’assurer du bon fonctionnement du code.

💡 À retenir

L’application concrète de la création et de l’affichage de variables permet de renforcer la compréhension des notions fondamentales en programmation. En manipulant directement ces opérations, l’étudiant apprend à stocker, nommer et vérifier des données dans un programme.

📖 8. Utilité et importance des variables dans la programmation

🔑 Notions clés & Définitions

• Variables : éléments fondamentaux qui permettent de stocker des données dans un programme, facilitant leur manipulation et leur utilisation ultérieure. Elles sont caractérisées par un nom clair et cohérent, et peuvent contenir différents types de valeurs, comme des nombres ou du texte. Leur rôle est d’assurer la conservation temporaire d’informations pour permettre leur traitement ou leur affichage.

📝 Points essentiels

• Les variables jouent un rôle central en programmation en permettant de stocker et de manipuler des données dynamiques. Par exemple, dans un programme Python, on peut créer une variable pour enregistrer le nombre de frères et sœurs d’une personne, puis l’afficher ou la modifier selon les besoins. Cette capacité à conserver une valeur dans une variable est essentielle pour réaliser des opérations interactives ou conditionnelles. Les variables sont indispensables pour écrire des programmes flexibles, car elles évitent la nécessité de changer manuellement les valeurs dans le code à chaque modification. Elles facilitent également la réutilisation des valeurs, ce qui permet de modifier une donnée en un seul endroit, sans avoir à parcourir tout le programme pour faire des ajustements. La manipulation des données via des variables contribue à rendre le code plus lisible, plus efficace et plus adaptable à différents scénarios.

💡 À retenir

Les variables constituent la base de toute programmation efficace, car elles permettent de stocker, modifier et réutiliser facilement des données dynamiques, rendant ainsi les programmes plus flexibles et interactifs.

📊 Tableaux de Synthèse

Comparaison des règles de nommage des variables

Critère	Règles
Caractères autorisés	Lettres, chiffres, underscores (_), pas d'espaces, pas de caractères spéciaux
Début du nom	Une lettre ou underscore (_), pas un chiffre
Lisibilité	Utiliser des noms explicites, snake_case pour séparer les mots

⚠️ Pièges & Confusions Fréquentes

1. Utiliser des noms de variables qui commencent par un chiffre.
2. Oublier de déclarer une variable avant de l'utiliser, entraînant une erreur NameError.
3. Utiliser des noms de variables qui ne respectent pas la convention snake_case, réduisant la lisibilité.
4. Confondre la casse, par exemple variable et Variable, ce qui crée des erreurs.
5. Réutiliser un nom de variable sans réinitialiser ou redéfinir, causant des erreurs ou comportements inattendus.
6. Oublier de réaffecter une variable avant de l'utiliser dans une opération ou affichage.
7. Ne pas respecter la sensibilité à la casse, entraînant des erreurs difficiles à diagnostiquer.

✅ Checklist Examen

1. Vérifier que chaque variable est déclarée avant utilisation.
2. Respecter la syntaxe d'assignation : nom = valeur.
3. Utiliser des noms explicites et cohérents.
4. Respecter la casse dans tous les usages.
5. Utiliser snake_case pour nommer les variables.
6. Vérifier que les noms de variables ne commencent pas par un chiffre.
7. Éviter d'utiliser des caractères spéciaux ou espaces dans les noms.
8. Réaffecter une variable avant de l'utiliser si nécessaire.
9. Utiliser print() pour afficher la valeur des variables.
10. Faire attention à la portée des variables dans les fonctions.
11. Ne pas utiliser de variables non initialisées.