Conversione dei tipi di dato in Python: guida con esempi

Nell'esempio, un valore intero a_int è stato sommato a un valore float b_float, e il risultato è stato automaticamente convertito in un valore float c_sum senza che tu dovessi dirlo al compilatore. Questa è la conversione implicita.

Perché invece il valore float non è stato convertito in intero?

Questo dipende da un concetto più ampio di promozione del tipo in informatica. In poche parole, è un meccanismo di difesa del compilatore che ti consente di eseguire operazioni quando possibile convertendo i dati in un supertipo diverso senza perdere informazioni.

Ciò significa che la conversione da float a intero non viene eseguita perché il compilatore dovrebbe rimuovere la parte frazionaria, causando una perdita di informazioni.

Conversione esplicita del tipo di dato in Python

La conversione esplicita del tipo di dato, spesso chiamata type casting, avviene quando converti deliberatamente un valore da un tipo di dato a un altro. Questo approccio ti dà il controllo diretto sulla conversione, poiché specifichi esplicitamente il tipo di destinazione nel codice. È comunemente usata quando la conversione automatica (implicita) fornita da Python non soddisfa le tue esigenze.

La sintassi per la conversione esplicita è:

target_data_type(expression)

Per esempio, se vuoi convertire un numero in virgola mobile in un intero, scriverai:

int(3.14)  # Converts 3.14 to 3

Nota: sebbene le conversioni esplicite siano molto utili, possono portare a perdite di informazione. Ad esempio, convertire un numero in virgola mobile in un intero ne scarterà la parte frazionaria. È importante comprenderne le conseguenze per evitare risultati indesiderati nei tuoi programmi.

Esploriamo alcune delle conversioni esplicite più comuni.

Strutture dati primitive e non primitive in Python

Le strutture dati primitive 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

Le strutture dati non primitive non archiviano solo un valore, ma una raccolta di valori in vari formati. In Python, hai le seguenti strutture dati non primitive:

• Liste
• Tuple
• Dizionari
• Set

Puoi approfondirle con il tutorial sulle strutture dati in Python di DataCamp.

Conversioni delle strutture dati primitive

Conversioni tra interi e float in Python

Interi e float sono tipi di dato che trattano numeri.

Per convertire un intero in un float, usa la funzione float() in Python. Allo stesso modo, se vuoi convertire un float in un intero, puoi usare la funzione int().

a_int = 3
b_int = 2

# Conversione esplicita da int a float
c_float_sum = float(a_int + b_int)
print(c_float_sum)

5.0

a_float = 3.3
b_float = 2.0

# Conversione esplicita da float a int
c_int_sum = int(a_float + b_float)
print(c_int_sum)

c_float_sum = a_float + b_float
print(c_float_sum)

5
5.3

Problemi di precisione con i float e il modulo Decimal

L'aritmetica in virgola mobile in Python può portare a problemi di precisione:

print(0.1 + 0.2)  # Output: 0.30000000000000004

Per evitarlo, usa il modulo Decimal:

from decimal import Decimal

print(Decimal('0.1') + Decimal('0.2'))  # Output: 0.3

Conversione da reale a complesso in Python

Puoi convertire interi in numeri complessi usando complex(real,imag). Richiede due interi (parte reale e immaginaria) e converte i numeri reali in numeri complessi.

real = 2
imag = 5
print(complex(real, imag))

(2+5j)

Conversione dei tipi di dato con le stringhe in Python

Una stringa è una raccolta di uno o più caratteri (lettere, numeri, simboli). Potresti dover convertire spesso stringhe in numeri o numeri in stringhe.

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + total  + "$")

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

TypeError                                 Traceback (most recent call last)

<ipython-input-12-54bd76b9b4bd> in <module>()
      2 price_cookie = 6
      3 total = price_cake + price_cookie
----> 4 print("The total is: " + total  + "$")


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

L'esempio sopra genera un TypeError, informandoti che il compilatore non può convertire implicitamente un valore intero in una stringa.

Quello che il programma dovrebbe fare qui può sembrarti intuitivo. Tuttavia, il compilatore non sempre può esserne certo, quindi offre un meccanismo con il type casting esplicito per permetterti di indicare chiaramente cosa vuoi. Ecco come puoi convertire un intero in una stringa in Python usando la funzione str():

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + str(total)  + "$")

The total is: 21$

Funziona allo stesso modo quando converti valori float in stringhe.

In Python, puoi anche convertire stringhe in valori interi e float quando possibile. Vediamo cosa significa:

price_cake = '15'
price_cookie = '6'

# Concatenazione di stringhe
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Conversione esplicita a intero
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total)  + "$")

The total is: 156$
The total is: 21$

Analizziamo il codice.

price_cake e price_cookie inizialmente sono stringhe. Poi devi trovare il totale, il che significa che devono essere prima convertite nei rispettivi valori interi. Altrimenti, il compilatore assumerà che l'operazione desiderata sia una concatenazione di stringhe piuttosto che un'addizione numerica. Devi quindi inserire questo valore nella stringa finale di visualizzazione e, di conseguenza, convertire il totale in stringa per concatenarlo al resto del messaggio.

Speriamo che questo esempio ti aiuti a vedere l'importanza delle conversioni di tipo. Anche se è un esempio molto semplice, puoi già capire quanto possa essere utile.

Nota: hai notato il "quando possibile" nel convertire una stringa in intero o float? Questo perché non è sempre possibile convertire stringhe in numeri e applicare loro operazioni numeriche. Il compilatore lo sa e quindi ti restituirà un errore quando ci proverai. Guarda l'esempio qui sotto:

price_cake = 'fifteen'
price_cookie = 'six'
total = int(price_cake) + int(price_cookie)

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

ValueError                                Traceback (most recent call last)

<ipython-input-25-80591b8accda> in <module>()
      1 price_cake = 'fifteen'
      2 price_cookie = 'six'
----> 3 total = int(price_cake) + int(price_cookie)


ValueError: invalid literal for int() with base 10: 'fifteen'

Riepilogo: conversioni dei tipi di dato primitivi in Python

Conversioni delle strutture dati non primitive

Conversione in tuple e liste in Python

Come per interi e float, puoi anche convertire liste in tuple e tuple in liste.

Ricordi cosa sono tuple e liste? Le liste e le tuple in Python servono per archiviare una raccolta di elementi omogenei. La differenza tra tuple e liste è che le tuple sono immutabili, il che significa che una volta definite non puoi eliminare, aggiungere o modificare alcun valore al loro interno.

Perché convertire liste in tuple?

Perché le tuple sono tipi di dato immutabili e consentono una notevole ottimizzazione dei programmi che crei.

E perché convertire tuple in liste?

Magari vuoi apportare modifiche alla tupla iniziale. Puoi quindi convertirla in lista, effettuare la modifica e poi riconvertirla in tupla.

In Python, puoi usare la funzione tuple() per restituire una versione tupla del valore passato e, analogamente, la funzione list() per convertire una tupla in lista:

a_tuple = ('a', 1) ,('f', 2), ('g', 3)
b_list = [1,2,3,4,5]

print(tuple(b_list))
print(list(a_tuple))

(1, 2, 3, 4, 5)
[('a', 1), ('f', 2), ('g', 3)]

Allo stesso modo, ecco come convertire una stringa in una lista o in una tupla in Python:

dessert = 'Cake'

# Converti i caratteri in una stringa in elementi individuali in una tupla
print(tuple(dessert))

# Converti una stringa in una lista
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

('C', 'a', 'k', 'e')
['C', 'a', 'k', 'e', 's']

Conversione in dizionari e set in Python

Puoi usare la funzione dict() per convertire una tupla in un dizionario e set() per convertire una lista in un set. 

print(dict(a_tuple))
print(set(b_list))

{'a': 1, 'f': 2, 'g': 3}
{1, 2, 3, 4, 5}

Analogamente ad altre funzioni di conversione, ti basta fornire il nome della funzione per convertire qualsiasi tipo di dato in dizionari e set.

Usare dataclasses per dati strutturati (Python 3.7+)

Invece di usare dizionari o tuple, le dataclasses offrono un modo migliore per gestire dati strutturati.

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    in_stock: bool

item = Product("Laptop", 799.99, True)
print(item)  # Output: Product(name='Laptop', price=799.99, in_stock=True)

Riepilogo: conversioni delle strutture dati non primitive in Python

Unicode, interi binari, ottali ed esadecimali in Python

I sistemi di numerazione si riferiscono al numero di simboli o caratteri che rappresentano un qualsiasi valore numerico. Il sistema di numerazione che usi tipicamente ogni giorno è chiamato decimale. Nel sistema decimale usi dieci simboli diversi: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Con questi dieci simboli puoi rappresentare qualsiasi quantità. Unicode, binario, esadecimale e ottale si riferiscono a sistemi di numerazione diversi.

Quando finisci i simboli, passi alla posizione di cifra successiva. Nel sistema decimale, per rappresentare uno in più di 9, usi 10, che significa un'unità di dieci e zero unità di uno. Tuttavia, è diverso in altri sistemi di numerazione. Ad esempio, considerando un sistema binario che usa solo due simboli, 0 e 1, devi passare alla successiva posizione di cifra quando termini i simboli. Quindi così conterai in binario: 0, 1, 10, 11, 100, 101, ecc.

Vediamo più nel dettaglio alcuni dei sistemi di numerazione nelle prossime sezioni.

Convertire da binario a decimale in Python

Gli interi binari sono numeri rappresentati in base due. Questo significa che nel sistema binario ci sono solo due simboli usati per rappresentare i numeri: 0 e 1. Quando conti da zero in binario, esaurisci più rapidamente i simboli: 0, 1, ???

Non ci sono più simboli. Non passi alla cifra 2 perché il 2 non esiste in binario. Invece, usi una combinazione di 1 e 0. In un sistema binario, 1000 equivale a 8 in decimale. In binario usi potenze di due, il che significa che 8 è sostanzialmente: (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8. La posizione di 1 e 0 definisce la potenza a cui elevare 2.

Vediamo questo con un esempio più complesso per chiarire:

Binary Number = 1001111
Decimal value = (1*(2^6)) + (0*(2^5)) + (0*(2^4)) + (1*(2^3)) + (1*(2^2)) + (1*(2^1)) + (1*(2^0))
              = 79

In Python, puoi semplicemente usare la funzione bin() per convertire da un valore decimale al corrispondente valore binario.

Allo stesso modo, la funzione int() per convertire un binario nel suo valore decimale. La funzione int() accetta come secondo argomento la base del numero da convertire, che è 2 nel caso dei numeri binari.

a = 79

# Base 2(binary)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) #Base 2(binary)

0b1001111
79

Convertire da ottale a decimale in Python

L'ottale è un altro sistema numerico con meno simboli rispetto al sistema decimale convenzionale. È in base otto, il che significa che otto simboli vengono usati per rappresentare tutte le quantità. Sono 0, 1, 2, 3, 4, 5, 6 e 7. Dopo 7 viene 10, dato che l'8 non esiste.

Proprio come usavi le potenze di due in binario per determinare il valore di un numero, userai le potenze di 8 poiché questa è la base otto.

In un sistema ottale, 10 equivale a 8 in decimale. Scomponiamolo: (1(8^1)) + (0(8^0)) = 8.

Un esempio più complesso:

Octal Number = 117
Decimal value = (1*(8^2)) + (1*(8^1)) + (7*(8^0))
              = 79

In Python, puoi usare la funzione oct() per convertire da un valore decimale al corrispondente valore ottale. In alternativa, puoi anche usare la funzione int() con la base corretta, che è 8 per il sistema ottale.

a = 79

# Base 8(octal)
oct_a = oct(a)
print(oct_a)
print(int(oct_a, 8))

0o117
79

Convertire da esadecimale a decimale in Python

L'esadecimale è un sistema numerico in base 16. A differenza di binario e ottale, usa sei simboli aggiuntivi oltre ai numeri presenti nel sistema decimale.

Ma cosa viene dopo il 9?

Quando servono simboli oltre ai valori numerici normali, si usano le lettere. Quindi in esadecimale l'elenco totale dei simboli è 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E e F.

Usando lo stesso esempio di prima:

Hexadecimal Number = 4F
Decimal value = (4*(16^1)) + (F*(16^0))
              = 79

In Python, puoi usare la funzione hex() per convertire da un valore decimale al corrispondente valore esadecimale, oppure la funzione int() con base 16 per il sistema esadecimale.

a = 79

# Base 16(hexadecimal)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))

0x4f
79

Convertire da Unicode a carattere

Python chr() converte interi Unicode in una stringa. Unicode è una codifica di caratteri universalmente accettata per visualizzare i testi scritti di lingue diverse.

Abbiamo fornito vari interi Unicode alla funzione chr() per visualizzare “DATACAMP”. Puoi anche usare ord() per convertire un singolo carattere in un intero Unicode. 

print(
    chr(68),
    chr(65),
    chr(84),
    chr(65),
    chr(67),
    chr(65),
    chr(77),
    chr(80),
)

D A T A C A M P

Riepilogo: conversioni dei sistemi numerici in Python

Ci sei riuscito!

Complimenti! Hai imparato le conversioni dei tipi di dato in Python, principalmente usando metodi integrati. Questo ti aiuterà sicuramente a gestire vari tipi di dato, fornendoti maggiore flessibilità durante la scrittura dei programmi.

Abbiamo un ottimo corso su Intermediate Python for Data Science in cui puoi imparare a visualizzare i dati con matplotlib e a lavorare con dizionari e il famoso DataFrame di pandas. Vedrai anche come controllare il flusso del programma con i cicli. Alla fine del corso c'è anche un caso di studio in cui potrai applicare tutto ciò che hai imparato e mettere in pratica le tue conoscenze!