पायथन - सुंदर प्रिंट त्रुटिबर्स

Question

मैं डेटा मूल्यांकन के लिए numpy, scipy और matplotlib के साथ अजगर का उपयोग कर रहा हूं। परिणाम के रूप में मैं एररबार्स के साथ औसत और फिटिंग पैरामीटर प्राप्त करता हूं।

मैं चाहता हूं कि पाइथन स्वचालित रूप से किसी दिए गए परिशुद्धता के अनुसार इस डेटा को सुंदर-प्रिंट करें। उदाहरण के लिए:

मान लीजिए मुझे परिणाम x = 0./- 0.000123 मिला है। के रूप में इसे स्वचालित रूप से प्रारूपित करने का कोई तरीका है जब 2 की सटीकता निर्दिष्ट की गई थी। यही है, मूल्य के बजाय, त्रुटि पट्टी में परिशुद्धता की गिनती।

क्या कोई ऐसे पैकेज को जानता है जो ऐसी कार्यक्षमता प्रदान करता है, या मुझे इसे स्वयं लागू करना होगा?

क्या पाइथन स्ट्रिंग स्वरूपण तंत्र में इसे इंजेक्ट करने का कोई तरीका है? अर्थात। "%.2N" % (0., 0.0000123) जैसे कुछ लिखने में सक्षम होना।

मैंने पहले से ही numpy और scipy के दस्तावेज़ों के माध्यम से देखा और चारों ओर googled, लेकिन मुझे कुछ भी नहीं मिला। मुझे लगता है कि आंकड़ों से निपटने वाले हर किसी के लिए यह एक उपयोगी सुविधा होगी।

आपकी मदद के लिए धन्यवाद!

संपादित करें: जैसा कि नाथन व्हाइटहेड द्वारा अनुरोध किया गया है, मैं कुछ उदाहरण दूंगा।

123 +- 1   ----precision 1-----> 123(1) 
123 +- 1.1  ----precision 2-----> 123.0(11) 
0.- 0.001 ----precision 1-----> 0.012(1) 
123.111 +- 0.123 ----precision 2-----> 123.11(12) 

स्पष्टता के लिए दस की शक्तियां छोड़ी गई हैं। ब्रांड्स के अंदर संख्या मानक त्रुटि के लिए एक शॉर्टेंड नोटेशन है। माता-पिता के सामने संख्या का अंतिम अंक और माता-पिता के अंदर संख्या के अंतिम अंक को एक ही दशमलव शक्ति पर होना चाहिए। किसी कारण से मुझे ऑनलाइन इस अवधारणा का अच्छा स्पष्टीकरण नहीं मिल रहा है। मुझे केवल एक चीज मिली है यह जर्मन विकिपीडिया लेख here है। हालांकि, यह एक काफी आम और बहुत आसान नोटेशन है।

EDIT2: मैं आशुलिपि संकेतन बात अपने आप को लागू किया:

#!/usr/bin/env python 
# *-* coding: utf-8 *-* 

from math import floor, log10 

# uncertainty to string 
def un2str(x, xe, precision=2): 
    """pretty print nominal value and uncertainty 

    x - nominal value 
    xe - uncertainty 
    precision - number of significant digits in uncertainty 

    returns shortest string representation of `x +- xe` either as 
     x.xx(ee)e+xx 
    or as 
     xxx.xx(ee)""" 
    # base 10 exponents 
    x_exp = int(floor(log10(x))) 
    xe_exp = int(floor(log10(xe))) 

    # uncertainty 
    un_exp = xe_exp-precision+1 
    un_int = round(xe*10**(-un_exp)) 

    # nominal value 
    no_exp = un_exp 
    no_int = round(x*10**(-no_exp)) 

    # format - nom(unc)exp 
    fieldw = x_exp - no_exp 
    fmt = '%%.%df' % fieldw 
    result1 = (fmt + '(%.0f)e%d') % (no_int*10**(-fieldw), un_int, x_exp) 

    # format - nom(unc) 
    fieldw = max(0, -no_exp) 
    fmt = '%%.%df' % fieldw 
    result2 = (fmt + '(%.0f)') % (no_int*10**no_exp, un_int*10**max(0, un_exp)) 

    # return shortest representation 
    if len(result2) <= len(result1): 
     return result2 
    else: 
     return result1 


if __name__ == "__main__": 
    xs = [123456, 12.34567, 0.123456, 0.0, 0.000] 
    xes = [ 123, 0.00123, 0.000123, 0.000000, 0.00000] 
    precs = [  1,  2,  3,    4,   1] 

    for (x, xe, prec) in zip(xs, xes, precs): 
     print '%.6e +- %.6e @%d --> %s' % (x, xe, prec, un2str(x, xe, prec)) 

आउटपुट:

1.234560e+05 +- 1.230000e+02 @1 --> 1.235(1)e5 
1.234567e+01 +- 1.230000e-03 @2 --> 12.3457(12) 
1.234560e-01 +- 1.230000e-04 @3 --> 0.123456(123) 
1.234560e-03 +- 1.234500e-08 @4 --> 0.0(1235) 
1.234560e-05 +- 1.234000e-07 @1 --> 1.23(1)e-5 

Answer 1

x +- y के बाद से एक मानक प्रकार (यह असली और काल्पनिक के साथ एक जटिल के रूप में देखा जा सकता है नहीं है एक्स और यी अनुमान के रूप में, लेकिन यह कुछ भी आसान नहीं करता है ...) लेकिन आप स्ट्रिंग फ़ंक्शन को टाइप करके ओवरराइड करके प्रस्तुति पर पूर्ण नियंत्रण प्राप्त कर सकते हैं, यानी

जैसे कुछ

class Res(object): 
    def __init__(self, res, delta): 
    self.res = res 
    self.delta = delta 

    def __str__(self): 
    return "%f +- %f"%(self.res,self.delta) 

if __name__ == '__main__': 
    x = Res(0.2710,0.001) 
    print(x) 
    print(" a result: %s" % x) 

आप स्वाभाविक रूप से कुछ में थोड़ा और अधिक __str__ समारोह के अंदर कल्पना कर सकता है ...