Проверьте, является ли переменная списком или кортежем

В Python, как лучше всего проверить, содержит ли переменная список или кортеж? (т.е. коллекция)

Является ли isinstance()зло, как предлагается здесь? http://www.canonical.org/~kragen/isinstance/

Обновление: наиболее распространенная причина, по которой я хочу отличить список от строки, это когда у меня есть какое-то неопределенно глубокое вложенное дерево / структура данных списков списков строк и т. Д., Которые я изучаю с помощью рекурсивного алгоритма, и мне нужно чтобы знать, когда я нажал на "лист" узлы.

Идите и используйте, isinstanceесли вам это нужно. Это несколько плохо, поскольку исключает пользовательские последовательности, итераторы и другие вещи, которые вам могут понадобиться. Однако иногда вам нужно вести себя иначе, если кто-то, например, передает строку. Мое предпочтение было бы явно проверить strили unicodeвот так:

import types
isinstance(var, types.StringTypes)

NB Не принимайте types.StringTypeза types.StringTypes. Последний включает в себя strи unicodeобъекты.

typesМодуль рассматривается многими устаревшими в пользу просто проверка непосредственно против типа объекта, так что если вы не хотите использовать выше, вы можете альтернативно проверить явно против strи unicode, как это:

isinstance(var, (str, unicode)):

Редактировать:

Еще лучше:

isinstance(var, basestring)

Конец редактирования

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

Видите, что «зло» в проверке типов заключается не в том, что вы, возможно, захотите вести себя по-разному для определенного типа объектов, а в том, что вы искусственно ограничиваете свою функцию от правильных действий с неожиданными типами объектов, которые в противном случае сделали бы правильные вещи. Если у вас есть последний запасной вариант, который не проверен, вы удалите это ограничение. Следует отметить, что слишком большая проверка типов является запахом кода, который указывает на то, что вы, возможно, захотите провести некоторый рефакторинг, но это не обязательно означает, что вы должны избегать его из getgo.

if type(x) is list:
    print 'a list'
elif type(x) is tuple:
    print 'a tuple'
else:
    print 'neither a tuple or a list'

Там нет ничего плохого в использовании, isinstanceесли это не избыточно. Если переменная должна быть только списком / кортежем, документируйте интерфейс и просто используйте его как таковой. В противном случае проверка вполне разумна:

if isinstance(a, collections.Iterable):
    # use as a container
else:
    # not a container!

У этого типа проверки есть несколько хороших сценариев использования, например, со стандартными строками метода beginwith / ndswith (хотя, если быть точным, они реализованы в C в CPython с использованием явной проверки, чтобы увидеть, является ли это кортежем - есть более одного способа чтобы решить эту проблему, как указано в статье, на которую вы ссылаетесь).

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

Документируйте аргумент как необходимый как последовательность, и используйте его как последовательность. Не проверяйте тип.

Как насчет hasattr(a, "__iter__"):?

Он сообщает, может ли возвращаемый объект быть повторен как генератор. По умолчанию кортежи и списки могут, но не типы строк.

В Python 2.8 type(list) is listвозвращается, false
я бы предложил сравнить тип таким ужасным способом:

if type(a) == type([]) :
  print "variable a is a list"

(по крайней мере, в моей системе, используя anaconda в Mac OS X Yosemite)

Python использует «типизацию утки», то есть, если переменная похожа на утку, это должна быть утка. В вашем случае вы, вероятно, хотите, чтобы он был повторяемым, или хотите получить доступ к элементу по определенному индексу. Вы должны просто сделать это: т.е. использовать объект внутри for var:или var[idx]внутри tryблока, и если вы получите исключение, это не утка ...

>>> l = []
>>> l.__class__.__name__ in ('list', 'tuple')
True

Если вам просто нужно знать, можете ли вы использовать foo[123]нотацию с переменной, вы можете проверить наличие __getitem__атрибута (то, что Python вызывает при доступе по индексу) с помощьюhasattr(foo, '__getitem__')

Должен быть более сложный тест, если вы действительно хотите обрабатывать что-либо как аргумент функции.

type(a) != type('') and hasattr(a, "__iter__")

Хотя обычно достаточно просто объяснить, что функция ожидает повторяемость, а затем выполнить только проверку type(a) != type('').

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

Другой простой способ узнать, является ли переменная списком или кортежем или вообще проверить тип переменной:

    def islist(obj):

        if ("list" in str(type(obj)) ): return True

        else : return False

В принципе, я согласен с Игнасио выше, но вы также можете использовать тип, чтобы проверить, является ли что-то кортежем или списком.

>>> a = (1,)
>>> type(a)
(type 'tuple')
>>> a = [1]
>>> type(a)
(type 'list')