Guide des variables Python

Les variables en Python sont des conteneurs qui stockent des données pouvant être modifiées pendant l’exécution du programme. Chaque variable est associée à un nom qui la distingue des autres, ainsi qu’à une valeur qui peut être de différents types, tels que des nombres, des chaînes de caractères, des listes, des dictionnaires, etc.

En Python, les variables sont déclarées et initialisées dynamiquement. Cela signifie que vous n’avez pas besoin de spécifier explicitement le type de données que la variable contiendra lors de sa déclaration. Vous pouvez simplement assigner une valeur à une variable, et Python déduira automatiquement le type de données.

Voici un exemple de déclaration de variable en Python :

pythonCopy code
x = 10

Dans cet exemple, nous avons déclaré une variable nommée « x » et lui avons assigné la valeur entière 10. Python a automatiquement déduit que « x » est une variable de type entier (int).

Il est important de noter que les noms de variables en Python sont sensibles à la casse, ce qui signifie que « x », « X » et « X » sont considérés comme des noms de variables différents.

Vous pouvez également réaffecter une nouvelle valeur à une variable existante :

pythonCopy code
x = 10
x = 20

Maintenant, la variable « x » contient la valeur 20 au lieu de 10.

Python prend également en charge plusieurs affectations en une seule ligne :

pythonCopy code
a, b, c = 10, 20, 30

Dans cet exemple, nous avons déclaré trois variables (a, b et c) et leur avons assigné respectivement les valeurs 10, 20 et 30.

Les variables en Python peuvent être de différents types de données. Voici quelques-uns des types de données les plus courants :

• Entiers (int) : Ils représentent des nombres entiers, tels que -1, 0, 1, 2, etc.
• Nombres à virgule flottante (float) : Ils représentent des nombres décimaux, tels que 3.14, 2.5, -0.5, etc.
• Chaînes de caractères (str) : Elles représentent des séquences de caractères, telles que « Bonjour », « Python », « 123 », etc.
• Listes (list) : Elles sont des collections ordonnées d’éléments pouvant être de différents types, telles que [1, 2, 3], [« a », « b », « c »], etc.
• Tuples (tuple) : Ils sont similaires aux listes, mais immuables, ce qui signifie qu’ils ne peuvent pas être modifiés après leur création, tels que (1, 2, 3), (« a », « b », « c »), etc.
• Dictionnaires (dict) : Ils sont constitués de paires clé-valeur, où chaque valeur est associée à une clé unique, tels que {« nom »: « Jean », « âge »: 30, « ville »: « Paris »}, etc.

Pour accéder à la valeur d’une variable, il suffit d’utiliser son nom :

pythonCopy code
x = 10
print(x)  # Affiche : 10

Vous pouvez également effectuer des opérations sur les variables, en fonction de leur type. Par exemple, pour les entiers et les nombres à virgule flottante, vous pouvez effectuer des opérations arithmétiques telles que l’addition, la soustraction, la multiplication et la division :

pythonCopy code
a = 10
b = 5
addition = a + b
soustraction = a - b
multiplication = a * b
division = a / b

print(addition)        # Affiche : 15
print(soustraction)    # Affiche : 5
print(multiplication)  # Affiche : 50
print(division)        # Affiche : 2.0

Pour les chaînes de caractères, vous pouvez effectuer des opérations de concaténation et d’autres manipulations de chaînes :

pythonCopy code
prenom = "Jean"
nom = "Dupont"
nom_complet = prenom + " " + nom
print(nom_complet)  # Affiche : Jean Dupont

Pour les listes, vous pouvez effectuer des opérations telles que l’ajout d’éléments, la suppression d’éléments, l’accès aux éléments par leur indice, etc. :

pythonCopy code
liste = [1, 2, 3, 4, 5]
liste.append(6)        # Ajoute 6 à la fin de la liste
liste.remove(3)        # Supprime la première occurrence de 3 dans la liste
element = liste[2]     # Accède à l'élément d'indice 2 (troisième élément) de la liste

print(liste)    # Affiche : [1, 2, 4, 5, 6]
print(element)  # Affiche : 4

Pour les dictionnaires, vous pouvez accéder aux valeurs en utilisant les clés, ajouter de nouvelles paires clé-valeur, supprimer des paires clé-valeur, etc. :

pythonCopy code
personne = {"nom": "Jean", "âge": 30, "ville": "Paris"}
print(personne["nom"])   # Affiche : Jean
personne["profession"] = "Ingénieur"  # Ajoute une nouvelle paire clé-valeur
del personne["âge"]      # Supprime la paire clé-valeur avec la clé "âge"

print(personne)  # Affiche : {"nom": "Jean", "ville": "Paris", "profession": "Ingénieur"}

En conclusion, les variables en Python sont des éléments essentiels pour stocker et manipuler des données dans vos programmes. Elles peuvent être de différents types de données et peuvent être utilisées dans une variété de contextes pour effectuer des opérations et des manipulations diverses. Comprendre comment déclarer, initialiser et manipuler des variables est fondamental pour le développement en Python.

Bien sûr, explorons davantage les concepts relatifs aux variables et leur utilisation en Python.

1. Portée des variables :
   En Python, la portée d’une variable fait référence à la partie du code où cette variable est accessible. Il existe principalement deux types de portées de variables :

   • Portée locale : Les variables déclarées à l’intérieur d’une fonction sont accessibles uniquement à l’intérieur de cette fonction. Elles sont dites avoir une portée locale.
   • Portée globale : Les variables déclarées en dehors de toutes les fonctions sont accessibles de n’importe où dans le script. Elles sont dites avoir une portée globale.

   Exemple de portée locale et globale :

   pythonCopy code
   x = 10  # Variable globale
   
   def ma_fonction():
       y = 20  # Variable locale
       print(x)  # Accès à la variable globale x
       print(y)  # Accès à la variable locale y
   
   ma_fonction()
   print(x)  # Accès à la variable globale x en dehors de la fonction
   print(y)  # Erreur : la variable locale y est inaccessible en dehors de la fonction
   

2. Variables dynamiques :
   Contrairement à certains langages de programmation qui nécessitent une déclaration explicite du type de données d’une variable, Python est un langage à typage dynamique. Cela signifie que le type de données d’une variable peut changer au cours de l’exécution du programme en fonction de la valeur qui lui est assignée.

   Exemple de typage dynamique en Python :

   pythonCopy code
   x = 10  # x est de type int
   x = "Bonjour"  # x est maintenant de type str
   x = [1, 2, 3]  # x est maintenant de type list
   

3. Conversion de types :
   Vous pouvez également convertir des variables d’un type à un autre à l’aide de fonctions intégrées telles que int(), float(), str(), list(), etc.

   Exemple de conversion de types :

   pythonCopy code
   x = "10"
   y = int(x)  # Convertit la chaîne de caractères en entier
   z = float(x)  # Convertit la chaîne de caractères en nombre à virgule flottante
   
   print(y)  # Affiche : 10
   print(z)  # Affiche : 10.0
   

4. Identificateurs de variables valides :
   En Python, les noms de variables doivent suivre certaines règles :

   • Ils peuvent contenir des lettres (majuscules ou minuscules), des chiffres et le caractère souligné _.
   • Ils ne peuvent pas commencer par un chiffre.
   • Ils ne peuvent pas contenir de caractères spéciaux tels que !, @, #, etc.
   • Ils doivent être des noms significatifs et descriptifs pour améliorer la lisibilité du code.

   Exemples de noms de variables valides :

   • nom
   • age
   • total_clients
   • moyenne_temperatures

5. Convention de nommage :
   Bien qu’il n’y ait pas de règles strictes concernant la convention de nommage des variables en Python, il est courant de suivre le style de nommage snake_case, où les mots sont séparés par des underscores.

   Exemple de convention de nommage en Python :

   pythonCopy code
   nom_utilisateur = "JeanDupont"
   age_utilisateur = 30
   

   Il est également important de noter que Python est sensible à la casse, ce qui signifie que variable, Variable et VARIABLE sont considérés comme des noms de variables différents.

En explorant ces concepts plus en profondeur, vous aurez une compréhension plus complète de la manière dont les variables fonctionnent en Python et de la façon de les utiliser efficacement dans vos programmes.