À propos de Python for loop

Le but de cette histoire

• Sachez ce qu'est une boucle Python for (je suis curieux)
• Connaître la différence entre la notation d'inclusion de liste et l'expression du générateur

pour boucle

for_loop.py

for i in [0, 1, 2, 3, 4]:
    print(i)

Quand tu cours

% python for_loop.py
0
1
2
3
4

for i inJe veux savoir comment la chose derrière est utilisée. (Dans le cas de l'exemple ci-dessus, il semble que les éléments de `` [0, 1, 2, 3, 4] '' soient extraits dans l'ordre.)

Essayez de mettre un bel objet

Voyons comment il est atteint en référence à l'erreur d'exécution

duck.py

class Duck(object):
    pass


if __name__ == '__main__':
    for i in Duck():
        print(i)

Quand je le lance, je me fâche si ce n'est pas itérable

% python duck.py
Traceback (most recent call last):
  File "duck.py", line 6, in <module>
    for i in Duck():
TypeError: 'Duck' object is not iterable

• iterable est un objet avec la méthode __ iter__ ()
• A cause de cette définition, je le crois pour le moment

Essayez d'implémenter iterable

On m'a dit de le mettre en œuvre, alors je vais le mettre en œuvre. Mais retourne juste un objet vide

duck.py

class DuckIter(object):
    def __init__(self):
        pass


class Duck(object):
    def __iter__(self):
        return DuckIter()


if __name__ == '__main__':
    for i in Duck():
        print(i)

L'erreur a changé (un pas en avant!)

% python duck.py
Traceback (most recent call last):
  File "duck.py", line 12, in <module>
    for i in Duck():
TypeError: iter() returned non-iterator of type 'DuckIter'

• iterator est un objet qui a une méthode `` next () ''
• Pour Python3, la méthode `` next () ''

Essayez d'implémenter l'itérateur

Essayez de crier trois fois.

duck.py

class DuckIter(object):
    def __init__(self):
        self._count = 3

    def next(self):
        if self._count > 0:
            self._count -= 1
            return "quack"
        raise StopIteration()


class Duck(object):
    def __iter__(self):
        return DuckIter()


if __name__ == '__main__':
    for i in Duck():
        print(i)

Plus d'erreurs lors de l'exécution

% python duck.py
quack
quack
quack

Le canard a sonné!

Typage de canard

If it walks like a duck and quacks like a duck, it must be a duck https://ja.wikipedia.org/wiki/ダック・タイピング

L'objet lui-même détermine ce que l'objet peut faire (Indépendamment de l'héritage qu'ils ont)

Dans le cas de l'exemple précédent

• Duck: Il a été considéré comme itérable car il a une méthode `` __ iter__ () ''.
• DuckIter: Il a été considéré comme un itérateur car il a une méthode `` next () ''.

Cela nous a permis de tourner la boucle for:

for i in Duck():
    print(i)

Cette notation est à peu près la même que ci-dessous

iter = Duck().__iter__()
while True:
    try:
        i = iter.next()
        print(i)
    except StopIteration:
        break

En d'autres termes, le flux de traitement de la boucle for

1. Obtenez l'itérateur
2. Appelez la méthode next () de l'itérateur
3. S'il ne s'agit pas de StopIteration, exécutez "Traitement en boucle" et passez à 2. à nouveau.

Un peu de pratique

Créons un objet avec un itérateur dans l'ordre inverse de la liste

>>> lst = [0, 1, 2, 3, 4]
>>> rev = RevList(lst)
>>> for r in rev:
...     print(r)
...
4
3
2
1
0

Pointe:

• Vous pouvez maintenant obtenir "objet avec la méthode`next ()` `méthode" avec __iter__ () ``
• next () '' `` retourne à partir de la fin de la liste d'origine

Réponse 1

• Suivez les conseils avec obéissance
• Ne copiez pas la liste originale, consultez-la

class RevListIter(object):
    def __init__(self, lst):
        self._orig = lst
        self._i = len(lst)

    def next(self):
        if self._i > 0:
            self._i -= 1
            return self._orig[self._i]
        raise StopIteration()


class RevList(object):
    def __init__(self, lst):
        self._orig = lst

    def __iter__(self):
        return RevListIter(self._orig)


if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    rev = RevList(lst)
    for r in rev:
        print(r)

Réponse 2

• Faites une liste dans l'ordre inverse avec des tranches de pas = -1
• Renvoie l'itérateur de cette liste

class RevList(object):
    def __init__(self, lst):
        self._orig = lst

    def __iter__(self):
        return self._orig[::-1].__iter__()


if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    rev = RevList(lst)
    for r in rev:
        print(r)

Différence entre les deux réponses

• La réponse 1 crée un élément à chaque fois qu'il est utilisé, pas lors de sa création.
• La réponse 2 génère une liste dans l'ordre inverse lors de la création de l'itérateur

Notation d'inclusion de liste et représentation du générateur

Une autre pratique

Créons un itérateur qui met au carré chaque élément d'une liste d'entiers

>>> lst = [0, 1, 2, 3, 4]
>>>pour moi dans quelque chose(lst):
...     print(i)
...
0
1
4
9
16

Deux exemples de réponses

>>> lst = [0, 1, 2, 3, 4]
>>> for i in [x*x for x in lst]:
...     print(i)
...
0
1
4
9
16
>>> for i in (x*x for x in lst):
...     print(i)
...
0
1
4
9
16

Les deux sont des solutions. Voyons la différence entre les deux.

Notation d'inclusion de liste

notation

[f(x) for x in lst]

Exemple de code

list_comprehension.py

def f(x):
    print("%d*%d" % (x, x))
    return x*x

if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    x = [f(x) for x in lst]
    print(type(x))
    for i in x:
        print(i)

Résultat d'exécution

% python list_comprehension.py
0*0
1*1
2*2
3*3
4*4
<type 'list'>
0
1
4
9
16

• Liste des retours
• Calculer avant la boucle et générer la liste des résultats
• Dans une boucle for, récupérez simplement les valeurs dans l'ordre

Représentation du générateur

notation

(f(x) for x in lst)

Exemple de code

generator_expression.py

def f(x):
    print("%d*%d" % (x, x))
    return x*x

if __name__ == '__main__':
    lst = [0, 1, 2, 3, 4]
    x = (f(x) for x in lst)
    print(type(x))
    for i in x:
        print(i)

Résultat d'exécution

% python generator_expression.py
<type 'generator'>
0*0
0
1*1
1
2*2
4
3*3
9
4*4
16

• Renvoie un générateur
• Non calculé avant l'utilisation de la boucle for
• Calculé chaque fois qu'une valeur est récupérée dans une boucle for

Résumé

• Python est un type de canard
• En implémentant __iter__ (), next () '' ``, iterable est terminé.
• En Python3 `` `__next () __```
• La boucle For récupère les valeurs dans l'ordre de l'itérateur et fait tourner le processus
• Notation pour rendre itérable à partir de la liste
• compréhension de liste: calculer lors de la création et générer une liste de résultats
• expression du générateur: ne pas calculer lors de la création. Calculé à chaque utilisation
• En relation: fonction de carte
• En Python2, équivalent à la compréhension de liste → renvoie la liste
• En Python3, équivalent à l'expression du générateur → retourne l'itérateur