Sommaire
Pas de tableau, mais Python propose plusieurs structures de données: lists, tuples, dictionnaires, sets.
Ce sont des séquences ordonnées et modifiables (mutables) qui peuvent contenir des éléments hétérogènes (nombres, chaînes, objets, etc.).
Elles se définissent entre crochets [].
# Création d'une liste vide
ma_liste = []
# Création d'une liste avec des éléments
fruits = ["pomme", "banane", "cerise"]
nombres = [1, 2, 3, 4, 5]
mix = [42, "Python", True, 3.14]Opérations courantes sur les lites:
fruits = ["pomme", "banane", "cerise"]
# Accès par indice
print(fruits[0]) # "pomme"
print(fruits[-1]) # "cerise"
# Modification
fruits[1] = "orange"
# Ajout d'éléments
fruits.append("kiwi") # ajoute à la fin
fruits.insert(1, "mangue") # ajoute à un indice précis
# Suppression d'éléments
del fruit[0] # supprime le premier élément
fruits.remove("cerise") # supprime la première occurrence trouvée
dernier = fruits.pop() # supprime et retourne l'élément à l'indice donné, par défaut le dernier
# obtenir l'index d'un élément
banane_idx = fruits.index('banane') # sans l’opérateur "in" déclenche une erreur si la valeur n'existe pas
# une list pour contenir une autre liste
coordinates = [[0, 0], [100, 100], [200, 200]]
# trier une list
list.sort() # par défaut utilise l'opérateur <
list.sort(reverse=True) # trie inversé du plus grand au plus petitfruits = ["pomme", "banane", "cerise"]
# Parcourir une list
for fruit in fruits:
print(fruit)
# Parcourir une list avec l'index
for fruit in enumerate(fruits):
print(fruit) # (x, '_le_fruit_') - x étant l'index
# Parcourir une list avec l'index en "unpackant"
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}") # x: '_le_fruit_'
# Parcourir une list avec un index 'spécifique' en "unpackant"
for index, fruit in enumerate(fruits,5):
print(f"{index}: {fruit}") # x: '_le_fruit_' - x démarra à 5
# Utilisation de map() pour mettre chaque fruit en majuscules
resultat = map(str.upper, fruits)
# Conversion en liste pour afficher le résultat
print(list(resultat)) # Affiche : ['POMME', 'BANANE', 'CERISE']
# remarque utiliser list comprehension pour être plus concis
(voir plus bas pour plus de détails)Pour trouver l'index d'un élément on va utiliser l'opérateur in afin de vérifier si la valeur existe, pour ne pas déclencher d'erreur dans le cas contraire.
Voici un exemple extrait du tutoriel pythontutorial.net - python-find-index-of-element-in-list.
cities = ['New York', 'Beijing', 'Cairo', 'Mumbai', 'Mexico']
city = 'Osaka'
if city in cities:
result = cities.index(city)
print(f"The {city} has an index of {result}.")
else:
print(f"{city} doesn't exist in the list.")
# output -> Osaka doesn't exist in the list.Cet exemple est directement issue du tutoriel pythontutorial.net - sorting-a-list-of-tuples.
Pour faciliter le tri, on va implémenter une function intermédiaire, qu'on utilisera avec la fonction sort().
# soit la list suivante
companies = [('Google', 2019, 134.81),
('Apple', 2019, 260.2),
('Facebook', 2019, 70.7)]
# la fonction intermédiaire qui récupère la donnée souhaitée
def sort_key(company):
return company[2]
# on applique la fonction sort
companies.sort(key=sort_key, reverse=True)
# on peux également écrire une fonction lambda
# si on veut quelques chose de plus concis
companies.sort(key=lambda company: company[2])Si on souhaite conserver la list d'origine, on peut utiliser la fonction sorted().
Principe de base du slicing sur une list ma_liste[start:stop:step]
# Exemple de base
nombres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# On extrait les éléments d'indice 2 à 5 (5 exclus)
sous_liste = nombres[2:5]
print(sous_liste) # [2, 3, 4]
# Extrait depuis le début jusqu'à l'indice 4 (exclu)
sous_liste = nombres[:4]
print(sous_liste) # [0, 1, 2, 3]
# Extrait depuis l'indice 5 jusqu'à la fin
sous_liste = nombres[5:]
print(sous_liste) # [5, 6, 7, 8, 9]
# Utilisation d'un pas (step)
sous_liste = nombres[2:8:1]
print(sous_liste) # [2, 3, 4, 5, 6, 7]
# Pas différent (extraction tous les 2 éléments)
sous_liste = nombres[::2]
print(sous_liste) # [0, 2, 4, 6, 8]
# Slicing avec début, fin et pas personnalisés
sous_liste = nombres[1:8:3]
print(sous_liste) # [1, 4, 7]Avec un indice négatif, on peut compter à partir de la fin de la liste:
nombres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Derniers 3 éléments de la liste
sous_liste = nombres[-3:]
print(sous_liste) # [7, 8, 9]
# Extrait de l'indice -7 à -3 (exclu)
sous_liste = nombres[-7:-3]
print(sous_liste) # [3, 4, 5, 6]On peut également, copier, inverser, extraire avec des indices hors limites:
nombres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Slicing avec un pas négatif personnalisé
# Extrait les éléments en partant de la fin, un sur deux
sous_liste = nombres[::-2]
print(sous_liste) # [9, 7, 5, 3, 1]
# Slicing avec des indices hors limites (ne génère pas d'erreur)
sous_liste = nombres[5:50]
print(sous_liste) # [5, 6, 7, 8, 9]
# Slicing avec un début supérieur à la fin
sous_liste = nombres[8:4]
print(sous_liste) # []
# Slicing avec des indices égaux
sous_liste = nombres[3:3]
print(sous_liste) # []On peut également substituer/remplacer, supprimer des éléments via le slicing:
# Liste initiale
ma_liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Substituer les éléments d'indice 2 à 4 par de nouvelles valeurs
ma_liste[2:5] = ['a', 'b', 'c']
print(ma_liste) # [0, 1, 'a', 'b', 'c', 5, 6, 7, 8, 9]
# Remplacer par une séquence de même taille
ma_liste = [0, 1, 2, 3, 4, 5]
ma_liste[2:4] = ['x', 'y']
print(ma_liste) # [0, 1, 'x', 'y', 4, 5]
# Remplacer par une séquence de taille inférieure
ma_liste = [0, 1, 2, 3, 4, 5]
ma_liste[2:5] = ['a'] # Remplace trois éléments par un seul élément
print(ma_liste) # [0, 1, 'a', 5]
# Remplacer par une séquence de taille supérieure
ma_liste = [0, 1, 2, 3, 4, 5]
ma_liste[2:4] = ['p', 'q', 'r', 's'] # Remplace deux éléments par quatre éléments
print(ma_liste) # [0, 1, 'p', 'q', 'r', 's', 4, 5]
# Supprimer des éléments d'une liste
# En assignant une liste vide à un slice
ma_liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
ma_liste[3:7] = [] # Supprime les éléments d'indice 3 à 6
print(ma_liste) # [0, 1, 2, 7, 8, 9]
# En utilisant l'instruction del sur un slice
ma_liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del ma_liste[3:7] # Supprime les mêmes éléments
print(ma_liste) # [0, 1, 2, 7, 8, 9]Ces exemples illustrent la puissance et la flexibilité du slicing pour manipuler des listes en Python, en permettant non seulement l'extraction d'une portion, mais aussi sa substitution, son redimensionnement ou sa suppression. N'hésite pas à tester ces opérations pour bien comprendre leur comportement dans différents contextes !
Pense-bête des cas 'simple'.
Si dans l'ensemble, les exemples sont "facile" a comprendre, les nombreuses possibilités font que l'on peut vite s'y perdre. Prenons, le temps d'assimiler au moins les cas "simple":
| Opération | Syntaxe | Résultat attendu |
|---|---|---|
| Prendre les 5 premiers | liste[:5] |
[0, 1, 2, 3, 4] |
| Prendre les 5 derniers | liste[-5:] |
[5, 6, 7, 8, 9] |
| Sauter un élément sur deux | liste[::2] |
[0, 2, 4, 6, 8] |
| Inverser la liste | liste[::-1] |
[9, 8, 7, 6, ..., 0] |
| Supprimer les 3 premiers | del liste[:3] |
[3, 4, 5, 6, 7, 8, 9] |
| Remplacer 3 éléments par un seul | liste[2:5] = [99] |
[0, 1, 99, 5, 6, 7, 8, 9] |
L'unpacking permet de décomposer une liste ou un tuple en plusieurs variables. On peut aussi utiliser * pour capturer plusieurs éléments.
# exemple d'unpacking
data = [1, 2, 3]
a, b, c = data # a = 1, b = 2, c = 3
# utilisation * pour capturer plusieurs éléments
data = [1, 2, 3, 4, 5]
a, *middle, c = data # a = 1, middle = [2, 3, 4], c = 5Les lists sont flexibles et dynamique, au détriment de la performance pour la recherche et la suppression en début de liste.
Une list comprehension est une manière compacte de créer une nouvelle liste en appliquant une expression à chaque élément d'un itérable (par exemple, une liste, un tuple, ou un range), tout en pouvant y inclure des conditions de filtrage. Cela permet d'écrire du code plus lisible et concis, par rapport à une boucle for classique.
Syntaxe: [ expression for item in iterable ]
Il est également possible d'ajouter une condition pour filtrer les éléments :
[ expression for item in iterable if condition ]
# Créer une liste de nombres de 0 à 9 :
nombres = [x for x in range(10)]
print(nombres) # Affiche : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Créer une liste contenant le carré des nombres de 0 à 9 :
carres = [x**2 for x in range(10)]
print(carres) # Affiche : [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# "Filtrer" Créer une liste des nombres pairs entre 0 et 9 :
pairs = [x for x in range(10) if x % 2 == 0]
print(pairs) # Affiche : [0, 2, 4, 6, 8]
# List comprehension avec condition et transformation
# Crée une liste contenant la chaîne "Pair" pour les nombres pairs et "Impair" pour les nombres impairs :
resultat = [("Pair" if x % 2 == 0 else "Impair") for x in range(10)]
print(resultat)
# Affiche : ['Pair', 'Impair', 'Pair', 'Impair', 'Pair', 'Impair', 'Pair', 'Impair', 'Pair', 'Impair']
# List comprehension imbriquée
# une matrice (liste de listes) de dimensions 3x4
matrice = [[i * j for j in range(4)] for i in range(3)]
print(matrice)
# Affiche :
# [
# [0, 0, 0, 0],
# [0, 1, 2, 3],
# [0, 2, 4, 6]
# ]Avantages des list comprehensions:
for explicite, surtout pour les opérations simples.Comparaison avec les boucles for:
# Utiliser une list comprehension :
carres = [x**2 for x in range(10)]
# Est équivalent à écrire :
carres = []
for x in range(10):
carres.append(x**2)La version avec list comprehension est plus concise et souvent plus facile à comprendre pour des opérations simples.
Les list comprehensions sont un outil puissant en Python pour créer des listes de façon élégante et concise. Elles permettent de combiner transformation et filtrage d'éléments d'un itérable en une seule ligne de code, ce qui rend le code plus lisible et souvent plus performant (elle est implémentée en C en interne).
J'essaie de faire des distinctions ici, mais je manque d'expérience dans la pratique de Python, ce paragraphe manque de clarté pour le moment.
Python propose différentes façon d’itérer sur une list: for, map, filter, reduce, sorted, sort, list comprehensions.
Faisons le point sur l'utilisation de celles-ci. Soit la list suivante: fruits = ["pomme", "banane", "cerise"]
Supposons que nous souhaitions filtrer les fruits qui contiennent la lettre "a" (en minuscule) :
fruits = ["pomme", "banane", "cerise"]
filtered_fruits = list(filter(lambda fruit: "a" in fruit, fruits))
print(filtered_fruits) # Affiche : ['banane']La fonction lambda prend chaque élément de la liste et vérifie si "a" in fruit est vrai. Seuls les fruits pour lesquels la condition est vraie sont conservés.
Imaginons que nous souhaitions concaténer tous les fruits en une seule chaîne de caractères séparés par une virgule :
from functools import reduce
fruits = ["pomme", "banane", "cerise"]
concatenation = reduce(lambda acc, fruit: acc + ", " + fruit, fruits)
print(concatenation) # Affiche : "pomme, banane, cerise"acc (accumulateur) commence par la première valeur de la liste.La fonction sorted() trie un itérable et retourne une nouvelle liste triée sans modifier l'itérable original. Par exemple, pour trier alphabétiquement la liste des fruits :
fruits = ["pomme", "banane", "cerise"]
sorted_fruits = sorted(fruits)
print(sorted_fruits) # Affiche : ['banane', 'cerise', 'pomme']Remarque: pour une liste, on peut également utiliser la méthode sort() qui trie la liste en place et ne retourne rien.
fruits = ["pomme", "banane", "cerise"]
fruits.sort() # Trie la liste 'fruits' en place
print(fruits) # Affiche : ['banane', 'cerise', 'pomme']Important: sorted() fonctionne sur tout itérable (listes, tuples, ensembles, etc.) et retourne une nouvelle liste.
sort() est une méthode de liste qui trie l'objet lui-même et ne fonctionne que sur des listes.
cas d'utilisation:
for :
map() : Pour appliquer une transformation à chaque élément d'un itérable et retourner un nouvel itérable avec les résultats.
filter() : Pour sélectionner certains éléments qui satisfont une condition.
reduce() : Pour combiner les éléments d’un itérable en une seule valeur (agrégation, cumul, concaténation).
sorted() et sort():
sorted() retourne une nouvelle liste et fonctionne sur tout type d'itérable.sort() trie une liste en place (modifie l'objet original).List comprehensions() : Pour créer des listes de manière concise, en combinant transformation et filtrage d’éléments dans une seule expression.Comment choisir ?
map() (ou list comprehension sans condition) pour transformer tous les éléments.filter() pour sélectionner certains éléments selon une condition.reduce() pour combiner tous les éléments en une seule valeur.sorted() pour trier des itérables, en choisissant sort() pour modifier la liste originale.map() et filter() retournent des itérables, ce qui peut être plus efficace en termes de mémoire (traitement paresseux) dans certains contextes.for offrent plus de flexibilité pour des effets de bord ou des traitements complexes.Les Tuples sont des séquences ordonnées mais immuables. Une fois créés, leurs éléments ne peuvent pas être modifiés
Ils se définissent par des parenthèses () ou simplement par la virgule.
# Création d'un tuple
coordonnees = (10.0, 20.0)
couleurs = "rouge", "vert", "bleu" # Parenthèses optionnelles
numbers = (3,) # un tuple composé d'un seul élément (virgule obligatoire)
# exemple
def coordonnées():
return (10, 20)
x, y = coordonnées() # Déballage du tuple
print(x, y) # Affiche: 10 20Idéal pour stocker des données constantes. Ils sont couramment utilisés pour:
Le tuple unpacking (ou déballage de tuple) consiste à assigner les éléments d'un tuple (ou plus généralement d'un itérable) directement à des variables. Cette technique permet d'extraire plusieurs valeurs en une seule ligne, rendant le code plus concis et lisible.
Exemple de base :
# Un tuple simple
personne = ("Alice", 30, "Ingénieur")
# unpacking du tuple dans des variables
nom, age, profession = personne
print(nom) # Affiche "Alice"
print(age) # Affiche 30
print(profession) # Affiche "Ingénieur"L'opérateur * peut être utilisé dans le unpacking pour capturer un nombre variable d'éléments dans une liste. Cela est particulièrement utile lorsque le nombre d'éléments de l'itérable n'est pas fixe ou lorsque vous souhaitez isoler des éléments en début ou en fin de séquence.
# Tuple avec plusieurs éléments
nombres = (1, 2, 3, 4, 5)
# On affecte le premier élément à 'premier', le dernier à 'dernier'
# et tous les éléments intermédiaires à 'milieu' sous forme de liste
premier, *milieu, dernier = nombres
print(premier) # Affiche 1
print(milieu) # Affiche [2, 3, 4]
print(dernier) # Affiche 5Quelques points importants :
* ne peut être utilisé qu'une seule fois dans une affectation, sinon Python ne saura pas répartir correctement les éléments.* contiendra toujours une liste, même si la séquence captée ne contient qu'un seul élément ou est vide.Cas d'usage courants:
Récupérer des parties spécifiques d'une séquence: Vous pouvez isoler le premier ou le dernier élément et récupérer les autres dans une variable intermédiaire.
data = ("début", "milieu1", "milieu2", "fin")
premier, *corps, dernier = data
print(premier, corps, dernier)
# Affiche: début ['milieu1', 'milieu2'] finFonctions avec paramètres variables: L'extended unpacking est également très utilisé dans les définitions de fonctions pour capturer un nombre arbitraire d'arguments positionnels.
def afficher_elements(premier, *autres):
print("Premier élément:", premier)
print("Autres éléments:", autres)
afficher_elements(10, 20, 30, 40)
# Affiche: Premier élément: 10
# Autres éléments: (20, 30, 40)L'opérateur * peut également être utilisé du côté droit (dans une expression) pour décomposer une séquence au sein d'une nouvelle structure de données. Cela permet de créer facilement de nouveaux tuples ou listes en "étalant" (ou en "décompressant") le contenu d'un itérable dans une nouvelle séquence.
Exemple en Créant un Tuple: Lorsque vous souhaitez combiner plusieurs séquences en une seule, vous pouvez utiliser l'opérateur * pour "déballer" une séquence dans un nouveau tuple.
tuple1 = (1, 2, 3)
tuple2 = (4, 5)
# Crée un nouveau tuple qui combine tuple1 et tuple2
nouveau_tuple = (*tuple1, *tuple2)
print(nouveau_tuple) # Affiche (1, 2, 3, 4, 5)Vérifier le nombre d'éléments : Quand vous effectuez un unpacking, assurez-vous que le nombre d'éléments (sauf pour ceux capturés par *) correspond exactement à ce qui est attendu. Sinon, Python générera une ValueError.
Ce sont des collections où l'ordre d'insertion est conservé, qui stockent des paires clé:valeur.
Ils se définissent avec des accolades {}.
# Création d'un dictionnaire vide
mon_dict = {}
# Création avec des paires clé : valeur
etudiant = {
"nom": "Alice",
"age": 22,
"filière": "Informatique"
}
# Accès à une valeur par sa clé
print(etudiant["nom"]) # Affiche "Alice"
# Accès à une valeur par sa clé via get()
print(etudiant.get("nom") # Affiche "Alice"
print(etudiant.get("truc") # ne provoquera pas d'erreur
# Modification
etudiant["age"] = 23
# Ajout d'une nouvelle paire
etudiant["ville"] = "Paris"
# Suppression d'une clé
del etudiant["filière"]
# Itération sur un dictionnaire, via items() et unpack
for clé, valeur in etudiant.items():
print(clé, ":", valeur)
# itérer sur les valeurs en ignorant les clés via values()
for value in etudiant.values():
print(value) # affiche Alice, 22, InformatiqueLes dictionaries permettent une recherche très rapide grâce à l'indexation par clé. Flexibles pour associer des informations de manière explicite. Cela resemble aux tableaux scalaires de php.
Attention toutefois, les clés doivent être immuables (par exemple, chaînes, tuples).
Une dictionary comprehension permet de construire un dictionnaire en appliquant une expression aux clés et/ou aux valeurs d'un itérable.
Elle offre une syntaxe similaire à la list comprehension, mais produit un dictionnaire au lieu d'une liste.
Syntaxe :
# syntaxe de base
{ clé: valeur for élément in iterable }
# On peut également ajouter une condition pour filtrer les éléments
{ clé: valeur for élément in iterable if condition }
Créer un dictionnaire simple:
Supposons que nous voulions créer un dictionnaire associant un nombre à son carré pour les nombres de 0 à 4 :
carrés = {x: x**2 for x in range(5)}
print(carrés) # Affiche : {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}Inverser les clés et les valeurs:
Partons d'un dictionnaire existant et créons un nouveau dictionnaire avec les clés et valeurs inversées :
dico = {"a": 1, "b": 2, "c": 3}
inverse = {v: k for k, v in dico.items()}
print(inverse) # Affiche : {1: 'a', 2: 'b', 3: 'c'}Filtrer les éléments lors de la création:
Créons un dictionnaire pour ne retenir que les nombres pairs et associer à chaque nombre son carré :
nombres_pairs = {x: x**2 for x in range(10) if x % 2 == 0}
print(nombres_pairs) # Affiche : {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}Transformation sur des éléments complexes:
Imaginons que nous avons une liste de tuples contenant un nom et un âge, et nous souhaitons créer un dictionnaire qui associe le nom à l'âge, mais uniquement pour les personnes majeures (âge >= 18) :
personnes = [("Alice", 17), ("Bob", 20), ("Charlie", 16), ("Diane", 22)]
adultes = {nom: age for nom, age in personnes if age >= 18}
print(adultes) # Affiche : {'Bob': 20, 'Diane': 22}Avantages:
zip(), enumerate(), etc.Cas d'utilisation courants :
Les dictionary comprehensions sont un outil puissant en Python pour créer et manipuler des dictionnaires de manière concise.
Elles permettent de combiner transformation et filtrage dans une seule expression, ce qui facilite la lecture et l'écriture du code.
Les Sets sont des collections non ordonnées d'éléments uniques (aucun doublon).
Ils se définissent avec des accolades {} ou via la fonction set().
# Création d'un set
mon_set = set()
mon_set = {1, 2, 3, 4}
# Création via set()
autre_set = set([3, 4, 5, 6])
# ordre n'est pas conservé
characters = set('letter')
print(characters) # affiche {'r', 'l', 't', 'e'}
# Ajout d'un élément
mon_set.add(5)
# Suppression d'un élément
mon_set.remove(2) # Provoque une erreur si l'élément n'existe pas.
mon_set.discard(2) # Ne provoque pas d'erreur si l'élément n'existe pas.
mon_set.pop() # retire un élément arbitraire du set et le retourne
mon_set.clear() # supprime tous les éléments du set
# rendre un set immuable
mon_set = frozenset(mon_set)
# connaître la "taille" d'un set via len()
len(mon_set) # affiche 4
# vérifier si un élément existe dans le set via "in set" ou "not in set"
t=2
if t in mon_set:
print(f'mon_sert contient {t}') # mon_sert contient 2
# parcourir un set via for
for e in mon_set:
print(e) # affiche 1 2 3 4
# parcourir un set via for avec un index (foreach de php)
for index, e in enumerate(mon_set):
print(f"{index}-{e}") # affiche 0-1 1-2 2-3 3-4
# en spécifiant un index de départ
for index, e in enumerate(mon_set,1):
print(f"{index}-{e}") # affiche 1-1 2-2 3-3 4-4
# Opérations mathématiques (très utiles pour la théorie des ensembles)
# union
union = mon_set.union(autre_set) # via .union - accepte tous iterable
union = mon_set | autre_set # via | operator - seulement avec les sets
# Intersection - regroupe ce qui est "commun"
inter = lon_set.intersection(autre_set) # via .intersection - accepte tous iterable
inter = mon_set & autre_set # via & operator - seulement avec les sets
# Différence - récupère ce qui est différent dans le premier set
diff = mon_set.difference(autre_set) # via .difference - accepte tous iterable
diff = mon_set - autre_set # via - operator - seulement avec les sets
# Différence symétrique - récupère ce qui est différent dans chaque set
sym_diff = mon_set.symmetric_difference(autre_set) # via .symmetric_difference - accepte tous iterable
sym_diff = mon_set ^ autre_set # via ^ operator - seulement avec les setsIls permettent de garantir l'unicité, Les éléments ne conservent pas d'ordre. Ils sont utiles pour filtrer des doublons dans une collection et réaliser des opérations d'ensemble (union, intersection, etc.) qui sont très performantes.
En Python, un ensemble est une collection non ordonnée d'éléments uniques. Les ensembles sont particulièrement utiles pour effectuer des opérations mathématiques classiques comme l'union, l'intersection ou la différence.
La méthode union permet de créer un nouvel ensemble contenant tous les éléments présents dans plusieurs ensembles. Elle élimine automatiquement les doublons puisque, par définition, un ensemble ne contient qu'une seule occurrence de chaque élément.
Syntaxe: nouvel_ensemble = ensemble1.union(ensemble2, ensemble3, ...)
Voici un exemple illustrant l'utilisation de la méthode union() :
# Définition de deux ensembles
ensemble_a = {1, 2, 3}
ensemble_b = {3, 4, 5}
# Création d'un nouvel ensemble qui est l'union de ensemble_a et ensemble_b
resultat = ensemble_a.union(ensemble_b)
print(resultat) # Affiche {1, 2, 3, 4, 5}Dans cet exemple, l'élément commun 3 n'apparaît qu'une seule fois dans le résultat.
|En Python, l'opérateur | peut être utilisé de manière équivalente à la méthode union. Cet opérateur combine les ensembles de la même manière :
# Utilisation de l'opérateur |
resultat = ensemble_a | ensemble_b
print(resultat) # Affiche {1, 2, 3, 4, 5}Cet opérateur est particulièrement utile pour rendre le code plus concis.
La méthode union accepte plusieurs ensembles en argument. Par exemple :
ensemble_c = {5, 6, 7}
resultat = ensemble_a.union(ensemble_b, ensemble_c)
print(resultat) # Affiche {1, 2, 3, 4, 5, 6, 7}Ici, tous les éléments des ensembles ensemble_a, ensemble_b et ensemble_c sont combinés en un seul ensemble sans doublons.
|, Python offre d'autres opérateurs pour des opérations sur les ensembles, tels que & pour l'intersection et - pour la différence.La méthode union est un outil puissant pour combiner des ensembles en Python. Elle vous permet de rassembler tous les éléments uniques provenant de plusieurs ensembles en une seule opération simple et efficace.
La méthode intersection permet de créer un nouvel ensemble contenant uniquement les éléments communs à deux ou plusieurs ensembles. Autrement dit, elle retourne l'intersection des ensembles, c'est-à-dire les éléments qui apparaissent dans tous les ensembles considérés.
Syntaxe: resultat = ensemble1.intersection(ensemble2, ensemble3, ...)
intersection()Voici un exemple illustrant l'utilisation de la méthode intersection() :
# Définition de deux ensembles
ensemble_a = {1, 2, 3, 4}
ensemble_b = {3, 4, 5, 6}
# Création d'un nouvel ensemble qui est l'intersection de ensemble_a et ensemble_b
resultat = ensemble_a.intersection(ensemble_b)
print(resultat) # Affiche {3, 4}Dans cet exemple, seuls les éléments 3 et 4 sont communs aux deux ensembles, et c'est pourquoi ils apparaissent dans le résultat.
&En Python, l'opérateur & peut être utilisé de manière équivalente à la méthode intersection. Cet opérateur permet d'effectuer l'opération de façon plus concise :
resultat = ensemble_a & ensemble_b
print(resultat) # Affiche {3, 4}La méthode intersection peut également être utilisée pour comparer plus de deux ensembles :
ensemble_c = {4, 5, 6, 7}
# Intersection de ensemble_a, ensemble_b et ensemble_c
resultat = ensemble_a.intersection(ensemble_b, ensemble_c)
print(resultat) # Affiche {4}Dans ce cas, l’élément commun à tous les ensembles est uniquement 4.
Ensemble vide : Si aucun élément n'est commun à tous les ensembles, le résultat sera un ensemble vide.
ensemble_d = {8, 9}
resultat = ensemble_a.intersection(ensemble_d)
print(resultat) # Affiche set()Modification in-situ avec intersection_update : La méthode intersection_update permet de modifier directement l'ensemble d'origine en conservant uniquement les éléments communs.
ensemble_a = {1, 2, 3, 4}
ensemble_b = {3, 4, 5, 6}
ensemble_a.intersection_update(ensemble_b)
print(ensemble_a) # Affiche {3, 4}La méthode intersection et son équivalent opérateur & sont des outils essentiels pour travailler avec des ensembles en Python. Ils vous permettent de trouver rapidement et efficacement les éléments communs entre plusieurs ensembles, ce qui est particulièrement utile dans le traitement de données et l'optimisation des recherches.
La méthode difference permet de créer un nouvel ensemble contenant tous les éléments présents dans le premier ensemble qui ne figurent pas dans le second. Autrement dit, elle retourne la différence entre deux ensembles en éliminant les éléments communs.
Syntaxe: resultat = ensemble1.difference(ensemble2)
ensemble1.ensemble1 qui ne se trouvent pas dans ensemble2.difference()Voici un exemple illustrant l'utilisation de la méthode difference() :
# Définition de deux ensembles
ensemble_a = {1, 2, 3, 4, 5}
ensemble_b = {4, 5, 6, 7}
# Calcul de la différence : éléments de ensemble_a qui ne sont pas dans ensemble_b
resultat = ensemble_a.difference(ensemble_b)
print(resultat) # Affiche {1, 2, 3}Dans cet exemple, les éléments 4 et 5 sont présents dans les deux ensembles, ils sont donc retirés du résultat.
-En Python, l'opérateur - peut être utilisé de manière équivalente à la méthode difference pour obtenir la différence entre deux ensembles :
resultat = ensemble_a - ensemble_b
print(resultat) # Affiche {1, 2, 3}Cet opérateur permet d'écrire l'opération de manière plus concise.
difference_updateSi vous souhaitez modifier directement l'ensemble d'origine en retirant les éléments présents dans un autre ensemble, vous pouvez utiliser la méthode difference_update. Cette méthode modifie l'ensemble appelant en retirant les éléments communs.
ensemble_a = {1, 2, 3, 4, 5}
ensemble_b = {4, 5, 6, 7}
ensemble_a.difference_update(ensemble_b)
print(ensemble_a) # Affiche {1, 2, 3}Après l'appel à difference_update, ensemble_a ne contient plus que les éléments qui ne sont pas dans ensemble_b.
Sensibilité à l'ordre des ensembles : La différence n'est pas symétrique. Par exemple, ensemble_a.difference(ensemble_b) ne donne pas le même résultat que ensemble_b.difference(ensemble_a).
Ensemble vide : Si aucun élément n'est retiré, le résultat sera identique à l'ensemble de départ.
Multiples ensembles : Vous pouvez également passer plusieurs ensembles à la méthode difference pour retirer l'ensemble des éléments présents dans chacun d'eux.
ensemble_a = {1, 2, 3, 4, 5}
ensemble_b = {4, 5}
ensemble_c = {1, 6}
resultat = ensemble_a.difference(ensemble_b, ensemble_c)
print(resultat) # Affiche {2, 3}La méthode difference est un outil essentiel pour manipuler les ensembles en Python. Elle vous permet d'extraire rapidement les éléments exclusifs d'un ensemble par rapport à un autre, facilitant ainsi la comparaison et la gestion de collections de données. L'utilisation de l'opérateur - ou de la méthode difference_update offre des alternatives pour des cas d'usage spécifiques, rendant les opérations sur les ensembles à la fois flexibles et efficaces.
La méthode symmetric_difference permet de créer un nouvel ensemble contenant les éléments qui se trouvent dans l'un ou l'autre des ensembles, mais pas dans les deux en même temps. En d'autres termes, elle retourne la différence symétrique entre deux ensembles.
Définition: Différence symétrique : C'est l'ensemble de tous les éléments qui sont dans l'un des ensembles ou dans l'autre, mais pas dans leur intersection.
Syntaxe: resultat = ensemble1.symmetric_difference(ensemble2)
Prenons un exemple simple pour illustrer le fonctionnement :
# Définition de deux ensembles
ensemble_a = {1, 2, 3, 4}
ensemble_b = {3, 4, 5, 6}
# Calcul de la différence symétrique
resultat = ensemble_a.symmetric_difference(ensemble_b)
print(resultat) # Affiche {1, 2, 5, 6}Dans cet exemple, les éléments 3 et 4 étant communs aux deux ensembles, ils sont exclus du résultat. Seuls les éléments exclusifs (1, 2, 5 et 6) sont retenus.
^En Python, l'opérateur ^ offre une syntaxe plus concise pour obtenir la différence symétrique :
resultat = ensemble_a ^ ensemble_b
print(resultat) # Affiche {1, 2, 5, 6}Cet opérateur est équivalent à la méthode symmetric_difference et peut être utilisé pour simplifier le code.
symmetric_difference_updateSi vous souhaitez modifier directement l'ensemble d'origine pour qu'il devienne la différence symétrique avec un autre ensemble, vous pouvez utiliser la méthode symmetric_difference_update :
ensemble_a = {1, 2, 3, 4}
ensemble_b = {3, 4, 5, 6}
ensemble_a.symmetric_difference_update(ensemble_b)
print(ensemble_a) # Affiche {1, 2, 5, 6}Dans cet exemple, ensemble_a est mis à jour pour contenir uniquement les éléments qui ne sont pas communs à ensemble_a et ensemble_b.
Non-destructif versus in-situ :
Utilisation pratique: La différence symétrique est particulièrement utile lorsque vous devez identifier rapidement les différences entre deux ensembles de données, par exemple, pour détecter des modifications entre deux listes d'éléments.
La méthode symmetric_difference (et son équivalent avec l'opérateur ^) est un outil puissant pour comparer deux ensembles en Python. Elle vous permet d'extraire facilement les éléments exclusifs à chaque ensemble, simplifiant ainsi le traitement et la comparaison de données.
La méthode issubset permet de vérifier si tous les éléments d'un ensemble (l'ensemble "courant") se trouvent dans un autre ensemble. Autrement dit, elle teste si le premier ensemble est un sous-ensemble du second.
Syntaxe: ensemble1.issubset(ensemble2)
ensemble1.True si chaque élément de ensemble1 est contenu dans ensemble2 et False sinon.
Voici un exemple illustrant l'utilisation de issubset :
# Définition de deux ensembles
ensemble_a = {1, 2, 3}
ensemble_b = {1, 2, 3, 4, 5}
# Vérification si ensemble_a est un sous-ensemble de ensemble_b
print(ensemble_a.issubset(ensemble_b)) # Affiche True
# Vérification dans l'autre sens
print(ensemble_b.issubset(ensemble_a)) # Affiche False, car ensemble_b contient des éléments absents de ensemble_aensemble_a est un sous-ensemble de ensemble_b puisque tous ses éléments (1, 2, 3) se trouvent dans ensemble_b.ensemble_b n'est pas un sous-ensemble de ensemble_a car il contient des éléments (4, 5) qui ne sont pas présents dans ensemble_a.<=En Python, l'opérateur <= peut être utilisé pour vérifier si un ensemble est un sous-ensemble d'un autre, et il est équivalent à l'utilisation de issubset :
# Utilisation de l'opérateur <=
print(ensemble_a <= ensemble_b) # Affiche TrueDe manière similaire, l'opérateur < permet de tester si un ensemble est un sous-ensemble strict d'un autre (c'est-à-dire qu'il est contenu dans l'autre et qu'il n'est pas égal à celui-ci).
Exemple avec des chaînes de caractères
# Création d'ensembles à partir de chaînes de caractères
mot1 = set("abc")
mot2 = set("abcd")
print(mot1.issubset(mot2)) # Affiche True, car "abc" est contenu dans "abcd"Exemple avec des ensembles vides
Un ensemble vide est considéré comme un sous-ensemble de tout ensemble.
ensemble_vide = set()
ensemble_non_vide = {1, 2, 3}
print(ensemble_vide.issubset(ensemble_non_vide)) # Affiche TrueLa méthode issubset est très utile pour vérifier l'inclusion des éléments d'un ensemble dans un autre. Elle permet d'implémenter rapidement des vérifications logiques dans vos programmes et peut être utilisée en complément d'autres opérations sur les ensembles.
La méthode issuperset permet de vérifier si un ensemble est un sur-ensemble d'un autre. Autrement dit, elle teste si tous les éléments d'un autre ensemble se trouvent dans l'ensemble appelant.
Définition:
issuperset retourne True si l'ensemble appelant contient tous les éléments de l'ensemble passé en argument, et False sinon.Syntaxe: ensemble_A.issuperset(ensemble_B)
ensemble_A.Voici un exemple illustrant le fonctionnement de issuperset :
# Définition de deux ensembles
ensemble_A = {1, 2, 3, 4, 5}
ensemble_B = {2, 3, 5}
# Vérification si ensemble_A est un sur-ensemble de ensemble_B
print(ensemble_A.issuperset(ensemble_B)) # Affiche True>
# Autre exemple
ensemble_C = {2, 3, 6}
print(ensemble_A.issuperset(ensemble_C)) # Affiche False, car 6 n'est pas dans ensemble_ADans cet exemple, ensemble_A contient tous les éléments de ensemble_B, d'où le résultat True. En revanche, comme ensemble_A ne contient pas l'élément 6 de ensemble_C, le résultat est False.
>=En Python, l'opérateur >= peut être utilisé de manière équivalente à issuperset pour vérifier si un ensemble est un sur-ensemble d'un autre :
print(ensemble_A >= ensemble_B) # Affiche True
print(ensemble_A >= ensemble_C) # Affiche FalsePour vérifier un sur-ensemble strict (où l'ensemble appelant doit contenir des éléments en plus), l'opérateur > est utilisé :
print(ensemble_A > ensemble_B) # Affiche True si ensemble_A contient des éléments supplémentaires par rapport à ensemble_BNon-modification des ensembles.La méthode issuperset ne modifie pas les ensembles. Elle se contente de vérifier la relation d'inclusion.
Utilisation pratique, cette méthode est particulièrement utile dans des situations où vous devez vous assurer que certaines données ou conditions sont entièrement satisfaites par un ensemble de valeurs.
La méthode issuperset est un outil essentiel pour travailler avec les ensembles en Python. Elle permet de vérifier rapidement si tous les éléments d'un ensemble se trouvent dans un autre, facilitant ainsi les comparaisons et les validations de données. L'utilisation de l'opérateur >= offre une syntaxe alternative et concise pour cette vérification.
La méthode isdisjoint permet de vérifier si deux ensembles n'ont aucun élément en commun. Elle renvoie :
ensemble1.isdisjoint(ensemble2)Exemple 1: Ensembles disjoints
a = {1, 2, 3}
b = {4, 5, 6}
# Vérifie s'il n'y a aucun élément commun entre a et b
print(a.isdisjoint(b)) # Affiche True, car a et b n'ont aucun élément en communDans cet exemple, les ensembles a et b n'ont aucun élément en commun, donc la méthode renvoie True.
Exemple 2: Ensembles non disjoints
a = {1, 2, 3}
c = {3, 4, 5}
# Vérifie s'il n'y a aucun élément commun entre a et c
print(a.isdisjoint(c)) # Affiche False, car l'élément 3 est présent dans les deux ensemblesIci, l'élément 3 est partagé par les deux ensembles, ce qui fait que isdisjoint renvoie False.
isdisjoint peut être utilisée pour s'assurer que deux collections de données n'ont pas d'intersection, ce qui est utile dans des contextes où des doublons ou des conflits doivent être évités.isdisjoint ne modifie pas les ensembles originaux.La méthode isdisjoint est un outil simple mais puissant pour comparer deux ensembles en Python. Elle permet de vérifier rapidement si deux ensembles sont complètement distincts, c'est-à-dire sans aucun élément commun, ce qui peut être très utile dans de nombreux scénarios de validation et de traitement de données.