वैज्ञानिक संकेतन में एक दशमलव प्रदर्शित करें

Question

मैं इसे कैसे प्रदर्शित कर सकता हूं:

दशमलव ('40800000000.00000000000000') '4.08E + 10' के रूप में?

मैंने यह कोशिश की है:

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

लेकिन यह उन अतिरिक्त 0 है।

Comments

थोड़े डबलपोस्टिंग, आप इस विषय का उपयोग कर सकते हैं जिसे आपने अभी शुरू किया था: stackoverflow.com/questions/6913166/…

— Samuele Mattiuzzo

नहीं, बिल्कुल नहीं। मैं इसे आसान प्रश्न (पायथन में कैसे करना है) और कठिन, अस्पष्ट प्रश्न से अलग करना चाहता था, मुझे संदेह है कि कोई भी इसका जवाब देगा (इसे Django में कैसे किया जाए)। ध्यान दें कि इसका उत्तर पहले से ही है। अगर मैं उन्हें एक साथ पोस्ट किया था तो मैं अब 0% के बजाय अपने अंतिम उत्तर के लिए आधे रास्ते पर हूं। इसके अलावा, प्रश्नों को अलग करने से लोगों को उत्तरों की खोज करना आसान हो जाता है। ई।, अगर बॉब एक ​​दशमलव स्वरूपण प्रश्न की खोज कर रहा है तो वह शीर्षक में Django के साथ एक SO खोज को छोड़ सकता है।

— ग्रेग

हाँ, यह सिर्फ मेरी रुचि के लिए था: पी एक धागा का पालन करना आसान है। मूल रूप से यह मेरे उत्तर के समान है (सिर्फ एक "बिट" अधिक विशिष्ट)। मैं एक django जवाब के लिए उम्मीद कर रहा हूँ, btw।

— सामूले मतीउज़्ज़ो

Answer 1

from decimal import Decimal

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

# returns '4.08E+10'

आपके '40800000000.00000000000000' में और भी कई महत्वपूर्ण शून्य हैं जिनका किसी अन्य अंक के समान अर्थ है। इसलिए आपको स्पष्ट रूप से बताना होगा कि आप कहां रुकना चाहते हैं।

यदि आप सभी ट्रेलिंग शून्य को स्वचालित रूप से निकालना चाहते हैं, तो आप कोशिश कर सकते हैं:

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'

Comments

एक तरफ के रूप में, format % valuesअभी भी सिंटैक्स का उपयोग पायथन 3 मानक पुस्तकालय के भीतर भी किया जा रहा है, मेरा मानना ​​है कि यह तकनीकी रूप से पायथन 3 में पदावनत है, या कम से कम अनुशंसित प्रारूपण विधि नहीं है, और वर्तमान अनुशंसित सिंटैक्स, पायथन 2.6 के साथ शुरू होगा, '{0:.2E}'.format(Decimal('40800000000.00000000000000'))( होगा ) या '{:.2E}'पायथन 2.7+ में)। इस स्थिति के लिए कड़ाई से उपयोगी नहीं है, बिना किसी अतिरिक्त कार्यक्षमता के अतिरिक्त वर्णों के कारण, str.formatप्रारूप तर्कों के अधिक जटिल मिश्रण / पुन: व्यवस्थित / पुन: व्यवस्थित करने की अनुमति देता है।

— JAB

अजगर 3 के बारे में क्या?

— चार्ली पार्कर

@CharlieParker का उपयोग करें format। यह अधिक jazzy है ।

— मतीन उलहाक

Answer 2

यहां format()फ़ंक्शन का उपयोग करके एक उदाहरण दिया गया है:

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

प्रारूप के बजाय, आप एफ-स्ट्रिंग्स का उपयोग भी कर सकते हैं :

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

• आधिकारिक दस्तावेज

• मूल प्रारूप () प्रस्ताव

Comments

यह वाक्यविन्यास 3.6+f"{Decimal('40800000000.00000000000000'):.2E}"

— ट्रिटियम 21

Answer 3

आपका नंबर दिया

x = Decimal('40800000000.00000000000000')

पायथन 3 से शुरू,

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

यह करने का अनुशंसित तरीका है

eइसका मतलब है कि आप वैज्ञानिक अंकन चाहते हैं, और .2इसका मतलब है कि आप डॉट के बाद 2 अंक चाहते हैं। तो आपको मिलेगाx.xxE±n

Comments

दशमलव का उपयोग करने का बिंदु सटीक और मनमाना सटीक दशमलव अंकगणित प्राप्त करना है। यह फ्लोट का उपयोग करने के बराबर नहीं है।

— asmeurer

@ व्याख्याता स्पष्टीकरण के लिए धन्यवाद। मेरा जवाब बदल दिया।

— patapouf_ai

क्या तैरने के लिए इससे वापस आने का कोई रास्ता है?

— ओलेन्स्की

@olenscki बस करने float(x)से x को फ्लोट में बदल देगा।

— patapouf_ai

Answer 4

किसी ने भी इसके संक्षिप्त रूप का उल्लेख नहीं किया है .format विधि :

कम से कम अजगर 3.6 की जरूरत है

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

(मेरा मानना ​​है कि यह सीस टिमरमैन की तरह ही है, बस थोड़ा छोटा है)

Comments

उत्तर स्वीकार किया जाना चाहिए। f- स्ट्रिंग्स में भविष्य का अजगर स्ट्रिंग फॉर्मेटिंग :)

— गंडालफ सक्से

भविष्य के पाठकों के लिए खुद की तरह एक फ़िजी के रूप में: यदि आप अंकों की संख्या को नियंत्रित करने और फ़्लोटिंग पॉइंट त्रुटियों को ध्यान में नहीं रखते हैं, तो आप बस उपयोग कर सकते हैं {num:E}, जहां उदाहरण संख्या = 40800000000.00000000000000

— Shayaan

Answer 5

उचित प्रारूप लेआउट का चयन करने के लिए पायथन स्ट्रिंग प्रारूपण से तालिकाओं को देखें । आपके मामले में %.2E।

Answer 6

मेरे दशमलव बहुत बड़े हैं %Eइसलिए मुझे सुधार करना पड़ा:

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)

यहां एक उदाहरण का उपयोग किया गया है:

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

Comments

बस "{:.2e}".format(n)रिटर्न '3.39e+7800'में अजगर 3.3.2 (v3.3.2: 16 मई 2013 00:06:53 d047928ae3f6,) [एमएससी v.1600 64 बिट (AMD64)] Win32 पर।

— सेस टिम्मरमैन

Answer 7

इसने मेरे लिए सबसे अच्छा काम किया:

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

Answer 8

यह "सरल" उत्तरों और टिप्पणियों की एक समेकित सूची है ।

पायथन 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 के बिना IMPORTकी

# 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

तो पायथन 3 के लिए, आप अभी के लिए तीनों में से किसी के बीच स्विच कर सकते हैं।

मेरा प्रिय:

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

Answer 9

मैं पाइथन 3.x तरीका पसंद करता हूं।

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

4 यह दर्शाता है कि फ्लोटिंग भाग में कितने अंक दिखाए गए हैं।

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

Answer 10

स्वरूप स्ट्रिंग में सटीक निर्दिष्ट करने की आवश्यकता के बिना दशमलव को वैज्ञानिक संकेतन में बदलने के लिए, और शून्य को पीछे किए बिना, मैं इसका उपयोग कर रहा हूं।

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

किसी भी ट्रेलिंग शून्य को रखने के लिए, बस को हटा दें normalize()।

Answer 11

यहाँ सबसे सरल है जो मुझे मिल सकता है।

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

('ई' केस संवेदी नहीं है। आप '.2e' का भी उपयोग कर सकते हैं)

Answer 12

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