python: comment identifier si une variable est un tableau ou un scalaire

J'ai une fonction qui prend l'argument NBins. Je veux appeler cette fonction avec un scalaire 50ou un tableau [0, 10, 20, 30]. Comment puis-je identifier au sein de la fonction, quelle est sa longueur NBins? ou dit différemment, si c'est un scalaire ou un vecteur?

J'ai essayé ceci:

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

Comme vous le voyez, je ne peux pas demander lenà P, car il est pas un tableau .... Y at - il quelque chose comme isarrayou isscalaren python?

Merci

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

Pour prendre en charge tout type de séquence, cochez collections.Sequenceau lieu de list.

Remarque : isinstanceprend également en charge un tuple de classes, la vérification type(x) in (..., ...)doit être évitée et n'est pas nécessaire.

Vous pouvez également vérifier not isinstance(x, (str, unicode))

Les réponses précédentes supposent que le tableau est une liste standard python. En tant que personne qui utilise numpy souvent, je recommanderais un test très pythonique de:

if hasattr(N, "__len__")

En combinant les réponses de @jamylak et @ jpaddison3 ensemble, si vous devez être robuste contre les tableaux numpy en entrée et les gérer de la même manière que les listes, vous devez utiliser

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

Ceci est robuste contre les sous-classes de tableaux list, tuple et numpy.

Et si vous voulez également être robuste contre toutes les autres sous-classes de séquence (pas seulement la liste et le tuple), utilisez

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

Pourquoi devriez-vous procéder isinstanceainsi sans vous comparer type(P)à une valeur cible? Voici un exemple, où nous créons et étudions le comportement d' NewListune sous-classe triviale de liste.

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

Malgré leur comparaison xet leur yégalité, leur manipulation typeentraînerait un comportement différent. Cependant, puisqu'il xs'agit d'une instance d'une sous-classe de list, using isinstance(x,list)donne le comportement et les traitements souhaités xet yde la même manière.

Existe-t-il un équivalent à isscalar () dans numpy? Oui.

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

Alors que l'approche de @ jamylak est la meilleure, voici une approche alternative

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

Une autre approche alternative (utilisation de la propriété de nom de classe ):

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

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

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

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

Pas besoin d'importer quoi que ce soit.

Voici la meilleure approche que j'ai trouvée: Vérifier l'existence de __len__et__getitem__ .

Vous vous demandez peut-être pourquoi? Les raisons incluent:

1. La méthode populaire isinstance(obj, abc.Sequence)échoue sur certains objets, y compris le tenseur de PyTorch car ils n'implémentent pas__contains__ .
2. Malheureusement, rien dans les collections.abc de Python ne vérifie uniquement __len__et__getitem__ qui me semble être des méthodes minimales pour les objets de type tableau.
3. Il fonctionne sur liste, tuple, ndarray, Tensor etc.

Alors sans plus tarder:

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

Notez que j'ai ajouté des paramètres par défaut, car la plupart du temps, vous souhaiterez peut-être considérer les chaînes comme des valeurs, et non comme des tableaux. De même pour les tuples.

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

Vous pouvez vérifier le type de données de la variable.

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

Il vous donnera un type de données de P.

<type 'int'>

Pour que vous puissiez différencier qu'il s'agit d'un entier ou d'un tableau.

Je suis surpris qu'une telle question de base ne semble pas avoir de réponse immédiate en python. Il me semble que presque toutes les réponses proposées utilisent une sorte de vérification de type, ce qui n'est généralement pas conseillé en python et elles semblent limitées à un cas spécifique (elles échouent avec différents types numériques ou objets génériques itérables qui ne sont pas des tuples ou des listes).

Pour moi, ce qui fonctionne mieux, c'est d'importer numpy et d'utiliser array.size, par exemple:

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

A noter également:

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

Out[5]: 2

mais:

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

Utilisez simplement sizeau lieu 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] est de forme (128,128,1) Permet de vérifier son type de données en utilisant la fonction isinstance () isinstance prend 2 arguments. Le premier argument correspond aux données Le deuxième argument correspond au type de données isinstance (preds_test [0], np.ndarray) donne la sortie True. Cela signifie que preds_test [0] est un tableau.

Pour répondre à la question dans le titre, un moyen direct de savoir si une variable est un scalaire est d'essayer de la convertir en un flottant. Si vous obtenez TypeError, ce n'est pas le cas.

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