Quando tutto funziona, quasi nessuno pensa alle basi numeriche.
Un programma mostra un colore come #AD2DC8, Linux presenta un permesso come 754, un registro hardware restituisce 0x1A3F e un sensore invia una sequenza di bit. Per chi lavora a livello applicativo sono semplicemente valori da leggere, ma quando qualcosa non torna quelle rappresentazioni diventano improvvisamente importanti.
Un bit interpretato nel modo sbagliato può cambiare un permesso, alterare il valore di un registro oppure trasformare una misura positiva in un numero negativo. È proprio in queste situazioni che capire come funzionano binario, ottale, decimale ed esadecimale smette di essere un esercizio puramente scolastico e diventa uno strumento utile per leggere e controllare i dati.
In questo articolo affrontiamo sei esercizi con difficoltà crescente. Partiremo da una maschera binaria proveniente da un dispositivo IoT, passeremo dai colori CSS e dai permessi Unix, arriveremo ai registri hardware a 16 bit e al complemento a due, per concludere con la conversione di un numero frazionario.
Ogni esercizio segue la stessa logica: prima viene presentato uno scenario concreto, poi viene risolto il problema matematico e infine viene utilizzato Python per automatizzare e verificare il risultato.
L’obiettivo non è soltanto ottenere il numero corretto, ma capire perché quel numero viene rappresentato proprio in quel modo e riconoscere, quando lo incontriamo nel codice o nei dati, quale informazione contiene.
Perché le basi numeriche sono importanti in informatica
Il sistema decimale è quello che utilizziamo normalmente per contare, confrontare prezzi, misurare quantità e svolgere la maggior parte dei calcoli quotidiani. Un computer, però, lavora fisicamente con stati discreti che possono essere rappresentati attraverso bit, mentre molte rappresentazioni utilizzate nella programmazione sono costruite proprio a partire da questi bit.
Da qui derivano alcune basi particolarmente importanti.
Il sistema binario utilizza soltanto le cifre 0 e 1 ed è direttamente collegato alla rappresentazione dei bit.
Il sistema ottale utilizza le cifre da 0 a 7 e presenta un rapporto particolarmente comodo con il binario perché:
[math]8=2^3[/math]
Ogni cifra ottale può quindi essere rappresentata con esattamente tre bit.
Il sistema esadecimale utilizza le cifre da 0 a 9 e le lettere da A a F, con:
[math]16=2^4[/math]
Ogni cifra esadecimale corrisponde quindi a quattro bit.
Il sistema decimale, infine, utilizza le dieci cifre da 0 a 9 ed è quello con cui normalmente esprimiamo il valore numerico dei dati.
Queste corrispondenze non sono semplici curiosità matematiche. Sono il motivo per cui un valore binario molto lungo può essere rappresentato in forma esadecimale in modo molto più compatto e perché la notazione ottale è stata utilizzata per rappresentare i permessi dei sistemi Unix.
Contesto e notazione
Negli esercizi utilizzeremo prevalentemente le basi 2, 8, 10 e 16. Per evitare ambiguità, è utile distinguere il valore numerico dalla base nella quale viene scritto.
Possiamo utilizzare la notazione matematica:
- binario: [math]1010_2[/math]
- ottale: [math]754_8[/math]
- decimale: [math]182_{10}[/math]
- esadecimale: [math]1A3F_{16}[/math]
Nel codice Python vengono invece utilizzati i prefissi convenzionali:
0b1010 # binario
0o754 # ottale
182 # decimale
0x1A3F # esadecimale
È importante prestare attenzione alla notazione ottale in Python 3: 0o754 è la forma corretta per indicare esplicitamente un valore ottale, mentre la vecchia convenzione 0754 non è una sintassi valida per un intero ottale in Python 3.
Come scegliere il metodo di conversione
Non tutte le conversioni devono essere affrontate nello stesso modo. La scelta del procedimento dipende dalla rappresentazione di partenza e da quella di arrivo.
| Conversione | Metodo utile |
|---|---|
| Base qualsiasi → decimale | Espansione posizionale |
| Decimale intero → altra base | Divisioni successive |
| Binario → ottale | Raggruppamento di 3 bit |
| Ottale → binario | Conversione di ogni cifra in 3 bit |
| Binario → esadecimale | Raggruppamento di 4 bit |
| Esadecimale → binario | Conversione di ogni cifra in 4 bit |
| Frazione → altra base | Moltiplicazioni successive |
| Complemento a due | Interpretazione della parola binaria e del bit di segno |
Questa tabella è utile anche quando si lavora senza Python, perché permette di scegliere rapidamente il procedimento più naturale.
Un piccolo toolkit Python per le conversioni
Prima di affrontare gli esercizi costruiamo alcune funzioni riutilizzabili. L’obiettivo non è sostituire la comprensione matematica con una funzione Python, ma avere uno strumento con cui verificare i risultati e sperimentare con valori diversi.
Il toolkit permette di convertire interi tra basi da 2 a 36, gestire valori negativi, interpretare numeri in complemento a due e convertire frazioni utilizzando Fraction, evitando gli errori di arrotondamento tipici dei numeri floating point.
from fractions import Fraction
DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def base_to_int(s: str, base: int) -> int:
"""Converte una stringa in una base compresa tra 2 e 36
nel corrispondente intero decimale.
"""
if not (2 <= base <= len(DIGITS)):
raise ValueError("La base deve essere compresa tra 2 e 36")
s = s.strip().upper().replace("_", "")
if not s:
raise ValueError("La stringa di input non può essere vuota")
sign = 1
if s[0] in "+-":
sign = -1 if s[0] == "-" else 1
s = s[1:]
if not s:
raise ValueError("La stringa contiene solo il carattere di segno")
n = 0
for ch in s:
if ch not in DIGITS:
raise ValueError(
f"Carattere non valido per la conversione: {ch}"
)
d = DIGITS.index(ch)
if d >= base:
raise ValueError(
f"La cifra {ch} non è valida nella base {base}"
)
n = n * base + d
return sign * n
def int_to_base(n: int, base: int) -> str:
"""Converte un intero nella base specificata."""
if not (2 <= base <= len(DIGITS)):
raise ValueError("La base deve essere compresa tra 2 e 36")
if n == 0:
return "0"
sign = "-" if n < 0 else ""
n = abs(n)
out = []
while n:
n, r = divmod(n, base)
out.append(DIGITS[r])
return sign + "".join(reversed(out))
def decode_twos_complement(raw_hex: str, bits: int) -> int:
"""Decodifica un intero signed rappresentato
in complemento a due.
"""
if bits <= 0:
raise ValueError("Il numero di bit deve essere positivo")
raw = base_to_int(raw_hex, 16)
if raw >= 1 << bits:
raise ValueError(
"Il valore eccede il numero di bit indicati"
)
if raw & (1 << (bits - 1)):
return raw - (1 << bits)
return raw
def fraction_to_base(
value: Fraction,
base: int,
max_digits: int = 20
) -> str:
"""Converte una frazione nella base specificata."""
if not (2 <= base <= len(DIGITS)):
raise ValueError(
"La base deve essere compresa tra 2 e 36"
)
if value < 0:
return "-" + fraction_to_base(
-value, base, max_digits
)
integer = value.numerator // value.denominator
frac = value - integer
int_part = int_to_base(integer, base)
digits = []
for _ in range(max_digits):
if frac == 0:
break
frac *= base
d = frac.numerator // frac.denominator
digits.append(DIGITS[d])
frac -= d
return int_part + (
"." + "".join(digits)
if digits else ""
)
Una funzione come base_to_int() applica, dietro le quinte, la regola posizionale. L’istruzione:
n = n * base + d
permette infatti di costruire progressivamente il valore numerico senza dover calcolare manualmente tutte le potenze della base.
Come utilizzare e importare il toolkit negli esercizi
Il toolkit diventa davvero utile quando non dobbiamo riscrivere le stesse funzioni all’interno di ogni esercizio. L’idea è semplice: raccogliamo le funzioni in un piccolo modulo Python, lo importiamo nel programma e poi utilizziamo soltanto le funzioni che servono per risolvere il problema.
Creare il modulo Python
Supponiamo di chiamare il file del toolkit:
conversioni_basi.py
Il file contiene le funzioni viste nella sezione precedente:
def base_to_int(s, base):
return int(s, base)
def int_to_base(n, base):
if n == 0:
return "0"
digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
result = ""
while n > 0:
result = digits[n % base] + result
n //= base
return result
def decode_twos_complement(raw_hex, bits):
value = int(raw_hex, 16)
if value >= 2 ** (bits - 1):
value -= 2 ** bits
return value
def fraction_to_base(value, base, max_digits=20):
...
Il nome conversioni_basi.py non è obbligatorio: è semplicemente il nome che utilizzeremo negli esempi. La cosa importante è che il file abbia estensione .py e che il nome scelto venga poi utilizzato nell’istruzione import.
Come importare il modulo
Se conversioni_basi.py si trova nella stessa cartella del programma Python che stiamo eseguendo, possiamo importarlo con:
import conversioni_basi
A questo punto possiamo richiamare le funzioni specificando il nome del modulo:
risultato = conversioni_basi.base_to_int("10110110", 2)
print(risultato)
L’output sarà:
182
In questo caso la struttura della chiamata è:
nome_modulo.nome_funzione(...)
quindi:
conversioni_basi.base_to_int(...)
significa: “usa la funzione base_to_int contenuta nel modulo conversioni_basi“.
Importare direttamente le funzioni
Se vogliamo evitare di scrivere ogni volta conversioni_basi., possiamo importare direttamente le funzioni che ci interessano:
from conversioni_basi import base_to_int, int_to_base
Ora possiamo scrivere:
numero = base_to_int("10110110", 2)
binario = int_to_base(173, 2)
print(numero)
print(binario)
ottenendo:
182
10101101
Questa forma è particolarmente comoda negli esercizi, perché rende il codice più leggibile.
È anche possibile importare tutte le funzioni del modulo:
from conversioni_basi import *
ma negli esempi didattici è generalmente preferibile importare esplicitamente le funzioni utilizzate. In questo modo si vede subito da dove provengono e si evita di introdurre nel programma nomi che non servono.
Se utilizziamo Google Colab
In Google Colab il concetto è leggermente diverso perché il file conversioni_basi.py deve essere presente nell’ambiente di esecuzione.
Per un articolo didattico possiamo procedere in modo semplice caricando il file nella sessione Colab. Dopo aver caricato conversioni_basi.py, possiamo verificare che il file sia disponibile:
import os
print(os.listdir())
Se nell’elenco compare:
conversioni_basi.py
possiamo importarlo normalmente:
import conversioni_basi
oppure:
from conversioni_basi import base_to_int, int_to_base
Una volta importato, il modulo può essere utilizzato negli esercizi senza copiare nuovamente tutte le funzioni.
Come scegliere la funzione negli esercizi
A questo punto possiamo leggere ogni esercizio in due momenti distinti: prima individuiamo il tipo di conversione matematica richiesta, poi scegliamo la funzione Python corrispondente.
| Situazione | Funzione da utilizzare |
|---|---|
| Binario → decimale | base_to_int() |
| Ottale → decimale | base_to_int() |
| Esadecimale → decimale | base_to_int() |
| Decimale → binario | int_to_base() |
| Decimale → ottale | int_to_base() |
| Decimale → esadecimale | int_to_base() |
| Numero in complemento a due | decode_twos_complement() |
| Frazione → altra base | fraction_to_base() |
Per esempio, se un esercizio presenta il valore binario:
10110110₂
la conversione richiesta è binario → decimale, quindi utilizziamo:
from conversioni_basi import base_to_int
valore = base_to_int("10110110", 2)
print(valore)
ottenendo:
182
Se invece dobbiamo trasformare 173 in esadecimale:
from conversioni_basi import int_to_base
valore = int_to_base(173, 16)
print(valore)
otteniamo:
AD
Nel caso del complemento a due, la funzione da utilizzare è diversa perché non stiamo effettuando una semplice conversione di base. Dobbiamo interpretare una sequenza di bit come numero con segno secondo una determinata ampiezza.
Per esempio:
from conversioni_basi import decode_twos_complement
valore = decode_twos_complement("F3A", 12)
print(valore)
restituisce:
-198
Il parametro 12 è fondamentale: indica che F3A deve essere interpretato come una parola di 12 bit. Senza conoscere la dimensione della parola non possiamo stabilire correttamente l’interpretazione con segno.
Il vantaggio del modulo
La differenza rispetto a inserire tutte le funzioni direttamente in ogni esercizio diventa evidente quando gli esercizi aumentano.
Senza un modulo dovremmo ripetere continuamente:
def base_to_int(...):
...
def int_to_base(...):
...
def decode_twos_complement(...):
...
Con il modulo, invece, ogni esercizio può iniziare semplicemente con:
from conversioni_basi import base_to_int, int_to_base
e concentrarsi sul problema da risolvere.
Questa separazione è importante anche dal punto di vista didattico: il modulo contiene gli strumenti, mentre l’esercizio contiene la logica del problema.
Negli esercizi successivi, quindi, seguiremo sempre lo stesso schema: prima interpretiamo il problema e svolgiamo la conversione matematica, poi utilizziamo la funzione del toolkit come verifica e come implementazione Python. In questo modo Python non sostituisce il ragionamento sulla rappresentazione dei numeri, ma diventa uno strumento per automatizzarlo e controllarne il risultato.
Esercizio — Una maschera di stato IoT da binario a decimale
Scenario operativo
Un gateway IoT riceve continuamente da un sensore ambientale una maschera di stato a 8 bit. L’ultimo valore acquisito è:
10110110
Il firmware deve pubblicare sul broker MQTT il valore decimale corrispondente e, nello stesso tempo, documentare quali bit risultano attivi.
Soluzione matematica
La rappresentazione binaria è una notazione posizionale nella quale ogni cifra viene moltiplicata per una potenza di 2. Partendo da destra, il primo bit ha peso [math]2^0[/math], il successivo [math]2^1[/math], poi [math]2^2[/math] e così via.
Per gli otto bit considerati abbiamo:
| Posizione | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|---|---|---|---|---|---|---|---|---|
| Peso | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| Bit | 1 | 0 | 1 | 1 | 0 | 1 | 1 | 0 |
Sono quindi attivi i bit nelle posizioni 7, 5, 4, 2 e 1.
Il valore decimale è:
[math]128+32+16+4+2=182[/math]
perciò:
[math]\boxed{10110110_2=182_{10}}[/math]
Verifica con Python
valore_decimale = base_to_int("10110110", 2)
print(valore_decimale)
Output:
182
Il risultato è coerente con il calcolo manuale.
Un dettaglio importante sui bit
Il bit più a sinistra viene chiamato Most Significant Bit, o MSB, perché possiede il peso maggiore, mentre quello più a destra viene chiamato Least Significant Bit, o LSB.
Aggiungere zeri a sinistra non cambia il valore matematico:
[math]10110110_2=010110110_2[/math]
purché si mantenga la stessa interpretazione della sequenza. In un sistema digitale, però, la larghezza del dato può essere significativa, perché un registro a 8 bit e uno a 16 bit rappresentano parole di dimensione diversa.
Domande di riflessione
Perché una stessa sequenza di bit non può rappresentare due interi diversi quando la base e l’ordine delle cifre sono fissati?
Che cosa cambia, dal punto di vista della rappresentazione, quando lo stesso valore viene memorizzato in un registro a 8 bit oppure in uno a 16 bit?
Esercizio — Un colore CSS da decimale a binario ed esadecimale
Scenario operativo
Un web designer trasmette a un’API backend un colore espresso nel formato:
rgb(173, 45, 200)
Il sistema che riceve il dato accetta invece esclusivamente il formato esadecimale concatenato:
#RRGGBB
Dobbiamo quindi convertire le tre componenti e ottenere il codice CSS finale.
Per la componente rossa, pari a 173, vogliamo inoltre mostrare il passaggio attraverso la rappresentazione binaria.
Conversione di 173 in binario
Per convertire un intero decimale in binario possiamo utilizzare divisioni successive per 2, conservando i resti.
| Divisione | Quoziente | Resto |
|---|---|---|
| 173 / 2 | 86 | 1 |
| 86 / 2 | 43 | 0 |
| 43 / 2 | 21 | 1 |
| 21 / 2 | 10 | 1 |
| 10 / 2 | 5 | 0 |
| 5 / 2 | 2 | 1 |
| 2 / 2 | 1 | 0 |
| 1 / 2 | 0 | 1 |
Leggendo i resti dal basso verso l’alto otteniamo:
[math]173_{10}=10101101_2[/math]
Per passare dal binario all’esadecimale possiamo raggruppare i bit a quattro a quattro:
1010 1101
Il gruppo 1010 corrisponde a 10, cioè A, mentre 1101 corrisponde a 13, cioè D.
Pertanto:
[math]173_{10}=AD_{16}[/math]
Conversione delle altre componenti
Per il verde:
[math]45/16=2[/math]
con resto 13, cioè D, mentre:
[math]2/16=0[/math]
con resto 2.
Otteniamo quindi:
[math]45_{10}=2D_{16}[/math]
Per il blu:
[math]200/16=12[/math]
con resto 8, quindi:
[math]200_{10}=C8_{16}[/math]
Il colore completo diventa:
[math]\boxed{\#AD2DC8}[/math]
Implementazione Python
rosso = int_to_base(173, 16).zfill(2)
verde = int_to_base(45, 16).zfill(2)
blu = int_to_base(200, 16).zfill(2)
colore_esadecimale = f"#{rosso}{verde}{blu}"
print(colore_esadecimale)
print(int_to_base(173, 2))
Output:
#AD2DC8
10101101
L’uso di zfill(2) è utile perché il formato CSS richiede che ciascuna componente occupi due cifre esadecimali, anche quando il valore potrebbe essere rappresentato con una sola cifra.
Perché l’esadecimale è così comodo
Il rapporto:
[math]16=2^4[/math]
fa sì che ogni cifra esadecimale rappresenti esattamente quattro bit. Un byte, quindi, può essere scritto con due sole cifre esadecimali.
Per esempio:
10101101
può essere scritto semplicemente come:
AD
La stessa relazione spiega perché l’esadecimale è così comune nei colori CSS, negli indirizzi MAC, negli indirizzi IPv6, nei dump di memoria e nella rappresentazione di valori binari.
Domande di riflessione
Perché ogni cifra esadecimale corrisponde esattamente a quattro bit?
Che cosa dovrebbe accadere durante la validazione se una stringa dichiarata esadecimale contenesse una cifra come G?
Esercizio — Permessi Unix e rappresentazione ottale
Scenario operativo
Un amministratore di sistema esegue:
chmod 754 deploy.sh
e deve spiegare a un collega che cosa rappresentano le tre cifre 754, mostrando anche la corrispondente rappresentazione binaria e il valore decimale.
Perché i permessi Unix utilizzano l’ottale
Ogni cifra ottale può essere rappresentata con tre bit perché:
[math]8=2^3[/math]
La corrispondenza è particolarmente comoda per i permessi Unix, perché i tre bit possono essere associati a lettura, scrittura ed esecuzione.
| Cifra | Binario | Permessi |
|---|---|---|
| 7 | 111 | rwx |
| 5 | 101 | r-x |
| 4 | 100 | r– |
Pertanto:
754
diventa:
111 101 100
e quindi:
[math]\boxed{754_8=111101100_2}[/math]
La configurazione significa che il proprietario dispone di lettura, scrittura ed esecuzione, il gruppo dispone di lettura ed esecuzione, mentre gli altri utenti dispongono soltanto della lettura.
La rappresentazione simbolica è quindi:
rwxr-xr--
Conversione in decimale
Utilizzando l’espansione posizionale:
[math]\displaystyle 754_8 = 7\cdot8^2 + 5\cdot8^1 + 4\cdot8^0[/math]
quindi:
[math]7\cdot64+5\cdot8+4[/math]
[math]448+40+4=492[/math]
e dunque:
[math]\boxed{754_8=492_{10}}[/math]
Implementazione Python
permessi_ottali = "754"
valore_decimale = base_to_int(
permessi_ottali,
8
)
valore_binario = int_to_base(
valore_decimale,
2
)
print(valore_decimale)
print(valore_binario)
Output:
492
111101100
In Python possiamo anche rappresentare direttamente il valore ottale attraverso il prefisso 0o:
permessi = 0o754
print(permessi)
ottenendo:
492
Una precisazione sulla rappresentazione
Il numero 492 è il valore decimale associato a [math]754_8[/math], ma non è la forma più leggibile quando stiamo parlando di permessi Unix. In questo contesto 754 contiene una struttura che il lettore riconosce immediatamente: tre gruppi di tre bit, rispettivamente associati a proprietario, gruppo e altri utenti.
Domande di riflessione
Perché la base ottale è particolarmente adatta a rappresentare i permessi POSIX?
In che modo i valori 4, 2 e 1 si combinano per produrre tutte le possibili configurazioni rwx?
Esercizio — Un registro hardware a 16 bit
Scenario operativo
Durante l’ispezione a basso livello di una scheda di rete, un analizzatore legge il seguente valore:
0x1A3F
Il registro hardware è largo 16 bit e il firmware deve conoscere sia il valore decimale sia la rappresentazione binaria completa, mantenendo quindi anche gli eventuali zeri iniziali.
Conversione in decimale
La rappresentazione esadecimale contiene quattro cifre:
1 A 3 F
Ricordando che:
[math]A=10[/math]
e:
[math]F=15[/math]
possiamo applicare l’espansione posizionale:
[math]\displaystyle 1\cdot16^3 + 10\cdot16^2 + 3\cdot16^1 + 15\cdot16^0[/math]
Otteniamo:
[math]1\cdot4096=4096[/math]
[math]10\cdot256=2560[/math]
[math]3\cdot16=48[/math]
[math]15\cdot1=15[/math]
La somma è:
[math]4096+2560+48+15=6719[/math]
perciò:
[math]\boxed{0x1A3F=6719_{10}}[/math]
Conversione in binario
Il vantaggio dell’esadecimale diventa particolarmente evidente in questa fase, perché ogni cifra può essere sostituita direttamente da quattro bit:
1 → 0001
A → 1010
3 → 0011
F → 1111
Otteniamo quindi:
0001 1010 0011 1111
ovvero:
[math]\boxed{0001101000111111_2}[/math]
Poiché il registro è definito come registro a 16 bit, mantenere i quattro zeri iniziali è utile per mostrare la posizione di tutti i bit all’interno della parola.
Implementazione Python
valore_grezzo = base_to_int("1A3F", 16)
binario_espanso = int_to_base(
valore_grezzo,
2
).zfill(16)
print(valore_grezzo)
print(binario_espanso)
Output:
6719
0001101000111111
Qui zfill(16) non modifica il valore numerico: serve a rendere esplicita la larghezza della rappresentazione.
Questa distinzione è importante perché gli zeri iniziali non aggiungono valore matematico, ma possono avere un significato quando la larghezza della parola fa parte del problema.
Un collegamento con le operazioni bit a bit
Quando lavoriamo con un registro hardware, la posizione di un bit può avere un significato concreto. Una maschera come:
0000000011110000
può indicare quali bit devono essere letti, modificati o lasciati invariati durante un’operazione.
In questi casi visualizzare il valore nella sua larghezza completa rende molto più semplice confrontare il dato con la maschera.
Una domanda sull’endianness
Se il valore 0x1A3F viene memorizzato in RAM utilizzando due byte, la sequenza dei byte dipende dall’endianness dell’architettura.
In una rappresentazione Big-Endian il byte più significativo viene memorizzato per primo:
1A 3F
In una rappresentazione Little-Endian viene memorizzato per primo il byte meno significativo:
3F 1A
Il valore numerico rimane lo stesso, mentre cambia l’ordine dei byte in memoria.
Domande di riflessione
Perché gli zeri iniziali sono utili quando rappresentiamo un registro a larghezza fissa, anche se non modificano il valore numerico?
Qual è la differenza tra il valore 0x1A3F e l’ordine dei suoi due byte quando viene memorizzato in RAM?
Esercizio — Un sensore ADC a 12 bit in complemento a due
Scenario operativo
Un sistema di controllo riceve da un convertitore analogico-digitale, o ADC, una misura signed rappresentata su 12 bit in complemento a due.
L’ultimo valore ricevuto è:
0xF3A
Il software deve trasformare la rappresentazione grezza nel corrispondente valore decimale signed.
Dall’esadecimale al binario
Ogni cifra esadecimale corrisponde a quattro bit:
F → 1111
3 → 0011
A → 1010
Otteniamo:
1111 0011 1010
Poiché stiamo lavorando con una parola di 12 bit, il primo bit è il bit più significativo e, nel complemento a due, determina se il valore è positivo o negativo.
Qui il bit più significativo vale:
1
quindi il valore deve essere interpretato come negativo.
Calcolo attraverso il valore unsigned
Se ignorassimo temporaneamente il segno, il valore sarebbe:
[math]\displaystyle 15\cdot256 + 3\cdot16 + 10[/math]
quindi:
[math]3840+48+10=3898[/math]
Il massimo valore rappresentabile con 12 bit senza segno è:
[math]2^{12}-1=4095[/math]
Nel complemento a due, quando il bit di segno vale 1, possiamo ottenere il valore signed sottraendo [math]2^{12}[/math]:
[math]3898-4096=-198[/math]
Pertanto:
[math]\boxed{0xF3A=-198}[/math]
Verifica attraverso il complemento a due
Possiamo anche procedere nel modo tradizionale.
Partiamo da:
1111 0011 1010
Invertiamo tutti i bit:
0000 1100 0101
e aggiungiamo 1:
0000 1100 0110
Il valore ottenuto è:
[math]198[/math]
Poiché la rappresentazione originale aveva il bit di segno uguale a 1, il risultato è:
[math]\boxed{-198}[/math]
I due procedimenti arrivano allo stesso risultato.
Implementazione Python
valore_decodificato = decode_twos_complement(
"F3A",
12
)
print(valore_decodificato)
Output:
-198
Perché il complemento a due è così importante
Il complemento a due permette di utilizzare la stessa logica binaria per effettuare operazioni aritmetiche su valori positivi e negativi, evitando la presenza di due rappresentazioni dello zero e rendendo naturale l’uso di somme e sottrazioni a livello hardware.
Per una parola di [math]n[/math] bit, l’intervallo rappresentabile con complemento a due è:
[math]-2^{n-1}\leq x\leq 2^{n-1}-1[/math]
Per 12 bit abbiamo quindi:
[math]-2048\leq x\leq 2047[/math]
Il valore -198 rientra correttamente in questo intervallo.
Un errore frequente: l’estensione del segno
Quando un valore signed viene trasferito da una parola più piccola a una più grande, non basta aggiungere zeri a sinistra.
Per esempio, il valore binario a 8 bit:
11111110
rappresenta -2 in complemento a due.
Se vogliamo rappresentarlo su 16 bit dobbiamo mantenere il segno:
1111111111111110
e non:
0000000011111110
La prima è ancora -2, mentre la seconda rappresenta 254.
Domande di riflessione
Qual è la differenza fondamentale tra interpretare 11111110 come unsigned e interpretarlo come signed in complemento a due?
Perché, quando si amplia una rappresentazione signed negativa, è necessario effettuare l’estensione del segno invece di aggiungere semplicemente zeri?
Esercizio — Un fattore di calibrazione frazionario
Scenario operativo
Un sistema di telemetria riceve un fattore di calibrazione pari a:
[math]10.625[/math]
Il processore utilizza una rappresentazione binaria, mentre alcuni strumenti di diagnostica utilizzano rappresentazioni ottali ed esadecimali.
In questo caso non basta convertire la parte intera, perché dobbiamo trasformare anche la parte frazionaria.
Separiamo parte intera e parte frazionaria
Scriviamo:
[math]10.625=10+0.625[/math]
La parte intera è:
[math]10_{10}=1010_2=12_8=A_{16}[/math]
Resta da convertire:
[math]0.625[/math]
Conversione della parte frazionaria in binario
Per convertire una frazione in una nuova base utilizziamo moltiplicazioni successive per la base di destinazione, prendendo ogni volta la parte intera del risultato.
Per la base 2:
[math]0.625\cdot2=1.25[/math]
La prima cifra è quindi 1 e rimane:
[math]0.25[/math]
Continuiamo:
[math]0.25\cdot2=0.50[/math]
La seconda cifra è 0.
Infine:
[math]0.50\cdot2=1.00[/math]
La terza cifra è 1 e il resto è zero.
Otteniamo:
[math]0.625_{10}=0.101_2[/math]
La parte intera era 1010, quindi:
[math]\boxed{10.625_{10}=1010.101_2}[/math]
Conversione in ottale
Moltiplichiamo per 8:
[math]0.625\cdot8=5[/math]
Il resto è zero, quindi abbiamo direttamente:
[math]0.625_{10}=0.5_8[/math]
e:
[math]\boxed{10.625_{10}=12.5_8}[/math]
Conversione in esadecimale
Moltiplichiamo per 16:
[math]0.625\cdot16=10[/math]
Il valore 10 corrisponde alla cifra A in esadecimale, quindi:
[math]0.625_{10}=0.A_{16}[/math]
e:
[math]\boxed{10.625_{10}=A.A_{16}}[/math]
Verifica con Python
Il valore decimale può essere scritto esattamente come:
[math]10.625=\frac{85}{8}[/math]
Utilizziamo quindi Fraction:
from fractions import Fraction
valore_frazionario = Fraction(85, 8)
print(fraction_to_base(
valore_frazionario,
2
))
print(fraction_to_base(
valore_frazionario,
8
))
print(fraction_to_base(
valore_frazionario,
16
))
Output:
1010.101
12.5
A.A
Quando una frazione ha una rappresentazione finita?
Qui emerge una regola matematica generale molto utile.
Una frazione ridotta ai minimi termini ha una rappresentazione finita nella base [math]b[/math] se e solo se tutti i fattori primi del denominatore sono anche fattori della base.
Per esempio:
[math]\frac58[/math]
ha denominatore:
[math]8=2^3[/math]
e quindi possiede una rappresentazione finita in base 2, base 8 e base 16.
Al contrario:
[math]\frac13[/math]
ha come denominatore il numero primo 3. In base 2 non può essere rappresentata con un numero finito di cifre:
[math]\frac13=0.01010101\ldots_2[/math]
La stessa frazione è invece periodica anche in base 10:
[math]\frac13=0.3333\ldots_{10}[/math]
La presenza o meno di una parte periodica, quindi, non dipende dal fatto che un numero sia “frazionario” in senso generico, ma dalla relazione tra i fattori primi del denominatore e la base nella quale vogliamo rappresentarlo.
Un dettaglio importante su Python
L’utilizzo di Fraction è particolarmente utile negli esercizi didattici perché conserva esattamente il rapporto tra numeratore e denominatore.
Con un normale float, infatti, molti numeri decimali non sono rappresentabili esattamente in binario. In questo esercizio 10.625 non presenta questo problema, ma utilizzare una frazione esatta rende esplicito il procedimento matematico e permette di estenderlo a casi più generali.
Domande di riflessione
Perché alcune frazioni finite in base 10 diventano periodiche in base 2, mentre altre mantengono una rappresentazione finita?
Quale condizione deve soddisfare il denominatore di una frazione ridotta ai minimi termini affinché la rappresentazione nella base [math]b[/math] sia finita?
Errori comuni nelle conversioni tra basi
Gli errori nelle conversioni numeriche non derivano sempre da calcoli sbagliati; spesso nascono da una rappresentazione interpretata nel modo sbagliato.
Un primo errore consiste nel confondere il valore numerico con la rappresentazione. 1010 può essere il numero dieci se interpretato in base 10, oppure il numero dieci anche se scritto come [math]1010_2[/math], ma una stringa come 754 non può essere interpretata allo stesso modo in tutte le basi perché la cifra 7 non è valida, per esempio, in base 7.
Un secondo errore riguarda gli zeri iniziali. Dal punto di vista matematico:
[math]101_2=00101_2[/math]
ma se stiamo rappresentando un registro a 5 bit, quei cinque bit fanno parte della rappresentazione che vogliamo visualizzare.
Un terzo errore consiste nel dimenticare che l’esadecimale utilizza le lettere da A a F. La cifra G, per esempio, non è valida in base 16.
Un quarto errore riguarda il complemento a due: il valore di una sequenza binaria dipende dalla sua interpretazione. La stessa sequenza di bit può essere considerata unsigned oppure signed, producendo valori numerici diversi.
Un quinto errore consiste nel trattare tutte le frazioni come se avessero necessariamente una rappresentazione finita in qualsiasi base. La finitezza dipende invece dai fattori primi del denominatore e dalla base utilizzata.
Infine, quando si scrive codice per una conversione, è importante distinguere il risultato matematico dal formato richiesto dall’applicazione. Il valore A può essere numericamente corretto, ma se stiamo costruendo una componente CSS dobbiamo rispettare il formato a due cifre esadecimali previsto da #RRGGBB.
Cosa abbiamo visto nei sei esercizi
I sei esercizi seguono situazioni diverse, ma sono collegati dalla stessa idea: una sequenza di cifre acquista significato solo quando conosciamo la base e il modo in cui il dato deve essere interpretato.
Nel primo esercizio abbiamo trasformato una maschera binaria in un valore decimale e abbiamo collegato le singole cifre alle posizioni dei bit.
Nel secondo abbiamo visto perché l’esadecimale è particolarmente efficace nella rappresentazione dei colori e come il rapporto [math]16=2^4[/math] permetta di passare direttamente tra gruppi di quattro bit e cifre esadecimali.
Nel terzo abbiamo utilizzato la stessa logica per leggere i permessi Unix, sfruttando il rapporto [math]8=2^3[/math] tra ottale e binario.
Nel quarto abbiamo lavorato con un registro a 16 bit, mostrando perché la larghezza della parola può essere importante anche quando gli zeri iniziali non modificano il valore numerico.
Nel quinto abbiamo affrontato una situazione più delicata, nella quale la stessa sequenza di bit deve essere interpretata attraverso il complemento a due per ottenere un valore signed.
Nel sesto, infine, abbiamo esteso il ragionamento ai numeri frazionari, arrivando a una regola generale sulla finitezza delle rappresentazioni posizionali.
Python non sostituisce questi procedimenti: permette di automatizzarli, verificarli e utilizzarli su quantità di dati molto più grandi. La funzione:
base_to_int("10110110", 2)
è utile proprio perché sappiamo già che cosa dovrebbe fare matematicamente.
Questa distinzione è importante quando si lavora con dati reali: un programma può eseguire una conversione in una frazione di secondo, ma la correttezza del risultato dipende dalla nostra capacità di stabilire quale rappresentazione stiamo leggendo e quale significato dobbiamo attribuirle.
Risposte alle domande di riflessione
Esercizio — Maschera binaria
Una rappresentazione posizionale in una base fissata assegna a ogni posizione una potenza della base e limita le cifre ammesse all’intervallo da 0 a [math]b-1[/math]. Questa struttura determina univocamente il valore rappresentato.
Gli zeri iniziali non cambiano il valore matematico, ma possono essere necessari per rendere esplicita la dimensione della parola utilizzata dal sistema. Un dato a 8 bit e uno a 16 bit possono quindi avere lo stesso valore numerico pur appartenendo a rappresentazioni di larghezza diversa.
Esercizio — Colore CSS
Il raggruppamento a quattro bit deriva direttamente dalla relazione:
[math]16=2^4[/math]
Le sedici possibili combinazioni di quattro bit corrispondono esattamente alle sedici cifre disponibili nella base esadecimale, da 0 a F.
Una cifra come G non appartiene alla base 16. Un parser correttamente progettato deve quindi rifiutarla invece di tentare di attribuirle arbitrariamente un valore.
Esercizio — Permessi Unix
La base ottale è adatta ai permessi Unix perché:
[math]8=2^3[/math]
Ogni cifra ottale corrisponde quindi a tre bit. I tre bit rappresentano rispettivamente i pesi 4, 2 e 1, associati alle autorizzazioni di lettura, scrittura ed esecuzione.
Per esempio:
7 = 4 + 2 + 1 = rwx
5 = 4 + 1 = r-x
4 = 4 = r--
Esercizio — Registro a 16 bit
Gli zeri iniziali non modificano il valore numerico, ma rendono visibile la posizione di tutti i bit all’interno della parola. Questo diventa importante quando il valore viene confrontato con maschere, registri o specifiche hardware che lavorano con una larghezza precisa.
Per quanto riguarda l’endianness, il valore 0x1A3F è composto dai byte 1A e 3F. In Big-Endian viene memorizzato come 1A 3F, mentre in Little-Endian come 3F 1A.
Esercizio — Complemento a due
La sequenza:
11111110
se interpretata come unsigned vale:
[math]254[/math]
mentre su 8 bit, se interpretata in complemento a due, vale:
[math]254-256=-2[/math]
Quando una rappresentazione signed negativa viene ampliata, bisogna mantenere il valore del bit di segno. Per questo 11111110 diventa:
1111111111111110
e non:
0000000011111110
Esercizio — Numero frazionario
Una frazione ridotta ai minimi termini ha una rappresentazione finita in base [math]b[/math] quando tutti i fattori primi del denominatore sono fattori della base.
Per esempio:
[math]\frac58[/math]
ha denominatore [math]2^3[/math], quindi è finita in base 2, 8 e 16.
Al contrario:
[math]\frac13[/math]
ha un denominatore contenente il fattore primo 3 e quindi non possiede una rappresentazione finita in base 2.
La regola permette di capire in anticipo se una conversione produrrà una sequenza finita oppure una parte frazionaria periodica.
Un ultimo controllo con Python
Possiamo concludere verificando in modo compatto alcuni dei risultati ottenuti:
print(base_to_int("10110110", 2))
print(int_to_base(173, 16))
print(base_to_int("754", 8))
print(int_to_base(6719, 2).zfill(16))
print(decode_twos_complement("F3A", 12))
valore = Fraction(85, 8)
print(fraction_to_base(valore, 2))
print(fraction_to_base(valore, 8))
print(fraction_to_base(valore, 16))
Output:
182
AD
492
0001101000111111
-198
1010.101
12.5
A.A
I risultati ottenuti dal programma coincidono con quelli ricavati attraverso i procedimenti matematici.
Ed è proprio questo il punto centrale dell’esercizio: Python è molto utile per fare conversioni rapidamente, ma la parte più importante rimane capire che cosa rappresenta il dato prima di convertirlo.
Un 10110110 può essere una semplice sequenza di bit, una maschera di stato, un intero unsigned oppure una parte di una struttura più complessa. Un F3A può rappresentare 3898 se interpretato come unsigned oppure -198 se interpretato come valore signed a 12 bit. Il numero non è cambiato: è cambiata la regola con cui quei bit vengono interpretati.
Per questo le basi numeriche continuano ad avere un ruolo concreto nella programmazione, nei sistemi operativi, nell’elettronica digitale e nell’analisi dei dati. Capire la rappresentazione significa poter leggere correttamente ciò che il computer sta effettivamente manipolando.
📚 Per approfondire: rappresentazione dei numeri, basi e Python
Se vuoi andare oltre le singole conversioni e capire come basi numeriche, proprietà dei numeri e programmazione si collegano tra loro, ecco alcuni percorsi di approfondimento:
👉 Conversione tra basi numeriche: guida completa con esercizi e applicazioni
👉 Aritmetica modulare e divisibilità: esercizi risolti sui resti e residui quadratici
👉 Come risolvere le espressioni con radici e potenze grandi: 5 esercizi svolti passo passo
👉 Python: calcolo del M.C.D. tra due numeri
👉 Cime gemelle matematiche: visualizzare l’orografia dei numeri con Python
👉 Dimostriamo che non possiamo avere quattro numeri dispari consecutivi tutti primi (anche in Python)
(89)
Altri articoli nella categoria "Esercizi svolti di Algebra"
- Somme di frazioni e identità simmetriche: problemi ed esercizi svolti
- Radicali ed Equazioni Esponenziali: Esercizi Svolti, Basi Coniugate e Metodi di Risoluzione
- Funzioni trascendenti: definizioni ed esercizi svolti su esponenziali, logaritmi e trigonometria
- Esercizi Svolti sui Logaritmi: Guida Progressiva con Domini e Proprietà
- Test Logaritmi con Soluzioni Spiegate: 10 Quesiti ed Errori Tipici
- Disequazioni Fratte Difficili: Valore Assoluto, Parametri e Radicali
- Sistemi lineari: 6 esercizi svolti con tutti i metodi di risoluzione
- Equazioni Omogenee Esponenziali: Guida Pratica con Esercizi Svolti e Applicazioni
- Risolvere le Equazioni Frazionarie Simmetriche: Dal Calcolo del Rapporto a/b alle Trasformazioni di Möbius e Python
- Come calcolare logaritmi con il cambio di base: formule, espansioni e stime analitiche