Zeigen Sie eine Dezimalstelle in wissenschaftlicher Notation an

158

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.

Greg
quelle
3
Ein bisschen Doubleposting, du hättest dieses Thema verwenden können, das du gerade begonnen hast: stackoverflow.com/questions/6913166/…
Samuele Mattiuzzo
12
nein, überhaupt nicht. Ich wollte dies in die einfache Frage (wie es in Python geht) und die harte, dunkle Frage, die ich bezweifle, dass jemand sie beantworten wird (wie man es in Django macht), unterteilen. Beachten Sie, dass dies bereits eine Antwort hat. Ich bin jetzt auf halbem Weg zu meiner endgültigen Antwort anstatt zu 0%, wenn ich sie zusammen gepostet hätte. Außerdem erleichtert das Trennen der Fragen den Menschen die Suche nach Antworten. ZB wenn Bob nach einer Frage zur Dezimalformatierung sucht, überspringt er möglicherweise eine SO-Quest mit Django im Titel.
Greg
Ja, es war nur für mein Interesse: P Es ist einfacher, einem Thread zu folgen. Im Grunde ist es meiner Antwort ähnlich (nur ein bisschen spezifischer). Ich hoffe übrigens auch auf eine Django-Antwort.
Samuele Mattiuzzo

Antworten:

155
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'
Eumiro
quelle
22
Abgesehen davon, obwohl die format % valuesSyntax auch in der Python 3-Standardbibliothek noch verwendet wird, glaube ich, dass sie in Python 3 technisch veraltet ist oder zumindest nicht die empfohlene Formatierungsmethode, und die derzeit empfohlene Syntax, beginnend mit Python 2.6, wäre '{0:.2E}'.format(Decimal('40800000000.00000000000000'))( oder '{:.2E}'in Python 2.7+). Obwohl dies für diese Situation nicht unbedingt nützlich ist, ermöglicht es aufgrund der zusätzlichen Zeichen für keine zusätzliche Funktionalität ein str.formatkomplexeres Mischen / Neuanordnen / Wiederverwenden von Formatargumenten.
JAB
Was ist mit Python 3?
Charlie Parker
4
@CharlieParker Verwendung format. Es ist jazziger .
Mateen Ulhaq
120

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'
Cees Timmerman
quelle
3
Diese Syntax gilt auch für F-Strings in 3.6+f"{Decimal('40800000000.00000000000000'):.2E}"
Tritium21
37

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

patapouf_ai
quelle
1
Bei der Verwendung von Dezimalstellen geht es darum, eine Dezimalarithmetik mit exakter und beliebiger Genauigkeit zu erhalten. Dies entspricht nicht der Verwendung eines Schwimmers.
Asmeurer
@asmeurer Danke für die Klarstellung. Meine Antwort wurde geändert.
Patapouf_ai
Gibt es eine Möglichkeit, davon zurückzukehren, um zu schweben?
Olenscki
@olenscki float(x)konvertiert gerade x in float.
patapouf_ai
33

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)

Eulenfuchswiesel
quelle
3
Sollte als Antwort akzeptiert werden. F-Strings ist die Zukunft der Python-String-Formatierung :)
Gandalf Saxe
1
Zu Ihrer Information für zukünftige Leser wie mich: Wenn Sie die Anzahl der Ziffern nicht {num:E}kontrollieren
möchten
4

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
ubershmekel
quelle
3
Gerade "{:.2e}".format(n)kehrt '3.39e+7800'in Python 3.3.2 (V3.3.2: d047928ae3f6, 16. Mai 2013, 00.06.53) [MSC v.1600 64 Bit (AMD64)] auf win32.
Cees Timmerman
4

Das hat bei mir am besten funktioniert:

import decimal
'%.2E' % decimal.Decimal('40800000000.00000000000000')
# 4.08E+10
Matthew Fitch
quelle
4

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))
JayRizzo
quelle
3

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} ")
snr
quelle
2

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

MikeM
quelle
1

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

Rahat Ibrahim
quelle
0
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
Andrej
quelle