Tuples, ensembles et dictionnaires Python || Jour #f #daysofMiva

C'est le jour n°5 de #100daysofMiva - Voir les projets GitHub
.

J'ai exploré trois structures de données fondamentales en Python : les tuples, les ensembles et les dictionnaires. Ces structures sont essentielles pour organiser et accéder efficacement aux données, chacune ayant des caractéristiques et des cas d’utilisation uniques. Voici un rapport détaillé de ce que j'ai appris, y compris les processus, les détails techniques et des exemples de code.

1. Tuples

Définition : Un tuple est une collection immuable et ordonnée d'éléments. Les tuples sont similaires aux listes mais avec la principale différence qu'ils ne peuvent pas être modifiés après la création.

Caractéristiques :

Immuable : Une fois créés, les éléments d'un tuple ne peuvent pas être modifiés (pas d'affectation, d'ajout ou de suppression d'éléments).

Ordonné : Les éléments conservent leur ordre et l'indexation est prise en charge.
Hétérogène : les tuples peuvent stocker des éléments de différents types.

Création de tuples

Les tuples peuvent être créés à l'aide de parenthèses () ou simplement en séparant les éléments par des virgules.

python

my_tuple = (1, 2, 3)
another_tuple = "a", "b", "c"
singleton_tuple = (42,)  # Note the comma, necessary for single element tuples

Accès aux éléments

Les éléments sont accessibles via l'indexation, similaire aux listes.

python
Copy code
first_element = my_tuple[0]
last_element = my_tuple[-1]

Déballage des tuples

Les tuples permettent d'attribuer plusieurs variables à la fois.

python
Copy code
a, b, c = my_tuple
print(a)  # 1
print(b)  # 2
print(c)  # 3

Pourquoi utiliser des tuples ?

Performance : Les tuples sont généralement plus rapides que les listes en raison de leur immuabilité.

Intégrité des données : L'immuabilité garantit que les données ne peuvent pas être modifiées, ce qui rend les tuples idéaux pour les collections fixes d'éléments.

Hashable : Parce qu'ils sont immuables, les tuples peuvent être utilisés comme clés dans des dictionnaires ou comme éléments dans des ensembles.

2. Ensembles

Définition : Un ensemble est une collection non ordonnée d'éléments uniques. Les ensembles sont couramment utilisés pour tester l’adhésion et éliminer les entrées en double.

Caractéristiques :

Non ordonné : Aucune commande n'est maintenue, l'indexation n'est donc pas possible.

Éléments uniques : Chaque élément doit être unique ; les doublons sont automatiquement supprimés.

Mutable : Des éléments peuvent être ajoutés ou supprimés, bien que les éléments eux-mêmes doivent être immuables.

Création d'ensembles

Les ensembles sont créés à l'aide d'accolades {} ou de la fonction set().

python
Copy code
my_set = {1, 2, 3, 4}
another_set = set([4, 5, 6])  # Creating a set from a list
empty_set = set()  # Note: {} creates an empty dictionary, not a set

Opérations de base sur les ensembles

Les ensembles prennent en charge diverses opérations telles que l'union, l'intersection et la différence.

python

# Union
union_set = my_set | another_set
print(union_set)  # {1, 2, 3, 4, 5, 6}

# Intersection
intersection_set = my_set & another_set
print(intersection_set)  # {4}

# Difference
difference_set = my_set - another_set
print(difference_set)  # {1, 2, 3}

Test d'adhésion

Les ensembles sont optimisés pour des tests d'adhésion rapides.

python

print(3 in my_set)  # True
print(7 in my_set)  # False

Pourquoi utiliser des ensembles ?

Éléments uniques : Idéal pour stocker des articles où l'unicité est requise.

Opérations efficaces : Les opérations telles que les tests d'appartenance et l'algèbre d'ensembles (union, intersection) sont plus rapides que les listes.

Élimination des doublons : La conversion d'une liste en un ensemble est une technique courante pour supprimer les doublons.

3. Dictionnaires

Définition : Un dictionnaire est une collection non ordonnée de paires clé-valeur. Chaque clé d'un dictionnaire est unique et correspond à une valeur.

Caractéristiques :

Paires clé-valeur : Les clés sont uniques et immuables, tandis que les valeurs peuvent être de n'importe quel type.

Non ordonné : Avant Python 3.7, les dictionnaires n'étaient pas ordonnés. À partir de Python 3.7, ils conservent l'ordre d'insertion.

Mutable : Les dictionnaires peuvent être modifiés en ajoutant, supprimant ou modifiant des paires clé-valeur.

Créer des dictionnaires

Les dictionnaires sont créés à l'aide d'accolades {} avec des paires clé-valeur séparées par des deux-points.

python

my_dict = {"name": "Alice", "age": 30, "city": "New York"}
another_dict = dict(name="Bob", age=25, city="Los Angeles")
empty_dict = {}

Accéder aux valeurs

Les valeurs sont accessibles à l'aide de leurs clés.

`python

nom = mon_dict["nom"]
age = my_dict.get("age") # Utiliser get() pour éviter KeyError`

Ajout et modification d'entrées

Les dictionnaires sont dynamiques ; vous pouvez ajouter ou modifier des entrées à la volée.

python

my_dict["email"] = "alice@example.com"  # Adding a new key-value pair
my_dict["age"] = 31  # Modifying an existing value

Suppression d'entrées

Les entrées peuvent être supprimées à l'aide de la méthode del ou pop().

python

del my_dict["city"]  # Removing a key-value pair
email = my_dict.pop("email", "No email provided")  # Removes and returns the value

*Méthodes du dictionnaire
*
Les dictionnaires disposent de diverses méthodes utiles :

python

keys = my_dict.keys()  # Returns a view of the dictionary's keys
values = my_dict.values()  # Returns a view of the dictionary's values
items = my_dict.items()  # Returns a view of the dictionary's key-value pairs

Pourquoi utiliser des dictionnaires ?

Accès basé sur une clé : Idéal pour les scénarios où les données doivent être récupérées rapidement via un identifiant unique (la clé).

Structure dynamique : Utile pour les structures de données qui doivent croître et changer au fil du temps.

Efficace : L'accès basé sur une clé est généralement plus rapide que la recherche dans une liste ou un tuple.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!