NumPy参考 > 通用功能（ufunc）
A universal function (or ufunc for short) is a function that
operates on ndarrays
in an elementbyelement fashion,
supporting array broadcasting, type
casting, and several other standard features. That
is, a ufunc is a “vectorized” wrapper for a function that
takes a fixed number of specific inputs and produces a fixed number of
specific outputs.
In NumPy, universal functions are instances of the
numpy.ufunc
class. Many of the builtin functions are
implemented in compiled C code. The basic ufuncs operate on scalars, but
there is also a generalized kind for which the basic elements are subarrays
(vectors, matrices, etc.), and broadcasting is done over other dimensions.
One can also produce custom ufunc
instances using the
frompyfunc
factory function.
Each universal function takes array inputs and produces array outputs by performing the core function elementwise on the inputs (where an element is generally a scalar, but can be a vector or higherorder subarray for generalized ufuncs). Standard broadcasting rules are applied so that inputs not sharing exactly the same shapes can still be usefully operated on. Broadcasting can be understood by four rules:
All input arrays with ndim
smaller than the
input array of largest ndim
, have 1’s
prepended to their shapes.
The size in each dimension of the output shape is the maximum of all the input sizes in that dimension.
An input can be used in the calculation if its size in a particular dimension either matches the output size in that dimension, or has value exactly 1.
If an input has a dimension size of 1 in its shape, the first data entry in that dimension will be used for all calculations along that dimension. In other words, the stepping machinery of the ufunc will simply not step along that dimension (the stride will be 0 for that dimension).
Broadcasting is used throughout NumPy to decide how to handle
disparately shaped arrays; for example, all arithmetic operations (+
,

, *
, …) between ndarrays
broadcast the
arrays before operation.
A set of arrays is called “broadcastable” to the same shape if the above rules produce a valid result, i.e., one of the following is true:
The arrays all have exactly the same shape.
The arrays all have the same number of dimensions and the length of each dimensions is either a common length or 1.
The arrays that have too few dimensions can have their shapes prepended with a dimension of length 1 to satisfy property 2.
Example
If a.shape
is (5,1), b.shape
is (1,6), c.shape
is (6,)
and d.shape
is () so that d is a scalar, then a, b, c,
and d are all broadcastable to dimension (5,6); and
a acts like a (5,6) array where a[:,0]
is broadcast to the other
columns,
b acts like a (5,6) array where b[0,:]
is broadcast
to the other rows,
c acts like a (1,6) array and therefore like a (5,6) array
where c[:]
is broadcast to every row, and finally,
d acts like a (5,6) array where the single value is repeated.
The output of the ufunc (and its methods) is not necessarily an
ndarray
, if all input arguments are not ndarrays
.
Indeed, if any input defines an __array_ufunc__
method,
control will be passed completely to that function, i.e., the ufunc is
overridden.
If none of the inputs overrides the ufunc, then
all output arrays will be passed to the __array_prepare__
and
__array_wrap__
methods of the input (besides
ndarrays
, and scalars) that defines it and has
the highest __array_priority__
of any other input to the
universal function. The default __array_priority__
of the
ndarray is 0.0, and the default __array_priority__
of a subtype
is 0.0. Matrices have __array_priority__
equal to 10.0.
All ufuncs can also take output arguments. If necessary, output will
be cast to the datatype(s) of the provided output array(s). If a class
with an __array__
method is used for the output, results will be
written to the object returned by __array__
. Then, if the class
also has an __array_prepare__
method, it is called so metadata
may be determined based on the context of the ufunc (the context
consisting of the ufunc itself, the arguments passed to the ufunc, and
the ufunc domain.) The array object returned by
__array_prepare__
is passed to the ufunc for computation.
Finally, if the class also has an __array_wrap__
method, the returned
ndarray
result will be passed to that method just before
passing control back to the caller.
Internally, buffers are used for misaligned data, swapped data, and data that has to be converted from one data type to another. The size of internal buffers is settable on a perthread basis. There can be up to buffers of the specified size created to handle the data from all the inputs and outputs of a ufunc. The default size of a buffer is 10,000 elements. Whenever bufferbased calculation would be needed, but all input arrays are smaller than the buffer size, those misbehaved or incorrectlytyped arrays will be copied before the calculation proceeds. Adjusting the size of the buffer may therefore alter the speed at which ufunc calculations of various sorts are completed. A simple interface for setting this variable is accessible using the function

Set the size of the buffer used in ufuncs. 
Universal functions can trip special floatingpoint status registers in your hardware (such as dividebyzero). If available on your platform, these registers will be regularly checked during calculation. Error handling is controlled on a perthread basis, and can be configured using the functions

Set how floatingpoint errors are handled. 

Set the floatingpoint error callback function or log object. 
Note
In NumPy 1.6.0, a type promotion API was created to encapsulate the
mechanism for determining output types. See the functions
result_type
, promote_types
, and
min_scalar_type
for more details.
At the core of every ufunc is a onedimensional strided loop that
implements the actual function for a specific type combination. When a
ufunc is created, it is given a static list of inner loops and a
corresponding list of type signatures over which the ufunc operates.
The ufunc machinery uses this list to determine which inner loop to
use for a particular case. You can inspect the .types
attribute for a particular ufunc to see which type
combinations have a defined inner loop and which output type they
produce (character codes are used
in said output for brevity).
Casting must be done on one or more of the inputs whenever the ufunc does not have a core loop implementation for the input types provided. If an implementation for the input types cannot be found, then the algorithm searches for an implementation with a type signature to which all of the inputs can be cast “safely.” The first one it finds in its internal list of loops is selected and performed, after all necessary type casting. Recall that internal copies during ufuncs (even for casting) are limited to the size of an internal buffer (which is user settable).
Note
Universal functions in NumPy are flexible enough to have mixed type
signatures. Thus, for example, a universal function could be defined
that works with floatingpoint and integer values. See ldexp
for an example.
By the above description, the casting rules are essentially
implemented by the question of when a data type can be cast “safely”
to another data type. The answer to this question can be determined in
Python with a function call: can_cast(fromtype, totype)
. The Figure below shows the results of this call for
the 24 internally supported types on the author’s 64bit system. You
can generate this table for your system with the code given in the Figure.
Figure
Code segment showing the “can cast safely” table for a 64bit system. Generally the output depends on the system; your system might result in a different table.
>>> mark = {False: ' ', True: ' Y'}
>>> def print_table(ntypes):
... print('X ' + ' '.join(ntypes))
... for row in ntypes:
... print(row, end='')
... for col in ntypes:
... print(mark[np.can_cast(row, col)], end='')
... print()
...
>>> print_table(np.typecodes['All'])
X ? b h i l q p B H I L Q P e f d g F D G S U V O M m
? Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y  Y
b  Y Y Y Y Y Y       Y Y Y Y Y Y Y Y Y Y Y  Y
h   Y Y Y Y Y        Y Y Y Y Y Y Y Y Y Y  Y
i    Y Y Y Y         Y Y  Y Y Y Y Y Y  Y
l     Y Y Y         Y Y  Y Y Y Y Y Y  Y
q     Y Y Y         Y Y  Y Y Y Y Y Y  Y
p     Y Y Y         Y Y  Y Y Y Y Y Y  Y
B   Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y  Y
H    Y Y Y Y  Y Y Y Y Y  Y Y Y Y Y Y Y Y Y Y  Y
I     Y Y Y   Y Y Y Y   Y Y  Y Y Y Y Y Y  Y
L           Y Y Y   Y Y  Y Y Y Y Y Y  
Q           Y Y Y   Y Y  Y Y Y Y Y Y  
P           Y Y Y   Y Y  Y Y Y Y Y Y  
e              Y Y Y Y Y Y Y Y Y Y Y  
f               Y Y Y Y Y Y Y Y Y Y  
d                Y Y  Y Y Y Y Y Y  
g                 Y   Y Y Y Y Y  
F                  Y Y Y Y Y Y Y  
D                   Y Y Y Y Y Y  
G                    Y Y Y Y Y  
S                     Y Y Y Y  
U                      Y Y Y  
V                       Y Y  
O                       Y Y  
M                       Y Y Y 
m                       Y Y  Y
You should note that, while included in the table for completeness, the ‘S’, ‘U’, and ‘V’ types cannot be operated on by ufuncs. Also, note that on a 32bit system the integer types may have different sizes, resulting in a slightly altered table.
Mixed scalararray operations use a different set of casting rules that ensure that a scalar cannot “upcast” an array unless the scalar is of a fundamentally different kind of data (i.e., under a different hierarchy in the datatype hierarchy) than the array. This rule enables you to use scalar constants in your code (which, as Python types, are interpreted accordingly in ufuncs) without worrying about whether the precision of the scalar constant will cause upcasting on your large (small precision) array.
Classes (including ndarray subclasses) can override how ufuncs act on them by defining certain special methods. For details, see Standard array subclasses.
ufunc
¶All ufuncs take optional keyword arguments. Most of these represent advanced usage and will not typically be used.
out
New in version 1.6.
The first output can be provided as either a positional or a keyword parameter. Keyword ‘out’ arguments are incompatible with positional ones.
New in version 1.10.
The ‘out’ keyword argument is expected to be a tuple with one entry per output (which can be None for arrays to be allocated by the ufunc). For ufuncs with a single output, passing a single array (instead of a tuple holding a single array) is also valid.
Passing a single array in the ‘out’ keyword argument to a ufunc with multiple outputs is deprecated, and will raise a warning in numpy 1.10, and an error in a future release.
If ‘out’ is None (the default), a uninitialized return array is created. The output array is then filled with the results of the ufunc in the places that the broadcast ‘where’ is True. If ‘where’ is the scalar True (the default), then this corresponds to the entire output being filled. Note that outputs not explicitly filled are left with their uninitialized values.
where
New in version 1.7.
Accepts a boolean array which is broadcast together with the operands. Values of True indicate to calculate the ufunc at that position, values of False indicate to leave the value in the output alone. This argument cannot be used for generalized ufuncs as those take nonscalar input.
Note that if an uninitialized return array is created, values of False will leave those values uninitialized.
axes
New in version 1.15.
A list of tuples with indices of axes a generalized ufunc should operate on. For instance, for a signature of
(i,j),(j,k)>(i,k)
appropriate for matrix multiplication, the base elements are twodimensional matrices and these are taken to be stored in the two last axes of each argument. The corresponding axes keyword would be[(2, 1), (2, 1), (2, 1)]
. For simplicity, for generalized ufuncs that operate on 1dimensional arrays (vectors), a single integer is accepted instead of a singleelement tuple, and for generalized ufuncs for which all outputs are scalars, the output tuples can be omitted.
axis
New in version 1.15.
A single axis over which a generalized ufunc should operate. This is a shortcut for ufuncs that operate over a single, shared core dimension, equivalent to passing in
axes
with entries of(axis,)
for each singlecoredimension argument and()
for all others. For instance, for a signature(i),(i)>()
, it is equivalent to passing inaxes=[(axis,), (axis,), ()]
.
keepdims
New in version 1.15.
If this is set to True, axes which are reduced over will be left in the result as a dimension with size one, so that the result will broadcast correctly against the inputs. This option can only be used for generalized ufuncs that operate on inputs that all have the same number of core dimensions and with outputs that have no core dimensions , i.e., with signatures like
(i),(i)>()
or(m,m)>()
. If used, the location of the dimensions in the output can be controlled withaxes
andaxis
.
casting
New in version 1.6.
May be ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, or ‘unsafe’. See
can_cast
for explanations of the parameter values.Provides a policy for what kind of casting is permitted. For compatibility with previous versions of NumPy, this defaults to ‘unsafe’ for numpy < 1.7. In numpy 1.7 a transition to ‘same_kind’ was begun where ufuncs produce a DeprecationWarning for calls which are allowed under the ‘unsafe’ rules, but not under the ‘same_kind’ rules. From numpy 1.10 and onwards, the default is ‘same_kind’.
order
New in version 1.6.
Specifies the calculation iteration order/memory layout of the output array. Defaults to ‘K’. ‘C’ means the output should be Ccontiguous, ‘F’ means Fcontiguous, ‘A’ means Fcontiguous if the inputs are Fcontiguous and not also not Ccontiguous, Ccontiguous otherwise, and ‘K’ means to match the element ordering of the inputs as closely as possible.
dtype
New in version 1.6.
Overrides the dtype of the calculation and output arrays. Similar to signature.
subok
New in version 1.6.
Defaults to true. If set to false, the output will always be a strict array, not a subtype.
signature
Either a datatype, a tuple of datatypes, or a special signature string indicating the input and output types of a ufunc. This argument allows you to provide a specific signature for the 1d loop to use in the underlying calculation. If the loop specified does not exist for the ufunc, then a TypeError is raised. Normally, a suitable loop is found automatically by comparing the input types with what is available and searching for a loop with datatypes to which all inputs can be cast safely. This keyword argument lets you bypass that search and choose a particular loop. A list of available signatures is provided by the types attribute of the ufunc object. For backwards compatibility this argument can also be provided as sig, although the long form is preferred. Note that this should not be confused with the generalized ufunc signature that is stored in the signature attribute of the of the ufunc object.
extobj
a list of length 1, 2, or 3 specifying the ufunc buffersize, the error mode integer, and the error callback function. Normally, these values are looked up in a threadspecific dictionary. Passing them here circumvents that look up and uses the lowlevel specification provided for the error mode. This may be useful, for example, as an optimization for calculations requiring many ufunc calls on small arrays in a loop.
There are some informational attributes that universal functions possess. None of the attributes can be set.
__doc__ 
A docstring for each ufunc. The first part of the docstring is dynamically generated from the number of outputs, the name, and the number of inputs. The second part of the docstring is provided at creation time and stored with the ufunc. 
__name__ 
The name of the ufunc. 
The number of inputs. 

The number of outputs. 

The number of arguments. 

The number of types. 

Returns a list with types grouped input>output. 

The identity value. 

Definition of the core elements a generalized ufunc operates on. 
All ufuncs have four methods. However, these methods only make sense on scalar
ufuncs that take two input arguments and return one output argument.
Attempting to call these methods on other ufuncs will cause a
ValueError
. The reducelike methods all take an axis keyword, a dtype
keyword, and an out keyword, and the arrays must all have dimension >= 1.
The axis keyword specifies the axis of the array over which the reduction
will take place (with negative values counting backwards). Generally, it is an
integer, though for ufunc.reduce
, it can also be a tuple of int
to
reduce over several axes at once, or None, to reduce over all axes.
The dtype keyword allows you to manage a very common problem that arises
when naively using ufunc.reduce
. Sometimes you may
have an array of a certain data type and wish to add up all of its
elements, but the result does not fit into the data type of the
array. This commonly happens if you have an array of singlebyte
integers. The dtype keyword allows you to alter the data type over which
the reduction takes place (and therefore the type of the output). Thus,
you can ensure that the output is a data type with precision large enough
to handle your output. The responsibility of altering the reduce type is
mostly up to you. There is one exception: if no dtype is given for a
reduction on the “add” or “multiply” operations, then if the input type is
an integer (or Boolean) datatype and smaller than the size of the
int_
data type, it will be internally upcast to the int_
(or uint
) datatype. Finally, the out keyword allows you to provide
an output array (for singleoutput ufuncs, which are currently the only ones
supported; for future extension, however, a tuple with a single argument
can be passed in). If out is given, the dtype argument is ignored.
Ufuncs also have a fifth method that allows in place operations to be performed using fancy indexing. No buffering is used on the dimensions where fancy indexing is used, so the fancy index can list an item more than once and the operation will be performed on the result of the previous operation for that item.

Reduces a’s dimension by one, by applying ufunc along one axis. 

Accumulate the result of applying the operator to all elements. 

Performs a (local) reduce with specified slices over a single axis. 

Apply the ufunc op to all pairs (a, b) with a in A and b in B. 

Performs unbuffered in place operation on operand ‘a’ for elements specified by ‘indices’. 
Warning
A reducelike operation on an array with a datatype that has a
range “too small” to handle the result will silently wrap. One
should use dtype
to increase the size of the datatype over which
reduction takes place.
There are currently more than 60 universal functions defined in
numpy
on one or more types, covering a wide variety of
operations. Some of these ufuncs are called automatically on arrays
when the relevant infix notation is used (e.g., add(a, b)
is called internally when a + b
is written and a or b is an
ndarray
). Nevertheless, you may still want to use the ufunc
call in order to use the optional output argument(s) to place the
output(s) in an object (or objects) of your choice.
Recall that each ufunc operates elementbyelement. Therefore, each scalar ufunc will be described as if acting on a set of scalar inputs to return a set of scalar outputs.
Note
The ufunc still returns its output(s) even if you use the optional output argument(s).

Add arguments elementwise. 

Subtract arguments, elementwise. 

Multiply arguments elementwise. 

Returns a true division of the inputs, elementwise. 

Logarithm of the sum of exponentiations of the inputs. 

Logarithm of the sum of exponentiations of the inputs in base2. 

Returns a true division of the inputs, elementwise. 

Return the largest integer smaller or equal to the division of the inputs. 

Numerical negative, elementwise. 

Numerical positive, elementwise. 

First array elements raised to powers from second array, elementwise. 

Return elementwise remainder of division. 

Return elementwise remainder of division. 

Return the elementwise remainder of division. 

Return elementwise quotient and remainder simultaneously. 

Calculate the absolute value elementwise. 

Compute the absolute values elementwise. 

Round elements of the array to the nearest integer. 

Returns an elementwise indication of the sign of a number. 

Compute the Heaviside step function. 

Return the complex conjugate, elementwise. 

Return the complex conjugate, elementwise. 

Calculate the exponential of all elements in the input array. 

Calculate 2**p for all p in the input array. 

Natural logarithm, elementwise. 

Base2 logarithm of x. 

Return the base 10 logarithm of the input array, elementwise. 

Calculate 

Return the natural logarithm of one plus the input array, elementwise. 

Return the nonnegative squareroot of an array, elementwise. 

Return the elementwise square of the input. 

Return the cuberoot of an array, elementwise. 

Return the reciprocal of the argument, elementwise. 

Returns the greatest common divisor of 

Returns the lowest common multiple of 
Tip
The optional output arguments can be used to help you save memory
for large calculations. If your arrays are large, complicated
expressions can take longer than absolutely necessary due to the
creation and (later) destruction of temporary calculation
spaces. For example, the expression G = a * b + c
is equivalent to
t1 = A * B; G = T1 + C; del t1
. It will be more quickly executed
as G = A * B; add(G, C, G)
which is the same as
G = A * B; G += C
.
All trigonometric functions use radians when an angle is called for. The ratio of degrees to radians is

Trigonometric sine, elementwise. 

Cosine elementwise. 

Compute tangent elementwise. 

Inverse sine, elementwise. 

Trigonometric inverse cosine, elementwise. 

Trigonometric inverse tangent, elementwise. 

Elementwise arc tangent of 

Given the “legs” of a right triangle, return its hypotenuse. 

Hyperbolic sine, elementwise. 

Hyperbolic cosine, elementwise. 

Compute hyperbolic tangent elementwise. 

Inverse hyperbolic sine elementwise. 

Inverse hyperbolic cosine, elementwise. 