python: cómo identificar si una variable es un array o un escalar

Las respuestas anteriores asumen 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 contra matrices numpy como entrada y manejarlas de la misma manera que las listas, debe usar{[15]]}

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

Esto es robusto contra subclases de matrices list, tupla y numpy.

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

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

¿Por qué hacer las cosas de esta manera con isinstance y no comparar type(P) con un valor objetivo? Aquí hay un ejemplo, donde hacemos y estudiamos el comportamiento de NewList, una subclase trivial de 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

A pesar de que x y y se comparen como iguales, manejarlos por type resultaría en un comportamiento diferente. Sin embargo, dado que x es una instancia de una subclase de list, usar isinstance(x,list) da el comportamiento deseado y trata x y y de la misma manera.

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

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

Si bien 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 clase nombre propiedad):

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

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

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

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

No hay necesidad de importar nada.

Simplemente use size en lugar 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

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

Puede comprobar el tipo de datos de la variable.

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

Se le dará a cabo poner 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 utilizan algún tipo de tipo comprobación, que generalmente no se aconseja en python y parecen restringidos a un caso específico (fallan con diferentes tipos numéricos u objetos iterables genéricos que no son tuplas o listas).

Para mí, lo que funciona mejor es importar numpy y usar array.tamaño, 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