ChatGPT解决这个技术问题 Extra ChatGPT

python: how to identify if a variable is an array or a scalar

I have a function that takes the argument NBins. I want to make a call to this function with a scalar 50 or an array [0, 10, 20, 30]. How can I identify within the function, what the length of NBins is? or said differently, if it is a scalar or a vector?

I tried this:

>>> N=[2,3,5]
>>> P = 5
>>> len(N)
3
>>> len(P)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()
>>> 

As you see, I can't apply len to P, since it's not an array.... Is there something like isarray or isscalar in python?

thanks

Have you tried testing for it's type?

j
jamylak
>>> import collections.abc
>>> isinstance([0, 10, 20, 30], collections.abc.Sequence)
True
>>> isinstance(50, collections.abc.Sequence)
False

note: isinstance also supports a tuple of classes, check type(x) in (..., ...) should be avoided and is unnecessary.

You may also wanna check not isinstance(x, (str, unicode))

As noted by @2080 and also here this won't work for numpy arrays. eg.

>>> import collections.abc
>>> import numpy as np
>>> isinstance((1, 2, 3), collections.abc.Sequence)
True
>>> isinstance(np.array([1, 2, 3]), collections.abc.Sequence)
False

In which case you may try the answer from @jpaddison3:

>>> hasattr(np.array([1, 2, 3]), "__len__")
True
>>> hasattr([1, 2, 3], "__len__")
True
>>> hasattr((1, 2, 3), "__len__")
True

However as noted here, this is not perfect either, and will incorrectly (at least according to me) classify dictionaries as sequences whereas isinstance with collections.abc.Sequence classifies correctly:

>>> hasattr({"a": 1}, "__len__")
True
>>> from numpy.distutils.misc_util import is_sequence
>>> is_sequence({"a": 1})
True
>>> isinstance({"a": 1}, collections.abc.Sequence)
False

You could customise your solution to something like this, add more types to isinstance depending on your needs:

>>> isinstance(np.array([1, 2, 3]), (collections.abc.Sequence, np.ndarray))
True
>>> isinstance([1, 2, 3], (collections.abc.Sequence, np.ndarray))
True

thanks, I didn't imagine inverting list to get false for scalars... thanks
While this is a great answer, collections.Sequence is an ABC for string as well, so that should be taken into account. I'm using something like if type(x) is not str and isinstance(x, collections.Sequence):. This isn't great, but it is reliable.
@bbenne10 sure, but avoid type, and also check not isinstance(x, (str, unicode)) on Python 2
Why did you say "check type(x) in (..., ...) should be avoided and is unnecessary."? If you say so, that would be very kind to explain why, maybe I'm not the only one to wonder why it should be avoided.
collections.Sequence --> collections.abc.Sequence may be required in Python 3.9 or 3.10.
j
jpaddison3

Previous answers assume that the array is a python standard list. As someone who uses numpy often, I'd recommend a very pythonic test of:

if hasattr(N, "__len__")

strings have a __len__ attribute (so I guess, not technically a scalar type)
if hasattr(N, '__len__') and (not isinstance(N, str)) would properly account for strings.
Also account for dict on Python 3
s
scottclowe

Combining @jamylak and @jpaddison3's answers together, if you need to be robust against numpy arrays as the input and handle them in the same way as lists, you should use

import numpy as np
isinstance(P, (list, tuple, np.ndarray))

This is robust against subclasses of list, tuple and numpy arrays.

And if you want to be robust against all other subclasses of sequence as well (not just list and tuple), use

import collections
import numpy as np
isinstance(P, (collections.Sequence, np.ndarray))

Why should you do things this way with isinstance and not compare type(P) with a target value? Here is an example, where we make and study the behaviour of NewList, a trivial subclass of list.

>>> class NewList(list):
...     isThisAList = '???'
... 
>>> x = NewList([0,1])
>>> y = list([0,1])
>>> print x
[0, 1]
>>> print y
[0, 1]
>>> x==y
True
>>> type(x)
<class '__main__.NewList'>
>>> type(x) is list
False
>>> type(y) is list
True
>>> type(x).__name__
'NewList'
>>> isinstance(x, list)
True

Despite x and y comparing as equal, handling them by type would result in different behaviour. However, since x is an instance of a subclass of list, using isinstance(x,list) gives the desired behaviour and treats x and y in the same manner.


This is the answer that most suited my needs. I just added set, too. Because I don't want to be robust against dicts. isinstance(P, (list, tuple, set, np.ndarray))
S
Stefan

Is there an equivalent to isscalar() in numpy? Yes.

>>> np.isscalar(3.1)
True
>>> np.isscalar([3.1])
False
>>> np.isscalar(False)
True
>>> np.isscalar('abcd')
True

It would be better and an example :>>> np.isscalar('abcd') returns True.
thanks! this is a much more general example than any of the above and should be preferred. It's also a direct answer to the OP's question.
Nice. Although one gotcha is that isscalar(None) returns False. Numpy implements this as return (isinstance(num, generic) or type(num) in ScalarType or isinstance(num, numbers.Number))
No, sadly. The numpy.isscalar() function suffers a number of irreconcilable design flaws and will probably be deprecated at some future revision. To paraphrase official documentation: "In almost all cases np.ndim(x) == 0 should be used instead of np.isscaler(x), as the former will also correctly return true for 0d arrays." A robust forward-compatible alternative to numpy.isscalar() would thus be to trivially wrap numpy.ndim(): e.g., def is_scalar(obj): return np.ndim(obj) == 0
Actually this should not be upvoted because np.isscalar is confusing. Official doc suggested using np.array.ndim everywhere, i.e. np.isscalar(np.array(12)) is False while it should be considered as scalar since np.array(12).ndim is 0.
S
Sukrit Kalra

While, @jamylak's approach is the better one, here is an alternative approach

>>> N=[2,3,5]
>>> P = 5
>>> type(P) in (tuple, list)
False
>>> type(N) in (tuple, list)
True

It would have been great if the person who downvoted the answer would have given a reason too.
i've actually upvoted, but then realized that it deosn't work in 2.7:>>> p=[] >>> type(p) in (list) Traceback (most recent call last): File "", line 1, in
@OlegGryb: Try type(p) in (list, ).
ah, it's a tuple on the right, not a list, got it, thanks and it works now. I regret, I can't upvote 2 times - the best solution so far :)
M
Marek

Another alternative approach (use of class name property):

N = [2,3,5]
P = 5

type(N).__name__ == 'list'
True

type(P).__name__ == 'int'
True

type(N).__name__ in ('list', 'tuple')
True

No need to import anything.


S
Shital Shah

Here is the best approach I have found: Check existence of __len__ and __getitem__.

You may ask why? The reasons includes:

The popular method isinstance(obj, abc.Sequence) fails on some objects including PyTorch's Tensor because they do not implement __contains__. Unfortunately, there is nothing in Python's collections.abc that checks for only __len__ and __getitem__ which I feel are minimal methods for array-like objects. It works on list, tuple, ndarray, Tensor etc.

So without further ado:

def is_array_like(obj, string_is_array=False, tuple_is_array=True):
    result = hasattr(obj, "__len__") and hasattr(obj, '__getitem__') 
    if result and not string_is_array and isinstance(obj, (str, abc.ByteString)):
        result = False
    if result and not tuple_is_array and isinstance(obj, tuple):
        result = False
    return result

Note that I've added default parameters because most of the time you might want to consider strings as values, not arrays. Similarly for tuples.


This doesn't work well on scalar (TensorFlow) tensors, because they have a len method but raise an error if you try to call it on a scalar tensor: TypeError: Scalar tensor has no len(). Kind of annoying behaviour on the part of TensorFlow...
To deal with this I find myself first doing something like if hasattr(obj,"shape") and obj.shape==() to check for these "scalar array" cases.
s
suhailvs
>>> N=[2,3,5]
>>> P = 5
>>> type(P)==type(0)
True
>>> type([1,2])==type(N)
True
>>> type(P)==type([1,2])
False

P
Puck

To answer the question in the title, a direct way to tell if a variable is a scalar is to try to convert it to a float. If you get TypeError, it's not.

N = [1, 2, 3]
try:
    float(N)
except TypeError:
    print('it is not a scalar')
else:
    print('it is a scalar')

Is anything wrong with this answer? The chosen answer fails when doing isinstance(np.arange(10), collections.Sequence).
u
unnati patil

You can check data type of variable.

N = [2,3,5]
P = 5
type(P)

It will give you out put as data type of P.

<type 'int'>

So that you can differentiate that it is an integer or an array.


V
Vincenzooo

I am surprised that such a basic question doesn't seem to have an immediate answer in python. It seems to me that nearly all proposed answers use some kind of type checking, that is usually not advised in python and they seem restricted to a specific case (they fail with different numerical types or generic iteratable objects that are not tuples or lists).

For me, what works better is importing numpy and using array.size, for example:

>>> a=1
>>> np.array(a)
Out[1]: array(1)

>>> np.array(a).size
Out[2]: 1

>>> np.array([1,2]).size
Out[3]: 2

>>> np.array('125')
Out[4]: 1

Note also:

>>> len(np.array([1,2]))

Out[5]: 2

but:

>>> len(np.array(a))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-40-f5055b93f729> in <module>()
----> 1 len(np.array(a))

TypeError: len() of unsized object

I'm also surprised that none of them seem to deal with generators either.
It also doesn't work on mappings: >>> np.array({1:2, 3:4}).size == 1
these are because the np.array function creates an array of dtype object, with a single element containing the dictionary (or the generator). It is different using np.array(list(a.items())).size or np.array(list(a.keys())).size gives a different result.
M
Mathieu Villion

Simply use size instead of len!

>>> from numpy import size
>>> N = [2, 3, 5]
>>> size(N)
3
>>> N = array([2, 3, 5])
>>> size(N)
3
>>> P = 5
>>> size(P)
1

NameError: name 'size' is not defined
That's true. I was using numpy size without noticing it. You need: from numpy import size
np.size(5) and np.size([5]) are both == 1, so this doesn't correctly distinguish type (i.e., identify a scalar), which I believe is the goal.
This is an interesting remark. Original question refers to isscalar, which is a Matlab function. In Matlab, there is absolutely no difference between a scalar and an array of size 1, may it be a vector or a N-dim array. IMHO, this is a plus for Matlab.
Madness. That would mean {} == {{}}.
N
Nicola

Since the general guideline in Python is to ask for forgiveness rather than permission, I think the most pythonic way to detect a string/scalar from a sequence is to check if it contains an integer:

try:
    1 in a
    print('{} is a sequence'.format(a))
except TypeError:
    print('{} is a scalar or string'.format(a))

S
Sumanth Meenan

preds_test[0] is of shape (128,128,1) Lets check its data type using isinstance() function isinstance takes 2 arguments. 1st argument is data 2nd argument is data type isinstance(preds_test[0], np.ndarray) gives Output as True. It means preds_test[0] is an array.