# O que há de novo no Python 3.10

Editor:

  Pablo Galindo Salgado

Este artigo explica os novos recursos no Python 3.10, em comparação com 3.9. Python 3.10 foi lançado em 4 de outubro de 2021. Veja changelog para uma lista completa de mudanças.

## Resumo – Destaques da versão

Novos recursos de sintaxe:

- PEP 634, Correspondência de padrão estrutural: especificação

- PEP 635, Correspondência de padrão estrutural: motivação e justificativa

- PEP 636, Correspondência de padrão estrutural: Tutorial

- bpo-12782, Gerenciadores de contexto entre parênteses agora são permitidos oficialmente.

Novos recursos na biblioteca padrão:

- PEP 618, Adiciona verificação de comprimento opcional ao zip.

Melhorias no interpretador:

- PEP 626, Números de linha precisos para depuração e outras ferramentas.

Novos recursos de tipagem:

- PEP 604, Permite escrever tipos de união como X | Y

- PEP 612, Variáveis de especificação de parâmetro

- PEP 613, Apelidos de tipo explícitos

- PEP 647, Guardas de Tipo Definidas Pelo Usuário

Descontinuações, remoções ou restrições importantes:

- PEP 644, Exige OpenSSL 1.1.1 ou mais novo

- PEP 632, Descontinua o módulo distutils.

- PEP 623, Descontinua e prepara para a remoção do membro wstr em PyUnicodeObject.

- PEP 624, Remove APIs codificadoras de Py_UNICODE

- PEP 597, Adiciona EncodingWarning opcional

## Novas funcionalidades

### Gerenciadores de contexto entre parênteses

O uso de parênteses para continuação em várias linhas em gerenciadores de contexto agora é suportado. Isso permite a formatação de uma longa coleção de gerenciadores de contexto em várias linhas de maneira semelhante à que era possível anteriormente com instruções de importação. Por exemplo, todos esses exemplos agora são válidos:

    with (CtxManager() as exemplo):
        ...

    with (
        CtxManager1(),
        CtxManager2()
    ):
        ...

    with (CtxManager1() as exemplo,
          CtxManager2()):
        ...

    with (CtxManager1(),
          CtxManager2() as exemplo):
        ...

    with (
        CtxManager1() as exemplo1,
        CtxManager2() as exemplo2
    ):
        ...

também é possível usar uma vírgula no final do grupo fechado:

    with (
        CtxManager1() as exemplo1,
        CtxManager2() as exemplo2,
        CtxManager3() as exemplo3,
    ):
        ...

Esta nova sintaxe usa as capacidades não LL(1) do novo analisador sintático. Confira PEP 617 para mais detalhes.

(Contribuição de Guido van Rossum, Pablo Galindo e Lysandros Nikolaou em bpo-12782 e bpo-40334.)

### Melhores mensagens de erro

#### SyntaxErrors

Ao analisar o código que contém parênteses ou chaves não fechados, o interpretador agora inclui o local da chave não fechado de parênteses em vez de exibir SyntaxError: unexpected EOF while parsing ou apontando para algum local incorreto. Por exemplo, considere o seguinte código (observe o “{” não fechado):

    esperado = {9: 1, 18: 2, 19: 2, 27: 3, 28: 3, 29: 3, 36: 4, 37: 4,
                38: 4, 39: 4, 45: 5, 46: 5, 47: 5, 48: 5, 49: 5, 54: 6,
    algum_outro_codigo = foo()

Versões anteriores do interpretador relatavam lugares confusos como local do erro de sintaxe:

    File "exemplo.py", line 3
        algum_outro_codigo = foo()
                           ^
    SyntaxError: invalid syntax

mas no Python 3.10, um erro mais informativo é emitido:

    File "exemplo.py", line 1
        esperado = {9: 1, 18: 2, 19: 2, 27: 3, 28: 3, 29: 3, 36: 4, 37: 4,
                   ^
    SyntaxError: '{' was never closed

De maneira semelhante, erros envolvendo literais de string não fechadas (entre aspas simples e triplas) agora apontam para o início da string em vez de relatar EOF/EOL.

Essas melhorias são inspiradas em trabalhos anteriores no interpretador PyPy.

(Contribuição de Pablo Galindo em bpo-42864 e Batuhan Taskaya em bpo-40176.)

As exceções `SyntaxError` levantadas pelo interpretador agora destacam o intervalo total de erros da expressão que constitui o próprio erro de sintaxe, em vez de apenas onde o problema foi detectado. Desta forma, em vez de exibir (antes do Python 3.10):

    >>> foo(x, z for z in range(10), t, w)
      File "<stdin>", line 1
        foo(x, z for z in range(10), t, w)
               ^
    SyntaxError: Generator expression must be parenthesized

agora o Python 3.10 vai exibir a exceção como:

    >>> foo(x, z for z in range(10), t, w)
      File "<stdin>", line 1
        foo(x, z for z in range(10), t, w)
               ^^^^^^^^^^^^^^^^^^^^
    SyntaxError: Generator expression must be parenthesized

Esta melhoria foi contribuída por Pablo Galindo em bpo-43914.

Uma quantidade considerável de novas mensagens especializadas para exceções `SyntaxError` foram incorporadas. Alguns dos mais notáveis são os seguintes:

- Faltando `:` antes de blocos:

      >>> if foguete.posicao > horizonte_evento
        File "<stdin>", line 1
          if foguete.posicao > horizonte_evento
                                              ^
      SyntaxError: expected ':'

  (Contribuição de Pablo Galindo em bpo-42997.)

- Tuplas sem parênteses em alvos de compreensão:

      >>> {x,y for x,y in zip('abcd', '1234')}
        File "<stdin>", line 1
          {x,y for x,y in zip('abcd', '1234')}
           ^
      SyntaxError: did you forget parentheses around the comprehension target?

  (Contribuição de Pablo Galindo em bpo-43017.)

- Faltando vírgulas em literais de coleção e entre expressões:

      >>> items = {
      ... x: 1,
      ... y: 2
      ... z: 3,
        File "<stdin>", line 3
          y: 2
             ^
      SyntaxError: invalid syntax. Perhaps you forgot a comma?

  (Contribuição de Pablo Galindo em bpo-43822.)

- Vários tipos de exceção sem parênteses:

      >>> try:
      ...     construir_esfera_de_dyson()
      ... except NotEnoughScienceError, NotEnoughResourcesError:
        File "<stdin>", line 3
          except NotEnoughScienceError, NotEnoughResourcesError:
                 ^
      SyntaxError: multiple exception types must be parenthesized

  (Contribuição de Pablo Galindo em bpo-43149.)

- Faltando `:` em valores em literais de dicionário:

      >>> values = {
      ... x: 1,
      ... y: 2,
      ... z:
      ... }
        File "<stdin>", line 4
          z:
           ^
      SyntaxError: expression expected after dictionary key and ':'

      >>> values = {x:1, y:2, z w:3}
        File "<stdin>", line 1
          values = {x:1, y:2, z w:3}
                              ^
      SyntaxError: ':' expected after dictionary key

  (Contribuição de Pablo Galindo em bpo-43823.)

- Blocos `try` sem blocos `except` ou `finally`:

      >>> try:
      ...     x = 2
      ... algumacoisa = 3
        File "<stdin>", line 3
          algumacoisa = 3
          ^^^^^^^^^^^
      SyntaxError: expected 'except' or 'finally' block

  (Contribuição de Pablo Galindo em bpo-44305.)

- Uso de `=` em vez de `==` nas comparações:

      >>> if foguete.posicao = horizonte_evento:
        File "<stdin>", line 1
          if foguete.posicao = horizonte_evento:
                             ^
      SyntaxError: cannot assign to attribute here. Maybe you meant '==' instead of '='?

  (Contribuição de Pablo Galindo em bpo-43797.)

- Uso de `*` em f-strings:

      >>> f"Buracos negros {*all_black_holes} e revelações"
        File "<stdin>", line 1
          (*all_black_holes)
           ^
      SyntaxError: f-string: cannot use starred expression here

  (Contribuição de Pablo Galindo em bpo-41064.)

#### IndentationErrors

Muitas exceções `IndentationError` agora têm mais contexto sobre que tipo de bloco estava esperando um indentação, incluindo a localização da instrução:

    >>> def foo():
    ...    if lel:
    ...    x = 2
      File "<stdin>", line 3
        x = 2
        ^
    IndentationError: expected an indented block after 'if' statement in line 2

#### AttributeErrors

Ao exibir `AttributeError`, `PyErr_Display()` oferecerá sugestões de nomes de atributos semelhantes no objeto a partir do qual a exceção foi levantada:

    >>> collections.namedtoplo
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: module 'collections' has no attribute 'namedtoplo'. Did you mean: namedtuple?

(Contribuição de Pablo Galindo em bpo-38530.)

Aviso

Observe que isso não funcionará se `PyErr_Display()` não for chamado para exibir o erro que pode ocorrer se alguma outra função personalizada de exibição de erro for usada. Este é um cenário comum em alguns REPLs, laços de leitura-avaliação-impressão, como o IPython.

#### NameErrors

Ao exibir `NameError` levantada pelo interpretador, `PyErr_Display()` irá oferecer sugestões de nomes de variáveis semelhantes na função de onde a exceção foi levantada:

    >>> buraco_negro_de_schwarzschild = None
    >>> buraco_negro_de_schwarschild
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'buraco_negro_de_schwarschild' is not defined. Did you mean: buraco_negro_de_schwarzschild?

(Contribuição de Pablo Galindo em bpo-38530.)

Aviso

Observe que isso não funcionará se `PyErr_Display()` não for chamado para exibir o erro que pode ocorrer se alguma outra função personalizada de exibição de erro for usada. Este é um cenário comum em alguns REPLs, laços de leitura-avaliação-impressão, como o IPython.

### PEP 626: Números de linha precisos para depuração e outras ferramentas

O PEP 626 traz números de linha mais precisos e confiáveis para ferramentas de depuração, criação de perfil e cobertura. Eventos de rastreamento, com o número de linha correto, são gerados para todas as linhas de código executadas e apenas para linhas de código que são executadas.

O atributo `f_lineno` de objetos de quadro sempre conterá o número de linha esperado.

O atributo `co_lnotab` code objects foi descontinuado e será removido no 3.12. O código que precisa ser convertido do deslocamento para o número da linha deve usar o novo método `co_lines()`.

### PEP 634: Correspondência de padrão estrutural

A correspondência de padrão estrutural foi adicionada na forma de uma instrução de correspondência e instruções de caso de padrões com ações associadas. Os padrões consistem em sequências, mapeamentos, tipos de dados primitivos, bem como instâncias de classe. A correspondência de padrão permite que os programas extraiam informações de tipos de dados complexos, ramifiquem na estrutura de dados e apliquem ações específicas com base em diferentes formas de dados.

#### Sintaxe e operações

A sintaxe genérica da correspondência de padrão é:

    match sujeito:
        case <padrão_1>:
            <ação_1>
        case <padrão_2>:
            <ação_2>
        case <padrão_3>:
            <ação_3>
        case _:
            <ação_curinga>

Uma instrução de correspondência pega uma expressão e compara seu valor com padrões sucessivos fornecidos como um ou mais blocos de caso. Especificamente, a correspondência de padrões opera:

1. usando dados com tipo e forma (o `sujeito`)

2. avaliando o `sujeito` na instrução `match`

3. comparando o assunto com cada padrão em uma instrução `case` de cima para baixo até que uma correspondência seja confirmada.

4. executando a ação associada ao padrão da correspondência confirmada

5. Se uma correspondência exata não for confirmada, no último caso, um curinga `_`, se fornecido, será usado como o caso de correspondência. Se uma correspondência exata não for confirmada e não houver um caractere curinga, todo o bloco de correspondência será autônomo.

#### Abordagem declarativa

Os leitores podem estar cientes da correspondência de padrão por meio do exemplo simples de correspondência de um assunto (objeto de dados) a um literal (padrão) com a instrução switch encontrada em C, Java ou JavaScript (e muitas outras linguagens). Frequentemente, a instrução switch é usada para comparação de um objeto/expressão com instruções case contendo literais.

Exemplos mais poderosos de correspondência de padrão podem ser encontrados em linguagens como Scala e Elixir. Com a correspondência de padrão estrutural, a abordagem é “declarativa” e declara explicitamente as condições (os padrões) para que os dados correspondam.

Embora uma série “imperativa” de instruções usando instruções “if” aninhadas possa ser usada para realizar algo semelhante à correspondência de padrão estrutural, é menos clara do que a abordagem “declarativa”. Em vez disso, a abordagem “declarativa” estabelece as condições a serem atendidas para uma correspondência e é mais legível por meio de seus padrões explícitos. Embora a correspondência de padrão estrutural possa ser usada em sua forma mais simples comparando uma variável a um literal em uma instrução case, seu verdadeiro valor para Python reside em seu tratamento do tipo e forma do sujeito.

#### Padrão simples: corresponder a um literal

Vejamos este exemplo como correspondência de padrão em sua forma mais simples: um valor, o assunto, sendo correspondido a vários literais, os padrões. No exemplo abaixo, `status` é o assunto da instrução de correspondência. Os padrões são cada uma das instruções de caso, onde literais representam códigos de status de solicitação. A ação associada ao caso é executada após uma partida:

    def http_error(status):
        match status:
            case 400:
                return "Bad request"
            case 404:
                return "Not found"
            case 418:
                return "I'm a teapot"
            case _:
                return "Something's wrong with the internet"

Se a função acima receber um `status` de 418, “I’m a teapot” será retornado. Se a função acima receber um `status` de 500, a instrução case com `_` irá corresponder a um curinga, e “Something’s wrong with the Internet” é retornado. Observe o último bloco: o nome da variável, `_`, atua como um curinga e garante que o assunto sempre corresponderá. O uso de `_` é opcional.

Você pode combinar vários literais em um único padrão usando `|` (“ou”):

    case 401 | 403 | 404:
        return "Não permitido"

##### Comportamento sem o curinga

Se modificarmos o exemplo acima removendo o último bloco case, o exemplo se tornará:

    def http_error(status):
        match status:
            case 400:
                return "Bad request"
            case 404:
                return "Not found"
            case 418:
                return "I'm a teapot"

Sem o uso de `_` em uma instrução case, uma correspondência pode não existir. Se não houver correspondência, o comportamento é autônomo. Por exemplo, se o `status` de 500 for passado, ocorre um no-op.

#### Padrões com uma literal e variável

Os padrões podem parecer atribuições de desempacotamento e um padrão pode ser usado para vincular variáveis. Neste exemplo, um ponto de dados pode ser desempacotado em sua coordenada x e coordenada y:

    # ponto é uma tupla (x, y)
    match ponto:
        case (0, 0):
            print("Origem")
        case (0, y):
            print(f"Y={y}")
        case (x, 0):
            print(f"X={x}")
        case (x, y):
            print(f"X={x}, Y={y}")
        case _:
            raise ValueError("Não é um ponto")

O primeiro padrão tem dois literais, `(0, 0)`, e pode ser considerado uma extensão do padrão literal mostrado acima. Os próximos dois padrões combinam um literal e uma variável, e a variável vincula um valor do assunto (`ponto`). O quarto padrão captura dois valores, o que o torna conceitualmente semelhante à atribuição de desempacotamento `(x, y) = ponto`.

#### Padrões e classes

Se estiver usando classes para estruturar seus dados, você pode usar como padrão o nome da classe seguido por uma lista de argumentos semelhante a um construtor. Este padrão tem a capacidade de capturar atributos da instância em variáveis:

    class Point:
        def __init__(self, x, y):
            self.x = x
            self.y = y

    def location(point):
        match point:
            case Point(x=0, y=0):
               print("O ponto está na origem.")
            case Point(x=0, y=y):
               print(f "Y={y} e o ponto está no eixo y.")
            case Point(x=x, y=0):
               print(f "X={x} e o ponto está no eixo x.")
            case Point():
               print("O ponto está localizado em outro lugar no plano.")
            case _:
               print("Não é um ponto")

##### Padrões com parâmetros posicionais

Você pode usar parâmetros posicionais com algumas classes embutidas que fornecem uma ordem para seus atributos (por exemplo, classes de dados). Você também pode definir uma posição específica para atributos em padrões configurando o atributo especial `__match_args__` em suas classes. Se for definido como (“x”, “y”), os seguintes padrões são todos equivalentes (e todos ligam o atributo `y` à variável `var`):

    Ponto(1, var)
    Ponto(1, y=var)
    Ponto(x=1, y=var)
    Ponto(y=var, x=1)

#### Padrões aninhados

Os padrões podem ser aninhados arbitrariamente. Por exemplo, se nossos dados forem uma pequena lista de pontos, eles podem ser correspondidos assim:

    match points:
        case []:
            print("Nenhum ponto na lista.")
        case [Point(0, 0)]:
            print("A origem é o único ponto na lista.")
        case [Point(x, y)]:
            print(f"Um único ponto {x}, {y} está na lista.")
        case [Point(0, y1), Point(0, y2)]:
            print(f"Dois pontos no eixo Y em {y1}, {y2} estão na lista.")
        case _:
            print("Algo diferente foi encontrado na lista.")

#### Padrões complexos e o curinga

Até este ponto, os exemplos usaram `_` sozinho na última instrução case. Um curinga pode ser usado em padrões mais complexos, como `('error', code, _)`. Por exemplo:

    match test_variable:
        case ('warning', code, 40):
            print("Foi recebido um alerta.")
        case ('error', code, _):
            print(f"Ocorreu um erro {code}.")

No caso acima, `test_variable` irá corresponder a (‘erro’, código, 100) e (‘erro’, código, 800).

#### Guarda

Podemos adicionar uma cláusula `if` a um padrão, conhecido como “guarda”. Se a guarda for falsa, `match` tenta o próximo bloco de caso. Observe que a captura de valor ocorre antes que a guarda seja avaliada:

    match point:
        case Point(x, y) if x == y:
            print(f"O ponto está localizado em uma diagonal Y=X at {x}.")
        case Point(x, y):
            print(f"Ponto não está na diagonal.")

#### Outros recursos-chave

Vários outros recursos-chave:

- Assim como desempacotar atribuições, os padrões de tupla e lista têm exatamente o mesmo significado e realmente correspondem a sequências arbitrárias. Tecnicamente, o sujeito deve ser uma sequência. Portanto, uma exceção importante é que padrões não correspondem a iteradores. Também evita um erro comum, sequência de padrões não correspondem a strings.

- Os padrões de sequência têm suporte a curingas: `[x, y, *rest]` e `(x, y, *rest)` funcionam de forma semelhante a curingas em desempacotamentos de atribuições. O nome depois de `*` também pode ser `_`, então `(x, y, *_)` corresponde a uma sequência de pelo menos dois itens sem ligar os itens restantes.

- Padrões de mapeamento: `{"bandwidth": b, "latency": l}` captura os valores `"bandwidth"` e `"latency"` de um dicionário. Diferente dos padrões de sequência, chaves extra são ignoradas. Um curinga `**rest` também é permitido. (Mas `**_` seria redundante, então não é permitido.)

- Subpadrões podem ser capturados usando a palavra reservada `as`

      case (Ponto(x1, y1), Ponto(x2, y2) as p2): ...

  Isso liga x1, y1, x2, y2 como você esperaria sem a cláusula `as` e p2 a todo o segundo item do sujeito.

- A maioria dos literais são comparados por igualdade. No entanto, os singletons `True`, `False` e `None` são comparados por identidade.

- Constantes nomeadas podem ser usadas em padrões. Essas constantes nomeadas devem ser nomes pontilhados para evitar que a constante seja interpretada como uma variável de captura:

      from enum import Enum
      class Color(Enum):
          RED = 0
          GREEN = 1
          BLUE = 2

      color = Color.GREEN
      match color:
          case Color.RED:
              print("Eu vejo vermelho!")
          case Color.GREEN:
              print("A grama é verde")
          case Color.BLUE:
              print("Eu azul de fome :(")

Para obter as especificações completas, consulte a PEP 634. A motivação e o raciocínio estão na PEP 635, e um tutorial mais longo está na PEP 636.

### `EncodingWarning` opcional e opção `encoding="locale"`

A codificação padrão de `TextIOWrapper` e `open()` depende da plataforma e da localidade. Como o UTF-8 é usado na maioria das plataformas Unix, omitir a opção `encoding` ao abrir arquivos UTF-8 (por exemplo, JSON, YAML, TOML, Markdown) é um bug muito comum. Por exemplo:

    # BUG: mode "rb" ou encoding="utf-8" deve ser usado.
    with open("data.json") as f:
        data = json.load(f)

Para encontrar este tipo de bug, uma `EncodingWarning` opcional é adicionada. É emitido quando `sys.flags.warn_default_encoding` é verdadeiro e a codificação padrão específica da localidade é usada.

A opção `-X warn_default_encoding` e `PYTHONWARNDEFAULTENCODING` são adicionadas para ativar o aviso.

Veja Codificação do texto para mais informações.

## Novos recursos relacionados a dicas de tipo

Esta seção cobre as principais mudanças que afetam as dicas de tipo da PEP 484 e o módulo `typing`.

### PEP 604: novo operador de união de tipo

Um novo operador de união de tipo foi introduzido, o que permite a sintaxe `X | Y`. Isso fornece uma maneira mais limpa de expressar “tanto o tipo X quanto o tipo Y” ao invés de usar `typing.Union`, especialmente em dicas de tipo.

Nas versões anteriores do Python, para aplicar uma dica de tipo para funções que aceitam argumentos de vários tipos, era usado `typing.Union`:

    def square(number: Union[int, float]) -> Union[int, float]:
        return number ** 2

As dicas de tipo agora podem ser escritas de uma maneira mais sucinta:

    def square(number: int | float) -> int | float:
        return number ** 2

Esta nova sintaxe também é aceita como o segundo argumento para `isinstance()` e `issubclass()`:

    >>> isinstance(1, int | str)
    True

Veja Tipo União e PEP 604 para mais detalhes.

(Contribuição de Maggie Moss e Philippe Prados em bpo-41428, com acréscimos por Yurii Karabas e Serhiy Storchaka em bpo-44490.)

### PEP 612: variáveis de especificação de parâmetros

Duas novas opções para melhorar as informações fornecidas para verificadores de tipo estático para `Callable` da PEP 484 foram adicionadas ao módulo `typing`.

A primeira é a variável de especificação de parâmetro. Eles são usados para encaminhar os tipos de parâmetro de um chamável para outro chamável – um padrão comumente encontrado em funções de ordem superior e decoradores. Exemplos de uso podem ser encontrados em `typing.ParamSpec`. Anteriormente, não havia uma maneira fácil de digitar a dependência de anotação de tipos de parâmetro de maneira tão precisa.

A segunda opção é o novo operador `Concatenate`. É usado em conjunto com variáveis de especificação de parâmetro para digitar anotar um chamável de ordem superior que adiciona ou remove parâmetros de outro chamável. Exemplos de uso podem ser encontrados em `typing.Concatenate`.

Veja `typing.Callable`, `typing.ParamSpec`, `typing.Concatenate`, `typing.ParamSpecArgs`, `typing.ParamSpecKwargs` e PEP 612 para mais detalhes.

(Contribuição de Ken Jin em bpo-41559, com pequenas melhorias por Jelle Zijlstra em bpo-43783. PEP escrita por Mark Mendoza.)

### PEP 613: TypeAlias

PEP 484 introduziu o conceito de apelidos de tipo, exigindo apenas que fossem atribuições não anotadas de nível superior. Essa simplicidade às vezes tornava difícil para os verificadores de tipo distinguirem entre apelidos de tipo e atribuições comuns, especialmente quando referências diretas ou tipos inválidos estavam envolvidos. Compare:

    StrCache = 'Cache[str]'  # um apelido de tipo
    LOG_PREFIX = 'LOG[DEBUG]'  # uma constante do módulo

Agora o módulo `typing` tem um valor especial `TypeAlias` que permite declarar apelidos de tipo, mais explicitamente:

    StrCache: TypeAlias = 'Cache[str]'  # um apelido de tipo
    LOG_PREFIX = 'LOG[DEBUG]'  # uma constante do módulo

Veja PEP 613 para mais detalhes.

(Contribuição de Mikhail Golubev em bpo-41923.)

### PEP 647: guardas de tipo definidas pelo usuário

`TypeGuard` foi adicionado ao módulo `typing` para anotar funções de guarda de tipo e melhorar informações fornecidas a verificadores de tipo estático durante um estreitamento de tipo. Para mais informações, veja a documentação do `TypeGuard` e a PEP 647.

(Contribuição de Ken Jin e Guido van Rossum em bpo-43766. PEP escrita por Eric Traut.)

## Outras mudanças na linguagem

- O tipo `int` tem um novo método `int.bit_count()`, retornando o número de unidades na expansão binária de um dado inteiro, também conhecido como contagem da população. (Contribuição de Niklas Fiekas em bpo-29882.)

- As visualizações retornadas por `dict.keys()`, `dict.values()` e `dict.items()` agora têm um atributo `mapping` que fornece um objeto `types.MappingProxyType` que envolve o dicionário original. (Contribuição de Dennis Sweeney em bpo-40890.)

- PEP 618: A função `zip()` agora tem um sinalizador opcional `strict`, usado para exigir que todos os iteráveis tenham um comprimento igual.

- Funções embutidas e de extensão que recebem argumentos inteiros não aceitam mais `Decimal`, `Fraction` e outros objetos que podem ser convertidos em inteiros apenas com uma perda (por exemplo, tem o método `__int__()`, mas não tem o método `__index__()`). (Contribuição de Serhiy Storchaka em bpo-37999.)

- Se `object.__ipow__()` retorna `NotImplemented`, o operador vai corretamente recorrer ao `object.__pow__()` e `object.__rpow__()` como esperado. (Contribuição de Alex Shkop em bpo-38302.)

- Expressões de atribuição agora podem ser usadas sem parênteses dentro de literais de conjuntos e compreensões de conjuntos, bem como em índices de sequência (mas não em fatias).

- As funções têm um novo atributo `__builtins__` que é usado para procurar por símbolos embutidos quando uma função é executada, em vez de procurar em `__globals__['__builtins__']`. O atributo é inicializado a partir de `__globals__["__builtins__"]` se existir; do contrário, a partir dos embutidos atuais. (Contribuição de Mark Shannon em bpo-42990.)

- Duas novas funções embutidas – `aiter()` e `anext()` foram adicionadas para fornecer contrapartes assíncronas para `iter()` e `next()`, respectivamente. (Contribuição de Joshua Bronson, Daniel Pope e Justin Wang em bpo-31861.)

- Métodos estáticos (`@staticmethod`) e métodos de classe (`@classmethod`) agora herdam os atributos de método (`__module__`, `__name__`, `__qualname__`, `__doc__`, `__annotations__`) e têm um novo atributo `__wrapped__` . Além disso, métodos estáticos são agora chamáveis como funções comuns. (Contribuição de Victor Stinner em bpo-43682.)

- Anotações para alvos complexos (tudo além de alvos de nome simples, ou `simple name`, definidos pela PEP 526) não causam mais nenhum efeito de tempo de execução com `from __future__ import annotations`. (Contribuição de Batuhan Taskaya em bpo-42737.)

- Objetos classe e módulo agora criam preguiçosamente dados vazios de anotações sob demanda. Os dicionários de anotações são armazenados em `__dict__` do objeto para compatibilidade com versões anteriores. Isso melhora as melhores práticas para trabalhar com `__annotations__`; para mais informações, veja Boas práticas para anotações. (Contribuição de Larry Hastings em bpo-43901.)

- Anotações consistindo em `yield`, `yield from`, `await` ou expressões nomeadas agora são proibidas em `from __future__ import annotations` por causa de seus efeitos colaterais. (Contribuição de Batuhan Taskaya em bpo-42725.)

- O uso de variáveis não ligadas, `super()` e outras expressões que podem alterar o processamento da tabela de símbolos como anotações são agora processadas sem efeito sob `from __future__ import annotations`. (Contribuição de Batuhan Taskaya em bpo-42725.)

- Hashes de valores NaN de ambos os tipos `float` e `decimal.Decimal` agora dependem da identidade do objeto. Anteriormente, eles sempre hash para `0` mesmo que os valores NaN não sejam iguais uns aos outros. Isso causou um comportamento de tempo de execução potencialmente quadrático devido a colisões de hash excessivas ao criar dicionários e conjuntos contendo vários NaNs. (Contribuição de Raymond Hettinger em bpo-43475.)

- Uma `SyntaxError` (ao invés de uma `NameError`) será levantada ao excluir a constante `__debug__`. (Contribuição de Donghee Na em bpo-45000.)

- Exceções `SyntaxError` agora possuem atributos `end_lineno` e `end_offset`. Eles serão `None` se não forem determinados. (Contribuição de Pablo Galindo em bpo-43914.)

## Novos módulos

- Nenhum.

## Módulos melhorados

### asyncio

Adiciona o método `connect_accepted_socket()` até então em falta. (Contribuição de Alex Grönholm em bpo-41332.)

### argparse

A frase enganosa “argumentos opcionais” foi substituída por “opções” na ajuda do argparse. Alguns testes podem exigir adaptação se eles dependerem da correspondência de saída exata. (Contribuição de Raymond Hettinger em bpo-9694.)

### array

O método `index()` de `array.array` agora possui os parâmetros start e stop. (Contribuição de Anders Lorentsen e Zackery Spytz em bpo-31956.)

### asynchat, asyncore, smtpd

Esses módulos foram marcados como descontinuados em sua documentação de módulo desde o Python 3.6. Uma exceção `DeprecationWarning` em tempo de importação agora foi adicionada a todos esses três módulos.

### base64

Adiciona `base64.b32hexencode()` e `base64.b32hexdecode()` para dar suporte a Codificação Base32 com alfabeto hexa estendido.

### bdb

Adiciona `clearBreakpoints()` para redefinir todos os pontos de interrupção definidos. (Contribuição de Irit Katriel em bpo-24160.)

### bisect

Adicionada a possibilidade de fornecer uma função key para as APIs no módulo `bisect`. (Contribuição de Raymond Hettinger em bpo-4356.)

### codecs

Adiciona uma função `codecs.unregister()` para cancelar um registro de uma função de pesquisa de codecs. (Contribuição de Hai Shi em bpo-41842.)

### collections.abc

Os `__args__` do genérico parametrizado para `collections.abc.Callable` agora são consistentes com `typing.Callable`. A classe genérica `collections.abc.Callable` agora achata parâmetros de tipo, de forma semelhante ao que `typing.Callable` atualmente faz. Isso significa que `collections.abc.Callable[[int, str], str]` terá `__args__` de `(int, str, str)`; anteriormente, isso era `([int, str], str)`. Para permitir esta alteração, agora é possível criar subclasse de `types.GenericAlias` e uma subclasse será retornada ao fazer um subscript do tipo `collections.abc.Callable`. Observe que uma `TypeError` pode ser levantada para formas inválidas de parametrizar `collections.abc.Callable` que podem ter passado silenciosamente no Python 3.9. (Contribuição de Ken Jin em bpo-42195.)

### contextlib

Adiciona um gerenciador de contexto `contextlib.aclosing()` para fechar com segurança geradores assíncronos e objetos que representam recursos liberados de forma assíncrona. (Contribuição de Joongi Kim e John Belmonte em bpo-41229.)

Adiciona suporte a gerenciador de contexto assíncrono a `contextlib.nullcontext()`. (Contribuição de Tom Gringauz em bpo-41543.)

Adiciona `AsyncContextDecorator`, para dar suporte ao uso de gerenciadores de contexto assíncronos como decoradores.

### curses

As funções de cores estendidas adicionadas no ncurses 6.1 serão usadas transparentemente por `curses.color_content()`, `curses.init_color()`, `curses.init_pair()` e `curses.pair_content()`. Uma nova função, `curses.has_extended_color_support()`, indica se o suporte a cores estendidas é fornecido pela biblioteca ncurses subjacente. (Contribuição de Jeffrey Kintscher e Hans Petter Jansson em bpo-36982.)

As constantes `BUTTON5_*` agora são expostas no módulo `curses` se forem fornecidas pela biblioteca curses subjacente. (Contribuição de Zackery Spytz em bpo-39273.)

### dataclasses

#### __slots__

Adicionado o parâmetro `slots` no decorador `dataclasses.dataclass()`. (Contribuição de Yurii Karabas em bpo-42269)

#### Campos somente-nomeados

dataclasses agora oferece suporte a campos que são somente-nomeados no método __init__ gerado. Há várias maneiras de especificar campos somente-nomeados.

Você pode dizer que todos os campos são somente-nomeados:

    from dataclasses import dataclass

    @dataclass(kw_only=True)
    class Birthday:
        name: str
        birthday: datetime.date

Ambos `name` e `birthday` são parâmetros somente-nomeados para o método __init__ gerado.

Você pode especificar somente-nomeado por campo:

    from dataclasses import dataclass, field

    @dataclass
    class Birthday:
        name: str
        birthday: datetime.date = field(kw_only=True)

Aqui apenas `birthday` é somente-nomeado. Se você definir `kw_only` em campos individuais, esteja ciente de que existem regras sobre a reordenação de campos devido a campos somente-nomeados que precisam seguir campos não somente-nomeados. Consulte a documentação completa de dataclasses para obter detalhes.

Você também pode especificar que todos os campos a partir de um marcador KW_ONLY sejam somente-nomeados. Este provavelmente será o uso mais comum:

    from dataclasses import dataclass, KW_ONLY

    @dataclass
    class Point:
        x: float
        y: float
        _: KW_ONLY
        z: float = 0.0
        t: float = 0.0

Aqui, `z` e `t` são parâmetros somente-nomeados, enquanto `x` e `y` não são. (Contribuição de Eric V. Smith em bpo-43532.)

### distutils

Todo o pacote `distutils` foi descontinuado, para ser removido no Python 3.12. Sua funcionalidade para especificar compilações de pacote já foi completamente substituída por pacotes de terceiros `setuptools` e `packaging`, e a maioria das outras APIs comumente usadas estão disponíveis em outro lugar na biblioteca padrão (como `platform`, `shutil`, `subprocess` ou `sysconfig`). Não há planos para migrar qualquer outra funcionalidade de `distutils`, e aplicativos que estão usando outras funções devem planejar fazer cópias privadas do código. Consulte PEP 632 para discussão.

O comando descontinuado `bdist_wininst` no Python 3.8 foi removido. O comando `bdist_wheel` agora é recomendado para distribuir pacotes binários no Windows. (Contribuição de Victor Stinner em bpo-42802.)

### doctest

Quando um módulo não define `__loader__`, recorre a `__spec__.loader`. (Contribuição de Brett Cannon em bpo-42133.)

### encodings

`encodings.normalize_encoding()` agora ignora caracteres não-ASCII. (Contribuição de Hai Shi em bpo-39337.)

### enum

`__repr__()` do `Enum` agora retorna `enum_name.member_name` e `__str__()` agora retorna `member_name`. Os enums da stdlib disponíveis como constantes de módulo têm `repr()` de `module_name.member_name`. (Contribuição de Ethan Furman em bpo-40066.)

Adiciona `enum.StrEnum` para enums onde todos os membros são strings. (Contribuição de Ethan Furman em bpo-41816.)

### fileinput

Adiciona os parâmetros encoding e errors a `fileinput.input()` e `fileinput.FileInput`. (Contribuição de Inada Naoki em bpo-43712.)

`fileinput.hook_compressed()` agora retorna um objeto `TextIOWrapper` quando mode é “r” e o arquivo está compactado, como arquivos descompactados. (Contribuição de Inada Naoki em bpo-5758.)

### faulthandler

O módulo `faulthandler` agora detecta se um erro fatal ocorre durante a coleta do coletor de lixo. (Contribuição de Victor Stinner em bpo-44466.)

### gc

Adiciona ganchos de auditoria para `gc.get_objects()`, `gc.get_referrers()` e `gc.get_referents()`. (Contribuição de Pablo Galindo em bpo-43439.)

### glob

Adiciona os parâmetros root_dir e dir_fd em `glob()` e `iglob()`, o que permite especificar o diretório raiz para a pesquisa. (Contribuição de Serhiy Storchaka em bpo-38144.)

### hashlib

O módulo hashlib requer OpenSSL 1.1.1 ou mais recente. (Contribuição de Christian Heimes em PEP 644 e bpo-43669.)

O módulo hashlib tem suporte preliminar a OpenSSL 3.0.0. (Contribuição de Christian Heimes em bpo-38820 e outras issues.)

A alternativa puramente Python de `pbkdf2_hmac()` foi descontinuada. No futuro, o PBKDF2-HMAC só estará disponível quando o Python for desenvolvido com suporte a OpenSSL. (Contribuição de Christian Heimes em bpo-43880.)

### hmac

O módulo hmac agora usa a implementação HMAC do OpenSSL internamente. (Contribuição de Christian Heimes em bpo-40645.)

### IDLE e idlelib

Faz o IDLE invocar `sys.excepthook()` (quando iniciado sem ‘-n’). Ganchos de usuário eram ignorados anteriormente. (Contribuição de Ken Hilton em bpo-43008.)

Reorganiza a caixa de diálogo de configurações. Divide a aba General nas abas Windows e Shell/Ed. Move as fontes de ajuda, que estendem o menu Help, para a aba Extensions. Abre espaço para novas opções e encurta a caixa de diálogo. O último faz com que o diálogo se ajuste melhor a telas pequenas. (Contribuição de Terry Jan Reedy em bpo-40468.) Move a configuração do espaço de recuo da aba Font para a nova aba Windows. (Contribuição de Mark Roseman e Terry Jan Reedy em bpo-33962.)

As alterações acima foram portadas para uma versão de manutenção 3.9.

Adiciona uma barra lateral ao console. Move o prompt principal (‘>>>’) para a barra lateral. Adiciona prompts secundários (’…’) à barra lateral. Clicar com o botão esquerdo e opcionalmente arrastar seleciona uma ou mais linhas de texto, como na barra lateral do número da linha do editor. Clicar com o botão direito após selecionar as linhas de texto exibe um menu de contexto com “copy with prompts”. Isso compacta os prompts da barra lateral com linhas do texto selecionado. Esta opção também aparece no menu de contexto para o texto. (Contribuição de Tal Einat em bpo-37903.)

Use espaços em vez de tabulações para indentar o código interativo. Isso faz com que as entradas de código interativo “pareçam corretas”. Tornar isso viável foi a principal motivação para adicionar a barra lateral do console. Contribuição de Terry Jan Reedy em bpo-37892.)

Realça as novas palavra reservada suave `match`, `case` e `_` em instruções de correspondência de padrões. No entanto, este realce não é perfeito e estará incorreto em alguns casos raros, incluindo alguns `_` em padrões de `case`. (Contribuição de Tal Einat em bpo-44010.)

Novo nas versões de manutenção 3.10.

Aplica realce de sintaxe em arquivos `.pyi`. (Contribuição de Alex Waygood e Terry Jan Reedy em bpo-45447.)

Inclui prompts ao salvar o console com entradas e saídas. (Contribuição de Terry Jan Reedy em gh-95191.)

### importlib.metadata

Paridade de recursos com `importlib_metadata` 4.6 (histórico).

Pontos de entrada importlib.metadata agora oferecem uma experiência melhor para selecionar pontos de entrada por grupo e nome através do novo importlib.metadata.EntryPoints. Consulte a Nota de Compatibilidade nos documentos para obter mais informações sobre a descontinuação e uso.

Adicionada importlib.metadata.packages_distributions() para resolver módulos e pacotes Python de alto nível com suas importlib.metadata.Distribution.

### inspect

Quando um módulo não define `__loader__`, recorre a `__spec__.loader`. (Contribuição de Brett Cannon em bpo-42133.)

Adiciona `inspect.get_annotations()`, que calcula com segurança as anotações definidas em um objeto. Ele contorna as peculiaridades de acessar as anotações em vários tipos de objetos e faz poucas suposições sobre o objeto que examina. `inspect.get_annotations()` também pode desfazer a string corretamente de anotações em string. `inspect.get_annotations()` agora é considerada a melhor prática para acessar o dict de anotações definido em qualquer objeto Python; para mais informações sobre as melhores práticas para trabalhar com anotações, consulte Boas práticas para anotações. Da mesma forma, `inspect.signature()`, `inspect.Signature.from_callable()` e `inspect.Signature.from_function()` agora chamam `inspect.get_annotations()` para recuperar anotações. Isso significa que `inspect.signature()` e `inspect.Signature.from_callable()` agora também podem remover a string de anotações em string. (Contribuição de Larry Hastings em bpo-43817.)

### itertools

Adiciona `itertools.pairwise()`. (Contribuição de Raymond Hettinger em bpo-38200.)

### linecache

Quando um módulo não define `__loader__`, recorre a `__spec__.loader`. (Contribuição de Brett Cannon em bpo-42133.)

### os

Adiciona suporte a `os.cpu_count()` para RTOS de VxWorks. (Contribuição de Peixing Xin em bpo-41440.)

Adiciona uma nova função `os.eventfd()` e auxiliares relacionados para envolver a chamada de sistema `eventfd2` no Linux. (Contribuição de Christian Heimes em bpo-41001.)

Adiciona `os.splice()` que permite mover dados entre dois descritores de arquivo sem copiar entre o espaço de endereço do kernel e o espaço de endereço do usuário, onde um dos descritores de arquivo deve se referir a um encadeamento (pipe). (Contribuição de Pablo Galindo em bpo-41625.)

Adiciona `O_EVTONLY`, `O_FSYNC`, `O_SYMLINK` e `O_NOFOLLOW_ANY` para macOS. (Contribuição de Donghee Na em bpo-43106.)

### os.path

`os.path.realpath()` agora aceita um argumento somente-nomeado strict. Quando definido como `True`, a exceção `OSError` é levantada se um caminho não existe ou um loop de link simbólico é encontrado. (Contribuição de Barney Gale em bpo-43757.)

### pathlib

Adiciona suporte a fatiamento a `PurePath.parents`. (Contribuição de Joshua Cannon em bpo-35498.)

Adiciona suporte a indexação negativa a `PurePath.parents`. (Contribuição de Yaroslav Pankovych em bpo-21041.)

Adiciona o método `Path.hardlink_to` que substitui `link_to()`. O novo método tem a mesma ordem de argumentos que `symlink_to()`. (Contribuição de Barney Gale em bpo-39950.)

`pathlib.Path.stat()` e `chmod()` agora aceita um argumento somente-nomeado follow_symlinks para consistência com as funções correspondentes no módulo `os`. (Contribuição de Barney Gale em bpo-39906.)

### platform

Adiciona `platform.freedesktop_os_release()` para obter a identificação do sistema operacional a partir do arquivo padrão os-release do freedesktop.org. (Contribuição de Christian Heimes em bpo-28468.)

### pprint

`pprint.pprint()` agora aceita um novo argumento nomeado `underscore_numbers`. (Contribuição de sblondon em bpo-42914.)

`pprint` agora pode fazer impressão bonita de instâncias de `dataclasses.dataclass`. (Contribuição de Lewis Gaul em bpo-43080.)

### py_compile

Adiciona a opção `--quiet` à interface de linha de comando de `py_compile`. (Contribuição de Gregory Schevchenko em bpo-38731.)

### pyclbr

Adiciona um atributo `end_lineno` aos objetos `Function` e `Class` na árvore retornada por `pyclbr.readmodule()` e `pyclbr.readmodule_ex()`. Isso corresponde ao `lineno` (início) existente. (Contribuição de Aviral Srivastava em bpo-38307.)

### shelve

O módulo `shelve` agora usa `pickle.DEFAULT_PROTOCOL` por padrão em vez do protocolo `3` do `pickle` ao criar “shelves”. (Contribuição de Zackery Spytz em bpo-34204.)

### statistics

Adiciona `covariance()`, `correlation()` do Pearson, e funções simples `linear_regression()`. (Contribuição de Tymoteusz Wołodźko em bpo-38490.)

### site

Quando um módulo não define `__loader__`, recorre a `__spec__.loader`. (Contribuição de Brett Cannon em bpo-42133.)

### socket

A exceção `socket.timeout` é agora um apelido de `TimeoutError`. (Contribuição de Christian Heimes em bpo-42413.)

Adiciona a opção de criar soquetes MPTCP com `IPPROTO_MPTCP` (Contribuição de Rui Cunha em bpo-43571.)

Adiciona a opção `IP_RECVTOS` para receber o tipo do serviço (ToS) ou campos DSCP/ECN (Contribuição de Georg Sauthoff em bpo-44077.)

### ssl

O módulo ssl requer OpenSSL 1.1.1 ou mais recente. (Contribuição de Christian Heimes em PEP 644 e bpo-43669.)

O módulo ssl tem um suporte preliminar para OpenSSL 3.0.0 e a nova opção `OP_IGNORE_UNEXPECTED_EOF`. (Contribuição de Christian Heimes em bpo-38820, bpo-43794, bpo-43788, bpo-43791, bpo-43799, bpo-43920, bpo-43789 e bpo-43811.)

Função descontinuada e o uso de constantes descontinuadas agora resultam em uma `DeprecationWarning`. `ssl.SSLContext.options` tem `OP_NO_SSLv2` e `OP_NO_SSLv3` definidos por padrão e, portanto, não consegue avisar sobre a definição do sinalizador novamente. A seção de descontinuidade tem uma lista de recursos descontinuados. (Contribuição de Christian Heimes em bpo-43880.)

O módulo ssl agora tem configurações padrão mais seguras. Cifras sem forward secrecy ou SHA-1 MAC são desabilitadas por padrão. O nível de segurança 2 proíbe chaves fracas RSA, DH e ECC com menos de 112 bits de segurança. `SSLContext` assume como padrão a versão mínima do protocolo TLS 1.2. As configurações são baseadas na pesquisa de Hynek Schlawack. (Contribuição de Christian Heimes em bpo-43998.)

Os protocolos descontinuados SSL 3.0, TLS 1.0 e TLS 1.1 não são mais oficialmente suportados. Python não os bloqueia ativamente. No entanto, as opções de compilação do OpenSSL, configurações de distro, patches de fornecedores e suítes de criptografia podem impedir um handshake bem-sucedido.

Adiciona um parâmetro timeout à função `ssl.get_server_certificate()`. (Contribuição de Zackery Spytz em bpo-31870.)

O módulo ssl usa tipos de heap e inicialização multifásica. (Contribuição de Christian Heimes em bpo-42333.)

Uma nova sinalização de verificação `VERIFY_X509_PARTIAL_CHAIN` foi adicionada. (Contribuição de l0x em bpo-40849.)

### sqlite3

Adiciona eventos de auditoria para `connect/handle()`, `enable_load_extension()` e `load_extension()`. (Contribuição de Erlend E. Aasland em bpo-43762.)

### sys

Adiciona o atributo `sys.orig_argv`: a lista de argumentos de linha de comando originais passada para o executável Python. (Contribuição de Victor Stinner em bpo-23427.)

Adiciona `sys.stdlib_module_names`, contendo a lista de nomes de módulos da biblioteca padrão. (Contribuição de Victor Stinner em bpo-42955.)

### _thread

`_thread.interrupt_main()` agora aceita um número de sinal opcional para simular (o padrão ainda é `signal.SIGINT`). (Contribuição de Antoine Pitrou em bpo-43356.)

### threading

Adiciona `threading.gettrace()` e `threading.getprofile()` para obter as funções definidas por `threading.settrace()` e `threading.setprofile()`, respectivamente. (Contribuição de Mario Corchero em bpo-42251.)

Adiciona `threading.__excepthook__` para permitir obtenção do valor original de `threading.excepthook()` no caso dele estar definido com um valor quebrado ou diferente. (Contribuição de Mario Corchero em bpo-42308.)

### traceback

As funções `format_exception()`, `format_exception_only()` e `print_exception()` podem agora receber um objeto exceção como um argumento somente-posicional. (Contribuição de Zackery Spytz e Matthias Bussonnier em bpo-26389.)

### types

Reintroduz as classes `types.EllipsisType`, `types.NoneType` e `types.NotImplementedType`, fornecendo um novo conjunto de tipos prontamente interpretáveis pelos verificadores de tipo. (Contribuição de Bas van Beek em bpo-41810.)

### typing

Para alterações principais, veja Novos recursos relacionados a dicas de tipo.

O comportamento de `typing.Literal` foi alterado para ficar em conformidade com a PEP 586 e para corresponder ao comportamento de verificadores de tipo estático especificados na PEP.

1. `Literal` agora elimina a duplicação de parâmetros.

2. Comparações de igualdade entre objetos `Literal` agora são independentes da ordem.

3. Comparações de `Literal` agora respeitam os tipos. Por exemplo, `Literal[0] == Literal[False]` avaliava anteriormente como `True`. Agora é `False`. Para oferecer suporte a essa mudança, o cache de tipo usado internamente agora oferece suporte a tipos de diferenciação.

4. Objetos `Literal` agora irão levantar uma exceção `TypeError` durante as comparações de igualdade se algum de seus parâmetros não for hasheáveis. Observe que declarar `Literal` com parâmetros inalteráveis não acusará um erro:

       >>> from typing import Literal
       >>> Literal[{0}]
       >>> Literal[{0}] == Literal[{False}]
       Traceback (most recent call last):
         File "<stdin>", line 1, in <module>
       TypeError: unhashable type: 'set'

(Contribuição de Yurii Karabas em bpo-42345.)

Adiciona uma nova função `typing.is_typeddict()` para fazer introspecção se uma anotação for uma `typing.TypedDict`. (Contribuição de Patrick Reader em bpo-41792.)

Subclasses de `typing.Protocol` que apenas têm variáveis de dados declaradas agora irão levantar um `TypeError` quando verificadas com `isinstance` a menos que sejam decoradas com `runtime_checkable()`. Anteriormente, essas verificações eram aprovadas silenciosamente. Os usuários devem decorar suas subclasses com o decorador `runtime_checkable()` se quiserem protocolos de tempo de execução. (Contribuição de Yurii Karabas em bpo-38908.)

A importação dos submódulos `typing.io` e `typing.re` agora emitirá `DeprecationWarning`. Esses submódulos fora descontinuados desde o Python 3.8 e serão removidos em uma versão futura do Python. Qualquer coisa pertencente a esses submódulos deve ser importada diretamente de `typing`. (Contribuição de Sebastian Rittau em bpo-38291.)

### unittest

Adiciona novo método new `assertNoLogs()` para complementar o existente `assertLogs()`. (Contribuição de Kit Yan Choi em bpo-39385.)

### urllib.parse

Versões do Python anteriores ao Python 3.10 permitiam o uso de `;` e `&` como separadores de parâmetros de consulta em `urllib.parse.parse_qs()` e `urllib.parse.parse_qsl()`. Devido a questões de segurança e em conformidade com as recomendações mais recentes do W3C, isso foi alterado para permitir apenas uma única chave separadora, com `&` como padrão. Esta mudança também afeta `cgi.parse()` e `cgi.parse_multipart()` já que elas usam as funções afetadas internamente. Para obter mais detalhes, consulte a respectiva documentação. (Contribuição de Adam Goldschmidt, Senthil Kumaran e Ken Jin em bpo-42967.)

A presença de caracteres de nova linha ou tab em partes de um URL permite algumas formas de ataques. Seguindo a especificação WHATWG que atualiza RFC 3986, nova linha ASCII `\n`, `\r` e os caracteres de tabulação `\t` são retirados da URL pelo analisador sintático em `urllib.parse` impedindo tais ataques. Os caracteres de remoção são controlados por uma nova variável de nível de módulo `urllib.parse._UNSAFE_URL_BYTES_TO_REMOVE`. (Veja gh-88048)

### xml

Adiciona uma classe `LexicalHandler` ao módulo `xml.sax.handler`. (Contribuição de Jonathan Gossage e Zackery Spytz em bpo-35018.)

### zipimport

Adiciona métodos relacionados à PEP 451: `find_spec()`, `zipimport.zipimporter.create_module()` e `zipimport.zipimporter.exec_module()`. (Contribuição de Brett Cannon em bpo-42131.)

Adiciona o método `invalidate_caches()`. (Contribuição de Desmond Cheong em bpo-14678.)

## Otimizações

- Os construtores `str()`, `bytes()` e `bytearray()` estão agora mais rápido (cerca de 30–40% para objetos pequenos). (Contribuição de Serhiy Storchaka em bpo-41334.)

- O módulo `runpy` agora importa menos módulos. O tempo de inicialização do comando `python3 -m module-name` é 1,4 vezes mais rápido em média. No Linux, `python3 -I -m module-name` importa 69 módulos no Python 3.9, sendo que importa apenas 51 módulos (-18) no Python 3.10. (Contribuição de Victor Stinner em bpo-41006 e bpo-41718.)

- A instrução `LOAD_ATTR` agora usa o novo mecanismo “cache por opcode”. É cerca de 36% mais rápido agora para atributos regulares e 44% mais rápido para slots. (Contribuição de Pablo Galindo e Yury Selivanov em bpo-42093 e Guido van Rossum em bpo-42927, com base em ideias implementadas originalmente em PyPy e MicroPython.)

- Ao construir o Python com `--enable-optimizations` agora, `-fno-semantic-interposition` é adicionado à linha de compilação e vinculação. Isso acelera as compilações do interpretador Python criado com `--enable-shared` com `gcc` em até 30%. Consulte este artigo para mais detalhes. (Contribuição de Victor Stinner e Pablo Galindo em bpo-38980.)

- Usa um novo código de gerenciamento de buffer de saída para os módulos `bz2` / `lzma` / `zlib` e adiciona a função `.readall()` à classe `_compression.DecompressReader`. A descompressão bz2 agora é 1,09x ~ 1.17x mais rápida, a descompressão lzma 1.20x ~ 1.32x mais rápida, `GzipFile.read(-1)` 1,11x ~ 1.18x mais rápida. (Contribuição de Ma Lin, revisada por Gregory P. Smith, em bpo-41486)

- Ao usar anotações em strings, dicts de anotações para funções não são mais criados quando a função é criada. Em vez disso, eles são armazenados como uma tupla de strings, e o objeto função converte lentamente isso no dict de anotações sob demanda. Essa otimização reduz pela metade o tempo de CPU necessário para definir uma função anotada. (Contribuição de Yurii Karabas e Inada Naoki em bpo-42202.)

- Funções de pesquisa de substring como `str1 in str2` e `str2.find(str1)` agora às vezes usam o algoritmo de pesquisa de string “Two-Way” de Crochemore & Perrin para evitar comportamento quadrático em strings longas. (Contribuição de Dennis Sweeney em bpo-41972)

- Adiciona micro-otimizações a `_PyType_Lookup()` para melhorar o desempenho de pesquisa de cache de atributo de tipo no caso comum de acessos de cache. Isso torna o interpretador 1,04 vezes mais rápido, em média. (Contribuição de Dino Viehland em bpo-43452.)

- As seguintes funções embutidas agora oferecem suporte a uma convenção de chamada de vectorcalls mais rápidos da PEP 590: `map()`, `filter()`, `reversed()`, `bool()` e `float()`. (Contribuição de Donghee Na e Jeroen Demeyer em bpo-43575, bpo-43287, bpo-41922, bpo-41873 e bpo-41870.)

- O desempenho de `BZ2File` foi melhorado removendo o `RLock` interno. Isso torna `BZ2File` inseguro para threads em face a vários leitores ou gravadores simultâneos, da mesma forma que suas classes equivalentes em `gzip` e `lzma` têm sido. (Contribuição de Inada Naoki em bpo-43785.)

## Descontinuados

- Atualmente Python aceita literais numéricos imediatamente seguidos por palavras-chave, por exemplo `0in x`, `1or x`, `0if 1else 2`. Permite expressões confusas e ambíguas como `[0x1for x in y]` (que pode ser interpretada como `[0x1 for x in y]` ou `[0x1f or x in y]`). A partir desta versão, um aviso de descontinuidade é levantado se o literal numérico for seguido imediatamente por uma das palavras-chave `and`, `else`, `for`, `if`, `in`, `is` e `or`. Em versões futuras, ele será alterado para aviso de sintaxe e, finalmente, para erro de sintaxe. (Contribuição de Serhiy Storchaka em bpo-43833.)

- A partir desta versão, haverá um esforço concentrado para começar a limpar a semântica de importação antiga que foi mantida para compatibilidade com Python 2.7. Especificamente, `find_loader()`/`find_module()` (substituídos por `find_spec()`), `load_module()` (substituído por `exec_module()`), `module_repr()` (que o sistema de importação cuida para você), o atributo `__package__` (substituído por `__spec__.parent`), o atributo `__loader__` (substituído por `__spec__.loader`), e o atributo `__cached__` ( substituído por `__spec__.cached`) será removido lentamente (assim como outras classes e métodos em `importlib`). `ImportWarning` e/ou `DeprecationWarning` será levantada conforme apropriado para ajudar a identificar o código que precisa ser atualizado durante esta transição.

- Todo o espaço de nomes de `distutils` foi descontinuado, para ser removido no Python 3.12. Consulte a seção de alterações do módulo para mais informações.

- Argumentos não inteiros para `random.randrange()` foram descontinuados. A exceção `ValueError` foi descontinuada em favor de uma exceção `TypeError`. (Contribuição de Serhiy Storchaka e Raymond Hettinger em bpo-37319.)

- Os vários métodos de `load_module()` de `importlib` foram documentados como descontinuados desde Python 3.6, mas agora também irão disparar um `DeprecationWarning`. Use `exec_module()` em vez disso. (Contribuição de Brett Cannon em bpo-26131.)

- `zimport.zipimporter.load_module()` foi descontinuado em preferência a `exec_module()`. (Contribuição de Brett Cannon em bpo-26131.)

- O uso de `load_module()` pelo sistema de importação agora dispara uma exceção `ImportWarning`, pois `exec_module()` é preferível. (Contribuição de Brett Cannon em bpo-26131.)

- O uso de `importlib.abc.MetaPathFinder.find_module()` e `importlib.abc.PathEntryFinder.find_module()` pelo sistema de importação agora dispara uma exceção `ImportWarning`, pois `importlib.abc.MetaPathFinder.find_spec()` e `importlib.abc.PathEntryFinder.find_spec()` são preferidos, respectivamente. Você pode usar `importlib.util.spec_from_loader()` para ajudar no port. (Contribuição de Brett Cannon em bpo-42134.)

- O uso de `importlib.abc.PathEntryFinder.find_loader()` pelo sistema de importação agora dispara uma exceção `ImportWarning`, pois `importlib.abc.PathEntryFinder.find_spec()` é preferido. Você pode usar `importlib.util.spec_from_loader()` para ajudar no port. (Contribuição de Brett Cannon em bpo-43672.)

- As várias implementações de `importlib.abc.MetaPathFinder.find_module()` ( `importlib.machinery.BuiltinImporter.find_module()`, `importlib.machinery.FrozenImporter.find_module()`, `importlib.machinery.WindowsRegistryFinder.find_module()`, `importlib.machinery.PathFinder.find_module()`, `importlib.abc.MetaPathFinder.find_module()` ), `importlib.abc.PathEntryFinder.find_module()` (`importlib.machinery.FileFinder.find_module()` ) e `importlib.abc.PathEntryFinder.find_loader()` ( `importlib.machinery.FileFinder.find_loader()` ) agora levantam `DeprecationWarning` e estão programadas para remoção no Python 3.12 (anteriormente, eles foram documentados como descontinuados no Python 3.4). (Contribuição de Brett Cannon em bpo-42135.)

- `importlib.abc.Finder` foi descontinuada (incluindo seu único método, `find_module()`). `importlib.abc.MetaPathFinder` e `importlib.abc.PathEntryFinder` não mais herdam da classe. Usuários devem herdar de uma dessas duas classes conforme apropriado. (Contribuição de Brett Cannon em bpo-42135.)

- As descontinuações de `imp`, `importlib.find_loader()`, `importlib.util.set_package_wrapper()`, `importlib.util.set_loader_wrapper()`, `importlib.util.module_for_loader()`, `pkgutil.ImpImporter` e `pkgutil.ImpLoader` foram todas atualizadas para listar Python 3.12 como a versão programada para remoção (elas começaram a levantar `DeprecationWarning` em versões anteriores do Python). (Contribuição de Brett Cannon em bpo-43720.)

- O sistema de importação agora usa o atributo `__spec__` em módulos antes de recorrer a `module_repr()` para um método `__repr__()` do módulo. A remoção do uso de `module_repr()` está programado para Python 3.12. (Contribuição de Brett Cannon em bpo-42137.)

- `importlib.abc.Loader.module_repr()`, `importlib.machinery.FrozenLoader.module_repr()` e `importlib.machinery.BuiltinLoader.module_repr()` foram descontinuadas e programadas para remoção no Python 3.12. (Contribuição de Brett Cannon em bpo-42136.)

- `sqlite3.OptimizedUnicode` teve a documentação removida e foi descontinuado desde o Python 3.3, quando foi tornado um apelido para `str`. Foi agora descontinuado, programado para remoção no Python 3.12. (Contribuição de Erlend E. Aasland em bpo-42264.)

- A função embutida não documentada `sqlite3.enable_shared_cache` foi agora descontinuada, agendada para remoção no Python 3.12. Seu uso é fortemente desencorajado pela documentação do SQLite3. Veja a documentação do SQLite3 para mais detalhes. Se um cache compartilhado deve ser usado, abra o banco de dados no modo URI usando o parâmetro de consulta `cache=shared`. (Contribuição de Erlend E. Aasland em bpo-24464.)

- Os seguintes métodos de `threading` foram agora descontinuados:

  - `threading.currentThread` => `threading.current_thread()`

  - `threading.activeCount` => `threading.active_count()`

  - `threading.Condition.notifyAll` => `threading.Condition.notify_all()`

  - `threading.Event.isSet` => `threading.Event.is_set()`

  - `threading.Thread.setName` => `threading.Thread.name`

  - `threading.thread.getName` => `threading.Thread.name`

  - `threading.Thread.isDaemon` => `threading.Thread.daemon`

  - `threading.Thread.setDaemon` => `threading.Thread.daemon`

  (Contribuição de Jelle Zijlstra em gh-87889.)

- `pathlib.Path.link_to()` foi descontinuado e programado para remoção no Python 3.12. Use `pathlib.Path.hardlink_to()` em vez disso. (Contribuição de Barney Gale em bpo-39950.)

- `cgi.log()` foi descontinuado e programado para remoção no Python 3.12. (Contribuição de Inada Naoki em bpo-41139.)

- Os recurso a seguir do `ssl` foram descontinuados desde o Python 3.6, Python 3.7 ou OpenSSL 1.1.0, e serão removidos no 3.11:

  - `OP_NO_SSLv2`, `OP_NO_SSLv3`, `OP_NO_TLSv1`, `OP_NO_TLSv1_1`, `OP_NO_TLSv1_2` e `OP_NO_TLSv1_3` foram substituídos por `minimum_version` e `maximum_version`.

  - `PROTOCOL_SSLv2`, `PROTOCOL_SSLv3`, `PROTOCOL_SSLv23`, `PROTOCOL_TLSv1`, `PROTOCOL_TLSv1_1`, `PROTOCOL_TLSv1_2` e `PROTOCOL_TLS` foram descontinuados em favor de `PROTOCOL_TLS_CLIENT` e `PROTOCOL_TLS_SERVER`

  - `wrap_socket()` foi substituída por `ssl.SSLContext.wrap_socket()`

  - `match_hostname()`

  - `RAND_pseudo_bytes()`, `RAND_egd()`

  - Recurso de NPN como `ssl.SSLSocket.selected_npn_protocol()` e `ssl.SSLContext.set_npn_protocols()` foram substituídos por ALPN.

- A depuração de threads (variável de ambiente `PYTHONTHREADDEBUG`) foi descontinuada no Python 3.10 e será removida no Python 3.12. Este recurso exige uma construção de depuração de Python. (Contribuição de Victor Stinner em bpo-44584.)

- A importação dos submódulos `typing.io` e `typing.re` agora emitirá `DeprecationWarning`. Esses submódulos serão removidos em uma versão futura do Python. Qualquer coisa pertencente a esses submódulos deve ser importada diretamente de `typing`. (Contribuição de Sebastian Rittau em bpo-38291.)

## Removidos

- Removidos os métodos especiais `__int__`, `__float__`, `__floordiv__`, `__mod__`, `__divmod__`, `__rfloordiv__`, `__rmod__` e `__rdivmod__` da classe `complex`. Eles sempre levantavam uma exceção `TypeError`. (Contribuição de Serhiy Storchaka em bpo-41974.)

- O método `ParserBase.error()` do módulo privado e não documentado `_markupbase` foi removido. `html.parser.HTMLParser` é a única subclasse de `ParserBase` e sua implementação de `error()` já tinha sido removida no Python 3.5. (Contribuição de Berker Peksag em bpo-31844.)

- Removido o atributo `unicodedata.ucnhash_CAPI` que foi um objeto interno PyCapsule. A estrutura privada relacionada `_PyUnicode_Name_CAPI` foi movida para uma API C interna. (Contribuição de Victor Stinner em bpo-42157.)

- Removido o módulo `parser`, que foi descontinuado em 3.9 em razão da mudança para o novo analisador sintático GASE, bem como todo os arquivos código-fonte e cabeçalhos C que estavam sendo usados pelo analisador sintático antigo, incluindo `node.h`, `parser.h`, `graminit.h` e `grammar.h`.

- Removidas as funções de API C pública `PyParser_SimpleParseStringFlags`, `PyParser_SimpleParseStringFlagsFilename`, `PyParser_SimpleParseFileFlags` e `PyNode_Compile` que foram descontinuadas no 3.9 em razão da mudança para o novo analisador sintático GASE.

- Removido o módulo `formatter`, que foi descontinuado no Python 3.4. É um tanto obsoleto, pouco usado e não testado. Ele foi originalmente programado para ser removido no Python 3.6, mas tais remoções foram adiadas até depois do fim de vida do Python 2.7. Os usuários existentes devem copiar quaisquer classes que usam em seu código. (Contribuição de Dong-hee Na e Terry J. Reedy em bpo-42299.)

- Removida a função `PyModule_GetWarningsModule()` que era inútil agora porque o módulo `_warnings` foi convertido em um módulo embutido no 2.6. (Contribuição de Hai Shi em bpo-42599.)

- Remove apelidos descontinuados para Classes Base Abstratas de Coleções do módulo `collections`. (Contribuição de Victor Stinner em bpo-37324.)

- O parâmetro `loop` foi removido da maioria da API de alto nível do `asyncio` seguindo a descontinuidade no Python 3.8. A motivação por trás desta alteração é multifacetada:

  1. Isso simplifica a API de alto nível.

  2. As funções na API de alto nível obtêm implicitamente o laço de eventos em execução do thread atual desde o Python 3.7. Não há necessidade de passar o laço de eventos para a API na maioria dos casos de uso normais.

  3. A passagem de laço de eventos está sujeita a erros, especialmente ao lidar com laços em execução em diferentes threads.

  Observe que a API de baixo nível ainda aceitará `loop`. Veja Alterações na API Python para exemplos de como substituir o código existente.

  (Contribuição de Yurii Karabas, Andrew Svetlov, Yury Selivanov e Kyle Stanley em bpo-42392.)

## Portando para Python 3.10

Esta seção lista as alterações descritas anteriormente e outras correções que podem exigir alterações no seu código.

### Alterações na sintaxe Python

- O aviso de descontinuação agora é emitido ao compilar a sintaxe anteriormente válida se o literal numérico for seguido imediatamente por uma palavra reservada (como em `0in x`). Em versões futuras, ele será alterado para aviso de sintaxe e, finalmente, para um erro de sintaxe. Para se livrar do aviso e tornar o código compatível com versões futuras, basta adicionar um espaço entre o literal numérico e a palavra reservada seguinte. (Contribuição de Serhiy Storchaka em bpo-43833.)

### Alterações na API Python

- Os parâmetros etype das funções `format_exception()`, `format_exception_only()` e `print_exception()` no módulo `traceback` foram renomeadas para exc. (Contribuição de Zackery Spytz e Matthias Bussonnier em bpo-26389.)

- `atexit`: ao sair do Python, se uma função de retorno registrada com `atexit.register()` falhar, sua exceção agora é registrada nos logs. Anteriormente, apenas algumas exceções eram registradas nos logs e a última exceção era sempre ignorada silenciosamente. (Contribuição de Victor Stinner em bpo-42639.)

- A classe genérica `Collections.abc.Callable` agora nivela os parâmetros de tipo, similar ao que `typing.Callable` faz atualmente. Isso significa que `collections.abc.Callable[[int, str], str]` terá `__args__` de `(int, str, str)`; anteriormente era `([int, str], str)`. O código que acessa os argumentos via `typing.get_args()` ou `__args__` precisa levar em conta esta mudança. Além disso, `TypeError` pode ser levantada para formas inválidas de parametrização `Collections.abc.Callable` que pode ter passada silenciosamente no Python 3.9. (Contribuição de Ken Jin em bpo-42195.)

- `socket.htons()` e `socket.ntohs()` agora levantam `OverflowError` em vez de `DeprecationWarning` se o parâmetro dado não couber em um inteiro sem sinal de 16 bits. (Contribuição de Erlend E. Aasland em bpo-42393.)

- O parâmetro `loop` foi removido da maioria da API de alto nível do `asyncio` seguindo a descontinuidade no Python 3.8.

  A corrotina que atualmente se parece com isso:

      async def foo(loop):
          await asyncio.sleep(1, loop=loop)

  Deve ser substituída por isso:

      async def foo():
          await asyncio.sleep(1)

  Se `foo()` for especificamente projetado para não executar no laço de eventos em execução da thread atual (por exemplo, executar no laço de eventos de outra thread), considere usar `asyncio.run_coroutine_threadsafe()`.

  (Contribuição de Yurii Karabas, Andrew Svetlov, Yury Selivanov e Kyle Stanley em bpo-42392.)

- O construtor `types.FunctionType` agora herda os embutidos atuais se o dicionário globals tiver nenhuma chave `"__builtins__"`, em vez de usar `{"None": None}` como embutidos: o mesmo comportamento que as funções `eval()` e `exec()`. Definir uma função com `def function(...): ...` no Python não é afetado, globais não podem ser substituídos com esta sintaxe: também herda os embutidos atuais. (Contribuição de Victor Stinner em bpo-42990.)

### Alterações na API C

- As funções de API C `PyParser_SimpleParseStringFlags`, `PyParser_SimpleParseStringFlagsFilename`, `PyParser_SimpleParseFileFlags`, `PyNode_Compile` e o tipo usado por essas funções, `struct _node`, foram removidos em razão da mudança para o novo analisador sintático GASE.

  O código-fonte deve ser agora compilado diretamente para um objeto código usando, por exemplo, `Py_CompileString()`. O objeto código resultante pode ser então avaliado usando, por exemplo, `PyEval_EvalCode()`.

  Especificamente:

  - Uma chamada para `PyParser_SimpleParseStringFlags` seguida por `PyNode_Compile` pode ser substituída por `Py_CompileString()`.

  - Não há substituição direta para `PyParser_SimpleParseFileFlags`. Para compilar código de um argumento `FILE *`, você vai precisar ler o arquivo em C e passar o buffer resultante para `Py_CompileString()`.

  - Para compilar um arquivo de um nome de arquivo `char *` dado, abra explicitamente o arquivo, leia-o e compile o resultado. Uma forma de fazer isso é usando o módulo `io` com `PyImport_ImportModule()`, `PyObject_CallMethod()`, `PyBytes_AsString()` e `Py_CompileString()`, como esboçado abaixo. (Declarações e tratamento de erro foram omitidos.)

        io_module = Import_ImportModule("io");
        fileobject = PyObject_CallMethod(io_module, "open", "ss", filename, "rb");
        source_bytes_object = PyObject_CallMethod(fileobject, "read", "");
        result = PyObject_CallMethod(fileobject, "close", "");
        source_buf = PyBytes_AsString(source_bytes_object);
        code = Py_CompileString(source_buf, filename, Py_file_input);

  - Para objetos `FrameObject`, o membro `f_lasti` agora representa um deslocamento de código de palavra em vez de um deslocamento simples na string de bytecode. Isso significa que esse número precisa ser multiplicado por 2 para ser usado com APIs que esperam um deslocamento de byte (como `PyCode_Addr2Line()`, por exemplo). Observe também que o membro `f_lasti` de objetos `FrameObject` não é considerado estável: por favor, use `PyFrame_GetLineNumber()` em vez disso.

## Alterações de bytecode do CPython

- A instrução `MAKE_FUNCTION` agora aceita um dicionário ou uma tupla de strings como as anotações da função. (Contribuição de Yurii Karabas e Inada Naoki em bpo-42202.)

## Mudanças na construção

- PEP 644: Python agora exige OpenSSL 1.1.1 ou mais novo. OpenSSL 1.0.2 não é mais suportado. (Contribuição de Christian Heimes em bpo-43669.)

- As funções C99 `snprintf()` e `vsnprintf()` agora são exigidas para compilar o Python. (Contribuição de Victor Stinner em bpo-36020.)

- `sqlite3` exige SQLite 3.7.15 ou superior. (Contribuição de Sergey Fedoseev e Erlend E. Aasland em bpo-40744 e bpo-40810.)

- O módulo `atexit` deve agora sempre ser construído como um módulo embutido. (Contribuição de Victor Stinner em bpo-42639.)

- Adiciona a opção `--disable-test-modules` ao script `configure`: não constrói nem instala módulos de teste. (Contribuição de Xavier de Gaye, Thomas Petazzoni e Peixing Xin em bpo-27640.)

- Adiciona a `option --with-wheel-pkg-dir=CAMINHO` ao script `./configure`. Se especificado, o módulo `ensurepip` procura por pacotes wheel de `setuptools` e `pip` neste diretório: se ambos estiverem presentes, esses pacotes wheel são usados em vez de pacotes wheel empacotados por ensurepip.

  Algumas distribuições Linux possuem políticas de empacotamento recomendando evitar o empacotamento de dependências. Por exemplo, Fedora instala pacotes wheel no diretório `/usr/share/python-wheels/` e não instala o pacote `ensurepip._bundled`.

  (Contribuição de Victor Stinner em bpo-42856.)

- Adiciona uma nova `opção --without-static-libpython de configure` para não construir biblioteca estática `libpythonMAJOR.MINOR.a` e não instala o arquivo objeto `python.o`.

  (Contribuição de Victor Stinner em bpo-43103.)

- O script `configure` agora usa o utilitário `pkg-config`, se disponível, para detectar a localização dos cabeçalhos Tcl/Tk e bibliotecas. Como antes, esses locais podem ser explicitamente especificados com as opções de configuração `--with-tcltk-includes` e `--with-tcltk-libs` . (Contribuição de Manolis Stamatogiannakis em bpo-42603.)

- Adiciona a opção `--with-openssl-rpath` ao script `configure`. A opção simplifica a construção do Python com uma instalação OpenSSL personalizada, por exemplo, `./configure --with-openssl=/path/to/openssl --with-openssl-rpath=auto`. (Contribuição de Christian Heimes em bpo-43466.)

## Alterações na API C

### PEP 652: Mantendo a ABI estável

A ABI (interface binária de aplicação) Estável para módulos de extensão ou Python embutido agora está explicitamente definido. Estabilidade da API C descreve as garantias de estabilidade da API C e ABI junto com as melhores práticas para usar a ABI estável.

(Contribuição de Petr Viktorin em PEP 652 e bpo-43795.)

### Novas funcionalidades

- O resultado de `PyNumber_Index()` agora sempre tem o tipo exato `int`. Anteriormente, o resultado poderia ser uma instância de uma subclasse de `int`. (Contribuição de Serhiy Storchaka em bpo-40792.)

- Adiciona um novo membro `orig_argv` à estrutura `PyConfig`: a lista dos argumentos originais da linha de comando passados para o executável Python. (Contribuição de Victor Stinner em bpo-23427.)

- As macros `PyDateTime_DATE_GET_TZINFO()` e `PyDateTime_TIME_GET_TZINFO()` foram adicionadas para acessar os atributos `tzinfo` dos objetos `datetime.datetime` e `datetime.time`. (Contribuição de Zackery Spytz em bpo-30155.)

- Adiciona uma função `PyCodec_Unregister()` para cancelar um registro de uma função de pesquisa de codecs. (Contribuição de Hai Shi em bpo-41842.)

- A função `PyIter_Send()` foi adicionada para permitir o envio de valor para o iterador sem levantar a exceção `StopIteration`. (Contribuição de Vladimir Matveev em bpo-41756.)

- Adiciona `PyUnicode_AsUTF8AndSize()` à API C limitada. (Contribuição de Alex Gaynor em bpo-41784.)

- Adiciona a função `PyModule_AddObjectRef()`: semelhante a `PyModule_AddObject()`, mas não roube uma referência ao valor em caso de sucesso. (Contribuição de Victor Stinner em bpo-1635741.)

- Adiciona as funções `Py_NewRef()` e `Py_XNewRef()` para incrementar a contagem de referências de um objeto e retornar o objeto. (Contribuição de Victor Stinner em bpo-42262.)

- As funções `PyType_FromSpecWithBases()` e `PyType_FromModuleAndSpec()` agora aceitam uma única classe como o argumento bases. (Contribuição de Serhiy Storchaka em bpo-42423.)

- A função `PyType_FromModuleAndSpec()` agora aceita o slot NULL `tp_doc`. (Contribuição de Hai Shi em bpo-41832.)

- A função `PyType_GetSlot()` pode aceitar tipos estáticos. (Contribuição de Hai Shi e Petr Viktorin em bpo-41073.)

- Adiciona uma nova função `PySet_CheckExact()` à C-API para verificar se um objeto é uma instância de `set`, mas não uma instância de um subtipo. (Contribuição de Pablo Galindo em bpo-43277.)

- Adiciona `PyErr_SetInterruptEx()` que permite passar um número de sinal para simular. (Contribuição de Antoine Pitrou em bpo-43356.)

- A API C limitada agora é suportada se o Python for compilado no modo de depuração (se a macro `Py_DEBUG` estiver definida). Na API C limitada, as funções `Py_INCREF()` e `Py_DECREF()` agora são implementadas como chamadas de função opacas, em vez de acessar diretamente o membro `PyObject.ob_refcnt`, se o Python for compilado no modo de depuração e a macro `Py_LIMITED_API` tiver como alvo o Python 3.10 ou mais recente. Tornou-se possível suportar a API C limitada no modo de depuração porque a estrutura `PyObject` é a mesma no modo de lançamento e depuração desde o Python 3.8 (consulte bpo-36465).

  A API C limitada ainda não é suportada na compilação especial `--with-trace-refs` (macro `Py_TRACE_REFS`). (Contribuição de Victor Stinner em bpo-43688.)

- Adiciona a função `Py_Is(x, y)` para testar se o objeto x é o objeto y, o mesmo que `x is y` em Python. Adiciona também as funções `Py_IsNone()`, `Py_IsTrue()`, `Py_IsFalse()` para testar se um objeto é, respectivamente, o singleton `None`, o singleton `True` ou o singleton `False`. (Contribuição de Victor Stinner em bpo-43753.)

- Adiciona novas funções para controlar o coletor de lixo do código C: `PyGC_Enable()`, `PyGC_Disable()`, `PyGC_IsEnabled()`. Estas funções permitem ativar, desativar e consultar o estado do coletor de lixo do código C sem precisar importar o módulo `gc`.

- Adiciona um novo sinalizador de tipo `Py_TPFLAGS_DISALLOW_INSTANTIATION` para impedir a criação de instâncias de tipo. (Contribuição de Victor Stinner em bpo-43916.)

- Adiciona um novo sinalizador de tipo `Py_TPFLAGS_IMMUTABLETYPE` para criar objetos de tipo imutável: atributos de tipo não podem ser definidos nem excluídos. (Contribuição de Victor Stinner e Erlend E. Aasland em bpo-43908.)

### Portando para Python 3.10

- A macro `PY_SSIZE_T_CLEAN` deve agora ser definida para usar os formatos `PyArg_ParseTuple()` e `Py_BuildValue()` que usam `#`: `es#`, `et#`, `s#`, `u#`, `y#`, `z#`, `U#` e `Z#`. Veja Análise de argumentos e construção de valores e PEP 353. (Contribuição de Victor Stinner em bpo-40943.)

- Como `Py_REFCNT()` é alterado para a função estática em linha, `Py_REFCNT(obj) = new_refcnt` deve ser substituído por `Py_SET_REFCNT(obj, new_refcnt)`: veja `Py_SET_REFCNT()` (disponível desde o Python 3.9). Para compatibilidade com versões anteriores, esta macro pode ser usada:

      #if PY_VERSION_HEX < 0x030900A4
      #  define Py_SET_REFCNT(obj, refcnt) ((Py_REFCNT(obj) = (refcnt)), (void)0)
      #endif

  (Contribuição de Victor Stinner em bpo-39573.)

- A chamada de `PyDict_GetItem()` sem a GIL retida era permitido por razões históricas. Isso não é mais permitido. (Contribuição de Victor Stinner em bpo-40839.)

- `PyUnicode_FromUnicode(NULL, size)` e `PyUnicode_FromStringAndSize(NULL, size)` levantam `DeprecationWarning` agora. Use `PyUnicode_New()` para alocar objeto Unicode sem dados iniciais. (Contribuição de Inada Naoki em bpo-36346.)

- A estrutura privada `_PyUnicode_Name_CAPI` da API PyCapsule `unicodedata.ucnhash_CAPI` foi movida para a API C interna. (Contribuição de Victor Stinner em bpo-42157.)

- As funções `Py_GetPath()`, `Py_GetPrefix()`, `Py_GetExecPrefix()`, `Py_GetProgramFullPath()`, `Py_GetPythonHome()` e `Py_GetProgramName()` agora retornam `NULL` se chamadas antes de `Py_Initialize()` (antes do Python ser inicializado). Use a nova API de Configuração de Inicialização do Python para obter a Python Path Configuration. (Contribuição de Victor Stinner em bpo-42260.)

- As macros `PyList_SET_ITEM()`, `PyTuple_SET_ITEM()` e `PyCell_SET()` não podem mais ser usadas como valor-l ou valor-r. Por exemplo, `x = PyList_SET_ITEM(a, b, c)` e `PyList_SET_ITEM(a, b, c) = x` agora falham com um erro do compilador. Isso previne bugs como o teste `if (PyList_SET_ITEM (a, b, c) < 0) ...`. (Contribuição de Zackery Spytz e Victor Stinner em bpo-30459.)

- Os arquivos de API não limitada `odictobject.h`, `parser_interface.h`, `piclebufobject.h`, `pyarena.h`, `pyctype.h`, `pydebug. h`, `pyfpe.h` e `pytime.h` foram movidos para o diretório `Include/cpython`. Esses arquivos não devem ser incluídos diretamente, pois já estão incluídos em `Python.h`; veja Arquivos de inclusão. Se eles foram incluídos diretamente, considere incluir `Python.h` em vez disso. (Contribuição de Nicholas Sim em bpo-35134.)

- Use o sinalizador de tipo `Py_TPFLAGS_IMMUTABLETYPE` para criar objetos de tipo imutável. Não confie em `Py_TPFLAGS_HEAPTYPE` para decidir se um objeto de tipo é mutável ou não; verifique se `Py_TPFLAGS_IMMUTABLETYPE` está definido. (Contribuição de Victor Stinner e Erlend E. Aasland em bpo-43908.)

- A função não documentada `Py_FrozenMain` foi removida da API limitada. A função é útil principalmente para compilações personalizadas do Python. (Contribuição de Petr Viktorin em bpo-26241.)

### Descontinuados

- A função `PyUnicode_InternImmortal()` agora foi descontinuada e será removida no Python 3.12: use `PyUnicode_InternInPlace()` em vez disso. (Contribuição de Victor Stinner em bpo-41692.)

### Removidos

- Removidas as funções `Py_UNICODE_str*` que manipulam strings `Py_UNICODE*`. (Contribuição de Inada Naoki em bpo-41123.)

  - `Py_UNICODE_strlen`: use `PyUnicode_GetLength()` ou `PyUnicode_GET_LENGTH`

  - `Py_UNICODE_strcat`: use `PyUnicode_CopyCharacters()` ou `PyUnicode_FromFormat()`

  - `Py_UNICODE_strcpy`, `Py_UNICODE_strncpy`: use `PyUnicode_CopyCharacters()` ou `PyUnicode_Substring()`

  - `Py_UNICODE_strcmp`: use `PyUnicode_Compare()`

  - `Py_UNICODE_strncmp`: use `PyUnicode_Tailmatch()`

  - `Py_UNICODE_strchr`, `Py_UNICODE_strrchr`: use `PyUnicode_FindChar()`

- Removida `PyUnicode_GetMax()`. Migre para as novas APIs ( PEP 393). (Contribuição de Inada Naoki em bpo-41103.)

- Removida `PyLong_FromUnicode()`. Migre para `PyLong_FromUnicodeObject()`. (Contribuição de Inada Naoki em bpo-41103.)

- Removida `PyUnicode_AsUnicodeCopy()`. Use `PyUnicode_AsUCS4Copy()` ou `PyUnicode_AsWideCharString()` (Contribuição de Inada Naoki em bpo-41103.)

- Removida a variável `_Py_CheckRecursionLimit`: foi substituída por `ceval.recursion_limit` da estrutura `PyInterpreterState`. (Contribuição de Victor Stinner em bpo-41834.)

- Removidas as macros não documentadas `Py_ALLOW_RECURSION` e `Py_END_ALLOW_RECURSION` e o campo `recursion_critical` da estrutura `PyInterpreterState`. (Contribuição de Serhiy Storchaka em bpo-41936.)

- Removida a função `PyOS_InitInterrupts()` não documentada. Inicializar o Python já instala implicitamente manipuladores de sinal: veja `PyConfig.install_signal_handlers`. (Contribuição de Victor Stinner em bpo-41713.)

- Remova a função `PyAST_Validate()`. Não é mais possível construir um objeto AST (tipo `mod_ty`) com a API C pública. A função já foi excluída da API C limitada ( PEP 384). (Contribuição de Victor Stinner em bpo-43244.)

- Remove o arquivo de cabeçalho `symtable.h` e as funções não documentadas:

  - `PyST_GetScope()`

  - `PySymtable_Build()`

  - `PySymtable_BuildObject()`

  - `PySymtable_Free()`

  - `Py_SymtableString()`

  - `Py_SymtableStringObject()`

  A função `Py_SymtableString()` fazia parte da ABI estável por engano, mas não pôde ser usada, porque o arquivo de cabeçalho `symtable.h` foi excluído da API C limitada.

  Use o módulo Python `symtable` em vez disso. (Contribuição de Victor Stinner em bpo-43244.)

- Remove `PyOS_ReadlineFunctionPointer()` dos cabeçalhos limitados da API C e de `python3.dll`, a biblioteca que fornece a ABI estável no Windows. Como a função recebe um argumento `FILE*`, sua estabilidade ABI não pode ser garantida. (Contribuição de Petr Viktorin em bpo-43868.)

- Remove os arquivos de cabeçalho `ast.h`, `asdl.h` e `Python-ast.h`. Essas funções não estavam documentadas e excluídas da API C limitada. A maioria dos nomes definidos por esses arquivos de cabeçalho não foram prefixados por `Py` e, portanto, podem criar conflitos de nomes. Por exemplo, `Python-ast.h` definiu uma macro `Yield` que estava em conflito com o nome `Yield` usado pelo cabeçalho `<winbase.h>` do Windows. Use o módulo Python `ast` em vez disso. (Contribuição de Victor Stinner em bpo-43244.)

- Remove as funções do compilador e do analisador usando o tipo `struct _mod`, porque a API AST C pública foi removida:

  - `PyAST_Compile()`

  - `PyAST_CompileEx()`

  - `PyAST_CompileObject()`

  - `PyFuture_FromAST()`

  - `PyFuture_FromASTObject()`

  - `PyParser_ASTFromFile()`

  - `PyParser_ASTFromFileObject()`

  - `PyParser_ASTFromFilename()`

  - `PyParser_ASTFromString()`

  - `PyParser_ASTFromStringObject()`

  Essas funções não estavam documentadas e excluídas da API C limitada. (Contribuição de Victor Stinner em bpo-43244.)

- Remove o arquivo de cabeçalho `pyarena.h` com funções:

  - `PyArena_New()`

  - `PyArena_Free()`

  - `PyArena_Malloc()`

  - `PyArena_AddPyObject()`

  Essas funções não estavam documentadas, excluídas da API C limitada e eram usadas apenas internamente pelo compilador. (Contribuição de Victor Stinner em bpo-43244.)

- O membro `PyThreadState.use_tracing` foi removido para otimizar o Python. (Contribuição de Mark Shannon em bpo-43760.)

## Recursos de segurança notáveis no 3.10.7

Converter entre `int` e `str` em bases diferentes de 2 (binário), 4, 8 (octal), 16 (hexadecimal) ou 32 como base 10 (decimal) agora levanta uma exceção `ValueError` se o número de dígitos em forma de string estiver acima de um limite para evitar possíveis ataques de negação de serviço devido à complexidade algorítmica. Esta é uma mitigação para CVE 2020-10735. Este limite pode ser configurado ou desabilitado por variável de ambiente, sinalizador de linha de comando ou APIs de `sys`. Veja a documentação de limitação de comprimento de conversão de string inteira. O limite padrão é de 4300 dígitos em forma de string.

## Recursos de segurança notáveis no 3.10.8

O módulo descontinuado `mailcap` agora se recusa a injetar texto não seguro (nomes de arquivos, tipos MIME, parâmetros) em comandos shell. Em vez de usar esse texto, ele avisará e agirá como se uma correspondência não fosse encontrada (ou para comandos de teste, como se o teste tivesse falhado). (Contribuição de Petr Viktorin em gh-98966.)

## Alterações notáveis no 3.10.12

### tarfile

- Os métodos de extração em `tarfile` e `shutil.unpack_archive()`, têm um novo argumento filter que permite limitar recursos do tar que podem ser surpreendentes ou perigosos, como criar arquivos fora do diretório de destino. Veja Filtros de extração para detalhes. No Python 3.12, usar sem o argumento filter mostrará um `DeprecationWarning`. No Python 3.14, o padrão mudará para `'data'`. (Contribuição de Petr Viktorin em PEP 706.)