# 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 "
"that refer to it.::"
msgstr ""
"A atribuição simples em Python nunca copia dados. Quando você atribui uma "
"lista a uma variável, a variável se refere à *lista existente*. Quaisquer "
"alterações que você fizer na lista por meio de uma variável serão vistas por "
"todas as outras variáveis que se referem a ela::"

#: ../../tutorial/introduction.rst:434
msgid ""
">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n"
">>> rgba = rgb\n"
">>> id(rgb) == id(rgba)  # they reference the same object\n"
"True\n"
">>> rgba.append(\"Alph\")\n"
">>> rgb\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
msgstr ""
">>> rgb = [\"Vermelho\", \"Verde\", \"Azul\"]\n"
">>> rgba = rgb\n"
">>> id(rgb) == id(rgba)  # elas referenciam o mesmo objeto\n"
"True\n"
">>> rgba.append(\"Alf\")\n"
">>> rgb\n"
"[\"Vermelho\", \"Verde\", \"Azul\", \"Alf\"]"

#: ../../tutorial/introduction.rst:442
msgid ""
"All slice operations return a new list containing the requested elements.  "
"This means that the following slice returns a :ref:`shallow copy "
"<shallow_vs_deep_copy>` of the list::"
msgstr ""
"Todas as operações de fatiamento devolvem uma nova lista contendo os "
"elementos solicitados. Isso significa que o seguinte fatiamento devolve uma :"
"ref:`cópia rasa <shallow_vs_deep_copy>` da lista::"

#: ../../tutorial/introduction.rst:446
msgid ""
">>> correct_rgba = rgba[:]\n"
">>> correct_rgba[-1] = \"Alpha\"\n"
">>> correct_rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alpha\"]\n"
">>> rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
msgstr ""
">>> rgba_correto = rgba[:]\n"
">>> rgba_correto[-1] = \"Alfa\"\n"
">>> rgba_correto\n"
"[\"Vermelho\", \"Verde\", \"Azul\", \"Alfa\"]\n"
">>> rgba\n"
"[\"Vermelho\", \"Verde\", \"Azul\", \"Alf\"]"

#: ../../tutorial/introduction.rst:453
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
"Atribuição a fatias também é possível, e isso pode até alterar o tamanho da "
"lista ou remover todos os itens dela::"

#: ../../tutorial/introduction.rst:456
msgid ""
">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> letters\n"
"['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> # replace some values\n"
">>> letters[2:5] = ['C', 'D', 'E']\n"
">>> letters\n"
"['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
">>> # now remove them\n"
">>> letters[2:5] = []\n"
">>> letters\n"
"['a', 'b', 'f', 'g']\n"
">>> # clear the list by replacing all the elements with an empty list\n"
">>> letters[:] = []\n"
">>> letters\n"
"[]"
msgstr ""
">>> letras = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> letras\n"
"['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> # substitui alguns valores\n"
">>> letras[2:5] = ['C', 'D', 'E']\n"
">>> letras\n"
"['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
">>> # agora remove-os\n"
">>> letras[2:5] = []\n"
">>> letras\n"
"['a', 'b', 'f', 'g']\n"
">>> # limpa a lista substituindo todos os elementos por uma lista vazia\n"
">>> letras[:] = []\n"
">>> letras\n"
"[]"

#: ../../tutorial/introduction.rst:472
msgid "The built-in function :func:`len` also applies to lists::"
msgstr "A função embutida :func:`len` também se aplica a listas::"

#: ../../tutorial/introduction.rst:474
msgid ""
">>> letters = ['a', 'b', 'c', 'd']\n"
">>> len(letters)\n"
"4"
msgstr ""
">>> letras = ['a', 'b', 'c', 'd']\n"
">>> len(letras)\n"
"4"

#: ../../tutorial/introduction.rst:478
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr ""
"É possível aninhar listas (criar listas contendo outras listas), por "
"exemplo::"

#: ../../tutorial/introduction.rst:481
msgid ""
">>> a = ['a', 'b', 'c']\n"
">>> n = [1, 2, 3]\n"
">>> x = [a, n]\n"
">>> x\n"
"[['a', 'b', 'c'], [1, 2, 3]]\n"
">>> x[0]\n"
"['a', 'b', 'c']\n"
">>> x[0][1]\n"
"'b'"
msgstr ""
">>> a = ['a', 'b', 'c']\n"
">>> n = [1, 2, 3]\n"
">>> x = [a, n]\n"
">>> x\n"
"[['a', 'b', 'c'], [1, 2, 3]]\n"
">>> x[0]\n"
"['a', 'b', 'c']\n"
">>> x[0][1]\n"
"'b'"

#: ../../tutorial/introduction.rst:494
msgid "First Steps Towards Programming"
msgstr "Primeiros passos para a programação"

#: ../../tutorial/introduction.rst:496
msgid ""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together.  For instance, we can write an initial sub-sequence of the "
"`Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_sequence>`_ as "
"follows::"
msgstr ""
"Claro, podemos usar o Python para tarefas mais complicadas do que somar 2+2. "
"Por exemplo, podemos escrever o início da `sequência de Fibonacci <https://"
"pt.wikipedia.org/wiki/Sequência_de_Fibonacci>`_ assim::"

#: ../../tutorial/introduction.rst:501
msgid ""
">>> # Fibonacci series:\n"
">>> # the sum of two elements defines the next\n"
">>> a, b = 0, 1\n"
">>> while a < 10:\n"
"...     print(a)\n"
"...     a, b = b, a+b\n"
"...\n"
"0\n"
"1\n"
"1\n"
"2\n"
"3\n"
"5\n"
"8"
msgstr ""
">>> # Sequência de Fibonacci:\n"
">>> # a soma de dois elementos define a próxima\n"
">>> a, b = 0, 1\n"
">>> while a < 10:\n"
"...     print(a)\n"
"...     a, b = b, a+b\n"
"...\n"
"0\n"
"1\n"
"1\n"
"2\n"
"3\n"
"5\n"
"8"

#: ../../tutorial/introduction.rst:516
msgid "This example introduces several new features."
msgstr "Este exemplo introduz diversas características ainda não mencionadas."

#: ../../tutorial/introduction.rst:518
msgid ""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1.  On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place.  The right-"
"hand side expressions are evaluated  from the left to the right."
msgstr ""
"A primeira linha contém uma atribuição múltipla: as variáveis ``a`` e ``b`` "
"recebem simultaneamente os novos valores 0 e 1. Na última linha há outro "
"exemplo de atribuição múltipla demonstrando que expressões do lado direito "
"são sempre avaliadas primeiro, antes da atribuição. As expressões do lado "
"direito são avaliadas da esquerda para a direita."

#: ../../tutorial/introduction.rst:524
msgid ""
"The :keyword:`while` loop executes as long as the condition (here: ``a < "
"10``) remains true.  In Python, like in C, any non-zero integer value is "
"true; zero is false.  The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false.  The test used in the example is a simple comparison.  The "
"standard comparison operators are written the same as in C: ``<`` (less "
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
"O laço de repetição :keyword:`while` executa enquanto a condição (aqui: ``a "
"< 10``) permanece verdadeira. Em Python, como em C, qualquer valor inteiro "
"que não seja zero é considerado verdadeiro; zero é considerado falso. A "
"condição pode também ser uma cadeia de caracteres ou uma lista, ou qualquer "
"sequência; qualquer coisa com um tamanho maior que zero é verdadeiro, "
"enquanto sequências vazias são falsas. O teste usado no exemplo é uma "
"comparação simples. Os operadores padrões de comparação são os mesmos de C: "
"``<`` (menor que), ``>`` (maior que), ``==`` (igual), ``<=`` (menor ou "
"igual), ``>=`` (maior ou igual) e ``!=`` (diferente)."

#: ../../tutorial/introduction.rst:533
msgid ""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements.  At the interactive prompt, you have to type a tab or "
"space(s) for each indented line.  In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility.  When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line).  Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
"O *corpo* do laço é *indentado*: indentação em Python é a maneira de agrupar "
"comandos em blocos. No console interativo padrão você terá que digitar tab "
"ou espaços para indentar cada linha. Na prática você vai preparar scripts "
"Python mais complicados em um editor de texto; a maioria dos editores de "
"texto tem facilidades de indentação automática. Quando um comando composto é "
"digitado interativamente, deve ser finalizado por uma linha em branco (já "
"que o interpretador não tem como adivinhar qual é a última linha do "
"comando). Observe que toda linha de um mesmo bloco de comandos deve ter a "
"mesma indentação."

#: ../../tutorial/introduction.rst:542
msgid ""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating-point quantities, and strings.  Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
"A função :func:`print` escreve o valor dos argumentos fornecidos. É "
"diferente de apenas escrever a expressão no interpretador (como fizemos "
"anteriormente nos exemplos da calculadora) pela forma como lida com "
"múltiplos argumentos, quantidades de ponto flutuante e strings. As strings "
"são impressas sem aspas, e um espaço é inserido entre os itens, assim você "
"pode formatar bem o resultado, dessa forma::"

#: ../../tutorial/introduction.rst:549
msgid ""
">>> i = 256*256\n"
">>> print('The value of i is', i)\n"
"The value of i is 65536"
msgstr ""
">>> i = 256*256\n"
">>> print('O valor de i é', i)\n"
"O valor de i é 65536"

#: ../../tutorial/introduction.rst:553
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr ""
"O argumento nomeado *end* pode ser usado para evitar uma nova linha após a "
"saída ou finalizar a saída com uma string diferente::"

#: ../../tutorial/introduction.rst:556
msgid ""
">>> a, b = 0, 1\n"
">>> while a < 1000:\n"
"...     print(a, end=',')\n"
"...     a, b = b, a+b\n"
"...\n"
"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"
msgstr ""
">>> a, b = 0, 1\n"
">>> while a < 1000:\n"
"...     print(a, end=',')\n"
"...     a, b = b, a+b\n"
"...\n"
"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"

#: ../../tutorial/introduction.rst:565
msgid "Footnotes"
msgstr "Notas de rodapé"

#: ../../tutorial/introduction.rst:566
msgid ""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted "
"as ``-(3**2)`` and thus result in ``-9``.  To avoid this and get ``9``, you "
"can use ``(-3)**2``."
msgstr ""
"Uma vez que ``**`` tem precedência mais alta que ``-``, ``-3**2`` será "
"interpretado como ``-(3**2)`` e assim resultará em ``-9``. Para evitar isso "
"e obter ``9``, você pode usar ``(-3)**2``."

#: ../../tutorial/introduction.rst:570
msgid ""
"Unlike other languages, special characters such as ``\\n`` have the same "
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
"Ao contrário de outras linguagens, caracteres especiais como ``\\n`` têm o "
"mesmo significado com as aspas simples (``'...'``) e duplas (``\"...\"``) . "
"A única diferença entre as duas é que, dentro de aspas simples, você não "
"precisa escapar o ``\"`` (mas você deve escapar a ``\\'``) e vice-versa."

#: ../../tutorial/introduction.rst:21
msgid "# (hash)"
msgstr "# (cerquilha)"

#: ../../tutorial/introduction.rst:21
msgid "comment"
msgstr "comentário"