Comment vérifier si un objet est une liste ou un tuple (mais pas une chaîne)?

C'est ce que je fais normalement pour vérifier que l'entrée est un list/ tuple- mais pas un str. Parce que plusieurs fois, je suis tombé sur des bugs où une fonction passe un strobjet par erreur, et la fonction cible for x in lstsuppose que lstc'est en fait un listou tuple.

assert isinstance(lst, (list, tuple))

Ma question est: existe-t-il un meilleur moyen d'y parvenir?

En python 2 uniquement (pas en python 3):

assert not isinstance(lst, basestring)

C'est en fait ce que vous voulez, sinon vous passerez à côté de beaucoup de choses qui agissent comme des listes, mais ne sont pas des sous-classes de listou tuple.

N'oubliez pas qu'en Python, nous voulons utiliser le "typage du canard". Ainsi, tout ce qui agit comme une liste peut être traité comme une liste. Donc, ne vérifiez pas le type d'une liste, voyez simplement si elle agit comme une liste.

Mais les chaînes agissent également comme une liste, et souvent ce n'est pas ce que nous voulons. Il y a des moments où c'est même un problème! Donc, recherchez explicitement une chaîne, mais utilisez ensuite la frappe de canard.

Voici une fonction que j'ai écrite pour le plaisir. Il s'agit d'une version spéciale repr()qui imprime toute séquence entre crochets ('<', '>').

def srepr(arg):
    if isinstance(arg, basestring): # Python 3: isinstance(arg, str)
        return repr(arg)
    try:
        return '<' + ", ".join(srepr(x) for x in arg) + '>'
    except TypeError: # catch when for loop fails
        return repr(arg) # not a sequence so just return repr

C'est propre et élégant, dans l'ensemble. Mais que fait ce isinstance()chèque là-bas? C'est une sorte de hack. Mais c'est essentiel.

Cette fonction s'appelle récursivement sur tout ce qui agit comme une liste. Si nous ne gérions pas la chaîne spécialement, elle serait traitée comme une liste et divisée un caractère à la fois. Mais alors l'appel récursif essaierait de traiter chaque personnage comme une liste - et cela fonctionnerait! Même une chaîne à un caractère fonctionne comme une liste! La fonction continuerait à s'appeler récursivement jusqu'au débordement de la pile.

Les fonctions comme celle-ci, qui dépendent de chaque appel récursif décomposant le travail à effectuer, doivent avoir des chaînes de cas spécial - car vous ne pouvez pas décomposer une chaîne en dessous du niveau d'une chaîne à un caractère, et même une La chaîne de caractères agit comme une liste.

Remarque: le try/ exceptest le moyen le plus propre d'exprimer nos intentions. Mais si ce code était en quelque sorte critique dans le temps, nous pourrions vouloir le remplacer par une sorte de test pour voir s'il args'agit d'une séquence. Plutôt que de tester le type, nous devrions probablement tester les comportements. S'il a une .strip()méthode, c'est une chaîne, alors ne la considérez pas comme une séquence; sinon, si elle est indexable ou itérable, c'est une séquence:

def is_sequence(arg):
    return (not hasattr(arg, "strip") and
            hasattr(arg, "__getitem__") or
            hasattr(arg, "__iter__"))

def srepr(arg):
    if is_sequence(arg):
        return '<' + ", ".join(srepr(x) for x in arg) + '>'
    return repr(arg)

EDIT: J'ai écrit à l'origine ce qui précède avec une vérification, __getslice__()mais j'ai remarqué que dans la collectionsdocumentation du module, la méthode intéressante est __getitem__(); c'est logique, c'est ainsi que vous indexez un objet. Cela semble plus fondamental que __getslice__()j'ai donc changé ce qui précède.

H = "Hello"

if type(H) is list or type(H) is tuple:
    ## Do Something.
else
    ## Do Something.

Pour Python 3:

import collections.abc

if isinstance(obj, collections.abc.Sequence) and not isinstance(obj, str):
    print("obj is a sequence (list, tuple, etc) but not a string")

Modifié dans la version 3.3: Classes de base abstraites des collections déplacées vers le module collections.abc. Pour des raisons de compatibilité descendante, ils continueront à être visibles dans ce module également jusqu'à la version 3.8 où il cessera de fonctionner.

Pour Python 2:

import collections

if isinstance(obj, collections.Sequence) and not isinstance(obj, basestring):
    print "obj is a sequence (list, tuple, etc) but not a string or unicode"

Python avec saveur PHP:

def is_array(var):
    return isinstance(var, (list, tuple))

D'une manière générale, le fait qu'une fonction qui itère sur un objet fonctionne aussi bien sur les chaînes que sur les tuples et les listes est plus caractéristique que bug. Vous pouvez certainement utiliser isinstanceou taper du texte pour vérifier un argument, mais pourquoi devriez-vous?

Cela ressemble à une question rhétorique, mais ce n'est pas le cas. La réponse à "pourquoi devrais-je vérifier le type de l'argument?" va probablement suggérer une solution au vrai problème, pas au problème perçu. Pourquoi est-ce un bug quand une chaîne est passée à la fonction? Aussi: si c'est un bug quand une chaîne est passée à cette fonction, est-ce aussi un bug si un autre itérable non list / tuple lui est passé? Pourquoi ou pourquoi pas?

Je pense que la réponse la plus courante à la question est probablement que les développeurs qui écrivent f("abc")s'attendent à ce que la fonction se comporte comme s'ils avaient écrit f(["abc"]). Il existe probablement des circonstances où il est plus logique de protéger les développeurs contre eux-mêmes que de prendre en charge le cas d'utilisation de l'itération sur les caractères d'une chaîne. Mais j'y réfléchirais longuement et longuement en premier.

Essayez ceci pour la lisibilité et les meilleures pratiques:

Python2

import types
if isinstance(lst, types.ListType) or isinstance(lst, types.TupleType):
    # Do something

Python3

import typing
if isinstance(lst, typing.List) or isinstance(lst, typing.Tuple):
    # Do something

J'espère que cela aide.

L' strobjet n'a pas d' __iter__attribut

>>> hasattr('', '__iter__')
False 

afin que vous puissiez faire un contrôle

assert hasattr(x, '__iter__')

et cela soulèvera également une belle AssertionErrorpour tout autre objet non itérable.

Edit: Comme Tim le mentionne dans les commentaires, cela ne fonctionnera qu'en python 2.x, pas 3.x

Ce n'est pas destiné à répondre directement au PO, mais je voulais partager quelques idées connexes.

J'ai été très intéressé par la réponse de @steveha ci-dessus, qui semblait donner un exemple où la frappe de canard semble casser. À la réflexion, cependant, son exemple suggère que le typage du canard est difficile à respecter, mais il ne suggère pas qu'il strmérite une manipulation particulière.

Après tout, un non- strtype (par exemple, un type défini par l'utilisateur qui conserve certaines structures récursives compliquées) peut provoquer une sreprfonction @steveha provoquant une récursion infinie. Bien que cela soit certes assez improbable, nous ne pouvons pas ignorer cette possibilité. Par conséquent, plutôt que de cuvelage spécial strdans srepr, nous devons clarifier ce que nous voulons sreprfaire quand un résultat de récursion infinie.

Il peut sembler qu'une approche raisonnable consiste simplement à briser la récursivité dans sreprl'instant list(arg) == [arg]. En fait, cela résoudrait complètement le problème avec str, sans aucun isinstance.

Cependant, une structure récursive vraiment compliquée peut provoquer une boucle infinie où il list(arg) == [arg]ne se produit jamais. Par conséquent, bien que la vérification ci-dessus soit utile, elle n'est pas suffisante. Nous avons besoin de quelque chose comme une limite stricte sur la profondeur de récursivité.

Mon point est que si vous envisagez de gérer des types d'arguments arbitraires, la manipulation strvia la frappe de canard est beaucoup, beaucoup plus facile que la gestion des types plus généraux que vous pouvez (théoriquement) rencontrer. Donc, si vous ressentez le besoin d'exclure des strinstances, vous devez plutôt demander que l'argument soit une instance de l'un des rares types que vous spécifiez explicitement.

Je trouve une telle fonction nommée is_sequence dans tensorflow .

def is_sequence(seq):
  """Returns a true if its input is a collections.Sequence (except strings).
  Args:
    seq: an input sequence.
  Returns:
    True if the sequence is a not a string and is a collections.Sequence.
  """
  return (isinstance(seq, collections.Sequence)
and not isinstance(seq, six.string_types))

Et j'ai vérifié qu'il répond à vos besoins.

Je le fais dans mes tests.

def assertIsIterable(self, item):
    #add types here you don't want to mistake as iterables
    if isinstance(item, basestring): 
        raise AssertionError("type %s is not iterable" % type(item))

    #Fake an iteration.
    try:
        for x in item:
            break;
    except TypeError:
        raise AssertionError("type %s is not iterable" % type(item))

Non testé sur les générateurs, je pense que vous êtes laissé au prochain «rendement» s'il est passé dans un générateur, ce qui peut visser les choses en aval. Mais là encore, c'est un «unittest»

De manière "typée canard", que diriez-

try:
    lst = lst + []
except TypeError:
    #it's not a list

ou

try:
    lst = lst + ()
except TypeError:
    #it's not a tuple

respectivement. Cela évite le truc isinstance/ hasattrintrospection.

Vous pouvez également vérifier l'inverse:

try:
    lst = lst + ''
except TypeError:
    #it's not (base)string

Toutes les variantes ne modifient pas réellement le contenu de la variable, mais impliquent une réaffectation. Je ne sais pas si cela pourrait être indésirable dans certaines circonstances.

Fait intéressant, avec l'affectation "en place", +=aucun TypeErrorne serait soulevé dans tous les cas s'il lsts'agit d'une liste (et non d'un tuple ). C'est pourquoi la mission se fait de cette façon. Peut-être que quelqu'un peut nous expliquer pourquoi.

manière la plus simple ... en utilisant anyetisinstance

>>> console_routers = 'x'
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
False
>>>
>>> console_routers = ('x',)
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
True
>>> console_routers = list('x',)
>>> any([isinstance(console_routers, list), isinstance(console_routers, tuple)])
True

Une autre version du typage canard pour aider à distinguer les objets de type chaîne des autres objets de type séquence.

La représentation sous forme de chaîne des objets de type chaîne est la chaîne elle-même, vous pouvez donc vérifier si vous récupérez un objet égal du strconstructeur:

# If a string was passed, convert it to a single-element sequence
if var == str(var):
    my_list = [var]

# All other iterables
else: 
    my_list = list(var)

Cela devrait fonctionner pour tous les objets compatibles avec stret pour toutes sortes d'objets itérables.

Python 3 a ceci:

from typing import List

def isit(value):
    return isinstance(value, List)

isit([1, 2, 3])  # True
isit("test")  # False
isit({"Hello": "Mars"})  # False
isit((1, 2))  # False

Donc, pour vérifier les listes et les tuples, ce serait:

from typing import List, Tuple

def isit(value):
    return isinstance(value, List) or isinstance(value, Tuple)

assert (type(lst) == list) | (type(lst) == tuple), "Not a valid lst type, cannot be string"

Fais juste ça

if type(lst) in (list, tuple):
    # Do stuff

en python> 3,6

import collections
isinstance(set(),collections.abc.Container)
True
isinstance([],collections.abc.Container)
True
isinstance({},collections.abc.Container)
True
isinstance((),collections.abc.Container)
True
isinstance(str,collections.abc.Container)
False

J'ai tendance à faire ça (si je devais vraiment, vraiment le faire):

for i in some_var:
   if type(i) == type(list()):
       #do something with a list
   elif type(i) == type(tuple()):
       #do something with a tuple
   elif type(i) == type(str()):
       #here's your string