फ्लोट वैल्यू प्रिंट करते समय वैज्ञानिक संकेतन को कैसे दबाएं?

Question

यहाँ मेरा कोड है:

x = 1.0
y = 100000.0    
print x/y

मेरे भागफल के रूप में प्रदर्शित करता है 1.00000e-05।

क्या वैज्ञानिक संकेतन को दबाने और इसे प्रदर्शित करने का कोई तरीका है 0.00001? मैं एक स्ट्रिंग के रूप में परिणाम का उपयोग करने जा रहा हूं।

Comments

1/10000 = 0.0001 = 1.00000e-04

— एड्रियन आर्चर

@ एए, यह मानते हुए कि असाइनमेंट स्टेटमेंट में एक टाइपो था, मैंने इसे ठीक कर लिया है।

— दान

यह निराशाजनक है कि यहां कोई भी उत्तर प्रश्न को संबोधित नहीं करता है। यह अच्छा होगा यदि स्पष्ट रूप से निर्दिष्ट किए जाने पर अजगर (3) को वैज्ञानिक संकेतन का उपयोग करने से रोकने का कोई तरीका हो। सभी उत्तरों के लिए उपयोगकर्ता को वैज्ञानिक संकेतन को स्पष्ट रूप से दबाने की आवश्यकता होती है, जो आमतौर पर अजगर के भीतर से वैज्ञानिक संकेतन के निहित उपयोग को दबाने के समान नहीं है।

— BLUC

Answer 1

'%f' % (x/y)

लेकिन आपको अपने आप को सटीक प्रबंधित करने की आवश्यकता है। जैसे,

'%f' % (1/10**8)

केवल शून्य प्रदर्शित करेगा।
विवरण डॉक्स में हैं

या पायथन 3 के लिए बराबर पुराने स्वरूपण या नई शैली स्वरूपण

Comments

मैं यह कहने के लिए आपके कथन को स्पष्ट करने का सुझाव देता हूं, "आप अपने आप सटीक प्रदर्शन का प्रबंधन करते हैं ।" वास्तविक (पायथन इंटरनल) परिशुद्धता को नहीं बदला गया है, जैसा कि अक्सर अन्य भाषाओं में किया जाता है।

— जेएस।

Answer 2

नए संस्करण का उपयोग करना ''.format(यह भी निर्दिष्ट करना याद रखें कि .आप कितने अंकों के बाद प्रदर्शित करना चाहते हैं, यह इस बात पर निर्भर करता है कि फ्लोटिंग संख्या कितनी छोटी है)। इस उदाहरण को देखें:

>>> a = -7.1855143557448603e-17
>>> '{:f}'.format(a)
'-0.000000'

जैसा कि ऊपर दिखाया गया है, डिफ़ॉल्ट 6 अंक है! यह हमारे मामले के उदाहरण के लिए उपयोगी नहीं है, इसलिए इसके बजाय हम कुछ इस तरह का उपयोग कर सकते हैं:

>>> '{:.20f}'.format(a)
'-0.00000000000000007186'

अपडेट करें

पायथन 3.6 में शुरू, यह नए स्वरूपित स्ट्रिंग शाब्दिक के साथ सरल किया जा सकता है, इस प्रकार है:

>>> f'{a:.20f}'
'-0.00000000000000007186'

Comments

हालांकि महत्वपूर्ण आंकड़ों को निर्दिष्ट करते हुए यह कैसे करें?

— Marses

मैं एक चर का उपयोग करके अनुमान लगाता हूं, इसे वांछित अंक दें, और शाब्दिक संख्या के बजाय इसका उपयोग करें जैसेf"{a:.{precision}f}"

— अजीज अल्टो

Answer 3

पायथन (2.6 और बाद के) के नए संस्करणों के साथ, आप यह सुनिश्चित करने के ''.format()लिए उपयोग कर सकते हैं कि @SilentGhost ने क्या सुझाव दिया है:

'{0:f}'.format(x/y)

Comments

क्या यह वास्तव में आप चाहते हैं? मैं नहीं: >>> print('{:f}'.format(0.000000123)) 0.000000

— द्वंद्व_

@ शुद्धता आपको सटीक निर्दिष्ट करने की आवश्यकता हो सकती है। '{0:.10f}'

— नौमिकल

Answer 4

एक अन्य विकल्प, यदि आप पांडा का उपयोग कर रहे हैं और सभी फ़्लोट्स के लिए वैज्ञानिक संकेतन को दबाना चाहते हैं, तो पांडा विकल्पों को समायोजित करना है।

import pandas as pd
pd.options.display.float_format = '{:.2f}'.format

Answer 5

ऊपर दिए गए अधिकांश उत्तर आपको सटीक निर्दिष्ट करने की आवश्यकता है। लेकिन क्या होगा अगर आप इस तरह से तैरना प्रदर्शित करना चाहते हैं, जिसमें कोई अनावश्यक शून्य न हो:

1
0.1
0.01
0.001
0.0001
0.00001
0.000001
0.000000000001

numpy जवाब है: np.format_float_positional

import numpy as np

def format_float(num):
    return np.format_float_positional(num, trim='-')

Answer 6

यह किसी भी घातांक के लिए काम करेगा:

def getExpandedScientificNotation(flt):
    str_vals = str(flt).split('e')
    coef = float(str_vals[0])
    exp = int(str_vals[1])
    return_val = ''
    if int(exp) > 0:
        return_val += str(coef).replace('.', '')
        return_val += ''.join(['0' for _ in range(0, abs(exp - len(str(coef).split('.')[1])))])
    elif int(exp) < 0:
        return_val += '0.'
        return_val += ''.join(['0' for _ in range(0, abs(exp) - 1)])
        return_val += str(coef).replace('.', '')
    return return_val

Answer 7

यह कप्तान ककड़ी के जवाब का उपयोग कर रहा है , लेकिन 2 परिवर्धन के साथ।

1) फ़ंक्शन को गैर-वैज्ञानिक संकेतन संख्याएं प्राप्त करने की अनुमति देता है और जैसा कि है, उन्हें वापस कर देता है (ताकि आप बहुत से इनपुट फेंक सकें कि कुछ संख्याएं 0.00003123 बनाम 3.123e-05 हैं और अभी भी फ़ंक्शन का काम है।

2) नकारात्मक संख्याओं के लिए समर्थन जोड़ा। (मूल कार्य में, एक नकारात्मक संख्या ०.००4१०4 ९ ०४ की तरह समाप्त हो जाएगी -1.08904e-05 से)

def getExpandedScientificNotation(flt):
    was_neg = False
    if not ("e" in flt):
        return flt
    if flt.startswith('-'):
        flt = flt[1:]
        was_neg = True 
    str_vals = str(flt).split('e')
    coef = float(str_vals[0])
    exp = int(str_vals[1])
    return_val = ''
    if int(exp) > 0:
        return_val += str(coef).replace('.', '')
        return_val += ''.join(['0' for _ in range(0, abs(exp - len(str(coef).split('.')[1])))])
    elif int(exp) < 0:
        return_val += '0.'
        return_val += ''.join(['0' for _ in range(0, abs(exp) - 1)])
        return_val += str(coef).replace('.', '')
    if was_neg:
        return_val='-'+return_val
    return return_val

Answer 8

SG के उत्तर के अलावा, आप दशमलव मॉड्यूल का उपयोग भी कर सकते हैं:

from decimal import Decimal
x = str(Decimal(1) / Decimal(10000))

# x is a string '0.0001'

Comments

यह 1e-6 से छोटे मूल्यों के लिए वैज्ञानिक संकेतन में बदल जाता है

— SilentGhost

Answer 9

यदि यह उदाहरण के लिए रूपांतरण करने के लिए इसमें stringनिर्मित बिल्ट है तो इसका उपयोग करें float: print( "%.5f" % float("1.43572e-03")) उत्तर:0.00143572

Answer 10

चूंकि यह Google पर शीर्ष परिणाम है, इसलिए मैं अपनी समस्या का समाधान खोजने में विफल रहने के बाद यहां पोस्ट करूंगा। यदि आप एक फ्लोट ऑब्जेक्ट के प्रदर्शन मूल्य को प्रारूपित करना चाहते हैं और क्या यह एक फ्लोट है - स्ट्रिंग नहीं, तो आप इस समाधान का उपयोग कर सकते हैं:

एक नया वर्ग बनाएं जो फ्लोट मानों को प्रदर्शित करने के तरीके को संशोधित करता है।

from builtins import float
class FormattedFloat(float):

    def __str__(self):
        return "{:.10f}".format(self).rstrip('0')

आप पूर्णांक मानों को बदलकर परिशुद्धता को स्वयं संशोधित कर सकते हैं {:f}

Answer 11

3.6.4 का उपयोग करते हुए, मुझे एक समान समस्या थी कि बेतरतीब ढंग से, आउटपुट फ़ाइल में एक नंबर को वैज्ञानिक नोटेशन के साथ स्वरूपित किया जाएगा:

fout.write('someFloats: {0:0.8},{1:0.8},{2:0.8}'.format(someFloat[0], someFloat[1], someFloat[2]))

इसे ठीक करने के लिए मुझे बस इतना करना था कि 'एफ' को जोड़ा जाए:

fout.write('someFloats: {0:0.8f},{1:0.8f},{2:0.8f}'.format(someFloat[0], someFloat[1], someFloat[2]))

Answer 12

3.6 के रूप में (शायद थोड़ा पुराने 3.x के साथ भी काम करता है), यह मेरा समाधान है:

import locale
locale.setlocale(locale.LC_ALL, '')

def number_format(n, dec_precision=4):
    precision = len(str(round(n))) + dec_precision
    return format(float(n), f'.{precision}n')

precisionगणना का उद्देश्य यह सुनिश्चित करना है कि हमारे पास वैज्ञानिक संकेतन से बाहर रहने के लिए पर्याप्त सटीकता है (डिफ़ॉल्ट परिशुद्धता अभी भी 6 है)।

dec_precisionतर्क दशमलव अंक के लिए उपयोग करने के लिए अतिरिक्त परिशुद्धता कहते हैं। चूंकि यह nप्रारूप का उपयोग करता है, इसलिए कोई तुच्छ शून्य जोड़ा नहीं जाएगा ( fप्रारूपों के विपरीत )। nदशमलव के बिना पहले से ही पूर्णांक पूर्णांक प्रदान करने का भी ध्यान रखेगा।

nfloatइनपुट की आवश्यकता है, इस प्रकार कलाकारों।