Início / coding / Perguntas / 79428650
Accepted
Rusty
Asked: 2025-02-11 09:05:49 +0800 CST

`map` causando loop infinito em Python 3

  • 772

Tenho o seguinte código:

def my_zip(*iterables):
    iterators = tuple(map(iter, iterables))
    while True:
        yield tuple(map(next, iterators))

Quando my_zipé chamado, ele apenas cria um loop infinito e nunca termina. Se eu inserir uma instrução print (como mostrado abaixo), é revelado que my_zipestá produzindo tuplas vazias infinitamente!

def my_zip(*iterables):
    iterators = tuple(map(iter, iterables))
    while True:
        t = tuple(map(next, iterators))
        print(t)
        yield t

Entretanto, o código equivalente com uma expressão geradora funciona bem:

def my_genexp_zip(*iterables):
    iterators = tuple(iter(it) for it in iterables)
    while True:
        try:
            yield tuple(next(it) for it in iterators)
        except:
            print("exception caught!")
            return

Por que a função mapnão está se comportando como esperado? (Ou, se for o comportamento esperado, como eu poderia modificar seu comportamento para corresponder ao da função usando a expressão do gerador?)

Estou testando com o seguinte código:

print(list(my_genexp_zip(range(5), range(0, 10, 2))))
print(list(my_zip(range(5), range(0, 10, 2))))
python

2 respostas

  1. Best Answer

    Os dois trechos de código que você forneceu não são realmente "equivalentes", com a função usando expressões geradoras tendo notavelmente um manipulador de exceções "pega-tudo" em torno da expressão geradora produzindo itens para saída de tupla.

    E se você realmente tornar as duas funções "equivalentes" removendo o manipulador de exceções:

    def my_listcomp_zip(*iterables):
    iterators = tuple(iter(it) for it in iterables)
    while True:
        yield tuple(next(it) for it in iterators)

print(list(my_listcomp_zip(range(5), range(0, 10, 2))))

    você obterá um rastreamento de:

    Traceback (most recent call last):
  File "test.py", line 4, in <genexpr>
    yield tuple(next(it) for it in iterators)
                ~~~~^^^^
StopIteration

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "test.py", line 6, in <module>
    print(list(my_listcomp_zip(range(5), range(0, 10, 2))))
          ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "test.py", line 4, in my_listcomp_zip
    yield tuple(next(it) for it in iterators)
          ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
RuntimeError: generator raised StopIteration

    Então, está claro agora que a razão pela qual seu loop infinito com while True:pode terminar com sua versão de expressão do gerador da função é porque a RuntimeErroré capturado pelo seu manipulador de exceção catch-all, que retorna da função.

    E isso ocorre porque, desde o Python 3.7 , com a implementação do PEP-479 , StopIterationo gerado dentro de um gerador é automaticamente transformado em um RuntimeErrorpara não ser confundido com o StopIterationgerado por um gerador esgotado.

    Se você tentar seu código em uma versão anterior do Python (como 2.7), você verá que a versão da expressão do gerador da função fica presa no loop infinito também, onde a StopIterationexceção levantada por nextbubbles sai do gerador e é manipulada pelo tupleconstrutor para produzir uma tupla vazia, assim como a mapversão da sua função. E abordar esse efeito de mascaramento de exceção é exatamente o motivo pelo qual o PEP-479 foi proposto e implementado.

    • 3

  2. Sua mapversão tem um loop infinito explícito. A única maneira de parar é se o corpo levantou uma exceção. Mas o mapiterador deixa o StopIterationfrom da nextchamada com falha cair, e então tuplesimplesmente pensa mapque levantou e para (resultando em tuplas vazias assim que o primeiro iterador se esgota).

    Isso é esperado, a roundrobin receita do itertools por exemplo também usa esse truque:

    def roundrobin(*iterables):
    "Visit input iterables in a cycle until each is exhausted."
    # roundrobin('ABC', 'D', 'EF') → A D E B F C
    # Algorithm credited to George Sakkis
    iterators = map(iter, iterables)
    for num_active in range(len(iterables), 0, -1):
        iterators = cycle(islice(iterators, num_active))
        yield from map(next, iterators)

    Aqui, cada nextchamada com falha simplesmente faz com yield fromque o seja interrompido e, então, o algoritmo continua com os iteradores restantes (enquanto algum ainda estiver ativo).

    Você pode consertar sua mapversão, por exemplo, verificando o comprimento da tupla e breaking se for menor que iterables. Ou você pode encadear um RuntimeErroriterador -raising em todos os iteráveis ​​e capturar isso como na sua versão genexp:

    from itertools import chain, repeat

def my_fixed_zip(*iterables):
    def error():
        raise RuntimeError
        yield
    iterators = tuple(map(chain, iterables, repeat(error())))
    while True:
        try:
            yield tuple(map(next, iterators))
        except:
            print("exception caught!")
            return

    Tente isso online!

    • 1

relate perguntas