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

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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-02-27 16:15+0000\n"

"PO-Revision-Date: 2025-07-18 19:59+0000\n"

"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\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/introduction.rst:5

msgid "An Informal Introduction to Python"

msgstr "Uma introdução informal ao Python"

#: ../../tutorial/introduction.rst:7

msgid ""

"In the following examples, input and output are distinguished by the "

"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "

"example, you must type everything after the prompt, when the prompt appears; "

"lines that do not begin with a prompt are output from the interpreter. Note "

"that a secondary prompt on a line by itself in an example means you must "

"type a blank line; this is used to end a multi-line command."

msgstr ""

"Nos exemplos seguintes, pode-se distinguir entrada e saída pela presença ou "

"ausência dos prompts (:term:`>>>` e :term:`...`): para repetir o exemplo, "

"você deve digitar tudo após o prompt, quando o mesmo aparece; linhas que não "

"começarem com um prompt são na verdade as saídas geradas pelo interpretador. "

"Observe que quando aparece uma linha contendo apenas o prompt secundário "

"você deve digitar uma linha em branco; é assim que se encerra um comando de "

"múltiplas linhas."

#: ../../tutorial/introduction.rst:16

msgid ""

"You can toggle the display of prompts and output by clicking on ``>>>`` in "

"the upper-right corner of an example box. If you hide the prompts and "

"output for an example, then you can easily copy and paste the input lines "

"into your interpreter."

msgstr ""

"Você pode alternar a exibição de prompts e saída clicando em ``>>>`` no "

"canto superior direito de uma caixa de exemplo. Se você ocultar os prompts e "

"a saída para um exemplo, poderá copiar e colar facilmente as linhas de "

"entrada no seu interpretador."

#: ../../tutorial/introduction.rst:23

msgid ""

"Many of the examples in this manual, even those entered at the interactive "

"prompt, include comments. Comments in Python start with the hash character, "

"``#``, and extend to the end of the physical line. A comment may appear at "

"the start of a line or following whitespace or code, but not within a string "

"literal. A hash character within a string literal is just a hash character. "

"Since comments are to clarify code and are not interpreted by Python, they "

"may be omitted when typing in examples."

msgstr ""

"Muitos exemplos neste manual, mesmo aqueles inscritos na linha de comando "

"interativa, incluem comentários. Comentários em Python começam com o "

"caractere cerquilha ``#`` e estende até o final da linha. Um comentário pode "

"aparecer no inicio da linha ou após espaço em branco ou código, mas não "

"dentro de uma string literal. O caractere cerquilha dentro de uma string "

"literal é apenas uma cerquilha. Como os comentários são para esclarecer o "

"código e não são interpretados pelo Python, eles podem ser omitidos ao "

"digitar exemplos."

#: ../../tutorial/introduction.rst:31

msgid "Some examples::"

msgstr "Alguns exemplos:"

#: ../../tutorial/introduction.rst:33

msgid ""

"# this is the first comment\n"

"spam = 1 # and this is the second comment\n"

" # ... and now a third!\n"

"text = \"# This is not a comment because it's inside quotes.\""

msgstr ""

"# este é o primeiro comentário\n"

"spam = 1 # e este é o segundo comentário\n"

" # ... e agora um terceiro!\n"

"texto = \"# Este não é um comentário por estar entre aspas.\""

#: ../../tutorial/introduction.rst:42

msgid "Using Python as a Calculator"

msgstr "Usando Python como uma calculadora"

#: ../../tutorial/introduction.rst:44

msgid ""

"Let's try some simple Python commands. Start the interpreter and wait for "

"the primary prompt, ``>>>``. (It shouldn't take long.)"

msgstr ""

"Vamos experimentar alguns comandos simples em Python. Inicie o interpretador "

"e aguarde o prompt primário, ``>>>``. (Não deve demorar muito.)"

#: ../../tutorial/introduction.rst:51

msgid "Numbers"

msgstr "Números"

#: ../../tutorial/introduction.rst:53

msgid ""

"The interpreter acts as a simple calculator: you can type an expression at "

"it and it will write the value. Expression syntax is straightforward: the "

"operators ``+``, ``-``, ``*`` and ``/`` can be used to perform arithmetic; "

"parentheses (``()``) can be used for grouping. For example::"

msgstr ""

"O interpretador funciona como uma calculadora bem simples: você pode digitar "

"uma expressão e o resultado será apresentado. A sintaxe de expressões é a "

"usual: operadores ``+``, ``-``, ``*`` e ``/`` podem ser usadas para realizar "

"operações aritméticas; parênteses (``()``) podem ser usados para agrupar "

"expressões. Por exemplo::"

#: ../../tutorial/introduction.rst:59

msgid ""

">>> 2 + 2\n"

"4\n"

">>> 50 - 5*6\n"

"20\n"

">>> (50 - 5*6) / 4\n"

"5.0\n"

">>> 8 / 5 # division always returns a floating-point number\n"

"1.6"

msgstr ""

">>> 2 + 2\n"

"4\n"

">>> 50 - 5*6\n"

"20\n"

">>> (50 - 5*6) / 4\n"

"5.0\n"

">>> 8 / 5 # divisão sempre retorna um número de ponto flutuante\n"

"1.6"

#: ../../tutorial/introduction.rst:68

msgid ""

"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "

"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"

"`float`. We will see more about numeric types later in the tutorial."

msgstr ""

"Os números inteiros (por exemplo, ``2``, ``4`` e ``20``) são do tipo :class:"

"`int`, aqueles com parte fracionária (por exemplo, ``5.0`` e ``1.6``) são do "

"tipo :class:`float`. Veremos mais sobre tipos numéricos posteriormente neste "

"tutorial."

#: ../../tutorial/introduction.rst:72

msgid ""

"Division (``/``) always returns a float. To do :term:`floor division` and "

"get an integer result you can use the ``//`` operator; to calculate the "

"remainder you can use ``%``::"

msgstr ""

"Divisão (``/``) sempre retorna ponto flutuante (float). Para fazer uma :term:"

"`divisão pelo piso` e receber um inteiro como resultado você pode usar o "

"operador ``//``; para calcular o resto você pode usar o ``%``::"

#: ../../tutorial/introduction.rst:76

msgid ""

">>> 17 / 3 # classic division returns a float\n"

"5.666666666666667\n"

">>>\n"

">>> 17 // 3 # floor division discards the fractional part\n"

"5\n"

">>> 17 % 3 # the % operator returns the remainder of the division\n"

"2\n"

">>> 5 * 3 + 2 # floored quotient * divisor + remainder\n"

"17"

msgstr ""

">>> 17 / 3 # divisão clássica retorna um ponto flutuante\n"

"5.666666666666667\n"

">>>\n"

">>> 17 // 3 # divisão pelo piso descarta a parte fracionária\n"

"5\n"

">>> 17 % 3 # o operador % retorna o resto da divisão\n"

"2\n"

">>> 5 * 3 + 2 # quociente do piso * divisor + restante\n"

"17"

#: ../../tutorial/introduction.rst:86

msgid ""

"With Python, it is possible to use the ``**`` operator to calculate powers "

"[#]_::"

msgstr ""

"Com Python, é possível usar o operador ``**`` para calcular potências [#]_::"

#: ../../tutorial/introduction.rst:88

msgid ""

">>> 5 ** 2 # 5 squared\n"

"25\n"

">>> 2 ** 7 # 2 to the power of 7\n"

"128"

msgstr ""

">>> 5 ** 2 # 5 ao quadrado\n"

"25\n"

">>> 2 ** 7 # 2 à potência de 7\n"

"128"

#: ../../tutorial/introduction.rst:93

msgid ""

"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "

"no result is displayed before the next interactive prompt::"

msgstr ""

"O sinal de igual (``'='``) é usado para atribuir um valor a uma variável. "

"Depois de uma atribuição, nenhum resultado é exibido antes do próximo "

"prompt::"

#: ../../tutorial/introduction.rst:96

msgid ""

">>> width = 20\n"

">>> height = 5 * 9\n"

">>> width * height\n"

"900"

msgstr ""

">>> largura = 20\n"

">>> altura = 5 * 9\n"

">>> largura * altura\n"

"900"

#: ../../tutorial/introduction.rst:101

msgid ""

"If a variable is not \"defined\" (assigned a value), trying to use it will "

"give you an error::"

msgstr ""

"Se uma variável não é \"definida\" (não tem um valor atribuído), tentar "

"utilizá-la levantará um erro::"

#: ../../tutorial/introduction.rst:104

msgid ""

">>> n # try to access an undefined variable\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"NameError: name 'n' is not defined"

msgstr ""

">>> n # tenta acessar uma variável não definida\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"NameError: name 'n' is not defined"

#: ../../tutorial/introduction.rst:109

msgid ""

"There is full support for floating point; operators with mixed type operands "

"convert the integer operand to floating point::"

msgstr ""

"Há suporte completo para ponto flutuante (*float*); operadores com operandos "

"de diferentes tipos convertem o inteiro para ponto flutuante::"

#: ../../tutorial/introduction.rst:112

msgid ""

">>> 4 * 3.75 - 1\n"

"14.0"

msgstr ""

">>> 4 * 3.75 - 1\n"

"14.0"

#: ../../tutorial/introduction.rst:115

msgid ""

"In interactive mode, the last printed expression is assigned to the variable "

"``_``. This means that when you are using Python as a desk calculator, it "

"is somewhat easier to continue calculations, for example::"

msgstr ""

"No modo interativo, o valor da última expressão exibida é atribuída a "

"variável ``_``. Assim, ao utilizar Python como uma calculadora, fica mais "

"fácil prosseguir com os cálculos, por exemplo::"

#: ../../tutorial/introduction.rst:119

msgid ""

">>> tax = 12.5 / 100\n"

">>> price = 100.50\n"

">>> price * tax\n"

"12.5625\n"

">>> price + _\n"

"113.0625\n"

">>> round(_, 2)\n"

"113.06"

msgstr ""

">>> taxa = 12.5 / 100\n"

">>> preço = 100.50\n"

">>> preço * taxa\n"

"12.5625\n"

">>> preço + _\n"

"113.0625\n"

">>> round(_, 2)\n"

"113.06"

#: ../../tutorial/introduction.rst:128

msgid ""

"This variable should be treated as read-only by the user. Don't explicitly "

"assign a value to it --- you would create an independent local variable with "

"the same name masking the built-in variable with its magic behavior."

msgstr ""

"Essa variável especial deve ser tratada como *somente para leitura* pelo "

"usuário. Nunca lhe atribua explicitamente um valor --- do contrário, estaria "

"criando uma outra variável (homônima) independente, que mascararia a "

"variável especial com seu comportamento mágico."

#: ../../tutorial/introduction.rst:132

msgid ""

"In addition to :class:`int` and :class:`float`, Python supports other types "

"of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions."

"Fraction`. Python also has built-in support for :ref:`complex numbers "

"<typesnumeric>`, and uses the ``j`` or ``J`` suffix to indicate the "

"imaginary part (e.g. ``3+5j``)."

msgstr ""

"Além de :class:`int` e :class:`float`, o Python oferece suporte a outros "

"tipos de números, tais como :class:`~decimal.Decimal` e :class:`~fractions."

"Fraction`. O Python também possui suporte embutido a :ref:`números complexos "

"<typesnumeric>`, e usa os sufixos ``j`` ou ``J`` para indicar a parte "

"imaginária (por exemplo, ``3+5j``)."

#: ../../tutorial/introduction.rst:142

msgid "Text"

msgstr "Texto"

#: ../../tutorial/introduction.rst:144

msgid ""

"Python can manipulate text (represented by type :class:`str`, so-called "

"\"strings\") as well as numbers. This includes characters \"``!``\", words "

"\"``rabbit``\", names \"``Paris``\", sentences \"``Got your back.``\", etc. "

"\"``Yay! :)``\". They can be enclosed in single quotes (``'...'``) or double "

"quotes (``\"...\"``) with the same result [#]_."

msgstr ""

"Python pode manipular texto (representado pelo tipo :class:`str`, também "

"chamado de \"strings\"), bem como números. Isso inclui caracteres \"``!``\", "

"palavras \"``coelho``\", nomes \"``Paris``\", frases \"``Eu te protejo.``\", "

"etc. \"``Oba! :)``\". Eles podem ser colocados entre aspas simples "

"(``'...'``) ou aspas duplas (``\"...\"``) com o mesmo resultado [#]_."

#: ../../tutorial/introduction.rst:157

msgid ""

"To quote a quote, we need to \"escape\" it, by preceding it with ``\\``. "

"Alternatively, we can use the other type of quotation marks::"

msgstr ""

"Para colocar aspas entre aspas, precisamos \"escapá-la\", precedendo-as com "

"``\\``. Alternativamente, podemos usar o outro tipo de aspas::"

#: ../../tutorial/introduction.rst:160

msgid ""

">>> 'doesn\\'t' # use \\' to escape the single quote...\n"

"\"doesn't\"\n"

">>> \"doesn't\" # ...or use double quotes instead\n"

"\"doesn't\"\n"

">>> '\"Yes,\" they said.'\n"

"'\"Yes,\" they said.'\n"

">>> \"\\\"Yes,\\\" they said.\"\n"

"'\"Yes,\" they said.'\n"

">>> '\"Isn\\'t,\" they said.'\n"

"'\"Isn\\'t,\" they said.'"

msgstr ""

">>> 'd\\'água' # use \\' para escapar a aspa simples...\n"

"\"d'água\"\n"

">>> \"d'água\" # ...ou use aspas duplas\n"

"\"d'água\"\n"

">>> '\"Sim\", eles disseram.'\n"

"'\"Sim\", eles disseram.'\n"

">>> \"\\\"Sim\\\", eles disseram.\"\n"

"'\"Sim\", eles disseram.'\n"

">>> '\"Copo d\\'água\", eles pediram.'\n"

"'\"Copo d'água\", eles pediram.'"

#: ../../tutorial/introduction.rst:171

msgid ""

"In the Python shell, the string definition and output string can look "

"different. The :func:`print` function produces a more readable output, by "

"omitting the enclosing quotes and by printing escaped and special "

"characters::"

msgstr ""

"No shell do Python, a definição de string e a string de saída podem parecer "

"diferentes. A função :func:`print` produz uma saída mais legível, omitindo "

"as aspas delimitadoras e imprimindo caracteres de escape e especiais::"

#: ../../tutorial/introduction.rst:175

msgid ""

">>> s = 'First line.\\nSecond line.' # \\n means newline\n"

">>> s # without print(), special characters are included in the string\n"

"'First line.\\nSecond line.'\n"

">>> print(s) # with print(), special characters are interpreted, so \\n "

"produces new line\n"

"First line.\n"

"Second line."

msgstr ""

">>> s = 'Primeira linha.\\nSegunda linha.' # \\n significa nova linha\n"

">>> s # sem print(), caracteres especiais são incluídos na string\n"

"'Primeira linha.\\nSegunda linha.'\n"

">>> print(s) # com print(), caracteres especiais são interpretados, então "

"\\n produz nova linha\n"

"Primeira linha.\n"

"Segunda linha."

#: ../../tutorial/introduction.rst:182

msgid ""

"If you don't want characters prefaced by ``\\`` to be interpreted as special "

"characters, you can use *raw strings* by adding an ``r`` before the first "

"quote::"

msgstr ""

"Caso não queira que os caracteres precedidos por ``\\`` sejam interpretados "

"como caracteres especiais, você pode usar *strings brutas* (*raw*, em "

"inglês) adicionando um ``r`` antes da primeira aspa::"

#: ../../tutorial/introduction.rst:186

msgid ""

">>> print('C:\\some\\name') # here \\n means newline!\n"

"C:\\some\n"

"ame\n"

">>> print(r'C:\\some\\name') # note the r before the quote\n"

"C:\\some\\name"

msgstr ""

">>> print('C:\\algum\\nome') # aqui \\n significa nova linha!\n"

"C:\\algum\n"

"ome\n"

">>> print(r'C:\\algum\\nome') # observe o r antes das aspas\n"

"C:\\algum\\nome"

#: ../../tutorial/introduction.rst:192

msgid ""

"There is one subtle aspect to raw strings: a raw string may not end in an "

"odd number of ``\\`` characters; see :ref:`the FAQ entry <faq-programming-"

"raw-string-backslash>` for more information and workarounds."

msgstr ""

"Há um aspecto sutil nas strings brutas: uma string bruta não pode terminar "

"em um número ímpar de caracteres ``\\``; consulte :ref:`o FAQ relacionado "

"<faq-programming-raw-string-backslash>` para mais informações e soluções "

"alternativas."

#: ../../tutorial/introduction.rst:197

msgid ""

"String literals can span multiple lines. One way is using triple-quotes: "

"``\"\"\"...\"\"\"`` or ``'''...'''``. End-of-line characters are "

"automatically included in the string, but it's possible to prevent this by "

"adding a ``\\`` at the end of the line. In the following example, the "

"initial newline is not included::"

msgstr ""

"As strings literais podem abranger várias linhas. Uma maneira é usar as "

"aspas triplas: ``\"\"\"...\"\"\"`` ou ``'''...'''``. Caracteres de fim de "

"linha são incluídos automaticamente na string, mas é possível evitar isso "

"adicionando uma ``\\`` no final. No exemplo a seguir, a nova linha no início "

"não é incluída::"

#: ../../tutorial/introduction.rst:203

msgid ""

">>> print(\"\"\"\\\n"

"... Usage: thingy [OPTIONS]\n"

"... -h Display this usage message\n"

"... -H hostname Hostname to connect to\n"

"... \"\"\")\n"

"Usage: thingy [OPTIONS]\n"

" -h Display this usage message\n"

" -H hostname Hostname to connect to\n"

"\n"

">>>"

msgstr ""

">>> print(\"\"\"\\\n"

"... Uso: coisinha [OPÇÕES]\n"

"... -h Exibe esta mensagem de uso\n"

"... -H hostname Hostname para se conectar\n"

"... \"\"\")\n"

"Usage: coisinha [OPÇÕES]\n"

" -h Exibe esta mensagem de ajuda\n"

" -H hostname Hostname para se conectar\n"

"\n"

">>>"

#: ../../tutorial/introduction.rst:214

msgid ""

"Strings can be concatenated (glued together) with the ``+`` operator, and "

"repeated with ``*``::"

msgstr ""

"Strings podem ser concatenadas (coladas) com o operador ``+``, e repetidas "

"com ``*``::"

#: ../../tutorial/introduction.rst:217

msgid ""

">>> # 3 times 'un', followed by 'ium'\n"

">>> 3 * 'un' + 'ium'\n"

"'unununium'"

msgstr ""

">>> # 3 vezes 'un', seguido por 'ium'\n"

">>> 3 * 'un' + 'ium'\n"

"'unununium'"

#: ../../tutorial/introduction.rst:221

msgid ""

"Two or more *string literals* (i.e. the ones enclosed between quotes) next "

"to each other are automatically concatenated. ::"

msgstr ""

"Duas ou mais *strings literais* (ou seja, entre aspas) ao lado da outra são "

"automaticamente concatenados. ::"

#: ../../tutorial/introduction.rst:224

msgid ""

">>> 'Py' 'thon'\n"

"'Python'"

msgstr ""

">>> 'Py' 'thon'\n"

"'Python'"

#: ../../tutorial/introduction.rst:227

msgid ""

"This feature is particularly useful when you want to break long strings::"

msgstr ""

"Esse recurso é particularmente útil quando você quer quebrar strings longas::"

#: ../../tutorial/introduction.rst:229

msgid ""

">>> text = ('Put several strings within parentheses '\n"

"... 'to have them joined together.')\n"

">>> text\n"

"'Put several strings within parentheses to have them joined together.'"

msgstr ""

">>> texto = ('Coloque várias strings dentro de parênteses '\n"

"... 'para fazer com que elas sejam concatenadas.')\n"

">>> texto\n"

"'Coloque várias strings dentro de parênteses para fazer com que elas sejam "

"concatenadas.'"

#: ../../tutorial/introduction.rst:234

msgid ""

"This only works with two literals though, not with variables or expressions::"

msgstr ""

"Isso só funciona com duas strings literais, não com variáveis ou expressões::"

#: ../../tutorial/introduction.rst:236

msgid ""

">>> prefix = 'Py'\n"

">>> prefix 'thon' # can't concatenate a variable and a string literal\n"

" File \"<stdin>\", line 1\n"

" prefix 'thon'\n"

" ^^^^^^\n"

"SyntaxError: invalid syntax\n"

">>> ('un' * 3) 'ium'\n"

" File \"<stdin>\", line 1\n"

" ('un' * 3) 'ium'\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

msgstr ""

">>> prefixo = 'Py'\n"

">>> prefixo 'thon' # não é possível concatenar uma variável e um literal de "

"string\n"

" File \"<stdin>\", line 1\n"

" prefixi 'thon'\n"

" ^^^^^^\n"

"SyntaxError: invalid syntax\n"

">>> ('un' * 3) 'ium'\n"

" File \"<stdin>\", line 1\n"

" ('un' * 3) 'ium'\n"

" ^^^^^\n"

"SyntaxError: invalid syntax"

#: ../../tutorial/introduction.rst:248

msgid ""

"If you want to concatenate variables or a variable and a literal, use ``+``::"

msgstr ""

"Se você quiser concatenar variáveis ou uma variável e uma literal, use "

"``+``::"

#: ../../tutorial/introduction.rst:250

msgid ""

">>> prefix + 'thon'\n"

"'Python'"

msgstr ""

">>> prefixo + 'thon'\n"

"'Python'"

#: ../../tutorial/introduction.rst:253

msgid ""

"Strings can be *indexed* (subscripted), with the first character having "

"index 0. There is no separate character type; a character is simply a string "

"of size one::"

msgstr ""

"As strings podem ser *indexadas* (subscritas), com o primeiro caractere como "

"índice 0. Não existe um tipo específico para caracteres; um caractere é "

"simplesmente uma string cujo tamanho é 1::"

#: ../../tutorial/introduction.rst:257

msgid ""

">>> word = 'Python'\n"

">>> word[0] # character in position 0\n"

"'P'\n"

">>> word[5] # character in position 5\n"

"'n'"

msgstr ""

">>> palavra = 'Python'\n"

">>> palavra[0] # caractere na posição 0\n"

"'P'\n"

">>> palavra[5] # caractere na posição 5\n"

"'n'"

#: ../../tutorial/introduction.rst:263

msgid ""

"Indices may also be negative numbers, to start counting from the right::"

msgstr ""

"Índices também podem ser números negativos para iniciar a contagem pela "

"direita::"

#: ../../tutorial/introduction.rst:265

msgid ""

">>> word[-1] # last character\n"

"'n'\n"

">>> word[-2] # second-last character\n"

"'o'\n"

">>> word[-6]\n"

"'P'"

msgstr ""

">>> palavra[-1] # último caractere\n"

"'n'\n"

">>> palavra[-2] # penúltimo caractere\n"

"'o'\n"

">>> palavra[-6]\n"

"'P'"

#: ../../tutorial/introduction.rst:272

msgid "Note that since -0 is the same as 0, negative indices start from -1."

msgstr "Note que dado que -0 é o mesmo que 0, índices negativos começam em -1."

#: ../../tutorial/introduction.rst:274

msgid ""

"In addition to indexing, *slicing* is also supported. While indexing is "

"used to obtain individual characters, *slicing* allows you to obtain a "

"substring::"

msgstr ""

"Além da indexação, o *fatiamento* também é permitido. Embora a indexação "

"seja usada para obter caracteres individuais, *fatiar* permite que você "

"obtenha uma substring::"

#: ../../tutorial/introduction.rst:277

msgid ""

">>> word[0:2] # characters from position 0 (included) to 2 (excluded)\n"

"'Py'\n"

">>> word[2:5] # characters from position 2 (included) to 5 (excluded)\n"

"'tho'"

msgstr ""

">>> palavra[0:2] # caracteres da posição 0 (incluída) até 2 (excluída)\n"

"'Py'\n"

">>> palavra[2:5] # caracteres da posição 2 (incluída) até 5 (excluída)\n"

"'tho'"

#: ../../tutorial/introduction.rst:282

msgid ""

"Slice indices have useful defaults; an omitted first index defaults to zero, "

"an omitted second index defaults to the size of the string being sliced. ::"

msgstr ""

"Os índices do fatiamento possuem padrões úteis; um primeiro índice omitido "

"padrão é zero, um segundo índice omitido é por padrão o tamanho da string "

"sendo fatiada::"

#: ../../tutorial/introduction.rst:285

msgid ""

">>> word[:2] # character from the beginning to position 2 (excluded)\n"

"'Py'\n"

">>> word[4:] # characters from position 4 (included) to the end\n"

"'on'\n"

">>> word[-2:] # characters from the second-last (included) to the end\n"

"'on'"

msgstr ""

">>> palavra[:2] # caracteres do início até a posição 2 (excluída)\n"

"'Py'\n"

">>> palavra[4:] # caracteres da posição 4 (incluída) até o fim\n"

"'on'\n"

">>> palavra[-2:] # caracteres da penúltima (incluída) até o fim\n"

"'on'"

#: ../../tutorial/introduction.rst:292

msgid ""

"Note how the start is always included, and the end always excluded. This "

"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"

msgstr ""

"Observe como o início sempre está incluído, e o fim sempre é excluído. Isso "

"garante que ``s[:i] + s[i:]`` seja sempre igual a ``s``::"

#: ../../tutorial/introduction.rst:295

msgid ""

">>> word[:2] + word[2:]\n"

"'Python'\n"

">>> word[:4] + word[4:]\n"

"'Python'"

msgstr ""

">>> palavra[:2] + palavra[2:]\n"

"'Python'\n"

">>> palavra[:4] + palavra[4:]\n"

"'Python'"

#: ../../tutorial/introduction.rst:300

msgid ""

"One way to remember how slices work is to think of the indices as pointing "

"*between* characters, with the left edge of the first character numbered 0. "

"Then the right edge of the last character of a string of *n* characters has "

"index *n*, for example::"

msgstr ""

"Uma maneira de lembrar como fatias funcionam é pensar que os índices indicam "

"posições *entre* caracteres, onde a borda esquerda do primeiro caractere é "

"0. Assim, a borda direita do último caractere de uma string de comprimento "

"*n* tem índice *n*, por exemplo::"

#: ../../tutorial/introduction.rst:305

msgid ""

" +---+---+---+---+---+---+\n"

" | P | y | t | h | o | n |\n"

" +---+---+---+---+---+---+\n"

" 0 1 2 3 4 5 6\n"

"-6 -5 -4 -3 -2 -1"

msgstr ""

" +---+---+---+---+---+---+\n"

" | P | y | t | h | o | n |\n"

" +---+---+---+---+---+---+\n"

" 0 1 2 3 4 5 6\n"

"-6 -5 -4 -3 -2 -1"

#: ../../tutorial/introduction.rst:311

msgid ""

"The first row of numbers gives the position of the indices 0...6 in the "

"string; the second row gives the corresponding negative indices. The slice "

"from *i* to *j* consists of all characters between the edges labeled *i* and "

"*j*, respectively."

msgstr ""

"A primeira fileira de números indica a posição dos índices 0...6 na string; "

"a segunda fileira indica a posição dos respectivos índices negativos. Uma "

"fatia de *i* a *j* consiste em todos os caracteres entre as bordas *i* e "

"*j*, respectivamente."

#: ../../tutorial/introduction.rst:316

msgid ""

"For non-negative indices, the length of a slice is the difference of the "

"indices, if both are within bounds. For example, the length of "

"``word[1:3]`` is 2."

msgstr ""

"Para índices positivos, o comprimento da fatia é a diferença entre os "

"índices, se ambos estão dentro dos limites da string. Por exemplo, o "

"comprimento de ``word[1:3]`` é 2."

#: ../../tutorial/introduction.rst:320

msgid "Attempting to use an index that is too large will result in an error::"

msgstr ""

"A tentativa de usar um índice que seja muito grande resultará em um erro::"

#: ../../tutorial/introduction.rst:322

msgid ""

">>> word[42] # the word only has 6 characters\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"IndexError: string index out of range"

msgstr ""

">>> palavra[42] # a palavra só tem 6 caracteres\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"IndexError: string index out of range"

#: ../../tutorial/introduction.rst:327

msgid ""

"However, out of range slice indexes are handled gracefully when used for "

"slicing::"

msgstr ""

"No entanto, os índices de fatiamento fora do alcance são tratados "

"graciosamente (N.d.T: o termo original “gracefully” indica robustez no "

"tratamento de erros) quando usados para fatiamento. Um índice maior que o "

"comprimento é trocado pelo comprimento, um limite superior menor que o "

"limite inferior produz uma string vazia::"

#: ../../tutorial/introduction.rst:330

msgid ""

">>> word[4:42]\n"

"'on'\n"

">>> word[42:]\n"

"''"

msgstr ""

">>> palavra[4:42]\n"

"'on'\n"

">>> palavra[42:]\n"

"''"

#: ../../tutorial/introduction.rst:335

msgid ""

"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "

"assigning to an indexed position in the string results in an error::"

msgstr ""

"As strings do Python não podem ser alteradas --- uma string é :term:"

"`imutável`. Portanto, atribuir a uma posição indexada na sequência resulta "

"em um erro::"

#: ../../tutorial/introduction.rst:338

msgid ""

">>> word[0] = 'J'\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: 'str' object does not support item assignment\n"

">>> word[2:] = 'py'\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: 'str' object does not support item assignment"

msgstr ""

">>> palavra[0] = 'J'\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: 'str' object does not support item assignment\n"

">>> palavra[2:] = 'py'\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"TypeError: 'str' object does not support item assignment"

#: ../../tutorial/introduction.rst:347

msgid "If you need a different string, you should create a new one::"

msgstr "Se você precisar de uma string diferente, deverá criar uma nova::"

#: ../../tutorial/introduction.rst:349

msgid ""

">>> 'J' + word[1:]\n"

"'Jython'\n"

">>> word[:2] + 'py'\n"

"'Pypy'"

msgstr ""

">>> 'J' + palavra[1:]\n"

"'Jython'\n"

">>> palavra[:2] + 'py'\n"

"'Pypy'"

#: ../../tutorial/introduction.rst:354

msgid "The built-in function :func:`len` returns the length of a string::"

msgstr "A função embutida :func:`len` devolve o comprimento de uma string::"

#: ../../tutorial/introduction.rst:356

msgid ""

">>> s = 'supercalifragilisticexpialidocious'\n"

">>> len(s)\n"

"34"

msgstr ""

">>> s = 'supercalifragilisticexpialidoce'\n"

">>> len(s)\n"

"31"

#: ../../tutorial/introduction.rst:363

msgid ":ref:`textseq`"

msgstr ":ref:`textseq`"

#: ../../tutorial/introduction.rst:364

msgid ""

"Strings are examples of *sequence types*, and support the common operations "

"supported by such types."

msgstr ""

"As strings são exemplos de *tipos de sequências* e suportam as operações "

"comumente suportadas por esses tipos."

#: ../../tutorial/introduction.rst:367

msgid ":ref:`string-methods`"

msgstr ":ref:`string-methods`"

#: ../../tutorial/introduction.rst:368

msgid ""

"Strings support a large number of methods for basic transformations and "

"searching."

msgstr ""

"As strings suportam uma grande quantidade de métodos para transformações "

"básicas e busca."

#: ../../tutorial/introduction.rst:371

msgid ":ref:`f-strings`"

msgstr ":ref:`f-strings`"

#: ../../tutorial/introduction.rst:372

msgid "String literals that have embedded expressions."

msgstr "Strings literais que possuem expressões embutidas."

#: ../../tutorial/introduction.rst:374

msgid ":ref:`formatstrings`"

msgstr ":ref:`formatstrings`"

#: ../../tutorial/introduction.rst:375

msgid "Information about string formatting with :meth:`str.format`."

msgstr ""

"Informações sobre formatação de string com o método :meth:`str.format`."

#: ../../tutorial/introduction.rst:377

msgid ":ref:`old-string-formatting`"

msgstr ":ref:`old-string-formatting`"

#: ../../tutorial/introduction.rst:378

msgid ""

"The old formatting operations invoked when strings are the left operand of "

"the ``%`` operator are described in more detail here."

msgstr ""

"As antigas operações de formatação invocadas quando as strings são o "

"operando esquerdo do operador ``%`` são descritas com mais detalhes aqui."

#: ../../tutorial/introduction.rst:385

msgid "Lists"

msgstr "Listas"

#: ../../tutorial/introduction.rst:387

msgid ""

"Python knows a number of *compound* data types, used to group together other "

"values. The most versatile is the *list*, which can be written as a list of "

"comma-separated values (items) between square brackets. Lists might contain "

"items of different types, but usually the items all have the same type. ::"

msgstr ""

"Python inclui diversas estruturas de dados *compostas*, usadas para agrupar "

"outros valores. A mais versátil é *list* (lista), que pode ser escrita como "

"uma lista de valores (itens) separados por vírgula, entre colchetes. Os "

"valores contidos na lista não precisam ser todos do mesmo tipo. ::"

#: ../../tutorial/introduction.rst:392

msgid ""

">>> squares = [1, 4, 9, 16, 25]\n"

">>> squares\n"

"[1, 4, 9, 16, 25]"

msgstr ""

">>> quadrados = [1, 4, 9, 16, 25]\n"

">>> quadrados\n"

"[1, 4, 9, 16, 25]"

#: ../../tutorial/introduction.rst:396

msgid ""

"Like strings (and all other built-in :term:`sequence` types), lists can be "

"indexed and sliced::"

msgstr ""

"Como strings (e todos os tipos embutidos de :term:`sequência`), listas pode "

"ser indexados e fatiados::"

#: ../../tutorial/introduction.rst:399

msgid ""

">>> squares[0] # indexing returns the item\n"

"1\n"

">>> squares[-1]\n"

"25\n"

">>> squares[-3:] # slicing returns a new list\n"

"[9, 16, 25]"

msgstr ""

">>> quadrados[0] # indexação retorna o item\n"

"1\n"

">>> quadrados[-1]\n"

"25\n"

">>> quadrados[-3:] # fatiamento retorna uma nova lista\n"

"[9, 16, 25]"

#: ../../tutorial/introduction.rst:406

msgid "Lists also support operations like concatenation::"

msgstr "As listas também suportam operações como concatenação::"

#: ../../tutorial/introduction.rst:408

msgid ""

">>> squares + [36, 49, 64, 81, 100]\n"

"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"

msgstr ""

">>> quadrados + [36, 49, 64, 81, 100]\n"

"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"

#: ../../tutorial/introduction.rst:411

msgid ""

"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "

"type, i.e. it is possible to change their content::"

msgstr ""

"Diferentemente de strings, que são :term:`imutáveis<immutable>`, listas são :"

"term:`mutáveis<mutable>`, ou seja, é possível alterar elementos individuais "

"de uma lista::"

#: ../../tutorial/introduction.rst:414

msgid ""

">>> cubes = [1, 8, 27, 65, 125] # something's wrong here\n"

">>> 4 ** 3 # the cube of 4 is 64, not 65!\n"

"64\n"

">>> cubes[3] = 64 # replace the wrong value\n"

">>> cubes\n"

"[1, 8, 27, 64, 125]"

msgstr ""

">>> cubos = [1, 8, 27, 65, 125] # algo errado aqui\n"

">>> 4 ** 3 # o cubo de 4 é 64, não 65!\n"

"64\n"

">>> cubos[3] = 64 # substitui o valor errado\n"

">>> cubos\n"

"[1, 8, 27, 64, 125]"

#: ../../tutorial/introduction.rst:421

msgid ""

"You can also add new items at the end of the list, by using the :meth:`!list."

"append` *method* (we will see more about methods later)::"

msgstr ""

"Você também pode adicionar novos itens no final da lista, usando o *método* :"

"meth:`!list.append` (estudaremos mais a respeito dos métodos "

"posteriormente)::"

#: ../../tutorial/introduction.rst:424

msgid ""

">>> cubes.append(216) # add the cube of 6\n"

">>> cubes.append(7 ** 3) # and the cube of 7\n"

">>> cubes\n"

"[1, 8, 27, 64, 125, 216, 343]"

msgstr ""

">>> cubos.append(216) # adiciona o cubo de 6\n"

">>> cubos.append(7 ** 3) # e o cubo de 7\n"

">>> cubos\n"

"[1, 8, 27, 64, 125, 216, 343]"

#: ../../tutorial/introduction.rst:429

msgid ""

"Simple assignment in Python never copies data. When you assign a list to a "

"variable, the variable refers to the *existing list*. Any changes you make "

"to the list through one variable will be seen through all other variables "