Show More
Menu
Image
Hi there! I am Federico Trotta

Technical WriterFreelance

Data Structures in Python: la Guida Completa

Novembre 24, 2023
By Federico
0 Comments
Post Image

Se hai iniziato a programmare, che tu voglia diventare un ingegnere del software o un data scientist, devi assolutamente padroneggiare le data structures in Python.

Ci sono diverse tipologie di data structures in Python (altrimenti dette “strutture dati” in italiano) che ci consentono di archiviare dati. In questo articolo approfondiremo quelli più utilizzati. Quindi, se stai iniziando la tua carriera e hai bisogno di imparare le strutture dei dati, allora questo articolo fa sicuramente per te.


Data structures in Python: le liste

Data structures in Python dal blog di Federico Trotta: una lista
Foto di Gerd Altmann da Pixabay

Esempi su come si definiscano e come si creino le liste in Python

Tra le data structures in Python, una lista è una raccolta di elementi ordinati che possono essere di qualsiasi tipo: stringhe, interi, float, ecc…

Per creare una lista, gli elementi devono essere inseriti tra parentesi quadre e devono essere separati da una virgola. Ad esempio, ecco come possiamo creare una lista di numeri interi:

# Create list of integers
my_integers = [1, 2, 3, 4, 5, 6]

Ma le liste possono anche avere tipologie di dati “misti” memorizzati al loro interno. Ad esempio, creiamo una lista con sia numeri interi che stringhe:

# Create a mixed list
mixed_list = [1, 3, "dad", 101, "apple"]

Per creare una lista, possiamo anche usare la funzione integrata Python list(). Ecco come possiamo usarlo:

# Create list and print it
my_list = list((1, 2, 3, 4, 5))
print(my_list)
>>>  
    [1, 2, 3, 4, 5]


Questa funzione integrata direttamente in Python è molto utile in alcuni casi particolari. Ad esempio, supponiamo di voler creare un elenco di numeri nell’intervallo (1–10). Ecco come possiamo farlo:

# Create a list in a range
my_list = list(range(1, 10))
print(my_list)
>>>
  [1, 2, 3, 4, 5, 6, 7, 8, 9]

NOTA:
Ricorda che la funzione `range()` include il primo valore, ed esclude l'ultimo.

Manipolazione delle liste

Grazie al fatto che le liste sono mutabili, abbiamo tantissime possibilità per manipolarle.

Ad esempio, supponiamo di avere un elenco di nomi, ma di aver commesso un errore e di volerne modificare uno. Ecco come possiamo farlo:

# List of names
names = ["James", "Richard", "Simon", "Elizabeth", "Tricia"]
# Change the wrong name
names[0] = "Alexander"
# Print list
print(names)
>>>
    
    ['Alexander', 'Richard', 'Simon', 'Elizabeth', 'Tricia']

Quindi, nell’esempio sopra, abbiamo cambiato il primo nome dell’elenco da James ad Alexander.

NOTA:
Nel caso non lo sapessi, nota che in Python al primo elemento
si accede sempre con "0", indipendentemente dalla tipologia di dato che stiamo manipolando.
Quindi, nell'esempio precedente, "names[0]" rappresenta il primo elemento
della lista "names".

Ora, supponiamo di aver dimenticato un nome. Possiamo aggiungerlo alla nostra lista in questo modo:

# List of names
names = ["James", "Richard", "Simon", "Elizabeth", "Tricia"]
# Append another name
names.append("Alexander")
# Print list
print(names) 
>>>
    ['James', 'Richard', 'Simon', 'Elizabeth', 'Tricia', 'Alexander']

Se dobbiamo concatenare due liste abbiamo due possibilità: il metodo di concatenazione oppure possiamo usare extend(). Vediamoli:

# Create list1
list1 = [1, 2, 3]
# Create list2
list2 = [4, 5, 6]
# Concatenate lists
concatenated_list = list1 + list2
# Print concatenated list
print(concatenated_list)
>>>
  [1, 2, 3, 4, 5, 6]

Quindi, questo metodo crea una lista come la somma di altre liste.

Vediamo il metodo extend():

# Create list1
list1 = [1, 2, 3]
# Create list2
list2 = [4, 5, 6]
# Extend list1 with list2
list1.extend(list2)
# Print new list1
print(list1)
>>>
  [1, 2, 3, 4, 5, 6]

Come possiamo vedere, i risultati sono gli stessi, ma la sintassi è diversa. Questo metodo estende list1 con list2.

Se, invece, vogliamo rimuovere elementi abbiamo due possibilità: possiamo utilizzare il metodo remove() oppure del. Vediamoli:

# Create list
my_list = [1, 2, 3, 'four', 5.0]
# Remove one element and print
my_list.remove('four')
print(my_list)
>>>
  [1, 2, 3, 5.0]

Vediamo l’altra modalità:

# Create list
my_list = [1, 2, 3, 'four', 5.0]
# Delete one element and print
del my_list[3]
print(my_list)
>>>
    [1, 2, 3, 5.0]

Quindi, otteniamo gli stessi risultati con entrambi i metodi, ma remove() ci dà la possibilità di scrivere esplicitamente l’elemento da rimuovere, mentre del necessita di accedere alla posizione dell’elemento della lista.

NOTA:
Se hai acquisito dimestichezza con l'accesso alle posizioni, in quanto sopra
esempio my_list[3] = 'four'. Perché, ricorda: in Python iniziamo a contare
le posizioni a partire dallo 0.

List comprehension (o comprensione di lista)

Sono molti i casi in cui è necessario creare delle liste partendo da liste già esistenti, generalmente applicando dei filtri ai dati esistenti.

Per fare ciò abbiamo due possibilità:

  • Usiamo cicli e istruzioni.
  • Usiamo la list comprehension.

In pratica, sono entrambi lo stesso modo di scrivere la stessa cosa, ma la list comprehension è più concisa ed elegante.

Ma prima di discutere questi metodi, potresti aver bisogno di una panoramica approfondita di cicli e istruzioni. Ecco un paio di articoli che ho scritto in passato che potrebbero aiutarti:

Ora vediamo un paio di esempi che utilizzano direttamente cicli e istruzioni.

Supponiamo di avere una lista della spesa. Vogliamo che il nostro programma stampi che amiamo un frutto e che non ci piacciono gli altri della nostra lista. Ecco come possiamo farlo:

# Create shopping list
shopping_list = ["banana", "apple", "orange", "lemon"]
# Print the one I like
for fruit in shopping_list:
    if fruit == "lemon":
        print(f"I love {fruit}")
    else:
        print(f"I don't like {fruit}")
>>>
    I don't like banana
    I don't like apple
    I don't like orange
    I love lemon

Un altro esempio potrebbe essere il seguente. Supponiamo di avere una lista di numeri e di voler stampare solo quelli pari. Ecco come possiamo farlo:

# Create list
numbers = [1,2,3,4,5,6,7,8]
# Create empty list
even_list = []
# Print even numbers
for even in numbers:
    if even %2 == 0:
        even_list.append(even)
    else:
        pass
    
print(even_list)
>>>
    [2, 4, 6, 8]
NOTA:
Se non hai familiarità con la sintassi %2 == 0, te la spiego. Questa significa che stiamo dividendo un numero per 2 e ci aspettiamo un resto di 0. In altre parole,
 stiamo chiedendo al nostro programma di intercettare i numeri pari.

Quindi, nell’esempio sopra, abbiamo creato una lista di numeri. Per farlo, abbiamo creato una lista vuota che viene utilizzata dopo il ciclo per aggiungere tutti i numeri pari. In questo modo, abbiamo creato una lista di numeri pari da un elenco di numeri “generici”.

Ora… questo modo di creare nuove liste con cicli e istruzioni è un po’ “pesante”.

In altre parole: richiede molto codice. Possiamo ottenere gli stessi risultati in modo più conciso utilizzando la comprensione delle liste.

Ad esempio, per creare una lista con numeri pari possiamo usare la comprensione delle liste in questo modo:

# Create list
numbers = [1,2,3,4,5,6,7,8]
# Create list of even numbers
even_numbers = [even for even in numbers if even %2 == 0]
# Print even list
print(even_numbers)
>>>
    [2, 4, 6, 8]

Quindi, la comprensione delle liste crea direttamente una nuova lista e le condizioni sono definite al suo interno.

Come possiamo vedere, otteniamo lo stesso risultato di prima, ma in una sola riga di codice: niente male!

Ora creiamo una lista con commenti sul frutto che amo (e sul frutto che non amo) con la list comprehension:

# Create shipping list
shopping_list = ["banana", "apple", "orange", "lemon"]
# Create commented list and print it
commented_list = [f"I love {fruit}" if fruit == "banana"
                  else f"I don't like {fruit}"
                  for fruit in shopping_list]
print(commented_list)
>>>
  
  ['I love banana', "I don't like apple", "I don't like orange",
   "I don't like lemon"]

Quindi, abbiamo ottenuto lo stesso risultato di prima, ma con solo una riga di codice. L’unica differenza è che qui abbiamo stampato una lista (perché la comprensione delle liste ne crea una!), mentre prima stampavamo solo i risultati.

Liste di liste

C’è anche la possibilità di creare liste di liste, ovvero liste annidate in un’unica lista. Questa possibilità è utile quando vogliamo rappresentare i dati elencati come una lista univoca.

Ad esempio, consideriamo di voler creare una lista di studenti e i loro voti. Potremmo creare qualcosa del genere:

# Create lis with students and their grades
students = [
    ["John", [85, 92, 78, 90]],
    ["Emily", [77, 80, 85, 88]],
    ["Michael", [90, 92, 88, 94]],
    ["Sophia", [85, 90, 92, 87]]
]

Questa è una notazione utile se, ad esempio, vogliamo calcolare la media dei voti di ogni studente. Possiamo farlo in questo modo:

# Iterate over the list
for student in students:
    name = student[0] # Access names
    grades = student[1] # Access grades
    average_grade = sum(grades) / len(grades) # Calculate mean grades
    print(f"{name}'s average grade is {average_grade:.2f}")
>>>
    John's average grade is 86.25
    Emily's average grade is 82.50
    Michael's average grade is 91.00
    Sophia's average grade is 88.50

Con le data structures di tipo lista in Python abbiamo finito.

Se vuoi approfondire ulteriormente le liste, di consiglio di leggere questo mio articolo.


Data structures in Python: le tuple

Data structures in Python dal blog di Federico Trotta: un anello di acciaio a simboleggiare una tupla
Foto di Elisa da Pixabay

Le tuple sono un altro tipo di data structures in Python. Queste sono definite tra parentesi tonde e, come le liste, possono contenere qualsiasi tipo di dati separato da una virgola.

Quindi, ad esempio, possiamo definire una tupla in questo modo:

# Define a tuple and print it
my_tuple = (1, 3.0, "John")
print(my_tuple)
>>>
    (1, 3.0, 'John')

La differenza tra una tupla e una lista è che una tupla è immutabile. Ciò significa che gli elementi di una tupla non possono essere modificati.

Quindi, ad esempio, se proviamo ad aggiungere un valore a una tupla otteniamo un errore:

# Create a tuple with names
names = ("James", "Jhon", "Elizabeth")
# Try to append a name
names.append("Liza")
>>>
    AttributeError: 'tuple' object has no attribute 'append'

Quindi, poiché non possiamo modificare le tuple, queste sono utili quando vogliamo che i nostri dati siano immutabili; ad esempio, nelle situazioni in cui non vogliamo commettere errori.

Un esempio pratico può essere il carrello di un e-commerce. Potremmo volere che questo tipo di dati siano immutabili in modo da non commettere errori durante la manipolazione.

Immagina che qualcuno abbia acquistato una maglietta, un paio di scarpe e un orologio dal nostro e-commerce. Possiamo riportare questi dati con quantità e prezzo in un’unica tupla:

# Create a chart as a tuple
cart = (
    ("Shirt", 2, 19.99),
    ("Shoes", 1, 59.99),
    ("Watch", 1, 99.99)
)

Per essere precisi, questa è una tupla di tuple.

Poiché le tuple sono immutabili, sono più efficienti in termini di prestazioni, nel senso che risparmiano del nostro computer. Ma quando si tratta di manipolazione, possiamo usare esattamente lo stesso codice che abbiamo visto per le liste, quindi non lo riscriveremo.

Infine, analogamente alle liste, possiamo creare una tupla con la funzione incorporata tuple() in questo modo:

# Create a tuple in a range
my_tuple = tuple(range(1, 10))
print(my_tuple)
>>>
  (1, 2, 3, 4, 5, 6, 7, 8, 9)

Data Structures in Python: i dizionari

Data structures in Python dal blog di Federico Trotta: un dizionario
Foto di astize da Pixabay

Un dizionario è un’altra tipologia di data structures in Python. Esso èmodo per archiviare dati accoppiati come key (chiave) e value (valore). Ecco come possiamo crearne uno:

# Create a dictionary
my_dictionary = {'key_1':'value_1', 'key_2':'value_2'}

Quindi, un dizionario si crea con le parentesi graffe. In esso memorizziamo un paio di chiavi e di valori, separati da due punti. Le coppie key-value vengono quindi separate da una virgola.

Ora vediamo come possiamo manipolare i dizionari.

Manipolazione dei dizionari

Sia le chiavi che i valori di un dizionario possono essere di qualsiasi tipo: stringhe (strings), numeri interi (integers) o numeri decimali (flots). Quindi, ad esempio, possiamo creare un dizionario in questo modo:

# Create a dictionary of numbers and print it
numbers = {1:'one', 2:'two', 3:'three'}
print(numbers)
>>>
    {1: 'one', 2: 'two', 3: 'three'}

Ma possiamo farlo anche così:

# Create a dictionary of numbers and print it
numbers = {'one':1, 'two':2.0, 3:'three'}
print(numbers)
>>>
  {'one': 1, 'two': 2.0, 3: 'three'}

La scelta del tipo per la key ed il value dipende dal problema che dobbiamo risolvere. Ad ogni modo, considerando il dizionario che abbiamo visto prima, possiamo accedere sia ai values che alle keys in ​​questo modo:

# Access values and keys
keys = list(numbers.keys())
values = tuple(numbers.values())
# Print values and keys
print(f"The keys are: {keys}")
print(f"The values are: {values}")
>>>
    The keys are: ['one', 'two', 3]
    The values are: (1, 2.0, 'three')

Quindi, se il nostro dizionario si chiama numbers, accediamo alla sue keys con numbers.keys(). E con numbers.values() accediamo ai suoi values.

Tieni presente che abbiamo creato una lista con le keys e una tupla con i values utilizzando la notazione che abbiamo visto prima.

Naturalmente possiamo anche iterari i dizionari. Ad esempio, supponiamo di voler stampare i valori che sono maggiori di una certa soglia:

# Create a shopping list with fruits and prices
shopping_list = {'banana':2, 'apple':1, 'orange':1.5}
# Iterate over the values
for values in shopping_list.values():
    # Values greater than threshold
    if values > 1:
        print(values)
>>>
    2
    1.5

Così come le liste, anche i dizionari sono mutabili. Quindi, se vogliamo aggiungere un valore a un dizionario dobbiamo definire la key e il value da aggiungere ad esso.

Possiamo farlo in questo modo:

# Create the dictionary
person = {'name': 'John', 'age': 30}
# Add value and key and print
person['city'] = 'New York'
print(person)
>>>

    {'name': 'John', 'age': 30, 'city': 'New York'}

Per modificare il value di un dizionario dobbiamo accedere alla sua key:

# Create a dictionary
person = {'name': 'John', 'age': 30}
# Change age value and print
person['age'] = 35
print(person)

>>>
    {'name': 'John', 'age': 35}

Per eliminare una coppia key-value da un dizionario, dobbiamo accedere alla relativa key:

# Create dictionary
person = {'name': 'John', 'age': 30}
# Delete age and print
del person['age']
print(person)

>>>
    {'name': 'John'}

Dizionari nestati

Abbiamo visto prima che possiamo creare liste di liste e tuple di tuple. Allo stesso modo, possiamo creare dizionari nidificati.

Supponiamo, ad esempio, di voler creare un dizionario per memorizzare i dati relativi ad una classe di studenti. Possiamo farlo in questo modo:

# Create a classroom dictionary
classroom = {
    'student_1': {
        'name': 'Alice',
        'age': 15,
        'grades': [90, 85, 92]
    },
    'student_2': {
        'name': 'Bob',
        'age': 16,
        'grades': [80, 75, 88]
    },
    'student_3': {
        'name': 'Charlie',
        'age': 14,
        'grades': [95, 92, 98]
    }

Quindi, i dati di ogni studente sono rappresentati come un dizionario e tutti i dizionari sono archiviati in un dizionario unico, che rappresenta la classe.

Come possiamo vedere, i valori di un dizionario possono essere anche liste (o tuple, se vogliamo). In questo caso, abbiamo utilizzato le liste per memorizzare i voti di ciascuno studente.

Per stampare i valori di uno studente, basta ricordare che, dal punto di vista del dizionario che rappresenta la classe, dobbiamo accedere alla chiave e, in questo caso, le chiavi sono gli studenti stessi. Ciò significa che possiamo farlo in questo modo:

# Access student_3 and print
student_3 = classroom['student_3']
print(student_3)

>>>
    {'name': 'Charlie', 'age': 14, 'grades': [95, 92, 98]}

Comprensione dei dizionary (dictionary comprehension)

La dictionary comprehension ci consente di creare dizionari in modo conciso ed efficiente. È simile alla comprensione delle liste ma, invece di creare una lista, crea un dizionario.

Supponiamo di avere un dizionario in cui abbiamo memorizzato alcuni oggetti e i loro prezzi. Vogliamo conoscere gli oggetti che costano meno di una certa soglia. Possiamo farlo in questo modo:

# Define initial dictionary
products = {'shoes': 100, 'watch': 50, 'smartphone': 250, 'tablet': 120}
# Define threshold
max_price = 150
# Filter for threshold
products_to_buy = {fruit: price for fruit, price in products.items() if price <= max_price}
# Print filtered dictionary
print(products_to_buy)
>>>
    {'shoes': 100, 'watch': 50, 'tablet': 120}

Quindi, la sintassi per usare la dictionary comprehension è la seguente:

new_dict = {key:value for key, value in iterable}

Dove “iterable” è qualsiasi oggetto Python che sia iterabile. Può essere una lista, una tupla, un altro dizionario, ecc…

Creare dizionari con il metodo “standard” richiederebbe molto codice, con condizioni, cicli e istruzioni. Invece, come possiamo vedere, la comprensione del dizionario ci permette di creare un dizionario, basato su condizioni, con una sola riga di codice.

La comprensione del dizionario è particolarmente utile quando dobbiamo creare un dizionario recuperando dati da altre fonti o strutture dati. Ad esempio, supponiamo di dover creare un dizionario recuperando valori da due elenchi. Possiamo farlo in questo modo:

# Define names and ages in lists
names = ['John', 'Jane', 'Bob', 'Alice']
cities = ['New York', 'Boston', 'London', 'Rome']
# Create dictionary from lists and print results
name_age_dict = {name: city for name, city in zip(names, cities)}
print(name_age_dict)

>>>

   {'John': 'New York', 'Jane': 'Boston', 'Bob': 'London', 'Alice': 'Rome'}

Se vuoi approfondire la dictionary comprehensio, puoi leggere questo mio articolo.


Data structures in Python: i data frames

Data structures in Python dal blog di Federico Trotta: un data frame
Un data frame. Immagine dal sito web della libreria Pandas: https://pandas.pydata.org/docs/getting_started/index.html

L’ultima tipologia di data structures in Python che andiamo ad analizzare è il data frame.

Un data frame, indipendentemente dal fatto che si parli di Python o meno, è una struttura di dati bidimensionale composta da colonne e righe. Quindi, è in qualche modo simile a un foglio di calcolo o a una tabella in un database SQL.

I data frames le seguenti caratteristiche:

  • Ogni riga rappresenta una singola osservazione o registrazione.
  • Ogni colonna rappresenta una variabile o un attributo specifico dei dati.
  • Hanno righe (chiamate indici) e colonne etichettate, facilitando la manipolazione dei dati.
  • Le colonne possono contenere diversi tipi di dati, come interi, stringhe o floats. Anche una singola colonna può contenere diversi tipi di dati.

Sebbene i data frame siano la tipica struttura di dati utilizzata nel contesto di analisi dei dati e data science, non è raro che un ingegnere del software possa aver bisogno di manipolare un data frame, ed è per questo che ne stiamo facendo una panoramica in questo articolo.

Ecco come appare un data frame:

Data structures in Python: un data frame by Federico Trotta
Un data frame. Immagine di Federico Trotta.

Quindi, a sinistra (nel rettangolo blu) possiamo vedere gli indici, ovvero il conteggio delle righe. Possiamo quindi vedere che un data frame può contenere diversi tipi di dati. In particolare, la colonna Age contiene diversi tipi di dati (una stringa e due numeri interi).

Manipolaizone base di un data frame con Pandas

Mentre recentemente ha iniziato a circolare una nuova libreria per manipolare i frame di dati chiamata “Polars”, qui vedremo alcune manipolazioni di dati con Pandas che è ancora oggi la più utilizzata.

Innanzitutto, generalmente, possiamo creare un data frame importando dati da file .xlsx o .cvs. In Pandas possiamo farlo in questo modo:

import pandas as pd
# Import cvs file
my_dataframe = pd.read_csv('a_file.csv')
# Import xlsx
my_dataframe_2 = pd.read_excel('a_file_2.xlsx')

Se vogliamo creare un data frame:

import pandas as pd
# Create a dictionary with different types of data
data = {
    'Name': ['John', 'Alice', 'Bob'],
    'Age': ['twenty-five', 30, 27],
    'City': ['New York', 'London', 'Sydney'],
    'Salary': [50000, 60000.50, 45000.75],
    'Is_Employed': [True, True, False]
}
# Create the dataframe
df = pd.DataFrame(data)

Questo è il data frame che abbiamo mostrato sopra. Quindi, come possiamo vedere, creiamo prima un dizionario e poi lo convertiamo in un data frame con il metodo pd.DataFrame().

Abbiamo tre possibilità per visualizzare un data frame. Supponiamo di avere un data frame chiamato df:

  • Una è print(df).
  • Un’altra è df.head() che mostrerà le prime 5 righe del nostro data frame. Nel caso in cui abbiamo un data frame con molte righe, possiamo mostrarne più delle prime cinque. Ad esempio, df.head(20) mostra le prima 20.
  • Un’altra ancora è df.tail() che funziona esattamente come df.head(), ma mostra le ultime righe.

Dal punto di vista della visualizzazione, utilizzando il df sopra, questo è ciò che mostra df.head():

Data structures in Python: un data frame by Federico Trotta
VIsualizzazione col metodo df.head. Immagine di Fedrico Trotta

Questo è quel che mostra print(df) invece:

Data structures in Python: un data frame by Federico Trotta
VIsualizzazione col metodo print(df). Immagine di Fedrico Trotta

Nel caso di piccoli data sets come questo, la differenza è solo una questione di gusti (io preferisco head() perché “mostra la tabularità” dei dati). Ma nel caso di data sets di grandi dimensioni, head() è decisamente migliore. Provalo e fammi sapere!

Considera che Pandas è una libreria molto ampia, il che significa che ci permette di manipolare i dati tabulari in vari modi, quindi dovrebbe essere trattata da sola in un singolo articolo. Qui vogliamo mostrare solo le nozioni di base, quindi vedremo come aggiungere ed eliminare una colonna (le colonne di un frame di dati sono anche chiamate “Pandas series”).

Supponiamo di voler aggiungere una colonna al data frame df che abbiamo visto sopra che ci dice se le persone sono sposate o meno. Possiamo farlo in questo modo:

# Add marital status
df["married"] = ["yes", "yes", "no"]
NOTA:
questa è la stessa notazione che abbiamo usato per aggiungere valori a un dizionario.
Torna indietro nell'articolo e confronta i due metodi.

Mostrando i primi risultati otteniamo:

Data structures in Python: un data frame by Federico Trotta
Il data frame df con il marital status. Immagine di Federico Trotta.

Per eliminare una colonna:

# Delete the "Is_Employed" column
df = df.drop('Is_Employed', axis=1)

E otteniamo:

Data structures in Python: un data frame by Federico Trotta
Il data frame senza la colonna relativa ai dati di employement. Immagine di Federico Trotta.

Tieni presente che dobbiamo utilizzare axis=1 perché qui stiamo dicendo a Pandas di rimuovere le colonne e, poiché un data frame è una struttura di dati bidimensionale, axis=1 rappresenta la direzione verticale. Se invece vogliamo eliminare una riga, dobbiamo usare axis=0.

Ad esempio, supponiamo di voler eliminare la riga associata all’indice 1 (ovvero la seconda riga perché, anche in questo caso, iniziamo a contare da 0):

# Delete the second row 
df = df.drop(1, axis=0)

E otteniamo:

Data structures in Python: un data frame by Federico Trotta
Il data frame senza la secoda riga. Immagine di Federico Trotta.

Conclusioni

Tra tutte le data structures in Python abbiamo visto, in questo articolo, quelle più utilizzate.

Queste non sono le uniche, ma sicuramente sono le più utilizzate. Inoltre, non c’è niente di giusto o sbagliato nell’utilizzarne una piuttosto che un’altra: dobbiamo solo capire quali dati dobbiamo archiviare e utilizzare la migliore struttura dati per quel tipo di attività.

Spero che questo articolo ti abbia aiutato a comprendere l’utilizzo di queste strutture dati e quando utilizzarle.


NOTA: questo articolo è stato scritto originariamente in Inglese per Towards Data Science.


Federico Trotta
Federico Trotta

Ciao! Io sono Federico Trotta, e sono un Technical Writer Freelance.

Vuoi collaborare con me? Contattami.


Immagine in evidenza di Pexels on Pixabay

Federico Trotta

Technical Writer: I document digital products and write articles about AI & Python programming.

Leave a reply