Les techniques suivantes vont compléter vos connaissances sur les boucles et les listes en Python. Elles sont très souvent utilisées, donc essentielles.

break

Lorsqu'elle est exécutée, l'instruction "break" interrompt immédiatement la boucle "for" ou "while" dans laquelle elle se trouve. La condition de sortie de la boucle n'est pas évaluée, la boucle se termine immédiatement au point où "break" est rencontré, et le programme continue son exécution avec les instructions qui suivent la boucle.

Exemple: cette boucle va de 0 à 9, mais un break la stoppera à 3:


		for i in range(10):
			print(i)
			if i == 3:
				break

Affichage:

break ne stoppe QUE la boucle dans laquelle elle se situe DIRECTEMENT, pas une boucle extérieure dans le cas des boucles imbriquées. Par exemple:


		for i in range(5):
			for j in range(5):
				break

Dans ce code ↑ à chaque itération de la première boucle (avec i) la seconde boucle (avec j) n'a jamais l'occasion d'aller jusqu'au bout car elle est stoppée dès sa première itération. Cependant la première boucle va jusqu'au bout.

break en dehors d'une boucle provoque une SyntaxError.

continue

Lorsqu'elle est exécutée dans une boucle, cette instruction permet de passer directement à l'itération suivante. L'itération en cours est simplement interrompue au moment précis du "continue", et la boucle continue normalement avec l'itération suivante. Dans le cas d'une boucle "for", l'incrémentation est effectuée, la condition de fin de boucle est évaluée, puis la prochaine itération démarre (sauf si le test de fin de boucle évalue à False).

Par exemple, cette boucle ↓ va de 0 à 9, mais à chaque itération, si i n'est pas égal 5, on "continue", donc la boucle ne fait pas le print() et passe à l'itération suivante. Le seul cas où le print() peut être exécuté est quand i vaut 5:


		for i in range(10):
			if i != 5:
				continue
			print(i)

Affichage:

5

Tout comme pour break, continue n'affecte QUE la boucle dans laquelle elle se situe DIRECTEMENT, et pas d'éventuelles boucles extérieures. En dehors d'une boucle, continue provoque aussi une SyntaxError.

enumerate()

Lorsqu’on boucle sur une séquence avec une boucle for, et qu’on a besoin d’avoir à la fois l’indice actuel, et sa valeur correspondante, on utilise la fonction enumerate() comme ceci (remarquer que la boucle for supporte l'unpacking d'iterables):


		for indice, valeur in enumerate([10, 20, 30]):
			print(indice, valeur)

Affichage:

0 10
1 20
2 30

enumerate() prend un iterable en paramètre et retourne un objet de type enumerate, qui est un type d'iterator et donc utilisable par la boucle for. Chaque élément de cet iterator est un tuple contenant deux valeurs: en premier l'indice sous forme de int, et en second l'élément correspondant dans l'iterable passé en paramètre.

Exemple:


		>>> e = enumerate([10, 20, 30])
		>>> e
		<enumerate object at 0x000001D11D28ABC0>
		>>> next(e)
		(0, 10)
		>>> next(e)
		(1, 20)
		>>> next(e)
		(2, 30)
		>>> next(e)
		StopIteration

zip()

Lorsqu’on veut boucler sur plusieurs iterables en même temps, on utilise zip() comme ceci:


		L1 = [10, 20, 30]
		L2 = ['Salut', 'à', 'vous']
		L3 = [5, 6, 7]
		for val1, val2, val3 in zip(L1, L2, L3):
			print(val1, val2, val3)

Affichage:

10 Salut 5
20 à 6
30 vous 7

zip() prend un ou plusieurs iterables en paramètre, et retourne un objet de type zip, qui est un type d'iterator. Chaque élément de cet iterator est un tuple. A chaque itération, ce tuple contiendra autant d'élements que d'itérables passés en paramètre. Le 1er élément du tuple sera l'élément à la position actuelle dans le premier iterable, le 2nd élément du tuple sera l'élément à la position actuelle dans le second iterable, et ainsi de suite.

Exemple:


		>>> z = zip([10, 20, 30], ['Salut', 'à', 'vous'], [5, 6, 7])
		>>> z
		<zip object at 0x000001D11D28ABC0>
		>>> next(z)
		(10, 'Salut', 5)
		>>> next(z)
		(20, 'à', 6)
		>>> next(z)
		(30, 'vous', 7)
		>>> next(z)
		StopIteration

Par défaut zip() s'arrête quand l'iterable le plus court a été parcouru, les éléments restants dans les autres seront ignorés.

reversed()

Prend un iterable en paramètre, et retourne un iterator qui renverra les mêmes valeurs mais en ordre inverse.

Exemple:


		>>> r = reversed([10, 20, 30])
		>>> r
		<list_reverseiterator object at 0x000001D11D23DF60>
		>>> next(r)
		30
		>>> next(r)
		20
		>>> next(r)
		10
		>>> next(r)
		StopIteration