Guide complet des Variables Python à utiliser en tant que Data Analyst.

‍

Introduction aux variables en Python

Qu'est-ce qu'une variable ? 

En programmation, une variable est une référence à une valeur stockée en mémoire, qui peut être manipulée par le programme. 

Imaginez une variable comme une boîte étiquetée dans laquelle vous pouvez placer une valeur spécifique. 

Chaque boîte a un nom unique, qui est utilisé pour accéder à la valeur qu'elle contient. 

En Python, une variable est créée dès qu'une valeur lui est attribuée pour la première fois, sans besoin de déclaration préalable.

Par exemple :

‍

x = 10
y = "Bonjour, Python!"
z = 3.14

Dans cet exemple, `x` est une variable contenant l'entier `10`, `y` contient la chaîne de caractères `"Bonjour, Python!"`, et `z` contient le nombre à virgule flottante `3.14`.

‍

Pourquoi les variables sont-elles importantes en programmation ?

Les variables sont essentielles en programmation car elles permettent de manipuler et de stocker des informations de manière dynamique. 

Voici quelques raisons pour lesquelles elles sont cruciales :

• Stockage et réutilisation de données: Les variables permettent de stocker des valeurs qui peuvent être réutilisées plusieurs fois dans un programme, ce qui évite la redondance de code et rend le programme plus lisible et maintenable.

nom = "Alice"
age = 30
print(f"Nom: {nom}, Age: {age}")

Ici, les variables `nom` et `age` sont utilisées pour stocker des informations qui sont réutilisées dans l'instruction `print`.

‍

• Flexibilité et adaptabilité: En utilisant des variables, vous pouvez écrire des programmes qui peuvent traiter différentes valeurs sans avoir besoin de modifier le code.

‍

def calculer_aire_cercle(rayon):
    return 3.14 * rayon ** 2

print(calculer_aire_cercle(5))
print(calculer_aire_cercle(10))

La fonction `calculer_aire_cercle` utilise une variable `rayon` pour calculer l'aire d'un cercle. 

Cette variable rend la fonction adaptable à n'importe quelle valeur de rayon.

‍

• Manipulation des données: Les variables permettent d'effectuer des opérations et des transformations sur les données. 

‍

Par exemple, vous pouvez utiliser des variables pour effectuer des calculs mathématiques, manipuler des chaînes de caractères, ou itérer sur des collections de données.

‍

x = 10
y = 5
somme = x + y
print(somme)  # Affiche 15

Dans cet exemple, les variables `x` et `y` sont utilisées pour stocker des nombres, et la variable `somme` stocke le résultat de leur addition.

‍

• Gestion de l'état du programme: Les variables peuvent être utilisées pour suivre l'état d'un programme, comme le nombre d'itérations d'une boucle ou la réussite d'une condition.

‍

compteur = 0
while compteur < 5:
    print(compteur)
    compteur += 1

Ici, la variable `compteur’ est utilisée pour suivre le nombre d'itérations de la boucle `while’.

‍

Pour plus d'informations sur Python, vous avons justement une formation Python qui pourrais potentiellement vous interesser !

‍

Comment déclarer une variable en Python ?

En Python, la déclaration et l'assignation d'une variable se font en une seule étape, grâce à une syntaxe simple et directe. 

Vous n'avez pas besoin de spécifier le type de la variable au moment de sa déclaration, car Python est un langage à typage dynamique.

Syntaxe de base :

nom_de_variable=valeur

Exemple :

message = "Bonjour"
nombre = 123
prix = 19.99

‍

{{nl-inline="/brouillon"}}

‍

Conventions de nommage des variables

Il est important de suivre certaines conventions de nommage pour améliorer la lisibilité et la maintenabilité de votre code. 

Voici quelques règles couramment suivies:

•  Utilisez des noms significatifs: Choisissez des noms de variables qui décrivent clairement leur contenu ou leur rôle.

nombre_de_personnes = 5
total_prix = 99.99

• Utilisez des lettres minuscules et des underscores pour les mots multiples: Cette convention est connue sous le nom de `snake_case’.

nom_utilisateur = "Alice"
nombre_total = 100

• Évitez les noms de variables trop courts ou trop longs: Des noms de variables trop courts peuvent être ambigus, tandis que des noms trop longs peuvent rendre le code difficile à lire.

# Mauvais exemples :
n = 5
nombre_de_personnes_dans_la_salle_de_classe_principale = 30

# Bons exemles :
compteur = 5
nombre_etudiants = 30

• Évitez les mots réservés: Ne nommez pas vos variables avec des mots clés réservés du langage Python (comme `if`, `while`, `class`, etc.).

# Mauvais Exemple : 
class = "Eleve"

# Bon Exemple : 
classe = "Eleve"

En suivant ces conventions et en comprenant l'importance des variables, vous serez bien équipé pour écrire des programmes Python clairs, efficaces et faciles à maintenir.

{{cours-gratuit-python="/brouillon"}}

‍

Types de variables en Python

Variables numériques 

Entiers (int)

Les entiers sont des nombres sans décimales. En Python, ils peuvent être positifs ou négatifs.

age = 30
temperature = -5

‍

Nombres à virgule flottante (float)

Les nombres à virgule flottante (ou "floats") sont des nombres avec des décimales.

pi = 3.14159
poids = 70.5

‍

Nombres complexes (complex)

Les nombres complexes ont une partie réelle et une partie imaginaire.

nombre_complexe = 2+3j

‍

Variables textuelles (str)

Les chaînes de caractères (strings) sont des séquences de caractères.

salutation = "Bonjour"
nom = "Alice"

‍

Variables booléennes (bool)

Les booléens ne peuvent prendre que deux valeurs : `True` ou `False`.

est_ete = True
est_vancance = False

‍

Variables de séquence

Listes

Les listes sont des collections ordonnées de valeurs modifiables.

fruits = ["pomme", "banane", "cerise"]

‍

Tuples

Les tuples sont similaires aux listes, mais ils sont immuables, c’est à dire qu’on ne peut pas modifier les tuples comme les listes.

coordonnees = (10.0,20.0)

‍

Chaînes de caractères

Les chaînes de caractères peuvent également être considérées comme des séquences de caractères.

phrase = "Apprendre Python est amusant !"

‍

Déclaration et assignation de variables Python : Comment déclarer et assigner une varibale Python ?

Syntaxe de base d’une variable Python

En Python, la déclaration et l'assignation d'une variable se font en une seule étape.

variable = valeur

‍

Conventions de nommage des variables Python 

Il est recommandé d'utiliser des noms de variables significatifs et de suivre les conventions de nommage PEP 8. 

PEP 8, ou Python Enhancement Proposal 8, est un guide de style officiel pour écrire du code Python. 

Il contient des recommandations sur la manière d'écrire du code Python de manière cohérente et lisible.

L'utilisation de noms de variables significatifs et le respect des conventions de nommage sont des éléments essentiels de ce guide. 

Le lien du guide pour les curieux : https://peps.python.org/pep-0008/

nom_de_variable = valeur

‍

Assignation de multiples variables Python : Comment assigner des variables multiples ?

Python permet d'assigner plusieurs variables en une seule ligne de cette façon :

a, b, c = 1, 2, 3

Dans cet exemple, la variable ‘a’ reçoit la valeur 1, ‘b’ reçoit la valeur 2, et ‘c’ reçoit la valeur 3. 

L'assignation multiple permet d'initialiser plusieurs variables simultanément, ce qui est particulièrement utile dans diverses situations.

Portée des variables Python

La portée des variables, ou ‘scope’ en anglais, définit la région dans le code où une variable est accessible. 

En Python, il existe principalement trois types de portée pour les variables : locale, globale et non locale. 

Comprendre la portée des variables est crucial pour éviter les erreurs et écrire du code maintenable.

Variables locales

Les variables locales sont déclarées à l'intérieur d'une fonction et ne sont accessibles qu'à l'intérieur de cette fonction. 

Elles sont créées lorsqu'une fonction est appelée et sont détruites lorsque la fonction se termine.

Les variables locales permettent d'isoler des valeurs spécifiques à une fonction, évitant ainsi les conflits de noms avec des variables définies ailleurs dans le programme.

‍

Exemple :

def ma_fonction ():
	x = 10 # Variable Locale
    print (x) # Affiche 10
    
ma_fonction()
print (x) # erreur : x n'est pas défini en dehors de la fonction

Dans cet exemple, la variable `x` est locale à la fonction `ma_fonction` et n'est pas accessible en dehors de celle-ci.

‍

Variables globales

Les variables globales sont déclarées en dehors de toutes les fonctions et sont accessibles depuis n'importe quelle fonction du programme. 

Elles sont créées lorsque le programme commence à s'exécuter et sont détruites lorsque le programme se termine. 

Les variables globales peuvent être utiles pour partager des données entre plusieurs fonctions, mais leur utilisation doit être limitée pour éviter les problèmes de lisibilité et de débogage.

Exemple :

x = 10 # Variable Globale 
def ma_fonction () :
	print (x) # Accède à la variable globale x
    
ma fonction () # Affiche 10
print (x) # Affiche 10

Dans cet exemple, la variable `x` est globale et peut être utilisée à la fois dans la fonction `ma_fonction` et en dehors de celle-ci.

Modifications des variables globales dans les fonctions 

Pour modifier une variable globale à l'intérieur d'une fonction, vous devez utiliser le mot-clé ‘global’. 

Sans ce mot-clé, Python créera une nouvelle variable locale et ne modifiera pas la variable globale.

‍

Exemple :

x = 10 # Variable Globale
def ma_fonction () :
	global x
    x = 20 # Modifie la variable globale x
    print (x) # Affiche 20
    
ma_fonction ()
print(x) # Affiche 20

‍

Variables non locales

Les variables non locales sont utilisées dans les fonctions imbriquées (des fonctions définies à l'intérieur d'autres fonctions) pour faire référence à des variables dans la fonction englobante. 

Le mot-clé ‘nonlocal’ permet de modifier une variable dans une fonction englobante mais pas globale.

‍

Exemple :

def fonction_exterieure():
    x = "local"

    def fonction_interieure():
        nonlocal x
        x = "nonlocal"
        print(x)  # Affiche "nonlocal"

    fonction_interieure()
    print(x)  # Affiche "nonlocal"

fonction_exterieure()

Dans cet exemple, la variable `x` est définie dans `fonction_exterieure` et est accessible dans ‘fonction_interieure’ grâce au mot-clé ‘nonlocal’.

‍

Importance de la portée des variables

Comprendre la portée des variables aide à éviter des erreurs courantes comme :

• NameError: Essayer d'accéder à une variable qui n'est pas définie dans le contexte actuel.

def ma_fonction():
    print(x)  # Erreur : x n'est pas défini localement

ma_fonction()

‍

• Conflits de noms: Utiliser le même nom pour des variables locales et globales peut conduire à des comportements inattendus.

x = 10  # Variable globale

def ma_fonction():
    x = 5  # Variable locale, différente de la variable globale
    print(x)  # Affiche 5

ma_fonction()
print(x)  # Affiche 10

‍

En maîtrisant la portée des variables, vous pouvez écrire du code Python plus fiable, plus propre et plus facile à comprendre. 

Cela contribue également à éviter les erreurs difficiles à diagnostiquer et à maintenir un flux de données cohérent à travers votre programme.

‍

Opérations sur les variables Python

Opérations arithmétiques

Python supporte les opérations arithmétiques de base : addition, soustraction, multiplication, division, etc.

‍

x = 10
y = 5
print (x + y) # Addition
print (x - y) # Soustraction
print (x * y) # Multiplication
print (x / y) # Division

‍

Opérations de comparaison

 Les variables peuvent être comparées à l'aide des opérateurs de comparaison.

x = 10
y = 5
print (x + y) # Addition
print (x - y) # Soustraction
print (x * y) # Multiplication
print (x / y) # Division

print (x == y) # Egalité
print (x!= y) # Différence
print (x > y) # Supérieur
print (x > y) # Inférieur

‍

Opérations logiques

Les opérations logiques incluent ‘and’, ‘or’ et ‘not’.

a = True
b = False
print (a and b) # False
print (a or b) # True
print (not a) # False

‍

Conversion de types (Type Casting)

Conversion implicite

Python convertit automatiquement certains types de variables.

x = 10
y = 3.14
z = x + y # z devient un float

‍

Conversion explicite

Pour convertir explicitement des types de variables, utilisez les fonctions de conversion.

x = 10
z = float(x) # Convertit x en float
z = str(x) # Convertit x en string

‍

Variables spéciales en Python

None

‘None’ est une valeur spéciale utilisée pour indiquer l'absence de valeur.

x = None

‍

Variables prédéfinies

Python a plusieurs variables prédéfinies comme ‘__name__’ et ‘__main__’.

Ces deux variables sont utilisées pour déterminer si un fichier Python est exécuté comme programme principal ou s'il est importé en tant que module dans un autre script.

if _name_ == "_main_":
	print ("Ce script est exécuté directement.")

‍

Bonnes pratiques dans l'utilisation des variables Python

Choix des noms de variables

Utilisez des noms de variables clairs et significatifs.

Gestion de la mémoire 

Évitez d'utiliser trop de mémoire en utilisant des structures de données appropriées.

Éviter les variables globales

Minimisez l'utilisation de variables globales pour éviter les conflits et faciliter le débogage.

Débogage et erreurs courantes liées aux variables Python

NameError 

Se produit lorsque vous essayez d'utiliser une variable qui n'a pas été définie.

print (x) # NameError si x n'est pas défini

‍

TypeError

Se produit lorsque vous essayez d'effectuer une opération sur des types incompatibles.

```python

x = "10"

y = 5

print(x + y)  # TypeError

```

Utilisation de variables non initialisées

Toujours initialiser vos variables avant de les utiliser.

x = "10"
y = 5
print (x + y) # TypeError

‍

Concepts avancés de variables Python

Les variables en Python offrent une grande flexibilité et des fonctionnalités avancées. 

Voici quelques concepts avancés liés aux variables Python.

Variables de classe VS variables d'instance

En programmation orientée objet (POO), il est important de comprendre la différence entre les variables de classe et les variables d'instance.

Variables de classe

Les variables de classe sont partagées entre toutes les instances d'une classe. Elles sont définies au niveau de la classe.

class Compte:
	taux_interet = 0.05 # Variable de classe
    
    def _init_(self, titulaire, solde) :
    	self.titulaire = titulaire # Variable d'instance
        self.solde = solde # Variable d'instance

‍

La variable taux_interet est définie au niveau de la classe et partagée entre toutes les instances de la classe Compte. 

Cela signifie que toutes les instances de la classe accèdent à la même valeur de taux_interet.

Les variables titulaire et solde sont définies dans le constructeur __init__. 

Elles sont propres à chaque instance de la classe, ce qui signifie que chaque instance peut avoir des valeurs différentes pour ces variables.

‍

Variables d'instance

Les variables d'instance sont propres à chaque instance d'une classe et sont définies dans la méthode `__init__` ou d'autres méthodes de la classe.

compte1 = Compte("Alice", 1000)
compte2 = Compte "Bob", 2000)

print(compte1.titulaire) # Affiche "Alice"
print(compte2.solde) # Affiche 2000

‍

Variables dans les compréhensions de liste 

Les compréhensions de liste permettent de créer des listes de manière concise et expressive.

cubes = [x**3 for x in range(10)]
print(cubes) # Affiche [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]

‍

Variables dans les fonctions lambda

Les fonctions lambda sont des fonctions anonymes définies avec le mot-clé ‘lambda’.

ajouter_dix = lambda x: x + 10
print (ajouter_dix(5)) # Affiche 16

nombres = [1, 2, 3, 4, 5]
cubes = list(map(lambda x: x**3, nombres))
print(cubes) # Affiche ]1, 8, 27, 64, 125]

‍

Utilisation des décorateurs pour les variables 

Les décorateurs modifient le comportement des fonctions ou méthodes.

def mon_decorateur(fonction):
	def fonction_modifiee(*args, **kwargs):
    	print("fonction modifiee")
        return fonction(*args, **kwargs)
   	return fonction_modifiee
    
@mon_decorateur
def dire_bonjour(nom) :
	return "Bonjour, {nom} !"
    
print(dire_bonjour("Alice")) # Affiche "Fonction modifiée" puis "Bonjour, Alice !"

‍

Variables d'environnement

Les variables d'environnement sont utilisées pour configurer le comportement des programmes. Vous pouvez y accéder via le module ‘os’.

‍

import os

utilisateur = os.getenv("USER")
print(utilisateur) # Affiche le nom de l'utilisateur actuel

os.environ["NOM_PROJET"] = "ProjetPython"
print(os.getenv("NOM_PROJET")) # Affiche "ProjetPython"

‍

En maîtrisant ces concepts avancés, vous pouvez écrire du code Python plus efficace et adapté à des besoins complexes, tout en tirant parti des fonctionnalités avancées du langage pour résoudre des problèmes sophistiqués.

‍

En Récapitulé :

Les variables sont un concept fondamental en programmation Python. 

Comprendre les différents types de variables, leur portée, et comment les manipuler est essentiel pour écrire des scripts efficaces et maintenables. 

En suivant les bonnes pratiques et en se familiarisant avec les erreurs courantes, vous serez en mesure de gérer les variables Python de manière experte. 

‍Pour aller plus loin et approfondir vos connaissances en Python, n'hésitez pas à consulter notre formation complète.