বৈজ্ঞানিক স্বরলিপি একটি দশমিক প্রদর্শন করুন

Question

আমি এটি কীভাবে প্রদর্শন করতে পারি:

দশমিক ('40800000000.00000000000000') '4.08E + 10' হিসাবে?

আমি এটি চেষ্টা করেছি:

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

কিন্তু এটি অতিরিক্ত 0 এর আছে।

Comments

ধরণ পারে doubleposting, এই বিষয়ে আপনি মাত্র শুরু ব্যবহার করেছেন: stackoverflow.com/questions/6913166/...

— Samuele Mattiuzzo

নাহ, মোটেও না আমি এটিকে সহজ প্রশ্নে (পাইথনে এটি কীভাবে করা যায়) এবং কঠিন, অস্পষ্ট প্রশ্নের মধ্যে আমি আলাদা করতে চেয়েছিলাম যে আমি সন্দেহ করি যে যে কেউ উত্তর দেবে (জ্যাঙ্গোতে এটি কীভাবে করা যায়)। এটি ইতিমধ্যে একটি উত্তর আছে দেখুন। আমি এখন যদি 0% এর পরিবর্তে আমার চূড়ান্ত উত্তরে অর্ধেক হয়ে থাকি তবে যদি আমি তাদের একসাথে পোস্ট করি। এগুলি ছাড়াও, প্রশ্নগুলি পৃথক করা লোকদের উত্তরগুলির সন্ধান করা সহজ করে তোলে। E।, G যদি বব একটি দশমিক বিন্যাস সংক্রান্ত প্রশ্ন সন্ধান করে তবে তিনি শিরোনামে জ্যাঙ্গোর সাথে একটি এসও কোয়েস্টিন এড়িয়ে যেতে পারেন।

— গ্রেগ

হ্যাঁ, এটি কেবল আমার আগ্রহের জন্যই ছিল: পি এক থ্রেড অনুসরণ করা আরও সহজ। মূলত এটি আমার উত্তরের মতো (কেবলমাত্র "বিট" আরও নির্দিষ্ট)। আমিও জ্যাঙ্গো উত্তর আশা করছি, বিটিডব্লিউ।

— সামিউলে মাতিয়াজো

Answer 1

from decimal import Decimal

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

# returns '4.08E+10'

আপনার '40800000000000000000000000000' তে আরও অনেক উল্লেখযোগ্য শূন্য রয়েছে যা অন্য কোনও অঙ্কের মতো একই অর্থ। এজন্য আপনাকে স্পষ্ট করে বলতে হবে আপনি কোথায় থামতে চান।

আপনি যদি সমস্ত অনুসরণীয় শূন্যগুলি স্বয়ংক্রিয়ভাবে মুছে ফেলতে চান তবে আপনি চেষ্টা করতে পারেন:

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 এ প্রযুক্তিগতভাবে হ্রাস পেয়েছে বা কমপক্ষে প্রস্তাবিত বিন্যাস পদ্ধতি নয় এবং পাইথন ২.6 দিয়ে শুরু হওয়া বর্তমান প্রস্তাবিত বাক্য গঠনটি হবে '{0:.2E}'.format(Decimal('40800000000.00000000000000'))( বা '{:.2E}'পাইথন ২.7++ এ)। এই পরিস্থিতির জন্য কঠোরভাবে কার্যকর না হলেও, অতিরিক্ত ক্রিয়াকলাপের জন্য কোনও অতিরিক্ত ক্রিয়াকলাপের কারণে, str.formatআরও জটিল মিশ্রণ / পুনর্বিন্যাস / বিন্যাসের আর্গুমেন্টগুলির পুনরায় ব্যবহারের অনুমতি দেয়।

— জাব

অজগর 3 কি?

— চার্লি পার্কার 19

@CharlieParker ব্যবহারের format। এটা আরও জাজি ।

— মতিন উলহাক

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

এ থেকে ভেসে উঠার কোনও উপায় কি?

— ওলেনেসকি

@ ওলেনস্কি কেবলমাত্র এক্সকে ফ্লোটে float(x)রূপান্তরিত করবে।

— patapouf_ai

Answer 4

এর সংক্ষিপ্ত রূপের কথা কেউ উল্লেখ করেনি .format পদ্ধতির করেননি:

কমপক্ষে পাইথন 3.6 প্রয়োজন

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

(আমি বিশ্বাস করি এটি সিইস টিমারম্যানের মতো, কিছুটা ছোট)

Comments

উত্তর গ্রহণ করা উচিত। এফ-স্ট্রিংগুলি অজগর স্ট্রিং ফর্ম্যাটিংয়ের ভবিষ্যত :)

— গ্যান্ডালফ স্যাক্সে

আমার মতো ভবিষ্যতের পাঠকদের কাছে এফআইআই হিসাবে: যদি আপনি অঙ্কের সংখ্যা নিয়ন্ত্রণ করতে আগ্রহী না হন এবং ভাসমান পয়েন্ট ত্রুটিগুলি মনে না করেন তবে আপনি সহজেই ব্যবহার করতে পারেন {num:E}, যেমন নাম্বার = 40800000000.00000000000000

— শায়ান

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

বা ছাড়া 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'

('ই' কেস সংবেদনশীল নয় You আপনি '.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