# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
# Translators:
# Claudio Rogerio Carvalho Filho , 2021
# Leticia Portella , 2021
# Adson Rodrigues , 2021
# Adorilson Bezerra , 2021
# Rafael Fontenelle , 2021
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-08-18 13:46+0000\n"
"PO-Revision-Date: 2021-06-28 01:50+0000\n"
"Last-Translator: Rafael Fontenelle , 2021\n"
"Language-Team: Portuguese (Brazil) (https://www.transifex.com/python-doc/"
"teams/5390/pt_BR/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pt_BR\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
#: ../../tutorial/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr "Uma introduo 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 sada pela presena ou "
"ausncia dos prompts (:term:`>>>` e :term:`...`): para repetir o exemplo, "
"voc deve digitar tudo aps o prompt, quando o mesmo aparece; linhas que no "
"comearem com um prompt so na verdade as sadas geradas pelo interpretador. "
"Observe que quando aparece uma linha contendo apenas o prompt secundrio "
"voc deve digitar uma linha em branco; assim que se encerra um comando de "
"mltiplas linhas."
#: ../../tutorial/introduction.rst:16
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 comentrios. Comentrios em Python comeam com o "
"caractere cerquilha '#' e estende at o final da linha. Um comentrio pode "
"aparecer no inicio da linha ou aps espao em branco ou cdigo, mas no "
"dentro de uma string literal. O caracterer cerquilha dentro de uma string "
"literal apenas uma cerquilha. Como os comentrios so para esclarecer o "
"cdigo e no so interpretados pelo Python, eles podem ser omitidos ao "
"digitar exemplos."
#: ../../tutorial/introduction.rst:24
msgid "Some examples::"
msgstr "Alguns exemplos:"
#: ../../tutorial/introduction.rst:35
msgid "Using Python as a Calculator"
msgstr "Usando Python como uma calculadora"
#: ../../tutorial/introduction.rst:37
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 primrio, ``>>>``. (No deve demorar muito.)"
#: ../../tutorial/introduction.rst:44
msgid "Numbers"
msgstr "Nmeros"
#: ../../tutorial/introduction.rst:46
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 ``/`` work just like in most other "
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
"grouping. For example::"
msgstr ""
"O interpretador funciona como uma calculadora bem simples: voc pode digitar "
"uma expresso e o resultado ser apresentado. A sintaxe de expresses a "
"usual: operadores ``+``, ``-``, ``*`` e ``/`` funcionam da mesma forma que "
"em outras linguagens tradicionais (por exemplo, Pascal ou C); parnteses "
"(``()``) podem ser usados para agrupar expresses. Por exemplo::"
#: ../../tutorial/introduction.rst:61
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 nmeros inteiros (ex. ``2``, ``4``, ``20``) so do tipo :class:`int`, "
"aqueles com parte fracionria (ex. ``5.0``, ``1.6``) so do tipo :class:"
"`float`. Veremos mais sobre tipos numricos posteriormente neste tutorial."
#: ../../tutorial/introduction.rst:65
msgid ""
"Division (``/``) always returns a float. To do :term:`floor division` and "
"get an integer result (discarding any fractional result) you can use the ``//"
"`` operator; to calculate the remainder you can use ``%``::"
msgstr ""
"Diviso (``/``) sempre retorna ponto flutuante (float). Para fazer uma :term:"
"`diviso pelo piso` e receber um inteiro como resultado (descartando a parte "
"fracionria) voc pode usar o operador ``//``; para calcular o resto voc "
"pode usar o ``%``::"
#: ../../tutorial/introduction.rst:79
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr ""
"Com Python, possvel usar o operador ``**`` para calcular potncias [#]_::"
#: ../../tutorial/introduction.rst:86
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 varivel. "
"Depois de uma atribuio, nenhum resultado exibido antes do prximo "
"prompt::"
#: ../../tutorial/introduction.rst:94
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
"Se uma varivel no \"definida\" (no tem um valor atribudo), tentar "
"utiliz-la gerar um erro::"
#: ../../tutorial/introduction.rst:102
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:108
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 expresso exibida atribuda a "
"varivel ``_``. Assim, ao utilizar Python como uma calculadora, fica mais "
"fcil prosseguir com os clculos, por exemplo::"
#: ../../tutorial/introduction.rst:121
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 varivel especial deve ser tratada como *somente para leitura* pelo "
"usurio. Nunca lhe atribua explicitamente um valor --- do contrrio, estaria "
"criando uma outra varivel (homnima) independente, que mascararia a "
"varivel especial com seu comportamento mgico."
#: ../../tutorial/introduction.rst:125
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 "
"`, and uses the ``j`` or ``J`` suffix to indicate the "
"imaginary part (e.g. ``3+5j``)."
msgstr ""
"Alm de :class:`int` e :class:`float`, o Python suporta outros tipos de "
"nmeros, tais como :class:`~decimal.Decimal` e :class:`~fractions.Fraction`. "
"O Python tambm possui suporte nativo a :ref:`nmeros complexos "
"`, e usa os sufixos ``j`` ou ``J`` para indicar a parte "
"imaginria (por exemplo, ``3+5j``)."
#: ../../tutorial/introduction.rst:135
msgid "Strings"
msgstr "Strings"
#: ../../tutorial/introduction.rst:137
msgid ""
"Besides numbers, Python can also manipulate strings, which can be expressed "
"in several ways. They can be enclosed in single quotes (``'...'``) or "
"double quotes (``\"...\"``) with the same result [#]_. ``\\`` can be used "
"to escape quotes::"
msgstr ""
"Alm de nmeros, Python tambm pode manipular strings (sequncias de "
"caracteres), que podem ser expressas de diversas formas. Elas podem ser "
"delimitadas por aspas simples (``'...'``) ou duplas (``\"...\"``) e teremos "
"o mesmo resultado [#]_. ``\\`` pode ser usada para escapar aspas::"
#: ../../tutorial/introduction.rst:155
msgid ""
"In the interactive interpreter, the output string is enclosed in quotes and "
"special characters are escaped with backslashes. While this might sometimes "
"look different from the input (the enclosing quotes could change), the two "
"strings are equivalent. The string is enclosed in double quotes if the "
"string contains a single quote and no double quotes, otherwise it is "
"enclosed in single quotes. The :func:`print` function produces a more "
"readable output, by omitting the enclosing quotes and by printing escaped "
"and special characters::"
msgstr ""
"Na interpretao interativa, a string de sada delimitada com aspas e "
"caracteres especiais so escapados com barras invertidas. Embora isso possa "
"s vezes parecer diferente da entrada (as aspas podem mudar), as duas "
"strings so equivalentes. A string delimitada com aspas duplas se a string "
"contiver uma nica aspa simples e nenhuma aspa dupla, caso contrrio, ela "
"delimitada com aspas simples. A funo :func:`print` produz uma sada mais "
"legvel, ao omitir as aspas e ao imprimir caracteres escapados e especiais::"
#: ../../tutorial/introduction.rst:175
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 ""
"Se no quiseres que os caracteres sejam precedidos por ``\\`` para serem "
"interpretados como caracteres especiais, poders usar *strings raw* (N.d.T: "
"crua ou sem processamento de caracteres de escape) adicionando um ``r`` "
"antes da primeira aspa::"
#: ../../tutorial/introduction.rst:185
msgid ""
"String literals can span multiple lines. One way is using triple-quotes: ``"
"\"\"\"...\"\"\"`` or ``'''...'''``. End of lines are automatically included "
"in the string, but it's possible to prevent this by adding a ``\\`` at the "
"end of the line. The following example::"
msgstr ""
"As strings literais podem abranger vrias linhas. Uma maneira usar as "
"aspas triplas: ``\"\"\"...\"\"\"`` ou ``'''...'''``. O fim das linhas "
"includo automaticamente na string, mas possvel evitar isso adicionando "
"uma ``\\`` no final. O seguinte exemplo::"
#: ../../tutorial/introduction.rst:196
msgid ""
"produces the following output (note that the initial newline is not "
"included):"
msgstr ""
"produz a seguinte sada (observe que a linha inicial no est includa):"
#: ../../tutorial/introduction.rst:204
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:211
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 so "
"automaticamente concatenados. ::"
#: ../../tutorial/introduction.rst:217
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:224
msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr ""
"Isso s funciona com duas strings literais, no com variveis ou expresses::"
#: ../../tutorial/introduction.rst:238
msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr ""
"Se voc quiser concatenar variveis ou uma varivel e uma literal, use ``"
"+``::"
#: ../../tutorial/introduction.rst:243
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. No existe um tipo especfico para caracteres; um caractere "
"simplesmente uma string cujo tamanho 1::"
#: ../../tutorial/introduction.rst:253
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr ""
"ndices tambm podem ser nmeros negativos para iniciar a contagem pela "
"direita::"
#: ../../tutorial/introduction.rst:262
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 comeam em -1."
#: ../../tutorial/introduction.rst:264
msgid ""
"In addition to indexing, *slicing* is also supported. While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr ""
"Alm da indexao, o *fatiamento* tambm permitido. Embora a indexao "
"seja usada para obter caracteres individuais, *fatiar* permite que voc "
"obtenha substring::"
#: ../../tutorial/introduction.rst:272
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 padres teis; um primeiro ndice omitido "
"padro zero, um segundo ndice omitido por padro o tamanho da string "
"sendo fatiada::"
#: ../../tutorial/introduction.rst:282
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 incio sempre est includo, e o fim sempre excludo. Isso "
"garante que ``s[:i] + s[i:]`` seja sempre igual a ``s``::"
#: ../../tutorial/introduction.rst:290
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 "
"posies *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:301
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 nmeros indica a posio dos ndices 0...6 na string; "
"a segunda fileira indica a posio 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:306
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 diferena entre os "
"ndices, se ambos esto dentro dos limites da string. Por exemplo, o "
"comprimento de ``word[1:3]`` 2."
#: ../../tutorial/introduction.rst:310
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:317
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
"No entanto, os ndices de fatiamento fora do alcance so 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:325
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 no podem ser alteradas --- uma string :term:"
"`imutvel`. Portanto, atribuir a uma posio indexada na sequncia resulta "
"em um erro::"
#: ../../tutorial/introduction.rst:337
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:344
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "A funo embutida :func:`len` devolve o comprimento de uma string::"
#: ../../tutorial/introduction.rst:355
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"
#: ../../tutorial/introduction.rst:354
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
"As strings so exemplos de *tipos de sequncias* e suportam as operaes "
"comumente suportadas por esses tipos."
#: ../../tutorial/introduction.rst:359
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"
#: ../../tutorial/introduction.rst:358
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr ""
"As strings suportam uma grande quantidade de mtodos para transformaes "
"bsicas e busca."
#: ../../tutorial/introduction.rst:362
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"
#: ../../tutorial/introduction.rst:362
msgid "String literals that have embedded expressions."
msgstr "Strings literais que possuem expresses embutidas."
#: ../../tutorial/introduction.rst:365
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"
#: ../../tutorial/introduction.rst:365
msgid "Information about string formatting with :meth:`str.format`."
msgstr ""
"Informaes sobre formatao de string com o mtodo :meth:`str.format`."
#: ../../tutorial/introduction.rst:368
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"
#: ../../tutorial/introduction.rst:368
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr ""
"As antigas operaes de formatao invocadas quando as strings so o "
"operando esquerdo do operador ``%`` so descritas com mais detalhes aqui."
#: ../../tutorial/introduction.rst:375
msgid "Lists"
msgstr "Listas"
#: ../../tutorial/introduction.rst:377
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 verstil *list* (lista), que pode ser escrita como "
"uma lista de valores (itens) separados por vrgula, entre colchetes. Os "
"valores contidos na lista no precisam ser todos do mesmo tipo. ::"
#: ../../tutorial/introduction.rst:386
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:`sequncia`), listas pode "
"ser indexados e fatiados::"
#: ../../tutorial/introduction.rst:396
msgid ""
"All slice operations return a new list containing the requested elements. "
"This means that the following slice returns a :ref:`shallow copy "
"` of the list::"
msgstr ""
"Todas as operaes de fatiamento devolvem uma nova lista contendo os "
"elementos solicitados. Isso significa que o seguinte fatiamento devolve uma :"
"ref:`cpia rasa` da lista::"
#: ../../tutorial/introduction.rst:403
msgid "Lists also support operations like concatenation::"
msgstr "As listas tambm suportam operaes como concatenao::"
#: ../../tutorial/introduction.rst:408
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 so :term:`imutveis`, listas so :"
"term:`mutveis`, ou seja, possvel alterar elementos individuais "
"de uma lista::"
#: ../../tutorial/introduction.rst:418
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 tambm pode adicionar novos itens no final da lista, usando o *mtodo* :"
"meth:`~list.append` (estudaremos mais a respeito dos mtodos "
"posteriormente)::"
#: ../../tutorial/introduction.rst:426
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
"Atribuio a fatias tambm possvel, e isso pode at alterar o tamanho da "
"lista ou remover todos os itens dela::"
#: ../../tutorial/introduction.rst:445
msgid "The built-in function :func:`len` also applies to lists::"
msgstr "A funo embutida :func:`len` tambm se aplica a listas::"
#: ../../tutorial/introduction.rst:451
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr ""
" possvel aninhar listas (criar listas contendo outras listas), por "
"exemplo::"
#: ../../tutorial/introduction.rst:467
msgid "First Steps Towards Programming"
msgstr "Primeiros passos para a programao"
#: ../../tutorial/introduction.rst:469
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 `_ as "
"follows::"
msgstr ""
"Claro, podemos usar o Python para tarefas mais complicadas do que somar 2+2. "
"Por exemplo, podemos escrever o incio da `sequncia de Fibonacci `_ assim::"
#: ../../tutorial/introduction.rst:489
msgid "This example introduces several new features."
msgstr "Este exemplo introduz diversas caractersticas ainda no mencionadas."
#: ../../tutorial/introduction.rst:491
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 contm uma atribuio mltipla: as variveis ``a`` e ``b`` "
"recebem simultaneamente os novos valores 0 e 1. Na ltima linha h outro "
"exemplo de atribuio mltipla demonstrando que expresses do lado direito "
"so sempre avaliadas primeiro, antes da atribuio. As expresses do lado "
"direito so avaliadas da esquerda para a direita."
#: ../../tutorial/introduction.rst:497
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: ```` (greater than), ``==`` (equal to), ``=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
"O lao de repetio :keyword:`while` executa enquanto a condio (aqui: ``a "
"< 10``) permanece verdadeira. Em Python, como em C, qualquer valor inteiro "
"que no seja zero considerado verdadeiro; zero considerado falso. A "
"condio pode tambm ser uma cadeia de caracteres ou uma lista, ou qualquer "
"sequncia; qualquer coisa com um tamanho maior que zero verdadeiro, "
"enquanto sequncias vazias so falsas. O teste usado no exemplo uma "
"comparao simples. Os operadores padres de comparao so os mesmos de C: "
"```` (maior que), ``==`` (igual), ``=`` (maior ou igual) e ``!=`` (diferente)."
#: ../../tutorial/introduction.rst:506
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 lao *indentado*: indentao em Python a maneira de agrupar "
"comandos em blocos. No console interativo padro voc ter que digitar tab "
"ou espaos para indentar cada linha. Na prtica voc vai preparar scripts "
"Python mais complicados em um editor de texto; a maioria dos editores de "
"texto tem facilidades de indentao automtica. Quando um comando composto "
"digitado interativamente, deve ser finalizado por uma linha em branco (j "
"que o interpretador no tem como adivinhar qual a ltima linha do "
"comando). Observe que toda linha de um mesmo bloco de comandos deve ter a "
"mesma indentao."
#: ../../tutorial/introduction.rst:515
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 funo :func:`print` escreve o valor dos argumentos fornecidos. "
"diferente de apenas escrever a expresso no interpretador (como fizemos "
"anteriormente nos exemplos da calculadora) pela forma como lida com "
"mltiplos argumentos, quantidades de ponto flutuante e strings. As strings "
"so impressas sem aspas, e um espao inserido entre os itens, assim voc "
"pode formatar bem o resultado, dessa forma::"
#: ../../tutorial/introduction.rst:526
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 *end* pode ser usado para evitar uma nova linha aps a sada ou "
"finalizar a sada com uma string diferente::"
#: ../../tutorial/introduction.rst:538
msgid "Footnotes"
msgstr "Notas de rodap"
#: ../../tutorial/introduction.rst:539
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 precedncia 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:543
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 contrrio de outras linguagens, caracteres especiais como ``\\n`` tm o "
"mesmo significado com as aspas simples (``'...'``) e duplas (``\"...\"``) . "
"A nica diferena entre as duas que, dentro de aspas simples, voc no "
"precisa escapar o ``\"`` (mas voc deve escapar a ``\\'``) e vice-versa."