Bagaimana saya bisa menampilkan ini:

Desimal ('40800000000.00000000000000') sebagai '4.08E + 10'?

Saya sudah mencoba ini:

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

Tetapi memiliki 0 ekstra itu.

from decimal import Decimal

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

# returns '4.08E+10'

Di '40800000000.00000000000000' Anda, ada banyak nol signifikan yang memiliki arti yang sama dengan digit lainnya. Itu sebabnya Anda harus memberi tahu secara eksplisit ke mana Anda ingin berhenti.

Jika Anda ingin menghapus semua nol trailing secara otomatis, Anda dapat mencoba:

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'

Berikut ini contoh menggunakan format()fungsi:

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

Alih-alih memformat, Anda juga dapat menggunakan f-string :

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

• dokumentasi resmi

• proposal format asli ()

Diberi nomor Anda

x = Decimal('40800000000.00000000000000')

Mulai dari Python 3,

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

adalah cara yang disarankan untuk melakukannya.

eberarti Anda ingin notasi ilmiah, dan .2berarti Anda ingin 2 digit setelah titik. Jadi, Anda akan mendapatkannyax.xxE±n

Tidak ada yang menyebutkan bentuk singkat dari .formatmetode ini:

Membutuhkan setidaknya Python 3.6

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

(Saya percaya itu sama dengan Cees Timmerman, hanya sedikit lebih pendek)

Lihat tabel dari pemformatan string Python untuk memilih tata letak format yang tepat. Dalam kasus Anda, ini %.2E.

Desimal saya terlalu besar untuk %Ejadi saya harus berimprovisasi:

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)

Berikut ini contoh penggunaannya:

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

Ini bekerja paling baik untuk saya:

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

Ini adalah daftar gabungan dari Jawaban & Komentar "Sederhana" .

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

Perbandingan

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

Jadi untuk Python 3, Anda dapat beralih di antara ketiganya untuk saat ini.

Favoritku:

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

Saya lebih suka cara Python 3.x.

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

4 menunjukkan berapa banyak digit yang ditampilkan pada bagian mengambang.

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

Untuk mengkonversi Desimal menjadi notasi ilmiah tanpa perlu menentukan ketepatan dalam string format, dan tanpa menyertakan nol tambahan, saya saat ini menggunakan

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

Untuk menjaga angka nol yang tertinggal, cukup hapus normalize().

Ini adalah yang paling sederhana yang bisa saya temukan.

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

('E' tidak peka huruf besar-kecil. Anda juga dapat menggunakan '.2e')

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