All over the numpy code base you find things like:
def func_for_scalars_or_vectors(x):
x = np.asarray(x)
scalar_input = False
if x.ndim == 0:
x = x[None] # Makes x 1D
scalar_input = True
# The magic happens here
if scalar_input:
return np.squeeze(ret)
return ret
Answer from Jaime on Stack OverflowAll over the numpy code base you find things like:
def func_for_scalars_or_vectors(x):
x = np.asarray(x)
scalar_input = False
if x.ndim == 0:
x = x[None] # Makes x 1D
scalar_input = True
# The magic happens here
if scalar_input:
return np.squeeze(ret)
return ret
As a matter of opinion, I would prefer to have a function be flexible on input types, but always return a consistent type; this is what will ultimately prevent callers from having to check return types (the stated goal).
For example, allow scalars and/or arrays as arguments, but always return the array.
def func(x, y):
# allow (x=1,y=2) OR (x=[1,2], y=[3,4]) OR (!) (x=1,y=[2,3])
xn = np.asarray([x]) if np.isscalar(x) else np.asarray(x)
yn = np.asarray([y]) if np.isscalar(y) else np.asarray(y)
# calculations with numpy arrays xn and xy
res = xn + yn # ..etc...
return res
(Still, the example can easily be modified to return a scalar, by setting a flag "scalar=True", yada yada yada.. but you'd also have to handle one arg's a scalar, the other is an array, etc.; seems like a lot of YAGNI to me.)
A NumPy scalar is any object which is an instance of np.generic or whose type is in np.ScalarType:
In [12]: np.ScalarType
Out[13]:
(int,
float,
complex,
long,
bool,
str,
unicode,
buffer,
numpy.int16,
numpy.float16,
numpy.int8,
numpy.uint64,
numpy.complex192,
numpy.void,
numpy.uint32,
numpy.complex128,
numpy.unicode_,
numpy.uint32,
numpy.complex64,
numpy.string_,
numpy.uint16,
numpy.timedelta64,
numpy.bool_,
numpy.uint8,
numpy.datetime64,
numpy.object_,
numpy.int64,
numpy.float96,
numpy.int32,
numpy.float64,
numpy.int32,
numpy.float32)
This definition comes from looking at the source code for np.isscalar:
def isscalar(num):
if isinstance(num, generic):
return True
else:
return type(num) in ScalarType
Note that you can test if something is a scalar by using np.isscalar:
>>> np.isscalar(3.1)
True
>>> np.isscalar([3.1])
False
>>> np.isscalar(False)
True
How do we know what we know?
I like learning how people know what they know—more than the answers themselves. So let me try to explain where the above answer comes from.
Having the right tools can help you figure out things like this for yourself.
I found this out by using IPython. Using its TAB-completion feature, typing
In [19]: import numpy as np
In [20]: np.[TAB]
causes IPython to display all variables in the np module namespace. A search for the string "scalar" will lead you to np.ScalarType and np.isscalar. Typing
In [20]: np.isscalar?
(note the question mark at the end) prompts IPython to show you where np.isscalar is defined:
File: /data1/unutbu/.virtualenvs/dev/lib/python2.7/site-packages/numpy/core/numeric.py
which is how I got to the definition of isscalar. Alternatively, the NumPy documentation for isscalar has a link to the source code as well.
In this context, a scalar is one of the things you put in an array. A single 64-bit float or 32-bit int, for example, rather than a whole array of them.