Python vérifier si tous les éléments d'une liste sont du même type

Comment est-ce possible en python pour vérifier (sans vérifier individuellement chaque élément si possible) si les éléments d'une liste sont du même type?

Par exemple, je voudrais avoir une fonction pour vérifier que chaque élément de cette liste est de type entier (ce qui est clairement faux):

x=[1, 2.5, 'a']

def checkIntegers(x):
    # return true if all elements are integers, false otherwise

Comment pourriez-vous le faire sans vérification de chaque élément? Il n'y a aucun moyen de savoir quelque chose sur un élément que vous n'avez pas regardé.
vous pouvez court-circuit dès que vous trouvez une mauvaise.
Semble que l'utilisation de all est le chemin...
oui... j'ai pensé que l'OP a demandé une solution qui n'implique pas de l'itération à tous.

InformationsquelleAutor linello | 2012-11-06

89

Essayez d'utiliser all en conjonction avec isinstance:
```
all(isinstance(x, int) for x in lst)
```
Vous pouvez même vérifier plusieurs types avec isinstance si c'est souhaitable:
```
all(isinstance(x, (int, long)) for x in lst)
```
Pas que ce sera de recueillir les classes héritées ainsi. par exemple:
```
class MyInt(int):
     pass

print(isinstance(MyInt('3'),int)) #True
```
Si vous besoin de vous limiter à seulement entiers, vous pouvez utiliser all(type(x) is int for x in lst). Mais c'est un TRÈS rares.

Un plaisir de fonction vous pouvez écrire avec de c'est l'un qui renvoie le type du premier élément dans une séquence si tous les autres éléments sont du même type:
```
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
```
Cela fonctionne pour n'importe quel itérable, mais il va consommer "itérateurs" dans le processus.

Plaisir un autre fonction de la même veine qui renvoie l'ensemble des bases communes:
```
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
```
- Notez que homogeneous_type() (je suppose que c'est ce que la fonction est censé être appelé) erreurs pour vider les itérateurs. En outre, le résultat dépend de l'ordre des éléments dans l'itérable (je suppose que c'est ce que vous entendez par "itérateur"), ce qui n'est pas ce que je m'attends à partir d'une fonction de ce nom. (Un exemple serait [0, False] et [False, 0].)
- Je suppose que c'est un point raisonnable. Je pense que c'est bien d'une erreur sur vide itérateurs (en fait, je considère que quand j'ai écrit la fonction) ... Quel en sera le résultat dans le cas d'un vide itératif? Aussi loin que la transmission d'une liste de [0, False] ou [False, 0], j' pourrait résoudre qu'en faisant all( type(x) is first_type for x in iseq ), mais il me semble que la fonction serait plus utile s'il vérifié OK pour les sous-classes ainsi.
- Enfin, Oui, je ne veux dire iterable. Pour la sémantique, quels termes utiliseriez-vous pour décrire iterables qui peut être consommée (iter(...) ou générateurs) vs iterables qui ne le peuvent pas (list, tuple, ...)? (Et merci pour regarder à cette critique. Espérons que ça va faire pour une meilleure réponse 🙂
- all() a aussi l'avantage dans le fait qu'elle court-circuit et de s'arrêter dès qu'il rencontre un False valeur à partir du générateur d'expression.
- Basé sur la question du code de l'exemple, ne devrait pas x être l'objet de liste?
- Viens de réaliser que all retourne True vide itératif, qui est pourquoi homogeneous_type travaille pour des séquences de longueur 1. Astucieux!
InformationsquelleAutor mgilson
3

À l'aide de any(), pas besoin de parcourir toute la liste. Juste en pause dès que l'objet qui n'est pas int ou long est trouvé:
```
>>> 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
```
- La logique est beaucoup plus propre avec all, mais je suppose que not any(not condition ...) travaille trop. +1 pour vos efforts, je suppose (et pour démontrer all's de contrepartie, ce qui est tout aussi utile.)
- Cétait pour moi quand j'ai vu votre comment :), sinon j'ai été heureux avec all() en fonction de la solution.
- all aussi les courts-circuits, donc il n'y a pas vraiment de différence entre le présent et @mgilson de la solution. C'est plus un exercice de logique...
- Génériquement parlant, je pense que ce que vous devez faire est de vérifier si aucun élément n'est pas le même type que le premier. c'est à dire any(not isinstance(e,type(seq[0])) for e in seq[1:])
- En supposant que vous pouvez découper seq de cours. Sinon, vous devez utiliser iter et next -- ce Qui vous permet d'économiser les frais généraux de fabrication d'une copie, mais c'est généralement assez bon marché pour les listes.
- %timeit all(isinstance(x, basestring) for x in list_w_int_or_str) prend moins de temps que %timeit not any(not isinstance(x, basestring) for x in list_w_int_or_str)
InformationsquelleAutor Ashwini Chaudhary
2
```
>>> 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
```
- isinstance() doit être préférée à l' type().
- Lequel des deux est le plus rapide, isinstance() ou type()?
- isinstance(i,(int,long)) serait de travailler à la place.
- isinstance(i,(int,long)) est court. ce n'est pas une question de vitesse, de type() échouera pour les sous-classes d'int
- ouais, je viens de remarquer aussi que vous me battre pour la réponse de toute façon. 🙂
InformationsquelleAutor Inbar Rose
1

La façon la plus simple pour vérifier si une liste est composée de omogeneous éléments peuvent être à l'égard du groupe de la fonction du module itertools:
```
from itertools import groupby
len(list(groupby(yourlist,lambda i:type(i)))) == 1
```
Si le th len est différent de celui qu'il signifie qu'il a trouvé de différents types dans la liste.
C'est le problème de l'exécution par l'ensemble de la séquence.
Si vous voulez un paresseux version, vous pouvez écrire une fonction pour ça:
```
def same(iterable):
    iterable = iter(iterable)
    try:
        first = type(next(iterable))
        return all(isinstance(i,first) for i in iterable)
    except StopIteration:
        return True
```
Cette fonction stocker le type du premier élément et arrêter dès qu'elle trouve un autre type dans l'un des éléments dans la liste.

Deux de ces méthodes sont fortement sensible à la nature, donc il va voir que différentes int et float, mais ce doit être aussi proche que vous pouvez obtenir à votre demande

EDIT:

remplacé le pour le cycle avec un appel à tous, comme suggéré par mgilson

en cas de vide itérateur elle renvoie True pour être cohérent avec le comportement de la bulitin toutes les fonctions
- Pour moi, cela semble être une très compliquées façon de faire une tâche simple ...
- cela peut être fait facilement avec any(), voir ma solution.
- La première demande de l'OP n'est pas de vérifier tous les éléments d'un type spécifique, mais de vérifier si tous les éléments étaient de même type, indipendently de celui qui a été le premier. C'est une solution à un problème un peu différent.
- mais vous pouvez toujours faire un court-circuit de la version en 3 lignes. a=iter(obj);t=type(next(a));all(isinstance(x,t) for x in a). C'est encore plus facile pour une liste qui est ce que la question est à propos -- t = type(lst[0]); return all(instance(x,t) for x in lst[1:]). Pas trop mal.
- oui, vous pouvez court-circuit, mais elle ne le sera pas nulle itérateurs et déclenche une exception. C'est juste une question de choix, dans mon cas, j'ai visez plutôt le gérer, au lieu de lever
- Au lieu de lambda i: type(i), vous pouvez simplement utiliser type.
InformationsquelleAutor EnricoGiampieri
1

Combinant certaines des réponses déjà données, en utilisant une combinaison de carte(), le type() et set() fournit un à mon humble avis plutôt lisible réponse. En supposant que la limite de ne pas vérifier le type de polymorphismes est ok. Également pas les plus efficaces de calcul de réponse, mais il permet de facilement vérifier si tous les éléments sont du même type.
```
# 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
```
InformationsquelleAutor user1556435
0

Vous pouvez également utiliser type() si vous souhaitez exclure des sous-classes. Voir la différence entre isinstance() et 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
```
Bien que vous ne voulez pas, parce que ce sera de plus en plus fragile. Si y change son type d'une sous-classe de type int, ce code va briser, alors que isinstance() fonctionne toujours.

C'est OK pour utiliser is car il n'est qu'un <type 'int'> en mémoire, de sorte qu'ils doivent retourner le même identité s'ils sont du même type.

InformationsquelleAutor Mark Mikofski

-1

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

          return True

InformationsquelleAutor raton

-1

Je préfère utiliser la carte pour un cas comme celui-ci:

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

InformationsquelleAutor Low Kian Seong

Vous devez vous connecter pour publier un commentaire.