# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2026, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

# Rafael Fontenelle <rffontenelle@gmail.com>, 2026

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.13\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-15 15:54+0000\n"

"PO-Revision-Date: 2025-09-15 01:05+0000\n"

"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2026\n"

"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"

"teams/5390/pt_BR/)\n"

"Language: pt_BR\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "

"1000000 == 0 ? 1 : 2;\n"

#: ../../tutorial/controlflow.rst:5

msgid "More Control Flow Tools"

msgstr "Mais ferramentas de controle de fluxo"

#: ../../tutorial/controlflow.rst:7

msgid ""

"As well as the :keyword:`while` statement just introduced, Python uses a few "

"more that we will encounter in this chapter."

msgstr ""

"Assim como a instrução :keyword:`while` que acabou de ser apresentada, o "

"Python usa mais algumas que encontraremos neste capítulo."

#: ../../tutorial/controlflow.rst:14

msgid ":keyword:`!if` Statements"

msgstr "Instruções :keyword:`!if`"

#: ../../tutorial/controlflow.rst:16

msgid ""

"Perhaps the most well-known statement type is the :keyword:`if` statement. "

"For example::"

msgstr ""

"Provavelmente a mais conhecida instrução de controle de fluxo é o :keyword:"

"`if`. Por exemplo::"

#: ../../tutorial/controlflow.rst:19

msgid ""

">>> x = int(input(\"Please enter an integer: \"))\n"

"Please enter an integer: 42\n"

">>> if x < 0:\n"

"... x = 0\n"

"... print('Negative changed to zero')\n"

"... elif x == 0:\n"

"... print('Zero')\n"

"... elif x == 1:\n"

"... print('Single')\n"

"... else:\n"

"... print('More')\n"

"...\n"

"More"

msgstr ""

">>> x = int(input(\"Insira um número inteiro: \"))\n"

"Insira um número inteiro: 42\n"

">>> if x < 0:\n"

"... x = 0\n"

"... print('Negativo alterado para zero')\n"

"... elif x == 0:\n"

"... print('Zero')\n"

"... elif x == 1:\n"

"... print('Um')\n"

"... else:\n"

"... print('Mais')\n"

"...\n"

"Mais"

#: ../../tutorial/controlflow.rst:33

msgid ""

"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "

"part is optional. The keyword ':keyword:`!elif`' is short for 'else if', "

"and is useful to avoid excessive indentation. An :keyword:`!if` ... :"

"keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the "

"``switch`` or ``case`` statements found in other languages."

msgstr ""

"Pode haver zero ou mais partes :keyword:`elif`, e a parte :keyword:`else` é "

"opcional. A palavra-chave ':keyword:`!elif`' é uma abreviação para 'else "

"if', e é útil para evitar indentação excessiva. Uma sequência :keyword:`!"

"if` ... :keyword:`!elif` ... :keyword:`!elif` ... substitui as instruções "

"``switch`` ou ``case``, encontrados em outras linguagens."

#: ../../tutorial/controlflow.rst:39

msgid ""

"If you're comparing the same value to several constants, or checking for "

"specific types or attributes, you may also find the :keyword:`!match` "

"statement useful. For more details see :ref:`tut-match`."

msgstr ""

"Se você está comparando o mesmo valor com várias constantes, ou verificando "

"por tipos ou atributos específicos, você também pode achar a instrução :"

"keyword:`!match` útil. Para mais detalhes veja :ref:`tut-match`."

#: ../../tutorial/controlflow.rst:46

msgid ":keyword:`!for` Statements"

msgstr "Instruções :keyword:`!for`"

#: ../../tutorial/controlflow.rst:51

msgid ""

"The :keyword:`for` statement in Python differs a bit from what you may be "

"used to in C or Pascal. Rather than always iterating over an arithmetic "

"progression of numbers (like in Pascal), or giving the user the ability to "

"define both the iteration step and halting condition (as C), Python's :"

"keyword:`!for` statement iterates over the items of any sequence (a list or "

"a string), in the order that they appear in the sequence. For example (no "

"pun intended):"

msgstr ""

"A instrução :keyword:`for` em Python é um pouco diferente do que costuma ser "

"em C ou Pascal. Ao invés de sempre iterar sobre uma progressão aritmética de "

"números (como no Pascal), ou permitir ao usuário definir o passo de iteração "

"e a condição de parada (como C), a instrução :keyword:`!for` do Python itera "

"sobre os itens de qualquer sequência (seja uma lista ou uma string), na "

"ordem que aparecem na sequência. Por exemplo:"

#: ../../tutorial/controlflow.rst:63

msgid ""

">>> # Measure some strings:\n"

">>> words = ['cat', 'window', 'defenestrate']\n"

">>> for w in words:\n"

"... print(w, len(w))\n"

"...\n"

"cat 3\n"

"window 6\n"

"defenestrate 12"

msgstr ""

">>> # Mede algumas strings:\n"

">>> palavras = ['gato', 'janela', 'defenestrar']\n"

">>> for p in palavras:\n"

"... print(p, len(p))\n"

"...\n"

"gato 4\n"

"janela 6\n"

"defenestrar 11"

#: ../../tutorial/controlflow.rst:72

msgid ""

"Code that modifies a collection while iterating over that same collection "

"can be tricky to get right. Instead, it is usually more straight-forward to "

"loop over a copy of the collection or to create a new collection::"

msgstr ""

"Código que modifica uma coleção sobre a qual está iterando pode ser "

"inseguro. No lugar disso, usualmente você deve iterar sobre uma cópia da "

"coleção ou criar uma nova coleção::"

#: ../../tutorial/controlflow.rst:76

msgid ""

"# Create a sample collection\n"

"users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}\n"

"\n"

"# Strategy: Iterate over a copy\n"

"for user, status in users.copy().items():\n"

" if status == 'inactive':\n"

" del users[user]\n"

"\n"

"# Strategy: Create a new collection\n"

"active_users = {}\n"

"for user, status in users.items():\n"

" if status == 'active':\n"

" active_users[user] = status"

msgstr ""

"# Cria uma amostra de coleção\n"

"users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}\n"

"\n"

"# Estratégia: iterar por uma cópia\n"

"for user, status in users.copy().items():\n"

" if status == 'inactive':\n"

" del users[user]\n"

"\n"

"# Estratégia: criar uma nova coleção\n"

"active_users = {}\n"

"for user, status in users.items():\n"

" if status == 'active':\n"

" active_users[user] = status"

#: ../../tutorial/controlflow.rst:94

msgid "The :func:`range` Function"

msgstr "A função :func:`range`"

#: ../../tutorial/controlflow.rst:96

msgid ""

"If you do need to iterate over a sequence of numbers, the built-in function :"

"func:`range` comes in handy. It generates arithmetic progressions::"

msgstr ""

"Se você precisa iterar sobre sequências numéricas, a função embutida :func:"

"`range` é a resposta. Ela gera progressões aritméticas::"

#: ../../tutorial/controlflow.rst:99

msgid ""

">>> for i in range(5):\n"

"... print(i)\n"

"...\n"

"0\n"

"1\n"

"2\n"

"3\n"

"4"

msgstr ""

">>> for i in range(5):\n"

"... print(i)\n"

"...\n"

"0\n"

"1\n"

"2\n"

"3\n"

"4"

#: ../../tutorial/controlflow.rst:108

msgid ""

"The given end point is never part of the generated sequence; ``range(10)`` "

"generates 10 values, the legal indices for items of a sequence of length "

"10. It is possible to let the range start at another number, or to specify "

"a different increment (even negative; sometimes this is called the 'step')::"

msgstr ""

"O ponto de parada fornecido nunca é incluído na lista; ``range(10)`` gera "

"uma lista com 10 valores, exatamente os índices válidos para uma sequência "

"de comprimento 10. É possível iniciar o intervalo com outro número, ou "

"alterar a razão da progressão (inclusive com passo negativo)::"

#: ../../tutorial/controlflow.rst:113

msgid ""

">>> list(range(5, 10))\n"

"[5, 6, 7, 8, 9]\n"

"\n"

">>> list(range(0, 10, 3))\n"

"[0, 3, 6, 9]\n"

"\n"

">>> list(range(-10, -100, -30))\n"

"[-10, -40, -70]"

msgstr ""

">>> list(range(5, 10))\n"

"[5, 6, 7, 8, 9]\n"

"\n"

">>> list(range(0, 10, 3))\n"

"[0, 3, 6, 9]\n"

"\n"

">>> list(range(-10, -100, -30))\n"

"[-10, -40, -70]"

#: ../../tutorial/controlflow.rst:122

msgid ""

"To iterate over the indices of a sequence, you can combine :func:`range` "

"and :func:`len` as follows::"

msgstr ""

"Para iterar sobre os índices de uma sequência, combine :func:`range` e :func:"

"`len` da seguinte forma::"

#: ../../tutorial/controlflow.rst:125

msgid ""

">>> a = ['Mary', 'had', 'a', 'little', 'lamb']\n"

">>> for i in range(len(a)):\n"

"... print(i, a[i])\n"

"...\n"

"0 Mary\n"

"1 had\n"

"2 a\n"

"3 little\n"

"4 lamb"

msgstr ""

">>> a = ['Maria', 'tinha', 'um', 'carneirinho']\n"

">>> for i in range(len(a)):\n"

"... print(i, a[i])\n"

"...\n"

"0 Maria\n"

"1 tinha\n"

"2 um\n"

"3 carneirinho"

#: ../../tutorial/controlflow.rst:135

msgid ""

"In most such cases, however, it is convenient to use the :func:`enumerate` "

"function, see :ref:`tut-loopidioms`."

msgstr ""

"Na maioria dos casos, porém, é mais conveniente usar a função :func:"

"`enumerate`, veja :ref:`tut-loopidioms`."

#: ../../tutorial/controlflow.rst:138

msgid "A strange thing happens if you just print a range::"

msgstr "Uma coisa estranha acontece se você imprime um intervalo::"

#: ../../tutorial/controlflow.rst:140

msgid ""

">>> range(10)\n"

"range(0, 10)"

msgstr ""

">>> range(10)\n"

"range(0, 10)"

#: ../../tutorial/controlflow.rst:143

msgid ""

"In many ways the object returned by :func:`range` behaves as if it is a "

"list, but in fact it isn't. It is an object which returns the successive "

"items of the desired sequence when you iterate over it, but it doesn't "

"really make the list, thus saving space."

msgstr ""

"Em muitos aspectos, o objeto retornado pela função :func:`range` se comporta "

"como se fosse uma lista, mas na verdade não é. É um objeto que retorna os "

"itens sucessivos da sequência desejada quando você itera sobre a mesma, mas "

"na verdade ele não gera a lista, economizando espaço."

#: ../../tutorial/controlflow.rst:148

msgid ""

"We say such an object is :term:`iterable`, that is, suitable as a target for "

"functions and constructs that expect something from which they can obtain "

"successive items until the supply is exhausted. We have seen that the :"

"keyword:`for` statement is such a construct, while an example of a function "

"that takes an iterable is :func:`sum`::"

msgstr ""

"Dizemos que um objeto é :term:`iterável`, isso é, candidato a ser alvo de "

"uma função ou construção que espera alguma coisa capaz de retornar "

"sucessivamente seus elementos um de cada vez. Nós vimos que a instrução :"

"keyword:`for` é um exemplo de construção, enquanto que um exemplo de função "

"que recebe um iterável é :func:`sum`::"

#: ../../tutorial/controlflow.rst:154

msgid ""

">>> sum(range(4)) # 0 + 1 + 2 + 3\n"

"6"

msgstr ""

">>> sum(range(4)) # 0 + 1 + 2 + 3\n"

"6"

#: ../../tutorial/controlflow.rst:157

msgid ""

"Later we will see more functions that return iterables and take iterables as "

"arguments. In chapter :ref:`tut-structures`, we will discuss :func:`list` "

"in more detail."

msgstr ""

"Mais tarde, veremos mais funções que retornam iteráveis e tomam iteráveis "

"como argumentos. No capítulo :ref:`tut-structures`, iremos discutir :func:"

"`list` em mais detalhes."

#: ../../tutorial/controlflow.rst:164

msgid ":keyword:`!break` and :keyword:`!continue` Statements"

msgstr "Instruções :keyword:`!break` e :keyword:`!continue`"

#: ../../tutorial/controlflow.rst:166

msgid ""

"The :keyword:`break` statement breaks out of the innermost enclosing :"

"keyword:`for` or :keyword:`while` loop::"

msgstr ""

"A instrução :keyword:`break` sai imediatamente do laço de repetição mais "

"interno, seja :keyword:`for` ou :keyword:`while`::"

#: ../../tutorial/controlflow.rst:169

msgid ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(f\"{n} equals {x} * {n//x}\")\n"

"... break\n"

"...\n"

"4 equals 2 * 2\n"

"6 equals 2 * 3\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

msgstr ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(f\"{n} igual a {x} * {n//x}\")\n"

"... break\n"

"...\n"

"4 igual a 2 * 2\n"

"6 igual a 2 * 3\n"

"8 igual a 2 * 4\n"

"9 equals 3 * 3"

#: ../../tutorial/controlflow.rst:180

msgid ""

"The :keyword:`continue` statement continues with the next iteration of the "

"loop::"

msgstr ""

"A instrução :keyword:`continue` continua com a próxima iteração do laço::"

#: ../../tutorial/controlflow.rst:183

msgid ""

">>> for num in range(2, 10):\n"

"... if num % 2 == 0:\n"

"... print(f\"Found an even number {num}\")\n"

"... continue\n"

"... print(f\"Found an odd number {num}\")\n"

"...\n"

"Found an even number 2\n"

"Found an odd number 3\n"

"Found an even number 4\n"

"Found an odd number 5\n"

"Found an even number 6\n"

"Found an odd number 7\n"

"Found an even number 8\n"

"Found an odd number 9"

msgstr ""

">>> for num in range(2, 10):\n"

"... if num % 2 == 0:\n"

"... print(f\"Encontrado um número par {num}\")\n"

"... continue\n"

"... print(f\"Encontrado um número ímpar {num}\")\n"

"...\n"

"Encontrado um número par 2\n"

"Encontrado um número ímpar 3\n"

"Encontrado um número par 4\n"

"Encontrado um número ímpar 5\n"

"Encontrado um número par 6\n"

"Encontrado um número ímpar 7\n"

"Encontrado um número par 8\n"

"Encontrado um número ímpar 9"

#: ../../tutorial/controlflow.rst:202

msgid ":keyword:`!else` Clauses on Loops"

msgstr "Cláusulas :keyword:`!else` em laços"

#: ../../tutorial/controlflow.rst:204

msgid ""

"In a :keyword:`!for` or :keyword:`!while` loop the :keyword:`!break` "

"statement may be paired with an :keyword:`!else` clause. If the loop "

"finishes without executing the :keyword:`!break`, the :keyword:`!else` "

"clause executes."

msgstr ""

"Em um laço :keyword:`!for` ou :keyword:`!while` a instrução :keyword:`!"

"break` pode ser pareada com uma cláusula :keyword:`!else`. Se o laço "

"terminar sem executar o :keyword:`!break`, a cláusula :keyword:`!else` será "

"executada."

#: ../../tutorial/controlflow.rst:208

msgid ""

"In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the "

"loop finishes its final iteration, that is, if no break occurred."

msgstr ""

"Em um laço :keyword:`for`, a cláusula :keyword:`!else` é executada após o "

"laço finalizar sua iteração final, ou seja, se não ocorrer nenhuma "

"interrupção."

#: ../../tutorial/controlflow.rst:211

msgid ""

"In a :keyword:`while` loop, it's executed after the loop's condition becomes "

"false."

msgstr ""

"Em um laço :keyword:`while`, ele é executado após a condição do laço se "

"tornar falsa."

#: ../../tutorial/controlflow.rst:213

msgid ""

"In either kind of loop, the :keyword:`!else` clause is **not** executed if "

"the loop was terminated by a :keyword:`break`. Of course, other ways of "

"ending the loop early, such as a :keyword:`return` or a raised exception, "

"will also skip execution of the :keyword:`else` clause."

msgstr ""

"Em qualquer tipo de laço, a cláusula :keyword:`!else` **não** é executada se "

"o laço foi encerrado por um :keyword:`break`. Claro, outras maneiras de "

"encerrar o laço mais cedo, como um :keyword:`return` ou uma exceção "

"levantada, também pularão a execução da cláusula :keyword:`else`."

#: ../../tutorial/controlflow.rst:218

msgid ""

"This is exemplified in the following :keyword:`!for` loop, which searches "

"for prime numbers::"

msgstr ""

"Isso é exemplificado no seguinte laço :keyword:`!for`, que procura por "

"números primos::"

#: ../../tutorial/controlflow.rst:221

msgid ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(n, 'equals', x, '*', n//x)\n"

"... break\n"

"... else:\n"

"... # loop fell through without finding a factor\n"

"... print(n, 'is a prime number')\n"

"...\n"

"2 is a prime number\n"

"3 is a prime number\n"

"4 equals 2 * 2\n"

"5 is a prime number\n"

"6 equals 2 * 3\n"

"7 is a prime number\n"

"8 equals 2 * 4\n"

"9 equals 3 * 3"

msgstr ""

">>> for n in range(2, 10):\n"

"... for x in range(2, n):\n"

"... if n % x == 0:\n"

"... print(n, 'igual a', x, '*', n//x)\n"

"... break\n"

"... else:\n"

"... # a iteração passou direto sem encontrar um fator\n"

"... print(n, 'é um número primo')\n"

"...\n"

"2 é um número primo\n"

"3 é um número primo\n"

"4 igual a 2 * 2\n"

"5 é um número primo\n"

"6 igual a 2 * 3\n"

"7 é um número primo\n"

"8 igual a 2 * 4\n"

"9 igual a 3 * 3"

#: ../../tutorial/controlflow.rst:239

msgid ""

"(Yes, this is the correct code. Look closely: the ``else`` clause belongs "

"to the ``for`` loop, **not** the ``if`` statement.)"

msgstr ""

"(Sim, este é o código correto. Observe atentamente: a cláusula ``else`` "

"pertence ao laço ``for``, **não** à instrução ``if``.)"

#: ../../tutorial/controlflow.rst:242

msgid ""

"One way to think of the else clause is to imagine it paired with the ``if`` "

"inside the loop. As the loop executes, it will run a sequence like if/if/if/"

"else. The ``if`` is inside the loop, encountered a number of times. If the "

"condition is ever true, a ``break`` will happen. If the condition is never "

"true, the ``else`` clause outside the loop will execute."

msgstr ""

"Uma maneira de pensar na cláusula else é imaginá-la pareada com o ``if`` "

"dentro do laço. Conforme o laço é executado, ele executará uma sequência "

"como if/if/if/else. O ``if`` está dentro do laço, encontrado várias vezes. "

"Se a condição for verdadeira, um ``break`` acontecerá. Se a condição nunca "

"for verdadeira, a cláusula ``else`` fora do laço será executada."

#: ../../tutorial/controlflow.rst:248

msgid ""

"When used with a loop, the ``else`` clause has more in common with the "

"``else`` clause of a :keyword:`try` statement than it does with that of "

"``if`` statements: a ``try`` statement's ``else`` clause runs when no "

"exception occurs, and a loop's ``else`` clause runs when no ``break`` "

"occurs. For more on the ``try`` statement and exceptions, see :ref:`tut-"

"handling`."

msgstr ""

"Quando usado em um laço, a cláusula ``else`` tem mais em comum com a "

"cláusula ``else`` de uma instrução :keyword:`try` do que com a de instruções "

"``if``: a cláusula ``else`` de uma instrução ``try`` é executada quando não "

"ocorre exceção, e a cláusula ``else`` de um laço é executada quando não "

"ocorre um ``break``. Para mais informações sobre instrução ``try`` e "

"exceções, veja :ref:`tut-handling`."

#: ../../tutorial/controlflow.rst:258

msgid ":keyword:`!pass` Statements"

msgstr "Instruções :keyword:`!pass`"

#: ../../tutorial/controlflow.rst:260

msgid ""

"The :keyword:`pass` statement does nothing. It can be used when a statement "

"is required syntactically but the program requires no action. For example::"

msgstr ""

"A instrução :keyword:`pass` não faz nada. Pode ser usada quando a sintaxe "

"exige uma instrução, mas a semântica do programa não requer nenhuma ação. "

"Por exemplo::"

#: ../../tutorial/controlflow.rst:263

msgid ""

">>> while True:\n"

"... pass # Busy-wait for keyboard interrupt (Ctrl+C)\n"

"..."

msgstr ""

">>> while True:\n"

"... pass # Ocupado, aguardando interrupção por teclado (Ctrl+C)\n"

"..."

#: ../../tutorial/controlflow.rst:267

msgid "This is commonly used for creating minimal classes::"

msgstr "Isto é usado muitas vezes para se definir classes mínimas::"

#: ../../tutorial/controlflow.rst:269

msgid ""

">>> class MyEmptyClass:\n"

"... pass\n"

"..."

msgstr ""

">>> class MinhaClasseVazia:\n"

"... pass\n"

"..."

#: ../../tutorial/controlflow.rst:273

msgid ""

"Another place :keyword:`pass` can be used is as a place-holder for a "

"function or conditional body when you are working on new code, allowing you "

"to keep thinking at a more abstract level. The :keyword:`!pass` is silently "

"ignored::"

msgstr ""

"Outra ocasião em que o :keyword:`pass` pode ser usado é como um substituto "

"temporário para uma função ou bloco condicional, quando se está trabalhando "

"com código novo, ainda indefinido, permitindo que mantenha-se o pensamento "

"num nível mais abstrato. O :keyword:`!pass` é silenciosamente ignorado::"

#: ../../tutorial/controlflow.rst:277

msgid ""

">>> def initlog(*args):\n"

"... pass # Remember to implement this!\n"

"..."

msgstr ""

">>> def initlog(*args):\n"

"... pass # Lembre-se de implementar isso!\n"

"..."

#: ../../tutorial/controlflow.rst:281

msgid ""

"For this last case, many people use the ellipsis literal :code:`...` instead "

"of :code:`pass`. This use has no special meaning to Python, and is not part "

"of the language definition (you could use any constant expression here), "

"but :code:`...` is used conventionally as a placeholder body as well. See :"

"ref:`bltin-ellipsis-object`."

msgstr ""

"Para este último caso, muitas pessoas usam o literal de reticências :code:"

"`...` em vez de :code:`pass`. Este uso não tem significado especial para "

"Python e não faz parte da definição da linguagem (você pode usar qualquer "

"expressão constante aqui), mas :code:`...` também é usado convencionalmente "

"como um espaço reservado. Consulte :ref:`bltin-ellipsis-object`."

#: ../../tutorial/controlflow.rst:291

msgid ":keyword:`!match` Statements"

msgstr "Instruções :keyword:`!match`"

#: ../../tutorial/controlflow.rst:293

msgid ""

"A :keyword:`match` statement takes an expression and compares its value to "

"successive patterns given as one or more case blocks. This is superficially "

"similar to a switch statement in C, Java or JavaScript (and many other "

"languages), but it's more similar to pattern matching in languages like Rust "

"or Haskell. Only the first pattern that matches gets executed and it can "

"also extract components (sequence elements or object attributes) from the "

"value into variables."

msgstr ""

"Uma instrução :keyword:`match` pega uma expressão e compara seu valor com "

"padrões sucessivos fornecidos como um ou mais blocos de case. Isso é "

"superficialmente semelhante a uma instrução switch em C, Java ou JavaScript "

"(e muitas outras linguagens), mas também pode extrair componentes (elementos "

"de sequência ou atributos de objeto) do valor em variáveis, mas muito mais "

"parecido com a correspondência de padrões em linguages como Rust ou Haskell. "

"Apenas o primeiro padrão que corresponder será executado, podendo também "

"extrair componentes (elementos de sequência ou atributos de objetos) do "

"valor para variáveis."

#: ../../tutorial/controlflow.rst:301

msgid ""

"The simplest form compares a subject value against one or more literals::"

msgstr ""

"A forma mais simples compara um valor de assunto com um ou mais literais::"

#: ../../tutorial/controlflow.rst:303

msgid ""

"def http_error(status):\n"

" match status:\n"

" case 400:\n"

" return \"Bad request\"\n"

" case 404:\n"

" return \"Not found\"\n"

" case 418:\n"

" return \"I'm a teapot\"\n"

" case _:\n"

" return \"Something's wrong with the internet\""

msgstr ""

"def http_error(status):\n"

" match status:\n"

" case 400:\n"

" return \"Bad request\"\n"

" case 404:\n"

" return \"Not found\"\n"

" case 418:\n"

" return \"I'm a teapot\"\n"

" case _:\n"

" return \"Something's wrong with the internet\""

#: ../../tutorial/controlflow.rst:314

msgid ""

"Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and "

"never fails to match. If no case matches, none of the branches is executed."

msgstr ""

"Observe o último bloco: o \"nome da variável\" ``_`` atua como um *curinga* "

"e nunca falha em corresponder. Se nenhum caso corresponder, nenhuma das "

"ramificações será executada."

#: ../../tutorial/controlflow.rst:317

msgid ""

"You can combine several literals in a single pattern using ``|`` (\"or\")::"

msgstr ""

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

#: ../../tutorial/controlflow.rst:319

msgid ""

"case 401 | 403 | 404:\n"

" return \"Not allowed\""

msgstr ""

"case 401 | 403 | 404:\n"

" return \"Não permitido\""

#: ../../tutorial/controlflow.rst:322

msgid ""

"Patterns can look like unpacking assignments, and can be used to bind "

"variables::"

msgstr ""

"Os padrões podem se parecer com atribuições de desempacotamento e podem ser "

"usados para vincular variáveis::"

#: ../../tutorial/controlflow.rst:325

msgid ""

"# point is an (x, y) tuple\n"

"match point:\n"

" case (0, 0):\n"

" print(\"Origin\")\n"

" case (0, y):\n"

" print(f\"Y={y}\")\n"

" case (x, 0):\n"

" print(f\"X={x}\")\n"

" case (x, y):\n"

" print(f\"X={x}, Y={y}\")\n"

" case _:\n"

" raise ValueError(\"Not a point\")"

msgstr ""

"# ponto é uma tupla (x, y)\n"

"match ponto:\n"

" case (0, 0):\n"

" print(\"Origem\")\n"

" case (0, y):\n"

" print(f\"Y={y}\")\n"

" case (x, 0):\n"

" print(f\"X={x}\")\n"

" case (x, y):\n"

" print(f\"X={x}, Y={y}\")\n"

" case _:\n"

" raise ValueError(\"Não é um ponto\")"

#: ../../tutorial/controlflow.rst:338

msgid ""

"Study that one carefully! The first pattern has two literals, and can be "

"thought of as an extension of the literal pattern shown above. But the next "

"two patterns combine a literal and a variable, and the variable *binds* a "

"value from the subject (``point``). The fourth pattern captures two values, "

"which makes it conceptually similar to the unpacking assignment ``(x, y) = "

"point``."

msgstr ""

"Estude isso com cuidado! O primeiro padrão tem dois literais e pode ser "

"considerado uma extensão do padrão literal mostrado acima. Mas 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``."

#: ../../tutorial/controlflow.rst:345

msgid ""

"If you are using classes to structure your data you can use the class name "

"followed by an argument list resembling a constructor, but with the ability "

"to capture attributes into variables::"

msgstr ""

"Se você estiver usando classes para estruturar seus dados, você pode usar o "

"nome da classe seguido por uma lista de argumentos semelhante a um "

"construtor, mas com a capacidade de capturar atributos em variáveis::"

#: ../../tutorial/controlflow.rst:349

msgid ""

"class Point:\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"def where_is(point):\n"

" match point:\n"

" case Point(x=0, y=0):\n"

" print(\"Origin\")\n"

" case Point(x=0, y=y):\n"

" print(f\"Y={y}\")\n"

" case Point(x=x, y=0):\n"

" print(f\"X={x}\")\n"

" case Point():\n"

" print(\"Somewhere else\")\n"

" case _:\n"

" print(\"Not a point\")"

msgstr ""

"class Ponto:\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"def onde_está(ponto):\n"

" match ponto:\n"

" case Ponto(x=0, y=0):\n"

" print(\"Origem\")\n"

" case Ponto(x=0, y=y):\n"

" print(f\"Y={y}\")\n"

" case Ponto(x=x, y=0):\n"

" print(f\"X={x}\")\n"

" case Ponto():\n"

" print(\"Em outro lugar\")\n"

" case _:\n"

" print(\"Não é um ponto\")"

#: ../../tutorial/controlflow.rst:367

msgid ""

"You can use positional parameters with some builtin classes that provide an "

"ordering for their attributes (e.g. dataclasses). You can also define a "

"specific position for attributes in patterns by setting the "

"``__match_args__`` special attribute in your classes. If it's set to (\"x\", "

"\"y\"), the following patterns are all equivalent (and all bind the ``y`` "

"attribute to the ``var`` variable)::"

msgstr ""

"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``)::"

#: ../../tutorial/controlflow.rst:373

msgid ""

"Point(1, var)\n"

"Point(1, y=var)\n"

"Point(x=1, y=var)\n"

"Point(y=var, x=1)"

msgstr ""

"Ponto(1, var)\n"

"Ponto(1, y=var)\n"

"Ponto(x=1, y=var)\n"

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

#: ../../tutorial/controlflow.rst:378

msgid ""

"A recommended way to read patterns is to look at them as an extended form of "

"what you would put on the left of an assignment, to understand which "

"variables would be set to what. Only the standalone names (like ``var`` "

"above) are assigned to by a match statement. Dotted names (like ``foo."

"bar``), attribute names (the ``x=`` and ``y=`` above) or class names "

"(recognized by the \"(...)\" next to them like ``Point`` above) are never "

"assigned to."

msgstr ""

"Uma maneira recomendada de ler padrões é vê-los como uma forma estendida do "

"que você colocaria à esquerda de uma atribuição, para entender quais "

"variáveis seriam definidas para quê. Apenas os nomes autônomos (como ``var`` "

"acima) são atribuídos por uma instrução de correspondência. Nomes "

"pontilhados (como ``foo.bar``), nomes de atributos (o ``x=`` e ``y=`` acima) "

"ou nomes de classes (reconhecidos pelo \"(...)\" próximo a eles, como "

"``Ponto`` acima) nunca são atribuídos."

#: ../../tutorial/controlflow.rst:385

msgid ""

"Patterns can be arbitrarily nested. For example, if we have a short list of "

"Points, with ``__match_args__`` added, we could match it like this::"

msgstr ""

"Os padrões podem ser aninhados arbitrariamente. Por exemplo, se tivermos uma "

"pequena lista de Pontos, com ``__match_args__`` adicionado, poderíamos "

"correspondê-la assim::"

#: ../../tutorial/controlflow.rst:388

msgid ""

"class Point:\n"

" __match_args__ = ('x', 'y')\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"match points:\n"

" case []:\n"

" print(\"No points\")\n"

" case [Point(0, 0)]:\n"

" print(\"The origin\")\n"

" case [Point(x, y)]:\n"

" print(f\"Single point {x}, {y}\")\n"

" case [Point(0, y1), Point(0, y2)]:\n"

" print(f\"Two on the Y axis at {y1}, {y2}\")\n"

" case _:\n"

" print(\"Something else\")"

msgstr ""

"class Ponto:\n"

" __match_args__ = ('x', 'y')\n"

" def __init__(self, x, y):\n"

" self.x = x\n"

" self.y = y\n"

"\n"

"match pontos:\n"

" case []:\n"

" print(\"Sem pontos\")\n"

" case [Ponto(0, 0)]:\n"

" print(\"A origem\")\n"

" case [Ponto(x, y)]:\n"

" print(f\"Ponto único {x}, {y}\")\n"

" case [Ponto(0, y1), Ponto(0, y2)]:\n"

" print(f\"Dois do eixo Y em {y1}, {y2}\")\n"

" case _:\n"

" print(\"Outra coisa\")"

#: ../../tutorial/controlflow.rst:406

msgid ""

"We can add an ``if`` clause to a pattern, known as a \"guard\". If the "

"guard is false, ``match`` goes on to try the next case block. Note that "

"value capture happens before the guard is evaluated::"

msgstr ""

"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::"

#: ../../tutorial/controlflow.rst:410

msgid ""

"match point:\n"

" case Point(x, y) if x == y:\n"

" print(f\"Y=X at {x}\")\n"

" case Point(x, y):\n"

" print(f\"Not on the diagonal\")"

msgstr ""

"match ponto:\n"

" case Ponto(x, y) if x == y:\n"

" print(f\"Y=X at {x}\")\n"

" case Ponto(x, y):\n"

" print(f\"Não está na diagonal\")"

#: ../../tutorial/controlflow.rst:416

msgid "Several other key features of this statement:"

msgstr "Vários outros recursos importantes desta instrução::"

#: ../../tutorial/controlflow.rst:418

msgid ""

"Like unpacking assignments, tuple and list patterns have exactly the same "

"meaning and actually match arbitrary sequences. An important exception is "

"that they don't match iterators or strings."

msgstr ""

"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. Uma exceção importante é que eles não correspondem a iteradores "

"ou strings."

#: ../../tutorial/controlflow.rst:422

msgid ""

"Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, "

"*rest)`` work similar to unpacking assignments. The name after ``*`` may "

"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items "

"without binding the remaining items."

msgstr ""

"Os padrões de sequência têm suporte ao desempacotamento estendido: ``[x, y, "

"*rest]`` e ``(x, y, *rest)`` funcionam de forma semelhante ao "

"desempacotamento 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."

#: ../../tutorial/controlflow.rst:427

msgid ""

"Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the "

"``\"bandwidth\"`` and ``\"latency\"`` values from a dictionary. Unlike "

"sequence patterns, extra keys are ignored. An unpacking like ``**rest`` is "

"also supported. (But ``**_`` would be redundant, so it is not allowed.)"

msgstr ""

"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 desempacotamento como "

"``**rest`` também é permitido. (Mas ``**_`` seria redundante, então não é "

"permitido.)"

#: ../../tutorial/controlflow.rst:432

msgid "Subpatterns may be captured using the ``as`` keyword::"

msgstr "Subpadrões podem ser capturados usando a palavra reservada ``as`` ::"

#: ../../tutorial/controlflow.rst:434

msgid "case (Point(x1, y1), Point(x2, y2) as p2): ..."

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

#: ../../tutorial/controlflow.rst:436

msgid ""

"will capture the second element of the input as ``p2`` (as long as the input "

"is a sequence of two points)"

msgstr ""

"Vai capturar o segundo elemento da entrada como ``p2`` (se a entrada for uma "

"sequência de dois pontos)"

#: ../../tutorial/controlflow.rst:439

msgid ""

"Most literals are compared by equality, however the singletons ``True``, "

"``False`` and ``None`` are compared by identity."

msgstr ""

"A maioria dos literais são comparados por igualdade, no entanto os "

"singletons ``True``, ``False`` e ``None`` são comparados por identidade."

#: ../../tutorial/controlflow.rst:442

msgid ""

"Patterns may use named constants. These must be dotted names to prevent "

"them from being interpreted as capture variables::"

msgstr ""

"Padrões podem usar constantes nomeadas. Estas devem ser nomes pontilhados "

"para prevenir que sejam interpretadas como variáveis de captura::"

#: ../../tutorial/controlflow.rst:445

msgid ""

"from enum import Enum\n"

"class Color(Enum):\n"

" RED = 'red'\n"

" GREEN = 'green'\n"

" BLUE = 'blue'\n"

"\n"

"color = Color(input(\"Enter your choice of 'red', 'blue' or 'green': \"))\n"

"\n"

"match color:\n"

" case Color.RED:\n"

" print(\"I see red!\")\n"

" case Color.GREEN:\n"