Y a-t-il un besoin de range(len(a))?

Question

On trouve fréquemment des expressions de ce type dans les questions python sur SO. Que ce soit pour accéder à tous les éléments de l'itérable

for i in range(len(a)):
    print(a[i])

Ce qui est simplement une façon maladroite d'écrire:

for e in a:
    print(e)

Ou pour assigner des éléments de l'itérable:

for i in range(len(a)):
    a[i] = a[i] * 2

Ce qui devrait être le même que:

for i, e in enumerate(a):
     a[i] = e * 2
# Ou si ce n'est pas trop coûteux de créer un nouvel itérable
a = [e * 2 for e in a]

Ou pour filtrer sur les indices:

for i in range(len(a)):
    if i % 2 == 1: continue
    print(a[i])

Ce qui pourrait être exprimé comme ceci:

for e in a [::2]:
    print(e)

Ou lorsque vous avez juste besoin de la longueur de la liste, et pas de son contenu:

for _ in range(len(a)):
    faireQuelqueChoseNonLiéA()

Ce qui pourrait être:

for _ in a:
    faireQuelqueChoseNonLiéA()

En python nous avons enumerate, le slicing, filter, sorted, etc... Comme les constructions for en python sont destinées à itérer sur des itérables et non seulement des plages d'entiers, y a-t-il des cas d'utilisation réels où vous avez besoin de in range(len(a))?

Answer 1

Un problème avec for i, num in enumerate(a) est que num ne change pas lorsque vous changez a[i]. Par exemple, cette boucle :

for i, num in enumerate(a):
    while num > 0:
        a[i] -= 1

ne se terminera jamais. Bien sûr, vous pourriez toujours utiliser enumerate tout en remplaçant chaque utilisation de num par a[i], mais cela va à l'encontre du but même de enumerate, donc utiliser for i in range(len(a)) devient simplement plus logique et lisible.

Answer 2

Avoir une plage d'indices est utile pour certains problèmes plus sophistiqués en combinatoire. Par exemple, pour obtenir toutes les partitions possibles d'une liste en trois sections non vides, l'approche la plus simple est de trouver toutes les combinaisons de points distincts entre la première et la deuxième section et entre la deuxième et la troisième section. Cela revient à des paires ordonnées d'entiers choisis parmi les indices valides dans la liste (à l'exception de zéro, car cela rendrait la première partition vide). Ainsi :

>>> from itertools import combinations
>>> def trois_parties(sequence):
...     for i, j in combinations(range(1, len(sequence)), 2):
...         yield (sequence[:i], sequence[i:j], sequence[j:])
... 
>>> list(trois_parties('exemple'))
[('e', 'x', 'ample'), ('e', 'xa', 'mple'), ('e', 'xam', 'ple'), ('e', 'xamp', 'le'), ('e', 'xampl', 'e'), ('ex', 'a', 'mple'), ('ex', 'am', 'ple'), ('ex', 'amp', 'le'), ('ex', 'ampl', 'e'), ('exa', 'm', 'ple'), ('exa', 'mp', 'le'), ('exa', 'mpl', 'e'), ('exam', 'p', 'le'), ('exam', 'pl', 'e'), ('examp', 'l', 'e')]

Answer 3

Je ne comprends pas pourquoi personne n'a mentionné son utilité pour suivre l'index de l'élément sans avoir à ajouter un compteur à l'intérieur de la boucle.

lst = ["a", "b", "c"]
for i in range(len(lst)):
    print(f"Élément actuel : \"{lst[i]}\". Index de l'élément : \"{i}\".")

'''
Sortie :
Élément actuel : "a". Index de l'élément : "0".
Élément actuel : "b". Index de l'élément : "1".
Élément actuel : "c". Index de l'élément : "2".
'''

Answer 4

Mon code est :

s=["9"]*int(input())
for I in range(len(s)):
    while not set(s[I])<=set('01'):s[i]=input(i)
print(bin(sum([int(x,2)for x in s]))[2:])

C'est un additionneur binaire mais je ne pense pas que la plage len ou l'intérieur peuvent être remplacés pour le rendre plus petit/meilleur.

Answer 5

Je pense que c'est utile pour tqdm si vous avez une grande boucle et que vous voulez suivre la progression. Cela affichera une barre de progression :

from tqdm import tqdm

empty_list = np.full(len(items), np.nan)
for i in tqdm(range(len(items))):
    empty_list[i] = do_something(items[i])

Cela ne montrera pas la progression, du moins dans le cas où je l'utilisais :

empty_list = np.full(len(items), np.nan)
for i, _ in tqdm(enumerate(items)):
        empty_list[i] = do_something(items[i])

Il ne montrait que le nombre d'itérations. Pas aussi utile.