Méthode 1 :Itération sur des fenêtres consécutives (coulissantes)
Donnés sont :
- Liste Python
lst - Taille de la fenêtre
n
Formulation du problème :Comment parcourir la liste dans fenêtres d'éléments consécutives de taille n , pour qu'à chaque itération, vous puissiez accéder au n éléments suivants dans la liste ?
# INPUT: lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] n = 3 # window # OUTPUT: Window: ['a', 'b', 'c'] Window: ['b', 'c', 'd'] Window: ['c', 'd', 'e'] Window: ['d', 'e', 'f'] Window: ['e', 'f', 'g']
? Solution :Pour itérer sur une liste Python lst dans des fenêtres de taille n , itérer sur tous les indices de liste i de 0 à l'indice du n -ième dernier élément de la liste (inclus). Dans le corps de la boucle, utilisez les indices pour récupérer les fenêtres en découpant lst[i:i+n] . Le découpage est économe en mémoire car il ne crée pas de copies de la liste d'origine.
Voici le code complet :
lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
n = 3
for i in range(len(lst)-n+1):
batch = lst[i:i+n]
print('Window: ', batch) La sortie est :
''' OUTPUT: Window: ['a', 'b', 'c'] Window: ['b', 'c', 'd'] Window: ['c', 'd', 'e'] Window: ['d', 'e', 'f'] Window: ['e', 'f', 'g'] '''
Une variante consiste à itérer sur des fenêtres consécutives de taille 2 :paires !
Méthode 2 :parcourir une liste par paires
Formulation du problème : Comment itérer sur une liste par paires d'éléments ?
Il s'agit d'une variante du problème précédent où la taille de la fenêtre est n=2 . Nous utilisons la même approche :
? Solution :Pour itérer sur une liste Python lst par paires, itérer sur tous les indices de liste i de 0 à l'indice de l'avant-dernier élément de la liste (inclus). Dans le corps de la boucle, utilisez les indices pour récupérer les fenêtres en découpant lst[i:i+2] . Le découpage est économe en mémoire car il ne crée pas de copies de la liste d'origine.
Voici le code complet :
lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
for i in range(len(lst)-1):
pair = lst[i:i+2]
print('Pair: ', pair) La sortie est :
''' OUTPUT: Pair: ['a', 'b'] Pair: ['b', 'c'] Pair: ['c', 'd'] Pair: ['d', 'e'] Pair: ['e', 'f'] Pair: ['f', 'g'] '''
Méthode 3 :Découpage sur des fenêtres qui ne se chevauchent pas (lots)
Une variante du problème général abordé dans la méthode 1 consiste à parcourir la liste par lots de taille n . Cependant, les fenêtres coulissantes ne doivent pas se chevaucher !
Formulation du problème : Comment parcourir la liste par lots de taille n alors que chaque lot doit avoir des éléments uniques (lots qui ne se chevauchent pas) ?
? Solution :Vous pouvez le faire en modifiant le range() fonction qui définit la variable de boucle i pour inclure également une taille de pas de n . Vous utilisez ensuite le découpage lst[i:i+n] pour accéder au n éléments suivants de chaque index i . Cela se traduit par des fenêtres (lots) de tranches de liste qui ne se chevauchent pas.
lst = ['a', 'b', 'c', 'd', 'e', 'f']
n = 3 # batch size
for i in range(0, len(lst)-n+1, n):
batch = lst[i:i+n]
print('Batch: ', batch) Voici le résultat :
''' OUTPUT: Batch: ['a', 'b', 'c'] Batch: ['d', 'e', 'f'] '''
Découpage en arrière-plan
? Contexte :Le découpage est un concept pour découper une sous-chaîne à partir d'une chaîne donnée. Utiliser la notation de découpage s[start:stop:step] pour accéder à tous les step -ième élément à partir de l'index start (inclus) et se terminant par l'index stop (exclu). Les trois arguments sont facultatifs, vous pouvez donc les ignorer pour utiliser les valeurs par défaut (start=0 , stop=len(lst) , step=1 ). Par exemple, l'expression s[2:4] à partir de la chaîne 'hello' taille la tranche 'll' et l'expression s[:3:2] taille la tranche 'hl' .
