Conversione del formato in Python, formato (riempimento dello zero, notazione esponenziale, esadecimale, ecc.)

Attività commerciale

Per convertire (formattare) un numero o una stringa in vari formati in Python, usate la funzione built-in format() o il metodo str.format().

In questa sezione, spiegheremo come utilizzare le seguenti funzioni.

  • funzione incorporata (per esempio nel linguaggio di programmazione)format()
  • metodo della stringastr.format()

Inoltre, la stringa di specificazione del formato per la conversione al formato seguente è spiegata con codice di esempio.

  • Giustificato a sinistra, Giustificato al centro, Giustificato a destra
  • riempimento zero
  • Segno (più o meno)
  • Separatore di cifre (virgola, trattino basso)
  • Numeri binari, ottali ed esadecimali
  • Specificare il numero di cifre dopo il punto decimale
  • Cifre significative (numero di cifre significative)
  • notazione esponenziale
  • Visualizzazione della percentuale

Notate che da Python 3.6, le stringhe f (f-strings) sono state aggiunte al metodo str.format() per renderlo più conciso.

Funzione incorporata: format()

format() è fornito come una funzione standard integrata in Python.

Lo schema è il seguente.

  • format(value, format_spec)
    • Il primo argomento: ilvalue
      Il valore originale. Stringa str, numero int, float, ecc.
    • Il secondo argomentoformat_spec
      Stringa di specificazione del formato. Stringa str
    • Valore di ritorno: una stringa formattata str

Degli esempi sono mostrati qui sotto. I tipi di stringhe di formato e come scriverle sono descritti più avanti.

In questo esempio, abbiamo usato letterali numerici e letterali di stringa come primo argomento, ma naturalmente potete usare variabili che contengono questi valori.

s = format(255, '04x')
print(s)
print(type(s))
# 00ff
# <class 'str'>

print(format('center', '*^16'))
# *****center*****

Metodo stringa str.format()

C'è anche un metodo format() per il tipo stringa str.

Il {} nella stringa str che chiama il metodo format() è chiamato campo di sostituzione, e viene sostituito dall'argomento del metodo format().

La stringa di specificazione del formato dovrebbe essere scritta nel campo di sostituzione {} seguito da “:”.

Il valore di ritorno è una stringa formattata str.

Il processo equivalente alla funzione built-in format() descritta sopra è il seguente.

s = '{:04x}'.format(255)
print(s)
print(type(s))
# 00ff
# <class 'str'>

print('{:*^16}'.format('center'))
# *****center*****

Di nuovo, stiamo usando letterali numerici e letterali di stringa come argomenti, ma naturalmente anche le variabili sono accettabili.

Specificare gli argomenti per i campi di sostituzione

Specificare gli argomenti in ordine (predefinito)

Ci possono essere più campi di sostituzione {}, e per impostazione predefinita, gli argomenti del metodo sono processati in ordine. Se la stringa di specificazione del formato in {} è omessa, sarà semplicemente convertita in una stringa da str().

Utile per inserire valori variabili in una stringa e stamparli.

print('{}-{}-{}'.format('100', '二百', 300))
# 100-二百-300

Specificare un argomento posizionale per valori interi

Se un valore intero è specificato in {}, come {0} o {1}, l'output dipenderà dall'ordine degli argomenti. Lo stesso numero può essere usato ripetutamente. Questo è utile quando vuoi inserire lo stesso valore in una stringa.

print('{0}-{1}-{0}'.format('foo', 'bar'))
# foo-bar-foo

Specificare argomenti di parole chiave per nomi arbitrari (stringhe)

Potete anche specificare qualsiasi nome in {} e inserirlo come argomento di una parola chiave.

print('{day}/{month}/{year}/'.format(day=11, month=1, year=2018))
# 11/1/2018

Specificare un elenco o un dizionario come argomento

Le liste e i dizionari possono essere specificati come argomenti.

Usate [] per specificare l'indice di una lista o la chiave di un dizionario in un campo di sostituzione. Nota che le virgolette “'” e “” non si usano per specificare le chiavi di un dizionario.

Se volete usare lo stesso argomento ripetutamente, dovete specificare un valore intero o una stringa (nome) come descritto sopra.

l = ['one', 'two', 'three']
print('{0[0]}-{0[1]}-{0[2]}'.format(l))
# one-two-three

d1 = {'name': 'Alice', 'age': 20}
d2 = {'name': 'Bob', 'age': 30}
print('{0[name]} is {0[age]} years old.\n{1[name]} is {1[age]} years old.'.format(d1, d2))
# Alice is 20 years old.
# Bob is 30 years old.

Può essere espanso come argomento posizionale aggiungendo * alla lista e specificandolo come argomento, o come argomento di parola chiave aggiungendo ** al dizionario e specificandolo come argomento.

l = ['one', 'two', 'three']
print('{}-{}-{}'.format(*l))
# one-two-three

d = {'name': 'Alice', 'age': 20}
print('{name} is {age} years old.'.format(**d))
# Alice is 20 years old.

Descrizione delle parentesi graffe {}

Se vuoi scrivere parentesi graffe {,} nel metodo format(), ripetilo due volte come {{,}}. Notate che i backslash non possono essere sfuggiti.

print('{{}}-{num}-{{{num}}}'.format(num=100))
# {}-100-{100}

stringa formattata

In entrambi i casi, per specificare il formato, scrivete “:format string” dopo il valore intero o la stringa del nome in {}.

print('{num:x}'.format(num=255))
# ff

print('{day}/{month:02}/{year:02}/'.format(day=11, month=1, year=2018))
# 11/01/2018

Di seguito, spiegheremo come specificare il formato usando una stringa di formato. Il codice di esempio usa il metodo str.format(), ma la stessa stringa di formato può essere usata con la funzione built-in format(). Nella funzione built-in format(), la stringa di specificazione del formato è specificata come secondo argomento.

Giustificato a sinistra, Giustificato al centro, Giustificato a destra

Puoi allineare di seguito left-justified, center-justified, right-justified, ecc. Specifica il numero totale di caratteri come numero.

  • <
  • ^
  • >
print('left  : {:<10}'.format(100))
print('center: {:^10}'.format(100))
print('right : {:>10}'.format(100))
# left  : 100       
# center:    100    
# right :        100

Potete anche specificare un carattere da riempire. Se omesso, come nell'esempio precedente, è uno spazio.

Si possono usare caratteri a doppio byte, purché si tratti di un singolo carattere.

print('left  : {:*<10}'.format(100))
print('center: {:a^10}'.format(100))
print('right : {:鬼>10}'.format(100))
# left  : 100*******
# center: aaa100aaaa
# right : 鬼鬼鬼鬼鬼鬼鬼100

La giustificazione a destra con > non tiene conto del segno (-,+). Se usi =, il segno è seguito dal carattere specificato. Se vuoi specificare +, scrivi + dopo =. I dettagli del trattamento dei segni sono descritti più avanti.

print('sign: {:0>10}'.format(-100))
print('sign: {:0=10}'.format(-100))
print('sign: {:0=+10}'.format(100))
# sign: 000000-100
# sign: -000000100
# sign: +000000100

<, ^ e > possono essere specificati per le stringhe, ma = risulterà in un errore ValueError. Se volete usare = per una stringa, dovete convertirla in un numero usando int().

# print('sign: {:0=10}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

print('sign: {:0=10}'.format(int('-100')))
# sign: -000000100

Lo stesso vale per i numeri in virgola mobile. Anche i punti decimali sono contati come un carattere.

print('left  : {:*<10}'.format(1.23))
print('center: {:a^10}'.format(1.23))
print('right : {:鬼>10}'.format(1.23))
# left  : 1.23******
# center: aaa1.23aaa
# right : 鬼鬼鬼鬼鬼鬼1.23

print('sign: {:0>10}'.format(-1.23))
print('sign: {:0=10}'.format(-1.23))
print('sign: {:0=+10}'.format(1.23))
# sign: 00000-1.23
# sign: -000001.23
# sign: +000001.23

Elenchi, tuple, ecc. causeranno un errore se specificati così come sono, e possono essere convertiti in stringhe usando str().

l = [0, 1]
print(type(l))
# <class 'list'>

# print('{:*^16}'.format(l))
# TypeError: unsupported format string passed to list.__format__

print(type(str(l)))
# <class 'str'>

print('{:*^16}'.format(str(l)))
# *****[0, 1]*****

Per left-justified, center-justified, e right-justified, ci sono anche metodi dedicati alle stringhe chiamati ljust(), center(), e rjust().

0 riempimento

Se volete regolare il numero di cifre riempiendo lo zero, impostate il carattere da riempire su 0 e correggetelo a destra.

Nel caso dello zero-filling, se il simbolo di allineamento è omesso, viene processato come se fosse specificato =.

print('zero padding: {:0=10}'.format(100))
print('zero padding: {:010}'.format(100))
# zero padding: 0000000100
# zero padding: 0000000100

print('zero padding: {:0=10}'.format(-100))
print('zero padding: {:010}'.format(-100))
# zero padding: -000000100
# zero padding: -000000100

=Se specificate una stringa come argomento, come descritto sopra, otterrete un errore. Facciamo attenzione.

# print('zero padding: {:010}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

Per il riempimento a zero, c'è anche un metodo di stringa dedicato chiamato zfill().

Segno (più o meno)

Per impostazione predefinita, solo i numeri negativi sono contrassegnati da un segno (meno-).

Quando si aggiunge + alla stringa di specificazione della formattazione, un segno (più +) viene visualizzato anche per i numeri positivi. Se viene aggiunto uno spazio, viene visualizzato uno spazio all'inizio del numero positivo, e il numero di cifre viene allineato al numero negativo.

print('sign: {}'.format(100))
print('sign: {}'.format(-100))
# sign: 100
# sign: -100

print('sign: {:+}'.format(100))
print('sign: {:+}'.format(-100))
# sign: +100
# sign: -100

print('sign: {: }'.format(100))
print('sign: {: }'.format(-100))
# sign:  100
# sign: -100

Fate attenzione quando riempite con caratteri arbitrari, come il riempimento con lo zero menzionato sopra. L'impostazione predefinita, senza + e senza spazi, riempie i numeri positivi con un carattere in più.

print('sign: {:06}'.format(100))
print('sign: {:06}'.format(-100))
# sign: 000100
# sign: -00100

print('sign: {:+06}'.format(100))
print('sign: {:+06}'.format(-100))
# sign: +00100
# sign: -00100

print('sign: {: 06}'.format(100))
print('sign: {: 06}'.format(-100))
# sign:  00100
# sign: -00100

Se viene usato un simbolo di allineamento, il simbolo di designazione del segno dovrebbe essere scritto dopo il simbolo di allineamento.

print('sign: {:_>6}'.format(100))
print('sign: {:_>6}'.format(-100))
# sign: ___100
# sign: __-100

print('sign: {:_>+6}'.format(100))
print('sign: {:_>+6}'.format(-100))
# sign: __+100
# sign: __-100

print('sign: {:_> 6}'.format(100))
print('sign: {:_> 6}'.format(-100))
# sign: __ 100
# sign: __-100

Separatore di cifre (virgola, trattino basso)

Aggiungere una virgola o un trattino basso _ come separatore ogni tre cifre. Questo rende i numeri grandi più facili da leggere. Notate che underscore_ è un'opzione aggiunta in Python 3.6, quindi non può essere usata nelle versioni precedenti.

print('{:,}'.format(100000000))
# 100,000,000

print('{:_}'.format(100000000))
# 100_000_000

Nel caso dei tipi float di numeri a virgola mobile, solo la parte intera è delimitata.

print('{:,}'.format(1234.56789))
# 1,234.56789

Numeri binari, ottali ed esadecimali

Converte i valori numerici in numeri binari, ottali ed esadecimali per l'output.

  • b: Binario
  • o: Octal
  • d: Decimale
  • x,X: Esadecimale (le lettere maiuscole sono maiuscole)
print('bin: {:b}'.format(255))
print('oct: {:o}'.format(255))
print('dec: {:d}'.format(255))
print('hex: {:x}'.format(255))
print('HEX: {:X}'.format(255))
# bin: 11111111
# oct: 377
# dec: 255
# hex: ff
# HEX: FF

Può anche essere combinato con 0-fill, ed è spesso usato per allineare le cifre nella notazione binaria ed esadecimale.

print('bin: {:08b}'.format(255))
print('oct: {:08o}'.format(255))
print('dec: {:08d}'.format(255))
print('hex: {:08x}'.format(255))
print('HEX: {:08X}'.format(255))
# bin: 11111111
# oct: 00000377
# dec: 00000255
# hex: 000000ff
# HEX: 000000FF

Si noti che il numero di caratteri di riempimento zero deve essere specificato tenendo conto del prefisso.

print('bin: {:#010b}'.format(255))
print('oct: {:#010o}'.format(255))
print('dec: {:#010d}'.format(255))
print('hex: {:#010x}'.format(255))
print('HEX: {:#010X}'.format(255))
# bin: 0b11111111
# oct: 0o00000377
# dec: 0000000255
# hex: 0x000000ff
# HEX: 0X000000FF

Per i numeri binari ed esadecimali, può essere inserito solo il separatore di cifre underscore _ (Python 3.6 o successivo). Viene usato il separatore a 4 cifre; il numero di caratteri a zero deve tenere conto anche del numero di underscore.

print('hex: {:08x}'.format(255))
print('hex: {:09_x}'.format(255))
print('hex: {:#011_x}'.format(255))
# hex: 000000ff
# hex: 0000_00ff
# hex: 0x0000_00ff

Solo il tipo intero int può convertire il formato in binario o esadecimale. Potete usare int() per convertirlo in un numero.

# print('hex: {:08x}'.format('255'))
# ValueError: Unknown format code 'X' for object of type 'str'

print('hex: {:08x}'.format(int('255')))
# hex: 000000ff

Specificare il numero di cifre dopo il punto decimale

Per specificare il numero di cifre dopo la virgola decimale, fate come segue: n è il numero di cifre. Il numero di cifre dopo la virgola diventa il numero di cifre specificato, indipendentemente dal numero di cifre nella parte intera.
.[n]f

print('{:.2f}'.format(123.456))
print('{:.5f}'.format(123.456))
print('{:.3f}'.format(0.0001234))
# 123.46
# 123.45600
# 0.000

Il lato sinistro della virgola decimale può essere specificato come giustificato a sinistra, giustificato al centro, giustificato a destra, o riempito di zero come descritto sopra. Se il numero di cifre del valore di destinazione è superiore al numero specificato, non viene fatto nulla. Se il numero di cifre del valore di destinazione è maggiore del numero di cifre specificato, non viene fatto nulla.

print('{:>12.5f}'.format(123.456))
print('{:012.5f}'.format(123.456))
print('{:06.5f}'.format(123.456))
#    123.45600
# 000123.45600
# 123.45600

Se si specifica un numero di cifre inferiore al numero originale di cifre dopo la virgola, il valore verrà arrotondato. Notate che questo non è un arrotondamento al numero intero più vicino, ma a un numero pari, per esempio 0,5 è arrotondato a 0.

print('{:.0f}'.format(0.4))
print('{:.0f}'.format(0.5))
print('{:.0f}'.format(0.6))
# 0
# 0
# 1

Se volete usare l'arrotondamento generale, potete usare il metodo quantize() della libreria standard decimal.

notazione esponenziale

Quando un numero float a virgola mobile viene convertito in una stringa str, sarà automaticamente scritto in notazione esponenziale a seconda del numero di cifre. Il tipo intero int non lo fa.

print('{}'.format(0.0001234))
print('{}'.format(0.00001234))
# 0.0001234
# 1.234e-05

print('{}'.format(1234000000000000.0))
print('{}'.format(12340000000000000.0))
print('{}'.format(12340000000000000000000000))
# 1234000000000000.0
# 1.234e+16
# 12340000000000000000000000

Se specificate e o E nella stringa di specificazione della formattazione, potete sempre convertire in notazione esponenziale. I caratteri usati nell'output saranno rispettivamente e ed E.

print('{:e}'.format(0.0001234))
print('{:E}'.format(0.0001234))
# 1.234000e-04
# 1.234000E-04

È anche possibile specificare il numero di cifre dopo il punto decimale. La parte intera sarà sempre una cifra e il punto decimale sarà il numero di cifre specificato.

print('{:.5e}'.format(0.0001234))
print('{:.2E}'.format(0.0001234))
# 1.23400e-04
# 1.23E-04

print('{:.5e}'.format(987.65))
print('{:.2E}'.format(987.65))
# 9.87650e+02
# 9.88E+02

Notate che se specificate left-justified, center-justified, right-justified, o zero-filled, e-, E+, ecc. saranno anche contati come cifre (caratteri).

print('{:>12.5e}'.format(987.65))
print('{:012.2E}'.format(987.65))
#  9.87650e+02
# 00009.88E+02

Cifre significative (numero di cifre significative)

Potete specificare il numero complessivo di cifre facendo come segue A seconda del risultato, la notazione esponenziale sarà usata automaticamente. Notate che gli zeri di coda dopo la virgola decimale saranno omessi.
.[n]g

print('{:.2g}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.3g}'.format(0.0001234))
# 1.2e+02
# 123
# 123.456
# 0.000123

Se omettete g, l'output non sarà un intero. g è lo stesso nella maggior parte dei casi, ma solo nei casi in cui l'output è un intero.

print('{:.2}'.format(123.456))
print('{:.3}'.format(123.456))
print('{:.8}'.format(123.456))
print('{:.3}'.format(0.0001234))
# 1.2e+02
# 1.23e+02
# 123.456
# 0.000123

Se elaboriamo lo stesso valore, otteniamo rispettivamente i seguenti.

print('{:.3f}'.format(123.456))
print('{:.3e}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.3}'.format(123.456))
# 123.456
# 1.235e+02
# 123
# 1.23e+02

print('{:.8f}'.format(123.456))
print('{:.8e}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.8}'.format(123.456))
# 123.45600000
# 1.23456000e+02
# 123.456
# 123.456

Nel caso di g o se viene omesso, gli zeri finali dopo il punto decimale sono omessi, quindi se volete emettere lo stesso numero di cifre significative (numero di cifre significative), usate la notazione esponenziale di e o E. La parte intera è sempre una cifra e il punto decimale è il numero di cifre specificato, quindi se volete emettere n cifre significative, basta specificare n-1.

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

Visualizzazione della percentuale

Se % è specificato nella stringa di specificazione della formattazione, il valore del float numerico o dell'int è moltiplicato per 100 e convertito in una stringa con %.

È anche possibile specificare il numero di cifre dopo la virgola decimale. L'impostazione predefinita è di sei cifre dopo la virgola. Sono disponibili anche la rettifica a sinistra, la rettifica al centro, la rettifica a destra e lo zero-fill. Anche il % viene contato come un carattere.

print('{:%}'.format(0.12345))
print('{:.2%}'.format(0.12345))
# 12.345000%
# 12.35%

print('{:%}'.format(10))
print('{:.2%}'.format(10))
# 1000.000000%
# 1000.00%

print('{:>7.2%}'.format(0.12345))
print('{:07.2%}'.format(0.12345))
#  12.35%
# 012.35%
Copied title and URL