Python: convertir liste de générateur

dire que j'ai une liste

    data = []
    data.append("A")
    data.append("B")
    data.append("C")
    data.append("D")

Comment puis-je convertir celui-ci à un type de générateur ?
Toute l'aider avec un exemple de code est très apprécié...

Trouvé une URL http://eli.thegreenplace.net/2012/04/05/implementing-a-generatoryield-in-a-python-c-extension/

Est-ce que je veux faire ?

google mot-clé "rendement"

OriginalL'auteur swordholder | 2013-04-16

python

>>> (n for n in [1,2,3,5])
<generator object <genexpr> at 0x02A52940>

œuvres en Python 2.7.4+

>>> a2g = lambda x : (n for n in x)
>>> a2g([1,2,3,4,5])
<generator object <genexpr> at 0x02A57CD8>

Edit:

Encore une légère variation d'une lambda générateur de modèle de fabrique

>>> a2g = lambda *args: (n for n in args)
>>> for i in a2g(1,2,3,4, 5): print i

1
2
3
4
5

OriginalL'auteur David

13

Êtes-vous bien sûr, vous voulez créer un générateur? Un générateur est une fonction qui retourne un itérateur de type, construit en utilisant par exemple le yield mot-clé (cf. terme-générateur).
Si tu le veux vraiment, steven-rumbalski's réponse est précisément ce que vous cherchez:
```
data_gen = (y for y in data)
```
La plupart du temps, vous aurez envie de créer directement un iterator objet, par exemple, l'utilisation de la next() méthode. Dans ce cas, la réponse est implicite dans le commentaire par mgilson ci-dessus:
```
data_iter = iter(data)
```
qui est équivalent à data_iter = data.__iter__(), cf. fonctions#iter.

OriginalL'auteur Heinrich Hartmann
6

L'équivalent littéral serait:
```
def data_generator():
    yield 'A'
    yield 'B'
    yield 'C'
    yield 'D'
```
Appelant le générateur de fonction retourne un générateur d'itérateur. En passant le générateur itérateur à la liste constructeur donne:
```
>>> list(data_generator())
['A', 'B', 'C', 'D']
```
Ce générateur itérateur peut également être créé à l'aide d'un générateur d'expression:
```
data_iter = (c for c in 'ABCD')
```
Remarque: Vous avez rempli votre liste avec quatre append consolidés. C'est généralement pas comment vous l'écrire.

Plutôt faire:
```
data = ['A', 'B', 'C', 'D']
```
OriginalL'auteur Steven Rumbalski
2
```
import itertools
iter_data = itertools.chain(data)
```
comme suit:
```
In [10]: data
Out[10]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]: iter_data=itertools.chain(data)

In [12]: iter_data
Out[12]: <itertools.chain at 0x1ce8950>

In [13]: iter_data.next()
Out[13]: 1
```
FWIW, ce n'est pas différente de l' iter_data = iter(data) ... Vous n'êtes pas vraiment le chaînage de quoi que ce soit ici.
pas de chaînage quoi que ce soit? on ne peut pas avoir un seul maillon de la chaîne? 😉
Pas de. Non, vous ne pouvez pas ._.

OriginalL'auteur Cameron Sparr

>>> d = ['A', 'B', 'C', 'D']
>>> 
>>> def gen(d):
...     for i in d:
...             yield i
... 
>>> for i in gen(d):
...     print i
... 
A
B
C
D
>>>

OriginalL'auteur Yarkee

Vous voulez dire quelque chose comme cela?

def gen():
    for x in "ABCD":
        yield x

In [9]: it=gen()

In [10]: next(it)
Out[10]: 'A'

In [11]: next(it)
Out[11]: 'B'

In [12]: next(it)
Out[12]: 'C'

In [13]: next(it)
Out[13]: 'D'

OriginalL'auteur Ashwini Chaudhary

(item for item in listNameHere).next()

C'est la façon de le faire, si je me souviens bien.

>>> a = [0,1,2,3,4]
>>> x = (item for item in a)
>>> x
<generator object <genexpr> at 0x028B8440>
>>> x.next()
0
>>> x.next()
1
>>> x.next()
2

etc etc.

OriginalL'auteur Micaele

Vous devez vous connecter pour publier un commentaire.