Правильный способ определения параметра последовательности?

Я думаю, что я бы сделал, это проверил, есть ли у объекта определенные методы, указывающие, что это последовательность. Я не уверен, есть ли официальное определение того, что составляет последовательность. Лучшее, о чем я могу думать, это то, что он должен поддерживать нарезку. Итак, вы могли бы сказать:

is_sequence = '__getslice__' in dir(X)

Вы также можете проверить, какие функции вы собираетесь использовать.

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

Вы можете передать свой параметр во встроенную функцию len () и проверить, вызывает ли это ошибку. Как говорили другие, строковый тип требует особой обработки.

Согласно документации, функция len может принимать последовательность (строку, список, кортеж) или словарь.

Вы можете проверить, является ли объект строкой со следующим кодом:

x.__class__ == "".__class__

Исправленный ответ:

Я не знаю, совпадает ли ваше представление о «последовательности» с тем, что в руководствах Python называется «Тип последовательности», но в этом случае вам следует поискать метод __Contains__. Это метод, который Python использует для проверки «если что-то в объекте:»

if hasattr(X, '__contains__'):
    print "X is a sequence"

Мой первоначальный ответ:

Я бы проверил, реализует ли полученный вами объект интерфейс итератора:

if hasattr(X, '__iter__'):
    print "X is a sequence"

Для меня это самое близкое соответствие вашему определению последовательности, поскольку это позволит вам сделать что-то вроде:

for each in X:
    print each

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

Последовательности описаны здесь: https://docs.python.org/2/library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange

Таким образом, последовательности - это не то же самое, что итерируемые объекты. Я думаю, что последовательность должна быть реализована __getitem__, тогда как итерируемые объекты должны реализовывать __iter__. Так, например, строка - это последовательности и не реализует __iter__, объекты xrange - это последовательности и не реализуют __getslice__.

Но, судя по тому, что вы хотели сделать, я не уверен, что вам нужны последовательности, а скорее итерируемые объекты. Так что выбирайте hasattr("__getitem__", X), если вам нужны последовательности, но лучше выбирайте hasattr("__iter__", X), если вам, например, не нужны струны.

Самый простой способ - проверить, можно ли превратить его в итератор. т.е.

try:
    it = iter(X)
    # Iterable
except TypeError:
    # Not iterable

Однако, если вам нужно убедиться, что это перезапускаемая последовательность или последовательность с произвольным доступом (т.е. не генератор и т. д.), Этого подхода будет недостаточно.

Как отмечали другие, строки также являются итеративными, поэтому, если вам нужно так исключить их (особенно важно при рекурсии по элементам, поскольку list (iter ('a')) снова дает ['a'], вам может потребоваться специально исключить их с:

 if not isinstance(X, basestring)

Вы задаете неправильный вопрос. Вы не пытаетесь определять типы в Python; вы обнаруживаете поведение.

1. Напишите другую функцию, которая обрабатывает одно значение. (назовем это _use_single_val).
2. Напишите одну функцию, которая обрабатывает параметр последовательности. (назовем это _use_sequence).
3. Напишите третью родительскую функцию, которая вызывает две указанные выше. (назовите это use_seq_or_val). Окружите каждый вызов обработчиком исключений, чтобы перехватить недопустимый параметр (т. Е. Не одно значение или последовательность).
4. Напишите модульные тесты для передачи правильных и неправильных параметров родительской функции, чтобы убедиться, что она правильно улавливает исключения.

    def _use_single_val(v):
        print v + 1  # this will fail if v is not a value type

    def _use_sequence(s):
        print s[0]   # this will fail if s is not indexable

    def use_seq_or_val(item):    
        try:
            _use_single_val(item)
        except TypeError:
            pass

        try:
            _use_sequence(item)
        except TypeError:
            pass

        raise TypeError, "item not a single value or sequence"

Обновлено: исправлено, чтобы обрабатывать «последовательность или одно значение», о котором говорится в вопросе.

Начиная с версии 2.6, используйте абстрактные базовые классы.

>>> import collections
>>> isinstance([], collections.Sequence)
True
>>> isinstance(0, collections.Sequence)
False

Кроме того, ABC можно настроить для учета исключений, например, не рассматривать строки как последовательности. Вот пример:

import abc
import collections

class Atomic(object):
    __metaclass__ = abc.ABCMeta
    @classmethod
    def __subclasshook__(cls, other):
        return not issubclass(other, collections.Sequence) or NotImplemented

Atomic.register(basestring)

После регистрации класс Атомный можно использовать с это экземпляр и isubclass:

assert isinstance("hello", Atomic) == True

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

Обратите внимание, что в Python 3 изменился синтаксис для определения метаклассов и удален абстрактный суперкласс basestring, что требует использования чего-то вроде следующего:

class Atomic(metaclass=abc.ABCMeta):
    @classmethod
    def __subclasshook__(cls, other):
        return not issubclass(other, collections.Sequence) or NotImplemented

Atomic.register(str)

При желании можно написать код, совместимый как с Python 2.6+ и 3.x, но для этого требуется использование немного более сложной техники, которая динамически создает необходимый абстрактный базовый класс, тем самым избегая синтаксических ошибок из-за разницы в синтаксисе метаклассов. . По сути, это то же самое, что и функция with_metaclass() модуля Бенджамина Петерсона шесть.

class _AtomicBase(object):
    @classmethod
    def __subclasshook__(cls, other):
        return not issubclass(other, collections.Sequence) or NotImplemented

class Atomic(abc.ABCMeta("NewMeta", (_AtomicBase,), {})):
    pass

try:
    unicode = unicode
except NameError:  # 'unicode' is undefined, assume Python >= 3
    Atomic.register(str)  # str includes unicode in Py3, make both Atomic
    Atomic.register(bytes)  # bytes will also be considered Atomic (optional)
else:
    # basestring is the abstract superclass of both str and unicode types
    Atomic.register(basestring)  # make both types of strings Atomic

В версиях до 2.6 в модуле operator есть средства проверки типов.

>>> import operator
>>> operator.isSequenceType([])
True
>>> operator.isSequenceType(0)
False

Я здесь новенький, поэтому не знаю, как это сделать правильно. Хочу ответить на свои ответы:

Проблема со всеми вышеупомянутыми способами заключается в том, что str считается последовательностью (она повторяема, имеет __getitem__ и т. д.), Но обычно обрабатывается как один элемент.

Например, функция может принимать аргумент, который может быть либо именем файла, либо списком имен файлов. Какой самый питонический способ для функции определять первое из второго?

Должен ли я опубликовать это как новый вопрос? Отредактировать исходный?

IMHO, способ python - передать список как * list. Как в:

myfunc(item)
myfunc(*items)

Если проблема связана со строками, определите последовательность и отфильтруйте специальный случай строк:

def is_iterable(x):
  if type(x) == str:
    return False
  try:
    iter(x)
    return True
  except TypeError:
    return False

The problem with all of the above mentioned ways is that str is considered a sequence (it's iterable, has getitem, etc.) yet it's usually treated as a single item.

For example, a function may accept an argument that can either be a filename or a list of filenames. What's the most Pythonic way for the function to detect the first from the latter?

Судя по пересмотренному вопросу, похоже, что вы хотите что-то вроде:

def to_sequence(arg):
    ''' 
    determine whether an arg should be treated as a "unit" or a "sequence"
    if it's a unit, return a 1-tuple with the arg
    '''
    def _multiple(x):  
        return hasattr(x,"__iter__")
    if _multiple(arg):  
        return arg
    else:
        return (arg,)

>>> to_sequence("a string")
('a string',)
>>> to_sequence( (1,2,3) )
(1, 2, 3)
>>> to_sequence( xrange(5) )
xrange(5)

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

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