检查列表的所有元素是否属于同一类型

Question

如何检查列表的元素是否属于同一类型，而不是尽可能单独检查每个元素？

例如，我想有一个函数来检查这个列表的每个元素都是一个整数（这显然是错误的）：

x = [1, 2.5, 'a']

def checkIntegers(x):
    # return True if all elements are integers, False otherwise

Answer 1

尝试将all与isinstance结合使用：

all(isinstance(x, int) for x in lst)

如果需要，您甚至可以使用isinstance检查多种类型：

all(isinstance(x, (int, long)) for x in lst)

---

并不是说这也会选择继承的类。 例如：

class MyInt(int):
     pass

print(isinstance(MyInt('3'),int)) #True

如果你需要限制自己只使用整数，你可以使用all(type(x) is int for x in lst) 。 但这是一种非常罕见的情况。

---

你可以用它编写一个有趣的函数，如果所有其他元素都是相同的类型，它会返回序列中第一个元素的类型：

def homogeneous_type(seq):
    iseq = iter(seq)
    first_type = type(next(iseq))
    return first_type if all( (type(x) is first_type) for x in iseq ) else False

这适用于任意可迭代对象，但会在此过程中消耗“迭代器”。

同样的另一个有趣的函数返回一组公共基础：

import inspect
def common_bases(seq):
    iseq = iter(seq)
    bases = set(inspect.getmro(type(next(iseq))))
    for item in iseq:
        bases = bases.intersection(inspect.getmro(type(item)))
        if not bases:
           break
    return bases

---

Answer 2

使用any() ，无需遍历整个列表。 只要找到不是int或long的对象就中断：

>>> not any(not isinstance(y,(int,long)) for y in [1,2,3])
True
>>> not any(not isinstance(y,(int,long)) for y in [1,'a',2,3])
False

Answer 3

结合已经给出的一些答案，使用 map()、type() 和 set() 的组合提供了恕我直言，相当可读的答案。 假设不检查类型多态性的限制是可以的。 也不是计算效率最高的答案，但它可以轻松检查所有元素是否属于同一类型。

# To check whether all elements in a list are integers
set(map(type, [1,2,3])) == {int}
# To check whether all elements are of the same type
len(set(map(type, [1,2,3]))) == 1

Answer 4

检查列表是否由同质元素组成的最简单方法是使用 itertools 模块的 groupby 函数：

from itertools import groupby
len(list(groupby(yourlist,lambda i:type(i)))) == 1

如果 th len 与 one 不同，则意味着它在列表中找到了不同类型的类型。 这存在贯穿整个序列的问题。 如果你想要一个惰性版本，你可以为此编写一个函数：

def same(iterable):
    iterable = iter(iterable)
    try:
        first = type(next(iterable))
        return all(isinstance(i,first) for i in iterable)
    except StopIteration:
        return True

此函数存储第一个元素的类型，并在它在列表中的一个元素中发现不同类型时立即停止。

这两种方法都对类型非常敏感，因此它会看到不同的 int 和 float，但这应该尽可能接近您的请求

编辑：

按照 mgilson 的建议，将 for 循环替换为对所有人的调用

在 void 迭代器的情况下，它返回 True 以与 bulitin all 函数的行为一致

Answer 5

>>> def checkInt(l):
    return all(isinstance(i, (int, long)) for i in l)

>>> checkInt([1,2,3])
True
>>> checkInt(['a',1,2,3])
False
>>> checkInt([1,2,3,238762384762364892364])
True

Answer 6

我喜欢EnricoGiampieri （上面）的功能，但有一个更简单的版本，使用itertools文档的“ all_equal 食谱”部分的 all_equal：

from itertools import groupby

def all_equal(iterable):
    "Returns True if all the elements are equal to each other"
    g = groupby(iterable)
    return next(g, True) and not next(g, False)

所有这些食谱都打包在more_itertools中：

基本上所有这些方法和许多其他方法都可以从 Python Package Index 上的 more-itertools 项目安装：

pip install more-itertools

扩展工具提供与底层工具集相同的高性能。 卓越的内存性能是通过一次处理一个元素而不是一次将整个可迭代对象全部放入内存来保持的。 通过以有助于消除临时变量的功能样式将工具链接在一起，代码量保持较小。 通过优先使用“矢量化”构建块而不是使用会产生解释器开销的 for 循环和生成器来保持高速。

from more_itertools import all_equal

all_equal(map(type, iterable))

或者使用isinstance和已知类型的int （根据原始问题）

all_equal(map(lambda x: isinstance(x, int), iterable))

这两种方式比 Enrico 的建议更简洁，并且像 Enrico 的函数一样处理“void iterators”（例如range(0) ）。

all_equal(map(type, range(0))) # True
all_equal(map(type, range(1))) # True
all_equal(map(type, range(2))) # True

all_equal(map(lambda x: isinstance(x, int), range(0))) # True
all_equal(map(lambda x: isinstance(x, int), range(1))) # True
all_equal(map(lambda x: isinstance(x, int), range(2))) # True

Answer 7

如果要排除子类，也可以使用type() 。 查看isinstance()和type()之间的区别：

>>> not any(not type(y) is int for y in [1, 2, 3])
True
>>> not any(not type(y) == int for y in [1, 'a', 2.3])
False

虽然你可能不想，因为这样会更脆弱。 如果 y 将其类型更改为 int 的子类，此代码将中断，而isinstance()仍然有效。

可以使用is因为内存中只有一个<type 'int'> ，所以如果它们是相同的类型，它们应该返回相同的标识。

Answer 8

我希望您使用此方法，您可以在其中遍历列表中的每个项目并检查它们是否都是相同的数据类型，如果是，则返回 True，否则返回 False。

def checkIntegers(x):
    # return True if all elements are integers, False otherwise
    return all(isinstance(i, type(x[0])) for i in x[1:])

x = [1, 2.5, 'a']
checkIntegers(x)

False

Answer 9

这是一个关于此的简洁函数，目前它检查（在list ）是否所有项目都是整数，或者所有项目是否都是字符串，或者是否是混合数据类型。

def check_item_dtype_in_list(item_range):
    if all(map(lambda x: str(x).isdigit(), item_range)):
        item_range = list(map(int, item_range))
        print('all are integer')
        print(item_range)
        return 
    elif all(isinstance(item, str) for item in item_range):
        print('all are string')
        print(item_range)
        return 
    elif any(map(lambda x: str(x), item_range)):
        print('mixed dtype')
        print(item_range)
        return 

check_item_dtype_in_list(['2', 2, 3])
check_item_dtype_in_list(["2", 2, 'Two'])
check_item_dtype_in_list(['Two', 'Two', 'Two'])
check_item_dtype_in_list([2, 2., 'Two'])

all are integer
[2, 2, 3]
mixed dtype
['2', 2, 'Two']
all are string
['Two', 'Two', 'Two']
mixed dtype
[2, 2.0, 'Two']

Answer 10

    def c(x):
         for i in x:
             if isinstance(i,str):
                   return False
             if isinstance(i,float):
                   return False

          return True

Answer 11

对于这样的情况，我更喜欢使用地图：

from types import IntType
In [21]: map((lambda x: isinstance(x, IntType)), x)
   Out[21]: [True, False, False]