Python Set Vs List: la vera differenza

Nel mondo della programmazione Python, incontrerai spesso varie strutture di dati che servono a scopi diversi. Tra queste strutture, gli insiemi e gli elenchi sono comunemente usati per archiviare e manipolare raccolte di dati.

Anche se possono sembrare simili, ci sono notevoli differenze nelle loro proprietà e casi d'uso.

Sommario

• Comprensione degli insiemi e degli elenchi di Python
  • Cosa sono i set Python?
  • Cosa sono le liste Python
• 3 Differenze chiave tra insiemi ed elenchi
  • 1. Ordine e indicizzazione
  • 2. Mutevolezza
  • Unicità degli elementi
  • 3. Operazioni supportate
• Come si sceglie la giusta struttura dati?
  • Usa i casi per gli insiemi
  • Usa i casi per le liste
• AConfronto delle prestazioni tra insiemi ed elenchi
  • Complessità temporale
  • Utilizzo della memoria
• Operazioni e metodi comuni
  • Imposta metodo
  • Metodo elenco
• La nostra ultima parola

Comprensione degli insiemi e degli elenchi di Python

Ok, allora spieghiamo prima le cose.

Cosa sono i set Python?

Un set Python è una struttura dati incorporata che rappresenta una raccolta non ordinata di elementi distinti, chiamati membri.

Questo potente strumento è particolarmente utile nelle applicazioni di data science e nelle operazioni matematiche.

I set Python hanno le seguenti proprietà:

1. Sono non ordinati, il che significa che gli elementi in un set vengono archiviati indipendentemente dal loro indice. Questa raccolta non ordinata di valori univoci supporta test di appartenenza efficienti e comprensioni di insiemi.

2. Non consentono valori duplicati. Ciò li rende utili quando è necessario lavorare con valori univoci, rimuovere duplicati da un elenco o eseguire operazioni su insiemi come unioni, intersezioni e differenze simmetriche.

Ci sono due modi per creare un set in Python:

1. Utilizzando le parentesi graffe ({}), note anche come parentesi graffe.

2. Utilizzando la funzione predefinita set(), che accetta un singolo argomento, un iterabile contenente gli elementi che si desidera includere nell'insieme.

Di seguito viene fornita una sintassi generica per la creazione di un set Python utilizzando le parentesi graffe e la funzione set incorporata:

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

Cosa sono le liste Python

Un elenco Python è una struttura dati incorporata simile agli array dinamici in altri linguaggi di programmazione.

Sono utilizzati per memorizzare più elementi in una singola variabile, rendendoli un'opzione versatile per la gestione di vari tipi di dati, come stringhe, numeri e valori booleani.

Gli elenchi Python hanno le seguenti proprietà:

1. Sono ordinati, il che significa che un particolare elemento ha una posizione univoca in un elenco ed è accessibile tramite il suo indice. Questa raccolta ordinata supporta l'accesso casuale, consentendo di eseguire operazioni quali suddivisione, concatenazione e comprensione dell'elenco.

2. Sono mutabili e i loro elementi possono essere modificati dopo aver creato un elenco, offrendo flessibilità quando si lavora con strutture di dati.

3. Gli elenchi Python consentono valori duplicati e possono memorizzare una combinazione di tipi di dati, tra cui stringhe, numeri e valori booleani.

Esistono due modi per creare un elenco in Python:

1. Usando le parentesi quadre, che denotano i confini dell'elenco.

2. Utilizzando la funzione integrata list(), che può accettare un singolo argomento o un iterabile contenente gli elementi che si desidera includere nell'elenco.

Il seguente codice Python dimostra la creazione di un elenco Python utilizzando le parentesi quadre e la funzione list() incorporata:

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

3 Differenze chiave tra insiemi ed elenchi

Sono molteplici differenze tra un set Python e un elenco. Alcuni di quelli importanti sono elencati di seguito:

1. Ordine e indicizzazione

Ordine e indicizzazione nell'elenco Python : un elenco Python può supportare l'indicizzazione, il che significa che puoi accedere agli elementi in un elenco utilizzando la loro posizione nell'elenco. Ciò fornisce flessibilità durante la manipolazione dei dati con un ordine noto.

Il seguente codice Python dimostra l'ordine e l'indicizzazione delle liste:

# 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)

Set Python: un set Python è una raccolta non ordinata senza indicizzazione, il che significa che non è possibile accedere agli elementi utilizzando la loro posizione. Questo è utile quando l'ordine degli elementi non ha importanza.

Il seguente codice Python mostra gli insiemi di ordine e indicizzazione:

# 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. Mutevolezza

Elenco Python: un elenco Python è mutabile e consente di modificarne gli elementi. Possono contenere qualsiasi tipo di oggetto, incluse le liste nidificate, offrendo così maggiore flessibilità in termini di contenuto che possono memorizzare.

Il codice seguente dimostra la mutabilità negli elenchi 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]

Set Python: proprio come un elenco in Python, anche un set Python è mutabile e può essere modificato. Tuttavia, i set in Python possono contenere solo oggetti hashable (immutabili), il che significa che non è possibile avere un set di set o un set contenente oggetti mutabili come le liste.

Il codice seguente dimostra la mutabilità dei set 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à degli elementi

Set Python: una caratteristica chiave dei set è che memorizzano solo elementi univoci. L'aggiunta di valori duplicati a un elenco viene ignorata. Ciò rende un oggetto set ideale per diverse operazioni sugli insiemi, come la rimozione di duplicati o il controllo della presenza di elementi univoci.

# 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]

• 

  Elenchi Python: gli elenchi consentono valori duplicati e mantengono il loro ordine, che può essere essenziale nei casi d'uso in cui i duplicati e l'ordine degli elementi svolgono un ruolo significativo.

  # 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. Operazioni supportate

Esistono diverse operazioni che è possibile eseguire su insiemi ed elenchi, ciascuna ottimizzata per attività specifiche:

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. Iterazione: gli elenchi sono leggermente più veloci degli insiemi quando si tratta di iterare sugli elementi. Questo perché gli insiemi richiedono operazioni aggiuntive per garantire l'univocità, mentre gli elenchi mantengono una semplice raccolta ordinata con indicizzazione diretta.

Utilizzo della memoria

I set in genere consumano più memoria degli elenchi perché devono mantenere una tabella hash per garantire l'univocità degli elementi, il che comporta un maggiore consumo di memoria.

Gli elenchi memorizzano solo gli elementi in sequenza, portando a un minore consumo di memoria, rendendoli una scelta più efficiente in termini di memoria quando si gestiscono grandi raccolte di dati.

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")

Il codice fornito mostra il confronto delle prestazioni tra insiemi ed elenchi Python in termini di complessità temporale per la ricerca e l'iterazione.

Genera un ampio elenco e un insieme di numeri interi casuali, racchiusi tra parentesi graffe (chiamate anche parentesi graffe).

Quindi misura il tempo impiegato per cercare un elemento specifico, utilizzando un singolo argomento sia nell'elenco che nell'insieme, e misura il tempo impiegato per scorrere tutti gli elementi nell'elenco e nell'insieme.

L'output illustra le differenze di prestazioni tra elenchi e set Python per la ricerca e l'iterazione, che derivano dalla loro implementazione sottostante.

L'operazione di ricerca è più veloce nei set (0,000000 secondi) che negli elenchi (0,002999 secondi) a causa dell'uso delle funzioni hash per calcolare i valori hash per ricerche efficienti. Tuttavia, l'iterazione su un elenco (0,007995 secondi) è leggermente più veloce dell'iterazione su un set (0,017989 secondi) poiché i set richiedono operazioni aggiuntive per garantire l'univocità.

Operazioni e metodi comuni

Sia gli insiemi che gli elenchi in Python hanno varie operazioni e metodi, ciascuno ottimizzato per attività specifiche e manipolazione dei dati. Alcuni di questi metodi sono elencati di seguito:

Imposta metodo

I metodi set eseguono operazioni simili alle operazioni matematiche e sono potenti strumenti per la gestione di valori univoci in una raccolta.

• add(element): Aggiunge un elemento all'insieme se non è già presente.

• remove(element): Rimuove l'elemento specificato dall'insieme; genera un errore se l'elemento non viene trovato.

• scarto(elemento): Rimuove l'elemento specificato dall'insieme se è presente. Nessun errore viene generato se l'elemento non viene trovato.

• union(set2): restituisce un nuovo set contenente tutti gli elementi del set originale e set2, eseguendo effettivamente un'operazione set.

• crossing(set2): restituisce un nuovo set contenente elementi comuni sia al set originale che a set2.

• Difference(set2): restituisce un nuovo set contenente elementi nel set originale ma non in set2.

• symmetric_difference(set2): restituisce un nuovo set contenente elementi nel set originale o in set2, ma non in entrambi.

Metodo elenco

I metodi List forniscono vari modi per manipolare i dati.

• append(element): aggiunge un elemento alla fine dell'elenco.

• extend(iterable): aggiunge tutti gli elementi dall'iterable (ad esempio, un altro elenco) alla fine dell'elenco.

• insert(index, element): Inserisce un elemento all'indice specificato.

• remove(element): Rimuove la prima occorrenza dell'elemento specificato nella lista; genera un errore se l'elemento non è presente.

• pop(index): Rimuove e restituisce l'elemento all'indice specificato. Se non viene fornito alcun indice, rimuove l'ultimo elemento.

• index(element): Restituisce l'indice della prima occorrenza dell'elemento specificato nell'elenco.

• count(element): Restituisce il numero di occorrenze dell'elemento specificato nell'elenco.

• sort(): ordina l'elenco in ordine crescente per impostazione predefinita; per l'ordine decrescente, utilizzare il parametro reverse=True.

• reverse(): inverte l'ordine degli elementi nell'elenco.

Usando questi metodi set ed elenchi Python, puoi manipolare efficacemente i tuoi dati e risolvere vari problemi nella programmazione Python, nella scienza dei dati e in altre applicazioni.

La nostra ultima parola

Quando scegli tra elenchi e set Python per la tua struttura di dati, prendi in considerazione l'utilizzo di elenchi quando hai bisogno di una raccolta ordinata di elementi, desideri conservare elementi duplicati e richiedere la possibilità di accedere agli elementi per indice.

Optare per i set quando l'unicità degli elementi è essenziale, l'ordine degli elementi non è importante e si preferisce un test di appartenenza più rapido. Mentre gli elenchi eccellono nell'iterazione, gli insiemi forniscono controlli di contenimento più efficienti.

La tua scelta dipende in ultima analisi dai requisiti del tuo progetto, poiché ogni struttura di dati offre il proprio insieme di vantaggi e limiti, rendendoli strumenti potenti per affrontare varie attività nella programmazione Python. Godere!