À la fin de ce chapitre, vous serez capable de déclarer des variables en respectant les règles de nommage, de manipuler les principaux types de données (entiers, flottants, chaînes, booléens) et d'effectuer des conversions entre types simples.
Les variables sont des éléments fondamentaux en programmation. Elles permettent de stocker des informations et d'y accéder facilement dans un programme.
Une variable est un conteneur qui permet de stocker une valeur en mémoire. En Python, les variables sont créées au moment où on leur assigne une valeur pour la première fois.
# Création de variables age = 25 nom = "Alice" est_etudiant = True
En Python, on déclare une variable simplement en lui assignant une valeur avec l'opérateur =.
# Affectation simple x = 10 y = 20 # Affectation multiple a, b, c = 1, 2, 3 # Réaffectation variable = "première valeur" variable = "nouvelle valeur"
Les noms de variables en Python doivent respecter certaines règles :
Pour écrire un code lisible et maintenable, suivez ces conventions :
Python dispose de plusieurs types de données intégrés pour manipuler différents types d'informations.
Python supporte trois types numériques : les entiers, les flottants et les complexes.
Les entiers sont des nombres positifs ou négatifs sans partie décimale.
# Nombres entiers age = 25 temperature = -5 population = 7_900_000_000 # Avec séparateur de milliers
Les nombres flottants représentent des nombres réels avec une partie décimale.
# Nombres flottants pi = 3.14159 temperature = -2.5 prix = 19.99
Les nombres complexes sont représentés par une partie réelle et une partie imaginaire.
# Nombres complexes z = 3 + 4j print(z.real) # Partie réelle: 3.0 print(z.imag) # Partie imaginaire: 4.0
Les chaînes de caractères permettent de manipuler du texte.
Les chaînes peuvent être créées avec des apostrophes simples ou doubles.
# Création de chaînes nom = 'Alice' message = "Bonjour le monde" phrase = "J'aime Python" # Concaténation prenom = "Jean" nom_complet = prenom + " Dupont" # Répétition separateur = "-" * 20
Certains caractères nécessitent d'être échappés avec un antislash.
# Caractères d'échappement chaine = "Ceci est une \"citation\" importante" chemin = "C:\\Users\\Nom\\Documents" saut_ligne = "Première ligne\nDeuxième ligne" # Chaînes brutes (raw strings) chemin_raw = r"C:\Users\Nom\Documents"
Plusieurs méthodes permettent de formater les chaînes de caractères.
# Formatage avec f-strings (Python 3.6+) nom = "Alice" age = 25 message = f"Je m'appelle {nom} et j'ai {age} ans" # Formatage avec format() message = "Je m'appelle {} et j'ai {} ans".format(nom, age) # Formatage avec % (ancienne méthode) message = "Je m'appelle %s et j'ai %d ans" % (nom, age)
Le type booléen représente deux valeurs : True (Vrai) et False (Faux).
# Valeurs booléennes est_vrai = True est_faux = False # Expressions booléennes resultat = 10 > 5 # True est_egal = (10 == 5) # False
None est une constante qui représente l'absence de valeur.
# Utilisation de None resultat = None def fonction_sans_return(): print("Cette fonction ne retourne rien") valeur = fonction_sans_return() # valeur vaut None
Python offre plusieurs structures de données pour organiser et manipuler des collections de valeurs.
Les listes sont des collections ordonnées et modifiables d'éléments.
Les listes sont créées avec des crochets et les éléments sont accessibles par index.
# Création de listes nombres = [1, 2, 3, 4, 5] fruits = ["pomme", "banane", "orange"] mixte = [1, "deux", 3.0, True] # Accès aux éléments premier_fruit = fruits[0] # "pomme" dernier_fruit = fruits[-1] # "orange" sous_liste = nombres[1:4] # [2, 3, 4]
Les listes disposent de nombreuses méthodes pour les manipuler.
# Méthodes des listes fruits = ["pomme", "banane"] fruits.append("orange") # Ajoute à la fin fruits.insert(1, "kiwi") # Insère à la position 1 fruits.remove("banane") # Supprime l'élément dernier = fruits.pop() # Supprime et retourne le dernier fruits.sort() # Trie la liste
Les tuples sont des listes immuables (non modifiables).
# Création de tuples coordonnees = (10, 20) couleur_rgb = (255, 0, 0) point = (x, y, z) # Accès aux éléments x = coordonnees[0] y = coordonnees[1] # Les tuples sont immuables # coordonnees[0] = 15 # Erreur!
Les dictionnaires stockent des paires clé-valeur.
# Création de dictionnaires personne = { "nom": "Dupont", "prenom": "Jean", "age": 30 } # Accès aux valeurs nom = personne["nom"] age = personne.get("age") # Ajout et modification personne["ville"] = "Paris" personne["age"] = 31
Les ensembles sont des collections non ordonnées d'éléments uniques.
# Création d'ensembles fruits = {"pomme", "banane", "orange"} nombres = set([1, 2, 3, 4, 5]) # Ajout d'éléments fruits.add("kiwi") # Opérations sur les ensembles a = {1, 2, 3} b = {3, 4, 5} union = a | b # {1, 2, 3, 4, 5} intersection = a & b # {3}
Python offre plusieurs opérations pour manipuler et vérifier les types de variables.
Il est souvent utile de vérifier le type d'une variable.
# Vérification avec type() x = 10 print(type(x)) # <class 'int'> y = "hello" print(type(y)) # <class 'str'> # Vérification avec isinstance() nombre = 3.14 print(isinstance(nombre, float)) # True print(isinstance(nombre, int)) # False
Python permet de convertir un type de données en un autre.
# Conversion entre types x = 10 x_float = float(x) # 10.0 x_str = str(x) # "10" y = "25" y_int = int(y) # 25 z = 3.9 z_int = int(z) # 3 (troncature) liste = [1, 2, 3] liste_tuple = tuple(liste) # (1, 2, 3)
Les opérateurs se comportent différemment selon les types de données.
# Opérations numériques a = 10 + 5 # 15 (addition) b = 10 * 2 # 20 (multiplication) # Opérations sur les chaînes c = "Hello" + " " + "World" # "Hello World" (concaténation) d = "Hi" * 3 # "HiHiHi" (répétition) # Opérations sur les listes liste1 = [1, 2] + [3, 4] # [1, 2, 3, 4] (concaténation) liste2 = [0] * 5 # [0, 0, 0, 0, 0] (répétition)
La portée d'une variable définit où elle est accessible dans le code.
Les variables ont une portée locale ou globale selon où elles sont définies.
# Variable globale variable_globale = "Je suis globale" def ma_fonction(): # Variable locale variable_locale = "Je suis locale" print(variable_locale) # Accessible print(variable_globale) # Accessible ma_fonction() # print(variable_locale) # Erreur: variable_locale n'est pas définie
Le mot-clé global permet de modifier une variable globale depuis une fonction.
compteur = 0 def incrementer(): global compteur compteur += 1 incrementer() print(compteur) # 1 incrementer() print(compteur) # 2
Mettez en pratique les concepts appris avec ces exercices sur les variables et types de données.
Créez un programme qui :
Créez un programme qui :
Réalisez ces mini-projets pour appliquer vos connaissances :
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!