6. Fonctionnalités de haut niveau
6.1 Itération
Si une liste ou un tuple est donné, nous pouvons parcourir la liste ou le tuple à travers une boucle for. Ce parcours est appelé itération. En Python, l'itération se fait avec for...in.
Puisque dict n'est pas stocké dans l'ordre d'une liste, l'ordre des résultats itérés est susceptible d'être différent. Par défaut, dict parcourt les clés. Si vous souhaitez parcourir la valeur, vous pouvez utiliser for value dans d.values(). Si vous souhaitez parcourir la clé et la valeur en même temps, vous pouvez utiliser for k, v dans d.items().
Puisque les chaînes sont également des objets itérables, elles peuvent également être utilisées dans des boucles for :
|
>>> for ch in 'ABC':
... print(ch)
...
A
B
C
|
>>> pour ch dans 'ABC' :
... imprimer(ch)
|
>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False
|
...
|
>>> for i, value in enumerate(['A', 'B', 'C']):
... print(i, value)
...
0 A
1 B
2 C
|
A
B
C
|
Comment déterminer si un objet est un objet itérable ? La méthode est de juger par le type Iterable du module collections :
>>> à partir des collections importer Iterable
|
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
|
>>> isinstance('abc', Iterable) # Indique si str est itérable
|
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
|
Vrai
>>> isinstance([1,2,3], Iterable) # Indique si la liste est itérable
|
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']
|
Vrai
|
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']
|
>>> isinstance(123, Iterable) # Indique si l'entier est itérable
Faux
|
Et si vous souhaitez implémenter une boucle d'indice similaire à Java sur la liste ? La fonction enumerate intégrée de Python peut transformer une liste en une paire index-élément, de sorte que l'index et l'élément lui-même puissent être itérés simultanément dans une boucle for :
>>> pour i, valeur dans enumerate(['A', 'B', 'C']) :
|
>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
at 0x1022ef630>
|
... print(i, valeur)
...
0A
1B
2C
|
6.2 Dérivation de liste
Les compréhensions de listes sont une génération Python intégrée très simple mais puissante qui peut être utilisée pour créer des listes.
Pour générer une liste [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] vous pouvez utiliser list(range(1, 11)).
Lors de l'écriture d'une expression de génération de liste, mettez l'élément x * Vous pouvez également ajouter un jugement if après la boucle for, afin que nous puissions filtrer uniquement les carrés des nombres pairs :
|
>>> [x * x pour x dans la plage (1, 11) si x % 2 == 0]
[4, 16, 36, 64, 100]
|
Vous pouvez également utiliser une boucle à deux niveaux pour générer un arrangement complet :
|
>>> [m + n pour m dans 'ABC' pour n dans 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
|
La génération de liste peut également utiliser deux variables pour générer une liste :
|
>>> d = {'x' : 'A', 'y' : 'B', 'z' : 'C' >
>>> [k + '=' + v pour k, v dans d.items()]
['y=B', 'x=A', 'z=C']
|
Enfin, changez toutes les chaînes d'une liste en minuscules :
|
>>> L = ['Bonjour', 'Monde', 'IBM', 'Apple']
>>> [s.lower() pour s en L]
['bonjour', 'monde', 'ibm', 'pomme']
|
6.3 Expressions génératrices
Si les éléments de la liste peuvent être calculés selon un certain algorithme, les éléments suivants peuvent être calculés en continu pendant la boucle. En Python, ce mécanisme de calcul en boucle est appelé générateur : générateur.
Il existe de nombreuses façons de créer un générateur. La première méthode est très simple. Remplacez simplement [] par () dans une expression de génération de liste pour créer un générateur :
|
>>> L = [x * x pour x dans la plage (10)]
>>>L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x pour x dans la plage (10))
>>>g
à 0x1022ef630>
|
La seule différence entre créer L et g est le [] et () le plus externe est une liste et g est un générateur. Si vous souhaitez les imprimer un par un, vous pouvez obtenir la prochaine valeur de retour du générateur via la fonction next(). Comme nous l'avons dit, le générateur enregistre l'algorithme. Chaque fois que next(g) est appelé, la valeur de l'élément suivant de g est calculée jusqu'à ce que le dernier élément soit calculé. Lorsqu'il n'y a plus d'éléments, une erreur StopIteration est générée.
|
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
File "", line 1, in
StopIteration
|
>>> suivant(g)
0
|
>>> g = (x * x for x in range(10))
>>> for n in g:
... print(n)
...
0
1
4
9
16
25
36
49
64
81
|
>>> suivant(g)
|
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
|
1
>>> suivant(g)
4
>>> suivant(g)
9
|
>>> lax_coordinates = (33.9425, -118.408056)
>>> latitude, longitude = lax_coordinates # 元组拆包
>>> latitude
33.9425
>>> longitude
-118.408056
|
>>> suivant(g)
|
>>> divmod(20, 8) (2, 4)
>>> t = (20, 8)
>>> divmod(*t)
(2, 4)
>>> quotient, remainder = divmod(*t)
>>> quotient, remainder
(2, 4)
|
16
>>> suivant(g)
|
>>> import os
>>> _, filename = os.path.split('/home/luciano/.ssh/idrsa.pub')
>>> filename
'idrsa.pub’
|
25
>>> suivant(g)
|
>>> a, b, *rest = range(5)
>>> a, b, rest
(0, 1, [2, 3, 4])
>>> a, b, *rest = range(3)
>>> a, b, rest
(0, 1, [2])
>>> a, b, *rest = range(2)
>>> a, b, rest
(0, 1, [])
|
36
>>> suivant(g)
49
>>> suivant(g)
64
>>> suivant(g)
81
>>> suivant(g)
Traceback (dernier appel le plus récent) :
Fichier "", ligne 1, dans
Arrêter l'itération
|
La bonne façon est d'utiliser une boucle for, car le générateur est aussi un objet itérable :
|
>>> g = (x * x pour x dans la plage (10))
>>> pour n en g :
... imprimer(n)
...
0
1
4
9
16
25
36
49
64
81
|
Une autre façon de définir un générateur. Si une définition de fonction contient le mot-clé rendement, alors la fonction n'est plus une fonction ordinaire, mais un générateur :
|
déf fib(max):
n, a, b = 0, 0, 1
tandis que n
<🎜>rendement b<🎜>
<🎜>a, b = b, a + b<🎜>
<🎜>n=n+1<🎜>
<🎜> retourner 'terminé'<🎜>
|
<🎜>6.4 Déballage des tuples<🎜>
<🎜> Nous attribuons les éléments du tuple ('Tokyo', 2003, 32450, 0.66, 8014) aux variables city, year, pop, chg et area respectivement, et nous écrivons toutes les affectations avec une seule ligne de déclaration. De même, sur la ligne suivante, un opérateur % mappe les éléments du tuple du passeport aux espaces de chaîne de format dans la fonction d'impression. Ces deux applications sont des applications de décompression de tuples. <🎜>
<🎜> La forme la plus reconnaissable de décompression de tuple est l'affectation parallèle, c'est-à-dire l'affectation des éléments d'un objet itérable à un tuple composé de variables correspondantes. <🎜>
<🎜> Affectation parallèle : <🎜>
|
<🎜>>>> lax_coordonnées = (33.9425, -118.408056)
>>> latitude, longitude = lax_coordonnées # Déballage du tuple
>>> latitude
33.9425
>>> longitude
-118.408056
|
Vous pouvez utiliser l'opérateur * pour diviser un objet itérable en tant que paramètre de fonction :
|
>>>divmod(20, 8) (2, 4)
>>>t = (20, 8)
>>>divmod(*t)
(2, 4)
>>> quotient, reste = divmod(*t)
>>> quotient, reste
(2, 4)
|
Le but du déballage des tuples ici est de permettre à une fonction de renvoyer plusieurs valeurs sous forme de tuples, puis le code qui appelle la fonction peut facilement accepter ces valeurs de retour. Par exemple, la fonction os.path.split() renverra un tuple composé du chemin et du dernier nom du fichier (path, last_part) :
|
>>> importer le système d'exploitation
>>> _, nom de fichier = os.path.split('/home/luciano/.ssh/idrsa.pub')
>>> nom du fichier
'idrsa.pub'
|
En Python, c'est une manière classique d'écrire une fonction en utilisant *args pour obtenir un nombre incertain de paramètres.
En Python 3, ce concept a été étendu à l'affectation parallèle :
|
>>> a, b, *rest = range(5)
>>>a, b, repos
(0, 1, [2, 3, 4])
>>> a, b, *rest = range(3)
>>> a, b, repos
(0, 1, [2])
>>> a, b, *rest = range(2)
>>> a, b, repos
(0, 1, [])
|
En affectation parallèle, le préfixe * ne peut être utilisé que devant un nom de variable, mais cette variable peut apparaître n'importe où dans l'expression d'affectation :
|
>>> a, *body, c, d = range(5)
>>> a, body, c, d
(0, [1, 2], 3, 4)
>>> *head, b, c, d = range(5)
>>> head, b, c, d
([0, 1], 2, 3, 4)
|
>>> a, *corps, c, d = plage(5)
>>> a, corps, c, d
(0, [1, 2], 3, 4)
>>> *tête, b, c, d = plage(5)
>>> tête, b, c, d
([0, 1], 2, 3, 4)
|
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
