Wyświetl ułamek dziesiętny w notacji naukowej


159

Jak mogę to wyświetlić:

Dziesiętny („40800000000,00000000000000”) jako „4,08E + 10”?

Próbowałem tego:

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

Ale ma te dodatkowe zera.


3
trochę podwójne, mogłeś użyć tego tematu, który dopiero co zacząłeś: stackoverflow.com/questions/6913166/ ...
Samuele Mattiuzzo

12
nie, wcale. Chciałem podzielić to na proste pytanie (jak to zrobić w Pythonie) i trudne, niejasne pytanie, na które wątpię, aby ktokolwiek odpowiedział (jak to zrobić w Django). Zauważ, że to już ma odpowiedź. Jestem teraz w połowie drogi do mojej ostatecznej odpowiedzi, zamiast 0%, gdybym opublikował je razem. Poza tym oddzielenie pytań ułatwia ludziom poszukiwanie odpowiedzi. E., g jeśli Bob szuka pytania o formatowanie dziesiętne, może pominąć pytanie SO z Django w tytule.
Greg

tak, to było tylko z mojego zainteresowania: P łatwiej jest śledzić jeden wątek. w zasadzie jest podobny do mojej odpowiedzi (tylko „trochę” bardziej szczegółowy). Tak przy okazji, mam też nadzieję na odpowiedź django.
Samuele Mattiuzzo

Odpowiedzi:


157
from decimal import Decimal

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

# returns '4.08E+10'

W Twojej „40800000000.00000000000000” znajduje się o wiele więcej znaczących zer, które mają takie samo znaczenie, jak każda inna cyfra. Dlatego musisz wyraźnie powiedzieć, gdzie chcesz się zatrzymać.

Jeśli chcesz automatycznie usunąć wszystkie końcowe zera, możesz spróbować:

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'

22
Nawiasem mówiąc, pomimo tego, że format % valuesskładnia jest nadal używana nawet w standardowej bibliotece Python 3, uważam, że jest technicznie przestarzała w Pythonie 3, a przynajmniej nie jest zalecaną metodą formatowania, a obecna zalecana składnia, począwszy od Pythona 2.6, to '{0:.2E}'.format(Decimal('40800000000.00000000000000'))( lub '{:.2E}'w Pythonie 2.7+). Chociaż nie jest to ściśle przydatne w tej sytuacji, ze względu na dodatkowe znaki bez dodatkowej funkcjonalności, str.formatpozwala na bardziej złożone mieszanie / przestawianie / ponowne wykorzystanie formatów argumentów.
JAB

a co z Pythonem 3?
Charlie Parker

4
@CharlieParker Use format. Jest bardziej jazzy .
Mateen Ulhaq,


37

Biorąc pod uwagę twój numer

x = Decimal('40800000000.00000000000000')

Począwszy od Pythona 3,

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

jest zalecanym sposobem, aby to zrobić.

eoznacza, że ​​potrzebujesz notacji naukowej, a .2po kropce chcesz mieć 2 cyfry. Więc dostanieszx.xxE±n


1
Celem użycia Decimal jest uzyskanie dokładnej arytmetyki dziesiętnej z dowolną dokładnością. Nie jest to równoznaczne z użyciem pływaka.
asmeurer

@asmeurer Dzięki za wyjaśnienie. Zmieniłem odpowiedź.
patapouf_ai

Czy jest sposób, aby wrócić z tego i odpłynąć?
olenscki

@olenscki po prostu float(x)zamieni x na float.
patapouf_ai

33

Nikt nie wspomniał o krótkiej formie .formatmetody:

Wymaga przynajmniej Pythona 3.6

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

(Myślę, że jest taki sam jak Cees Timmerman, tylko trochę krótszy)


3
Powinna zostać zaakceptowana odpowiedź. f-strings jest przyszłość Pythona ciąg formatowania :)
Gandalf Saxe

1
Jako fyi dla przyszłych czytelników, takich jak ja: jeśli nie zależy ci na kontrolowaniu liczby cyfr i nie masz nic przeciwko błędom zmiennoprzecinkowym, możesz po prostu użyć {num:E}, gdzie np. Num = 40800000000.00000000000000
Shayaan


4

Moje liczby dziesiętne są za duże, %Ewięc musiałem improwizować:

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)

Oto przykład użycia:

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

3
Po prostu "{:.2e}".format(n)powraca '3.39e+7800'w Pythonie 3.3.2 (v3.3.2: d047928ae3f6, 16 maja 2013, 00:06:53) [MSC v.1600 64 bit (AMD64)] na win32.
Cees Timmerman

4

To zadziałało najlepiej dla mnie:

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

4

To jest skonsolidowana lista „prostych” odpowiedzi i komentarzy.

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

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

Porównywanie

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

W przypadku Pythona 3 możesz teraz przełączać się między dowolnym z trzech.

Mój ulubiony:

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

3

Wolę sposób Pythona 3.x.

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

4 wskazuje, ile cyfr jest wyświetlanych w części pływającej.

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

2

Aby przekonwertować notację dziesiętną na notację naukową bez konieczności określania dokładności w ciągu formatu i bez uwzględniania końcowych zer, obecnie używam

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

Aby zachować końcowe zera, po prostu usuń normalize().


1

Oto najprostszy, jaki udało mi się znaleźć.

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

(„E” nie rozróżnia wielkości liter. Możesz też użyć „.2e”)


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
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.