Comprendre les identificateurs en Python

Introduction

Dans ce laboratoire, vous acquerrez une compréhension approfondie des identificateurs en Python. Vous apprendrez les règles fondamentales régissant la manière de nommer les variables, les fonctions, les classes et d'autres objets dans votre code Python.

Grâce à la pratique, vous identifierez les noms d'identificateurs valides et invalides, renforçant ainsi les conventions de nommage. Le laboratoire couvrira également les conventions spéciales d'identificateurs utilisées en Python, vous dotant des connaissances nécessaires pour écrire un code clair, lisible et maintenable.

Apprendre les règles de nommage des identificateurs

Dans cette étape, nous allons apprendre les règles de nommage des identificateurs en Python. Les identificateurs sont des noms utilisés pour identifier les variables, les fonctions, les classes, les modules et d'autres objets dans un programme. Comprendre les règles de nommage est crucial pour écrire du code lisible et maintenable.

Comme mentionné dans l'introduction, les identificateurs Python doivent suivre ces règles :

Les identificateurs peuvent être composés de lettres (a-z, A-Z), de chiffres (0-9) et de traits de soulignement (_).
Le premier caractère d'un identificateur ne peut pas être un chiffre.
Les identificateurs ne peuvent pas contenir d'espaces ou de caractères spéciaux tels que @, %, $, *, etc.
Les identificateurs sont sensibles à la casse. myVariable et myvariable sont considérés comme des identificateurs différents.
Vous ne pouvez pas utiliser les mots-clés Python ou les noms de fonctions intégrées comme identificateurs.

Créons un fichier Python simple pour pratiquer la définition de quelques identificateurs.

Ouvrez le terminal intégré dans le WebIDE en cliquant sur Terminal -> New Terminal. Assurez-vous d'être dans le répertoire ~/project.

Maintenant, créons un nouveau fichier Python nommé identifier_rules.py dans le répertoire ~/project en utilisant l'éditeur VS Code. Vous pouvez le faire en faisant un clic droit dans le panneau de l'explorateur de fichiers à gauche et en sélectionnant New File, ou en utilisant la palette de commandes (Ctrl+Shift+P ou Cmd+Shift+P) et en tapant File: New File. Nommez le fichier identifier_rules.py.

Dans le fichier identifier_rules.py, tapez le code suivant :

## This is a valid identifier
my_variable = 10

## This is also a valid identifier
anotherVariable = "Hello"

## This is a valid identifier starting with an underscore
_private_variable = True

## This is an invalid identifier (starts with a digit)
## 1st_variable = 5

## This is an invalid identifier (contains a space)
## my variable = "invalid"

## This is an invalid identifier (contains a special character)
## my-variable = 20

## This is an invalid identifier (using a keyword)
## if = 30

print(my_variable)
print(anotherVariable)
print(_private_variable)

Enregistrez le fichier en appuyant sur Ctrl+S (ou Cmd+S).

Maintenant, exécutons ce script Python depuis le terminal pour voir la sortie. Dans le terminal, assurez-vous d'être dans le répertoire ~/project et exécutez la commande suivante :

python identifier_rules.py

Vous devriez voir la sortie des instructions print, confirmant que les identificateurs valides ont été traités correctement. Les lignes avec des identificateurs invalides sont commentées, elles ne causeront donc pas d'erreurs lors de l'exécution du script.

10
Hello
True

Cet exercice démontre les règles de base pour créer des identificateurs valides en Python. Dans les étapes suivantes, nous explorerons davantage les identificateurs valides et invalides ainsi que les conventions de nommage courantes.

Pratiquer les noms d'identificateurs valides

Dans cette étape, nous allons nous entraîner à créer des noms d'identificateurs valides en Python en nous basant sur les règles que nous avons apprises à l'étape précédente. Choisir des noms significatifs et valides pour vos variables, fonctions et autres éléments de code est une partie fondamentale de l'écriture d'un bon code.

Créons un nouveau fichier Python nommé valid_identifiers.py dans le répertoire ~/project en utilisant l'éditeur VS Code.

Dans le fichier valid_identifiers.py, tapez le code suivant. Ce code définit plusieurs variables en utilisant des noms d'identificateurs valides et affiche leurs valeurs.

## Valid variable names
user_age = 30
total_count = 100
item_price_usd = 25.50
is_active = True
_internal_value = "secret"
MAX_RETRIES = 5

## Valid function name (we will learn about functions later)
def calculate_total():
    return user_age * total_count

## Valid class name (we will learn about classes later)
class UserProfile:
    def __init__(self, name):
        self.name = name

## Print the values of the variables
print("User Age:", user_age)
print("Total Count:", total_count)
print("Item Price (USD):", item_price_usd)
print("Is Active:", is_active)
print("Internal Value:", _internal_value)
print("Maximum Retries:", MAX_RETRIES)

## Call the function and print the result
## print("Calculated Total:", calculate_total())

## Create an instance of the class and print a property
## user = UserProfile("Alice")
## print("User Name:", user.name)

Enregistrez le fichier en appuyant sur Ctrl+S (ou Cmd+S).

Maintenant, exécutons ce script Python depuis le terminal. Assurez-vous d'être dans le répertoire ~/project et exécutez la commande suivante :

python valid_identifiers.py

Vous devriez voir les valeurs des variables s'afficher dans la console.

User Age: 30
Total Count: 100
Item Price (USD): 25.5
Is Active: True
Internal Value: secret
Maximum Retries: 5

Remarquez comment les noms de variables utilisent des traits de soulignement (_) pour séparer les mots, ce qui est une convention courante en Python pour les noms de variables et de fonctions (snake_case). Les noms de classes, comme UserProfile, utilisent généralement des lettres majuscules pour la première lettre de chaque mot (PascalCase). Les constantes, comme MAX_RETRIES, sont souvent écrites entièrement en majuscules avec des traits de soulignement.

En vous exerçant avec ces exemples, vous vous familiariserez davantage avec la création de noms d'identificateurs valides et lisibles en Python.

Identifier les noms d'identificateurs invalides

Dans cette étape, nous allons nous concentrer sur l'identification des noms d'identificateurs invalides en Python. Comprendre ce qui rend un identificateur invalide est tout aussi important que de connaître les règles pour les noms valides. Tenter d'utiliser un identificateur invalide entraînera une SyntaxError lorsque vous essaierez d'exécuter votre code Python.

Créons un nouveau fichier Python nommé invalid_identifiers.py dans le répertoire ~/project en utilisant l'éditeur VS Code.

Dans le fichier invalid_identifiers.py, tapez le code suivant. Ce code contient des exemples de noms d'identificateurs invalides. Nous allons intentionnellement les inclure pour voir les erreurs qu'ils produisent.

## Invalid identifier: starts with a digit
## 1variable = 10

## Invalid identifier: contains a space
## my variable = "hello"

## Invalid identifier: contains a special character (@)
## user@name = "Alice"

## Invalid identifier: contains a special character (-)
## product-id = "XYZ123"

## Invalid identifier: using a Python keyword
## class = "Math"

## Invalid identifier: using another Python keyword
## for = 100

## Invalid identifier: contains a special character ($)
## total$amount = 50.75

## Invalid identifier: contains a special character (%)
## discount%rate = 0.15

print("Attempting to define invalid identifiers will cause a SyntaxError.")

Enregistrez le fichier en appuyant sur Ctrl+S (ou Cmd+S).

Maintenant, essayons d'exécuter ce script Python depuis le terminal. Assurez-vous d'être dans le répertoire ~/project et exécutez la commande suivante :

python invalid_identifiers.py

Étant donné que tous les identificateurs invalides sont commentés, le script s'exécutera sans erreur et affichera le message.

Attempting to define invalid identifiers will cause a SyntaxError.

Maintenant, supprimons le commentaire de l'un des identificateurs invalides pour voir l'erreur. Supprimez le # du début de la ligne ## 1variable = 10. La ligne devrait maintenant être 1variable = 10.

Enregistrez à nouveau le fichier.

Exécutez à nouveau le script :

python invalid_identifiers.py

Cette fois, vous devriez voir une SyntaxError indiquant que l'identificateur est invalide car il commence par un chiffre.

  File "/home/labex/project/invalid_identifiers.py", line 4
    1variable = 10
    ^
SyntaxError: invalid decimal literal

Vous pouvez essayer de décommenter d'autres identificateurs invalides un par un et d'exécuter le script pour voir les différents types de messages SyntaxError qu'ils produisent. N'oubliez pas de commenter l'identificateur invalide précédent avant de décommenter le suivant afin d'isoler l'erreur.

Cette étape vous aide à reconnaître les erreurs courantes lors de la nomination des identificateurs et à comprendre l'importance de suivre les règles de nommage pour éviter les erreurs de syntaxe.

Comprendre les conventions d'identificateurs spéciaux

Dans cette étape, nous allons explorer certaines conventions spéciales pour l'utilisation des traits de soulignement dans les identificateurs Python. Ces conventions n'affectent pas nécessairement la validité ou l'invalidité d'un identificateur selon les règles de base, mais elles transmettent des significations spécifiques sur l'utilisation prévue ou la visibilité de l'identificateur.

Voici les conventions courantes relatives aux traits de soulignement :

Trait de soulignement simple en préfixe (_nom) : Cette convention indique que l'identificateur est destiné à un usage interne au sein d'un module ou d'une classe. C'est un indice pour les autres programmeurs qu'ils ne devraient pas accéder directement à cet identificateur depuis l'extérieur du module ou de la classe. Cependant, Python ne l'applique pas strictement ; vous pouvez toujours y accéder si vous le souhaitez.
Double trait de soulignement en préfixe (__nom) : Cette convention est utilisée pour le "name mangling" (altération de nom) dans les classes. Lorsqu'un identificateur à l'intérieur d'une classe commence par deux traits de soulignement (et ne se termine pas par deux traits de soulignement), Python modifie en interne le nom pour rendre son accès direct depuis l'extérieur de la classe plus difficile. Cela aide à prévenir les conflits de noms dans l'héritage.
Double trait de soulignement en préfixe et en suffixe (__nom__) : Ces identificateurs sont réservés à un usage spécial par l'interpréteur Python. Des exemples incluent __init__ (constructeur), __str__ (représentation sous forme de chaîne), etc. Vous devriez éviter de créer vos propres identificateurs avec ce modèle, sauf si vous implémentez l'une des méthodes spéciales de Python.
Trait de soulignement simple en suffixe (nom_) : Cette convention est utilisée pour éviter les conflits de noms avec les mots-clés Python. Si vous souhaitez utiliser un nom qui est un mot-clé Python (comme class ou for), vous pouvez ajouter un trait de soulignement pour en faire un identificateur valide (par exemple, class_, for_).

Créons un nouveau fichier Python nommé underscore_conventions.py dans le répertoire ~/project en utilisant l'éditeur VS Code pour voir ces conventions en action.

Dans le fichier underscore_conventions.py, tapez le code suivant :

## Single leading underscore: intended for internal use
_internal_data = "This is internal data"

## Double leading underscore: name mangling in classes
class MyClass:
    def __init__(self):
        self.__private_attribute = "This is a private attribute"

    def get_private_attribute(self):
        return self.__private_attribute

## Double leading and trailing underscores: special method
class MyString:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"MyString object with value: {self.value}"

## Single trailing underscore: to avoid keyword conflict
import builtins
class_ = "This variable name avoids conflict with the 'class' keyword"

print("Internal data:", _internal_data)

## Accessing the private attribute (demonstrating name mangling)
obj = MyClass()
## print(obj.__private_attribute) ## This will cause an AttributeError
print("Accessing private attribute via method:", obj.get_private_attribute())
## You can technically access it using the mangled name, but it's not recommended
## print("Accessing mangled name:", obj._MyClass__private_attribute)

## Using the special __str__ method
my_str_obj = MyString("Hello World")
print(my_str_obj) ## This calls the __str__ method

print("Variable name avoiding keyword conflict:", class_)

Enregistrez le fichier en appuyant sur Ctrl+S (ou Cmd+S).

Maintenant, exécutez le script depuis le terminal :

python underscore_conventions.py

Vous devriez voir la sortie démontrant l'utilisation de ces conventions.

Internal data: This is internal data
Accessing private attribute via method: This is a private attribute
MyString object with value: Hello World
Variable name avoiding keyword conflict: This variable name avoids conflict with the 'class' keyword

Notez que tenter d'accéder directement à obj.__private_attribute entraînerait une AttributeError en raison du "name mangling". L'y accéder via la méthode get_private_attribute ou le nom altéré _MyClass__private_attribute fonctionne, mais la convention est d'utiliser la méthode. L'appel print(my_str_obj) utilise automatiquement la méthode __str__ car c'est une méthode spéciale pour la représentation sous forme de chaîne.

Comprendre ces conventions vous aide à interpréter l'intention derrière les noms d'identificateurs dans le code Python et à écrire du code qui suit les pratiques courantes.

Résumé

Dans ce laboratoire, nous avons appris les règles fondamentales pour nommer les identificateurs en Python. Nous nous sommes entraînés à créer des noms d'identificateurs valides en utilisant des lettres, des chiffres et des traits de soulignement, tout en respectant la règle selon laquelle les identificateurs ne peuvent pas commencer par un chiffre. Nous avons également identifié les noms d'identificateurs invalides qui contenaient des espaces, des caractères spéciaux ou qui étaient des mots-clés Python. De plus, nous avons exploré les conventions spéciales d'identificateurs, comme l'utilisation d'un trait de soulignement en préfixe pour les variables "privées".