Python Set Vs List - La vraie différence

Dans le monde de la programmation Python, vous rencontrerez souvent diverses structures de données qui servent à des fins différentes. Parmi ces structures, les ensembles et les listes sont couramment utilisés pour stocker et manipuler des collections de données.

Bien qu'ils puissent sembler similaires, il existe des différences notables dans leurs propriétés et leurs cas d'utilisation.

Table des matières

• Comprendre les ensembles et les listes Python
  • Que sont les ensembles Python ?
  • Que sont les listes Python
• 3 différences clés entre les ensembles et les listes
  • 1. Commande et indexation
  • 2. Mutabilité
  • Unicité des éléments
  • 3. Opérations prises en charge
• Comment choisir la bonne structure de données ?
  • Cas d'utilisation pour les ensembles
  • Cas d'utilisation pour les listes
• Comparaison des performances entre les ensembles et les listes
  • Complexité temporelle
  • Utilisation de la mémoire
• Opérations et méthodes courantes
  • Définir la méthode
  • Méthode de liste
• Notre dernier mot

Comprendre les ensembles et les listes Python

Ok, alors expliquons les choses d'abord.

Que sont les ensembles Python ?

Un ensemble Python est une structure de données intégrée qui représente une collection non ordonnée d'éléments distincts, appelés membres.

Cet outil puissant est particulièrement utile dans les applications de science des données et les opérations mathématiques.

Les ensembles Python ont les propriétés suivantes :

1. Ils ne sont pas ordonnés, ce qui signifie que les éléments d'un ensemble sont stockés indépendamment de leur index. Cette collection non ordonnée de valeurs uniques prend en charge des tests d'appartenance efficaces et des compréhensions d'ensembles.

2. Ils n'autorisent pas les valeurs en double. Cela les rend utiles lorsque vous devez travailler avec des valeurs uniques, supprimer des doublons d'une liste ou effectuer des opérations d'ensemble telles que des unions, des intersections et des différences symétriques.

Il existe deux manières de créer un ensemble en Python :

1. En utilisant des accolades ({}), également appelées accolades.

2. En utilisant la fonction intégrée set(), qui prend un seul argument, un itérable contenant les éléments que vous souhaitez inclure dans l'ensemble.

Une syntaxe générique pour créer un ensemble Python à l'aide d'accolades et de la fonction set intégrée est donnée ci-dessous :

my_set = {1, 2, 3}
another_set = set([4, 5, 6])

Que sont les listes Python

Une liste Python est une structure de données intégrée similaire aux tableaux dynamiques dans d'autres langages de programmation.

Ils sont utilisés pour stocker plusieurs éléments dans une seule variable, ce qui en fait une option polyvalente pour gérer divers types de données, tels que des chaînes, des nombres et des booléens.

Les listes Python ont les propriétés suivantes :

1. Ils sont ordonnés, ce qui signifie qu'un élément particulier occupe une position unique dans une liste et est accessible via son index. Cette collection ordonnée prend en charge l'accès aléatoire, ce qui vous permet d'effectuer des opérations telles que le découpage, la concaténation et la compréhension de liste.

2. Ils sont modifiables et leurs éléments peuvent être modifiés après la création d'une liste, offrant une flexibilité lors de l'utilisation de structures de données.

3. Les listes Python autorisent les valeurs en double et peuvent stocker un mélange de types de données, y compris des chaînes, des nombres et des booléens.

Il existe deux manières de créer une liste en Python :

1. En utilisant des crochets, qui indiquent les limites de la liste.

2. En utilisant la fonction intégrée list(), qui peut prendre un seul argument ou un itérable contenant les éléments que vous souhaitez inclure dans la liste.

Le code Python suivant illustre la création d'une liste Python à l'aide de crochets et de la fonction intégrée list() :

list1 = [1, 2, 3] 
list2 = list([4, 5, 6])

3 différences clés entre les ensembles et les listes

Ce sont de multiples différences entre un ensemble Python et une liste. Certains des plus importants sont énumérés ci-dessous :

1. Commande et indexation

Ordre et indexation dans la liste Python : une liste Python peut prendre en charge l'indexation, ce qui signifie que vous pouvez accéder aux éléments d'une liste en utilisant leur position dans la liste. Cela offre une flexibilité lors de la manipulation de données avec un ordre connu.

Le code Python suivant illustre l'ordre et l'indexation des listes :

# Creating a Python list
my_list = [3, 5, 2, 8, 1]

# Accessing elements using their index
first_element = my_list[0]  # This will be 3
third_element = my_list[2]  # This will be 2

# Modifying elements using their index
my_list[1] = 7  # The list becomes [3, 7, 2, 8, 1]

# Iterating over a list maintaining the order
for item in my_list:
    print(item)

Ensembles Python : un ensemble Python est une collection non ordonnée sans indexation, ce qui signifie que vous ne pouvez pas accéder aux éléments en utilisant leur position. Ceci est utile lorsque l'ordre des éléments n'a pas d'importance.

Le code Python suivant illustre les ensembles d'ordre et d'indexation :

# Creating a Python set
my_set = {3, 5, 2, 8, 1}

# Sets are unordered, so you cannot access elements using their position
# This would raise an error: first_element = my_set[0]

# Modifying a set by adding or removing elements
my_set.add(6)       # The set becomes {1, 2, 3, 5, 6, 8}
my_set.discard(5)   # The set becomes {1, 2, 3, 6, 8}

# Iterating over a set (order is not guaranteed)
for item in my_set:
    print(item)

2. Mutabilité

Liste Python : une liste Python est modifiable, ce qui vous permet de modifier ses éléments. Ils peuvent contenir tout type d'objet, y compris des listes imbriquées, offrant ainsi plus de flexibilité en termes de contenu qu'ils peuvent stocker.

Le code suivant illustre la mutabilité dans les listes Python :

# Creating a Python list
my_list = [3, 5, 2, 8, 1]

# Modifying the list by appending elements
my_list.append(4)  # The list becomes [3, 5, 2, 8, 1, 4]

# Modifying the list by removing elements
my_list.remove(2)  # The list becomes [3, 5, 8, 1, 4]

# Lists can hold any type of object, including nested lists
nested_list = [1, 2, [3, 4], 5]

Ensemble Python : tout comme une liste en Python, un ensemble Python est également modifiable et peut être modifié. Cependant, les ensembles en Python ne peuvent contenir que des objets hachables (immuables), ce qui signifie que vous ne pouvez pas avoir un ensemble d'ensembles ou un ensemble contenant des objets mutables comme des listes.

Le code suivant illustre la mutabilité des ensembles Python :

# Creating a Python set
my_set = {3, 5, 2, 8, 1}

# Modifying the set by adding elements
my_set.add(6)       # The set becomes {1, 2, 3, 5, 6, 8}

# Modifying the set by removing elements
my_set.discard(5)   # The set becomes {1, 2, 3, 6, 8}

# Sets can only hold hashable (immutable) objects
valid_set = {1, 2, 3, 4, (5, 6)}

# The following would raise an error because lists are mutable and cannot be stored in sets
# invalid_set = {1, 2, [3, 4]}

Unicité des éléments

Ensembles Python : une caractéristique clé des ensembles est qu'ils ne stockent que des éléments uniques. L'ajout de valeurs en double à une liste est ignoré. Cela rend un objet d'ensemble idéal pour différentes opérations d'ensemble, telles que la suppression des doublons ou la vérification de la présence d'éléments uniques.

# Creating a Python set with duplicate elements
my_set = {3, 5, 2, 8, 1, 3, 2, 5}
# The duplicate elements are automatically removed: {1, 2, 3, 5, 8}

# Checking for the presence of a unique element
if 5 in my_set:
    print("5 is in the set")
# Output: 5 is in the set

# Removing duplicates from a list using a set
my_list = [3, 5, 2, 8, 1, 3, 2, 5]
unique_list = list(set(my_list))
# The unique_list becomes [1, 2, 3, 5, 8]

• 

  Listes Python : les listes autorisent les valeurs en double et maintiennent leur ordre, ce qui peut être essentiel dans les cas d'utilisation où les doublons et l'ordre des éléments jouent un rôle important.

  # Creating a Python list with duplicate elements
  my_list = [3, 5, 2, 8, 1, 3, 2, 5]
  # The list contains duplicate values: [3, 5, 2, 8, 1, 3, 2, 5]
  
  # Checking for the presence of an element in a list
  if 5 in my_list:
      print("5 is in the list")
  # Output: 5 is in the list
  
  # Counting the occurrences of a value in a list
  count_of_5 = my_list.count(5)
  print("5 appears", count_of_5, "times")
  # Output: 5 appears 2 times

  

3. Opérations prises en charge

Il existe différentes opérations que l'on peut effectuer sur des ensembles et des listes, chacune optimisée pour des tâches spécifiques :

Python Lists: Due to their ordered and index-based nature, lists support operations like slicing, concatenation, repetition, and list comprehension. They also provide built-in methods, such as append(), pop(), and sort(), that allow you to manipulate elements of a list.

# Creating a Python list
my_list = [3, 5, 2, 8, 1]

# Slicing a list
sub_list = my_list[1:4]  # The sub_list becomes [5, 2, 8]

# Concatenation of two lists
list1 = [1, 2, 3]
list2 = [4, 5, 6]
concatenated_list = list1 + list2  # The concatenated_list becomes [1, 2, 3, 4, 5, 6]

# Repetition of a list
repeated_list = list1 * 2  # The repeated_list becomes [1, 2, 3, 1, 2, 3]

# List comprehension
squared_list = [x ** 2 for x in my_list]  # The squared_list becomes [9, 25, 4, 64, 1]

# Using built-in methods
my_list.append(4)  # The list becomes [3, 5, 2, 8, 1, 4]
my_list.pop()      # The list becomes [3, 5, 2, 8, 1]
my_list.sort()     # The list becomes [1, 2, 3, 5, 8]

Python Sets: Sets are optimized for performing set-related operations like union, intersection, difference, and checking membership using hash functions to find elements quickly. Since they are unordered and lack indexing, set operations differ from list-based ones.

# Creating Python sets
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# Union operation
union_set = set1.union(set2)  # The union_set becomes {1, 2, 3, 4, 5, 6, 7, 8}

# Intersection operation
intersection_set = set1.intersection(set2)  # The intersection_set becomes {4, 5}

# Difference operation
difference_set = set1.difference(set2)  # The difference_set becomes {1, 2, 3}

# Checking membership
if 3 in set1:
    print("3 is a member of set1")
# Output: 3 is a member of set1

How Do You Choose The Right Data Structure?

When working with Python, it’s essential to select the most suitable data structure for your specific task. In this section, we will discuss the best scenarios for using sets and lists, along with their unique advantages.

Let’s get into it.

Use Cases for Sets

Sets offer several advantages that make them the ideal choice for certain tasks:

Uniqueness: If you need to store a collection of unique elements, sets are the way to go. Sets automatically eliminate duplicates, ensuring that each element in the set is distinct.

Membership tests: Sets provide faster membership tests compared to lists. Due to their underlying hash table implementation and the use of hash functions, sets allow for highly efficient lookups based on hash values.

Set operations: Sets support operations such as union, intersection, difference, and symmetric difference that can be useful in many algorithms, data processing tasks, and data science applications.

Use Cases for Lists

Lists are better suited for the following scenarios:

Ordered data: Lists maintain the order of elements, making them suitable for tasks that require respecting the sequence of items, such as processing data in the order it was created or when support indexing is needed.

Mutable data: Lists are mutable, allowing you to add, remove, or modify a specific element as needed. This flexibility makes lists suitable for tasks that involve changing the content of the collection or when working with nested data structures, such as lists of lists or dictionaries.

Non-unique elements: Unlike sets, lists can store duplicate elements, making them appropriate for situations where the frequency of items matters, such as counting occurrences or maintaining the order of duplicate values.

Check out the below to show to further your learning.

APerformance Comparison Between Sets and Lists

In this section, we will compare the performance of Python sets and lists in terms of time complexity and memory usage, which is essential when working with large data structures or when optimizing code for efficiency.

Time Complexity

When it comes to time complexity, sets and lists have different strengths and weaknesses depending on the operations you perform due to their underlying implementation.

1. Searching: Sets use hash lookups and hash functions, which makes searching for an item significantly faster compared to lists. For example, searching through 100,000 items takes 49.663 seconds with a list, but only 0.007 seconds with a set, as it takes advantage of the hash value for quick access.

2. Itération : les listes sont légèrement plus rapides que les ensembles lorsqu'il s'agit d'itérer sur les éléments. En effet, les ensembles nécessitent des opérations supplémentaires pour garantir l'unicité, tandis que les listes conservent une collection ordonnée simple avec indexation directe.

Utilisation de la mémoire

Les ensembles consomment généralement plus de mémoire que les listes car ils doivent maintenir une table de hachage pour garantir l'unicité des éléments, ce qui se fait au prix d'une consommation de mémoire accrue.

Les listes ne stockent les éléments que de manière séquentielle, ce qui réduit la consommation de mémoire, ce qui en fait un choix plus efficace en termes de mémoire lors de la gestion de grandes collections de données.

import time
import random

# Generating a large list and set with 100,000 random integers
large_list = [random.randint(1, 1_000_000) for _ in range(100_000)]
large_set = set(large_list)

# Searching for an item in the list and set
search_value = random.randint(1, 1_000_000)

# Measuring the time it takes to search for the item in the list
start_time = time.time()
result = search_value in large_list
end_time = time.time()
list_search_time = end_time - start_time
print(f"List search time: {list_search_time:.6f} seconds")

# Measuring the time it takes to search for the item in the set
start_time = time.time()
result = search_value in large_set
end_time = time.time()
set_search_time = end_time - start_time
print(f"Set search time: {set_search_time:.6f} seconds")

# Iterating over the list and set
# Measuring the time it takes to iterate over the list
start_time = time.time()
for item in large_list:
    pass
end_time = time.time()
list_iter_time = end_time - start_time
print(f"List iteration time: {list_iter_time:.6f} seconds")

# Measuring the time it takes to iterate over the set
start_time = time.time()
for item in large_set:
    pass
end_time = time.time()
set_iter_time = end_time - start_time
print(f"Set iteration time: {set_iter_time:.6f} seconds")

Le code fourni présente la comparaison des performances entre les ensembles Python et les listes en termes de complexité temporelle pour la recherche et l'itération.

Il génère une longue liste et un ensemble d'entiers aléatoires, entourés d'accolades (également appelées accolades).

Il mesure ensuite le temps nécessaire pour rechercher un élément spécifique, en utilisant un seul argument à la fois dans la liste et dans l'ensemble, et mesure le temps nécessaire pour parcourir tous les éléments de la liste et de l'ensemble.

La sortie illustre les différences de performances entre les listes Python et les ensembles pour la recherche et l'itération, qui découlent de leur implémentation sous-jacente.

L'opération de recherche est plus rapide dans les ensembles (0,000000 secondes) que dans les listes (0,002999 secondes) en raison de l'utilisation de fonctions de hachage pour calculer les valeurs de hachage pour des recherches efficaces. Cependant, l'itération sur une liste (0,007995 secondes) est légèrement plus rapide que l'itération sur un ensemble (0,017989 secondes) car les ensembles nécessitent des opérations supplémentaires pour garantir l'unicité.

Opérations et méthodes courantes

Les ensembles et les listes en Python ont diverses opérations et méthodes, chacune optimisée pour des tâches spécifiques et la manipulation de données. Certaines de ces méthodes sont répertoriées ci-dessous :

Définir la méthode

Les méthodes d'ensemble effectuent des opérations similaires aux opérations mathématiques et sont des outils puissants pour gérer des valeurs uniques dans une collection.

• add(element) : ajoute un élément à l'ensemble s'il n'est pas déjà présent.

• remove(element) : supprime l'élément spécifié de l'ensemble ; génère une erreur si l'élément n'est pas trouvé.

• jeter(element) : Supprime l'élément spécifié de l'ensemble s'il est présent. Aucune erreur n'est générée si l'élément n'est pas trouvé.

• union(set2) : renvoie un nouvel ensemble contenant tous les éléments de l'ensemble d'origine et de l'ensemble2, effectuant ainsi une opération d'ensemble.

• intersection(set2) : renvoie un nouvel ensemble contenant des éléments communs à l'ensemble d'origine et à l'ensemble2.

• difference(set2) : renvoie un nouvel ensemble contenant des éléments de l'ensemble d'origine mais pas de l'ensemble2.

• symmetric_difference(set2) : renvoie un nouvel ensemble contenant des éléments soit dans l'ensemble d'origine, soit dans l'ensemble2, mais pas dans les deux.

Méthode de liste

Les méthodes de liste offrent différentes manières de manipuler les données.

• append(element) : ajoute un élément à la fin de la liste.

• extend(itérable) : ajoute tous les éléments de l'itérable (par exemple, une autre liste) à la fin de la liste.

• insert(index, element) : insère un élément à l'index spécifié.

• remove(element) : supprime la première occurrence de l'élément spécifié dans la liste ; génère une erreur si l'élément n'est pas présent.

• pop(index) : supprime et renvoie l'élément à l'index spécifié. Si aucun index n'est donné, il supprime le dernier élément.

• index(element) : renvoie l'index de la première occurrence de l'élément spécifié dans la liste.

• count(element) : renvoie le nombre d'occurrences de l'élément spécifié dans la liste.

• sort() : trie la liste par ordre croissant par défaut ; pour l'ordre décroissant, utilisez le paramètre reverse=True.

• reverse() : Inverse l'ordre des éléments dans la liste.

En utilisant ces méthodes d'ensemble et de liste Python, vous pouvez manipuler efficacement vos données et résoudre divers problèmes de programmation Python, de science des données et d'autres applications.

Notre dernier mot

Lorsque vous choisissez entre des listes et des ensembles Python pour votre structure de données, envisagez d'utiliser des listes lorsque vous avez besoin d'une collection ordonnée d'éléments, que vous souhaitez conserver les éléments en double et que vous avez besoin de pouvoir accéder aux éléments par index.

Optez pour des ensembles lorsque l'unicité des éléments est essentielle, que l'ordre des éléments n'est pas important et qu'un test d'adhésion plus rapide est préférable. Alors que les listes excellent dans l'itération, les ensembles fournissent des contrôles de confinement plus efficaces.

Votre choix dépend en fin de compte des exigences de votre projet, car chaque structure de données offre son propre ensemble d'avantages et de limites, ce qui en fait des outils puissants pour s'attaquer à diverses tâches de programmation Python. Apprécier!