Eu tenho uma função de gerador como a seguinte:

def myfunct():
  ...
  yield result

A maneira usual de chamar essa função seria:

for r in myfunct():
  dostuff(r)

Minha pergunta, existe uma maneira de obter apenas um elemento do gerador sempre que eu quiser? Por exemplo, eu gostaria de fazer algo como:

while True:
  ...
  if something:
      my_element = pick_just_one_element(myfunct())
      dostuff(my_element)
  ...

Crie um gerador usando

g = myfunct()

Sempre que quiser um item, use

next(g)

(ou g.next()no Python 2.5 ou abaixo).

Se o gerador sair, ele aumentará StopIteration. Você pode capturar essa exceção, se necessário, ou usar o defaultargumento para next():

next(g, default_value)

Para escolher apenas um elemento de um gerador, use breakem uma fordeclaração oulist(itertools.islice(gen, 1))

De acordo com o seu exemplo (literalmente), você pode fazer algo como:

while True:
  ...
  if something:
      for my_element in myfunct():
          dostuff(my_element)
          break
      else:
          do_generator_empty()

Se você deseja " obter apenas um elemento do gerador [uma vez gerado] sempre que eu quiser " (suponho que 50% seja a intenção original e a intenção mais comum), então:

gen = myfunct()
while True:
  ...
  if something:
      for my_element in gen:
          dostuff(my_element)
          break
      else:
          do_generator_empty()

Dessa maneira, o uso explícito de generator.next()pode ser evitado e o tratamento de final de entrada não requer StopIterationtratamento de exceção (enigmático) ou comparações extras de valores padrão.

A seção else:de fordeclaração é necessária apenas se você quiser fazer algo especial no caso de fim de gerador.

Nota sobre next()/ .next():

No Python3, o .next()método foi renomeado .__next__()por um bom motivo: é considerado de baixo nível (PEP 3114). Antes do Python 2.6, a função interna next()não existia. E foi discutido até a mudança next()para o operatormódulo (o que seria sensato), devido à sua rara necessidade e inflação questionável de nomes internos.

Usar next()sem padrão ainda é uma prática de nível muito baixo - lançar o enigmático StopIterationcomo um raio do nada no código normal do aplicativo abertamente. E o uso next()com o sentinel padrão - que melhor deve ser a única opção para uma entrada next()direta builtins- é limitado e geralmente dá motivo a lógicas / legibilidade não-pitonais estranhas.

Conclusão: Usar next () deve ser muito raro - como usar funções do operatormódulo. Usando for x in iterator, islice, list(iterator)e outras funções aceitar um iterador perfeitamente é a maneira natural de usar iteradores no nível de aplicação - e bastante sempre possível. next()é de baixo nível, um conceito extra, não óbvio - como mostra a pergunta deste tópico. Enquanto, por exemplo, o uso breakem foré convencional.

Não acredito que exista uma maneira conveniente de recuperar um valor arbitrário de um gerador. O gerador fornecerá um método next () para se movimentar, mas a sequência completa não é produzida imediatamente para economizar memória. Essa é a diferença funcional entre um gerador e uma lista.

Para aqueles que estão pesquisando essas respostas para obter um exemplo completo de trabalho para Python3 ... bem, aqui está:

def numgen():
    x = 1000
    while True:
        x += 1
        yield x

nums = numgen() # because it must be the _same_ generator

for n in range(3):
    numnext = next(nums)
    print(numnext)

Isso gera:

1001
1002
1003

Gerador é uma função que produz um iterador. Portanto, depois de ter a instância do iterador, use next () para buscar o próximo item do iterador. Como exemplo, use a função next () para buscar o primeiro item e, posteriormente, use for inpara processar os itens restantes:

# create new instance of iterator by calling a generator function
items = generator_function()

# fetch and print first item
first = next(items)
print('first item:', first)

# process remaining items:
for item in items:
    print('next item:', item)

generator = myfunct()
while True:
   my_element = generator.next()

certifique-se de capturar a exceção lançada após a captura do último elemento

Acredito que a única maneira é obter uma lista do iterador e obter o elemento que você deseja dessa lista.

l = list(myfunct())
l[4]