Obtenir le n-ième élément d'un générateur en Python

Est-il un plus pour la syntaxe concise façon d'écrire la suite?

gen = (i for i in xrange(10))
index = 5
for i, v in enumerate(gen):
    if i is index:
        return v

Il semble presque naturel que d'un générateur doit avoir un gen[index] expression, qui agit comme une liste, mais est fonctionnellement identique au code ci-dessus.

Vous ne voulez pas is dans cette situation (ou dans de nombreuses situations à tous). is est pour la comparaison de l'identité, non pas l'égalité. Vous souhaitez ==. Ce sera sans doute dans cette instance, mais uniquement par le hasard et le détail de l'implémentation.
Depuis que je suis en utilisant des entiers, comment pourrait-il ne fonctionne pas? Est-il même bien pratique de s'attendre à ce que le index objet de mettre en œuvre __eq__ dans de tels cas? (Ça devient hors sujet...)
Essayez 1000 is 500 + 500, il sera (probablement) être False. Voir, par exemple, stackoverflow.com/questions/306313/...
+1 pour cette question. Il semble étrange qu'il n'y a pas moins verbeux-à-dire "le n-ième résultat de gen".
Une autre possibilité est de fermetures à glissière - - - - ils gérer arbitraire des arbres, mais une liste est un arbre aussi. Voir cette mise en œuvre github.com/trivio/zipper/blob/master/tests/test_zipper.py

InformationsquelleAutor Oliver Zheng | 2010-02-20

generator python

51

une méthode serait d'utiliser itertools.islice
```
>>> next(itertools.islice(xrange(10), 5, 5 + 1))
5
```
- Remplacer 5 + 1 avec None il travaille aussi, et lit simple
InformationsquelleAutor cobbal
15

Vous pourriez faire, à l'aide de count comme un exemple de générateur:
```
from itertools import islice, count
next(islice(count(), n, n+1))
```
- Quelle version de Python est-ce? Le code ci-dessus me donne l'erreur AttributeError: 'itertools.islice' object has no attribute 'next' en 3.3.
- En Python 3x, changement next à __next__(), c'est à dire, islice(count, n, n=1).__next__()
- Il est donc préférable d'utiliser next(islice(count(), n, n+1)).
InformationsquelleAutor Mark Byers
3

Je pense que la meilleure façon est :
```
next(x for i,x in enumerate(it) if i==n)
```
(où it est votre itérateur et n est l'indice)

Il ne vous obligent pas à ajouter une importation (comme les solutions à l'aide de itertools), ni à la charge de tous les éléments de l'itérateur en mémoire à la fois (comme les solutions à l'aide de list).

Note 1: cette version jette un StopIteration d'erreur si votre itérateur a moins de n éléments. Si vous souhaitez obtenir None au lieu de cela, vous pouvez utiliser :
```
next((x for i,x in enumerate(it) if i==n), None)
```
Note 2: Il n'y a pas de crochets à l'intérieur de l'appel à next. Ce n'est pas une compréhension de liste, mais un générateur de compréhension, qui ne consomme pas l'original de l'itérateur plus loin que son nième élément.
- Je crois que ça va itérer sur l'ensemble de l'itérateur qui le rend lent lorsque l'itérateur est longue à remplir.
- Non, il ne le fera pas ! Il va parcourir les n premiers éléments (bien sûr), et c'est tout. Pourquoi ne pas l'essayer pour vous-même ?
- J'ai ajouté un deuxième remarque, la rendre plus claire que l'original itérateur n'est pas entièrement consommé
InformationsquelleAutor lovasoa
2

Je dirais contre la tentation de traiter des générateurs comme des listes. Le simple mais approche naïve est la simple one-liner:
```
gen = (i for i in range(10))
list(gen)[3]
```
Mais rappelez-vous, les générateurs ne sont pas comme des listes. Ils ne stockent pas leurs résultats intermédiaires n'importe où, alors vous ne pouvez pas revenir en arrière. Je vais illustrer le problème avec un exemple simple en python repl:
```
>>> gen = (i for i in range(10))
>>> list(gen)[3]
3
>>> list(gen)[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
```
Une fois que vous commencez à aller par le biais d'un générateur pour obtenir la n-ième valeur de la séquence, le générateur est maintenant dans un état différent, et en essayant d'obtenir le n-ième valeur de retourner un résultat différent, ce qui est susceptible d'entraîner un bug dans votre code.

Prenons un coup d'oeil à un autre exemple, basé sur le code de la question.

On pourrait d'abord attendre le suivant pour imprimer 4 deux fois.
```
gen = (i for i in range(10))
index = 4
for i, v in enumerate(gen):
    if i == index:
        answer = v
        break
print(answer)
for i, v in enumerate(gen):
    if i == index:
        answer = v
        break
print(answer)
```
mais tapez ceci dans le repl et vous obtenez:
```
>>> gen = (i for i in range(10))
>>> index = 4
>>> for i, v in enumerate(gen):
...     if i == index:
...             answer = v
...             break
... 
>>> print(answer)
4
>>> for i, v in enumerate(gen):
...     if i == index:
...             answer = v
...             break
... 
>>> print(answer)
9
```
Bonne chance de traçage qui bug vers le bas.

EDIT:

Comme l'a souligné, si le générateur est infiniment longue, vous ne pouvez même pas la convertir en une liste. L'expression list(gen) ne finira jamais.

Il ya une façon, vous pouvez mettre un paresseusement évalué la mise en cache wrapper autour d'une infinie générateur pour la faire ressembler à une liste infinie vous pourriez index en à volonté, mais qui mérite sa propre question et la réponse, et aurait de profondes implications sur les performances.
- Que faire si le générateur est infini?
- Bon point @enedil, je vais l'ajouter à ma réponse.
- Cela devrait être plus haut, comme cela arrive à un coût important en termes de temps. Merci de souligner ce point.
InformationsquelleAutor Brad Richardson
1

Les meilleurs à utiliser est :
exemple :
```
a = gen values ('a','c','d','e')
```
donc la réponse sera :
```
a = list(a) -> this will convert the generator to a list (it will store in memory)
```
puis, quand vous voulez aller de l'indice spécifique, vous aurez à :
```
a[INDEX] -> and you will able to get the value its holds 
```
si vous voulez savoir uniquement le compte ou effectuer des opérations qui pas nécessaire de stocker en mémoire les meilleures pratiques seront :
a = sum(1 in i in a) -> cela permettra de compter le nombre d'objets que vous avez

espère que j'ai fait plus simple.

InformationsquelleAutor Ido Bleicher

La première chose qui m'est venue à l'esprit était:

gen = (i for i in xrange(10))
index = 5

for i, v in zip(range(index), gen): pass

return v

InformationsquelleAutor Alexey

-2

Peut-être vous devriez donner plus de détails sur un cas d'utilisation.
```
>>> gen = xrange(10)
>>> ind=5 
>>> gen[ind]
5
```
- Je editted xrange(10) à (i for i in xrange(10)). S'avère que cette syntaxe fonctionne pour xrange puisqu'il n'est pas vraiment un générateur de...
- xrange antérieure générateurs, et renvoie un xrange objet, qui, de fait, met en œuvre la séquence complète du protocole de.
InformationsquelleAutor ghostdog74
-2

vous pouvez simplement convertir le générateur dans une liste et d'utiliser l'index comme d'habitude:
```
>>> [i for i in range(10)][index]
5
```
InformationsquelleAutor mockingjay

Vous devez vous connecter pour publier un commentaire.