Python, découvrez qu'une liste n'a pas d'élément spécifique

Question

Disons qu'il existe une liste a qui contient à la fois des chiffres et des lettres. Y at-il un moyen rapide de découvrir que la liste ne contient pas d'élément spécifique. Je prévois de l'utiliser dans des conditions.

Answer 1

Peut-être

3 not in [1, 2, "a"] 
# True 

Answer 2

Note: Si vous pouvez mettre les éléments clés comme d'un dict puis tester l'adhésion est beaucoup plus rapide grâce à l'algorithme de hachage. Ce sera seulement un problème si votre liste est très longue ou votre application fait beaucoup de ce genre de chose. Sinon, "X pas dans Y" comme le dit Sven.

Answer 3

voulez-vous dire

bool([x for x in alist if isinstance(x, int)]) 

meilleure version (par Sven Marnach):

any(isinstance(x, int) for x in alist) 

?

Answer 4

Cela dépend de ce que vous essayez de faire. Si la vitesse n'a pas d'importance, utilisez une première. Si cela est important, cela dépendra si vous pouvez vous permettre de convertir votre liste en une structure de données différente (c'est-à-dire si vous recherchez souvent des éléments dans la liste), taille, etc ...

Pour donner une idée :

import timeit 

a = range(10000) 
da = dict(zip(a, [None for i in a])) 

def list_first(): 
    return 0 in a 

def dict_first(): 
    return 0 in da 

def list_last(): 
    return 9999 in a 

def dict_last(): 
    return 9999 in da 

if __name__ == "__main__": 
    for f in ["list_first", "dict_first", "list_last", "dict_last"]: 
     t = timeit.Timer("%s()" % f, setup="from __main__ import %s" % f) 
     print min(t.repeat(number=10000)) 

Cela me donne:

0.00302004814148 
0.00318598747253 
4.21943712234 
0.004145860672 

Si vous recherchez un élément qui est au début de la liste, en utilisant un dict ne roulez pas trop vite les choses, comme prévu. Si vous cherchez un objet à la fin, alors la différence est très significative (3 ordres de grandeur), bien que comme prévu: dict utiliser hashtable, les listes doivent rechercher chaque élément l'un après l'autre. Si les éléments sont comparables, vous pouvez également obtenir une accélération significative en triant votre séquence et en utilisant une recherche binaire (log (N) au lieu de N, log (N) étant relativement rapide comparée à O (1) pour N pas trop gros en pratique pour python), ou en utilisant des structures plus avancées (arbre de recherche binaire, etc ...). Cela peut devenir assez complexe - les structures de données pour la recherche rapide est l'un des problèmes les plus étudiés dans CS après tout.