Numpy में वैज्ञानिक संकेतन को दबाएं जब नस्टेड सूची से एरे बनाना


160

मेरे पास एक नेस्टेड पायथन सूची है जो निम्नलिखित की तरह दिखता है:

my_list = [[3.74, 5162, 13683628846.64, 12783387559.86, 1.81],
 [9.55, 116, 189688622.37, 260332262.0, 1.97],
 [2.2, 768, 6004865.13, 5759960.98, 1.21],
 [3.74, 4062, 3263822121.39, 3066869087.9, 1.93],
 [1.91, 474, 44555062.72, 44555062.72, 0.41],
 [5.8, 5006, 8254968918.1, 7446788272.74, 3.25],
 [4.5, 7887, 30078971595.46, 27814989471.31, 2.18],
 [7.03, 116, 66252511.46, 81109291.0, 1.56],
 [6.52, 116, 47674230.76, 57686991.0, 1.43],
 [1.85, 623, 3002631.96, 2899484.08, 0.64],
 [13.76, 1227, 1737874137.5, 1446511574.32, 4.32],
 [13.76, 1227, 1737874137.5, 1446511574.32, 4.32]]

मैं तो Numpy आयात करता हूं, और प्रिंट विकल्प सेट करता हूं (suppress=True)। जब मैं एक सरणी बनाता हूं:

my_array = numpy.array(my_list)

मैं अपने जीवन के लिए वैज्ञानिक संकेतन को दबा नहीं सकता:

[[  3.74000000e+00   5.16200000e+03   1.36836288e+10   1.27833876e+10
    1.81000000e+00]
 [  9.55000000e+00   1.16000000e+02   1.89688622e+08   2.60332262e+08
    1.97000000e+00]
 [  2.20000000e+00   7.68000000e+02   6.00486513e+06   5.75996098e+06
    1.21000000e+00]
 [  3.74000000e+00   4.06200000e+03   3.26382212e+09   3.06686909e+09
    1.93000000e+00]
 [  1.91000000e+00   4.74000000e+02   4.45550627e+07   4.45550627e+07
    4.10000000e-01]
 [  5.80000000e+00   5.00600000e+03   8.25496892e+09   7.44678827e+09
    3.25000000e+00]
 [  4.50000000e+00   7.88700000e+03   3.00789716e+10   2.78149895e+10
    2.18000000e+00]
 [  7.03000000e+00   1.16000000e+02   6.62525115e+07   8.11092910e+07
    1.56000000e+00]
 [  6.52000000e+00   1.16000000e+02   4.76742308e+07   5.76869910e+07
    1.43000000e+00]
 [  1.85000000e+00   6.23000000e+02   3.00263196e+06   2.89948408e+06
    6.40000000e-01]
 [  1.37600000e+01   1.22700000e+03   1.73787414e+09   1.44651157e+09
    4.32000000e+00]
 [  1.37600000e+01   1.22700000e+03   1.73787414e+09   1.44651157e+09
    4.32000000e+00]]

अगर मैं सीधे एक साधारण संख्या बनाऊं:

new_array = numpy.array([1.5, 4.65, 7.845])

मुझे कोई समस्या नहीं है और यह निम्नानुसार प्रिंट करता है:

[ 1.5    4.65   7.845]

क्या किसी को पता है कि मेरी समस्या क्या है?


2
numpy.set_printoptionsनियंत्रित करता है कि कैसे सुन्न सरणियाँ मुद्रित की जाती हैं। हालांकि, वैज्ञानिक नोटेशन को पूरी तरह से दबाने का कोई विकल्प नहीं है। यह स्विचिंग है क्योंकि आपके पास 1e-2 से लेकर 1e9 तक के मान हैं। यदि आपके पास छोटी रेंज है, तो यह उन्हें प्रदर्शित करने के लिए वैज्ञानिक संकेतन का उपयोग नहीं करेगा। printहालांकि इससे कोई फर्क नहीं पड़ता कि वे किस तरह से प्रदर्शित होते हैं ? यदि आप इसे बचाने, उपयोग करने savetxtआदि के लिए प्रयास कर रहे हैं
जो किंगटन

2
वास्तव में आप क्या पूछ रहे हैं, लेकिन numpy.round (एक उच्च परिशुद्धता के साथ भी) का उपयोग करके मैं वैज्ञानिक संकेतन को हटाने में सक्षम था जो एक SVD पुनर्निर्माण मैट्रिक्स में 7.00000000e + 00 जैसा दिखता था। क्योंकि वैज्ञानिक संकेतन (?) से पहले यह समानता का दावा नहीं करेगा। मैं इसका उल्लेख कर रहा हूँ, क्योंकि np.set_printoptions (suppress = True) ने मेरे लिए इस समस्या को ठीक करने के लिए काम नहीं किया।
ब्रेख्तडैमैन

जवाबों:


261

मुझे लगता है कि आपको क्या चाहिए np.set_printoptions(suppress=True), विवरण के लिए यहां देखें: http://pythonquirks.blogspot.fr/2009/10/controlling-printing-in-numpy.html

SciPy.org के लिए numpy दस्तावेज़ीकरण, जिसमें सभी फ़ंक्शन पैरामीटर शामिल हैं (ऊपर दिए गए लिंक में दमन विस्तृत नहीं है), यहां देखें: https://docs.scipy.org/doc/numpy/reference/generated/numpy.set/printoptions.html


7
क्या आप कम से कम इसका सारांश प्रदान करते हैं कि यह क्या करता है?
चार्ली पार्कर

4
मेरे मामले में यह अभी भी वैज्ञानिक संकेतन का उपयोग करता है
lesolorzanov

2
@ZloySmiertniy, नीचे दिए गए एरिक के उत्तर में फॉर्मेटर का उपयोग करें। मैंने इस्तेमाल किया np.set_printoptions(formatter={'all':lambda x: str(x)})
नर्स

37

पाइथन फोर्स को दबाने के लिए सभी घातीय संकेतन को दबाते हैं जब सुन्न ndarrays, पाठ औचित्य, राउंडिंग और प्रिंट विकल्प को मिटाते हैं:

इस प्रकार क्या हो रहा है के लिए एक स्पष्टीकरण है, कोड डेमो के लिए नीचे स्क्रॉल करें।

suppress=Trueफ़ंक्शन के लिए पैरामीटर पास करना set_printoptionsकेवल उन संख्याओं के लिए काम करता है जो इस तरह आवंटित डिफ़ॉल्ट 8 वर्ण स्थान में फिट होते हैं:

import numpy as np
np.set_printoptions(suppress=True) #prevent numpy exponential 
                                   #notation on print, default False

#            tiny     med  large
a = np.array([1.01e-5, 22, 1.2345678e7])  #notice how index 2 is 8 
                                          #digits wide

print(a)    #prints [ 0.0000101   22.     12345678. ]

हालाँकि, यदि आप 8 वर्णों से अधिक की संख्या में गुजरते हैं, तो घातीय संकेतन फिर से लगाया जाता है, जैसे:

np.set_printoptions(suppress=True)

a = np.array([1.01e-5, 22, 1.2345678e10])    #notice how index 2 is 10
                                             #digits wide, too wide!

#exponential notation where we've told it not to!
print(a)    #prints [1.01000000e-005   2.20000000e+001   1.23456780e+10]

numpy के पास आपकी संख्या को आधे में काट देने के बीच एक विकल्प है, इसलिए इसे गलत तरीके से प्रस्तुत करना, या घातीय संकेतन को मजबूर करना, यह उत्तरार्द्ध को चुनता है।

यहां set_printoptions(formatter=...)प्रिंटिंग और राउंडिंग के विकल्पों को निर्दिष्ट करने के लिए बचाव है। बताओ set_printoptionsसिर्फ एक नंगे नाव नंगा मुद्रित करने के लिए:

np.set_printoptions(suppress=True,
   formatter={'float_kind':'{:f}'.format})

a = np.array([1.01e-5, 22, 1.2345678e30])  #notice how index 2 is 30
                                           #digits wide.  

#Ok good, no exponential notation in the large numbers:
print(a)  #prints [0.000010 22.000000 1234567799999999979944197226496.000000] 

हमने घातीय संकेतन को बलपूर्वक दबा दिया है, लेकिन यह गोल या उचित नहीं है, इसलिए अतिरिक्त स्वरूपण विकल्प निर्दिष्ट करें:

np.set_printoptions(suppress=True,
   formatter={'float_kind':'{:0.2f}'.format})  #float, 2 units 
                                               #precision right, 0 on left

a = np.array([1.01e-5, 22, 1.2345678e30])   #notice how index 2 is 30
                                            #digits wide

print(a)  #prints [0.00 22.00 1234567799999999979944197226496.00]

Ndarrays में सभी घातीय धारणा को बलपूर्वक दबाने का दोष यह है कि यदि आपके ndarray को अनंत के पास एक बड़ा फ्लोट मूल्य मिलता है, और आप इसे प्रिंट करते हैं, तो आप चेहरे पर एक पूर्ण संख्या वाले पृष्ठ के साथ ब्लास्ट होने वाले हैं।

पूर्ण उदाहरण डेमो 1:

from pprint import pprint
import numpy as np
#chaotic python list of lists with very different numeric magnitudes
my_list = [[3.74, 5162, 13683628846.64, 12783387559.86, 1.81],
           [9.55, 116, 189688622.37, 260332262.0, 1.97],
           [2.2, 768, 6004865.13, 5759960.98, 1.21],
           [3.74, 4062, 3263822121.39, 3066869087.9, 1.93],
           [1.91, 474, 44555062.72, 44555062.72, 0.41],
           [5.8, 5006, 8254968918.1, 7446788272.74, 3.25],
           [4.5, 7887, 30078971595.46, 27814989471.31, 2.18],
           [7.03, 116, 66252511.46, 81109291.0, 1.56],
           [6.52, 116, 47674230.76, 57686991.0, 1.43],
           [1.85, 623, 3002631.96, 2899484.08, 0.64],
           [13.76, 1227, 1737874137.5, 1446511574.32, 4.32],
           [13.76, 1227, 1737874137.5, 1446511574.32, 4.32]]

#convert python list of lists to numpy ndarray called my_array
my_array = np.array(my_list)

#This is a little recursive helper function converts all nested 
#ndarrays to python list of lists so that pretty printer knows what to do.
def arrayToList(arr):
    if type(arr) == type(np.array):
        #If the passed type is an ndarray then convert it to a list and
        #recursively convert all nested types
        return arrayToList(arr.tolist())
    else:
        #if item isn't an ndarray leave it as is.
        return arr

#suppress exponential notation, define an appropriate float formatter
#specify stdout line width and let pretty print do the work
np.set_printoptions(suppress=True,
   formatter={'float_kind':'{:16.3f}'.format}, linewidth=130)
pprint(arrayToList(my_array))

प्रिंटों:

array([[           3.740,         5162.000,  13683628846.640,  12783387559.860,            1.810],
       [           9.550,          116.000,    189688622.370,    260332262.000,            1.970],
       [           2.200,          768.000,      6004865.130,      5759960.980,            1.210],
       [           3.740,         4062.000,   3263822121.390,   3066869087.900,            1.930],
       [           1.910,          474.000,     44555062.720,     44555062.720,            0.410],
       [           5.800,         5006.000,   8254968918.100,   7446788272.740,            3.250],
       [           4.500,         7887.000,  30078971595.460,  27814989471.310,            2.180],
       [           7.030,          116.000,     66252511.460,     81109291.000,            1.560],
       [           6.520,          116.000,     47674230.760,     57686991.000,            1.430],
       [           1.850,          623.000,      3002631.960,      2899484.080,            0.640],
       [          13.760,         1227.000,   1737874137.500,   1446511574.320,            4.320],
       [          13.760,         1227.000,   1737874137.500,   1446511574.320,            4.320]])

पूर्ण उदाहरण डेमो 2:

import numpy as np  
#chaotic python list of lists with very different numeric magnitudes 

#            very tiny      medium size            large sized
#            numbers        numbers                numbers

my_list = [[0.000000000074, 5162, 13683628846.64, 1.01e10, 1.81], 
           [1.000000000055,  116, 189688622.37, 260332262.0, 1.97], 
           [0.010000000022,  768, 6004865.13,   -99e13, 1.21], 
           [1.000000000074, 4062, 3263822121.39, 3066869087.9, 1.93], 
           [2.91,            474, 44555062.72, 44555062.72, 0.41], 
           [5,              5006, 8254968918.1, 7446788272.74, 3.25], 
           [0.01,           7887, 30078971595.46, 27814989471.31, 2.18], 
           [7.03,            116, 66252511.46, 81109291.0, 1.56], 
           [6.52,            116, 47674230.76, 57686991.0, 1.43], 
           [1.85,            623, 3002631.96, 2899484.08, 0.64], 
           [13.76,          1227, 1737874137.5, 1446511574.32, 4.32], 
           [13.76,          1337, 1737874137.5, 1446511574.32, 4.32]] 
import sys 
#convert python list of lists to numpy ndarray called my_array 
my_array = np.array(my_list) 
#following two lines do the same thing, showing that np.savetxt can 
#correctly handle python lists of lists and numpy 2D ndarrays. 
np.savetxt(sys.stdout, my_list, '%19.2f') 
np.savetxt(sys.stdout, my_array, '%19.2f') 

प्रिंटों:

 0.00             5162.00      13683628846.64      10100000000.00              1.81
 1.00              116.00        189688622.37        260332262.00              1.97
 0.01              768.00          6004865.13 -990000000000000.00              1.21
 1.00             4062.00       3263822121.39       3066869087.90              1.93
 2.91              474.00         44555062.72         44555062.72              0.41
 5.00             5006.00       8254968918.10       7446788272.74              3.25
 0.01             7887.00      30078971595.46      27814989471.31              2.18
 7.03              116.00         66252511.46         81109291.00              1.56
 6.52              116.00         47674230.76         57686991.00              1.43
 1.85              623.00          3002631.96          2899484.08              0.64
13.76             1227.00       1737874137.50       1446511574.32              4.32
13.76             1337.00       1737874137.50       1446511574.32              4.32
 0.00             5162.00      13683628846.64      10100000000.00              1.81
 1.00              116.00        189688622.37        260332262.00              1.97
 0.01              768.00          6004865.13 -990000000000000.00              1.21
 1.00             4062.00       3263822121.39       3066869087.90              1.93
 2.91              474.00         44555062.72         44555062.72              0.41
 5.00             5006.00       8254968918.10       7446788272.74              3.25
 0.01             7887.00      30078971595.46      27814989471.31              2.18
 7.03              116.00         66252511.46         81109291.00              1.56
 6.52              116.00         47674230.76         57686991.00              1.43
 1.85              623.00          3002631.96          2899484.08              0.64
13.76             1227.00       1737874137.50       1446511574.32              4.32
13.76             1337.00       1737874137.50       1446511574.32              4.32

ध्यान दें कि गोलाई 2 इकाइयों की सटीकता पर संगत है, और घातीय संकेतन दोनों बहुत बड़ी e+xऔर बहुत छोटी e-xश्रेणियों में दबा हुआ है।


22

1 डी और 2 डी सरणियों के लिए आप एक विशिष्ट प्रारूप स्ट्रिंग का उपयोग करके प्रिंट करने के लिए np.savetxt का उपयोग कर सकते हैं:

>>> import sys
>>> x = numpy.arange(20).reshape((4,5))
>>> numpy.savetxt(sys.stdout, x, '%5.2f')
 0.00  1.00  2.00  3.00  4.00
 5.00  6.00  7.00  8.00  9.00
10.00 11.00 12.00 13.00 14.00
15.00 16.00 17.00 18.00 19.00

V1.3 में numpy.set_printoptions या numpy.array2string के साथ आपके विकल्प बहुत क्लिंक और सीमित हैं (उदाहरण के लिए बड़ी संख्या के लिए वैज्ञानिक संकेतन को दबाने का कोई तरीका नहीं)। ऐसा लगता है कि यह भविष्य के संस्करणों के साथ बदल जाएगा, numpy.set_printoptions (फ़ॉर्मेटर = ..) और numpy.array2string (शैली = ..) के साथ।


0

आप एक फ़ंक्शन लिख सकते हैं जो एक वैज्ञानिक संकेतन को नियमित रूप से परिवर्तित करता है, जैसे कुछ

def sc2std(x):
    s = str(x)
    if 'e' in s:
        num,ex = s.split('e')
        if '-' in num:
            negprefix = '-'
        else:
            negprefix = ''
        num = num.replace('-','')
        if '.' in num:
            dotlocation = num.index('.')
        else:
            dotlocation = len(num)
        newdotlocation = dotlocation + int(ex)
        num = num.replace('.','')
        if (newdotlocation < 1):
            return negprefix+'0.'+'0'*(-newdotlocation)+num
        if (newdotlocation > len(num)):
            return negprefix+ num + '0'*(newdotlocation - len(num))+'.0'
        return negprefix + num[:newdotlocation] + '.' + num[newdotlocation:]
    else:
        return s
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.