डिफ़ॉल्ट फ्लोट प्रिंट प्रारूप बदलें

Question

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

मुझे फ्लोट्स का उपयोग करने की आवश्यकता है और दशमलव नहीं। इसके अलावा, मुझे फ्लोट्स को छंटनी/गोल करने की अनुमति नहीं है।

क्या डिफ़ॉल्ट व्यवहार को बदलने का कोई तरीका है?

Answer 1

आप की अनुमति नहीं है इग्नासिओ की तरह, बंदरगाह सी प्रकारों के लिए।

हालांकि, यदि आप ऐसा करने में बहुत दबाए जाते हैं और आप कुछ सी जानते हैं, तो आप पाइथन दुभाषिया स्रोत कोड को स्वयं संशोधित कर सकते हैं, फिर इसे एक कस्टम समाधान में पुन: संकलित कर सकते हैं। एक बार जब मैंने सूचियों के लिए मानक व्यवहार में से एक को संशोधित किया और यह केवल एक मामूली दर्द था।

मैं तुम्हें इस तरह के सिर्फ "%0.2f" printf अंकन के साथ तैरता मुद्रण के रूप में एक बेहतर समाधान मिल जाए, सुझाव देते हैं: अजगर 3.1

for item in mylist: 
    print '%0.2f' % item, 

या

print " ".join('%0.2f' % item for item in mylist) 

Answer 2

नहीं, क्योंकि float.__str__() को संशोधित करने की आवश्यकता होगी, लेकिन आपको सी प्रकारों को बंदरगाह करने की अनुमति नहीं है। इसके बजाय स्ट्रिंग इंटरपोलेशन या स्वरूपण का प्रयोग करें।

Answer 3

>>> a = 0.1 
>>> a 
0.10000000000000001 
>>> print a 
0.1 
>>> print "%0.3f" % a 
0.100 
>>> 

Python docs से, repr(a) 17 अंक (देना होगा के रूप में सिर्फ इंटरैक्टिव प्रॉम्प्ट पर a टाइप करके देखा है, लेकिन str(a) (स्वचालित रूप से प्रदर्शन किया, जब आप इसे प्रिंट) के लिए 12.

संपादित दौर: अधिकांश बुनियादी हैक समाधान ... आप हालांकि अपने स्वयं के वर्ग का उपयोग करने के, तो है ... हाँ।

>>> class myfloat(float): 
...  def __str__(self): 
...    return "%0.3f" % self.real 
>>> b = myfloat(0.1) 
>>> print repr(b) 
0.10000000000000001 
>>> print b 
0.100 
>>> 

Answer 4

अपग्रेड। यह आवश्यक से अधिक अंक का उपयोग नहीं करता है।

Python 3.1.2 (r312:79147, Apr 15 2010, 15:35:48) 
[GCC 4.4.3] on linux2 
Type "help", "copyright", "credits" or "license" for more information. 
>>> 0.1 
0.1 

Answer 5

आप सी भाषा का प्रयोग कर रहे हैं, तो आप या तो #define या "%*.*f" उपयोग कर सकते हैं कि क्या करना है, उदा

printf("%*.*f",4,2,variable); 

Answer 6

मैं आज इस मुद्दे में भाग गया, और मैं एक अलग समाधान के साथ आया। यदि आप मुद्रित होने पर कैसा दिखते हैं, इसके बारे में चिंतित हैं, तो आप stdout फ़ाइल ऑब्जेक्ट को एक कस्टम के साथ प्रतिस्थापित कर सकते हैं, जब लिखते हैं() को कॉल किया जाता है, फ्लोट की तरह दिखने वाली किसी भी चीज की खोज करता है, और उन्हें अपने प्रारूप के साथ बदल देता है उन्हें।

class ProcessedFile(object): 

    def __init__(self, parent, func): 
     """Wraps 'parent', which should be a file-like object, 
     so that calls to our write transforms the passed-in 
     string with func, and then writes it with the parent.""" 
     self.parent = parent 
     self.func = func 

    def write(self, str): 
     """Applies self.func to the passed in string and calls 
     the parent to write the result.""" 
     return self.parent.write(self.func(str)) 

    def writelines(self, text): 
     """Just calls the write() method multiple times.""" 
     for s in sequence_of_strings: 
      self.write(s) 

    def __getattr__(self, key): 
     """Default to the parent for any other methods.""" 
     return getattr(self.parent, key) 

if __name__ == "__main__": 
    import re 
    import sys 

    #Define a function that recognises float-like strings, converts them 
    #to floats, and then replaces them with 1.2e formatted strings. 
    pattern = re.compile(r"\b\d+\.\d*\b") 
    def reformat_float(input): 
     return re.subn(pattern, lambda match: ("{:1.2e}".format(float(match.group()))), input)[0] 

    #Use this function with the above class to transform sys.stdout. 
    #You could write a context manager for this. 
    sys.stdout = ProcessedFile(sys.stdout, reformat_float) 
    print -1.23456 
    # -1.23e+00 
    print [1.23456] * 6 
    # [1.23e+00, 1.23e+00, 1.23e+00, 1.23e+00, 1.23e+00, 1.23e+00] 
    print "The speed of light is 299792458.0 m/s." 
    # The speed of light is 3.00e+08 m/s. 
    sys.stdout = sys.stdout.parent 
    print "Back to our normal formatting: 1.23456" 
    # Back to our normal formatting: 1.23456 

यह कोई अच्छी बात है, तो आप सिर्फ एक स्ट्रिंग में संख्या डाल रहे हैं, लेकिन अंत में आप शायद फ़ाइल किसी प्रकार का है कि स्ट्रिंग कहीं लिखना चाहें, और आप के साथ है कि फाइल रैप करने के लिए सक्षम हो सकता है उपरोक्त वस्तु। स्पष्ट रूप से एक प्रदर्शन ओवरहेड का थोड़ा सा है।

उचित चेतावनी: मैंने पाइथन 3 में इसका परीक्षण नहीं किया है, मुझे नहीं पता कि यह काम करेगा या नहीं।