Μετατροπή μορφής στην Python, μορφή (μηδενική συμπλήρωση, εκθετικός συμβολισμός, δεκαεξαδικό σύστημα κ.λπ.)

Επιχείρηση

Για να μετατρέψετε (μορφοποιήσετε) έναν αριθμό ή μια συμβολοσειρά σε διάφορες μορφές στην Python, χρησιμοποιήστε την ενσωματωμένη συνάρτηση format() ή τη μέθοδο συμβολοσειρών str.format().

Σε αυτή την ενότητα, θα εξηγήσουμε πώς να χρησιμοποιείτε τις ακόλουθες λειτουργίες.

  • ενσωματωμένη συνάρτηση (π.χ. σε γλώσσα προγραμματισμού)format()
  • μέθοδος stringstr.format()

Επιπλέον, η συμβολοσειρά προδιαγραφών μορφής για τη μετατροπή στην ακόλουθη μορφή εξηγείται με δείγμα κώδικα.

  • Αριστερά προσαρμοσμένο, Κέντρο προσαρμοσμένο, Δεξιά προσαρμοσμένο
  • μηδενική πλήρωση
  • Πρόσημο (συν ή μείον)
  • Διαχωριστικό ψηφίων (κόμμα, υπογράμμιση)
  • Δυαδικοί, οκταδικοί και δεκαεξαδικοί αριθμοί
  • Καθορίστε τον αριθμό των ψηφίων μετά το δεκαδικό σημείο
  • Σημαντικά ψηφία (αριθμός σημαντικών ψηφίων)
  • εκθετικός συμβολισμός
  • Ένδειξη ποσοστού

Σημειώστε ότι από την Python 3.6, οι συμβολοσειρές f (f-strings) έχουν προστεθεί στη μέθοδο συμβολοσειρών str.format() για να την κάνουν πιο συνοπτική.

Ενσωματωμένη συνάρτηση: format()

Η format() παρέχεται ως μια τυπική ενσωματωμένη συνάρτηση της Python.

Το περίγραμμα έχει ως εξής.

  • format(value, format_spec)
    • Το πρώτο επιχείρημα: τοvalue
      Η αρχική τιμή. Συμβολοσειρά str, αριθμός int, float, κ.λπ.
    • Το δεύτερο επιχείρημαformat_spec
      Συμβολοσειρά προδιαγραφών μορφοποίησης. Συμβολοσειρά str
    • Τιμή επιστροφής: μια μορφοποιημένη συμβολοσειρά str

Παραδείγματα παρουσιάζονται παρακάτω. Οι τύποι των συμβολοσειρών μορφοποίησης και ο τρόπος γραφής τους περιγράφονται στη συνέχεια.

Σε αυτό το παράδειγμα, χρησιμοποιήσαμε αριθμητικά γράμματα και γράμματα συμβολοσειράς ως πρώτο όρισμα, αλλά φυσικά μπορείτε να χρησιμοποιήσετε μεταβλητές που περιέχουν αυτές τις τιμές.

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

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

Μέθοδος String str.format()

Υπάρχει επίσης μια μέθοδος format() για τον τύπο string str.

Το {} στη συμβολοσειρά str που καλεί τη μέθοδο format() ονομάζεται πεδίο αντικατάστασης και αντικαθίσταται από το όρισμα της μεθόδου format().

Η συμβολοσειρά προδιαγραφών μορφής πρέπει να γράφεται στο πεδίο αντικατάστασης {} ακολουθούμενο από «:».

Η τιμή επιστροφής είναι μια μορφοποιημένη συμβολοσειρά str.

Η ισοδύναμη διαδικασία με την ενσωματωμένη συνάρτηση format() που περιγράφεται παραπάνω έχει ως εξής.

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

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

Και πάλι, χρησιμοποιούμε αριθμητικά γραμματικά και αλφαριθμητικά ως ορίσματα, αλλά φυσικά οι μεταβλητές είναι επίσης αποδεκτές.

Καθορισμός ορίων για πεδία αντικατάστασης

Καθορίστε τα ορίσματα με τη σειρά (προεπιλογή)

Μπορούν να υπάρχουν πολλαπλά πεδία αντικατάστασης {}, και από προεπιλογή, τα ορίσματα της μεθόδου επεξεργάζονται με τη σειρά. Εάν η συμβολοσειρά προδιαγραφής μορφής στο {} παραλειφθεί, θα μετατραπεί απλώς σε συμβολοσειρά από την str().

Χρήσιμο για την εισαγωγή μεταβλητών τιμών σε μια συμβολοσειρά και την εκτύπωσή τους.

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

Καθορίστε ένα όρισμα θέσης για ακέραιες τιμές

Εάν μια ακέραια τιμή καθορίζεται στο {}, όπως {0} ή {1}, η έξοδος θα εξαρτάται από τη σειρά των ορίων. Ο ίδιος αριθμός μπορεί να χρησιμοποιηθεί επανειλημμένα. Αυτό είναι χρήσιμο όταν θέλετε να εισάγετε την ίδια τιμή σε μια συμβολοσειρά.

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

Καθορισμός ορίσματος λέξης-κλειδί για αυθαίρετα ονόματα (συμβολοσειρές)

Μπορείτε επίσης να καθορίσετε οποιοδήποτε όνομα σε {} και να το εισαγάγετε ως όρισμα λέξης-κλειδί.

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

Καθορίστε μια λίστα ή ένα λεξικό ως όρισμα

Οι λίστες και τα λεξικά μπορούν να καθοριστούν ως ορίσματα.

Χρησιμοποιήστε [] για να καθορίσετε το δείκτη μιας λίστας ή το κλειδί ενός λεξικού σε ένα πεδίο αντικατάστασης. Σημειώστε ότι τα εισαγωγικά «'» και «» δεν χρησιμοποιούνται για τον προσδιορισμό κλειδιών λεξικού.

Αν θέλετε να χρησιμοποιήσετε το ίδιο όρισμα επανειλημμένα, πρέπει να καθορίσετε μια ακέραια τιμή ή μια συμβολοσειρά (όνομα), όπως περιγράφεται παραπάνω.

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.

Μπορεί να επεκταθεί ως όρισμα θέσης με την προσθήκη * στη λίστα και τον προσδιορισμό της ως όρισμα, ή ως όρισμα λέξης-κλειδί με την προσθήκη ** στο λεξικό και τον προσδιορισμό της ως όρισμα.

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.

Περιγραφή των καμπύλων αγκυλών {}

Αν θέλετε να γράψετε τις καμπύλες αγκύλες {,} στη μέθοδο format(), επαναλάβετε το δύο φορές όπως {{,}}. Σημειώστε ότι οι backslashes δεν μπορούν να διαφύγουν.

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

μορφοποιημένη συμβολοσειρά

Και στις δύο περιπτώσεις, για να καθορίσετε τη μορφή, γράψτε «:format string» μετά την ακέραια τιμή ή τη συμβολοσειρά ονόματος σε {}.

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

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

Στη συνέχεια, θα εξηγήσουμε πώς να καθορίσετε τη μορφή χρησιμοποιώντας μια συμβολοσειρά μορφής. Ο κώδικας του δείγματος χρησιμοποιεί τη μέθοδο str.format(), αλλά η ίδια συμβολοσειρά μορφοποίησης μπορεί να χρησιμοποιηθεί με την ενσωματωμένη συνάρτηση format(). Στην ενσωματωμένη συνάρτηση format(), η συμβολοσειρά προδιαγραφής μορφής καθορίζεται ως δεύτερο όρισμα.

Αριστερά προσαρμοσμένο, Κέντρο προσαρμοσμένο, Δεξιά προσαρμοσμένο

Μπορείτε να ευθυγραμμίσετε με αριστερή στοίχιση, κεντρική στοίχιση, δεξιά στοίχιση κ.λπ. παρακάτω. Καθορίστε το συνολικό αριθμό χαρακτήρων ως αριθμό.

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

Μπορείτε επίσης να καθορίσετε έναν χαρακτήρα που θα συμπληρωθεί. Αν παραλειφθεί, όπως στο παραπάνω παράδειγμα, είναι ένα κενό.

Μπορείτε να χρησιμοποιήσετε χαρακτήρες διπλού byte αρκεί να είναι ένας μόνο χαρακτήρας.

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

Η δεξιόστροφη διόρθωση με > δεν λαμβάνει υπόψη το πρόσημο (-,+). Εάν χρησιμοποιήσετε το =, το σύμβολο ακολουθείται από τον καθορισμένο χαρακτήρα. Αν θέλετε να καθορίσετε το +, γράψτε + μετά το =. Οι λεπτομέρειες της επεξεργασίας των σημείων περιγράφονται στη συνέχεια.

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

Τα <, ^ και > μπορούν να καθοριστούν για συμβολοσειρές, αλλά το = θα οδηγήσει σε σφάλμα ValueError. Αν θέλετε να χρησιμοποιήσετε το = για μια συμβολοσειρά, πρέπει να τη μετατρέψετε σε αριθμό χρησιμοποιώντας την int().

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

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

Το ίδιο ισχύει και για τους αριθμούς κινητής υποδιαστολής. Τα δεκαδικά σημεία υπολογίζονται επίσης ως χαρακτήρας.

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

Οι λίστες, οι πλειάδες κ.λπ. θα προκαλέσουν σφάλμα αν καθοριστούν ως έχουν και μπορούν να μετατραπούν σε συμβολοσειρές με τη χρήση της 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]*****

Για την αριστερή στοίχιση, την κεντρική στοίχιση και τη δεξιά στοίχιση, υπάρχουν επίσης ειδικές μέθοδοι συμβολοσειρών που ονομάζονται ljust(), center() και rjust().

0 γέμισμα

Εάν θέλετε να προσαρμόσετε τον αριθμό των ψηφίων με συμπλήρωση του μηδενός, ορίστε τον χαρακτήρα που πρόκειται να συμπληρωθεί σε 0 και στρέψτε τον προς τα δεξιά.

Στην περίπτωση μηδενικής συμπλήρωσης, εάν το σύμβολο ευθυγράμμισης παραλείπεται, η επεξεργασία γίνεται σαν να είχε καθοριστεί =.

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

=Αν καθορίσετε μια συμβολοσειρά ως όρισμα, όπως περιγράφεται παραπάνω, θα λάβετε ένα σφάλμα. Ας είμαστε προσεκτικοί.

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

Για τη συμπλήρωση του μηδενός, υπάρχει επίσης μια ειδική μέθοδος συμβολοσειράς που ονομάζεται zfill().

Πρόσημο (συν ή μείον)

Από προεπιλογή, μόνο οι αρνητικοί αριθμοί επισημαίνονται με ένα σύμβολο (μείον-).

Όταν προστίθεται το + στη συμβολοσειρά προδιαγραφών μορφοποίησης, εμφανίζεται επίσης ένα σύμβολο (συν +) για θετικούς αριθμούς. Εάν προστεθεί κενό, εμφανίζεται ένα κενό στην αρχή του θετικού αριθμού και ο αριθμός των ψηφίων ευθυγραμμίζεται με τον αρνητικό αριθμό.

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

Να είστε προσεκτικοί όταν συμπληρώνετε με αυθαίρετους χαρακτήρες, όπως η συμπλήρωση με μηδέν που αναφέρθηκε παραπάνω. Η προεπιλογή, χωρίς + και χωρίς κενά, γεμίζει τους θετικούς αριθμούς με έναν ακόμη χαρακτήρα.

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

Εάν χρησιμοποιείται σύμβολο ευθυγράμμισης, το σύμβολο προσδιορισμού σημείου πρέπει να γράφεται μετά το σύμβολο ευθυγράμμισης.

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

Διαχωριστικό ψηφίων (κόμμα, υπογράμμιση)

Προσθέστε ένα κόμμα ή μια υπογράμμιση _ ως διαχωριστικό κάθε τρία ψηφία. Αυτό διευκολύνει την ανάγνωση των μεγάλων αριθμών. Σημειώστε ότι το underscore_ είναι μια επιλογή που προστέθηκε στην Python 3.6, οπότε δεν μπορεί να χρησιμοποιηθεί σε προηγούμενες εκδόσεις.

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

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

Στην περίπτωση των τύπων αριθμών κινητής υποδιαστολής float, οριοθετείται μόνο το ακέραιο μέρος.

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

Δυαδικοί, οκταδικοί και δεκαεξαδικοί αριθμοί

Μετατρέπει αριθμητικές τιμές σε δυαδικούς, οκταδικούς και δεκαεξαδικούς αριθμούς για έξοδο.

  • b: Δυαδικό
  • o: Octal
  • d: Δεκαδικό
  • x,X: Hexadecimal (τα κεφαλαία γράμματα είναι κεφαλαία)
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

Μπορεί επίσης να συνδυαστεί με τη συμπλήρωση 0 και χρησιμοποιείται συχνά για την ευθυγράμμιση των ψηφίων στη δυαδική και δεκαεξαδική σημειογραφία.

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

Σημειώστε ότι ο αριθμός των χαρακτήρων μηδενικής συμπλήρωσης πρέπει να καθορίζεται λαμβάνοντας υπόψη το πρόθεμα.

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

Για δυαδικούς και δεκαεξαδικούς αριθμούς, μπορεί να εισαχθεί μόνο η υπογράμμιση _ (Python 3.6 ή νεότερη έκδοση). Χρησιμοποιείται 4ψήφιος διαχωριστής- ο αριθμός των χαρακτήρων με μηδενική πλήρωση πρέπει επίσης να λαμβάνει υπόψη τον αριθμό των υπογραμμίσεων.

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

Μόνο ο ακέραιος τύπος int μπορεί να μετατρέψει τη μορφή σε δυαδική ή δεκαεξαδική. Μπορείτε να χρησιμοποιήσετε την int() για να το μετατρέψετε σε αριθμό.

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

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

Καθορίστε τον αριθμό των ψηφίων μετά το δεκαδικό σημείο

Για να καθορίσετε τον αριθμό των ψηφίων μετά το δεκαδικό σημείο, κάντε τα εξής: n είναι ο αριθμός των ψηφίων. Ο αριθμός των ψηφίων μετά το δεκαδικό σημείο γίνεται ο καθορισμένος αριθμός ψηφίων ανεξάρτητα από τον αριθμό των ψηφίων στο ακέραιο μέρος.
.[n]f

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

Η αριστερή πλευρά του δεκαδικού σημείου μπορεί να καθοριστεί ως αριστεροστολισμένη, κεντροστολισμένη, δεξιοστολισμένη ή μηδενική, όπως περιγράφεται παραπάνω. Εάν ο αριθμός των ψηφίων της τιμής-στόχου είναι μεγαλύτερος από τον καθορισμένο αριθμό, δεν γίνεται τίποτα. Εάν ο αριθμός των ψηφίων της τιμής-στόχου είναι μεγαλύτερος από τον καθορισμένο αριθμό ψηφίων, δεν γίνεται τίποτα.

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

Εάν καθορίσετε αριθμό ψηφίων μικρότερο από τον αρχικό αριθμό ψηφίων μετά το δεκαδικό σημείο, η τιμή θα στρογγυλοποιηθεί. Σημειώστε ότι δεν πρόκειται για στρογγυλοποίηση στον πλησιέστερο ακέραιο αριθμό, αλλά σε ζυγό αριθμό, π.χ. το 0,5 στρογγυλοποιείται στο 0.

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

Αν θέλετε να χρησιμοποιήσετε γενική στρογγυλοποίηση, μπορείτε να χρησιμοποιήσετε τη μέθοδο quantize() της τυπικής βιβλιοθήκης decimal.

εκθετικός συμβολισμός

Όταν ένας αριθμός κινητής υποδιαστολής μετατρέπεται σε συμβολοσειρά str, θα γράφεται αυτόματα σε εκθετικό συμβολισμό ανάλογα με τον αριθμό των ψηφίων. Ο ακέραιος τύπος int δεν το κάνει.

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

Εάν καθορίσετε e ή E στη συμβολοσειρά προδιαγραφών μορφοποίησης, μπορείτε πάντα να μετατρέψετε σε εκθετική γραφή. Οι χαρακτήρες που χρησιμοποιούνται στην έξοδο θα είναι e και E, αντίστοιχα.

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

Μπορείτε επίσης να καθορίσετε τον αριθμό των ψηφίων μετά το δεκαδικό σημείο. Το ακέραιο μέρος θα είναι πάντα ένα ψηφίο και το δεκαδικό σημείο θα είναι ο καθορισμένος αριθμός ψηφίων.

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

Σημειώστε ότι αν καθορίσετε αριστεροστοί, κεντροστοί, δεξιοστοί ή μηδενικοί, τα e-, E+ κ.λπ. θα υπολογίζονται επίσης ως ψηφία (χαρακτήρες).

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

Σημαντικά ψηφία (αριθμός σημαντικών ψηφίων)

Μπορείτε να καθορίσετε τον συνολικό αριθμό των ψηφίων κάνοντας τα εξής Ανάλογα με το αποτέλεσμα, θα χρησιμοποιηθεί αυτόματα η εκθετική σημειογραφία. Σημειώστε ότι τα μηδενικά μετά το δεκαδικό σημείο θα παραλειφθούν.
.[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

Αν παραλείψετε το g, η έξοδος δεν θα είναι ακέραιος. Το g είναι το ίδιο στις περισσότερες περιπτώσεις, αλλά μόνο στις περιπτώσεις όπου η έξοδος είναι ακέραιος.

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

Αν επεξεργαστούμε την ίδια τιμή, θα έχουμε τα ακόλουθα αντίστοιχα.

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

Στην περίπτωση του g ή αν παραλειφθεί, τα μηδενικά που ακολουθούν μετά το δεκαδικό σημείο παραλείπονται, οπότε αν θέλετε να εξάγετε τον ίδιο αριθμό σημαντικών ψηφίων (αριθμός σημαντικών ψηφίων), χρησιμοποιήστε τον εκθετικό συμβολισμό του e ή E. Το ακέραιο μέρος είναι πάντα ένα ψηφίο και το δεκαδικό σημείο είναι ο καθορισμένος αριθμός ψηφίων, οπότε αν θέλετε να εξάγετε n σημαντικά ψηφία, απλώς καθορίστε 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

Ένδειξη ποσοστού

Εάν το % καθορίζεται στη συμβολοσειρά προδιαγραφών μορφοποίησης, η τιμή του αριθμητικού float ή int πολλαπλασιάζεται με το 100 και μετατρέπεται σε συμβολοσειρά με %.

Μπορείτε επίσης να καθορίσετε τον αριθμό των ψηφίων μετά το δεκαδικό σημείο. Η προεπιλογή είναι έξι ψηφία μετά το δεκαδικό σημείο. Διατίθενται επίσης η αριστερή ευθυγράμμιση, η κεντρική ευθυγράμμιση, η δεξιά ευθυγράμμιση και η συμπλήρωση του μηδενός. Το % υπολογίζεται επίσης ως χαρακτήρας.

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