Manière pythonique de combiner la boucle FOR et l'instruction IF

Je sais comment utiliser à la fois les boucles for et les instructions if sur des lignes distinctes, telles que:

>>> a = [2,3,4,5,6,7,8,9,0]
... xyz = [0,12,4,6,242,7,9]
... for x in xyz:
...     if x in a:
...         print(x)
0,4,6,7,9

Et je sais que je peux utiliser une compréhension de liste pour les combiner lorsque les déclarations sont simples, telles que:

print([x for x in xyz if x in a])

Mais ce que je ne trouve pas est un bon exemple n'importe où (pour copier et apprendre) démontrant un ensemble complexe de commandes (pas seulement "print x") qui se produisent après une combinaison d'une boucle for et de quelques instructions if. Quelque chose que j'attendrais ressemble à:

for x in xyz if x not in a:
    print(x...)

N'est-ce pas ainsi que le python est censé fonctionner?

Vous pouvez utiliser des expressions de générateur comme ceci:

gen = (x for x in xyz if x not in a)

for x in gen:
    print x

Selon The Zen of Python (si vous vous demandez si votre code est "Pythonic", c'est l'endroit où aller):

• Beau, c'est mieux que laid.
• Explicite vaut mieux qu'implicite.
• Simple, c'est mieux que complexe.
• L'appartement est meilleur que l'emboîtement.
• La lisibilité compte.

La façon Pythonique d'obtenir les deux s est:sorted intersectionset

>>> sorted(set(a).intersection(xyz))
[0, 4, 6, 7, 9]

Ou ces éléments qui sont xyzmais pas dans a:

>>> sorted(set(xyz).difference(a))
[12, 242]

Mais pour une boucle plus compliquée, vous pouvez l'aplatir en itérant sur une expression de générateur bien nommée et / ou en appelant une fonction bien nommée. Essayer de tout mettre sur une seule ligne est rarement "Pythonic".

Mise à jour suite aux commentaires supplémentaires sur votre question et la réponse acceptée

Je ne sais pas avec quoi vous essayez de faire enumerate, mais s'il as'agit d'un dictionnaire, vous voudrez probablement utiliser les clés, comme ceci:

>>> a = {
...     2: 'Turtle Doves',
...     3: 'French Hens',
...     4: 'Colly Birds',
...     5: 'Gold Rings',
...     6: 'Geese-a-Laying',
...     7: 'Swans-a-Swimming',
...     8: 'Maids-a-Milking',
...     9: 'Ladies Dancing',
...     0: 'Camel Books',
... }
>>>
>>> xyz = [0, 12, 4, 6, 242, 7, 9]
>>>
>>> known_things = sorted(set(a.iterkeys()).intersection(xyz))
>>> unknown_things = sorted(set(xyz).difference(a.iterkeys()))
>>>
>>> for thing in known_things:
...     print 'I know about', a[thing]
...
I know about Camel Books
I know about Colly Birds
I know about Geese-a-Laying
I know about Swans-a-Swimming
I know about Ladies Dancing
>>> print '...but...'
...but...
>>>
>>> for thing in unknown_things:
...     print "I don't know what happened on the {0}th day of Christmas".format(thing)
...
I don't know what happened on the 12th day of Christmas
I don't know what happened on the 242th day of Christmas

Je pense personnellement que c'est la plus jolie version:

a = [2,3,4,5,6,7,8,9,0]
xyz = [0,12,4,6,242,7,9]
for x in filter(lambda w: w in a, xyz):
  print x

Éditer

si vous souhaitez éviter d'utiliser lambda, vous pouvez utiliser une application de fonction partielle et utiliser le module opérateur (qui fournit les fonctions de la plupart des opérateurs).

https://docs.python.org/2/library/operator.html#module-operator

from operator import contains
from functools import partial
print(list(filter(partial(contains, a), xyz)))

Ce qui suit est une simplification / une ligne de la réponse acceptée:

a = [2,3,4,5,6,7,8,9,0]
xyz = [0,12,4,6,242,7,9]

for x in (x for x in xyz if x not in a):
    print(x)

12
242

Notez que le a generatorété maintenu en ligne . Cela a été testé python2.7et python3.6 (notez les parens dans le print;))

J'utiliserais probablement:

for x in xyz: 
    if x not in a:
        print x...

a = [2,3,4,5,6,7,8,9,0]
xyz = [0,12,4,6,242,7,9]  
set(a) & set(xyz)  
set([0, 9, 4, 6, 7])

Vous pouvez également utiliser des générateurs , si les expressions de générateur deviennent trop impliquées ou complexes:

def gen():
    for x in xyz:
        if x in a:
            yield x

for x in gen():
    print x

Utilisez intersectionouintersection_update

• intersection :

  a = [2,3,4,5,6,7,8,9,0]
  xyz = [0,12,4,6,242,7,9]
  ans = sorted(set(a).intersection(set(xyz)))

• intersection_update :

  a = [2,3,4,5,6,7,8,9,0]
  xyz = [0,12,4,6,242,7,9]
  b = set(a)
  b.intersection_update(xyz)

  alors best ta réponse

J'ai aimé la réponse d'Alex , car un filtre est exactement un s'il est appliqué à une liste, donc si vous voulez explorer un sous-ensemble d'une liste en fonction d'une condition, cela semble être le moyen le plus naturel

mylist = [1,2,3,4,5]
another_list = [2,3,4]

wanted = lambda x:x in another_list

for x in filter(wanted, mylist):
    print(x)

cette méthode est utile pour la séparation des préoccupations, si la fonction de condition change, le seul code à manipuler est la fonction elle-même

mylist = [1,2,3,4,5]

wanted = lambda x:(x**0.5) > 10**0.3

for x in filter(wanted, mylist):
    print(x)

La méthode du générateur semble meilleure lorsque vous ne voulez pas de membres de la liste, mais une modification desdits membres, qui semble plus adaptée à un générateur

mylist = [1,2,3,4,5]

wanted = lambda x:(x**0.5) > 10**0.3

generator = (x**0.5 for x in mylist if wanted(x))

for x in generator:
    print(x)

De plus, les filtres fonctionnent avec des générateurs, bien que dans ce cas ce ne soit pas efficace

mylist = [1,2,3,4,5]

wanted = lambda x:(x**0.5) > 10**0.3

generator = (x**0.9 for x in mylist)

for x in filter(wanted, generator):
    print(x)

Mais bien sûr, ce serait quand même bien d'écrire comme ceci:

mylist = [1,2,3,4,5]

wanted = lambda x:(x**0.5) > 10**0.3

# for x in filter(wanted, mylist):
for x in mylist if wanted(x):
    print(x)

Un moyen simple de trouver des éléments communs uniques des listes a et b:

a = [1,2,3]
b = [3,6,2]
for both in set(a) & set(b):
    print(both)