COLLECTIONS
Listes
Les listes en Python sont des structures de données qui permettent de stocker une collection ordonnée et modifiable d'éléments. Elles
peuvent contenir des éléments de différents types, y compris d'autres listes, ce qui permet une grande flexibilité. Les listes sont définies
par des éléments séparés par des virgules, entourés de crochets [].
Exemple d'Utilisation dans la Vie Courante Informatique
Les listes sont utilisées dans de nombreuses applications informatiques courantes, telles que :
● Stockage de données : Pour conserver des ensembles de données comme des noms d'utilisateurs, des scores dans un jeu, ou des
enregistrements de transactions.
● Traitement de données : Dans le traitement et l'analyse de données, par exemple, en science des données pour stocker des
ensembles de données importés à partir de fichiers CSV ou de bases de données.
● Gestion de flux de travail : Pour garder une trace des tâches ou des processus dans un ordre spécifique.
Listes
Différents Types de Déclarations de Listes
● Liste Vide : ma_liste = []
● Liste avec des Éléments Prédéfinis : ma_liste = [1, 2, 3, "texte", True]
● Liste par Compréhension : ma_liste = [x for x in range(5)] (crée une liste avec les nombres de 0 à 4)
Exemples de Saisie et d'Affichage d'une Liste
Exemple 1 : Création et Affichage Simple
# Création d'une liste
nombres = [1, 2, 3, 4, 5]
# Affichage de la liste
print(nombres)
Exemples de Saisie et d'Affichage d'une Liste
Exemple 2 : Ajout d'Éléments et Affichage
# Création d'une liste vide
fruits = []
# Ajout d'éléments
[Link]( "Pomme")
[Link]( "Banane" )
[Link]( "Orange" )
# Affichage de la liste
print(fruits)
Exemples de Saisie et d'Affichage d'une Liste
Exemple 3 : Utilisation de Compréhension de Liste et Affichage
# Création d'une liste avec compréhension
carres = [x 2 for x in range(1, 6)]
# Affichage de la liste
print(carres)
Ces exemples illustrent comment les listes peuvent être créées, modifiées et utilisées pour stocker et traiter des données de manière
flexible en Python.
Les Fonctions associées aux listes
Les listes en Python sont dotées de plusieurs fonctions et méthodes intégrées qui les rendent extrêmement flexibles et puissantes pour la
manipulation de données. Voici quelques-unes des fonctions et méthodes les plus couramment utilisées associées aux listes :
Ajout et Extension
● append(element) : Ajoute un élément à la fin de la liste.
● extend(iterable) : Étend la liste avec tous les éléments d'un itérable (par exemple, une autre liste).
● insert(index, element) : Insère un élément à une position spécifique.
Suppression
● remove(element) : Supprime le premier élément correspondant à la valeur donnée.
● pop(index=-1) : Supprime et renvoie un élément à une position donnée (par défaut, le dernier).
● clear() : Efface tous les éléments de la liste.
Les Fonctions associées aux listes
Recherche et Comptage
● index(element, start, end) : Trouve l'index du premier élément correspondant à la valeur donnée, dans les bornes spécifiées.
● count(element) : Compte le nombre de fois où un élément apparaît dans la liste.
Tri et Inversion
● sort(key=None, reverse=False) : Trie les éléments de la liste en place.
● reverse() : Inverse l'ordre des éléments dans la liste.
Informations sur la Liste
● len(liste) : Renvoie le nombre d'éléments dans la liste (bien que len soit une fonction intégrée, pas une méthode de liste).
Les Fonctions associées aux listes
Ajout et Extension
nombres = [ 1, 2, 3]
# append(element) : Ajoute un élément à la fin de la liste.
[Link]( 4)
print("Après append:" , nombres)
# extend(iterable) : Étend la liste avec tous les éléments d'un itérable.
[Link]([ 5, 6, 7])
print("Après extend:" , nombres)
# insert(index, element) : Insère un élément à une position spécifique.
[Link]( 3, 'a') # Insère 'a' à la position d'index 3
print("Après insert:" , nombres)
Les Fonctions associées aux listes
Suppression
# remove(element) : Supprime le premier élément correspondant à la valeur donnée.
[Link]( 'a')
print("Après remove:" , nombres)
# pop(index=-1) : Supprime et renvoie un élément à une position donnée.
# Par défaut, supprime le dernier élément.
element_supprime = [Link]()
print("Element supprimé:" , element_supprime)
print("Après pop:" , nombres)
Les Fonctions associées aux listes
Suppression
# pop(index) : Supprime et renvoie un élément à une position spécifique.
element_supprime = [Link]( 2) # Supprime l'élément à l'index 2
print("Element supprimé à l'index 2:" , element_supprime)
print("Après pop avec index:" , nombres)
# clear() : Efface tous les éléments de la liste.
[Link]()
print("Après clear:" , nombres)
Les Fonctions associées aux listes
Recherche et Comptage
lettres = [ 'a', 'b', 'c', 'd', 'a', 'a', 'b']
# index(element, [start], [end]) : Trouve l'index du premier élément correspondant.
index_a = [Link]( 'a') # Trouve l'index de la première occurrence de 'a'
print("Index de 'a':" , index_a)
# count(element) : Compte le nombre de fois où un élément apparaît.
nombre_a = [Link]( 'a')
print("Nombre de 'a' dans la liste:" , nombre_a)
Les Fonctions associées aux listes
Tri et Inversion
nombres = [ 3, 1, 4, 1, 5, 9, 2]
# sort(key=None, reverse=False) : Trie les éléments de la liste.
[Link]()
print("Liste triée:" , nombres)
# sort avec reverse=True pour un tri décroissant.
[Link]( reverse=True)
print("Liste triée en ordre décroissant:" , nombres)
# reverse() : Inverse l'ordre des éléments.
[Link]()
print("Liste inversée:" , nombres)
Les Fonctions associées aux listes
Informations sur la Liste
# len(liste) : Renvoie le nombre d'éléments dans la liste.
longueur = len(nombres)
print("Nombre d'éléments dans la liste:" , longueur)
Exercices
Exercice 1 : Ajout et Suppression avec Saisie
Énoncé : Demandez à l'utilisateur de saisir cinq nombres. Stockez-les dans une liste. Demandez ensuite un sixième nombre à ajouter à la fin. Enfin,
supprimez le troisième nombre de la liste.
Exercice 2 : Recherche avec Saisie d'Utilisateur
Énoncé : Demandez à l'utilisateur de saisir une série de nombres avec une condition d'arrêt (par exemple, entrer '0'). Recherchez ensuite dans cette
liste un élément spécifique également saisi par l'utilisateur.
Exercice 3 : Comptage d'Occurrences avec Liste Initialisée
Énoncé : Initialisez une liste avec des éléments répétés. Demandez à l'utilisateur de saisir un élément. Comptez combien de fois cet élément apparaît
dans la liste.
Exercice 4 : Tri avec Taille Spécifique
Énoncé : Demandez à l'utilisateur de spécifier la taille d'une liste, puis de saisir les éléments de cette taille. Triez la liste en ordre croissant, puis en
ordre décroissant.
Exercices
Exercice 5 : Inversion sans `reverse()`
Énoncé : Initialisez une liste avec quelques éléments. Inversez l'ordre des éléments sans utiliser la méthode `reverse()`.
Exercice 6 : Concaténation avec Saisie de Deux Listes
Énoncé : Demandez à l'utilisateur de saisir deux listes. Concaténez ces deux listes pour former une troisième liste.
Exercice 7 : Liste des Carrés avec Taille Définie
Énoncé : Demandez à l'utilisateur de spécifier une taille de liste. Utilisez ensuite une compréhension de liste pour créer une liste des carrés des
nombres jusqu'à cette taille.
Exercice 8 : Filtrage avec Seuil de Saisie
Énoncé : Initialisez une liste de nombres. Demandez à l'utilisateur de saisir un seuil. Créez une nouvelle liste qui ne contient que les nombres
supérieurs à ce seuil.
Exercices
Exercice 9 : Élément le Plus Long avec Saisie
Énoncé : Demandez à l'utilisateur de saisir une série de chaînes de caractères, avec une condition d'arrêt. Trouvez ensuite l'élément le plus long de
cette liste.
Exercice 10 : Somme avec Liste Initialisée
Énoncé : Initialisez une liste avec une série de nombres. Calculez la somme de tous les éléments de cette liste.
Dictionnaire
Les dictionnaires en Python sont des structures de données qui stockent des paires clé-valeur. Chaque clé est unique et est utilisée pour
accéder à la valeur qui lui est associée. Les dictionnaires sont définis entre accolades `{}` avec des paires clé-valeur séparées par des
virgules. Les clés peuvent être de n'importe quel type immuable (comme des chaînes ou des nombres), tandis que les valeurs peuvent
être de n'importe quel type de données.
Exemple d'Utilisation dans la Vie Courante
1. Stockage d'Informations sur les Utilisateurs : Un dictionnaire peut être utilisé pour stocker des informations sur des utilisateurs,
comme des noms d'utilisateur, des adresses e-mail, et des mots de passe. Par exemple, `utilisateurs = {'alice': 'alice@[Link]', 'bob':
'bob@[Link]'}`.
2. Paramètres de Configuration : Dans le développement de logiciels, les dictionnaires sont souvent utilisés pour stocker des
paramètres de configuration. Par exemple, `config = {'theme': 'sombre', 'langue': 'français'}`.
3. Comptage de Fréquence : Pour compter la fréquence des éléments dans une collection, par exemple, compter le nombre de fois
qu'un mot apparaît dans un texte. Par exemple, `compte_mots = {'le': 3, 'chat': 1, 'court': 2}`.
Les dictionnaires sont flexibles, puissants et optimisés pour les accès rapides, les modifications et la recherche de données, rendant leur
utilisation très courante dans de nombreux aspects de la programmation Python.
Dictionnaire
Différents Types de Déclarations de Dictionnaire
● Déclaration Directe avec des Accolades => mon_dict = {"cle1": "valeur1", "cle2": "valeur2"}
● Utilisation du Constructeur dict() => mon_dict = dict(cle1="valeur1", cle2="valeur2")
● Dictionnaire Vide => mon_dict = {} ou mon_dict = dict()
● À Partir de Séquences => cles = ['cle1', 'cle2']
valeurs = ['valeur1', 'valeur2']
mon_dict = dict(zip(cles, valeurs))
Exemple de saisie et d’affichage
# Création d'un dictionnaire vide
mon_dictionnaire = {}
# Demander à l'utilisateur combien de paires clé-valeur il souhaite entrer
nombre_paires = int(input("Combien de paires clé-valeur voulez-vous ajouter ? "))
for i in range(nombre_paires):
# Saisie de la clé
cle = input(f"Entrez la clé pour l'élément {i+1} : ")
# Saisie de la valeur
valeur = input(f"Entrez la valeur pour la clé '{cle}' : ")
# Ajout de la paire clé-valeur au dictionnaire
mon_dictionnaire[cle] = valeur
# Affichage du dictionnaire
print("\nDictionnaire Complet:")
for cle, valeur in mon_dictionnaire.items():
print(f"{cle}: {valeur}")
Fonctions associées aux dictionnaires
1. `get(key, default=None)`
Renvoie la valeur pour une clé donnée. Si la clé n'est pas trouvée, renvoie `default`.
valeur = mon_dict.get('cle', 'valeur par défaut')
2. `keys()`
Renvoie un objet affichant toutes les clés du dictionnaire.
cles = mon_dict.keys()
3. `values()`
Renvoie un objet affichant toutes les valeurs du dictionnaire
valeurs = mon_dict.values()
4. `items()`
Renvoie un objet affichant les paires clé-valeur du dictionnaire.
paires = mon_dict.items()
Fonctions associées aux dictionnaires
5. `update(other_dict)`
Met à jour le dictionnaire avec les éléments d'un autre dictionnaire ou avec un ensemble de paires clé-valeur.
mon_dict.update(autre_dict)
6. `pop(key[, default])`
Supprime la clé spécifiée et renvoie la valeur correspondante. Si la clé n'est pas trouvée, renvoie `default` (qui est `None` si non
spécifié).
valeur = mon_dict.pop('cle', 'valeur par défaut')
7. `popitem()`
Supprime et renvoie une paire (clé, valeur) du dictionnaire. Les paires sont renvoyées dans un ordre LIFO.
cle, valeur = mon_dict.popitem()
8. `clear()`
Supprime tous les éléments du dictionnaire.
mon_dict.clear()
Fonctions associées aux dictionnaires
9. `copy()`
Renvoie une copie superficielle du dictionnaire.
copie_dict = mon_dict.copy()
10. `setdefault(key, default=None)`
Renvoie la valeur de la clé spécifiée. Si la clé n'existe pas, insère la clé avec la valeur `default`.
valeur = mon_dict.setdefault('nouvelle_cle', 'valeur par défaut')
