Display a decimal in scientific notation

Question

How can I display Decimal('40800000000.00000000000000') as '4.08E+10'?

I've tried this:

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

But it has those extra 0's.

kinda doubleposting, you could have used this topic you just started: http://stackoverflow.com/questions/6913166/django-how-to-display-scientific-notation-on-admin-page-field — Samuele Mattiuzzo, Aug 02 '11 at 14:20
nah, not at all. I wanted to separate this into the easy question (how to do it in Python) and the hard, obscure question that I doubt anyone will answer (how to do it in Django). Notice how this already has an answer. I'm now halfway to my final answer instead of 0% if I had posted them together. Besides that, separating the questions makes it easier for people to search for the answers. E.,g if Bob is searching for a decimal formatting question he might skip a SO questin with Django in the title. — Greg, Aug 02 '11 at 14:26

score 220 · Accepted Answer · edited Nov 23 '16 at 18:22

220

from decimal import Decimal

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

# returns '4.08E+10'

In your '40800000000.00000000000000' there are many more significant zeros that have the same meaning as any other digit. That's why you have to tell explicitly where you want to stop.

If you want to remove all trailing zeros automatically, you can try:

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'

edited Nov 23 '16 at 18:22

ABM

1,628
2
26
42

answered Aug 02 '11 at 14:19

eumiro

207,213
34
299
261

26

As an aside, despite the `format % values` syntax still being used even within the Python 3 standard library, I believe it's technically deprecated in Python 3, or at least not the recommended formatting method, and the current recommended syntax, starting with Python 2.6, would be `'{0:.2E}'.format(Decimal('40800000000.00000000000000'))` (or `'{:.2E}'` in Python 2.7+). While not strictly useful for this situation, due to the additional characters for no added functionality, `str.format` does allow for more complex mixing/rearranging/reutilizing of format arguments. – JAB Aug 02 '11 at 14:42
4

@CharlieParker Use [`format`](https://stackoverflow.com/a/19864272/365102). It's more *jazzy*. – Mateen Ulhaq Feb 05 '18 at 21:26

score 180 · Answer 2 · edited May 16 '20 at 19:20

180

Here's an example using the format() function:

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

Instead of format, you can also use f-strings:

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

edited May 16 '20 at 19:20

jaquinocode

634
7
12

answered Nov 08 '13 at 16:44

Cees Timmerman

17,623
11
91
124

9

This syntax also applies to f-strings in 3.6+ `f"{Decimal('40800000000.00000000000000'):.2E}"` – Tritium21 Nov 06 '18 at 03:41

patapouf_ai · Answer 3 · 2021-07-14T15:39:00.193

72

Given your number

x = Decimal('40800000000.00000000000000')

Starting from Python 3,

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

is the recommended way to do it.

e means you want scientific notation, and .2 means you want 2 digits after the dot. So you will get x.xxE±n

edited Jul 14 '21 at 15:39

answered Mar 12 '17 at 15:47

patapouf_ai

17,605
13
92
132

2

The point of using Decimal is to get exact and arbitrary precision decimal arithmetic. It is not equivalent to using a float. – asmeurer Apr 05 '17 at 21:28
@asmeurer Thanks for the clarification. Changed my answer. – patapouf_ai Apr 05 '17 at 22:42
Is there a way to get back from this to float? – olenscki May 17 '20 at 23:40
@olenscki just doing `float(x)` will convert x into float. – patapouf_ai May 20 '20 at 13:45
Is there a difference between `e` and `E` ? – theonlygusti Nov 16 '22 at 17:15
I don't think so, no. – patapouf_ai Nov 21 '22 at 17:06
1

@theonlygusti: from the [documentation:](https://docs.python.org/3/library/string.html#formatstrings) "*Scientific notation. Same as 'e' except it uses an upper case ‘E’ as the separator character*" – mins Dec 22 '22 at 10:20

Eulenfuchswiesel · Answer 4 · 2018-03-23T10:20:27.077

48

No one mentioned the short form of the .format method:

Needs at least Python 3.6

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

(I believe it's the same as Cees Timmerman, just a bit shorter)

edited Mar 23 '18 at 10:20

answered Feb 26 '18 at 10:38

Eulenfuchswiesel

879
9
20

6

Should be accepted answer. f-strings is the future of python string formatting :) – Gandalf Saxe Nov 19 '18 at 11:13
4

As an fyi to future readers like myself: if you don't care to control the number of digits and don't mind floating point errors, you can simply use `{num:E}`, where e.g. num = 40800000000.00000000000000 – shayaan Feb 26 '19 at 08:16
1

For information about formatting https://stackoverflow.com/questions/45310254/fixed-digits-after-decimal-with-f-strings#45310389 – Eulenfuchswiesel Aug 25 '20 at 16:49
Following on from shayaan's recommendation that is f"{num:E}" – user160623 May 27 '23 at 15:09

score 18 · Answer 5 · answered Oct 27 '19 at 04:29

This is a consolidated list of the "Simple" Answers & Comments.

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

OR Without `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
# =====================================

Comparing

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

So for Python 3, you can switch between any of the three for now.

My Fav:

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

Example Usage: https://github.com/JayRizzo/rg_code/blob/master/class_act/factions.py#L37 — JayRizzo, Mar 23 '21 at 19:30

score 12 · Answer 6 · answered Aug 02 '11 at 14:22

12

See tables from Python string formatting to select the proper format layout. In your case it's %.2E.

answered Aug 02 '11 at 14:22

Mihai Maruseac

20,967
7
57
109

score 5 · Answer 7 · answered May 12 '16 at 08:09

5

This worked best for me:

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

answered May 12 '16 at 08:09

Matthew Fitch

245
1
9
13

score 4 · Answer 8 · answered Jan 06 '13 at 22:06

4

My decimals are too big for %E so I had to improvize:

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)

Here's an example usage:

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

answered Jan 06 '13 at 22:06

ubershmekel

11,864
10
72
89

3

Just `"{:.2e}".format(n)` returns `'3.39e+7800'` in Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:06:53) [MSC v.1600 64 bit (AMD64)] on win32. – Cees Timmerman Nov 08 '13 at 16:52

score 4 · Answer 9 · answered Feb 26 '14 at 11:37

To convert a Decimal to scientific notation without needing to specify the precision in the format string, and without including trailing zeros, I'm currently using

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

To keep any trailing zeros, just remove the normalize().

score 3 · Answer 10 · answered Sep 11 '19 at 03:33

3

I prefer Python 3.x way.

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

4 indicates how many digits are shown shown in the floating part.

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

answered Sep 11 '19 at 03:33

Soner from The Ottoman Empire

18,731
3
79
101

score 2 · Answer 11 · answered Oct 14 '21 at 10:41

Adding an updated answer to show how to apply e notation to small numbers only

value = 0.1
a = "{:,}".format(value) if value >= 0.001 else "{:,.3e}".format(value)
print(a) # 0.1

value = 0.00002488
a = "{:,}".format(value) if value >= 0.001 else "{:,.3e}".format(value)
print(a) # 2.488e-05

score 1 · Answer 12 · answered Apr 05 '20 at 22:05

1

Here is the simplest one I could find.

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

('E' is not case sensitive. You can also use '.2e')

answered Apr 05 '20 at 22:05

Ibrahim Khalil

28
1
8

Andrej · Answer 13 · 2015-01-12T15:51:30.110

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

Display a decimal in scientific notation

13 Answers13

PYTHON 3

OR Without `IMPORT`'s

Comparing

Linked

Related

Display a decimal in scientific notation

13 Answers13

PYTHON 3

OR Without IMPORT's

Comparing

Linked

Related

OR Without `IMPORT`'s