Tuples and Sets: Use Cases Explained

1. Tuples : Les Listes Immuables

Commençons par les tuples. Un tuple est très similaire à une liste : c'est une collection ordonnée d'éléments. La différence fondamentale est qu'un tuple est immuable (unchangeable). Une fois que vous avez créé un tuple, vous ne pouvez ni ajouter, ni supprimer, ni modifier ses éléments.

On crée un tuple en utilisant des parenthèses ().

# Un tuple pour des coordonnées
coordonnees = (48.8584, 2.2945) # (latitude, longitude) de la Tour Eiffel




# Un tuple pour une couleur RGB
couleur_rouge = (255, 0, 0)




# On peut accéder aux éléments par leur index, comme avec les listes
print(f"Latitude : {coordonnees[0]}")

La tentative de modifier un tuple provoquera une erreur. C'est une protection, pas une limitation.

# Ce code va générer une erreur !
# coordonnees[0] = 49.0 
# TypeError: 'tuple' object does not support item assignment

Quand utiliser les tuples ?

1. Intégrité des données : Lorsque vous avez des données qui ne doivent pas changer (constantes, configurations, etc.). L'immutabilité garantit que ni vous ni une autre partie de votre programme ne les modifierez par accident.
2. Clés de dictionnaire : Contrairement aux listes, les tuples peuvent être utilisés comme clés dans un dictionnaire, car ils sont immuables. C'est utile pour des clés composées.
3. Performance : Les tuples sont souvent un peu plus rapides et consomment un peu moins de mémoire que les listes.

Les opérations sur les tuples sont limitées en raison de leur nature immuable. Vous pouvez parcourir un tuple avec une boucle for et utiliser des méthodes qui ne le modifient pas, comme .count() (compter les occurrences d'un élément) et .index() (trouver l'index d'un élément).

Pour une ressource en arabe, la chaîne Elzero, que vous appréciez, propose des leçons sur les tuples.

2. Sets : Pour les Éléments Uniques et Non Ordonnés

Passons maintenant aux sets (ensembles). Un set est une collection non ordonnée d'éléments uniques. Pensez-y comme à une collection mathématique.

• Uniques : Un set ne peut pas contenir de doublons. Si vous essayez d'ajouter un élément qui existe déjà, il ne se passera rien.
• Non ordonnés : Les éléments d'un set n'ont pas de position ou d'index. Vous ne pouvez donc pas y accéder avec mon_set[0].

On crée un set avec des accolades {} (comme un dictionnaire, mais sans paires clé-valeur) ou avec la fonction set().

# Créer un set
tags_de_blog = {'python', 'machine learning', 'data science', 'python'}




# Le doublon 'python' est automatiquement supprimé
print(tags_de_blog) 



# Le résultat sera {'data science', 'python', 'machine learning'} (l'ordre peut varier)




# On ne peut pas accéder par index
# print(tags_de_blog[0]) # TypeError: 'set' object is not subscriptable

Quand utiliser les sets ?

1. Supprimer les doublons : C'est le cas d'usage le plus courant. Convertir une liste en set est la manière la plus simple et rapide d'obtenir ses éléments uniques.
2. Test d'appartenance : Vérifier si un élément est présent dans un set (element in mon_set) est extrêmement rapide, bien plus que dans une liste. C'est très utile lorsque vous devez faire cette vérification de nombreuses fois sur une grande collection.
3. Opérations mathématiques : Si vous avez une formation en mathématiques, vous apprécierez le fait que les sets supportent des opérations comme l'union, l'intersection, la différence, etc.

# 1. Supprimer les doublons d'une liste
nombres = [1, 2, 5, 2, 3, 4, 5, 1]
nombres_uniques = set(nombres)
print(f"Nombres uniques : {nombres_uniques}") # {1, 2, 3, 4, 5}




# 2. Test d'appartenance rapide
print('python' in tags_de_blog) # True
print('java' in tags_de_blog)   # False




# 3. Opérations sur les ensembles
set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}




# Union (tous les éléments des deux sets)
print(f"Union : {set_a | set_b}") # {1, 2, 3, 4, 5, 6}




# Intersection (éléments en commun)
print(f"Intersection : {set_a & set_b}") # {3, 4}




# Différence (éléments dans A mais pas dans B)
print(f"Différence : {set_a - set_b}") # {1, 2}

Bien que les sets soient non ordonnés, ils sont mutables. Vous pouvez y ajouter (.add()) et en supprimer (.remove()) des éléments.

Vous pouvez également consulter les leçons correspondantes d'Elzero en arabe.

3. Tableau Récapitulatif

Pour vous aider à visualiser les différences, voici un tableau qui résume les quatre principales structures de données que nous avons vues.

4. Exercice Pratique

Imaginons que vous analysiez les données d'un petit site web. Vous avez une liste de logs, où chaque log est un tuple (user_id, page_visitee).

# 1. Voici les données de logs. Notez l'utilisation d'une liste de tuples.
#    Pourquoi un tuple est-il un bon choix ici pour chaque entrée de log ?
logs = [
    (101, '/accueil'),
    (102, '/prix'),
    (101, '/contact'),
    (103, '/accueil'),
    (101, '/accueil'),
    (102, '/produits'),
    (104, '/contact'),
    (102, '/prix'),
]




# 2. Vous voulez savoir combien d'utilisateurs uniques ont visité le site.
#    Créez un set contenant tous les user_id pour éliminer les doublons.
user_ids = []
for log in logs:
    user_ids.append(log[0])

unique_user_ids = set(user_ids)
print(f"Nombre d'utilisateurs uniques : {len(unique_user_ids)}")
print(f"IDs des utilisateurs uniques : {unique_user_ids}")




# 3. De même, vous voulez connaître l'ensemble des pages uniques qui ont été visitées.
#    Créez un set des pages visitées.
pages = [log[1] for log in logs] # Une façon plus concise de créer une liste
unique_pages = set(pages)
print(f"Nombre de pages uniques visitées : {len(unique_pages)}")
print(f"Pages uniques : {unique_pages}")

Question de réflexion pour l'étape 1 : Un tuple est un bon choix pour chaque entrée de log car une entrée de log est un enregistrement d'un événement passé. Il ne doit pas être modifié. L'immutabilité du tuple protège l'intégrité de ces données.

Résultat attendu :

Nombre d'utilisateurs uniques : 4
IDs des utilisateurs uniques : {101, 102, 103, 104}
Nombre de pages uniques visitées : 4
Pages uniques : {'/produits', '/prix', '/contact', '/accueil'}

(Note : l'ordre des éléments dans les sets peut varier)

Conclusion

Félicitations ! Vous maîtrisez maintenant les quatre structures de données de base en Python : les listes, les dictionnaires, les tuples et les sets. Chacune a sa place et son utilité.

Points clés à retenir :

• Tuple : Utilisez-le quand vous avez besoin d'une collection ordonnée et non modifiable (immuable). C'est le choix de la sécurité et de la performance pour des données constantes.
• Set : Utilisez-le quand vous avez besoin d'une collection d'éléments uniques et que l'ordre n'a pas d'importance. Idéal pour supprimer les doublons et pour des tests d'appartenance très rapides.

Savoir quand utiliser chaque structure est une compétence clé qui rendra votre code plus propre, plus efficace et moins sujet aux erreurs.

Dans la prochaine leçon, nous découvrirons les list comprehensions. C'est une syntaxe élégante et puissante pour créer des listes, souvent à partir des collections que nous venons d'étudier. C'est l'une des caractéristiques les plus appréciées de Python