Exibir um decimal na notação científica


161

Como posso exibir isso:

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

Eu tentei isso:

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

Mas tem esses 0 extras.


3
meio que com duplo posicionamento, você poderia ter usado este tópico que você acabou de começar: stackoverflow.com/questions/6913166/…
Samuele Mattiuzzo

13
nah, de jeito nenhum. Eu queria separar isso na pergunta fácil (como fazê-lo em Python) e na pergunta difícil e obscura que duvido que alguém responda (como fazê-lo no Django). Observe como isso já tem uma resposta. Agora estou na metade da minha resposta final, em vez de 0%, se os tivesse postado juntos. Além disso, separar as perguntas facilita a busca de respostas pelas pessoas. Por exemplo, se Bob está procurando por uma pergunta de formatação decimal, ele pode pular uma busca SO com o Django no título.
Greg

Sim, foi apenas para o meu interesse: P é mais fácil seguir um tópico. basicamente é semelhante à minha resposta (apenas um pouco "mais específico"). Também estou esperando uma resposta de django, btw.
Samuele Mattiuzzo

Respostas:


157
from decimal import Decimal

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

# returns '4.08E+10'

No seu '40800000000.00000000000000', existem muitos zeros mais significativos que têm o mesmo significado que qualquer outro dígito. É por isso que você precisa dizer explicitamente onde deseja parar.

Se você deseja remover todos os zeros à direita automaticamente, tente:

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
Além disso, apesar da format % valuessintaxe ainda estar sendo usada mesmo na biblioteca padrão do Python 3, acredito que ela seja tecnicamente reprovada no Python 3, ou pelo menos não no método de formatação recomendado, e a sintaxe recomendada atual, começando no Python 2.6, seria '{0:.2E}'.format(Decimal('40800000000.00000000000000'))( ou '{:.2E}'no Python 2.7+). Embora não seja estritamente útil para essa situação, devido aos caracteres adicionais, sem funcionalidade adicional, str.formatpermite uma mistura / reorganização / reutilização mais complexa de argumentos de formato.
JAB

e quanto ao python 3?
Charlie Parker

4
@CharlieParker Use format. É mais jazzístico .
Mateen Ulhaq


37

Dado o seu número

x = Decimal('40800000000.00000000000000')

A partir do Python 3,

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

é a maneira recomendada de fazer isso.

esignifica que você deseja notação científica e .2significa que você deseja 2 dígitos após o ponto. Então você teráx.xxE±n


1
O objetivo de usar Decimal é obter aritmética decimal de precisão exata e arbitrária. Não é equivalente a usar um flutuador.
asmeurer

@asmeurer Obrigado pelo esclarecimento. Mudou minha resposta.
precisa saber é o seguinte

Existe uma maneira de voltar disso para flutuar?
olenscki 17/05

O @olenscki que fizer float(x)isso converterá x em float.
patapouf_ai

33

Ninguém mencionou a forma abreviada do .formatmétodo:

Precisa de pelo menos Python 3.6

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

(Eu acredito que é o mesmo que Cees Timmerman, apenas um pouco mais curto)


3
Deve ser aceita resposta. f-cordas é o futuro da cadeia de python formatação :)
Gandalf Saxe

1
Como fyi para futuros leitores como eu: se você não deseja controlar o número de dígitos e não se importa com erros de ponto flutuante, pode simplesmente usar {num:E}, onde, por exemplo, num = 40800000000.00000000000000
Shayaan


4

Meus decimais são grandes demais, %Eentão eu tive 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)

Aqui está um exemplo de uso:

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

3
Apenas "{:.2e}".format(n)retorna '3.39e+7800'no Python 3.3.2 (v3.3.2: d047928ae3f6, 16 de maio de 2013, 00:06:53) [MSC v.1600 de 64 bits (AMD64)] no win32.
precisa

4

Isso funcionou melhor para mim:

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

4

Esta é uma lista consolidada das respostas e comentários "simples" .

PITÃO 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
# =====================================

Ou sem 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

Portanto, para o Python 3, você pode alternar entre os três por enquanto.

Meu favorito:

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

3

Eu prefiro o modo Python 3.x.

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

4 indica quantos dígitos são mostrados na parte flutuante.

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

2

Para converter uma decimal para notação científica sem precisar especificar a precisão na sequência de formatação e sem incluir zeros à direita, estou usando atualmente

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 manter os zeros à direita, basta remover o normalize().


1

Aqui está o mais simples que eu poderia encontrar.

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

('E' não diferencia maiúsculas de minúsculas. Você também pode usar '.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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.