Função de gerador vazio do Python

Em python, pode-se definir facilmente uma função iteradora, colocando a palavra-chave yield no corpo da função, como:

def gen():
    for i in range(100):
        yield i

Como posso definir uma função de gerador que não produz nenhum valor (gera 0 valores), o código a seguir não funciona, pois python não pode saber que é suposto ser um gerador e não uma função normal:

def empty():
    pass

Eu poderia fazer algo como

def empty():
    if False:
        yield None

Mas isso seria muito feio. Existe alguma maneira legal de realizar uma função iteradora vazia?

Você pode usar returnuma vez em um gerador; ele interrompe a iteração sem produzir nada e, portanto, fornece uma alternativa explícita para deixar a função sair do escopo. Portanto, use yieldpara transformar a função em um gerador, mas precedê-lo com returnpara encerrar o gerador antes de produzir qualquer coisa.

>>> def f():
...     return
...     yield
... 
>>> list(f())
[]

Não tenho certeza se é muito melhor do que o que você tem - ele apenas substitui uma ifinstrução no-op por uma instrução no-op yield. Mas é mais idiomático. Observe que apenas usar yieldnão funciona.

>>> def f():
...     yield
... 
>>> list(f())
[None]

Por que não apenas usar iter(())?

Esta pergunta pergunta especificamente sobre uma função de gerador vazia . Por esse motivo, considero que seja uma questão sobre a consistência interna da sintaxe do Python, em vez de uma questão sobre a melhor maneira de criar um iterador vazio em geral.

Se a dúvida for realmente sobre a melhor maneira de criar um iterador vazio, você pode concordar com o Zectbumo sobre o uso iter(()). Porém, é importante observar que iter(())não retorna uma função! Ele retorna diretamente um iterável vazio. Suponha que você esteja trabalhando com uma API que espera um chamável que retorna um iterável. Você terá que fazer algo assim:

def empty():
    return iter(())

(O crédito deve ir para Unutbu por fornecer a primeira versão correta desta resposta.)

Agora, você pode achar o acima mais claro, mas posso imaginar situações em que seria menos claro. Considere este exemplo de uma longa lista de definições de funções geradoras (inventadas):

def zeros():
    while True:
        yield 0

def ones():
    while True:
        yield 1

...

No final dessa longa lista, prefiro ver algo com um yield, como este:

def empty():
    return
    yield

ou, no Python 3.3 e superior (conforme sugerido pelo DSM ), isto:

def empty():
    yield from ()

A presença da yieldpalavra-chave deixa claro à primeira vista que se trata apenas de mais uma função geradora, exatamente como todas as outras. Demora um pouco mais para ver que a iter(())versão está fazendo a mesma coisa.

É uma diferença sutil, mas honestamente acho que as yieldfunções baseadas em-são mais legíveis e sustentáveis.

iter(())

Você não precisa de um gerador. Vamos, pessoal!

Python 3.3 (porque estou em um yield fromchute, e porque @senderle roubou meu primeiro pensamento):

>>> def f():
...     yield from ()
... 
>>> list(f())
[]

Mas tenho que admitir que estou tendo dificuldade em encontrar um caso de uso para o qual iter([])ou (x)range(0)não funcione igualmente bem.

Outra opção é:

(_ for _ in ())

Deve ser uma função geradora? Se não, que tal

def f():
    return iter([])

A maneira "padrão" de fazer um iterador vazio parece ser iter ([]). Eu sugeri tornar [] o argumento padrão para iter (); isso foi rejeitado com bons argumentos, consulte http://bugs.python.org/issue25215 - Jurjen

Como disse @senderle, use isto:

def empty():
    return
    yield

Estou escrevendo esta resposta principalmente para compartilhar outra justificativa para isso.

Uma razão para escolher esta solução acima das outras é que ela é ótima no que diz respeito ao intérprete.

>>> import dis
>>> def empty_yield_from():
...     yield from ()
... 
>>> def empty_iter():
...     return iter(())
... 
>>> def empty_return():
...     return
...     yield
...
>>> def noop():
...     pass
...
>>> dis.dis(empty_yield_from)
  2           0 LOAD_CONST               1 (())
              2 GET_YIELD_FROM_ITER
              4 LOAD_CONST               0 (None)
              6 YIELD_FROM
              8 POP_TOP
             10 LOAD_CONST               0 (None)
             12 RETURN_VALUE
>>> dis.dis(empty_iter)
  2           0 LOAD_GLOBAL              0 (iter)
              2 LOAD_CONST               1 (())
              4 CALL_FUNCTION            1
              6 RETURN_VALUE
>>> dis.dis(empty_return)
  2           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE
>>> dis.dis(noop)
  2           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE

Como podemos ver, o empty_returntem exatamente o mesmo bytecode de uma função vazia regular; o resto executa uma série de outras operações que não mudam o comportamento de qualquer maneira. A única diferença entre empty_returne noopé que o primeiro tem o sinalizador gerador definido:

>>> dis.show_code(noop)
Name:              noop
Filename:          <stdin>
Argument count:    0
Positional-only arguments: 0
Kw-only arguments: 0
Number of locals:  0
Stack size:        1
Flags:             OPTIMIZED, NEWLOCALS, NOFREE
Constants:
   0: None
>>> dis.show_code(empty_return)
Name:              empty_return
Filename:          <stdin>
Argument count:    0
Positional-only arguments: 0
Kw-only arguments: 0
Number of locals:  0
Stack size:        1
Flags:             OPTIMIZED, NEWLOCALS, GENERATOR, NOFREE
Constants:
   0: None

Obviamente, a força desse argumento depende muito da implementação específica do Python em uso; um intérprete alternativo suficientemente inteligente pode perceber que as outras operações não significam nada útil e otimizá-las. No entanto, mesmo se essas otimizações estiverem presentes, elas exigem que o intérprete gaste tempo realizando-as e se proteja contra suposições de otimização sendo quebradas, como o iteridentificador no escopo global sendo rebote para outra coisa (mesmo que isso provavelmente indique um bug se realmente aconteceu). No caso de empty_returnsimplesmente não haver nada para otimizar, mesmo o relativamente ingênuo CPython não perderá tempo com operações espúrias.

generator = (item for item in [])