Как проверить, является ли объект списком или кортежем (но не строкой)?

Это то, что я обычно делаю, чтобы убедиться, что вход является list/ tuple-, но не а str. Потому что много раз я сталкивался с ошибками, когда функция strпо ошибке пропускает объект, а целевая функция for x in lstпредполагает, что lstэто на самом деле listили tuple.

assert isinstance(lst, (list, tuple))

Мой вопрос: есть ли лучший способ добиться этого?

Только в Python 2 (не Python 3):

assert not isinstance(lst, basestring)

Это на самом деле то, что вы хотите, иначе вы упустите много вещей, которые действуют как списки, но не являются подклассами listили tuple.

Помните, что в Python мы хотим использовать «Duck Typing». Таким образом, все, что действует как список, может рассматриваться как список. Поэтому не проверяйте тип списка, просто посмотрите, действует ли он как список.

Но строки тоже действуют как список, и часто это не то, что мы хотим. Есть моменты, когда это даже проблема! Так что, проверяйте явно строку, но затем используйте утку.

Вот функция, которую я написал для удовольствия. Это специальная версия, repr()которая печатает любую последовательность в угловых скобках ('<', '>').

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

Это чисто и элегантно, в целом. Но что там isinstance()делает эта проверка? Это что-то вроде хака. Но это важно.

Эта функция вызывает себя рекурсивно для всего, что действует как список. Если бы мы не обрабатывали строку специально, то она была бы обработана как список и разделена по одному символу за раз. Но тогда рекурсивный вызов попытается обработать каждый символ как список - и это сработает! Даже односимвольная строка работает как список! Функция будет продолжать вызывать себя рекурсивно, пока стек не переполнится.

Подобные функции, которые зависят от каждого рекурсивного вызова, разбивающего выполняемую работу, должны иметь строки специального случая - потому что вы не можете разбить строку ниже уровня односимвольной строки, и даже одну Строка -character действует как список.

Примечание: try/ exceptявляется самым чистым способом выразить наши намерения. Но если бы этот код был как-то критичным по времени, мы могли бы заменить его каким-то тестом, чтобы увидеть, argявляется ли последовательность. Вместо того, чтобы тестировать тип, мы, вероятно, должны проверить поведение. Если у него есть .strip()метод, это строка, поэтому не считайте ее последовательностью; в противном случае, если он индексируется или повторяется, это последовательность:

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)

РЕДАКТИРОВАТЬ: Первоначально я написал выше с проверкой для, __getslice__()но я заметил, что в collectionsдокументации модуля, интересный метод является __getitem__(); это имеет смысл, вот как вы индексируете объект. Это кажется более фундаментальным, чем __getslice__()я изменил выше.

H = "Hello"

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

Для 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")

Изменено в версии 3.3: перемещены абстрактные базовые классы коллекций в модуль collection.abc. Для обратной совместимости они также будут видны в этом модуле до версии 3.8, где он перестанет работать.

Для 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 со вкусом PHP:

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

Вообще говоря, тот факт, что функция, которая выполняет итерации по объекту, работает со строками, а также с кортежами и списками, является скорее особенностью, чем ошибкой. Вы, конечно, можете использовать isinstanceили не печатать, чтобы проверить аргумент, но зачем вам это?

Это звучит как риторический вопрос, но это не так. Ответ на вопрос «почему я должен проверять тип аргумента?» вероятно, собирается предложить решение реальной проблемы, а не предполагаемой проблемы. Почему это ошибка, когда в функцию передается строка? Кроме того: если это ошибка, когда строка передается этой функции, это также ошибка, если ей передается какая-либо иная итерация, не относящаяся к списку / кортежу? Почему или почему нет?

Я думаю, что наиболее распространенным ответом на этот вопрос, вероятно, будет то, что разработчики, которые пишут f("abc"), ожидают, что функция будет вести себя так, как будто они написали f(["abc"]). Вероятно, существуют обстоятельства, когда имеет смысл защитить разработчиков от самих себя, а не поддерживать вариант использования итерации по символам в строке. Но я бы сначала долго об этом думал.

Попробуйте это для удобства чтения и лучших практик:

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

Надеюсь, поможет.

У strобъекта нет __iter__атрибута

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

так что вы можете сделать проверку

assert hasattr(x, '__iter__')

и это также поднимет хороший AssertionErrorдля любого другого не повторяемого объекта тоже.

Изменить: как Тим упоминает в комментариях, это будет работать только в Python 2.x, а не 3.x

Это не предназначено для прямого ответа на ФП, но я хотел поделиться некоторыми связанными идеями.

Я был очень заинтересован в ответе @steveha выше, который, кажется, дал пример, где печать утки, кажется, ломается. Однако, после второго размышления, его пример предполагает, что с типизацией утки трудно соответствовать, но он не предполагает, что она strзаслуживает особой обработки.

В конце концов, не strтип (например, пользовательский тип, который поддерживает некоторые сложные рекурсивные структуры) может привести к тому, что sreprфункция @steveha вызовет бесконечную рекурсию. Хотя это по общему признанию довольно маловероятно, мы не можем игнорировать эту возможность. Поэтому, а не специальный кожух strв srepr, мы должны уточнить , что мы хотим sreprсделать , когда бесконечное результатов рекурсии.

Может показаться, что один разумный подход - просто прервать рекурсию в sreprданный момент list(arg) == [arg]. Это, на самом деле, полностью решит проблему str, без каких-либо isinstance.

Тем не менее, действительно сложная рекурсивная структура может вызвать бесконечный цикл, где это list(arg) == [arg]никогда не происходит. Поэтому, хотя вышеуказанная проверка полезна, ее недостаточно. Нам нужно что-то вроде жесткого ограничения на глубину рекурсии.

Моя точка зрения заключается в том, что если вы планируете обрабатывать произвольные типы аргументов, обработка с strпомощью утиной типизации намного, намного проще, чем обработка более общих типов, с которыми вы можете (теоретически) столкнуться. Поэтому, если вы чувствуете необходимость исключить strэкземпляры, вам следует вместо этого потребовать, чтобы аргумент был экземпляром одного из немногих типов, которые вы явно указали.

Я нахожу такую ​​функцию с именем 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))

И я убедился, что он отвечает вашим потребностям.

Я делаю это в моих тестовых случаях.

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

Не проверенный на генераторах, я думаю, что вы останетесь на следующем уровне «доходности», если передадите его в генератор, который может привести к ухудшению работы. Но опять же, это «unittest»

В манере "утки", как насчет

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

или

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

соответственно. Это позволяет избежать isinstance/ hasattrсамоанализ вещи.

Вы также можете проверить наоборот:

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

Все варианты фактически не изменяют содержимое переменной, но подразумевают переназначение. Я не уверен, может ли это быть нежелательным при некоторых обстоятельствах.

Интересно, что с назначением «на месте» в любом случае +=не TypeErrorбудет поднято значение, если lstэто список (не кортеж ). Вот почему назначение сделано таким образом. Может быть, кто-то может пролить свет на то, почему это так.

самый простой способ ... используя anyиisinstance

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

Другая версия утиной типизации, помогающая отличать строковые объекты от других похожих на последовательность объектов.

Строковое представление строковых объектов - это сама строка, поэтому вы можете проверить, получаете ли вы равный объект из strконструктора:

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

Это должно работать для всех объектов, совместимых с strи для всех видов итерируемых объектов.

Python 3 имеет это:

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

Таким образом, чтобы проверить списки и кортежи, было бы:

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"

Просто сделай это

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

в питоне> 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

Я склонен делать это (если я действительно, действительно должен был):

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