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

Greg a intrebat.

Cum pot afișa acest lucru:

Decimal(‘40800000000.000000000000000000’) ca ‘4.08E+10’?

Am încercat acest lucru:

>>> '%E' % Decimal('40800000000.00000000000000')
'4.080000E+10'

Dar are acei 0 în plus.

Comentarii

  • kinda doubleposting, ai fi putut folosi acest topic pe care tocmai l-ai deschis: stackoverflow.com/questions/6913166/… -…  > Por Samuele Mattiuzzo.
  • 17

  • nah, deloc. Am vrut să separ asta în întrebarea ușoară (cum să o faci în Python) și întrebarea dificilă, obscură, la care mă îndoiesc că va răspunde cineva (cum să o faci în Django). Observați că aceasta are deja un răspuns. Acum sunt la jumătatea drumului spre răspunsul final, în loc de 0% dacă le-aș fi postat împreună. În afară de asta, separarea întrebărilor facilitează căutarea răspunsurilor de către oameni. De exemplu, dacă Bob caută o întrebare despre formatarea zecimală, ar putea sări peste o întrebare SO cu Django în titlu. –  > Por Greg.
12 răspunsuri
eumiro
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'

Comentarii

    23

  • Ca o paranteză, în ciuda faptului că format % values sintaxa este încă folosită chiar și în cadrul bibliotecii standard Python 3, cred că din punct de vedere tehnic este depreciată în Python 3, sau cel puțin nu este metoda de formatare recomandată, iar sintaxa recomandată în prezent, începând cu Python 2.6, ar fi '{0:.2E}'.format(Decimal('40800000000.00000000000000')) (sau '{:.2E}' în Python 2.7+). Deși nu este strict utilă pentru această situație, din cauza caracterelor suplimentare pentru nicio funcționalitate adăugată, str.format permite o amestecare/rearanjare/reutilizare mai complexă a argumentelor de format. –  > Por JAB.
  • @CharlieParker Utilizare format. Este mai mult jazzy. –  > Por Mateen Ulhaq.
Cees Timmerman

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'

Comentarii

  • Această sintaxă se aplică, de asemenea, la f-strings în 3.6+. f"{Decimal('40800000000.00000000000000'):.2E}" –  > Por Tritium21.
patapouf_ai

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

Comentarii

  • Ideea de a folosi Decimal este de a obține aritmetică zecimală cu precizie exactă și arbitrară. Nu este echivalent cu utilizarea unui float. –  > Por asmeurer.
  • @asmeurer Mulțumesc pentru clarificare. Mi-am schimbat răspunsul. –  > Por patapouf_ai.
  • Există o modalitate de a reveni de aici la float? –  > Por olenscki.
  • @olenscki doar făcând float(x) va converti x în float. –  > Por patapouf_ai.
Eulenfuchswiesel

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ă)

Comentarii

  • Ar trebui să fie un răspuns acceptat. f-strings este viitorul formatării șirurilor de caractere python 🙂 –  > Por Gandalf Saxe.
  • Ca o informație pentru viitorii cititori ca mine: dacă nu vă interesează să controlați numărul de cifre și nu vă deranjează erorile de virgulă mobilă, puteți folosi pur și simplu {num:E}, , unde, de exemplu, num = 40800000000.0000000000000000000000 –  > Por shayaan.
  • Pentru informații despre formatare stackoverflow.com/questions/45310254/… –  > Por Eulenfuchswiesel.
JayRizzo

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))

Comentarii

Mihai Maruseac

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

ubershmekel

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

Comentarii

  • Doar "{:.2e}".format(n) returnează '3.39e+7800' în Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:06:53) [MSC v.1600 64 bit (AMD64)] pe win32. –  > Por Cees Timmerman.
Matthew Fitch

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

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

snr

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} ")

MikeM

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().

Rahat Ibrahim

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”)

Andrej
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