7. Instruções simples¶
Uma instrução simples consiste uma única linha lógica. Várias instruções simples podem ocorrer em uma única linha separada por ponto e vírgula. A sintaxe para instruções simples é:
simple_stmt ::=expression_stmt
|assert_stmt
|assignment_stmt
|augmented_assignment_stmt
|annotated_assignment_stmt
|pass_stmt
|del_stmt
|return_stmt
|yield_stmt
|raise_stmt
|break_stmt
|continue_stmt
|import_stmt
|future_stmt
|global_stmt
|nonlocal_stmt
7.1. Instruções de expressão¶
As instruções de expressão são usadas (principalmente interativamente) para calcular e escrever um valor, ou (geralmente) para chamar um procedimento (uma função que não retorna nenhum resultado significativo; em Python, os procedimentos retornam o valor None
). Outros usos de instruções de expressão são permitidos e ocasionalmente úteis. A sintaxe para uma instrução de expressão é:
expression_stmt ::= starred_expression
Uma instrução de expressão avalia a lista de expressões (que pode ser uma única expressão).
No modo interativo, se o valor não for None
, ele será convertido em uma string usando a função embutida repr()
e a string resultante será gravada na saída padrão em uma linha sozinha (exceto se o resultado é None
, de modo que as chamadas de procedimento não causam nenhuma saída.)
7.2. Instruções de atribuição¶
As instruções de atribuição são usadas para (re)vincular nomes a valores e modificar atributos ou itens de objetos mutáveis:
assignment_stmt ::= (target_list
"=")+ (starred_expression
|yield_expression
) target_list ::=target
(","target
)* [","] target ::=identifier
| "(" [target_list
] ")" | "[" [target_list
] "]" |attributeref
|subscription
|slicing
| "*"target
(Veja a seção Primaries para as definições de sintaxe de attributeref, subscription e slicing.)
Uma instrução de atribuição avalia a lista de expressões (lembre-se de que pode ser uma única expressão ou uma lista separada por vírgulas, a última produzindo uma tupla) e atribui o único objeto resultante a cada uma das listas alvos, da esquerda para a direita.
A atribuição é definida recursivamente dependendo da forma do alvo (lista). Quando um alvo faz parte de um objeto mutável (uma referência de atributo, assinatura ou divisão), o objeto mutável deve, em última análise, executar a atribuição e decidir sobre sua validade e pode levantar uma exceção se a atribuição for inaceitável. As regras observadas pelos vários tipos e as exceções levantadas são dadas com a definição dos tipos de objetos (ver seção A hierarquia de tipos padrão).
A atribuição de um objeto a uma lista alvo, opcionalmente entre parênteses ou colchetes, é definida recursivamente da maneira a seguir.
Se a lista alvo contiver um único alvo sem vírgula à direita, opcionalmente entre parênteses, o objeto será atribuído a esse alvo.
Senão:
Se a lista alvo contiver um alvo prefixado com um asterisco, chamado de alvo “com estrela” (starred): o objeto deve ser um iterável com pelo menos tantos itens quantos os alvos na lista alvo, menos um. Os primeiros itens do iterável são atribuídos, da esquerda para a direita, aos alvos antes do alvo com estrela. Os itens finais do iterável são atribuídos aos alvos após o alvo com estrela. Uma lista dos itens restantes no iterável é então atribuída ao alvo com estrela (a lista pode estar vazia).
Senão: o objeto deve ser um iterável com o mesmo número de itens que existem alvos na lista alvos, e os itens são atribuídos, da esquerda para a direita, aos alvos correspondentes.
A atribuição de um objeto a um único alvo é definida recursivamente da maneira a seguir.
Se o alvo for um identificador (nome):
Se o nome não ocorrer em uma instrução
global
ounonlocal
no bloco de código atual: o nome está vinculado ao objeto no espaço de nomes local atual.Caso contrário: o nome é vinculado ao objeto no espaço de nomes global global ou no espaço de nomes global externo determinado por
nonlocal
, respectivamente.
O nome é vinculado novamente se já estiver vinculado. Isso pode fazer com que a contagem de referências para o objeto anteriormente vinculado ao nome chegue a zero, fazendo com que o objeto seja desalocado e seu destrutor (se houver) seja chamado.
Se o alvo for uma referência de atributo: a expressão primária na referência é avaliada. Deve produzir um objeto com atributos atribuíveis; se este não for o caso, a exceção
TypeError
é levanta. Esse objeto é então solicitado a atribuir o objeto atribuído ao atributo fornecido; se não puder executar a atribuição, ele levanta uma exceção (geralmente, mas não necessariamenteAttributeError
).Nota: Se o objeto for uma instância de classe e a referência de atributo ocorrer em ambos os lados do operador de atribuição, a expressão do lado direito,
a.x
pode acessar um atributo de instância ou (se não existir nenhum atributo de instância) uma classe atributo. O alvo do lado esquerdoa.x
é sempre definido como um atributo de instância, criando-o se necessário. Assim, as duas ocorrências dea.x
não necessariamente se referem ao mesmo atributo: se a expressão do lado direito se refere a um atributo de classe, o lado esquerdo cria um novo atributo de instância como alvo da atribuição:class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3
Esta descrição não se aplica necessariamente aos atributos do descritor, como propriedades criadas com
property()
.Se o alvo for uma assinatura: a expressão primária na referência é avaliada. Deve produzir um objeto de sequência mutável (como uma lista) ou um objeto de mapeamento (como um dicionário). Em seguida, a expressão subscrito é avaliada.
Se o primário for um objeto de sequência mutável (como uma lista), o subscrito deverá produzir um inteiro. Se for negativo, o comprimento da sequência é adicionado a ela. O valor resultante deve ser um inteiro não negativo menor que o comprimento da sequência, e a sequência é solicitada a atribuir o objeto atribuído ao seu item com esse índice. Se o índice estiver fora do intervalo, a exceção
IndexError
será levantada (a atribuição a uma sequência subscrita não pode adicionar novos itens a uma lista).If the primary is a mapping object (such as a dictionary), the subscript must have a type compatible with the mapping’s key type, and the mapping is then asked to create a key/value pair which maps the subscript to the assigned object. This can either replace an existing key/value pair with the same key value, or insert a new key/value pair (if no key with the same value existed).
For user-defined objects, the
__setitem__()
method is called with appropriate arguments.Se o alvo for um fatiamento: a expressão primária na referência é avaliada. Deve produzir um objeto de sequência mutável (como uma lista). O objeto atribuído deve ser um objeto de sequência do mesmo tipo. Em seguida, as expressões de limite inferior e superior são avaliadas, na medida em que estiverem presentes; os padrões são zero e o comprimento da sequência. Os limites devem ser avaliados como inteiros. Se um dos limites for negativo, o comprimento da sequência será adicionado a ele. Os limites resultantes são cortados para ficarem entre zero e o comprimento da sequência, inclusive. Finalmente, o objeto de sequência é solicitado a substituir a fatia pelos itens da sequência atribuída. O comprimento da fatia pode ser diferente do comprimento da sequência atribuída, alterando assim o comprimento da sequência alvo, se a sequência alvo permitir.
Detalhes da implementação do CPython: Na implementação atual, a sintaxe dos alvos é considerada a mesma das expressões e a sintaxe inválida é rejeitada durante a fase de geração do código, causando mensagens de erro menos detalhadas.
Embora a definição de atribuição implique que as sobreposições entre o lado esquerdo e o lado direito sejam “simultâneas” (por exemplo, a, b = b, a
troca duas variáveis), sobreposições dentro da coleção de variáveis atribuídas ocorrem da esquerda para a direita, às vezes resultando em confusão. Por exemplo, o programa a seguir imprime [0, 2]
:
x = [0, 1]
i = 0
i, x[i] = 1, 2 # i is updated, then x[i] is updated
print(x)
Ver também
- PEP 3132 - Descompactação de Iterável Estendida
A especificação para o recurso
*target
.
7.2.1. Instruções de atribuição aumentada¶
A atribuição aumentada é a combinação, em uma única instrução, de uma operação binária e uma instrução de atribuição:
augmented_assignment_stmt ::=augtarget
augop
(expression_list
|yield_expression
) augtarget ::=identifier
|attributeref
|subscription
|slicing
augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|="
(Veja a seção Primaries para as definições de sintaxe dos últimos três símbolos.)
Uma atribuição aumentada avalia o alvo (que, diferentemente das instruções de atribuição normais, não pode ser um descompactação) e a lista de expressões, executa a operação binária específica para o tipo de atribuição nos dois operandos e atribui o resultado ao alvo original. O alvo é avaliado apenas uma vez.
Uma expressão de atribuição aumentada como x += 1
pode ser reescrita como x = x + 1
para obter um efeito semelhante, mas não exatamente igual. Na versão aumentada, x
é avaliado apenas uma vez. Além disso, quando possível, a operação real é executada no local, o que significa que, em vez de criar um novo objeto e atribuí-lo ao alvo, o objeto antigo é modificado.
Ao contrário das atribuições normais, as atribuições aumentadas avaliam o lado esquerdo antes de avaliar o lado direito. Por exemplo, a[i] += f(x)
primeiro procura a[i]
, então avalia f(x)
e executa a adição e, por último, escreve o resultado de volta para a[i]
.
Com exceção da atribuição a tuplas e vários alvos em uma única instrução, a atribuição feita por instruções de atribuição aumentada é tratada da mesma maneira que atribuições normais. Da mesma forma, com exceção do possível comportamento in-place, a operação binária executada por atribuição aumentada é a mesma que as operações binárias normais.
Para alvos que são referências de atributos, a mesma advertência sobre atributos de classe e instância se aplica a atribuições regulares.
7.2.2. instruções de atribuição anotado¶
A atribuição de anotação é a combinação, em uma única instrução, de uma anotação de variável ou atributo e uma instrução de atribuição opcional:
annotated_assignment_stmt ::=augtarget
":"expression
["=" (starred_expression
|yield_expression
)]
A diferença para as Instruções de atribuição normal é que apenas um único alvo é permitido.
Para nomes simples como alvos de atribuição, se no escopo de classe ou módulo, as anotações são avaliadas e armazenadas em uma classe especial ou atributo de módulo __annotations__
que é um mapeamento de dicionário de nomes de variáveis (desconfigurados se privados) para anotações avaliadas. Este atributo é gravável e é criado automaticamente no início da execução do corpo da classe ou módulo, se as anotações forem encontradas estaticamente.
Para expressões como alvos de atribuição, as anotações são avaliadas se estiverem no escopo da classe ou do módulo, mas não armazenadas.
Se um nome for anotado em um escopo de função, esse nome será local para esse escopo. As anotações nunca são avaliadas e armazenadas em escopos de função.
If the right hand side is present, an annotated
assignment performs the actual assignment before evaluating annotations
(where applicable). If the right hand side is not present for an expression
target, then the interpreter evaluates the target except for the last
__setitem__()
or __setattr__()
call.
Ver também
- PEP 526 - Sintaxe para Anotações de Variáveis
A proposta que adicionou sintaxe para anotar os tipos de variáveis (incluindo variáveis de classe e variáveis de instância), em vez de expressá-las por meio de comentários.
- PEP 484 - Dicas de tipo
A proposta que adicionou o módulo
typing
para fornecer uma sintaxe padrão para anotações de tipo que podem ser usadas em ferramentas de análise estática e IDEs.
Alterado na versão 3.8: Agora, as atribuições anotadas permitem as mesmas expressões no lado direito que as atribuições regulares. Anteriormente, algumas expressões (como expressões de tupla sem parênteses) causavam um erro de sintaxe.
7.3. A instrução assert
¶
As instruções assert são uma maneira conveniente de inserir asserções de depuração em um programa:
assert_stmt ::= "assert"expression
[","expression
]
A forma simples, assert expression
, é equivalente a
if __debug__:
if not expression: raise AssertionError
A forma estendida, assert expression1, expression2
, é equivalente a
if __debug__:
if not expression1: raise AssertionError(expression2)
Essas equivalências assumem que __debug__
e AssertionError
referem-se às variáveis embutidas com esses nomes. Na implementação atual, a variável embutida __debug__
é True
em circunstâncias normais, False
quando a otimização é solicitada (opção de linha de comando -O
). O gerador de código atual não emite código para uma instrução assert quando a otimização é solicitada em tempo de compilação. Observe que não é necessário incluir o código-fonte da expressão que falhou na mensagem de erro; ele será exibido como parte do stack trace (situação da pilha de execução).
Atribuições a __debug__
são ilegais. O valor da variável embutida é determinado quando o interpretador é iniciado.
7.4. A instrução pass
¶
pass_stmt ::= "pass"
pass
é uma operação nula — quando é executada, nada acontece. É útil como um espaço reservado quando uma instrução é necessária sintaticamente, mas nenhum código precisa ser executado, por exemplo:
def f(arg): pass # a function that does nothing (yet)
class C: pass # a class with no methods (yet)
7.5. A instrução del
¶
del_stmt ::= "del" target_list
A exclusão é definida recursivamente de maneira muito semelhante à maneira como a atribuição é definida. Em vez de explicar em detalhes, aqui estão algumas dicas.
A exclusão de uma lista alvo exclui recursivamente cada alvo, da esquerda para a direita.
A exclusão de um nome remove a ligação desse nome do espaço de nomes global local ou global, dependendo se o nome ocorre em uma instrução global
no mesmo bloco de código. Se o nome for desvinculado, uma exceção NameError
será levantada.
A exclusão de referências de atributos, assinaturas e fatias é passada para o objeto principal envolvido; a exclusão de um fatiamento é em geral equivalente à atribuição de uma fatia vazia do tipo certo (mas mesmo isso é determinado pelo objeto fatiado).
Alterado na versão 3.2: Anteriormente, era ilegal excluir um nome do espaço de nomes local se ele ocorresse como uma variável livre em um bloco aninhado.
7.6. A instrução return
¶
return_stmt ::= "return" [expression_list
]
return
só pode ocorrer sintaticamente aninhado em uma definição de função, não em uma definição de classe aninhada.
Se uma lista de expressões estiver presente, ela será avaliada, caso contrário, None
será substituído.
return
deixa a chamada da função atual com a lista de expressões (ou None
) como valor de retorno.
Quando return
passa o controle de uma instrução try
com uma cláusula finally
, essa cláusula finally
é executada antes de realmente sair da função.
Em uma função geradora, a instrução return
indica que o gerador está pronto e fará com que StopIteration
seja gerado. O valor retornado (se houver) é usado como argumento para construir StopIteration
e se torna o atributo StopIteration.value
.
Em uma função de gerador assíncrono, uma instrução return
vazia indica que o gerador assíncrono está pronto e fará com que StopAsyncIteration
seja gerado. Uma instrução return
não vazia é um erro de sintaxe em uma função de gerador assíncrono.
7.7. A instrução yield
¶
yield_stmt ::= yield_expression
Uma instrução yield
é semanticamente equivalente a uma expressão yield. A instrução yield pode ser usada para omitir os parênteses que, de outra forma, seriam necessários na instrução de expressão yield equivalente. Por exemplo, as instruções yield
yield <expr>
yield from <expr>
são equivalentes às instruções de expressão yield
(yield <expr>)
(yield from <expr>)
Expressões e instruções yield são usadas apenas ao definir uma função geradora e são usadas apenas no corpo da função geradora. Usar yield em uma definição de função é suficiente para fazer com que essa definição crie uma função geradora em vez de uma função normal.
Para detalhes completos da semântica yield
, consulte a seção Expressões yield.
7.8. A instrução raise
¶
raise_stmt ::= "raise" [expression
["from"expression
]]
Se nenhuma expressão estiver presente, raise
reativa a exceção que está sendo tratada no momento, que também é conhecida como exceção ativa. Se não houver uma exceção ativa no momento, uma exceção RuntimeError
é levantada indicando que isso é um erro.
Caso contrário, raise
avalia a primeira expressão como o objeto de exceção. Deve ser uma subclasse ou uma instância de BaseException
. Se for uma classe, a instância de exceção será obtida quando necessário instanciando a classe sem argumentos.
O tipo da exceção é a classe da instância de exceção, o valor é a própria instância.
A traceback object is normally created automatically when an exception is raised
and attached to it as the __traceback__
attribute.
You can create an exception and set your own traceback in one step using the
with_traceback()
exception method (which returns the
same exception instance, with its traceback set to its argument), like so:
raise Exception("foo occurred").with_traceback(tracebackobj)
The from
clause is used for exception chaining: if given, the second
expression must be another exception class or instance. If the second
expression is an exception instance, it will be attached to the raised
exception as the __cause__
attribute (which is writable). If the
expression is an exception class, the class will be instantiated and the
resulting exception instance will be attached to the raised exception as the
__cause__
attribute. If the raised exception is not handled, both
exceptions will be printed:
>>> try:
... print(1 / 0)
... except Exception as exc:
... raise RuntimeError("Something bad happened") from exc
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
print(1 / 0)
~~^~~
ZeroDivisionError: division by zero
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
raise RuntimeError("Something bad happened") from exc
RuntimeError: Something bad happened
A similar mechanism works implicitly if a new exception is raised when
an exception is already being handled. An exception may be handled
when an except
or finally
clause, or a
with
statement, is used. The previous exception is then
attached as the new exception’s __context__
attribute:
>>> try:
... print(1 / 0)
... except:
... raise RuntimeError("Something bad happened")
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
print(1 / 0)
~~^~~
ZeroDivisionError: division by zero
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
raise RuntimeError("Something bad happened")
RuntimeError: Something bad happened
Exception chaining can be explicitly suppressed by specifying None
in
the from
clause:
>>> try:
... print(1 / 0)
... except:
... raise RuntimeError("Something bad happened") from None
...
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
RuntimeError: Something bad happened
Informações adicionais sobre exceções podem ser encontradas na seção Exceções, e informações sobre como lidar com exceções estão na seção The try statement.
Alterado na versão 3.3: None
agora é permitido como Y
em raise X from Y
.
Added the __suppress_context__
attribute to suppress
automatic display of the exception context.
Alterado na versão 3.11: Se o traceback da exceção ativa for modificado em uma cláusula except
, uma instrução raise
subsequente levantará novamente a exceção com o traceback modificado. Anteriormente, a exceção era levantada novamente com o traceback que tinha quando foi capturada.
7.9. A instrução break
¶
break_stmt ::= "break"
break
só pode ocorrer sintaticamente aninhado em um laço for
ou while
, mas não aninhado em uma função ou definição de classe dentro desse laço.
Ele termina o laço de fechamento mais próximo, pulando a cláusula opcional else
se o laço tiver uma.
Se um laço for
é encerrado por break
, o alvo de controle do laço mantém seu valor atual.
Quando break
passa o controle de uma instrução try
com uma cláusula finally
, essa cláusula finally
é executada antes de realmente sair do laço.
7.10. A instrução continue
¶
continue_stmt ::= "continue"
continue
só pode ocorrer sintaticamente aninhado em um laço for
ou while
, mas não aninhado em uma função ou definição de classe dentro desse laço. Ele continua com o próximo ciclo do laço de fechamento mais próximo.
Quando continue
passa o controle de uma instrução try
com uma cláusula finally
, essa cláusula finally
é executada antes realmente iniciar o próximo ciclo do laço.
7.11. A instrução import
¶
import_stmt ::= "import"module
["as"identifier
] (","module
["as"identifier
])* | "from"relative_module
"import"identifier
["as"identifier
] (","identifier
["as"identifier
])* | "from"relative_module
"import" "("identifier
["as"identifier
] (","identifier
["as"identifier
])* [","] ")" | "from"relative_module
"import" "*" module ::= (identifier
".")*identifier
relative_module ::= "."*module
| "."+
A instrução de importação básica (sem cláusula from
) é executada em duas etapas:
encontra um módulo, carregando e inicializando-o se necessário
define um nome ou nomes no espaço de nomes local para o escopo onde ocorre a instrução
import
.
Quando a instrução contém várias cláusulas (separadas por vírgulas), as duas etapas são executadas separadamente para cada cláusula, como se as cláusulas tivessem sido separadas em instruções de importação individuais.
Os detalhes da primeira etapa, encontrar e carregar módulos, estão descritos com mais detalhes na seção sobre o sistema de importação, que também descreve os vários tipos de pacotes e módulos que podem ser importados, bem como todos os os ganchos que podem ser usados para personalizar o sistema de importação. Observe que falhas nesta etapa podem indicar que o módulo não pôde ser localizado ou que ocorreu um erro durante a inicialização do módulo, o que inclui a execução do código do módulo.
Se o módulo solicitado for recuperado com sucesso, ele será disponibilizado no espaço de nomes local de três maneiras:
Se o nome do módulo é seguido pela palavra reservada
as
, o nome a seguir é vinculado diretamente ao módulo importado.Se nenhum outro nome for especificado e o módulo que está sendo importado for um módulo de nível superior, o nome do módulo será vinculado ao espaço de nomes local como uma referência ao módulo importado
Se o módulo que está sendo importado não for um módulo de nível superior, o nome do pacote de nível superior que contém o módulo será vinculado ao espaço de nomes local como uma referência ao pacote de nível superior. O módulo importado deve ser acessado usando seu nome completo e não diretamente
O formulário from
usa um processo um pouco mais complexo:
encontra o módulo especificado na cláusula
from
, carregando e inicializando-o se necessário;para cada um dos identificadores especificados nas cláusulas
import
:verifica se o módulo importado tem um atributo com esse nome
caso contrário, tenta importar um submódulo com esse nome e verifica o módulo importado novamente para esse atributo
se o atributo não for encontrado, a exceção
ImportError
é levantada.caso contrário, uma referência a esse valor é armazenada no espaço de nomes local, usando o nome na cláusula
as
se estiver presente, caso contrário, usando o nome do atributo
Exemplos:
import foo # foo imported and bound locally
import foo.bar.baz # foo, foo.bar, and foo.bar.baz imported, foo bound locally
import foo.bar.baz as fbb # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as fbb
from foo.bar import baz # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as baz
from foo import attr # foo imported and foo.attr bound as attr
Se a lista de identificadores for substituída por uma estrela ('*'
), todos os nomes públicos definidos no módulo serão vinculados ao espaço de nomes local para o escopo onde ocorre a instrução import
.
Os nomes públicos definidos por um módulo são determinados verificando o espaço de nomes do módulo para uma variável chamada __all__
; se definido, deve ser uma sequência de strings que são nomes definidos ou importados por esse módulo. Os nomes dados em __all__
são todos considerados públicos e devem existir. Se __all__
não estiver definido, o conjunto de nomes públicos inclui todos os nomes encontrados no espaço de nomes do módulo que não começam com um caractere sublinhado ('_'
). __all__
deve conter toda a API pública. Destina-se a evitar a exportação acidental de itens que não fazem parte da API (como módulos de biblioteca que foram importados e usados no módulo).
A forma curinga de importação — from module import *
— só é permitida no nível do módulo. Tentar usá-lo em definições de classe ou função irá levantar uma SyntaxError
.
Ao especificar qual módulo importar, você não precisa especificar o nome absoluto do módulo. Quando um módulo ou pacote está contido em outro pacote, é possível fazer uma importação relativa dentro do mesmo pacote superior sem precisar mencionar o nome do pacote. Usando pontos iniciais no módulo ou pacote especificado após from
você pode especificar quão alto percorrer a hierarquia de pacotes atual sem especificar nomes exatos. Um ponto inicial significa o pacote atual onde o módulo que faz a importação existe. Dois pontos significam um nível de pacote acima. Três pontos são dois níveis acima, etc. Então, se você executar from . import mod
de um módulo no pacote pkg
então você acabará importando o pkg.mod
. Se você executar from ..subpkg2 import mod
de dentro de pkg.subpkg1
você irá importar pkg.subpkg2.mod
. A especificação para importações relativas está contida na seção Package Relative Imports.
importlib.import_module()
é fornecida para dar suporte a aplicações que determinam dinamicamente os módulos a serem carregados.
Levanta um evento de auditoria import
com argumentos module
, filename
, sys.path
, sys.meta_path
, sys.path_hooks
.
7.11.1. Instruções future¶
Uma instrução future é uma diretiva para o compilador de que um determinado módulo deve ser compilado usando sintaxe ou semântica que estará disponível em uma versão futura especificada do Python, onde o recurso se tornará padrão.
A instrução future destina-se a facilitar a migração para versões futuras do Python que introduzem alterações incompatíveis na linguagem. Ele permite o uso dos novos recursos por módulo antes do lançamento em que o recurso se torna padrão.
future_stmt ::= "from" "__future__" "import"feature
["as"identifier
] (","feature
["as"identifier
])* | "from" "__future__" "import" "("feature
["as"identifier
] (","feature
["as"identifier
])* [","] ")" feature ::=identifier
Uma instrução future deve aparecer perto do topo do módulo. As únicas linhas que podem aparecer antes de uma instrução future são:
o módulo docstring (se houver),
omentários,
linhas vazias e
outras instruções future.
O único recurso que requer o uso da instrução future é annotations
(veja PEP 563).
Todos os recursos históricos habilitados pela instrução future ainda são reconhecidos pelo Python 3. A lista inclui absolute_import
, division
, generators
, generator_stop
, unicode_literals
, print_function
, nested_scopes
e with_statement
. Eles são todos redundantes porque estão sempre habilitados e mantidos apenas para compatibilidade com versões anteriores.
Uma instrução future é reconhecida e tratada especialmente em tempo de compilação: as alterações na semântica das construções principais são frequentemente implementadas gerando código diferente. Pode até ser o caso de um novo recurso introduzir uma nova sintaxe incompatível (como uma nova palavra reservada), caso em que o compilador pode precisar analisar o módulo de maneira diferente. Tais decisões não podem ser adiadas até o tempo de execução.
Para qualquer versão, o compilador sabe quais nomes de recursos foram definidos e levanta um erro em tempo de compilação se uma instrução future contiver um recurso desconhecido.
A semântica do tempo de execução direto é a mesma de qualquer instrução de importação: existe um módulo padrão __future__
, descrito posteriormente, e será importado da maneira usual no momento em que a instrução future for executada.
A semântica interessante do tempo de execução depende do recurso específico ativado pela instrução future.
Observe que não há nada de especial sobre a instrução:
import __future__ [as name]
Essa não é uma instrução future; é uma instrução de importação comum sem nenhuma semântica especial ou restrições de sintaxe.
Code compiled by calls to the built-in functions exec()
and compile()
that occur in a module M
containing a future statement will, by default,
use the new syntax or semantics associated with the future statement. This can
be controlled by optional arguments to compile()
— see the documentation
of that function for details.
Uma instrução future tipada digitada em um prompt do interpretador interativo terá efeito no restante da sessão do interpretador. Se um interpretador for iniciado com a opção -i
, for passado um nome de script para ser executado e o script incluir uma instrução future, ela entrará em vigor na sessão interativa iniciada após a execução do script.
Ver também
- PEP 236 - De volta ao __future__
A proposta original para o mecanismo do __future__.
7.12. A instrução global
¶
global_stmt ::= "global"identifier
(","identifier
)*
A instrução global
é uma declaração que vale para todo o bloco de código atual. Isso significa que os identificadores listados devem ser interpretados como globais. Seria impossível atribuir a uma variável global sem global
, embora variáveis livres possam se referir a globais sem serem declaradas globais.
Nomes listados em uma instrução global
não devem ser usados no mesmo bloco de código que precede textualmente a instrução global
.
Os nomes listados em uma instrução global
não devem ser definidos como parâmetros formais, ou como alvos em instruções with
ou cláusulas except
, ou em uma lista alvo for
, definição de class
, definição de função, instrução import
ou anotação de variável.
Detalhes da implementação do CPython: A implementação atual não impõe algumas dessas restrições, mas os programas não devem abusar dessa liberdade, pois implementações future podem aplicá-las ou alterar silenciosamente o significado do programa.
Nota do programador: global
é uma diretiva para o analisador sintático. Aplica-se apenas ao código analisado ao mesmo tempo que a instrução global
. Em particular, uma instrução global
contida em uma string ou objeto código fornecido à função embutida exec()
não afeta o bloco de código contendo a chamada da função e o código contido em tal uma string não é afetada por instruções global
no código que contém a chamada da função. O mesmo se aplica às funções eval()
e compile()
.
7.13. A instrução nonlocal
¶
nonlocal_stmt ::= "nonlocal"identifier
(","identifier
)*
A instrução nonlocal
faz com que os identificadores listados se refiram a variáveis vinculadas anteriormente no escopo mais próximo, excluindo globais. Isso é importante porque o comportamento padrão para ligação é pesquisar primeiro o espaço de nomes local. A instrução permite que o código encapsulado ligue novamente variáveis fora do escopo local além do escopo global (módulo).
Os nomes listados em uma instrução nonlocal
, diferentemente daqueles listados em uma instrução global
, devem se referir a associações preexistentes em um escopo delimitador (o escopo no qual uma nova associação deve ser criada não pode ser determinado inequivocamente).
Os nomes listados em uma instrução nonlocal
não devem colidir com ligações preexistentes no escopo local.