Início / coding / Perguntas / 77494964
Accepted
Amir reza Riahi
Asked: 2023-11-16 20:53:19 +0800 CST

Por que as compreensões de lista criam uma função internamente?

  • 772

Esta é a desmontagem de uma compreensão de lista em python 3.10:

Python 3.10.12 (main, Jun 11 2023, 05:26:28) [GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import dis
>>> 
>>> dis.dis("[True for _ in ()]")
  1           0 LOAD_CONST               0 (<code object <listcomp> at 0x7fea68e0dc60, file "<dis>", line 1>)
              2 LOAD_CONST               1 ('<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_CONST               2 (())
              8 GET_ITER
             10 CALL_FUNCTION            1
             12 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x7fea68e0dc60, file "<dis>", line 1>:
  1           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                 4 (to 14)
              6 STORE_FAST               1 (_)
              8 LOAD_CONST               0 (True)
             10 LIST_APPEND              2
             12 JUMP_ABSOLUTE            2 (to 4)
        >>   14 RETURN_VALUE

Pelo que entendi ele cria um objeto de código chamado listcompque faz a iteração real e retorna a lista de resultados, e o chama imediatamente. Não consigo entender a necessidade de criar uma função separada para executar este trabalho. Isso é um tipo de truque de otimização?

python

1 respostas

  1. Best Answer

    A principal lógica de criação de uma função é isolar a variável de iteração da compreensão peps.python.org . Criando uma função:

    As variáveis ​​de iteração de compreensão permanecem isoladas e não substituem uma variável de mesmo nome no escopo externo, nem são visíveis após a compreensão

    Mas é ineficiente em tempo de execução . Por causa disso, implementou uma otimização chamada compreensão inlining(PEP 709) peps.python.org que não criará mais um objeto de código separado peps.python.org .

    As compreensões de dicionário, lista e conjunto agora estão embutidas, em vez de criar um novo objeto de função de uso único para cada execução da compreensão. Isso acelera a execução de uma compreensão em até duas vezes . Consulte PEP 709 para obter mais detalhes.

    Aqui está a saída para o mesmo código desmontado com (como você pode ver, não há mais um MAKE_FUNCTIONopcode)

    >>> import dis
>>> 
>>> dis.dis("[True for _ in ()]")
  0           0 RESUME                   0

  1           2 LOAD_CONST               0 (())
              4 GET_ITER
              6 LOAD_FAST_AND_CLEAR      0 (_)
              8 SWAP                     2
             10 BUILD_LIST               0
             12 SWAP                     2
        >>   14 FOR_ITER                 4 (to 26)
             18 STORE_FAST               0 (_)
             20 LOAD_CONST               1 (True)
             22 LIST_APPEND              2
             24 JUMP_BACKWARD            6 (to 14)
        >>   26 END_FOR
             28 SWAP                     2
             30 STORE_FAST               0 (_)
             32 RETURN_VALUE
        >>   34 SWAP                     2
             36 POP_TOP
             38 SWAP                     2
             40 STORE_FAST               0 (_)
             42 RERAISE                  0
ExceptionTable:
  10 to 26 -> 34 [2]
    • 24

relate perguntas