วิธีการพิมพ์ numpy.array โดยไม่ต้องใช้สัญลักษณ์ทางวิทยาศาสตร์และด้วยความแม่นยำที่ได้รับ?


332

ฉันอยากรู้ว่ามีวิธีการจัดรูปแบบการพิมพ์numpy.arraysเช่นในลักษณะที่คล้ายกับนี้หรือไม่:

x = 1.23456
print '%.3f' % x

ถ้าฉันต้องการที่จะพิมพ์numpy.arrayของลอยมันพิมพ์ทศนิยมหลายครั้งมักจะอยู่ในรูปแบบ 'ทางวิทยาศาสตร์' ซึ่งค่อนข้างยากที่จะอ่านแม้สำหรับอาร์เรย์มิติต่ำ แต่เห็นได้ชัดว่าจะต้องมีการพิมพ์เป็นสตริงคือมีnumpy.array %sมีวิธีแก้ปัญหาสำหรับเรื่องนี้หรือไม่?


การสนทนานี้อาจทำให้คนที่สนใจจบลงที่นี่ด้วยการค้นหาโดย Google
โหลด

คำตอบ:


558

คุณสามารถใช้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. ]

ดูเอกสารสำหรับ set_printoptionsสำหรับตัวเลือกอื่น ๆ


หากต้องการใช้ตัวเลือกการพิมพ์ในเครื่องโดยใช้ 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]

มีวิธีในการใช้การจัดรูปแบบเฉพาะกับคำสั่งการพิมพ์เฉพาะ (ตรงข้ามกับการตั้งค่ารูปแบบเอาต์พุตทั่วไปที่ใช้โดยคำสั่งการพิมพ์ทั้งหมด ) หรือไม่
bph

7
@Hiett: ไม่มีฟังก์ชั่น NumPy ในการตั้งค่าตัวเลือกการพิมพ์เพียงตัวเดียวprintแต่คุณสามารถใช้ตัวจัดการบริบทเพื่อทำสิ่งที่คล้ายกันได้ ฉันได้แก้ไขโพสต์ด้านบนเพื่อแสดงความหมายของฉัน
unutbu

2
คุณ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]อย่างไร?
Norfeldt

2
@Norfeldt: ฉันได้เพิ่มวิธีการดังกล่าวข้างต้น
unutbu

1
มันใช้งานได้ดี ตามบันทึกข้างคุณยังสามารถใช้ถ้าคุณต้องการแสดงสตริงและไม่จำเป็นต้องใช้set_printoptions printคุณสามารถเรียก__str__()ใช้อินสแตนซ์ของอาร์เรย์ numpy และคุณจะได้รับสตริงที่จัดรูปแบบตามตัวพิมพ์ที่คุณตั้งค่า
Jayesh

40

คุณสามารถรับnp.set_printoptionsฟังก์ชั่นย่อยจากnp.array_strคำสั่งซึ่งใช้กับคำสั่งพิมพ์เดียวเท่านั้น

http://docs.scipy.org/doc/numpy/reference/generated/numpy.array_str.html

ตัวอย่างเช่น:

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

37

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

15

FYI Numpy 1.15 (วันที่รอการอนุมัติ) จะรวมตัวจัดการบริบทสำหรับการตั้งค่าตัวเลือกการพิมพ์ในเครื่อง ซึ่งหมายความว่าสิ่งต่อไปนี้จะทำงานเหมือนกับตัวอย่างที่สอดคล้องกันในคำตอบที่ยอมรับ (โดย unutbu และ Neil G) โดยไม่ต้องเขียนตัวจัดการบริบทของคุณเอง เช่นใช้ตัวอย่าง:

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]

12

อัญมณีที่ทำให้ทุกอย่างง่ายเกินไปที่จะได้รับผลลัพธ์ในฐานะสตริง (ในเวอร์ชัน numpy ของวันนี้) ถูกซ่อนอยู่ในคำตอบที่ปฏิเสธ: 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]'

8

หลายปีต่อมาอีกอันอยู่ข้างล่าง แต่สำหรับการใช้งานทุกวันฉันแค่

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

'''
# http://stackoverflow.com/questions/2891790/pretty-printing-of-numpy-array


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

6

และนี่คือสิ่งที่ฉันใช้และมันค่อนข้างไม่ซับซ้อน:

print(np.vectorize("%.2f".__mod__)(sparse))

3

รู้สึกประหลาดใจที่ไม่เห็น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]]

2

ฉันต้องการคอลัมน์ที่แตกต่างกันเพื่อให้มีรูปแบบที่แตกต่างกัน นี่คือวิธีที่ฉันพิมพ์อาเรย์สองมิติแบบง่าย ๆ โดยใช้ความหลากหลายในการจัดรูปแบบโดยการแปลงอาเรย์ NumPy ของฉันให้เป็น tuple:

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

1

numpy.char.modอาจมีประโยชน์ขึ้นอยู่กับรายละเอียดของแอปพลิเคชันของคุณเช่น: numpy.char.mod('Value=%4.2f', numpy.arange(5, 10, 0.1))จะส่งคืนอาร์เรย์สตริงที่มีองค์ประกอบ "Value = 5.00", "Value = 5.10" เป็นต้น


1

อาร์เรย์ numpy มีวิธีการround(precision)ที่ส่งกลับอาร์เรย์ numpy ใหม่ที่มีองค์ประกอบกลมตาม

import numpy as np

x = np.random.random([5,5])
print(x.round(3))

1
สิ่งนี้ใช้ได้ผลสำหรับฉันเมื่อผ่านอาร์เรย์ไปยัง matplotlib ylabel ขอบคุณ
Hans

1

ฉันพบว่ารูปแบบลอยปกติ {: 9.5f} ทำงานได้อย่างถูกต้อง - ระงับการแสดงข้อความอิเล็กทรอนิกส์มูลค่าเล็กน้อยเมื่อแสดงรายการหรืออาร์เรย์โดยใช้ลูป แต่รูปแบบนั้นบางครั้งก็ไม่สามารถยับยั้งสัญลักษณ์อิเล็กทรอนิกส์ได้เมื่อตัวจัดรูปแบบมีหลายรายการในคำสั่งพิมพ์เดียว ตัวอย่างเช่น:

import numpy as np
np.set_printoptions(suppress=True)
a3 = 4E-3
a4 = 4E-4
a5 = 4E-5
a6 = 4E-6
a7 = 4E-7
a8 = 4E-8
#--first, display separate numbers-----------
print('Case 3:  a3, a4, a5:             {:9.5f}{:9.5f}{:9.5f}'.format(a3,a4,a5))
print('Case 4:  a3, a4, a5, a6:         {:9.5f}{:9.5f}{:9.5f}{:9.5}'.format(a3,a4,a5,a6))
print('Case 5:  a3, a4, a5, a6, a7:     {:9.5f}{:9.5f}{:9.5f}{:9.5}{:9.5f}'.format(a3,a4,a5,a6,a7))
print('Case 6:  a3, a4, a5, a6, a7, a8: {:9.5f}{:9.5f}{:9.5f}{:9.5f}{:9.5}{:9.5f}'.format(a3,a4,a5,a6,a7,a8))
#---second, display a list using a loop----------
myList = [a3,a4,a5,a6,a7,a8]
print('List 6:  a3, a4, a5, a6, a7, a8: ', end='')
for x in myList: 
    print('{:9.5f}'.format(x), end='')
print()
#---third, display a numpy array using a loop------------
myArray = np.array(myList)
print('Array 6: a3, a4, a5, a6, a7, a8: ', end='')
for x in myArray:
    print('{:9.5f}'.format(x), end='')
print()

ผลลัพธ์ของฉันแสดงข้อผิดพลาดในกรณี 4, 5 และ 6:

Case 3:  a3, a4, a5:               0.00400  0.00040  0.00004
Case 4:  a3, a4, a5, a6:           0.00400  0.00040  0.00004    4e-06
Case 5:  a3, a4, a5, a6, a7:       0.00400  0.00040  0.00004    4e-06  0.00000
Case 6:  a3, a4, a5, a6, a7, a8:   0.00400  0.00040  0.00004  0.00000    4e-07  0.00000
List 6:  a3, a4, a5, a6, a7, a8:   0.00400  0.00040  0.00004  0.00000  0.00000  0.00000
Array 6: a3, a4, a5, a6, a7, a8:   0.00400  0.00040  0.00004  0.00000  0.00000  0.00000

ฉันไม่มีคำอธิบายเกี่ยวกับเรื่องนี้และดังนั้นฉันมักจะใช้วนรอบสำหรับเอาท์พุทแบบลอยตัวของค่าหลายค่า


1

ฉันใช้

def np_print(array,fmt="10.5f"):
    print (array.size*("{:"+fmt+"}")).format(*array)

การปรับเปลี่ยนมันไม่ยากสำหรับอาร์เรย์หลายมิติ


0

อีกตัวเลือกหนึ่งคือการใช้decimalโมดูล:

import numpy as np
from decimal import *

arr = np.array([  56.83,  385.3 ,    6.65,  126.63,   85.76,  192.72,  112.81, 10.55])
arr2 = [str(Decimal(i).quantize(Decimal('.01'))) for i in arr]

# ['56.83', '385.30', '6.65', '126.63', '85.76', '192.72', '112.81', '10.55']
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.