python: como identificar se uma variável é uma matriz ou um escalar

Eu tenho uma função que aceita o argumento NBins. Quero fazer uma chamada para essa função com um escalar 50ou uma matriz [0, 10, 20, 30]. Como posso identificar dentro da função, qual é o tamanho NBins? ou dito de forma diferente, se for um escalar ou um vetor?

Eu tentei isso:

>>> 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 você pode ver, eu não posso aplicar lenpara P, uma vez que não é um array .... Existe algo parecido isarrayou isscalarem python?

obrigado

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

Para suportar qualquer tipo de sequência, marque em collections.Sequencevez de list.

nota : isinstancetambém suporta uma tupla de classes, a verificação type(x) in (..., ...)deve ser evitada e é desnecessária.

Você também pode querer verificar not isinstance(x, (str, unicode))

As respostas anteriores assumem que a matriz é uma lista padrão do python. Como alguém que usa sonolento com frequência, eu recomendaria um teste muito pythonico de:

if hasattr(N, "__len__")

Combinando as respostas @jamylak e @ jpaddison3, se você precisar ser robusto com matrizes numpy como entrada e manipulá-las da mesma maneira que as listas, use

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

Isso é robusto contra subclasses de matrizes de lista, tupla e numpy.

E se você quiser ser robusto com todas as outras subclasses de sequência (não apenas lista e tupla), use

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

Por que você deve fazer as coisas dessa maneira isinstancee não comparar type(P)com um valor-alvo? Aqui está um exemplo, onde criamos e estudamos o comportamento de NewList, uma subclasse trivial da 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

Apesar xe ycomparando como iguais, lidar com eles typeresultaria em um comportamento diferente. No entanto, uma vez que xé uma instância de uma subclasse de list, using isinstance(x,list)fornece o comportamento e os tratamentos desejados xe yda mesma maneira.

Existe um equivalente a isscalar () em numpy? Sim.

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

Embora a abordagem do @ jamylak seja a melhor, aqui está uma abordagem alternativa

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

Outra abordagem alternativa (uso da propriedade do nome da classe ):

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

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

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

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

Não há necessidade de importar nada.

Aqui está a melhor abordagem que eu encontrei: Verifique a existência de __len__e __getitem__.

Você pode perguntar por quê? Os motivos incluem:

1. O método popular isinstance(obj, abc.Sequence)falha em alguns objetos, incluindo o Tensor do PyTorch, porque eles não são implementados __contains__.
2. Infelizmente, não há nada nas coleções do Python.abc que verifique apenas __len__e __getitem__que considero métodos mínimos para objetos do tipo array.
3. Funciona em lista, tupla, ndarray, tensor etc.

Portanto, sem mais delongas:

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

Observe que eu adicionei parâmetros padrão, porque na maioria das vezes você pode considerar cadeias de caracteres como valores, não matrizes. Da mesma forma para tuplas.

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

Você pode verificar o tipo de dados da variável.

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

Ele fornecerá o tipo de dados P.

<type 'int'>

Para que você possa diferenciar que é um número inteiro ou uma matriz.

Estou surpreso que uma pergunta tão básica não pareça ter uma resposta imediata em python. Parece-me que quase todas as respostas propostas usam algum tipo de verificação de tipo, que geralmente não é recomendada em python e parecem restritas a um caso específico (elas falham com tipos numéricos diferentes ou objetos iteráveis ​​genéricos que não são tuplas ou listas).

Para mim, o que funciona melhor é importar numpy e usar array.size, por exemplo:

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

Observe também:

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

Out[5]: 2

mas:

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

Basta usar em sizevez 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] é da forma (128,128,1) Permite verificar seu tipo de dados usando a função isinstance () isinstance recebe 2 argumentos. O 1º argumento é dados O 2º argumento é o tipo de dados isinstance (preds_test [0], np.ndarray) fornece Output como True. Isso significa que o preds_test [0] é uma matriz.

Para responder à pergunta no título, uma maneira direta de saber se uma variável é escalar é tentar convertê-la em um ponto flutuante. Se você conseguir TypeError, não é.

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