Supprimer la Notation Scientifique dans Numpy Lors de la Création de Tableau De Liste Imbriquée

J'ai un imbriquée Python liste qui ressemble à la suivante:

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]]

Je puis import Numpy, et de définir les options d'impression pour (suppress=True). Lorsque je crée un tableau:

my_array = numpy.array(my_list)

Je ne peux pas pour la vie de me supprimer la notation scientifique:

[[  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]]

Si je créer un simple tableau numpy directement:

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

Je n'ai pas de problème et il imprime comme suit:

[ 1.5    4.65   7.845]

Personne ne sait à quoi mon problème?

  • numpy.set_printoptions contrôle la manière dont les tableaux numpy sont imprimés. Cependant, il n'y a pas d'option pour supprimer entièrement scientifique notatation. C'est le changement parce que vous avez des valeurs allant de 1e-2 jusqu'à 1e9. Si vous avez un plus petit de la gamme, il ne sera pas utiliser la notation scientifique pour les afficher. Pourquoi importe-t-il la façon dont ils sont affichés avec print, si? Si vous essayez d'enregistrer, utilisez savetxt, etc.
  • Pas vraiment ce que vous demandez, mais l'utilisation de numpy.round (même avec une haute précision), j'ai été en mesure de supprimer la notation scientifique qui ressemblait 7.00000000 e+00 dans un SVD de la reconstruction de la matrice. En raison de la notation scientifique (?) il ne serait pas affirmer l'égalité de tous devant. Je suis le mentionner parce que np.set_printoptions(supprimer=True) n'a pas de travail pour résoudre ce problème pour moi.
InformationsquelleAutor donopj2 | 2012-03-19
  1. 233

    Je suppose que ce que vous avez besoin est np.set_printoptions(suppress=True), pour les détails, voir ici:
    http://pythonquirks.blogspot.fr/2009/10/controlling-printing-in-numpy.html

    Pour SciPy.org numpy documentation, qui comprend tous les paramètres de la fonction (supprimer n'est pas détaillé dans le lien ci-dessus), voir ici: https://docs.scipy.org/doc/numpy/reference/generated/numpy.set_printoptions.html

    • pouvez-vous au moins de fournir un résumé de ce qu'il fait?
    • Dans mon cas, il utilise toujours la notation scientifique
    • utilisation en tant que formateur dans Eric réponse ci-dessous. J'ai utilisé np.set_printoptions(formatter={'all':lambda x: str(x)})
    InformationsquelleAutor wiswit
  2. 28

    Python Force-supprimer toutes notation exponentielle lors de l'impression de numpy ndarrays, de se quereller justification du texte, l'arrondissement et les options d'impression:

    Ce qui suit est une explication de ce qui se passe, faites défiler vers le bas pour le code des démos.

    Passage de paramètre suppress=True à la fonction set_printoptions ne fonctionne que pour les numéros qui correspondent à la valeur par défaut de 8 caractères espace alloué, comme ceci:

    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. ]

    Toutefois, si vous passez dans un certain nombre de plus de 8 caractères, notation exponentielle est imposée de nouveau, comme ceci:

    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 a un choix entre les hacher votre numéro dans la moitié donc fausse, ou de forcer la notation exponentielle, il choisit cette dernière.

    Voici set_printoptions(formatter=...) à la rescousse pour spécifier les options d'impression et d'arrondi. Dire set_printoptions à imprimer nu nu float:

    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]

    Nous avons la force supprimé la notation exponentielle, mais il n'est pas arrondi ou justifié, donc spécifier d'autres options de mise en forme:

    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]

    L'inconvénient de force-la suppression de tous exponentielle notion dans ndarrays est que si votre ndarray obtient une énorme valeur flottante près de l'infini, et vous l'imprimez, vous allez avoir dynamité dans le visage avec une page pleine de chiffres.

    Exemple complet Démo 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))

    Imprime: 

    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]])

    Exemple complet de Démonstration 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')

    Imprime: 

     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

    Avis que l'arrondissement est conforme à 2 unités de précision, et de la notation exponentielle est supprimée à la fois la très grande e+x et les très petites e-x plages.

    InformationsquelleAutor Eric Leschinski
  3. 20

    pour les codes 1D et 2D, des tableaux, vous pouvez utiliser np.savetxt pour imprimer à l'aide d'un format de chaîne de caractères:

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

    De vos options avec numpy.set_printoptions ou numpy.array2string en v1.3 sont assez maladroit et limitée (par exemple pas de moyen de supprimer la notation scientifique pour les grands nombres). Il ressemble à ce qui va changer avec les futures versions, avec numpy.set_printoptions(formateur=..) et numpy.array2string(style=..).

    InformationsquelleAutor lindyblackburn
  4. 0

    Vous pouvez écrire une fonction qui convertit une notation scientifique à l'ordinaire, quelque chose comme

    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
    InformationsquelleAutor Amir