Як перевірити, чи об’єкт є списком чи кортежем (але не рядком)?

Це те, що я зазвичай роблю для того, щоб переконатися, що вхід є 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 ми хочемо використовувати «набір качок». Отже, все, що діє як список, може трактуватися як список. Отже, не перевіряйте тип списку, просто подивіться, чи він діє як список.

Але рядки також діють як список, і часто це не те, що ми хочемо. Бувають випадки, коли це навіть проблема! Отже, явно перевірте наявність рядка, але потім використовуйте набір качок.

Ось функція, яку я написав для розваги. Це спеціальна версія, 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)

EDIT: Спочатку я писав вище з чеком, __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"

Пітон з ароматом 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 в 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))

І я переконався, що він відповідає вашим потребам.

Я роблю це у своїх тестах.

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

Не перевірений на генераторах, я думаю, що ви залишаєтесь при наступному «виході», якщо його передадуть в генератор, який може накрутити речі вниз за течією. Але знову ж таки, це "єдиний тест"

У "качки набору", як щодо

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