Quel est l'objet en Python itertools.répéter?

Chaque utilisation je peux penser pour Python itertools.répéter() classe, je ne peux penser à un autre tout aussi (voire plus) solution acceptable pour obtenir le même effet. Par exemple:

>>> [i for i in itertools.repeat('example', 5)]
['example', 'example', 'example', 'example', 'example']
>>> ['example'] * 5
['example', 'example', 'example', 'example', 'example']

>>> list(map(str.upper, itertools.repeat('example', 5)))
['EXAMPLE', 'EXAMPLE', 'EXAMPLE', 'EXAMPLE', 'EXAMPLE']
>>> ['example'.upper()] * 5
['EXAMPLE', 'EXAMPLE', 'EXAMPLE', 'EXAMPLE', 'EXAMPLE']

Est-il de toute affaire dans laquelle il serait la solution la plus appropriée? Si oui, dans quelles circonstances?

J'ai ajouté un nouvel élément de réponse qui montre l'original en cas d'utilisation de motivation pour itertools répéter. Aussi, j'ai juste mis à jour le Python docs afin de refléter cette note d'utilisation.
3 des 4 exemples de code ne sera pas réellement de travail. La première crée un générateur d'expression, pas un tuple (vous voulez tuple(itertools.repeat('example', 5))), le second multiplie 'example' lui-même pour faire 'exampleexampleexampleexampleexample' parce que ('example') ne pas faire un tuple en premier lieu (vous avez besoin ('example',) * 5), et votre troisième exemple utilise map, qui permettrait le retour d'un map objet, parce que Python 3 map est paresseux (vous auriez l'envelopper dans list pour obtenir le résultat fourni). C'est une question intéressante, mais truquer vos exemples de code ça fait mal.
J'ai été assez nouveau pour Python quand j'ai fait ce post et je viens de rapidement tapé quelques exemples sans contrôle de la production réelle. Un peu pédant, mais j'ai corrigé maintenant de toute façon. Merci! 🙂

InformationsquelleAutor Tyler Crompton | 2012-01-30

19

La itertools.repeat fonction est paresseux; il utilise seulement la mémoire nécessaire pour un élément. D'autre part, la (a,) * n et [a] * n idiomes créer de n copies de l'objet en mémoire. Pour les cinq éléments, la multiplication de l'idiome est probablement mieux, mais vous remarquerez peut-être un problème de ressource si vous avez eu à répéter quelque chose, disons, un million de fois.

Encore, il est difficile d'imaginer que de nombreuses statique utilise pour itertools.repeat. Cependant, le fait que itertools.repeat est un fonction vous permet de l'utiliser dans de nombreuses applications fonctionnelles. Par exemple, vous pourriez avoir un certain fonction de la bibliothèque func qui opère sur un objet iterable d'entrée. Parfois, vous pourriez avoir des pré-construit des listes de différents articles. D'autres fois, vous pouvez le faire fonctionner sur une même liste. Si la liste est grande, itertools.repeat vous permettront d'économiser de la mémoire.

Enfin, repeat rend possible la soi-disant "itérateur de l'algèbre" décrite dans le itertools de la documentation. Même les itertools module lui-même utilise le repeat fonction. Par exemple, le code suivant est donné comme l'équivalent de la mise en œuvre de itertools.izip_longest (même si le vrai code est écrit en C). Notez l'utilisation de repeat sept lignes à partir du bas:
```
class ZipExhausted(Exception):
    pass

def izip_longest(*args, **kwds):
    # izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
    fillvalue = kwds.get('fillvalue')
    counter = [len(args) - 1]
    def sentinel():
        if not counter[0]:
            raise ZipExhausted
        counter[0] -= 1
        yield fillvalue
    fillers = repeat(fillvalue)
    iterators = [chain(it, sentinel(), fillers) for it in args]
    try:
        while iterators:
            yield tuple(map(next, iterators))
    except ZipExhausted:
        pass
```
- Mineur chipoter: [a] * n ne crée pas de n copies de un en mémoire. Il crée n références à une copie unique d'un. Dans certains cas, la différence peut être très importante; essayez a = [[]] * 5; a[0].append(1).
- Bon point. J'oublie que presque tout dans Python est une référence. Je suppose que aussi la réduction de l'utilisation de la mémoire problème un peu, mais je suppose un million de références a encore une importante exigence de ressources.
- Yep, il aurait encore à allouer un tableau de n pointeurs.
InformationsquelleAutor HardlyKnowEm
19

Le but principal de itertools.répétez est de fournir un flux de valeurs constantes pour être utilisé avec carte ou zip:
```
>>> list(map(pow, range(10), repeat(2)))     # list of squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
```
Le but secondaire est qu'il donne un moyen très rapide de la boucle un nombre fixe de fois comme ceci:
```
for _ in itertools.repeat(None, 10000):
    do_something()
```
C'est plus rapide que:
```
for i in range(10000):
    do_something().
```
L'ancien l'emporte, car tout ce qu'il faut faire est de mettre à jour le compteur de référence de l'existant Aucun objet. Ce dernier perd à cause de la range() ou xrange() besoins pour la fabrication de 10 000 integer distinctes des objets.

Note, Guido utilise lui-même que l'accélération de la boucle de la technique des timeit() module. Voir la source à https://hg.python.org/cpython/file/2.7/Lib/timeit.py#l195 :
```
    if itertools:
        it = itertools.repeat(None, number)
    else:
        it = [None] * number
    gcold = gc.isenabled()
    gc.disable()
    try:
        timing = self.inner(it, self.timer)
```
- Cette réponse et repeat est un trésor. Pourquoi est-ce caché dans itertools et pas intégré? for _ in range(x): do() est un modèle commun.
InformationsquelleAutor Raymond Hettinger
14

Votre exemple de foo * 5 ressemble superficiellement similaire à itertools.repeat(foo, 5), mais il est tout à fait différent.

Si vous écrivez foo * 100000, l'interprète devez créer plus de 100 000 exemplaires de foo avant de pouvoir vous donner une réponse. C'est donc un très cher et la mémoire de convivialité opération.

Mais si vous écrivez itertools.repeat(foo, 100000), l'interprète peut retourner un itérateur qui exerce la même fonction, et n'a pas besoin de calculer un résultat jusqu'à ce que vous en avez besoin-dire, en l'utilisant dans une fonction qui veut connaître chaque résultat dans la séquence.

C'est le principal avantage de itérateurs: ils peuvent reporter le calcul d'une partie (ou la totalité) de la liste jusqu'à ce que vous avez vraiment besoin d'une réponse.
- Pourquoi ne pas simplement utiliser for i in range(100000): et ensuite accéder à foo l'intérieur de la boucle au lieu de demander à cette fonction, quelle est la valeur que vous lui avez donné?
- L'itérateur peut être transmis à d'autres choses que d'attendre de n'importe quel type d'itérateur, sans égard pour son intérieur contenu. Vous ne pouvez pas faire la même chose avec une fourchette (il est itératif, mais n'est pas lui-même un itérateur).
- Je comprends votre point, mais aussi loin que la fin de votre commentaire, en Python 3?
- range est un itérateur en Python 3, mais en Python 2, il renvoie une liste. En Python 2, utilisez xrange pour un itérateur; en Python 3, utilisation list(range(...)) pour une liste.
- Désolé, je ne savais pas que cette question a été marqué Python-3. Oui, @mlefavor est correct.
- Pédant: Py3 range et Py2 xrange sont paresseux, mais ils ne sont pas réellement des itérateurs eux-mêmes. Ils sont iterables, pas iteraret. Ils sont immuables séquences (légèrement paralysé sur Python 2 xrange, mais assez complet sur Python 3), seulement ceux qui calculent leur contenu à la demande. Cela fait une différence quand vous réitérer la même deux fois; r = range(10) (xrange sur Py2), suivie par sum(r) puis sum(r) nouveau produira le même résultat à chaque fois; si c'était un itérateur, l'appel de la deuxième serait de produire des 0 (parce que le premier appel d'échappement de l'itérateur).
InformationsquelleAutor John Feminella
2

C'est un itérateur. Gros indice: c'est dans le module itertools. À partir de la documentation liée à:

itertools.répéter(object[, fois])
Faire un itérateur qui renvoie l'objet, encore et encore. S'exécute indéfiniment, à moins que la fois argument est spécifié.

De sorte que vous ne jamais avoir tout ça en mémoire. Un exemple où vous souhaitez l'utiliser, il pourrait être
```
n = 25
t = 0
for x in itertools.repeat(4):
    if t > n:
        print t
    else:
        t += x
```
cela vous permettra un nombre arbitraire de 4s, ou ce que vous pourriez avoir besoin d'une liste infinie de.
- Vous pouvez modifier la ligne 3 à while True: et la x sur la ligne 7 à 4 et qu'il ferait exactement la même chose, serait plus lisible, et serait un peu plus rapide. C'est pourquoi je me demandais si il avait eu un but.
- Remarque: de manière Amusante, sur Python 2, while True: serait plus lent que for x in itertools.repeat(4):, parce que True n'était pas un mot-clé à cette époque, alors while True: chargé et testé pour truthiness sur chaque boucle pour être sûr que personne n'avait choisi (while 1: était un vrai sans condition de boucle infinie). repeat gardé l'itérateur sur la pile (pas de recherche dans le haut-ins portée) et est enregistré que le travail. Heureusement, sur Python 3 True et False sont des mots clés, et while True: est vraiment une inconditionnelle de boucle infinie lors de l'octet de code de niveau.
InformationsquelleAutor machine yearning
2

Comme mentionné avant, il fonctionne bien avec zip:

Un autre exemple:
```
from itertools import repeat

fruits = ['apples', 'oranges', 'bananas']

# Initialize inventory to zero for each fruit type.
inventory = dict( zip(fruits, repeat(0)) )
```
Résultat:
```
{'apples': 0, 'oranges': 0, 'bananas': 0}
```
De le faire sans le répète, j'aurais impliquer len(fruits).
- inventory = {fruit: 0 for fruit in fruits} est plus lisible et un peu plus rapide.
- En effet. Je ne suis pas sûr que j'ai utilisé cette syntaxe avant d'initialiser un dictionnaire. Ou je viens d'utiliser trop de LINQ 🙂 Merci pour le commentaire instructif.
- Si nous allons à la vitesse, dict.fromkeys(fruits, 0) est le plus rapide (pas de seulement trois éléments avec une valeur constante, due à une légère hausse des frais fixes, mais comme le nombre d'éléments dans fruits augmente, dict.fromkeys tire à l'avance, à partir d'environ huit articles); asymptotiquement sur ma machine, il fonctionne dans environ 2/3 le temps de la dict de la compréhension pour d'énormes entrées. Que de 3.6 (avec des garanties de commande pour dicts), dict.fromkeys(x) est une façon vraiment efficace de uniquify intrants tout en préservant la commande (à la différence de set(x), qui perd de la commande).
InformationsquelleAutor Jonathon Reinhart
0

J'ai l'habitude d'utiliser répéter en collaboration avec la chaîne et du cycle. Voici un exemple:
```
from itertools import chain,repeat,cycle

fruits = ['apples', 'oranges', 'bananas', 'pineapples','grapes',"berries"]

inventory = list(zip(fruits, chain(repeat(10,2),cycle(range(1,3)))))

print inventory
```
Met les 2 premiers fruits comme une valeur de 10, puis il passe en boucle les valeurs 1 et 2 pour les autres fruits.

InformationsquelleAutor Stefan Gruenwald

Vous devez vous connecter pour publier un commentaire.