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.
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.
Antworten:
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'
format % values
Syntax 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.format
komplexeres Mischen / Neuanordnen / Wiederverwenden von Formatargumenten.
format
. Es ist jazziger .
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'
f"{Decimal('40800000000.00000000000000'):.2E}"
Geben Sie Ihre Nummer an
x = Decimal('40800000000.00000000000000')
Ab Python 3,
'{:.2e}'.format(x)
ist der empfohlene Weg, dies zu tun.
e
bedeutet, dass Sie eine wissenschaftliche Notation wünschen und .2
dass Sie 2 Ziffern nach dem Punkt möchten. So wirst du bekommenx.xxE±n
float(x)
konvertiert gerade x in float.
Niemand erwähnte die Kurzform der .format
Methode:
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)
{num:E}
kontrollieren
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ß, %E
deshalb 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
"{:.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.
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.
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
# =====================================
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
# =====================================
# =====================================
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))
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