¿Cómo puedo mostrar esto?

¿Decimal ('40800000000.00000000000000') como '4.08E + 10'?

He intentado esto:

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

Pero tiene esos 0 extra.

from decimal import Decimal

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

# returns '4.08E+10'

En su '40800000000.00000000000000' hay muchos ceros más significativos que tienen el mismo significado que cualquier otro dígito. Es por eso que tienes que decir explícitamente dónde quieres parar.

Si desea eliminar todos los ceros finales automáticamente, puede intentar:

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'

Aquí hay un ejemplo usando la format()función:

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

En lugar de formato, también puede usar cadenas f :

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

• documentación oficial

• propuesta de formato original ()

Dado su número

x = Decimal('40800000000.00000000000000')

A partir de Python 3,

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

es la forma recomendada de hacerlo

esignifica que desea notación científica y .2quiere decir 2 dígitos después del punto. Entonces obtendrásx.xxE±n

Nadie mencionó la forma abreviada del .formatmétodo:

Necesita al menos Python 3.6

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

(Creo que es lo mismo que Cees Timmerman, solo un poco más corto)

Consulte las tablas del formato de cadena Python para seleccionar el diseño de formato adecuado. En tu caso lo es %.2E.

Mis decimales son demasiado grandes, %Easí que tuve que improvisar:

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)

Aquí hay un ejemplo de uso:

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

Esto funcionó mejor para mí:

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

Esta es una lista consolidada de las respuestas y comentarios "simples" .

PITÓN 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
# =====================================

O sin 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
# =====================================

Comparando

# =====================================
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

Entonces, para Python 3, puedes cambiar entre cualquiera de los tres por ahora.

Mi favorito:

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

Prefiero Python 3.x forma.

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

4 indica cuántos dígitos se muestran en la parte flotante.

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

Para convertir un decimal a notación científica sin necesidad de especificar la precisión en la cadena de formato, y sin incluir ceros finales, actualmente estoy usando

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

Para mantener los ceros a la izquierda, simplemente elimine el normalize().

Aquí está el más simple que pude encontrar.

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

('E' no distingue entre mayúsculas y minúsculas. También puede usar '.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