# `concurrent.interpreters` — Múltiplos interpretadores no mesmo processo

Adicionado na versão 3.14.

Código-fonte: Lib/concurrent/interpreters.py

## Introdução

O módulo `concurrent.interpreters` constrói interfaces de nível mais alto sobre o módulo de mais baixo nível `_interpreters`.

Ver também

Isolando módulos de extensão

  como atualizar um módulo de extensão para oferecer suporte a vários interpretadores

PEP 554

PEP 734

PEP 684

Disponibilidade: not WASI.

Este módulo não funciona ou não está disponível em WebAssembly. Veja Plataformas WebAssembly para mais informações.

## Detalhes-chave

Antes de mergulharmos nos exemplos, há alguns detalhes a serem lembrados sobre o uso de múltiplos interpretadores:

- isolados, por padrão

- nenhuma thread implícita

- nem todos os pacotes PyPI oferecem suporte ao uso em múltiplos interpretadores ainda

No contexto de múltiplos interpretadores, “isolados” significa que diferentes interpretadores não compartilham nenhum estado. Na prática, há alguns dados globais do processo que todos eles compartilham, mas isso é gerenciado pelo tempo de execução.

## Referência

Este módulo define as seguintes funções:

concurrent.interpreters.list_all()

  Retorna `list` de objetos `Interpreter`, um para cada interpretador existente.

concurrent.interpreters.get_current()

  Retorna um objeto `Interpreter` para o interpretador em execução no momento.

concurrent.interpreters.get_main()

  Retorna um objeto `Interpreter` para o interpretador principal.

concurrent.interpreters.create()

  Inicializa um novo interpretador Python (ocioso) e retorna um objeto `Interpreter` para ele.

### Objetos interpretador

class concurrent.interpreters.Interpreter(id)

  Um único interpretador no processo atual.

  Geralmente, `Interpreter` não deve ser chamado diretamente. Em vez disso, use `create()` ou uma das outras funções do módulo.

  id

    (somente leitura)

    O ID do interpretador.

  whence

    (somente leitura)

    Uma string descrevendo de onde o interpretador veio.

  is_running()

    Retorna `True` se o interpretador estiver executando código em seu módulo `__main__` e `False` caso contrário.

  close()

    Finaliza e destrói o interpretador.

  prepare_main(ns=None, **kwargs)

    Liga objetos “compartilháveis” no módulo `__main__` do interpretador.

  exec(code, /, dedent=True)

    Executa o código-fonte fornecido no interpretador (na thread atual).

  call(callable, /, *args, **kwargs)

    Retorna o resultado da chamada da execução da função fornecida no interpretador (na thread atual).

  call_in_thread(callable, /, *args, **kwargs)

    Executa a função fornecida no interpretador (em uma nova thread).

### Exceções

exception concurrent.interpreters.InterpreterError

  Esta exceção, uma subclasse de `Exception`, é levantada quando ocorre um erro relacionado ao interpretador.

exception concurrent.interpreters.InterpreterNotFoundError

  Esta exceção, uma subclasse de `InterpreterError`, é levantada quando o interpretador de destino não existe mais.

exception concurrent.interpreters.ExecutionFailed

  Esta exceção, uma subclasse de `InterpreterError`, é levantada quando o código em execução levanta uma exceção não capturada.

  excinfo

    Um snapshot básico da exceção levantada no outro interpretador.

exception concurrent.interpreters.NotShareableError

  Esta exceção, uma subclasse de `TypeError`, é levantada quando um objeto não pode ser enviado para outro interpretador.

## Uso básico

Criando um interpretador e executando código nele:

    from concurrent import interpreters

    interp = interpreters.create()

    # Executa na thread atual do sistema operacional.

    interp.exec('print("spam!")')

    interp.exec("""if True:
        print('spam!')
        """)

    from textwrap import dedent
    interp.exec(dedent("""
        print('spam!')
        """))

    def run():
        print('spam!')

    interp.call(run)

    # Executa uma nova thread do sistema operacional.

    t = interp.call_in_thread(run)
    t.join()