如何检查一个对象是列表还是元组（但不是字符串）？

Question

这是我通常所做的，以确定输入是 list/tuple - 但不是 str。因为很多时候我偶然发现了一些错误，其中函数错误地传递了 str 对象，并且目标函数执行 for x in lst 假设 lst实际上是一个列表或元组。

assert isinstance(lst, (list, tuple))

我的问题是：有更好的方法来实现这一目标吗？

Answer 1

以“鸭子打字”的方式，

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

所有变体实际上并不更改变量的内容，而是意味着重新分配。我不确定在某些情况下这是否是不可取的。

有趣的是，使用“就地”赋值+=，如果lst是一个列表，在任何情况下都不会引发TypeError em> （不是元组）。这就是为什么任务是这样完成的。也许有人可以解释为什么会这样。

Answer 2

鸭子类型的另一个版本，有助于区分字符串类对象和其他序列类对象。

类字符串对象的字符串表示形式是字符串本身，因此您可以检查是否从 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 兼容的所有对象code> 以及各种可迭代对象。

Answer 3

最简单的方法...使用 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

Answer 4

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)

Answer 5

assert (type(lst) == list) | (type(lst) == tuple), "Not a valid lst type, cannot be string"

Answer 6

assert type(lst).__name__ in ('tuple', 'list')

它也很容易扩展以进行更多检查，例如 numpy 数组（ndarray），而无需导入 numpy。

Answer 7

只要这样做

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

Answer 8

在Python中>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

Answer 9

我倾向于这样做（如果我真的、真的不得不这么做的话）：

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

Answer 10

仅在 python 2 中（不是 python 3）：

assert not isinstance(lst, basestring)

实际上是您想要的，否则您会错过很多像列表一样的东西，但不是 list 或 的子类元组。

Answer 11

请记住，在 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() 检查在那里做什么呢？这就是一种黑客行为。但这是必要的。

该函数在任何类似于列表的东西上递归地调用自身。如果我们不对字符串进行特殊处理，那么它将被视为一个列表，并一次分割一个字符。但随后递归调用会尝试将每个字符视为一个列表——并且它会起作用！即使是单字符字符串也可以用作列表！该函数将继续递归调用自身，直到堆栈溢出。

像这样的函数，依赖于分解要完成的工作的每个递归调用，必须对字符串进行特殊处理 - 因为您无法分解低于单字符字符串级别的字符串，甚至无法分解单字符字符串- 字符串的作用类似于列表。

注意：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__() 更基本，所以我改变了上面的内容。

Answer 12

H = "Hello"

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

Answer 13

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 or a dictionary.")

版本 3.3 中的更改：将“Collections Abstract Base Classes”的全局命名空间从 abc 移至 collections.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 or dictionary."

Answer 14

具有 PHP 风格的 Python：

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

Answer 15

试试这个以获得可读性和最佳实践：

Python2 - isinstance()

import types
if isinstance(lst, types.ListType) or isinstance(lst, types.TupleType):
    # Do something

Python3 - isinstance()

import typing
if isinstance(lst, typing.List) or isinstance(lst, typing.Tuple):
    # Do something

希望有帮助。

Answer 16

一般来说，迭代对象的函数适用于字符串以及元组和列表，这一事实更多的是功能而不是错误。您当然可以使用 isinstance 或鸭子类型来检查参数，但为什么要这样做呢？

这听起来像是一个反问句，但事实并非如此。 “为什么我应该检查参数的类型？”的答案可能会建议解决实际问题，而不是感知到的问题。为什么将字符串传递给函数时会出现错误？另外：如果将字符串传递给此函数时是一个错误，那么如果将其他非列表/元组可迭代传递给它，这也是一个错误吗？为什么，或者为什么不呢？

我认为这个问题最常见的答案可能是编写 f("abc") 的开发人员期望该函数的行为就像他们编写的 f([" abc"]) 。在某些情况下，保护开发人员免受自身侵害可能比支持迭代字符串中的字符的用例更有意义。但我首先会认真思考。

Answer 17

我并不是想直接回答OP，而是想分享一些相关的想法。

我对上面@steveha 的回答非常感兴趣，它似乎给出了一个鸭子打字似乎被破坏的例子。然而，再想一想，他的例子表明鸭子类型很难遵守，但它并不表明 str 值得任何特殊处理。

毕竟，非str类型（例如，维护一些复杂递归结构的用户定义类型）可能会导致@steveha srepr函数导致无限递归。虽然这确实不太可能发生，但我们不能忽视这种可能性。因此，我们应该明确当无限递归结果时我们希望 srepr 做什么，而不是在 srepr 中使用特殊大小写的 str。

似乎一种合理的方法是在 list(arg) == [arg] 时简单地中断 srepr 中的递归。事实上，这将完全解决 str 的问题，而不需要任何 isinstance。

然而，一个非常复杂的递归结构可能会导致无限循环，其中 list(arg) == [arg] 永远不会发生。因此，虽然上述检查很有用，但还不够。我们需要对递归深度进行硬性限制。

我的观点是，如果您打算处理任意参数类型，通过鸭子类型处理 str 比处理您可能（理论上）遇到的更通用的类型要容易得多。因此，如果您觉得需要排除 str 实例，您应该要求参数是您明确指定的少数类型之一的实例。

Answer 18

我在tensorflow中找到了一个名为 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))

我已经验证它满足您的需求。

Answer 19

str 对象没有 __iter__ 属性

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

，因此您可以进行检查

assert hasattr(x, '__iter__')

，这也会为任何其他非对象引发一个很好的 AssertionError也是可迭代对象。

编辑：
正如 Tim 在评论中提到的，这仅适用于 python 2.x，不适用于 3.x

Answer 20

我在我的测试用例中这样做。

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

未经在发电机上进行测试，我认为如果通过发电机，您将处于下一个“产量”，这可能会将下游的事情搞砸。但话又说回来，这是一个“单元测试”