Afișarea unei zecimale în notație științifică (Programare, Python, Formatarea Șirurilor De Caractere, Formatarea Numerelor, Notație Științifică)

from decimal import Decimal

'%.2E' % Decimal('40800000000.00000000000000')

# returns '4.08E+10'

În „40800000000.0000000000000000000000” al tău există mai multe zerouri semnificative care au aceeași semnificație ca orice altă cifră. De aceea trebuie să spui explicit unde vrei să te oprești.

Dacă doriți să eliminați automat toate zerourile rămase, puteți încerca:

def format_e(n):
    a = '%E' % n
    return a.split('E')[0].rstrip('0').rstrip('.') + 'E' + a.split('E')[1]

format_e(Decimal('40800000000.00000000000000'))
# '4.08E+10'

format_e(Decimal('40000000000.00000000000000'))
# '4E+10'

format_e(Decimal('40812300000.00000000000000'))
# '4.08123E+10'

Iată un exemplu care folosește format() funcție:

>>> "{:.2E}".format(Decimal('40800000000.00000000000000'))
'4.08E+10'

În loc de format, puteți utiliza și f-strings:

>>> f"{Decimal('40800000000.00000000000000'):.2E}"
'4.08E+10'

• documentația oficială

• propunerea originală format()

Având în vedere numărul dvs.

x = Decimal('40800000000.00000000000000')

Începând cu Python 3,

'{:.2e}'.format(x)

este modalitatea recomandată de a face acest lucru.

e înseamnă că doriți notația științifică, iar .2 înseamnă că doriți 2 cifre după punct. Astfel, veți obține x.xxE±n

Nimeni nu a menționat forma scurtă a .format metoda:

Necesită cel puțin Python 3.6

f"{Decimal('40800000000.00000000000000'):.2E}"

(cred că este aceeași cu cea a lui Cees Timmerman, doar că este un pic mai scurtă)

Aceasta este o listă consolidată a „simplă” Răspunsuri & Comentarii.

PYTHON 3

from decimal import Decimal

x = '40800000000.00000000000000'
# Converted to Float
x = Decimal(x)

# ===================================== # `Dot Format`
print("{0:.2E}".format(x))
# ===================================== # `%` Format
print("%.2E" % x)
# ===================================== # `f` Format
print(f"{x:.2E}")
# =====================================
# ALL Return: 4.08E+10
print((f"{x:.2E}") == ("%.2E" % x) == ("{0:.2E}".format(x)))
# True
print(type(f"{x:.2E}") == type("%.2E" % x) == type("{0:.2E}".format(x)))
# True
# =====================================

Sau fără IMPORT‘s

# NO IMPORT NEEDED FOR BASIC FLOATS
y = '40800000000.00000000000000'
y = float(y)

# ===================================== # `Dot Format`
print("{0:.2E}".format(y))
# ===================================== # `%` Format
print("%.2E" % y)
# ===================================== # `f` Format
print(f"{y:.2E}")
# =====================================
# ALL Return: 4.08E+10
print((f"{y:.2E}") == ("%.2E" % y) == ("{0:.2E}".format(y)))
# True
print(type(f"{y:.2E}") == type("%.2E" % y) == type("{0:.2E}".format(y)))
# True
# =====================================

Compararea

# =====================================
x
# Decimal('40800000000.00000000000000')
y
# 40800000000.0

type(x)
# <class 'decimal.Decimal'>
type(y)
# <class 'float'>

x == y
# True
type(x) == type(y)
# False

x
# Decimal('40800000000.00000000000000')
y
# 40800000000.0

Deci, pentru Python 3, puteți comuta între oricare dintre cele trei pentru moment.

Preferatul meu:

print("{0:.2E}".format(y))

Vezi tabelele din Formatarea șirurilor de caractere în Python pentru a selecta aspectul de format adecvat. În cazul dvs. %.2E.

Zecimalele mele sunt prea mari pentru %E așa că a trebuit să improvizez:

def format_decimal(x, prec=2):
    tup = x.as_tuple()
    digits = list(tup.digits[:prec + 1])
    sign = '-' if tup.sign else ''
    dec = ''.join(str(i) for i in digits[1:])
    exp = x.adjusted()
    return '{sign}{int}.{dec}e{exp}'.format(sign=sign, int=digits[0], dec=dec, exp=exp)

Iată un exemplu de utilizare:

>>> n = decimal.Decimal(4.3) ** 12314
>>> print format_decimal(n)
3.39e7800
>>> print '%e' % n
inf

Acest lucru a funcționat cel mai bine pentru mine:

import decimal
'%.2E' % decimal.Decimal('40800000000.00000000000000')
# 4.08E+10

Prefer modul Python 3.x.

cal = 123.4567
print(f"result {cal:.4E}")

4 indică câte cifre sunt afișate afișate în partea flotantă.

cal = 123.4567
totalDigitInFloatingPArt = 4
print(f"result {cal:.{totalDigitInFloatingPArt}E} ")

Pentru a converti o zecimală în notație științifică fără a fi nevoie să specificați precizia în șirul de format și fără a include zerouri de urmărire, folosesc în prezent

def sci_str(dec):
    return ('{:.' + str(len(dec.normalize().as_tuple().digits) - 1) + 'E}').format(dec)

print( sci_str( Decimal('123.456000') ) )    # 1.23456E+2

Pentru a păstra orice zerouri de urmărire, trebuie doar să eliminați normalize().

Iată cel mai simplu pe care l-am găsit.

format(40800000000.00000000000000, '.2E')
#'4.08E+10'

(„E” nu face distincție între majuscule și minuscule. Puteți folosi și „.2e”)

def formatE_decimal(x, prec=2):
    """ Examples:
    >>> formatE_decimal('0.1613965',10)
    '1.6139650000E-01'
    >>> formatE_decimal('0.1613965',5)
    '1.61397E-01'
    >>> formatE_decimal('0.9995',2)
    '1.00E+00'
    """
    xx=decimal.Decimal(x) if type(x)==type("") else x 
    tup = xx.as_tuple()
    xx=xx.quantize( decimal.Decimal("1E{0}".format(len(tup[1])+tup[2]-prec-1)), decimal.ROUND_HALF_UP )
    tup = xx.as_tuple()
    exp = xx.adjusted()
    sign = '-' if tup.sign else ''
    dec = ''.join(str(i) for i in tup[1][1:prec+1])   
    if prec>0:
        return '{sign}{int}.{dec}E{exp:+03d}'.format(sign=sign, int=tup[1][0], dec=dec, exp=exp)
    elif prec==0:
        return '{sign}{int}E{exp:+03d}'.format(sign=sign, int=tup[1][0], exp=exp)
    else:
        return None