Tutorial sulle strutture dati in Python

Le strutture dati sono un modo per organizzare e memorizzare i dati in modo che possano essere accessi e utilizzati in maniera efficiente. Definiscono la relazione tra i dati e le operazioni che si possono eseguire su di essi. Esistono molti tipi di strutture dati che permettono a data scientist e ingegneri informatici di concentrarsi sul quadro generale della risoluzione di problemi più grandi, invece di perdersi nei dettagli di descrizione e accesso ai dati.

In questo tutorial imparerai le varie strutture dati di Python e vedrai come sono implementate:

• Tipo di dato astratto e strutture dati
• Strutture dati primitive
  • Interi
  • Float
  • Stringhe
  • Booleani
• Strutture dati non primitive
  • Array
  • Liste
  • Tuple
  • Dizionario
  • Set
  • File

Nel nostro corso gratuito Intro to Python for Data Science puoi approfondire l’uso di Python proprio nel contesto della data science. Il corso introduce i concetti di base di Python. Scoprirai metodi, funzioni e il pacchetto NumPy.

Tipo di dato astratto e strutture dati

Come hai letto nell’introduzione, le strutture dati ti aiutano a concentrarti sul quadro generale invece di perderti nei dettagli. Questo è noto come astrazione dei dati.

Le strutture dati sono in realtà un’implementazione dei tipi di dato astratti o ADT. Questa implementazione richiede una visione fisica dei dati usando una raccolta di costrutti di programmazione e tipi di dato di base.

In generale, in informatica le strutture dati si dividono in due categorie: primitive e non primitive. Le prime sono le forme più semplici di rappresentazione dei dati, mentre le seconde sono più avanzate: contengono strutture dati primitive all’interno di strutture più complesse per scopi specifici.

Strutture dati primitive

Sono le strutture dati più primitive o di base. Sono i mattoni per la manipolazione dei dati e contengono valori puri e semplici. Python ha quattro tipi di variabili primitive:

• Interi
• Float
• Stringhe
• Booleani

Nelle prossime sezioni, li vedrai nel dettaglio!

Interi

Puoi usare un intero per rappresentare dati numerici e, più nello specifico, numeri interi da meno infinito a più infinito, come 4, 5 o -1.

Float

Float sta per “numero in virgola mobile”. Puoi usarlo per i numeri razionali, di solito con una parte decimale, come 1.11 o 3.14.

Dai un’occhiata al seguente DataCamp Light Chunk e prova alcune operazioni con interi e float!

Nota che in Python non devi dichiarare esplicitamente il tipo della variabile o dei tuoi dati. Questo perché è un linguaggio a tipizzazione dinamica. I linguaggi tipizzati dinamicamente sono quelli in cui il tipo di dato che un oggetto può memorizzare è mutabile.

Stringa

Le stringhe sono insiemi di lettere, parole o altri caratteri. In Python puoi creare stringhe racchiudendo una sequenza di caratteri tra virgolette singole o doppie. Per esempio: 'cake', "cookie", ecc.

Puoi anche applicare l’operatore + a due o più stringhe per concatenarle, come nell’esempio qui sotto:

x = 'Cake'
y = 'Cookie'
x + ' & ' + y

'Cake & Cookie'

Ecco altre operazioni di base che puoi fare con le stringhe; per esempio, puoi usare * per ripetere una stringa un certo numero di volte:

# Repeat
x * 2

'CakeCake'

Puoi anche eseguire slicing sulle stringhe, cioè selezionare parti di stringhe:

# Range Slicing
z1 = x[2:]  

print(z1)

# Slicing
z2 = y[0] + y[1]

ke
Co

Nota che le stringhe possono essere anche alfanumeriche, ma l’operatore + si usa comunque per concatenarle.

x = '4'
y = '2'

x + y

'42'

Python ha molti metodi integrati o funzioni di supporto per manipolare le stringhe. Sostituire una sottostringa, mettere in maiuscolo parole in un paragrafo, trovare la posizione di una stringa all’interno di un’altra sono manipolazioni comuni. Eccone alcune:

Mettere in maiuscolo le stringhe

str.capitalize('cookie')

'Cookie'

Recupera la lunghezza di una stringa in caratteri. Nota che anche gli spazi contano nel risultato finale:

str1 = "Cake 4 U"
str2 = "404"
len(str1)

8

Verificare se una stringa è composta solo da cifre

str1.isdigit()

False

str2.isdigit()

True

Sostituire parti di stringhe con altre stringhe

str1.replace('4 U', str2)

'Cake 404'

Trovare sottostringhe in altre stringhe; restituisce l’indice più basso o la posizione all’interno della stringa in cui viene trovata la sottostringa:

str1 = 'cookie'
str2 = 'cook'
str1.find(str2)

0

La sottostringa

'cook'

si trova all’inizio di

'cookie'

. Di conseguenza, fai riferimento alla posizione all’interno di

'cookie'

in cui trovi quella sottostringa. In questo caso

0

viene restituito perché inizi a contare le posizioni da 0!

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

Allo stesso modo, la sottostringa

'cook'

si trova alla posizione 12 all’interno di

'I got you a cookie'

. Ricorda che inizi a contare da 0 e che gli spazi contano nelle posizioni!

Puoi trovare un elenco completo dei metodi per le stringhe in Python qui.

Boolean

Questo tipo di dato integrato può assumere i valori: True e False, che spesso li rende intercambiabili con gli interi 1 e 0. I booleani sono utili nelle espressioni condizionali e di confronto, come negli esempi seguenti:

x = 4
y = 2
x == y

False

x > y

True

x = 4
y = 2
z = (x==y) # Espressione di confronto (Valuta a false)
if z: # Condizionale sul valore di verità/falsità di 'z'
    print("Cookie")
else: print("No Cookie")

No Cookie

Conversione dei tipi di dato

A volte ti capiterà di lavorare sul codice di qualcun altro e dovrai convertire un intero in un float o viceversa, per esempio. O magari ti accorgi di aver usato un intero quando in realtà ti serve un float. In questi casi puoi convertire il tipo di dato delle variabili!

Per verificare il tipo di un oggetto in Python, usa la funzione integrata type(), come nelle righe di codice qui sotto:

i = 4.0
type(i)

float

Quando cambi il tipo di un’entità da un tipo di dato a un altro, si parla di “typecasting”. Ci possono essere due tipi di conversione: implicita, detta coercion, ed esplicita, spesso chiamata casting.

Conversione implicita dei tipi di dato

Questa è una conversione automatica, gestita dal compilatore al posto tuo. Dai un’occhiata ai seguenti esempi:

# A float
x = 4.0 

# An integer
y = 2 

# Divide `x` by `y`
z = x/y

# Check the type of `z`
type(z)

float

Nell’esempio sopra, non hai dovuto cambiare esplicitamente il tipo di dato di y per effettuare una divisione con risultato float. Il compilatore lo ha fatto per te in modo implicito.

Facile!

Conversione esplicita dei tipi di dato

Questo tipo di conversione è definito dall’utente, cioè devi indicare esplicitamente al compilatore di cambiare il tipo di dato di certe entità. Considera il blocco di codice qui sotto per capirlo a fondo:

x = 2
y = "The Godfather: Part "
fav_movie = y + x

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-51-b8fe90df9e0e> in <module>()
      1 x = 2
      2 y = "The Godfather: Part "
----> 3 fav_movie = y + x


TypeError: Can't convert 'int' object to str implicitly

L’esempio sopra ti restituisce un errore perché il compilatore non capisce se stai cercando di concatenare o sommare, dato che i tipi sono misti. Stai provando ad aggiungere insieme un intero e una stringa.

C’è un evidente disallineamento.

Per risolvere, devi prima convertire l’int in una string per poter poi eseguire la concatenazione.

Nota che non sempre è possibile convertire un tipo di dato in un altro. Alcune funzioni di conversione integrate che puoi usare qui sono: int(), float() e str().

x = 2
y = "The Godfather: Part "
fav_movie = (y) + str(x)
print(fav_movie)

The Godfather: Part 2

Strutture dati non primitive

I tipi non primitivi sono i membri più sofisticati della famiglia delle strutture dati. Non memorizzano solo un valore, ma una collezione di valori in vari formati.

Nel mondo tradizionale dell’informatica, le strutture dati non primitive si dividono in:

• Array
• Liste
• File

Array

Per cominciare, gli array in Python sono un modo compatto per raccogliere tipi di dato di base: tutte le voci in un array devono essere dello stesso tipo. Tuttavia, in Python gli array non sono così popolari come in altri linguaggi come C++ o Java.

In generale, quando si parla di array in Python spesso ci si riferisce in realtà alle liste. C’è però una differenza fondamentale, che vedrai tra poco. In Python, gli array possono essere visti come un modo più efficiente di memorizzare un certo tipo di lista. Questo tipo di lista ha però elementi dello stesso tipo di dato.

In Python, gli array sono supportati dal modulo array e devono essere importati prima di inizializzarli e usarli. Gli elementi memorizzati in un array sono vincolati nel loro tipo di dato. Il tipo di dato è specificato durante la creazione dell’array e indicato tramite un “type code”, un singolo carattere come la I che vedi nell’esempio qui sotto:

import array as arr
a = arr.array("I",[3,6,9])
type(a)

array.array

La pagina della documentazione degli array in Python fornisce maggiori informazioni sui vari codici disponibili e sulle funzionalità offerte dal modulo array.

Lista

Le liste in Python servono a memorizzare raccolte di elementi eterogenei. Sono mutabili, il che significa che puoi cambiarne il contenuto senza cambiarne l’identità. Riconosci le liste dalle parentesi quadre [ e ] che racchiudono elementi separati da una virgola ,. Le liste sono integrate in Python: non devi richiamarle separatamente.

x = [] # Empty list
type(x)

list

x1 = [1,2,3]
type(x1)

list

x2 = list([1,'apple',3])
type(x2)

list

print(x2[1])

apple

x2[1] = 'orange'
print(x2)

[1, 'orange', 3]

Nota: come hai visto nell’esempio sopra con x1, le liste possono anche contenere elementi omogenei e quindi soddisfare la funzionalità di archiviazione di un array. Va benissimo, a meno che tu voglia applicare operazioni specifiche a questa collezione.

Python fornisce molti metodi per manipolare e lavorare con le liste. Aggiungere nuovi elementi, rimuoverne alcuni, ordinare o invertire una lista sono manipolazioni comuni. Vediamone alcune in azione:

• Aggiungi 11 alla lista list_num con append(). Per impostazione predefinita, questo numero verrà aggiunto alla fine della lista.

list_num = [1,2,45,6,7,2,90,23,435]
list_char = ['c','o','o','k','i','e']

list_num.append(11) # Add 11 to the list, by default adds to the last position
print(list_num)

[1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Usa insert() per inserire 11 all’indice o posizione 0 nella lista list_num

list_num.insert(0, 11)
print(list_num)

[11, 1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Rimuovi la prima occorrenza di 'o' da list_char con l’aiuto di remove()

list_char.remove('o') 
print(list_char)

['c', 'o', 'k', 'i', 'e']

• Rimuovi l’elemento all’indice -2 da list_char

list_char.pop(-2) # Removes the item at the specified position
print(list_char)

['c', 'o', 'k', 'e']

list_num.sort() # In-place sorting
print(list_num)

[1, 2, 2, 6, 7, 11, 11, 23, 45, 90, 435]

list.reverse(list_num)
print(list_num)

[435, 90, 45, 23, 11, 11, 7, 6, 2, 2, 1]

Se vuoi saperne di più sulle liste in Python, puoi leggere il tutorial 18 domande comuni sulle liste in Python!

Array vs. Liste

Ora che hai visto le liste in Python, potresti chiederti perché servono gli array. Il motivo è che sono fondamentalmente diversi nelle operazioni che puoi eseguire su di essi. Con gli array puoi applicare facilmente operazioni a tutti gli elementi individualmente, cosa che potrebbe non essere così immediata con le liste. Ecco un’illustrazione:

array_char = array.array("u",["c","a","t","s"])
array_char.tostring()
print(array_char)

array('u', 'cats')

Sei riuscito ad applicare la funzione tostring() di array_char perché Python sa che tutti gli elementi di un array sono dello stesso tipo di dato e quindi l’operazione si comporta allo stesso modo su ciascun elemento. Per questo, gli array possono essere molto utili quando lavori con grandi collezioni di tipi di dato omogenei. Poiché Python non deve ricordare i dettagli del tipo per ogni elemento individualmente, per alcuni utilizzi gli array possono essere più veloci e consumare meno memoria rispetto alle liste.

Vale anche la pena menzionare gli array di NumPy mentre siamo in tema. Gli array di NumPy sono ampiamente usati nel mondo della data science per lavorare con array multidimensionali. In generale, sono più efficienti del modulo array e delle liste Python. La lettura e scrittura di elementi in un array NumPy è più veloce e supportano operazioni “vettorializzate” come l’addizione elemento per elemento. Inoltre, gli array NumPy lavorano in modo efficiente con grandi dataset sparsi. Per saperne di più, dai un’occhiata al tutorial sugli array NumPy in Python di DataCamp.

Ecco un po’ di codice per iniziare con gli array NumPy:

import numpy as np

arr_a = np.array([3, 6, 9])
arr_b = arr_a/3 # Performing vectorized (element-wise) operations 
print(arr_b)

[ 1.  2.  3.]

arr_ones = np.ones(4)
print(arr_ones)

[ 1.  1.  1.  1.]

multi_arr_ones = np.ones((3,4)) # Creating 2D array with 3 rows and 4 columns
print(multi_arr_ones)

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

Tradizionalmente, la struttura dati lista può essere ulteriormente categorizzata in strutture lineari e non lineari. Stack e Queue sono dette “strutture dati lineari”, mentre Grafi e Alberi sono “strutture dati non lineari”. Queste strutture e i relativi concetti possono essere relativamente complessi ma sono usati ampiamente per la loro somiglianza con modelli del mondo reale. In questo tutorial ne avrai un assaggio.

Nota: in una struttura dati lineare, gli elementi sono organizzati in sequenza o, in altre parole, linearmente. Gli elementi vengono attraversati in serie uno dopo l’altro e tutti gli elementi di una struttura lineare possono essere attraversati in una singola esecuzione. Nelle strutture non lineari, invece, gli elementi non sono organizzati in sequenza. Ciò significa che gli elementi possono essere collegati a più di un elemento per riflettere relazioni particolari. Tutti gli elementi di una struttura non lineare potrebbero non essere attraversati in una singola esecuzione.

Stack

Uno stack è un contenitore di oggetti che vengono inseriti e rimossi secondo il concetto Last-In-First-Out (LIFO). Pensa a una pila di piatti a una cena: si aggiungono o rimuovono piatti sempre dalla cima. In informatica, questo concetto è usato per valutare espressioni e il parsing della sintassi, per algoritmi/ routine di scheduling, ecc.

Gli stack possono essere implementati usando le liste in Python. Quando aggiungi elementi a uno stack, si parla di operazione di push, mentre quando rimuovi o elimini un elemento si parla di operazione di pop. Nota che in Python hai effettivamente a disposizione il metodo pop() quando lavori con gli stack:

# Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack = [1,2,3,4,5] 
stack.append(6) # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 (Top)
print(stack)

[1, 2, 3, 4, 5, 6]

stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 (Top)
print(stack)

[1, 2, 3, 4]

Coda

Una coda è un contenitore di oggetti che vengono inseriti e rimossi secondo il principio First-In-First-Out (FIFO). Un ottimo esempio reale è la fila alla biglietteria, dove le persone vengono servite in base all’ordine di arrivo: chi arriva per primo è anche il primo ad andarsene. Le code possono essere di molti tipi diversi.

Le liste non sono efficienti per implementare una coda, perché append() e pop() dalla fine di una lista non sono operazioni veloci e comportano un costo di spostamento in memoria. Inoltre, inserire alla fine ed eliminare dall’inizio di una lista non è così veloce perché richiede uno shift delle posizioni degli elementi.

Grafi

Un grafo in matematica e informatica è una rete composta da nodi, detti anche vertici, che possono essere collegati tra loro o meno. Le linee o i percorsi che collegano due nodi si chiamano archi. Se l’arco ha una direzione di flusso, allora è un grafo diretto e l’arco è detto arco orientato. Se invece non sono specificate direzioni, il grafo è detto non diretto.

Può sembrare molto teorico e diventare piuttosto complesso andando a fondo. Tuttavia, i grafi sono un concetto importante, soprattutto nella data science, e sono spesso usati per modellare problemi reali. Social network, studi molecolari in chimica e biologia, mappe e sistemi di raccomandazione si basano tutti su grafi e teoria dei grafi.

Ecco una semplice implementazione di un grafo usando un dizionario Python per iniziare:

graph = { "a" : ["c", "d"],
          "b" : ["d", "e"],
          "c" : ["a", "e"],
          "d" : ["a", "b"],
          "e" : ["b", "c"]
        }

def define_edges(graph):
    edges = []
    for vertices in graph:
        for neighbour in graph[vertices]:
            edges.append((vertices, neighbour))
    return edges

print(define_edges(graph))

[('a', 'c'), ('a', 'd'), ('b', 'd'), ('b', 'e'), ('c', 'a'), ('c', 'e'), ('e', 'b'), ('e', 'c'), ('d', 'a'), ('d', 'b')]

Con i grafi puoi fare cose interessanti, come verificare se esiste un percorso tra due nodi, trovare il percorso più breve tra due nodi, determinare cicli nel grafo.

Il famoso “problema del commesso viaggiatore” riguarda proprio la ricerca del percorso più breve che visita ogni nodo esattamente una volta e torna al punto di partenza. A volte ai nodi o agli archi di un grafo vengono assegnati pesi o costi; puoi pensarli come livelli di difficoltà di percorrenza e sei interessato a trovare il percorso più economico o più facile.

Alberi

Un albero nel mondo reale è un essere vivente con le radici nel terreno e i rami che reggono foglie e frutti. I rami si estendono in modo più o meno organizzato. In informatica, gli alberi vengono usati per descrivere come talvolta sono organizzati i dati, tranne che la radice è in alto e rami e foglie seguono verso il basso: l’albero è disegnato capovolto rispetto a quello reale.

Per introdurre un po’ di notazione, la radice è sempre in cima all’albero. Mantenendo la metafora, gli altri nodi che seguono sono chiamati rami e l’ultimo nodo di ogni ramo è detto foglia. Puoi immaginare ogni ramo come un albero più piccolo a sé stante. La radice è spesso chiamata genitore e i nodi a cui fa riferimento sotto di essa sono detti figli. I nodi con lo stesso genitore sono detti fratelli. Capisci perché si chiama anche albero genealogico?

Gli alberi aiutano a definire scenari reali e sono usati ovunque, dal mondo dei videogiochi alla progettazione di parser XML; anche il principio di progettazione dei PDF è basato sugli alberi. In data science, il “Decision Tree based Learning” costituisce un’ampia area di ricerca. Numerosi metodi famosi, come bagging e boosting, usano il modello ad albero per generare un modello predittivo. Giochi come gli scacchi costruiscono un enorme albero con tutte le mosse possibili per analizzare e applicare euristiche e decidere la mossa ottimale.

Puoi implementare una struttura ad albero usando e combinando le varie strutture dati che hai visto finora in questo tutorial. Tuttavia, per semplicità, l’argomento sarà affrontato in un altro post.

class Tree:
    def __init__(self, info, left=None, right=None):
        self.info = info
        self.left  = left
        self.right = right

    def __str__(self):
        return (str(self.info) + ', Left child: ' + str(self.left) + ', Right child: ' + str(self.right))

tree = Tree(1, Tree(2, 2.1, 2.2), Tree(3, 3.1))
print(tree)

1, Left child: 2, Left child: 2.1, Right child: 2.2, Right child: 3, Left child: 3.1, Right child: None

Hai imparato gli array e visto anche la struttura dati lista. Tuttavia, Python offre molti altri meccanismi per le collezioni di dati e, sebbene non sempre rientrino tra gli argomenti tradizionali delle strutture dati in informatica, vale la pena conoscerli, soprattutto nel linguaggio Python:

• Tuple
• Dizionario
• Set

Tuple

Le tuple sono un altro tipo di dati sequenziali standard. La differenza tra tuple e liste è che le tuple sono immutabili: una volta definite non puoi eliminare, aggiungere o modificare alcun valore al loro interno. Questo può essere utile quando vuoi passare il controllo a qualcun altro ma non vuoi che modifichi i dati nella tua collezione; magari vuoi solo che li veda o che esegua operazioni separatamente su una copia dei dati.

Vediamo come si implementano le tuple:

x_tuple = 1,2,3,4,5
y_tuple = ('c','a','k','e')
x_tuple[0]

1

y_tuple[3]
x_tuple[0] = 0 # Cannot change values inside a tuple

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-74-b5d6da8c1297> in <module>()
      1 y_tuple[3]
----> 2 x_tuple[0] = 0 # Cannot change values inside a tuple


TypeError: 'tuple' object does not support item assignment

Dizionario

I dizionari sono esattamente ciò che ti serve se vuoi implementare qualcosa di simile a un elenco telefonico. Nessuna delle strutture dati viste finora è adatta a un elenco telefonico.

È qui che un dizionario torna utile. I dizionari sono composti da coppie chiave-valore. La key identifica l’elemento e il value, come suggerisce il nome, ne contiene il valore.

x_dict = {'Edward':1, 'Jorge':2, 'Prem':3, 'Joe':4}
del x_dict['Joe']
x_dict

{'Edward': 1, 'Jorge': 2, 'Prem': 3}

x_dict['Edward'] # Prints the value stored with the key 'Edward'.

1

Puoi applicare molte altre funzionalità integrate ai dizionari:

len(x_dict)

3

x_dict.keys()

dict_keys(['Prem', 'Edward', 'Jorge'])

x_dict.values()

dict_values([3, 1, 2])

Questo codice mostra un esempio di utilizzo di un dizionario Python per memorizzare e accedere a coppie chiave-valore.

Per prima cosa, il codice chiama la funzione len() con x_dict come argomento. Questo restituisce il numero di coppie chiave-valore nel dizionario, che è 3.

Successivamente, il codice chiama il metodo keys() su x_dict. Questo restituisce un oggetto vista contenente le chiavi del dizionario. In questo caso, le chiavi sono 'Prem', 'Edward' e 'Jorge', come mostrato in output.

Poi, il codice chiama il metodo values() su x_dict. Questo restituisce un oggetto vista contenente i valori del dizionario. In questo caso, i valori sono 3, 1 e 2, rispettivamente, come mostrato in output.

Set

I set sono collezioni di oggetti distinti (unici). Sono utili per creare elenchi che contengono solo valori unici in un dataset. È una collezione non ordinata ma mutabile: questo è molto utile quando si analizzano dataset di grandi dimensioni.

x_set = set('CAKE&COKE')
y_set = set('COOKIE')

print(x_set)

{'A', '&', 'O', 'E', 'C', 'K'}

print(y_set) # Single unique 'o'

{'I', 'O', 'E', 'C', 'K'}

print(x - y) # All the elements in x_set but not in y_set

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-3-31abf5d98454> in <module>()
----> 1 print(x - y) # All the elements in x_set but not in y_set


NameError: name 'x' is not defined

print(x_set|y_set) # Unique elements in x_set or y_set or both

{'C', '&', 'E', 'A', 'O', 'K', 'I'}

print(x_set & y_set) # Elements in both x_set and y_set

{'O', 'E', 'K', 'C'}

Il codice crea due set: x_set e y_set. Ogni set è creato passando una stringa di caratteri come argomento alla funzione set(). In questo caso, x_set è creato dalla stringa 'CAKE&COKE', mentre y_set è creato dalla stringa 'COOKIE'.

Poi il codice stampa ciascun set usando la funzione print(). Il primo print() stampa x_set, che contiene i caratteri unici della stringa 'CAKE&COKE'. L’output mostra che x_set contiene i caratteri 'A', '&', 'O', 'E', 'C' e 'K'. Analogamente, il secondo print() stampa y_set, che contiene i caratteri unici della stringa 'COOKIE'. L’output mostra che y_set contiene i caratteri 'I', 'O', 'E', 'C' e 'K'.

La terza istruzione print() tenta di stampare l’insieme di tutti gli elementi in x_set che non sono in y_set. Tuttavia, questa riga di codice genera un NameError perché la variabile x non è stata definita. Probabilmente questa riga avrebbe dovuto essere print(x_set - y_set).

La quarta istruzione print() stampa l’insieme degli elementi unici in x_set o y_set, o in entrambi. L’output mostra che l’insieme risultante contiene tutti i caratteri unici di x_set e y_set.

Infine, la quinta istruzione print() stampa l’insieme degli elementi presenti sia in x_set che in y_set. L’output mostra che questo insieme contiene i caratteri 'O', 'E', 'K' e 'C'.

File

I file fanno tradizionalmente parte delle strutture dati. E anche se il big data è all’ordine del giorno nell’industria della data science, un linguaggio di programmazione senza la capacità di memorizzare e recuperare informazioni precedentemente salvate sarebbe poco utile. Devi comunque usare tutti i dati presenti nei file sui database, e imparerai come farlo.

La sintassi per leggere e scrivere file in Python è simile ad altri linguaggi ma molto più semplice da gestire. Ecco alcune funzioni di base che ti aiuteranno a lavorare con i file in Python:

• open() per aprire file nel tuo sistema; il nome del file è il nome del file da aprire;

• read() per leggere interi file;

• readline() per leggere una riga alla volta;

• write() per scrivere una stringa su un file e restituire il numero di caratteri scritti; e

• close() per chiudere il file.

# File modes (2nd argument): 'r'(read), 'w'(write), 'a'(appending), 'r+'(both reading and writing)
f = open('file_name', 'w')

# Reads entire file
f.read() 

# Reads one line at a time
f.readline() 

# Writes the string to the file, returning the number of char written
f.write('Add this line.') 

f.close()

Il secondo argomento nella funzione open() è la modalità del file. Ti permette di specificare se vuoi leggere (r), scrivere (w), aggiungere in coda (a) oppure leggere e scrivere (r+).

Per saperne di più sulla gestione dei file in Python, assicurati di consultare questa pagina.

Conclusione

Complimenti per essere arrivato alla fine di questo tutorial! Sei un argomento più vicino al tuo obiettivo di conquistare il mondo della data science.

Se ti interessa, la nostra Python Data Science Toolbox in due parti approfondisce funzioni, iteratori, liste, ecc.