pythonic способ преобразовать переменную для списка

Вы можете выполнять прямое сравнение типов, используя type () .

def my_func(input):
    if not type(input) is list:
        input = [input]
    for e in input:
        # do something

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

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

Я бы сказал вам необходимо определить, какие типы данных у вас могут быть, чтобы у вас могли быть:

• любой потомок list против чего-либо еще
  • Протестируйте с isinstance (input, list) (так что ваш пример верен)
• любой тип последовательности, кроме строк ( basestring в Python 2.x, str в Python 3.x)
  • Используйте метакласс последовательности: isinstance (myvar, collections.Sequence), а не isinstance (myvar, str)
• некоторый тип последовательности для известных случаев, например int , str , MyClass
  • Тест с isinstance (input, (int, str, MyClass))
• любой итерации, кроме строк:
  • Протестируйте с

.

    try: 
        input = iter(input) if not isinstance(input, str) else [input]
    except TypeError:
        input = [input]

Ваш подход кажется мне правильным.

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

Так что да, не вижу в этом ничего плохого.

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

isinstance(input, (list, tuple))

или, в более общем смысле, абстрагироваться от вопроса:

def iterable(obj):
  try:
    len(obj)
    return True
  except TypeError:
    return False

, но опять же, в целом, ваш метод прост и правильный , что мне нравится!

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

Однако вы также можете подумать, имеет ли аргумент метод __iter__ или метод __getitem__ . (обратите внимание, что строки содержат __getitem__ вместо __iter __.)

hasattr(arg, '__iter__') or hasattr(arg, '__getitem__')

Это, вероятно, наиболее общее требование для типа, подобного списку, чем только проверка типа.

Вы можете поставить * перед аргументом, таким образом вы всегда получите кортеж:

def a(*p):
  print type(p)
  print p

a(4)
>>> <type 'tuple'>
>>> (4,)

a(4, 5)
>>> <type 'tuple'>
>>> (4,5,)

Но это заставит вас вызвать вашу функцию с переменными параметрами, я не Не знаю, приемлемо ли это для вас.

def a(*p):
  print type(p)
  print p

a(4)
>>> <type 'tuple'>
>>> (4,)

a(4, 5)
>>> <type 'tuple'>
>>> (4,5,)

Но это заставит вас вызвать функцию с переменными параметрами, я не знаю, приемлемо ли это для вас.

def a(*p):
  print type(p)
  print p

a(4)
>>> <type 'tuple'>
>>> (4,)

a(4, 5)
>>> <type 'tuple'>
>>> (4,5,)

Но это заставит вас вызвать функцию с переменными параметрами, я не знаю, приемлемо ли это для вас.

все без изменения ФАКТИЧЕСКОГО входного списка (если список действительно был ;-). Если все, что вам нужно, это один простой цикл для , тогда этот последний шаг не нужен (и действительно бесполезен, если, например, ввод - это огромный открытый файл), и я бы предложил вместо него вспомогательный генератор:

def justLoopOn(input):
  if isinstance(input, basestring):
    yield input
  else:
    try:
      for item in input:
        yield item
    except TypeError:
      yield input

теперь в каждую из ваших функций, требующих такой нормализации аргументов, вы просто используете:

 for item in justLoopOn(input):

Вы можете использовать вспомогательную функцию нормализации даже в другом случае (где вам нужен реальный список для дальнейших гнусных целей); на самом деле, в таких (более редких) случаях вы можете просто сделать:

 thelistforme = list(justLoopOn(input))

, чтобы (неизбежно) несколько сложная логика нормализации находилась в ОДНОМ месте, как и должно быть! -)

input - это огромный открытый файл), и вместо этого я бы предложил вспомогательный генератор:

def justLoopOn(input):
  if isinstance(input, basestring):
    yield input
  else:
    try:
      for item in input:
        yield item
    except TypeError:
      yield input

теперь в каждой из ваших функций, нуждающихся в такой нормализации аргументов, вы просто используете:

 for item in justLoopOn(input):

Вы можете использовать вспомогательную функцию нормализации даже в другой случай (где вам нужен реальный список для дальнейших гнусных целей); на самом деле, в таких (более редких) случаях вы можете просто сделать:

 thelistforme = list(justLoopOn(input))

, чтобы (неизбежно) несколько сложная логика нормализации находилась в ОДНОМ месте, как и должно быть! -)

input - это огромный открытый файл), и вместо этого я бы предложил вспомогательный генератор:

def justLoopOn(input):
  if isinstance(input, basestring):
    yield input
  else:
    try:
      for item in input:
        yield item
    except TypeError:
      yield input

теперь в каждой из ваших функций, нуждающихся в такой нормализации аргументов, вы просто используете:

 for item in justLoopOn(input):

Вы можете использовать вспомогательную функцию нормализации даже в другой случай (где вам нужен реальный список для дальнейших гнусных целей); на самом деле, в таких (более редких) случаях вы можете просто сделать:

 thelistforme = list(justLoopOn(input))

, чтобы (неизбежно) несколько сложная логика нормализации находилась в ОДНОМ месте, как и должно быть! -)

Вы можете поставить * перед аргументом, таким образом, вы