Variables et Structures de Données Python

Objectif pédagogique : Maîtriser la création de variables et l’utilisation des structures de données fondamentales en Python

À la fin de ce chapitre, tu seras capable de…

  • Créer et manipuler des variables avec les bonnes conventions de nommage
  • Identifier et convertir les différents types de données Python
  • Utiliser les listes pour stocker et organiser des collections de données
  • Appliquer l’indexation pour accéder aux éléments des structures de données
  • Distinguer les caractéristiques des listes, tuples, dictionnaires et ensembles

💡 Prérequis : Connaissances de base en informatique et familiarité avec l’environnement Python/Jupyter

Mise en contexte

Vous découvrirez comment créer des variables comme prenom = « Julien » et age = 23 pour stocker vos données. Vous apprendrez à organiser ces informations dans des listes comme fruits = [« orange », « banane », « cerise »] et à y accéder facilement. Ces compétences sont essentielles pour manipuler efficacement les données dans tous vos projets Python.

1 – Les variables et types

En informatique, une variable permet de stocker une information à manipuler dans nos programmes. La création d’une variable se fait en choisissant un nom pour cette dernière puis lui attribuer une valeur. Cela s’appelle « création et assignation d’une valeur à cette variable » : nom_de_la_variable = valeur_de_la_variable. Nous venons donc de créer une variable qui s’appelle nom_de_la_variable et nous lui avons assigné la valeur valeur_de_la_variable.

Exemple : Dans une cellule du notebook ouvert ci-dessus, coller et exécuter les lignes de code ci-dessous :

# Création des variables (cette ne sera pas exécutée)
prenom = "Julien"
age = 23

# Affichage des variables
print(prenom)

Le résultat attendu est : Julien

print(age)

Le résultat attendu est : 23

Le symbole # (appelé « dièse » ou « hash ») est utilisé pour créer des commentaires. Tout ce qui suit le symbole # sur une ligne est totalement ignoré lors de l’exécution du programme.
On utilise souvent des triples guillemets (ou triples apostrophes) pour écrire du texte sur plusieurs lignes.
💡 À retenir : Il est préférable de choisir des noms de variables qui respectent les règles suivantes :
  • Des noms plus descriptifs comme notes_examen_s1 ou nombre_de_livres_lus_2023
  • Une variable doit commencer par une lettre ou un tiret bas (_), mais jamais par un chiffre
  • Les noms de variables ne doivent pas contenir d’espaces
  • Le nom d’une variable ne peut pas commencer par un chiffre
  • Le nom d’une variable ne peut contenir que des caractères alphanumériques et des tirets bas
  • Python est sensible à la casse, donc nom et Nom sont des variables différentes.
Exemples valides :
mon_age = 30
_nom = « Alice »
age2 = 25
👉 Exemples non valides :
2age = 25 # Ne peut pas commencer par un chiffre
mon age = 30 # Ne peut pas contenir d’espaces
Chaque variable peut contenir différents types de données, et Python gère automatiquement ces types selon la valeur assignée. Voici les types de variables les plus courants en Python :
  • Entier désigné par int pour Integer
  • Flottant désigné par float – Désigne un nombre à virgule flottante (décimaux)
  • Chaîne de caractères désigné par str (texte)
  • Booléen désigné par bool et représente des valeurs logiques True ou False
  • Liste désigné par list et représente une collection ordonnée d’éléments
  • Dictionnaire désigné par dict. C’est une collection d’éléments clé-valeur
  • Tuple désigné par tuple. Il est similaire à une liste, mais il est immuable, c’est-à-dire non modifiable
Exemple :
age = 25 # Entier (int)
prix = 19.99 # Flottant (float)
nom = « Koffi » # Chaîne de caractères (str)
est_etudiant = True # Booléen (bool)
notes = [15, 18, 20, 12] # Liste (list) à détailler plus tard
personne = {« nom »: « Bob », « age »: 30} # Dictionnaire (dict) à détailler plus tard
coordonnees = (10, 20) # Tuple (tuple) à détailler plus tard
Il est possible de changer la valeur d’une variable en lui réassignant tout simplement une nouvelle valeur à tout moment.
Exemple :
age = 25
print(age) # Affiche 25
age = 30
print(age) # Affiche 30
Python gère les types automatiquement, mais il est possible de convertir un type en un autre dans certaines situations (par exemple, convertir un entier en chaîne de caractères).
Exemple :
age = 25
age_str = str(age) # Conversion d’un entier en chaîne de caractères
age = « 25 »
age_en_nombre = int(age) # Convertir une chaîne en entier
print(age_en_nombre + 5) # Affiche 30
Nous pouvons utiliser les fonctions suivantes pour convertir les types :
  • str() pour convertir en chaîne de caractères.
  • int() pour convertir en entier.
  • float() pour convertir en flottant.
  • bool() pour convertir en booléen.

2 – Les structures de données

Les structures de données sont des outils fondamentaux dans la programmation et en Data science. Elles permettent de stocker et organiser les données de manière efficace pour qu’elles puissent être facilement manipulées. En Python, les structures de données les plus couramment utilisées sont :
  • Les listes
  • Les tuples
  • Les dictionnaires
  • Les ensembles (sets)

Les listes

Une liste est une collection ordonnée et modifiable qui permet de stocker des éléments de types différents. Les listes sont définies avec des crochets [], et leurs éléments sont séparés par des virgules.
Exemple :
ma_liste = [10, 8.0, « Chat »]
fruits = [« orange », « banane », « cerise »]
Vous pouvez ajouter, supprimer ou modifier des éléments. Les éléments gardent l’ordre dans lequel ils ont été ajoutés.

Indexation

Pour récupérer un élément dans une liste, on utilise son numéro d’ordre (l’indice) placé entre crochets.
Exemple :
# Accéder à un élément par son index
print(fruits[0]) # Affiche « orange »
Il est aussi possible de mettre à jour des éléments d’une liste grâce à leur indice :
# Modification du 2ème élément de la liste
ma_liste[1] = 4
L’indexation d’une liste débute à 0. Il est aussi possible d’aller indexer les éléments dans l’ordre inverse, c’est ce qu’on appelle l’indexation négative. Le dernier élément de la liste a pour indice -1.
print(ma_liste[-1]) # affiche « Chat »

Découpage

Il existe un autre type d’indexation possible, le découpage ou slicing en anglais. Le découpage permet de récupérer une sous-liste d’éléments d’une plus grande liste en spécifiant les indices de début et de fin de la sous-liste séparés par le symbole :.
ma_liste = [3, 9, « Comment », -5.8, « ça », 103, « va »]
Exemple : Récupération des 4 PREMIERS éléments de ma_liste
premiers_elements = ma_liste[0:4]
print(premiers_elements) # Affiche [3, 9, « Comment », -5.8]
L’élément se trouvant à l’indice de fin du découpage n’est pas inclus dans la sous-liste. En effet, ma_liste[0:4] contient uniquement les éléments aux indices 0, 1, 2 et 3.
Si l’indice de début n’est pas spécifié, alors le découpage contiendra tous les éléments depuis le début jusqu’à l’indice de fin.
Exemple : Récupération des 4 PREMIERS éléments de ma_liste
premiers_elements = ma_liste[:4]
De même, si l’indice de fin n’est pas spécifié, alors le découpage contiendra tous les éléments depuis l’indice de début jusqu’à la fin de la liste.
Exemple : Récupération des 3 DERNIERS éléments de ma_liste
derniers_elements = ma_liste[-3:]

Les méthodes pour les listes

En Programmation Orientée Objet que nous allons aborder dans ce cours, une méthode est une fonctionnalité d’une classe d’objets. Ci-dessous les principales méthodes utilisées sur les listes.
La méthode pop()
La méthode pop() de la classe des listes permet de supprimer un élément d’une liste à l’indice spécifié. Elle renvoie la valeur de l’élément qui a été supprimé de la liste :
ma_liste = [7, 9, « Comment », -8, « ça », 103, « va »]
Exemple : Suppression et retour de l’élément situé à l’indice 4
ma_liste.pop(4)
Affichage de la liste
print(ma_liste) # [7, 9, « Comment », -8, 103, « va »]
La syntaxe d’utilisation d’une méthode est très spécifique :
  • L’objet appelant la méthode doit exister au préalable
  • Le nom de la méthode doit être suivi de parenthèses contenant les arguments de la méthode
  • Le nom de l’objet et la méthode sont séparés par un point
Si nous voulons enlever les éléments « Comment », « ça » et « va » de la liste ma_liste à l’aide de la méthode pop(), il faut faire :
Exemple : Suppression de « Comment » qui se trouve à la 3ème position
ma_liste.pop(2)
Exemple : Suppression de « ça » qui se trouve maintenant à la 4ème position
ma_liste.pop(3)
Exemple : Suppression de « va » qui se trouve en dernière position
ma_liste.pop(-1)
Affichage de la liste
print(ma_liste)
💡 À retenir : Attention, les indices de la liste changent une fois qu’un élément a été supprimé.
La méthode insert()
La méthode insert() permet d’ajouter une nouvelle valeur à une liste. Elle prend 2 arguments : l’indice où nous voulons insérer la valeur et la valeur que nous voulons insérer.
Exemple : Insertion de la valeur « Hello » à l’indice 2
ma_liste.insert(2, « Hello »)
Exemple : Insérer dans la liste ma_liste les éléments « how », « are » et « you » aux indices appropriés afin que l’affichage de ma_liste soit : [« comment », « how », « ça », « are », « va », « you »]
ma_liste = [7, 9, « Comment », -8, « ça », 103, « va »]
Suppression des nombres
ma_liste.pop(0)
ma_liste.pop(0)
ma_liste.pop(1)
ma_liste.pop(2)
Insertion des éléments « Hello », « how », « are » et « you »
ma_liste.insert(1, « how »)
ma_liste.insert(3, « are »)
ma_liste.insert(5, « you »)
# Affichage de la liste
print(ma_liste)
La méthode append()
La méthode append est utilisée pour ajouter un élément à la fin d’une liste. Voici un exemple simple de son utilisation :
Exemple : Ajout de l’élément « pour moi » à la fin de la liste
ma_liste.append(« pour moi »)
# Création d’une liste vide
ma_liste = []
# Ajout d’un élément à la liste
ma_liste.append(5)
print(ma_liste) # Affichera [5]
# Ajout d’un autre élément
ma_liste.append(10)
print(ma_liste) # Affichera [5, 10]
La méthode extend()
La méthode extend() est utilisée pour ajouter les éléments d’une autre liste (ou d’une autre structure itérable comme un tuple) à la liste actuelle. Contrairement à la méthode append() qui ajoute un élément à la fin de la liste, extend() ajoute chaque élément de l’itérable spécifié à la liste d’origine.
Exemple :
# Liste initiale
list1 = [1, 2, 3]
# Liste ou itérable à ajouter
list2 = [4, 5, 6]
# Utilisation de la méthode extend()
list1.extend(list2)
# Affichage de la nouvelle liste
print(list1) # Résultat: [1, 2, 3, 4, 5, 6]
Les éléments de list2 sont ajoutés à la fin de list1. La méthode extend() modifie la liste d’origine et ne retourne pas une nouvelle liste. L’itérable passé à extend() peut être une liste, un tuple, une chaîne de caractères, ou tout objet itérable.
Exemple :
list1 = [‘a’, ‘b’, ‘c’]
list1.extend(‘de’)
print(list1) # Résultat: [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]
Il est aussi possible d’utiliser l’opérateur +, mais il n’est pas recommandé de l’utiliser car il peut rajouter de l’ambiguïté dans le code lorsque nous ne sommes pas sûrs de travailler avec des nombres ou des listes. La classe des listes contient encore d’autres méthodes. Les méthodes que nous avons vues jusqu’à maintenant sont récapitulées dans le tableau ci-dessous :

<td

Méthode Argument Description
pop indice Enlève et retourne l’élément de la liste se trouvant à l’indice renseigné
insert indice, valeur Ajoute un nouvel élément à la liste à l’indice renseigné
PrécédentSuivant