我该如何打印格式化的NumPy数组，使其类似于这样:
x = 1.23456
print('%.3f' % x)
如果我想打印 numpy.ndarray 类型的浮点数，它会输出多个小数位数，通常以“科学”格式呈现，即使对于低维数组也很难阅读。但是，numpy.ndarray 显然必须作为字符串打印，即使用 %s。有没有解决方法？
在给定精度下，美观地打印 NumPy 数组而无需使用科学计数法。
461
- camillio
1
1这个讨论也可能会引起那些通过谷歌搜索到这里的人的兴趣。 - Foad S. Farimani
14个回答
756
使用numpy.set_printoptions来设置输出的精度:
import numpy as np
x = np.random.random(10)
print(x)
# [ 0.07837821 0.48002108 0.41274116 0.82993414 0.77610352 0.1023732
# 0.51303098 0.4617183 0.33487207 0.71162095]
np.set_printoptions(precision=3)
print(x)
# [ 0.078 0.48 0.413 0.83 0.776 0.102 0.513 0.462 0.335 0.712]
而 suppress 则抑制了对于小数的科学计数法表示：
y = np.array([1.5e-10, 1.5, 1500])
print(y)
# [ 1.500e-10 1.500e+00 1.500e+03]
np.set_printoptions(suppress=True)
print(y)
# [ 0. 1.5 1500. ]
要在本地应用打印选项，使用NumPy 1.15.0或更高版本，可以使用numpy.printoptions上下文管理器。
例如，在with-suite内设置precision=3和suppress=True:
x = np.random.random(10)
with np.printoptions(precision=3, suppress=True):
print(x)
# [ 0.073 0.461 0.689 0.754 0.624 0.901 0.049 0.582 0.557 0.348]
但是在with-suite之外，打印选项会恢复默认设置：
print(x)
# [ 0.07334334 0.46132615 0.68935231 0.75379645 0.62424021 0.90115836
# 0.04879837 0.58207504 0.55694118 0.34768638]
如果您使用的是较早版本的NumPy，则可以自行创建上下文管理器。例如：
import numpy as np
import contextlib
@contextlib.contextmanager
def printoptions(*args, **kwargs):
original = np.get_printoptions()
np.set_printoptions(*args, **kwargs)
try:
yield
finally:
np.set_printoptions(**original)
x = np.random.random(10)
with printoptions(precision=3, suppress=True):
print(x)
# [ 0.073 0.461 0.689 0.754 0.624 0.901 0.049 0.582 0.557 0.348]
为了防止浮点数末尾的零被去除：
np.set_printoptions现在有一个formatter参数，允许你为每种类型指定格式函数。
np.set_printoptions(formatter={'float': '{: 0.3f}'.format})
print(x)
打印的函数
[ 0.078 0.480 0.413 0.830 0.776 0.102 0.513 0.462 0.335 0.712]
代替
[ 0.078 0.48 0.413 0.83 0.776 0.102 0.513 0.462 0.335 0.712]
- unutbu
9
1有没有一种方法可以仅将格式应用于特定的打印语句（而不是设置所有打印语句使用的通用输出格式）？ - bph
11@Hiett：NumPy没有单独设置一个
print的打印选项的函数，但是你可以使用上下文管理器来实现类似功能。我已经编辑了上面的帖子来展示我的意思。 - unutbu2你的
np.set_printoptions(precision=3) 压制了末尾的零... 你怎么让它们显示成这样 [ 0.078 0.480 0.413 0.830 0.776 0.102 0.513 0.462 0.335 0.712]？ - Norfeldt2@Norfeldt：我已经在上面添加了一种方法来实现这个。 - unutbu
1这个工作得很好。顺带一提，如果您想要字符串表示而不一定使用
print，您还可以使用 set_printoptions。您只需要调用 numpy 数组实例的 __str__() 方法，就会按照您设置的打印选项获取格式化字符串。 - Jayesh显示剩余4条评论
73
使用np.array_str仅对单个打印语句应用格式设置。它提供了np.set_printoptions功能的子集。
例如：
In [27]: x = np.array([[1.1, 0.9, 1e-6]] * 3)
In [28]: print(x)
[[ 1.10000000e+00 9.00000000e-01 1.00000000e-06]
[ 1.10000000e+00 9.00000000e-01 1.00000000e-06]
[ 1.10000000e+00 9.00000000e-01 1.00000000e-06]]
In [29]: print(np.array_str(x, precision=2))
[[ 1.10e+00 9.00e-01 1.00e-06]
[ 1.10e+00 9.00e-01 1.00e-06]
[ 1.10e+00 9.00e-01 1.00e-06]]
In [30]: print(np.array_str(x, precision=2, suppress_small=True))
[[ 1.1 0.9 0. ]
[ 1.1 0.9 0. ]
[ 1.1 0.9 0. ]]
- Daniel Golden
1
4可能是最简单和高效的选项，因为它不会在
printoptions中引入永久更改，也不需要昂贵的循环或with结构。应该将格式化元素的可能性直接集成到numpy中（无法理解为什么不是这种情况）。 - mins46
Unutbu提供了非常全面的答案（他们也得到了我的+1），但这里有一个低技术的选择：
>>> x=np.random.randn(5)
>>> x
array([ 0.25276524, 2.28334499, -1.88221637, 0.69949927, 1.0285625 ])
>>> ['{:.2f}'.format(i) for i in x]
['0.25', '2.28', '-1.88', '0.70', '1.03']
作为一个函数（使用
format()语法进行格式化）：def ndprint(a, format_string ='{0:.2f}'):
print [format_string.format(v,i) for i,v in enumerate(a)]
使用方法：
>>> ndprint(x)
['0.25', '2.28', '-1.88', '0.70', '1.03']
>>> ndprint(x, '{:10.4e}')
['2.5277e-01', '2.2833e+00', '-1.8822e+00', '6.9950e-01', '1.0286e+00']
>>> ndprint(x, '{:.8g}')
['0.25276524', '2.283345', '-1.8822164', '0.69949927', '1.0285625']
数组的索引可以在格式字符串中访问:
>>> ndprint(x, 'Element[{1:d}]={0:.2f}')
['Element[0]=0.25', 'Element[1]=2.28', 'Element[2]=-1.88', 'Element[3]=0.70', 'Element[4]=1.03']
- Caleb Hattingh
20
FYI，Numpy 1.15（发布日期待定）将 包括用于在本地设置打印选项的上下文管理器。这意味着以下内容将与接受的答案中的对应示例相同，而无需编写自己的上下文管理器。例如，使用他们的示例：
x = np.random.random(10)
with np.printoptions(precision=3, suppress=True):
print(x)
# [ 0.073 0.461 0.689 0.754 0.624 0.901 0.049 0.582 0.557 0.348]
- Justin Lanfranchi
17
在今天的numpy版本中，使得将结果作为字符串轻松获取的宝石被隐藏在denis的答案中：
np.array2string
>>> import numpy as np
>>> x=np.random.random(10)
>>> np.array2string(x, formatter={'float_kind':'{0:.3f}'.format})
'[0.599 0.847 0.513 0.155 0.844 0.753 0.920 0.797 0.427 0.420]'
- hamogu
1
这是两个回答中的一个，实际上满足了要求，没有重复造轮子。 - undefined
11
多年后，下面还有另一个。但是对于日常使用，我只需要
np.set_printoptions( threshold=20, edgeitems=10, linewidth=140,
formatter = dict( float = lambda x: "%.3g" % x )) # float arrays %.3g
''' printf( "... %.3g ... %.1f ...", arg, arg ... ) for numpy arrays too
Example:
printf( """ x: %.3g A: %.1f s: %s B: %s """,
x, A, "str", B )
If `x` and `A` are numbers, this is like `"format" % (x, A, "str", B)` in python.
If they're numpy arrays, each element is printed in its own format:
`x`: e.g. [ 1.23 1.23e-6 ... ] 3 digits
`A`: [ [ 1 digit after the decimal point ... ] ... ]
with the current `np.set_printoptions()`. For example, with
np.set_printoptions( threshold=100, edgeitems=3, suppress=True )
only the edges of big `x` and `A` are printed.
`B` is printed as `str(B)`, for any `B` -- a number, a list, a numpy object ...
`printf()` tries to handle too few or too many arguments sensibly,
but this is iffy and subject to change.
How it works:
numpy has a function `np.array2string( A, "%.3g" )` (simplifying a bit).
`printf()` splits the format string, and for format / arg pairs
format: % d e f g
arg: try `np.asanyarray()`
--> %s np.array2string( arg, format )
Other formats and non-ndarray args are left alone, formatted as usual.
Notes:
`printf( ... end= file= )` are passed on to the python `print()` function.
Only formats `% [optional width . precision] d e f g` are implemented,
not `%(varname)format` .
%d truncates floats, e.g. 0.9 and -0.9 to 0; %.0f rounds, 0.9 to 1 .
%g is the same as %.6g, 6 digits.
%% is a single "%" character.
The function `sprintf()` returns a long string. For example,
title = sprintf( "%s m %g n %g X %.3g",
__file__, m, n, X )
print( title )
...
pl.title( title )
Module globals:
_fmt = "%.3g" # default for extra args
_squeeze = np.squeeze # (n,1) (1,n) -> (n,) print in 1 line not n
See also:
http://docs.scipy.org/doc/numpy/reference/generated/numpy.set_printoptions.html
http://docs.python.org/2.7/library/stdtypes.html#string-formatting
'''
# https://dev59.com/eHE85IYBdhLWcg3wNgrk
#...............................................................................
from __future__ import division, print_function
import re
import numpy as np
__version__ = "2014-02-03 feb denis"
_splitformat = re.compile( r'''(
%
(?<! %% ) # not %%
-? [ \d . ]* # optional width.precision
\w
)''', re.X )
# ... %3.0f ... %g ... %-10s ...
# -> ['...' '%3.0f' '...' '%g' '...' '%-10s' '...']
# odd len, first or last may be ""
_fmt = "%.3g" # default for extra args
_squeeze = np.squeeze # (n,1) (1,n) -> (n,) print in 1 line not n
#...............................................................................
def printf( format, *args, **kwargs ):
print( sprintf( format, *args ), **kwargs ) # end= file=
printf.__doc__ = __doc__
def sprintf( format, *args ):
""" sprintf( "text %.3g text %4.1f ... %s ... ", numpy arrays or ... )
%[defg] array -> np.array2string( formatter= )
"""
args = list(args)
if not isinstance( format, basestring ):
args = [format] + args
format = ""
tf = _splitformat.split( format ) # [ text %e text %f ... ]
nfmt = len(tf) // 2
nargs = len(args)
if nargs < nfmt:
args += (nfmt - nargs) * ["?arg?"]
elif nargs > nfmt:
tf += (nargs - nfmt) * [_fmt, " "] # default _fmt
for j, arg in enumerate( args ):
fmt = tf[ 2*j + 1 ]
if arg is None \
or isinstance( arg, basestring ) \
or (hasattr( arg, "__iter__" ) and len(arg) == 0):
tf[ 2*j + 1 ] = "%s" # %f -> %s, not error
continue
args[j], isarray = _tonumpyarray(arg)
if isarray and fmt[-1] in "defgEFG":
tf[ 2*j + 1 ] = "%s"
fmtfunc = (lambda x: fmt % x)
formatter = dict( float_kind=fmtfunc, int=fmtfunc )
args[j] = np.array2string( args[j], formatter=formatter )
try:
return "".join(tf) % tuple(args)
except TypeError: # shouldn't happen
print( "error: tf %s types %s" % (tf, map( type, args )))
raise
def _tonumpyarray( a ):
""" a, isarray = _tonumpyarray( a )
-> scalar, False
np.asanyarray(a), float or int
a, False
"""
a = getattr( a, "value", a ) # cvxpy
if np.isscalar(a):
return a, False
if hasattr( a, "__iter__" ) and len(a) == 0:
return a, False
try:
# map .value ?
a = np.asanyarray( a )
except ValueError:
return a, False
if hasattr( a, "dtype" ) and a.dtype.kind in "fi": # complex ?
if callable( _squeeze ):
a = _squeeze( a ) # np.squeeze
return a, True
else:
return a, False
#...............................................................................
if __name__ == "__main__":
import sys
n = 5
seed = 0
# run this.py n= ... in sh or ipython
for arg in sys.argv[1:]:
exec( arg )
np.set_printoptions( 1, threshold=4, edgeitems=2, linewidth=80, suppress=True )
np.random.seed(seed)
A = np.random.exponential( size=(n,n) ) ** 10
x = A[0]
printf( "x: %.3g \nA: %.1f \ns: %s \nB: %s ",
x, A, "str", A )
printf( "x %%d: %d", x )
printf( "x %%.0f: %.0f", x )
printf( "x %%.1e: %.1e", x )
printf( "x %%g: %g", x )
printf( "x %%s uses np printoptions: %s", x )
printf( "x with default _fmt: ", x )
printf( "no args" )
printf( "too few args: %g %g", x )
printf( x )
printf( x, x )
printf( None )
printf( "[]:", [] )
printf( "[3]:", [3] )
printf( np.array( [] ))
printf( [[]] ) # squeeze
- denis
9
以下是我使用的内容，非常简单易懂：
print(np.vectorize("%.2f".__mod__)(sparse))
- utdemir
8
NumPy 数组具有方法
round(precision)，该方法返回一个新的 NumPy 数组，其中的元素按照精度进行四舍五入。import numpy as np
x = np.random.random([5,5])
print(x.round(3))
- Ștefan
1
1当我将数组传递给matplotlib的ylabel时，这对我很有用，谢谢。 - Hans
6
惊讶地发现没有提到around方法 - 这意味着不需要改变打印选项。
import numpy as np
x = np.random.random([5,5])
print(np.around(x,decimals=3))
Output:
[[0.475 0.239 0.183 0.991 0.171]
[0.231 0.188 0.235 0.335 0.049]
[0.87 0.212 0.219 0.9 0.3 ]
[0.628 0.791 0.409 0.5 0.319]
[0.614 0.84 0.812 0.4 0.307]]
- tea_pea
1
1但这意味着每次想要打印它时都要创建数组的第二个副本，这可能会阻止某些使用情况。 - Brandon Rhodes
2
我经常希望不同的列具有不同的格式。以下是我如何使用一些不同的格式打印简单的二维数组，通过将NumPy数组的（切片）转换为元组：
import numpy as np
dat = np.random.random((10,11))*100 # Array of random values between 0 and 100
print(dat) # Lines get truncated and are hard to read
for i in range(10):
print((4*"%6.2f"+7*"%9.4f") % tuple(dat[i,:]))
- AstroFloyd
网页内容由stack overflow 提供, 点击上面的可以查看英文原文，
原文链接
原文链接