U
|
O ±d¢û ã @ s d Z ddddddddd g Zd
|
Zd d lZd d lZd d lZzd d lmZ W n ek
|
rf d d l mZ Y nX d d l
|
Z ddl m Z ddlmZmZmZmZ ddl mZ ddlmZmZmZmZmZmZmZ ddl m Z ddl m Z m Z m!Z! ddl m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( ddl)m*Z*m+Z+ d d l,Z,d d l-Z-d d l.Z.dddddd d d d d ej/d Z0dud!d"Z1e+d#dvd d$d%dZ2e+d#d&d Z3d'd( Z4e+d#e.j5d)d Z6dwd+d,Z7d-d. Z8d/d0 Z9d1d2 Z:d3d4 Z;d5d6 Z<dxd8d9Z=e= dyd<d=Z>dzd d$d>d?Z?e*e?d#d@d d d d:d;e j@d d d d d d;f d d$dAdZAdBdC ZBdDdE ZCdFdG ZDdHdI ZEG dJdK dKZFe+d#d{dNd ZGe+d#d|dOdZHG dPdQ dQZIG dRdS dSZJG dTdU dUZKG dVdW dWZLG dXdY dYeLZMG dZd[ d[eLZNG d\d] d]ZOG d^d_ d_ZPd`da ZQe$e%e&e'gZRdbdc ZSddde ZTd d d eAfdfdgZUd}dhdiZVe*eVd#d@d~djdZWe= dkdl ZXd d d eAfdmdnZYddodpZZe*eZd#d@ddqdZ[e\eAdreAZ]ej^eYe]dsZ_ej^eUe]dsZ`ddtdZad S )zXArray printing function
|
|
$Id: arrayprint.py,v 1.9 2005/09/13 13:58:44 teoliphant Exp $
|
|
Ú array2stringÚ array_strÚ
|
array_reprÚset_string_functionÚset_printoptionsÚget_printoptionsÚ printoptionsÚformat_float_positionalÚformat_float_scientificZrestructuredtexté N)Ú get_identé )Ú numerictypes)ÚabsoluteÚisinfÚisfiniteÚisnat)Ú
|
multiarray)ÚarrayÚdragon4_positionalÚdragon4_scientificÚdatetime_as_stringÚ datetime_dataÚndarrayÚset_legacy_print_mode)Úany)Ú concatenateÚasarrayÚerrstate)ÚlonglongÚintcÚint_Úfloat_Úcomplex_Úbool_Úflexible)Úarray_function_dispatchÚ
|
set_moduleé iè Úmaxprecé FéK ÚnanÚinfú-) Ú edgeitemsÚ thresholdÚ floatmodeÚ precisionÚsuppressÚ linewidthÚnanstrÚinfstrÚsignÚ formatterÚlegacyc
|
C s< dd t ¡ D } |dk r(t|| d< ddddg} | | dg kr^td d
|
d d | D ¡ |d krntd|
|
dkrtj| d< n<|
|
dkrd| d< n*|
|
dkr¦d| d< n|
|
dkr°ntjddd |dk rìt |t
|
j sÚt dt |¡rìtd| dk r8zt | ¡| d< W n. t k
|
r6 } zt d| W 5 d} ~ X Y nX | S ) zm
|
Make a dictionary out of the non-None arguments, plus conversion of
|
*legacy* and sanity checks.
|
c S s i | ]\}}|d k r||qS ©N© )Ú.0ÚkÚvr: r: úLd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/core/arrayprint.pyÚ
|
<dictcomp>H s z&_make_options_dict.<locals>.<dictcomp>Nr2 ÚfixedÚuniquer( Ú maxprec_equalz floatmode option must be one of ú, c s s | ]}d |¡V qdS )z"{}"N©Úformat)r; Úmr: r: r> Ú <genexpr>P s z%_make_options_dict.<locals>.<genexpr>)Nr- ú+ú z+sign option must be one of ' ', '+', or '-'Fr8 ú1.13éq ú1.21éy zGlegacy printing option can currently only be '1.13', '1.21', or `False`r' ©Ú
|
stacklevelzthreshold must be numericzIthreshold must be non-NAN, try sys.maxsize for untruncated representationr1 z precision must be an integer)ÚlocalsÚitemsÚboolÚ
|
ValueErrorÚjoinÚsysÚmaxsizeÚwarningsÚwarnÚ
|
isinstanceÚnumbersÚNumberÚ TypeErrorÚnpÚisnanÚoperatorÚindex)r1 r/ r. r3 r2 r4 r5 r6 r7 r0 r8 ÚoptionsÚmodesÚer: r: r> Ú_make_options_dict@ sB ÿ
|
|
þ
|
|
rd Únumpy©r8 c
|
C s| t | ||||||||| |
|
} || d< t | ¡ td dkrLtd dtd< n,td dkrbtd ntd tjkrxtd dS ) a
|
Set printing options.
|
|
These options determine the way floating point numbers, arrays and
|
other NumPy objects are displayed.
|
|
Parameters
|
----------
|
precision : int or None, optional
|
Number of digits of precision for floating point output (default 8).
|
May be None if `floatmode` is not `fixed`, to print as many digits as
|
necessary to uniquely specify the value.
|
threshold : int, optional
|
Total number of array elements which trigger summarization
|
rather than full repr (default 1000).
|
To always use the full repr without summarization, pass `sys.maxsize`.
|
edgeitems : int, optional
|
Number of array items in summary at beginning and end of
|
each dimension (default 3).
|
linewidth : int, optional
|
The number of characters per line for the purpose of inserting
|
line breaks (default 75).
|
suppress : bool, optional
|
If True, always print floating point numbers using fixed point
|
notation, in which case numbers equal to zero in the current precision
|
will print as zero. If False, then scientific notation is used when
|
absolute value of the smallest number is < 1e-4 or the ratio of the
|
maximum absolute value to the minimum is > 1e3. The default is False.
|
nanstr : str, optional
|
String representation of floating point not-a-number (default nan).
|
infstr : str, optional
|
String representation of floating point infinity (default inf).
|
sign : string, either '-', '+', or ' ', optional
|
Controls printing of the sign of floating-point types. If '+', always
|
print the sign of positive values. If ' ', always prints a space
|
(whitespace character) in the sign position of positive values. If
|
'-', omit the sign character of positive values. (default '-')
|
formatter : dict of callables, optional
|
If not None, the keys should indicate the type(s) that the respective
|
formatting function applies to. Callables should return a string.
|
Types that are not specified (by their corresponding keys) are handled
|
by the default formatters. Individual types for which a formatter
|
can be set are:
|
|
- 'bool'
|
- 'int'
|
- 'timedelta' : a `numpy.timedelta64`
|
- 'datetime' : a `numpy.datetime64`
|
- 'float'
|
- 'longfloat' : 128-bit floats
|
- 'complexfloat'
|
- 'longcomplexfloat' : composed of two 128-bit floats
|
- 'numpystr' : types `numpy.string_` and `numpy.unicode_`
|
- 'object' : `np.object_` arrays
|
|
Other keys that can be used to set a group of types at once are:
|
|
- 'all' : sets all types
|
- 'int_kind' : sets 'int'
|
- 'float_kind' : sets 'float' and 'longfloat'
|
- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
|
- 'str_kind' : sets 'numpystr'
|
floatmode : str, optional
|
Controls the interpretation of the `precision` option for
|
floating-point types. Can take the following values
|
(default maxprec_equal):
|
|
* 'fixed': Always print exactly `precision` fractional digits,
|
even if this would print more or fewer digits than
|
necessary to specify the value uniquely.
|
* 'unique': Print the minimum number of fractional digits necessary
|
to represent each value uniquely. Different elements may
|
have a different number of digits. The value of the
|
`precision` option is ignored.
|
* 'maxprec': Print at most `precision` fractional digits, but if
|
an element can be uniquely represented with fewer digits
|
only print it with that many.
|
* 'maxprec_equal': Print at most `precision` fractional digits,
|
but if every element in the array can be uniquely
|
represented with an equal number of fewer digits, use that
|
many digits for all elements.
|
legacy : string or `False`, optional
|
If set to the string `'1.13'` enables 1.13 legacy printing mode. This
|
approximates numpy 1.13 print output by including a space in the sign
|
position of floats and different behavior for 0d arrays. This also
|
enables 1.21 legacy printing mode (described below).
|
|
If set to the string `'1.21'` enables 1.21 legacy printing mode. This
|
approximates numpy 1.21 print output of complex structured dtypes
|
by not inserting spaces after commas that separate fields and after
|
colons.
|
|
If set to `False`, disables legacy mode.
|
|
Unrecognized strings will be ignored with a warning for forward
|
compatibility.
|
|
.. versionadded:: 1.14.0
|
.. versionchanged:: 1.22.0
|
|
See Also
|
--------
|
get_printoptions, printoptions, set_string_function, array2string
|
|
Notes
|
-----
|
`formatter` is always reset with a call to `set_printoptions`.
|
|
Use `printoptions` as a context manager to set the values temporarily.
|
|
Examples
|
--------
|
Floating point precision can be set:
|
|
>>> np.set_printoptions(precision=4)
|
>>> np.array([1.123456789])
|
[1.1235]
|
|
Long arrays can be summarised:
|
|
>>> np.set_printoptions(threshold=5)
|
>>> np.arange(10)
|
array([0, 1, 2, ..., 7, 8, 9])
|
|
Small results can be suppressed:
|
|
>>> eps = np.finfo(float).eps
|
>>> x = np.arange(4.)
|
>>> x**2 - (x + eps)**2
|
array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00])
|
>>> np.set_printoptions(suppress=True)
|
>>> x**2 - (x + eps)**2
|
array([-0., -0., 0., 0.])
|
|
A custom formatter can be used to display array elements as desired:
|
|
>>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
|
>>> x = np.arange(3)
|
>>> x
|
array([int: 0, int: -1, int: -2])
|
>>> np.set_printoptions() # formatter gets reset
|
>>> x
|
array([0, 1, 2])
|
|
To put back the default options, you can use:
|
|
>>> np.set_printoptions(edgeitems=3, infstr='inf',
|
... linewidth=75, nanstr='nan', precision=8,
|
... suppress=False, threshold=1000, formatter=None)
|
|
Also to temporarily override options, use `printoptions` as a context manager:
|
|
>>> with np.printoptions(precision=2, suppress=True, threshold=5):
|
... np.linspace(0, 10, 10)
|
array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ])
|
|
r7 r8 rK r- r6 rM r
|
N)rd Ú_format_optionsÚupdater rU rV ) r1 r/ r. r3 r2 r4 r5 r7 r6 r0 r8 Úoptr: r: r> r t s& "
|
þ
|
|
|
c C s* t ¡ } ddddtjdi| d | d< | S )a.
|
Return the current print options.
|
|
Returns
|
-------
|
print_opts : dict
|
Dictionary of current print options with keys
|
|
- precision : int
|
- threshold : int
|
- edgeitems : int
|
- linewidth : int
|
- suppress : bool
|
- nanstr : str
|
- infstr : str
|
- formatter : dict of callables
|
- sign : str
|
|
For a full description of these options, see `set_printoptions`.
|
|
See Also
|
--------
|
set_printoptions, printoptions, set_string_function
|
|
rK rJ rM rL Fr8 )rg ÚcopyrU rV )Úoptsr: r: r> r ' s ÿþc C s t d S )z'Return the legacy print mode as an int.r8 )rg r: r: r: r> Ú_get_legacy_print_modeI s rl c o s6 t ¡ }zt j| | t ¡ V W 5 t jf | X dS )a Context manager for setting print options.
|
|
Set print options for the scope of the `with` block, and restore the old
|
options at the end. See `set_printoptions` for the full description of
|
available options.
|
|
Examples
|
--------
|
|
>>> from numpy.testing import assert_equal
|
>>> with np.printoptions(precision=2):
|
... np.array([2.0]) / 3
|
array([0.67])
|
|
The `as`-clause of the `with`-statement gives the current print options:
|
|
>>> with np.printoptions(precision=2) as opts:
|
... assert_equal(opts, np.get_printoptions())
|
|
See Also
|
--------
|
set_printoptions, get_printoptions
|
|
N)r] r r )ÚargsÚkwargsrk r: r: r> r N s
|
r: c C s t |}|| jkr| | S | j| d| krjtt| ||tjd|
t| ||tj| d
f|dS t| ||tjdd
S dS )z·
|
Keep only the N-D corners (leading and trailing edges) of an array.
|
|
Should be passed a base-class ndarray, since it makes no guarantees about
|
preserving subclasses.
|
é N)Úaxis)ÚlenÚndimÚshaper Ú_leading_trailingr] Z index_exp)Úar. r` rp r: r: r> rt q s
|
þýrt c C s t | tkrd}nd}| | ¡S )z@ Object arrays containing lists should be printed unambiguously z
|
list({!r})z{!r})ÚtypeÚlistrE )ÚoÚfmtr: r: r> Ú_object_format
s rz c C s t | S r9 )Úrepr©Úxr: r: r> Ú repr_format s r~ c C s t | S r9 )Ústrr| r: r: r> Ú
|
str_format s r c s fdd fdd fdd fdd fdd fdd fdd fd dd
|
d d d d d d }dd } d k rfdd ¡ D }
|
d|
|
krà| ¡ D ]} | d || < qÊd|
|
krdD ]} | d || < qîd|
|
kr*dD ]} | d || < qd|
|
krPdD ]} | d || < q8d|
|
krj| d |d< | ¡ D ] } | |
|
krr| | || < qr|S )Nc s t S r9 )Ú
|
BoolFormatr: ©Údatar: r> Ú<lambda> ó z!_get_formatdict.<locals>.<lambda>c s t S r9 )Ú IntegerFormatr: r r: r> r r
c s t dS ©Nrf ©ÚFloatingFormatr: ©r r0 r8 r1 r6 r2 r: r> r s ÿc s t dS r r r: r r: r> r s ÿc s t dS r ©ÚComplexFloatingFormatr: r r: r> r s ÿc s t dS r r r: r r: r> r ¡ s ÿc s t dS r )ÚDatetimeFormatr: )r r8 r: r> r £ r
c s t S r9 )ÚTimedeltaFormatr: r r: r> r ¤ r
c S s t S r9 )rz r: r: r: r> r ¥ r
c S s t S r9 )r r: r: r: r> r ¦ r
c S s t S r9 )r~ r: r: r: r> r § r
) rR ÚintÚfloatÚ longfloatÚ complexfloatÚlongcomplexfloatÚdatetimeÚ timedeltaÚobjectÚvoidÚnumpystrc s fddS )Nc s S r9 r: r: r| r: r> r ¬ r
z3_get_formatdict.<locals>.indirect.<locals>.<lambda>r: r| r: r| r> Úindirect« s z!_get_formatdict.<locals>.indirectc s g | ]} | d k r|qS r9 r: )r; r< )r7 r: r> Ú
|
<listcomp>¯ s z#_get_formatdict.<locals>.<listcomp>ÚallZint_kind)r Z
|
float_kind)r r Z complex_kind)r r Zstr_kindr )Úkeys) r r1 r0 r2 r6 r8 r7 rn Ú
|
formatdictr ZfkeysÚkeyr: )r r0 r7 r8 r1 r6 r2 r> Ú_get_formatdict sB
|
|
|
ñ
|
|
|
|
|
|
r c K sX | j }|j}t| f|}|dkr*|d S t|tjr@|d S t|tjrnt|tjrb|d S |d S næt|tjrt|tj r|d S |d S n¸t|tj
|
rÊt|tj r¾|d S |d S nt|tj tj fræ|d S t|tj rþ|d
|
S t|tjr|d S t|tjrJ|jdk r>tj| f|S |d S n
|
|d S dS ) z;
|
find the right formatting function for the dtype_
|
Nr rR r r r r r r r r r )Údtyperv r Ú
|
issubclassÚ_ntr# ÚintegerZ timedelta64Zfloatingr ZcomplexfloatingZ
|
clongfloatZunicode_Zstring_Z
|
datetime64Zobject_r ÚnamesÚStructuredVoidFormatÚ from_data)r ra Zdtype_Zdtypeobjr r: r: r> Ú_get_format_functionÄ s<
|
|
|
|
|
|
|
|
r§ ú...c s fdd}|S )a
|
Like the python 3.2 reprlib.recursive_repr, but forwards *args and **kwargs
|
|
Decorates a function such that if it calls itself with the same first
|
argument, it returns `fillvalue` instead of recursing.
|
|
Largely copied from reprlib.recursive_repr
|
c s$ t t ¡ fdd}|S )Nc sJ t | t f}|krS |¡ z | f||W ¢S |¡ X d S r9 )Úidr ÚaddÚdiscard)Úselfrm rn r )ÚfÚ fillvalueÚ repr_runningr: r> Úwrapperú s
|
z>_recursive_guard.<locals>.decorating_function.<locals>.wrapper)ÚsetÚ functoolsÚwraps)r r° ©r® )r r¯ r> Údecorating_function÷ s
|
z-_recursive_guard.<locals>.decorating_functionr: )r® rµ r: r´ r> Ú_recursive_guardí s
|
r¶ rI Ú c
|
C s t | }| jdkr|} | j|d kr8d}t||d }nd}t|f|}d}|dt| 7 }t| ||d |||d ||d }|S ) Nr: r/ r¨ r. r· rI r3 r8 )r rs Úsizert r§ rq Ú _formatArray) ru ra Ú separatorÚprefixr Úsummary_insertÚformat_functionÚnext_line_prefixÚlstr: r: r> Ú _array2string s$
|
þrÀ c C s | fS r9 r: )ru Úmax_line_widthr1 Úsuppress_smallrº r» Ústyler7 r/ r. r6 r0 Úsuffixr8 r: r: r> Ú_array2string_dispatcher( s rÅ )Úmodulec C s t ||| ||dd|
|
|| | }t ¡ }| |¡ |d dkrl|tjkrHt}| jdkr| jj dkr||
|
¡ S n|tjk rt j dt dd |d dkr¦|d t| 8 < | jd kr´d
|
S t| |||S ) a
|
Return a string representation of an array.
|
|
Parameters
|
----------
|
a : ndarray
|
Input array.
|
max_line_width : int, optional
|
Inserts newlines if text is longer than `max_line_width`.
|
Defaults to ``numpy.get_printoptions()['linewidth']``.
|
precision : int or None, optional
|
Floating point precision.
|
Defaults to ``numpy.get_printoptions()['precision']``.
|
suppress_small : bool, optional
|
Represent numbers "very close" to zero as zero; default is False.
|
Very close is defined by precision: if the precision is 8, e.g.,
|
numbers smaller (in absolute value) than 5e-9 are represented as
|
zero.
|
Defaults to ``numpy.get_printoptions()['suppress']``.
|
separator : str, optional
|
Inserted between elements.
|
prefix : str, optional
|
suffix : str, optional
|
The length of the prefix and suffix strings are used to respectively
|
align and wrap the output. An array is typically printed as::
|
|
prefix + array2string(a) + suffix
|
|
The output is left-padded by the length of the prefix string, and
|
wrapping is forced at the column ``max_line_width - len(suffix)``.
|
It should be noted that the content of prefix and suffix strings are
|
not included in the output.
|
style : _NoValue, optional
|
Has no effect, do not use.
|
|
.. deprecated:: 1.14.0
|
formatter : dict of callables, optional
|
If not None, the keys should indicate the type(s) that the respective
|
formatting function applies to. Callables should return a string.
|
Types that are not specified (by their corresponding keys) are handled
|
by the default formatters. Individual types for which a formatter
|
can be set are:
|
|
- 'bool'
|
- 'int'
|
- 'timedelta' : a `numpy.timedelta64`
|
- 'datetime' : a `numpy.datetime64`
|
- 'float'
|
- 'longfloat' : 128-bit floats
|
- 'complexfloat'
|
- 'longcomplexfloat' : composed of two 128-bit floats
|
- 'void' : type `numpy.void`
|
- 'numpystr' : types `numpy.string_` and `numpy.unicode_`
|
|
Other keys that can be used to set a group of types at once are:
|
|
- 'all' : sets all types
|
- 'int_kind' : sets 'int'
|
- 'float_kind' : sets 'float' and 'longfloat'
|
- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
|
- 'str_kind' : sets 'numpystr'
|
threshold : int, optional
|
Total number of array elements which trigger summarization
|
rather than full repr.
|
Defaults to ``numpy.get_printoptions()['threshold']``.
|
edgeitems : int, optional
|
Number of array items in summary at beginning and end of
|
each dimension.
|
Defaults to ``numpy.get_printoptions()['edgeitems']``.
|
sign : string, either '-', '+', or ' ', optional
|
Controls printing of the sign of floating-point types. If '+', always
|
print the sign of positive values. If ' ', always prints a space
|
(whitespace character) in the sign position of positive values. If
|
'-', omit the sign character of positive values.
|
Defaults to ``numpy.get_printoptions()['sign']``.
|
floatmode : str, optional
|
Controls the interpretation of the `precision` option for
|
floating-point types.
|
Defaults to ``numpy.get_printoptions()['floatmode']``.
|
Can take the following values:
|
|
- 'fixed': Always print exactly `precision` fractional digits,
|
even if this would print more or fewer digits than
|
necessary to specify the value uniquely.
|
- 'unique': Print the minimum number of fractional digits necessary
|
to represent each value uniquely. Different elements may
|
have a different number of digits. The value of the
|
`precision` option is ignored.
|
- 'maxprec': Print at most `precision` fractional digits, but if
|
an element can be uniquely represented with fewer digits
|
only print it with that many.
|
- 'maxprec_equal': Print at most `precision` fractional digits,
|
but if every element in the array can be uniquely
|
represented with an equal number of fewer digits, use that
|
many digits for all elements.
|
legacy : string or `False`, optional
|
If set to the string `'1.13'` enables 1.13 legacy printing mode. This
|
approximates numpy 1.13 print output by including a space in the sign
|
position of floats and different behavior for 0d arrays. If set to
|
`False`, disables legacy mode. Unrecognized strings will be ignored
|
with a warning for forward compatibility.
|
|
.. versionadded:: 1.14.0
|
|
Returns
|
-------
|
array_str : str
|
String representation of the array.
|
|
Raises
|
------
|
TypeError
|
if a callable in `formatter` does not return a string.
|
|
See Also
|
--------
|
array_str, array_repr, set_printoptions, get_printoptions
|
|
Notes
|
-----
|
If a formatter is specified for a certain type, the `precision` keyword is
|
ignored for that type.
|
|
This is a very flexible function; `array_repr` and `array_str` are using
|
`array2string` internally so keywords with the same name should work
|
identically in all three functions.
|
|
Examples
|
--------
|
>>> x = np.array([1e-16,1,2,3])
|
>>> np.array2string(x, precision=2, separator=',',
|
... suppress_small=True)
|
'[0.,1.,2.,3.]'
|
|
>>> x = np.arange(3.)
|
>>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x})
|
'[0.00 1.00 2.00]'
|
|
>>> x = np.arange(3)
|
>>> np.array2string(x, formatter={'int':lambda x: hex(x)})
|
'[0x0 0x1 0x2]'
|
|
Nr8 rK r: zT'style' argument is deprecated and no longer functional except in 1.13 'legacy' moder' rN r3 r
|
z[])rd rg rj rh r] Ú_NoValuer{ rs r r¤ ÚitemrW rX ÚDeprecationWarningrq r¸ rÀ )ru rÁ r1 r rº r» rà r7 r/ r. r6 r0 rÄ r8 Ú overridesra r: r: r> r 1 s8 þ
|
|
|
þ
|
c C sX t |t | |k}|dkr0t |t |kr0d}|rH| | ¡ d 7 } |}||7 }| |fS )NrK FÚ
|
)rq Úrstrip)ÚsÚlineÚwordÚ
|
line_widthr¾ r8 Z
|
needs_wrapr: r: r> Ú _extendLineã s rÑ c
|
C sè | ¡ }t|dks |dkr.t| |||||S tdd |D }t|| |krt|t|kr| | ¡ d 7 } ||d }|}nt|d }||d 7 }|dd
D ] }| | ¡ d 7 } || }q¦|t|d } || d 7 }| |fS )
|
zS
|
Extends line with nicely formatted (possibly multi-line) string ``word``.
|
r rK c s s | ]}t |V qd S r9 ©rq )r; rÏ r: r: r> rG ù s z%_extendLine_pretty.<locals>.<genexpr>rË r
|
rI Néÿÿÿÿ)Ú
|
splitlinesrq rÑ ÚmaxrÌ )
|
rÍ rÎ rÏ rÐ r¾ r8 ÚwordsZmax_word_lengthÚindentZ suffix_lengthr: r: r> Ú_extendLine_prettyñ s$ ÿ
|
rØ c s6 fddzd||dW ¢S dX dS )zgformatArray is designed for two modes of operation:
|
|
1. Full output
|
|
2. Summarized output
|
|
c s¤ t | } j| }|dkr& | S |d }dkr<|}n |t d } j| }o`d |k }|rp} }
|
nd} |}
|
d} |dkr¸dkr |t ¡ } n|tt ¡ t d } |} t| D ]4}| |f ||}t| | || |\} } | 7 } qÆ|r4t| | | |\} } dkr,| d7 } n| 7 } t|
|
dd D ]8}| | f ||}t| | || |\} } | 7 } q@dkr|} | d
|
||}t| | || |\} } | | 7 } nÐd} ¡ d |d }t| D ](}| |f ||}| || | 7 } qØ|r4dkr$| | d 7 } n| | | 7 } t|
|
dd D ]*}| | f ||}| || | 7 } q@| d
|
||}| || 7 } d | t |d
d } | S )z¼
|
By using this local function, we don't need to recurse with all the
|
arguments. Since this function is not created recursively, the cost is
|
not significant
|
r
|
rI rK ú]ro r· r rC rÓ )rÓ rË z,
|
ú[N)rq rr rs rÌ rÕ ÚrangerØ rÑ )r` Úhanging_indentÚ
|
curr_widthrp Z axes_leftZnext_hanging_indentZ
|
next_widthZa_lenZ show_summaryZ leading_itemsZtrailing_itemsrÍ Z
|
elem_widthrÎ ÚirÏ Zline_sepÚnested©ru Ú
|
edge_itemsr½ r8 Úrecurserrº r¼ r: r> râ sª
|
|
|
ÿ
|
ÿ
|
|
ÿ
|
ÿ
|
|
ÿ z _formatArray.<locals>.recurserNr: )r` rÜ rÝ r: )ru r½ rÐ r¾ rº rá r¼ r8 r: rà r> r¹ s bþ
|
r¹ c C s& | d kr dS | dk r"t d |¡| S )NrÓ r
|
z{} must be >= 0)rS rE )r} Únamer: r: r> Ú_none_or_positive_arg s
|
rä c @ s0 e Zd ZdZd ddddZdd Zd d
|
ZdS ) r z' Formatter for subtypes of np.floating FNrf c C s t |tr|rdnd}|| _| jdkr<|jdkr<|dkr<d}|| _|dkrRd | _n|| _t| jd| _|| _|| _d| _ d| _
|
| |¡ d S ) NrH r- rK r: rI rA r1 F) rY rR Ú_legacyrs r0 r1 rä r r6 Ú
|
exp_formatZlarge_exponentÚ
|
fillFormat)r¬ r r1 r0 r r6 r8 r: r: r> Ú__init__ s
|
|
zFloatingFormat.__init__c s |t | }t||dk }t|dkrzt |¡}t |¡}tdd. |dksj jsp|dk sj|| dkrpd _W 5 Q R X t|dkr®d _ d _
|
d _ d _ d _ d _n¼ jrd
|
\ jd ksÒ jd krÚd \ fdd|D }tdd |D \}}} tdd |D \}
|
} tdd | D d _ d _ tdd | D _ j _ _ jd krrd _ ntdd |
|
D _ j d j _
|
nÐd
|
\ jd kr¶d \ fdd|D }tdd |D \}
|
} jd krdtdd |
|
D _ ntd d |
|
D _ td d | D _
|
d _ _ jd kr^ j
|
_ _d _ n d _ d _ jd kr jd kr tt |¡s j d7 _ |j|jkr jd kpÌt|t| dk } ttd! } ttd" | } j
|
d }t j | | || _ d S )#Nr
|
Úignore)Zoverg ×Ag-C ëâ6?g @@TÚ.rÓ )rê Tr@ rK )r< Fc 3 s( | ] }t | j jd kdV qdS )rH )r1 rA Útrimr6 N)r r1 r6 ©r; r} ©r¬ rë rA r: r> rG À s þ ÿz,FloatingFormat.fillFormat.<locals>.<genexpr>c s s | ]}| d ¡V qdS )rc N)Ú partition©r; rÍ r: r: r> rG Ã s c s s | ]}| d ¡V qdS ©rê N©Úsplitrï r: r: r> rG Ä s c s s | ]}t |V qd S r9 rÒ rï r: r: r> rG Å s r r< c s s | ]}t |V qd S r9 rÒ rï r: r: r> rG È s r' c s s | ]}t |V qd S r9 rÒ rï r: r: r> rG Ñ s ro c 3 s* | ]"}t | jd jdkdV qdS )TrH )r1 Ú
|
fractionalrA rë r6 N)r r1 r6 rì rí r: r> rG Ø s ü ýc s s | ]}| d ¡V qdS rð rñ rï r: r: r> rG Ý s c s s | ]}t | d ¡V qdS )z-+N)rq Úlstriprï r: r: r> rG ß s c s s | ]}t |V qd S r9 rÒ rï r: r: r> rG á s c s s | ]}t |V qd S r9 rÒ rï r: r: r> rG â s )r@ rB rI r- r4 r5 )r r rq r] rÕ Úminr r ræ Úpad_leftÚ pad_rightrë Úexp_sizerA Ú
|
min_digitsr0 rå Úzipr1 r6 r Zsignbitr¸ r rg )r¬ r Z finite_valsZ abs_non_zeroZmax_valZmin_valÚstrsZ frac_strsÚ_Zexp_strsZint_partZ frac_partZneginfZnanlenZinflenÚoffsetr: rí r> rç ¦ s
|
|
ÿ
|
ÿ
|
þ ü
|
zFloatingFormat.fillFormatc C sü t |¡stdd t |¡r@| jdkr.dnd}|td }n*|dk rLdn| jdkrZdnd}|td }d | j| j d
|
t| | W 5 Q R £ S Q R X | j rÌt
|
|| j | j | j | j| jdk| j| jd S t|| j | j | j d | j| jdk| j| jd S d S )Nré )ÚinvalidrH r· r4 r
|
r- r5 rI r )r1 rù rA rë r6 rö Ú
|
exp_digitsT)r1 rù rA ró rë r6 rö r÷ )r] r r r^ r6 rg rö r÷ rq ræ r r1 rù rA rë rø r )r¬ r} r6 Úretr: r: r> Ú__call__ú s8
|
|
2ù øzFloatingFormat.__call__)F)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__rè rç r r: r: r: r> r s ÿ Tr Tr< c
|
C s` t |d}t |d}t |d}t |d}|dkrH|dkrH||krHtdt| |||||||dS )aì
|
|
Format a floating-point scalar as a decimal string in scientific notation.
|
|
Provides control over rounding, trimming and padding. Uses and assumes
|
IEEE unbiased rounding. Uses the "Dragon4" algorithm.
|
|
Parameters
|
----------
|
x : python float or numpy floating scalar
|
Value to format.
|
precision : non-negative integer or None, optional
|
Maximum number of digits to print. May be None if `unique` is
|
`True`, but must be an integer if unique is `False`.
|
unique : boolean, optional
|
If `True`, use a digit-generation strategy which gives the shortest
|
representation which uniquely identifies the floating-point number from
|
other values of the same type, by judicious rounding. If `precision`
|
is given fewer digits than necessary can be printed. If `min_digits`
|
is given more can be printed, in which cases the last digit is rounded
|
with unbiased rounding.
|
If `False`, digits are generated as if printing an infinite-precision
|
value and stopping after `precision` digits, rounding the remaining
|
value with unbiased rounding
|
trim : one of 'k', '.', '0', '-', optional
|
Controls post-processing trimming of trailing digits, as follows:
|
|
* 'k' : keep trailing zeros, keep decimal point (no trimming)
|
* '.' : trim all trailing zeros, leave decimal point
|
* '0' : trim all but the zero before the decimal point. Insert the
|
zero if it is missing.
|
* '-' : trim trailing zeros and any trailing decimal point
|
sign : boolean, optional
|
Whether to show the sign for positive values.
|
pad_left : non-negative integer, optional
|
Pad the left side of the string with whitespace until at least that
|
many characters are to the left of the decimal point.
|
exp_digits : non-negative integer, optional
|
Pad the exponent with zeros until it contains at least this many digits.
|
If omitted, the exponent will be at least 2 digits.
|
min_digits : non-negative integer or None, optional
|
Minimum number of digits to print. This only has an effect for
|
`unique=True`. In that case more digits than necessary to uniquely
|
identify the value may be printed and rounded unbiased.
|
|
-- versionadded:: 1.21.0
|
|
Returns
|
-------
|
rep : string
|
The string representation of the floating point value
|
|
See Also
|
--------
|
format_float_positional
|
|
Examples
|
--------
|
>>> np.format_float_scientific(np.float32(np.pi))
|
'3.1415927e+00'
|
>>> s = np.float32(1.23e24)
|
>>> np.format_float_scientific(s, unique=False, precision=15)
|
'1.230000071797338e+24'
|
>>> np.format_float_scientific(s, exp_digits=4)
|
'1.23e+0024'
|
r1 rö rÿ rù r
|
ú2min_digits must be less than or equal to precision)r1 rA rë r6 rö rÿ rù )rä rS r )r} r1 rA rë r6 rö rÿ rù r: r: r> r s E
|
|
|
|
þc C sv t |d}t |d}t |d}t |d}|s<|dkr<td|dkr\|dkr\||kr\tdt| ||||||||d S ) a
|
Format a floating-point scalar as a decimal string in positional notation.
|
|
Provides control over rounding, trimming and padding. Uses and assumes
|
IEEE unbiased rounding. Uses the "Dragon4" algorithm.
|
|
Parameters
|
----------
|
x : python float or numpy floating scalar
|
Value to format.
|
precision : non-negative integer or None, optional
|
Maximum number of digits to print. May be None if `unique` is
|
`True`, but must be an integer if unique is `False`.
|
unique : boolean, optional
|
If `True`, use a digit-generation strategy which gives the shortest
|
representation which uniquely identifies the floating-point number from
|
other values of the same type, by judicious rounding. If `precision`
|
is given fewer digits than necessary can be printed, or if `min_digits`
|
is given more can be printed, in which cases the last digit is rounded
|
with unbiased rounding.
|
If `False`, digits are generated as if printing an infinite-precision
|
value and stopping after `precision` digits, rounding the remaining
|
value with unbiased rounding
|
fractional : boolean, optional
|
If `True`, the cutoffs of `precision` and `min_digits` refer to the
|
total number of digits after the decimal point, including leading
|
zeros.
|
If `False`, `precision` and `min_digits` refer to the total number of
|
significant digits, before or after the decimal point, ignoring leading
|
zeros.
|
trim : one of 'k', '.', '0', '-', optional
|
Controls post-processing trimming of trailing digits, as follows:
|
|
* 'k' : keep trailing zeros, keep decimal point (no trimming)
|
* '.' : trim all trailing zeros, leave decimal point
|
* '0' : trim all but the zero before the decimal point. Insert the
|
zero if it is missing.
|
* '-' : trim trailing zeros and any trailing decimal point
|
sign : boolean, optional
|
Whether to show the sign for positive values.
|
pad_left : non-negative integer, optional
|
Pad the left side of the string with whitespace until at least that
|
many characters are to the left of the decimal point.
|
pad_right : non-negative integer, optional
|
Pad the right side of the string with whitespace until at least that
|
many characters are to the right of the decimal point.
|
min_digits : non-negative integer or None, optional
|
Minimum number of digits to print. Only has an effect if `unique=True`
|
in which case additional digits past those necessary to uniquely
|
identify the value may be printed, rounding the last additional digit.
|
|
-- versionadded:: 1.21.0
|
|
Returns
|
-------
|
rep : string
|
The string representation of the floating point value
|
|
See Also
|
--------
|
format_float_scientific
|
|
Examples
|
--------
|
>>> np.format_float_positional(np.float32(np.pi))
|
'3.1415927'
|
>>> np.format_float_positional(np.float16(np.pi))
|
'3.14'
|
>>> np.format_float_positional(np.float16(0.3))
|
'0.3'
|
>>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
|
'0.3000488281'
|
r1 rö r÷ rù r
|
z4precision must be greater than 0 if fractional=Falser )r1 rA ró rë r6 rö r÷ rù )rä rS r ) r} r1 rA ró rë r6 rö r÷ rù r: r: r> r j s M
|
|
|
|
ýc @ s e Zd Zdd Zdd ZdS )r c C sF |j dkr2tttt |¡ttt |¡}nd}d |¡| _d S )Nr
|
z%{}d)r¸ rÕ rq r r] rõ rE )r¬ r Ú max_str_lenr: r: r> rè Ç s
|
ÿzIntegerFormat.__init__c C s
|
| j | S r9 rD ©r¬ r} r: r: r> r Ï s zIntegerFormat.__call__N©r r r rè r r: r: r: r> r Æ s r c @ s e Zd Zdd Zdd ZdS )r c K s |j dkrdnd| _d S )Nr: z TrueÚTrue)rs Útruestr)r¬ r rn r: r: r> rè Ô s zBoolFormat.__init__c C s |r
|
| j S dS )NÚFalse)r r r: r: r> r Ù s zBoolFormat.__call__Nr r: r: r: r> r Ó s r c @ s( e Zd ZdZd ddddZdd ZdS )
|
r z. Formatter for subtypes of np.complexfloating FNrf c C sb t |tr|rdnd}| }}|dkr.d}d}t|j|||||d| _t|j|||d|d| _d S )NrH r- rK rB r( )r6 r8 )rY rR r ÚrealÚ real_formatÚimagÚ imag_format) r¬ r} r1 r0 r r6 r8 Zfloatmode_realZfloatmode_imagr: r: r> rè ß s,
|
þ þz ComplexFloatingFormat.__init__c C sH | |j¡}| |j¡}t| ¡ }|d |
d ||d
}|| S )NÚj)r r r r rq rÌ )r¬ r} ÚrrÞ Úspr: r: r> r ó s
|
z ComplexFloatingFormat.__call__)F)r r r r rè r r: r: r: r> r Ý s ÿÿ r c @ s$ e Zd Zdd Zdd Zdd ZdS )Ú_TimelikeFormatc C s~ |t | }t|dkrFtt| t |¡¡t| t |¡¡}nd}t||jk rbt|d}d |¡| _d |¡| _
|
d S )Nr
|
é z%{}sz'NaT') r rq rÕ Ú_format_non_natr] rõ r¸ rE Ú_formatÚrjustÚ_nat)r¬ r Znon_natr r: r: r> rè ÿ s ÿ
|
z_TimelikeFormat.__init__c C s t d S r9 )ÚNotImplementedErrorr r: r: r> r s z _TimelikeFormat._format_non_natc C s" t |r| jS | j| |¡ S d S r9 )r r r r r r: r: r> r s z_TimelikeFormat.__call__N)r r r rè r r r: r: r: r> r þ s r c s2 e Zd Zd
|
fdd Z fddZdd Z ZS ) r NÚ same_kindFc s\ |d kr(|j jdkr$t|j d }nd}|d kr4d}|| _|| _|| _|| _t |¡ d S )NÚMr
|
rÍ Znaive) r Úkindr ÚtimezoneÚunitÚcastingr8 Úsuperrè )r¬ r} r r r r8 ©Ú __class__r: r> rè s zDatetimeFormat.__init__c s | j dkr| |¡S t |¡S )NrK )r8 r r! r r r" r: r> r , s
|
|
zDatetimeFormat.__call__c C s dt || j| j| jd S )Nú'%s')r r r )r r r r r r: r: r> r 1 s
|
ýz DatetimeFormat._format_non_nat)NNr F)r r r rè r r Ú __classcell__r: r: r" r> r s
|
ÿ r c @ s e Zd Zdd ZdS )r c C s t | d¡S )NÚi8)r Zastyper r: r: r> r 9 s z TimedeltaFormat._format_non_natN)r r r r r: r: r: r> r 8 s r c @ s e Zd Zdd Zdd ZdS )ÚSubArrayFormatc C s
|
|| _ d S r9 ©r½ )r¬ r½ r: r: r> rè > s zSubArrayFormat.__init__c sJ |j dkr*dd fdd|D ¡ d S dd fdd|D ¡ d S )Nr rÚ rC c 3 s | ]} |¡V qd S r9 r( ©r; ru ©r¬ r: r> rG C s z*SubArrayFormat.__call__.<locals>.<genexpr>rÙ c 3 s | ]} |¡V qd S r9 )r r) r* r: r> rG D s )rr rT )r¬ Úarrr: r* r> r A s
|
zSubArrayFormat.__call__Nr r: r: r: r> r' = s r' c @ s, e Zd ZdZdd Zedd Zdd ZdS ) r¥ zô
|
Formatter for structured np.void objects.
|
|
This does not work on structured alias types like np.dtype(('i4', 'i2,i2')),
|
as alias scalars lose their field information, and the implementation
|
relies upon np.void.__getitem__.
|
c C s
|
|| _ d S r9 )Úformat_functions)r¬ r, r: r: r> rè O s z StructuredVoidFormat.__init__c K sL g }|j jD ]6}t|| f|}|j | jdkr8t|}| |¡ q | |S )z¢
|
This is a second way to initialize StructuredVoidFormat, using the raw data
|
as input. Added to avoid changing the signature of __init__.
|
r: )r r¤ r§ rs r' Úappend)Úclsr ra r, Ú
|
field_namer½ r: r: r> r¦ R s z StructuredVoidFormat.from_datac C sD dd t || jD }t|dkr0d |d ¡S d d |¡¡S d S )Nc S s g | ]\}}||qS r: r: )r; Úfieldr½ r: r: r> r a s ÿz1StructuredVoidFormat.__call__.<locals>.<listcomp>r z({},)r
|
z({})rC )rú r, rq rE rT )r¬ r} Z
|
str_fieldsr: r: r> r ` s
|
þ z StructuredVoidFormat.__call__N)r r r r rè Ú classmethodr¦ r r: r: r: r> r¥ G s
|
|
r¥ c C s t jt| ft| S )z½
|
Implements the repr for structured-void scalars. It is called from the
|
scalartypes.c.src code, and is placed here because it uses the elementwise
|
formatters defined above.
|
)r¥ r¦ r rg r| r: r: r> Ú_void_scalar_reprk s r2 c C s< t | ¡} td dkr$| jtkr$dS | jdk r2dS | jtkS )a
|
Determine if the given dtype is implied by the representation of its values.
|
|
Parameters
|
----------
|
dtype : dtype
|
Data type
|
|
Returns
|
-------
|
implied : bool
|
True if the dtype is implied by the representation of its values.
|
|
Examples
|
--------
|
>>> np.core.arrayprint.dtype_is_implied(int)
|
True
|
>>> np.array([1, 2, 3], int)
|
array([1, 2, 3])
|
>>> np.core.arrayprint.dtype_is_implied(np.int8)
|
False
|
>>> np.array([1, 2, 3], np.int8)
|
array([1, 2, 3], dtype=int8)
|
r8 rK FN)r] r rg rv r# r¤ Ú _typelessdata)r r: r: r> Údtype_is_impliedw s
|
|
r4 c C sn t | jtjjkrt| S | jdk r,t| S t| j trDdt| S | j }|rj|d
|
¡ rb| ¡ sjt|}|S )zñ
|
Convert a dtype to a short form which evaluates to the same dtype.
|
|
The intent is roughly that the following holds
|
|
>>> from numpy import *
|
>>> dt = np.int64([1, 2]).dtype
|
>>> assert eval(dtype_short_repr(dt)) == dt
|
Nr$ r
|
) rv Ú__repr__r] r r{ r¤ r r¡ r$ rã ÚisalphaÚisalnum)r Útypenamer: r: r> Údtype_short_repr s
|
|
r9 c C sd |dkrt d }t| tk r(t| j}nd}t| jo>| jdk}|d }|rPdnd}t d d kr| jd
|
kr| jjst |
|
¡ } n<| jdks| jd kr¬|| |||d ||d } ndt | jf } || | }
|
|rÐ|
|
S d t | j¡} t |
|
|
|
d¡d } d} t d d kr.t| jjtrXddt |d } n*| t | d |krXddt |d } |
|
| | S )zEInternal version of array_repr() that allows overriding array2string.Nr3 r r
|
ú(ú)ú,r8 rK r: )r
|
rC )rÄ z [], shape=%sz dtype={})rË r rI )rg rv r r r4 r r¸ rs r¤ r{ rÈ rE r9 rq Úrfindr¡ r$ )r+ rÁ r1 r r Ú
|
class_nameZ skipdtyper» rÄ r¿ Zarr_strZ dtype_strZ last_line_lenZspacerr: r: r> Ú_array_repr_implementation· sB ÿÿ
|
ÿ r? c C s | fS r9 r: ©r+ rÁ r1 r r: r: r> Ú_array_repr_dispatcheræ s rA c C s t | |||S )a
|
Return the string representation of an array.
|
|
Parameters
|
----------
|
arr : ndarray
|
Input array.
|
max_line_width : int, optional
|
Inserts newlines if text is longer than `max_line_width`.
|
Defaults to ``numpy.get_printoptions()['linewidth']``.
|
precision : int, optional
|
Floating point precision.
|
Defaults to ``numpy.get_printoptions()['precision']``.
|
suppress_small : bool, optional
|
Represent numbers "very close" to zero as zero; default is False.
|
Very close is defined by precision: if the precision is 8, e.g.,
|
numbers smaller (in absolute value) than 5e-9 are represented as
|
zero.
|
Defaults to ``numpy.get_printoptions()['suppress']``.
|
|
Returns
|
-------
|
string : str
|
The string representation of an array.
|
|
See Also
|
--------
|
array_str, array2string, set_printoptions
|
|
Examples
|
--------
|
>>> np.array_repr(np.array([1,2]))
|
'array([1, 2])'
|
>>> np.array_repr(np.ma.array([0.]))
|
'MaskedArray([0.])'
|
>>> np.array_repr(np.array([], np.int32))
|
'array([], dtype=int32)'
|
|
>>> x = np.array([1e-6, 4e-7, 2, 3])
|
>>> np.array_repr(x, precision=6, suppress_small=True)
|
'array([0.000001, 0. , 2. , 3. ])'
|
|
)r? r@ r: r: r> r ë s - ÿc C s t | trt| S t| S r9 )rY Úbytesr{ r )r= r: r: r> Ú_guarded_repr_or_str s
|
rC c C sX t d dkr*| jdkr*| jjs*t| ¡ S | jdkrFttj | d¡S || |||ddS )zDInternal version of array_str() that allows overriding array2string.r8 rK r: rI r· )
|
rg rs r r¤ r rÈ rC r] r Ú __getitem__)ru rÁ r1 r r r: r: r> Ú_array_str_implementation# s ÿÿ
|
rE c C s | fS r9 r: ©ru rÁ r1 r r: r: r> Ú_array_str_dispatcher7 s rG c C s t | |||S )aa
|
Return a string representation of the data in an array.
|
|
The data in the array is returned as a single string. This function is
|
similar to `array_repr`, the difference being that `array_repr` also
|
returns information on the kind of array and its data type.
|
|
Parameters
|
----------
|
a : ndarray
|
Input array.
|
max_line_width : int, optional
|
Inserts newlines if text is longer than `max_line_width`.
|
Defaults to ``numpy.get_printoptions()['linewidth']``.
|
precision : int, optional
|
Floating point precision.
|
Defaults to ``numpy.get_printoptions()['precision']``.
|
suppress_small : bool, optional
|
Represent numbers "very close" to zero as zero; default is False.
|
Very close is defined by precision: if the precision is 8, e.g.,
|
numbers smaller (in absolute value) than 5e-9 are represented as
|
zero.
|
Defaults to ``numpy.get_printoptions()['suppress']``.
|
|
See Also
|
--------
|
array2string, array_repr, set_printoptions
|
|
Examples
|
--------
|
>>> np.array_str(np.arange(3))
|
'[0 1 2]'
|
|
)rE rF r: r: r> r < s $ ÿÚ __wrapped__)r c C s6 | dkr&|rt td¡S t td¡S n t | |¡S dS )aù
|
Set a Python function to be used when pretty printing arrays.
|
|
Parameters
|
----------
|
f : function or None
|
Function to be used to pretty print arrays. The function should expect
|
a single array argument and return a string of the representation of
|
the array. If None, the function is reset to the default NumPy function
|
to print arrays.
|
repr : bool, optional
|
If True (default), the function for pretty printing (``__repr__``)
|
is set, if False the function that returns the default string
|
representation (``__str__``) is set.
|
|
See Also
|
--------
|
set_printoptions, get_printoptions
|
|
Examples
|
--------
|
>>> def pprint(arr):
|
... return 'HA! - What are you going to do now?'
|
...
|
>>> np.set_string_function(pprint)
|
>>> a = np.arange(10)
|
>>> a
|
HA! - What are you going to do now?
|
>>> _ = a
|
>>> # [0 1 2 3 4 5 6 7 8 9]
|
|
We can reset the function to the default:
|
|
>>> np.set_string_function(None)
|
>>> a
|
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
|
`repr` affects either pretty printing or normal string representation.
|
Note that ``__repr__`` is still affected by setting ``__str__``
|
because the width of each array element in the returned string becomes
|
equal to the length of the result of ``__str__()``.
|
|
>>> x = np.arange(4)
|
>>> np.set_string_function(lambda x:'random', repr=False)
|
>>> x.__str__()
|
'random'
|
>>> x.__repr__()
|
'array([0, 1, 2, 3])'
|
|
Nr r
|
)r r Ú_default_array_reprÚ_default_array_str)r r{ r: r: r> r l s
|
3 ) NNNNNNNNNNN)
|
NNNNNNNNNN)r: )r¨ )rI r· ) NNNNNNNNNNNN)NTr< FNNN)NTTr< FNNN)NNN)NNN)NNN)NNN)T)br Ú__all__Z __docformat__r² rZ rU Ú_threadr Ú ImportErrorÚ _dummy_threadre r] r· r r¢ Zumathr r r r r r r r r r r r Z fromnumericr Únumericr r r r r r r! r" r# r$ rÊ r% r& r_ rW Ú
|
contextlibrV rg rd r r rl Úcontextmanagerr rt rz r~ r r r§ r¶ rÀ rÅ rÇ r rÑ rØ r¹ rä r r r r r r r r r r' r¥ r2 r3 r4 r9 r? rA r rC rE rG r ÚgetattrZ_array2string_implÚpartialrJ rI r r: r: r: r> Ú<module> s\ þ $ $ó þ
|
4 þþ 3
|
! !
|
1)
|
üû
|
ýü 2v þ O þ [
|
!
|
$ $ þ
|
0 ÿ
|
|
0
|
þ
|
ÿ
|
|
( ÿÿ
|
