Wie kann ich das anzeigen:

Dezimal ('40800000000.00000000000000') als '4.08E + 10'?

Ich habe das versucht:

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

Aber es hat diese zusätzlichen Nullen.

from decimal import Decimal

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

# returns '4.08E+10'

In Ihrem '40800000000.00000000000000' gibt es viel mehr signifikante Nullen, die dieselbe Bedeutung wie jede andere Ziffer haben. Deshalb müssen Sie explizit angeben, wo Sie aufhören möchten.

Wenn Sie alle nachgestellten Nullen automatisch entfernen möchten, können Sie Folgendes versuchen:

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'

Hier ist ein Beispiel mit der format()Funktion:

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

Anstelle des Formats können Sie auch F-Strings verwenden :

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

• offizielle Dokumentation

• Vorschlag für das Originalformat ()

Geben Sie Ihre Nummer an

x = Decimal('40800000000.00000000000000')

Ab Python 3,

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

ist der empfohlene Weg, dies zu tun.

ebedeutet, dass Sie eine wissenschaftliche Notation wünschen und .2dass Sie 2 Ziffern nach dem Punkt möchten. So wirst du bekommenx.xxE±n

Niemand erwähnte die Kurzform der .formatMethode:

Benötigt mindestens Python 3.6

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

(Ich glaube, es ist das gleiche wie Cees Timmerman, nur ein bisschen kürzer)

Informationen zur Auswahl des richtigen Formatlayouts finden Sie in den Tabellen aus der Python-Zeichenfolgenformatierung . In deinem Fall ist es %.2E.

Meine Dezimalstellen sind zu groß, %Edeshalb musste ich improvisieren:

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)

Hier ist ein Beispiel für die Verwendung:

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

Das hat bei mir am besten funktioniert:

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

Dies ist eine konsolidierte Liste der "einfachen" Antworten und Kommentare.

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

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

Vergleichen

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

Für Python 3 können Sie also vorerst zwischen den drei wechseln.

Mein Favorit:

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

Ich bevorzuge Python 3.x Weg.

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

4 Gibt an, wie viele Ziffern im schwebenden Teil angezeigt werden.

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

Um eine Dezimalzahl in eine wissenschaftliche Notation umzuwandeln, ohne die Genauigkeit in der Formatzeichenfolge angeben zu müssen und ohne nachgestellte Nullen einzuschließen, verwende ich derzeit

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

Um nachgestellte Nullen beizubehalten, entfernen Sie einfach die normalize().

Hier ist die einfachste, die ich finden konnte.

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

('E' unterscheidet nicht zwischen Groß- und Kleinschreibung. Sie können auch '.2e' verwenden.)

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