Python: cómo identificar si una variable es una matriz o un escalar

Tengo una función que toma el argumento NBins. Quiero hacer una llamada a esta función con un escalar 50o una matriz [0, 10, 20, 30]. ¿Cómo puedo identificar dentro de la función, cuál es la longitud de NBins? o dicho de otra manera, si es un escalar o un vector?

Intenté esto:

>>> 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()
>>> 

Como se puede ver, no puedo aplicar lena P, ya que no es una matriz .... ¿Hay algo así como isarrayo isscalaren Python?

Gracias

>>> isinstance([0, 10, 20, 30], list)
True
>>> isinstance(50, list)
False

Para admitir cualquier tipo de secuencia, marque en collections.Sequencelugar de list.

nota : isinstancetambién admite una tupla de clases, se type(x) in (..., ...)debe evitar la comprobación y es innecesario.

También es posible que desee comprobar not isinstance(x, (str, unicode))

Las respuestas anteriores suponen que la matriz es una lista estándar de Python. Como alguien que usa numpy a menudo, recomendaría una prueba muy pitónica de:

if hasattr(N, "__len__")

Combinando las respuestas de @jamylak y @ jpaddison3 juntas, si necesita ser robusto frente a matrices numpy como entrada y manejarlas de la misma manera que las listas, debe usar

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

Esto es robusto frente a subclases de listas, tuplas y matrices numpy.

Y si también quiere ser robusto frente a todas las demás subclases de secuencia (no solo lista y tupla), use

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

¿Por qué debería hacer las cosas de esta manera isinstancey no compararlas type(P)con un valor objetivo? Aquí hay un ejemplo, donde hacemos y estudiamos el comportamiento de NewListuna subclase trivial de la lista.

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

A pesar de xy ycomparándolos como iguales, manejarlos con ellos typeresultaría en un comportamiento diferente. Sin embargo, ya que xes una instancia de una subclase de list, utilizando isinstance(x,list)da el comportamiento y trata deseado xy yde la misma manera.

¿Hay un equivalente a isscalar () en numpy? Si.

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

Mientras que el enfoque de @ jamylak es el mejor, aquí hay un enfoque alternativo

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

Otro enfoque alternativo (uso de la propiedad de nombre de clase ):

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

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

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

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

No es necesario importar nada.

Aquí está el mejor enfoque que he encontrado: Verifique la existencia de __len__y __getitem__.

Usted puede preguntar por qué? Los motivos incluyen:

1. El método popular isinstance(obj, abc.Sequence)falla en algunos objetos, incluido el Tensor de PyTorch porque no se implementan __contains__.
2. Desafortunadamente, no hay nada en las colecciones.abc de Python que verifique solo __len__y __getitem__que considero que son métodos mínimos para objetos tipo matriz.
3. Funciona en lista, tupla, ndarray, tensor, etc.

Así que sin más preámbulos:

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

Tenga en cuenta que he agregado parámetros predeterminados porque la mayoría de las veces es posible que desee considerar las cadenas como valores, no como matrices. Del mismo modo para las tuplas.

>>> N=[2,3,5]
>>> P = 5
>>> type(P)==type(0)
True
>>> type([1,2])==type(N)
True
>>> type(P)==type([1,2])
False

Puede verificar el tipo de datos de la variable.

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

Le dará salida como tipo de datos de P.

<type 'int'>

Para que pueda diferenciar que es un entero o una matriz.

Me sorprende que una pregunta tan básica no parezca tener una respuesta inmediata en Python. Me parece que casi todas las respuestas propuestas usan algún tipo de verificación de tipo, que generalmente no se recomienda en python y parecen restringidas a un caso específico (fallan con diferentes tipos numéricos u objetos genéricos iterables que no son tuplas o listas).

Para mí, lo que funciona mejor es importar numpy y usar array.size, por ejemplo:

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

Nota también:

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

Out[5]: 2

pero:

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

Simplemente use en sizelugar de 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

preds_test [0] tiene forma (128,128,1) Permite verificar su tipo de datos usando la función isinstance () La función isinstance toma 2 argumentos. El primer argumento es datos. El segundo argumento es tipo de datos isinstance (preds_test [0], np.ndarray) da la salida como Verdadero. Significa que preds_test [0] es una matriz.

Para responder la pregunta en el título, una forma directa de saber si una variable es escalar es intentar convertirla en flotante. Si lo consigues TypeError, no lo es.

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