the simple way to check if the elements of a list or set are single type?

Question

i need to write a piece of code if all the elements are int or all are string then return true,else return false

[1,'1','a','b'] False
[1,2,3,4] True
['apple','orange','melon'] True
['1', 2, 3, 4] False

my solution is these

def foo(l):
    t = type(l[0])
    if t is not str and t is not int:
        return False
    for x in l:
        if t != type(x):
            return False
    return True

i think it should be better.

Answer 1

This code checks generally if all elements are of the same type:

len(set(type(elem) for elem in elems)) == 1

It answers the title of your question, but works differently than your solution (which returns false for a list of floats).

Answer 2

If you require all your elements in list l to be of a certain type, eg int , then the following is a very efficient method:

any(not isinstance(e, int) for e in l)

It short-circuits, ie on the first occurrence of a list element that is not if type int it evaluates to False .

If you require all your elements in list l to just be of the same type and do not provide this type as input information there is at least one element in the list, then this a is the analogon:

all(type(e) == type(l[0])) for e in l)

Answer 3

type(l[0]) in [int, str] and all( type(e) == type(l[0]) for e in l)

Answer 4

def all_of(iterable, types=[str,int])
    actual_types = set(map(type, iterable))
    return len(actual_types) == 1 and next(iter(actual_types)) in types

Answer 5

In [32]: len(set(map(type, [1, 2, 3]))) == 1
Out[32]: True

In [33]: len(set(map(type, [1, 2, '3']))) == 1
Out[33]: False

Answer 6

If you want to check that the sequence is all of a specific type...

def check_all_same_type(sequence, typ, strict=True):
    if strict:
        return all(type(item) == typ for item in sequence)
    return all(isinstance(item, typ) for item in sequence)

If you just wanted to make sure they're all the same type...

types = set(type(item) for item in sequence)
all_same = (len(types) == 1)
if all_same:
    print "They're all a type of", type(next(iter(types)))

Answer 7

i think it will be faster:

for ints :

>>> ints = set(list(range(10)))
>>> ints
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>>
>>>
>>>
>>> l = set([1,2,3,'d'])
>>> l - ints
set(['d'])
>>>
>>> l = set([1,2,'3','d'])
>>> l - ints
set(['3', 'd'])
>>>

it possible to use this method for str's .

Answer 8

Here's how I might do it. After the initial conditions are checked the function will stop checking as soon as an elem's type fails to pass. It also handles empty lists.

def check_elem_types(l):
    return bool(l) and type(l[0]) in (int, str) and all(type(e) == type(l[0]) for e in l[1:])

If you wanted to handle unicode strings (in Python 2.x), you would instead need this:

def check_elem_types(l):
    return (bool(l) and isinstance(l[0], (int, basestring)) and
            all(type(e) == type(l[0]) for e in l[1:]))