Jak sprawdzić, czy obiekt jest listą lub krotką (ale nie łańcuchem)?

Tak zwykle robię, aby upewnić się, że dane wejściowe to list/ tuple- ale nie str. Ponieważ wiele razy natknąłem się na błędy, w których funkcja stromyłkowo mija obiekt, a funkcja celu for x in lstprzyjmuje, że lsttak naprawdę jest to listlub tuple.

assert isinstance(lst, (list, tuple))

Moje pytanie brzmi: czy jest lepszy sposób na osiągnięcie tego?

Tylko w python 2 (nie python 3):

assert not isinstance(lst, basestring)

Jest właściwie tym, czego chcesz, w przeciwnym razie przegapisz wiele rzeczy, które działają jak listy, ale nie są podklasami listlub tuple.

Pamiętaj, że w Pythonie chcemy używać „pisania kaczego”. Tak więc wszystko, co działa jak lista, może być traktowane jako lista. Nie sprawdzaj więc typu listy, po prostu sprawdź, czy działa ona jak lista.

Ale łańcuchy znaków również działają jak lista i często nie tego chcemy. Są chwile, kiedy jest to nawet problem! Sprawdź więc wyraźnie, czy nie ma łańcucha, ale następnie użyj wpisywania kaczki.

Oto funkcja, którą napisałem dla zabawy. Jest to specjalna wersja, repr()która drukuje dowolną sekwencję w nawiasach kątowych („<”, „>”).

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

Ogólnie rzecz biorąc, jest to czyste i eleganckie. Ale co isinstance()tam robi ta kontrola? To rodzaj włamania. Ale to jest niezbędne.

Ta funkcja wywołuje się rekurencyjnie do wszystkiego, co działa jak lista. Gdybyśmy nie traktowali łańcucha specjalnie, wówczas byłby traktowany jak lista i dzieliłby po jednym znaku na raz. Ale wtedy wywołanie rekurencyjne spróbuje traktować każdą postać jak listę - i zadziała! Nawet ciąg jednoznakowy działa jako lista! Funkcja będzie się ciągle wywoływać rekurencyjnie, aż do przepełnienia stosu.

Funkcje takie jak ta, które zależą od każdego wywołania rekurencyjnego rozkładającego pracę do wykonania, wymagają ciągów znaków specjalnych - ponieważ nie można rozbić ciągu poniżej poziomu ciągu jednego znaku, a nawet jednego -znak znaków działa jak lista.

Uwaga: try/ exceptjest najczystszym sposobem wyrażenia naszych intencji. Ale jeśli ten kod byłby w jakiś sposób krytyczny czasowo, moglibyśmy chcieć zastąpić go jakimś testem, aby sprawdzić, czy argjest to sekwencja. Zamiast testować typ, powinniśmy prawdopodobnie przetestować zachowania. Jeśli ma .strip()metodę, jest to ciąg znaków, więc nie traktuj jej jako sekwencji; w przeciwnym razie, jeśli jest indeksowalny lub iterowalny, jest to sekwencja:

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)

EDYCJA: Pierwotnie napisałem powyższe z zaznaczeniem, __getslice__()ale zauważyłem, że w collectionsdokumentacji modułu ciekawą metodą jest __getitem__(); ma to sens, tak indeksujesz obiekt. Wydaje się to bardziej fundamentalne, __getslice__()więc zmieniłem powyższe.

H = "Hello"

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

W przypadku 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")

Zmieniono w wersji 3.3: Przeniesione kolekcje Abstrakcyjne klasy podstawowe do modułu collections.abc. Dla kompatybilności wstecznej będą one również widoczne w tym module aż do wersji 3.8, gdzie przestanie działać.

W przypadku 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 o smaku PHP:

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

Ogólnie rzecz biorąc, fakt, że funkcja, która iteruje obiekt, działa zarówno na ciągach, jak i krotkach i listach, jest bardziej cechą niż błędem. Na pewno możesz użyć isinstanceklawisza lub klawisza, aby sprawdzić argument, ale dlaczego?

To brzmi jak pytanie retoryczne, ale tak nie jest. Odpowiedź na „dlaczego powinienem sprawdzić typ argumentu?” prawdopodobnie zaproponuje rozwiązanie prawdziwego problemu, a nie postrzeganego problemu. Dlaczego błąd jest przekazywany do funkcji? Ponadto: jeśli jest to błąd, gdy ciąg znaków jest przekazywany do tej funkcji, to czy jest to również błąd, jeśli przekazywana jest do niego inna iterowalna lista / krotka? Dlaczego lub dlaczego nie?

Myślę, że najczęstszą odpowiedzią na to pytanie może być to, że programiści, którzy piszą, f("abc")oczekują, że funkcja będzie zachowywać się tak, jak gdyby napisali f(["abc"]). Prawdopodobnie istnieją sytuacje, w których bardziej sensowne jest chronienie programistów przed sobą, niż wspieranie przypadku iteracji znaków w ciągu. Ale najpierw długo się nad tym zastanowię.

Wypróbuj to dla czytelności i najlepszych praktyk:

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

Mam nadzieję, że to pomoże.

strObiekt nie ma __iter__atrybutu

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

abyś mógł sprawdzić

assert hasattr(x, '__iter__')

i to również podniesie ładność AssertionErrordla każdego innego obiektu, który nie będzie iterowalny.

Edytować: Jak Tim wspomina w komentarzach, będzie to działać tylko w Pythonie 2.x, a nie 3.x

To nie ma na celu bezpośredniej odpowiedzi na PO, ale chciałem podzielić się kilkoma powiązanymi pomysłami.

Byłem bardzo zainteresowany powyższą odpowiedzią @steveha, która zdawała się dawać przykład, w którym pisanie kaczek wydaje się łamać. Jednak przy drugim przemyśleniu jego przykład sugeruje, że pisanie kaczek jest trudne do dostosowania, ale nie sugeruje, że strzasługuje na specjalne podejście.

W końcu inny niż strtyp (np. Typ zdefiniowany przez użytkownika, który utrzymuje pewne skomplikowane struktury rekurencyjne) może spowodować, że sreprfunkcja @steveha spowoduje nieskończoną rekurencję. Chociaż jest to raczej mało prawdopodobne, nie możemy zignorować tej możliwości. Dlatego zamiast specjalnej obudowy strw srepr, powinniśmy wyjaśnić, co chcemy sreprzrobić, gdy nieskończonej wyniki rekursji.

Może się wydawać, że jednym rozsądnym podejściem jest po prostu przerwanie rekurencji w sreprdanym momencie list(arg) == [arg]. To całkowicie rozwiązałoby problem strbez żadnegoisinstance .

Jednak naprawdę skomplikowana struktura rekurencyjna może powodować nieskończoną pętlę, w której list(arg) == [arg]nigdy się nie zdarza. Dlatego chociaż powyższa kontrola jest przydatna, nie jest wystarczająca. Potrzebujemy czegoś w rodzaju twardego ograniczenia głębokości rekurencji.

Chodzi mi o to, że jeśli planujesz obsługiwać dowolne typy argumentów, obsługa strza pomocą pisania kaczego jest o wiele łatwiejsza niż obsługa bardziej ogólnych typów, które możesz (teoretycznie) napotkać. Jeśli więc czujesz potrzebę wykluczenia strinstancji, powinieneś zamiast tego zażądać, aby argument był instancją jednego z niewielu typów, które wyraźnie określiłeś.

W funkcji tensorflow znajduję taką funkcję o nazwie is_sequence .

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

I zweryfikowałem, że spełnia twoje potrzeby.

Robię to w moich testach.

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

Nieprzetestowane na generatorach, myślę, że pozostaniesz przy następnej „wydajności”, jeśli zostaniesz przekazany do generatora, co może zepsuć wszystko w dół rzeki. Ale z drugiej strony jest to „niestosowne”

Co powiesz na „pisanie kaczką”?

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

lub

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

odpowiednio. Pozwala to uniknąć isinstance/hasattr introspekcji.

Możesz także sprawdzić na odwrót:

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

Wszystkie warianty tak naprawdę nie zmieniają zawartości zmiennej, ale sugerują zmianę przypisania. Nie jestem pewien, czy w pewnych okolicznościach może to być niepożądane.

Co ciekawe, przy przypisaniu „na miejscu” +=nie TypeErrorpojawi się żadna lista, jeśli lstjest to lista (a nie krotka ). Dlatego zadanie jest wykonywane w ten sposób. Może ktoś może wyjaśnić, dlaczego tak jest.

najprostszy sposób ... używając anyiisinstance

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

Inna wersja pisma kaczego, która pomaga odróżnić obiekty łańcuchowe od innych obiektów podobnych do sekwencji.

Reprezentacja ciągu obiektów podobnych do łańcucha jest samym łańcuchem, dzięki czemu można sprawdzić, czy otrzymano od strkonstruktora równy obiekt :

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

Powinno to działać dla wszystkich obiektów zgodnych z stri dla wszystkich rodzajów obiektów iterowalnych.

Python 3 ma to:

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

Aby sprawdzić zarówno Listy, jak i Tuple, byłoby to:

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"

Po prostu to zrób

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

w 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

Zwykle to robię (jeśli naprawdę, naprawdę musiałem):

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