Python: Structures de données courantes

Cette documentation fait partie du guide Apprendre Python. Consultez le guide complet ici : Un guide complet sur Python.

👋 Bienvenue sur la documentation de Stackhero !

Stackhero propose une solution cloud Python prête à l'emploi offrant de nombreux avantages, notamment :

• Déployez votre application en quelques secondes avec un simple git push.
• Utilisez votre propre nom de domaine et bénéficiez de la configuration automatique des certificats HTTPS pour une sécurité renforcée.
• Profitez de la tranquillité d'esprit avec des sauvegardes automatiques, des mises à jour en un clic, et une tarification simple, transparente et prévisible.
• Obtenez des performances optimales et une sécurité robuste grâce à une VM privée et dédiée.

Gagnez du temps et simplifiez-vous la vie : il ne faut que 5 minutes pour essayer la solution d'hébergement cloud Python de Stackhero !

Python fournit plusieurs structures de données pour vous aider à organiser, stocker et manipuler efficacement les données. Les plus couramment utilisées sont les listes, les tuples, les dictionnaires et les ensembles. Les listes et les tuples maintiennent une séquence ordonnée d'éléments, les dictionnaires stockent des paires clé-valeur, et les ensembles stockent des éléments uniques. Chaque structure propose une gamme de méthodes adaptées à des cas d'utilisation spécifiques.

• Liste : my_list = [1, 2, 3, 4]
• Tuple : my_tuple = (1, 2, 3, 4)
• Dictionnaire : my_dictionary = {'key1': 'value1', 'key2': 'value2'}
• Ensemble : my_set = {1, 2, 3, 4}

Listes

Les listes sont des collections d'éléments mutables et ordonnées. Elles permettent les doublons et peuvent contenir des éléments de divers types de données, y compris d'autres listes, tuples, dictionnaires ou ensembles. Vous pouvez facilement ajouter, mettre à jour et supprimer des éléments. Les listes sont définies entre crochets [] avec des éléments séparés par des virgules.

Points clés sur les listes :

1. Mutables et ordonnées
2. Permettent les éléments dupliqués
3. Maintiennent l'ordre d'ajout des éléments
4. Supportent plusieurs types de données
5. Fournissent des opérations pour ajouter, mettre à jour et supprimer des éléments

Les listes sont couramment utilisées lorsque vous avez besoin d'une collection dynamique et redimensionnable d'éléments.

Exemples :

# Créer une liste
my_list = [1, 2, 3, 4, 5]

# Accéder aux éléments
print(my_list[0])  # Sortie : 1
print(my_list[-1])  # Sortie : 5

# Ajouter des éléments
my_list.append(6)
print(my_list)  # Sortie : [1, 2, 3, 4, 5, 6]

# Mettre à jour des éléments
my_list[0] = 0
print(my_list)  # Sortie : [0, 2, 3, 4, 5, 6]

# Supprimer des éléments
del my_list[0]
print(my_list)  # Sortie : [2, 3, 4, 5, 6]

Dictionnaires

Les dictionnaires sont des collections mutables et non ordonnées de paires clé-valeur. Chaque clé doit être unique, et vous pouvez utiliser ces clés pour accéder à leurs valeurs associées. Comme les listes, les dictionnaires peuvent stocker des éléments de divers types de données, y compris des collections imbriquées. Ils sont définis entre accolades {} avec des paires clé-valeur séparées par des virgules, et des clés et valeurs séparées par un deux-points.

Points clés sur les dictionnaires :

1. Collection mutable et non ordonnée
2. Composée de paires clé-valeur avec des clés uniques
3. Accès aux valeurs à l'aide des clés
4. Stockent divers types de données

Les dictionnaires sont idéaux pour les tâches nécessitant des recherches, telles que les paramètres de configuration ou les comptages de fréquence.

Exemples :

# Créer un dictionnaire
my_dictionary = {'a': 1, 'b': 2, 'c': 3}

# Accéder aux éléments
print(my_dictionary['a'])  # Sortie : 1

# Ajouter des éléments
my_dictionary['d'] = 4
print(my_dictionary)  # Sortie : {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Mettre à jour des éléments
my_dictionary['a'] = 0
print(my_dictionary)  # Sortie : {'a': 0, 'b': 2, 'c': 3, 'd': 4}

# Supprimer des éléments
del my_dictionary['a']
print(my_dictionary)  # Sortie : {'b': 2, 'c': 3, 'd': 4}

Tuples

Les tuples sont des collections immuables et ordonnées d'éléments. Ils fonctionnent comme les listes, sauf qu'une fois un tuple créé, ses éléments ne peuvent pas être modifiés, ajoutés ou supprimés. Les tuples sont définis à l'aide de parenthèses () avec des éléments séparés par des virgules.

Points clés sur les tuples :

1. Collection immuable et ordonnée
2. Supportent plusieurs types de données
3. Structure de taille fixe

Les tuples sont utiles lorsque vous avez besoin d'une collection inchangeable, ou lorsque vous souhaitez utiliser la collection comme clé de dictionnaire.

Exemple :

# Créer un tuple
my_tuple = (1, 2, 3, 4, 5)

# Accéder aux éléments
print(my_tuple[0])  # Sortie : 1
print(my_tuple[-1])  # Sortie : 5

# Remarque : Les tuples sont immuables

Ensembles

Les ensembles sont des collections mutables et non ordonnées qui stockent des éléments uniques. Ils suppriment automatiquement les doublons et ne maintiennent pas d'ordre. Les ensembles peuvent contenir des éléments de divers types de données, à l'exclusion des types mutables comme les listes et les dictionnaires. Ils peuvent être définis à l'aide d'accolades {} ou du constructeur set().

Points clés sur les ensembles :

1. Mutables et non ordonnés
2. Stockent uniquement des éléments uniques, supprimant automatiquement les doublons
3. Excluent les types mutables (comme les listes et les dictionnaires)

Les ensembles sont idéaux pour les tests d'appartenance, la déduplication et les opérations d'ensemble comme l'union, l'intersection et la différence.

# Créer un ensemble
my_set = {1, 2, 3, 4, 5}

# Vérifier l'appartenance
print(1 in my_set)  # Sortie : True

# Ajouter un élément
my_set.add(6)
print(my_set)  # Sortie : {1, 2, 3, 4, 5, 6}

# Mettre à jour en supprimant un élément et en ajoutant un autre
my_set.remove(1)
my_set.add(0)
print(my_set)  # Sortie : {0, 2, 3, 4, 5, 6}

# Supprimer un élément
my_set.remove(0)
print(my_set)  # Sortie : {2, 3, 4, 5, 6}