Python: Structures de données courantes

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

👋 Bienvenue sur la documentation de Stackhero !

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

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

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

Python propose plusieurs structures de données pour organiser, stocker et manipuler efficacement vos données. Les plus utilisées sont les listes, tuples, dictionnaires et ensembles. Les listes et tuples conservent un ordre, les dictionnaires stockent des paires clé-valeur, et les ensembles contiennent uniquement des éléments uniques. Chaque structure dispose de méthodes adaptées à des besoins 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 ordonnées et modifiables d'éléments. Elles acceptent les doublons et peuvent contenir différents types de données, y compris d'autres listes, tuples, dictionnaires ou ensembles. Vous pouvez facilement ajouter, modifier ou supprimer des éléments. Les listes sont définies avec des crochets [] et les éléments sont séparés par des virgules.

Points clés sur les listes :

1. Modifiables et ordonnées
2. Acceptent les éléments dupliqués
3. Conservent l'ordre d'ajout des éléments
4. Supportent plusieurs types de données
5. Permettent d'ajouter, modifier et supprimer des éléments

Les listes sont très 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])  # Affiche : 1
print(my_list[-1])  # Affiche : 5

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

# Modifier des éléments
my_list[0] = 0
print(my_list)  # Affiche : [0, 2, 3, 4, 5, 6]

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

Dictionnaires

Les dictionnaires sont des collections modifiables et non ordonnées de paires clé-valeur. Chaque clé doit être unique et permet d'accéder à sa valeur associée. Comme les listes, les dictionnaires peuvent contenir différents types de données, y compris des collections imbriquées. Ils sont définis avec des accolades {} et les paires clé-valeur sont séparées par des virgules, la clé et la valeur étant séparées par un deux-points.

Points clés sur les dictionnaires :

1. Collection modifiable et non ordonnée
2. Composée de paires clé-valeur avec des clés uniques
3. Accès aux valeurs via les clés
4. Stockent différents types de données

Les dictionnaires sont idéaux pour les recherches rapides, comme 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'])  # Affiche : 1

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

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

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

Tuples

Les tuples sont des collections ordonnées et immuables d'éléments. Ils fonctionnent comme les listes, à la différence qu'une fois créés, leurs éléments ne peuvent plus être modifiés, ajoutés ou supprimés. Les tuples sont définis avec des parenthèses () et les éléments sont 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 non modifiable, ou si 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])  # Affiche : 1
print(my_tuple[-1])  # Affiche : 5

# Remarque : Les tuples sont immuables

Ensembles

Les ensembles sont des collections modifiables et non ordonnées qui ne contiennent que des éléments uniques. Ils éliminent automatiquement les doublons et ne conservent pas l'ordre. Les ensembles peuvent contenir différents types de données, à l'exception des types modifiables comme les listes et les dictionnaires. Ils peuvent être définis avec des accolades {} ou le constructeur set().

Points clés sur les ensembles :

1. Modifiables et non ordonnés
2. Ne stockent que des éléments uniques, suppression automatique des doublons
3. Excluent les types modifiables (comme les listes et dictionnaires)

Les ensembles sont parfaits pour tester l'appartenance, dédupliquer des données ou effectuer des opérations ensemblistes comme l'union, l'intersection ou la différence.

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

# Tester l'appartenance
print(1 in my_set)  # Affiche : True

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

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

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