# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2026

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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-09-15 17:49+0000\n"

"PO-Revision-Date: 2025-09-16 00:02+0000\n"

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

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

"teams/5390/pt_BR/)\n"

"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=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "

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

#: ../../tutorial/inputoutput.rst:5

msgid "Input and output"

msgstr "Entrada e saída"

#: ../../tutorial/inputoutput.rst:7

msgid ""

"There are several ways to present the output of a program; data can be "

"printed in a human-readable form, or written to a file for future use. This "

"chapter will discuss some of the possibilities."

msgstr ""

"Existem várias maneiras de apresentar a saída de um programa; os dados podem "

"ser exibidos em forma legível para seres humanos, ou escritos em arquivos "

"para uso posterior. Este capítulo apresentará algumas das possibilidades."

#: ../../tutorial/inputoutput.rst:15

msgid "Fancier output formatting"

msgstr "Formatação de saída mais elaborada"

#: ../../tutorial/inputoutput.rst:17

msgid ""

"So far we've encountered two ways of writing values: *expression statements* "

"and the :func:`print` function. (A third way is using the :meth:`~io."

"TextIOBase.write` method of file objects; the standard output file can be "

"referenced as ``sys.stdout``. See the Library Reference for more information "

"on this.)"

msgstr ""

"Até agora vimos duas maneiras de exibir valores: *expressões* e a função :"

"func:`print`. (Uma outra maneira é utilizar o método :meth:`~io.TextIOBase."

"write` de objetos do tipo arquivo; o arquivo saída padrão pode ser "

"referenciado como ``sys.stdout``. Veja a Referência da Biblioteca Python "

"para mais informações sobre isso.)"

#: ../../tutorial/inputoutput.rst:22

msgid ""

"Often you'll want more control over the formatting of your output than "

"simply printing space-separated values. There are several ways to format "

"output."

msgstr ""

"Muitas vezes se deseja mais controle sobre a formatação da saída do que "

"simplesmente exibir valores separados por espaço. Existem várias maneiras de "

"formatar a saída."

#: ../../tutorial/inputoutput.rst:25

msgid ""

"To use :ref:`formatted string literals <tut-f-strings>`, begin a string with "

"``f`` or ``F`` before the opening quotation mark or triple quotation mark. "

"Inside this string, you can write a Python expression between ``{`` and ``}"

"`` characters that can refer to variables or literal values."

msgstr ""

"Para usar :ref:`strings literais formatadas <tut-f-strings>`, comece uma "

"string com ``f`` ou ``F``, antes de abrir as aspas ou aspas triplas. Dentro "

"dessa string, pode-se escrever uma expressão Python entre caracteres ``{`` e "

"``}``, que podem se referir a variáveis, ou valores literais."

#: ../../tutorial/inputoutput.rst:32

msgid ""

">>> year = 2016\n"

">>> event = 'Referendum'\n"

">>> f'Results of the {year} {event}'\n"

"'Results of the 2016 Referendum'"

msgstr ""

">>> ano = 2016\n"

">>> evento = 'Referendo'\n"

">>> f'Resultados do {evento} {ano}'\n"

"'Resultados do Referendo 2016'"

#: ../../tutorial/inputoutput.rst:37

msgid ""

"The :meth:`str.format` method of strings requires more manual effort. "

"You'll still use ``{`` and ``}`` to mark where a variable will be "

"substituted and can provide detailed formatting directives, but you'll also "

"need to provide the information to be formatted. In the following code block "

"there are two examples of how to format variables:"

msgstr ""

"O método de strings :meth:`str.format` requer mais esforço manual. Ainda "

"será necessário usar ``{`` e ``}`` para marcar onde a variável será "

"substituída e pode-se incluir diretivas de formatação detalhadas, mas também "

"precisará incluir a informação a ser formatada. No bloco de código a seguir "

"há dois exemplos de como formatar variáveis:"

#: ../../tutorial/inputoutput.rst:46

msgid ""

">>> yes_votes = 42_572_654\n"

">>> total_votes = 85_705_149\n"

">>> percentage = yes_votes / total_votes\n"

">>> '{:-9} YES votes {:2.2%}'.format(yes_votes, percentage)\n"

"' 42572654 YES votes 49.67%'"

msgstr ""

">>> votos_sim = 42_572_654\n"

">>> votos_totais = 85_705_149\n"

">>> porcentagem = votos_sim / votos_totais\n"

">>> '{:-9} votos SIM {:2.2%}'.format(votos_sim, porcentagem)\n"

"' 42572654 votos SIM 49.67%'"

#: ../../tutorial/inputoutput.rst:52

msgid ""

"Notice how the ``yes_votes`` are padded with spaces and a negative sign only "

"for negative numbers. The example also prints ``percentage`` multiplied by "

"100, with 2 decimal places and followed by a percent sign (see :ref:"

"`formatspec` for details)."

msgstr ""

"Observe como ``yes_votes`` são preenchidos com espaços e um sinal negativo "

"apenas para números negativos. O exemplo também imprime ``percentage`` "

"multiplicado por 100, com 2 casas decimais e seguido por um sinal de "

"porcentagem (veja :ref:`formatspec` para detalhes)."

#: ../../tutorial/inputoutput.rst:57

msgid ""

"Finally, you can do all the string handling yourself by using string slicing "

"and concatenation operations to create any layout you can imagine. The "

"string type has some methods that perform useful operations for padding "

"strings to a given column width."

msgstr ""

"Finalmente, pode-se fazer todo o tratamento da saída usando as operações de "

"fatiamento e concatenação de strings para criar qualquer layout que se possa "

"imaginar. O tipo string possui alguns métodos que realizam operações úteis "

"para preenchimento de strings para uma determinada largura de coluna."

#: ../../tutorial/inputoutput.rst:62

msgid ""

"When you don't need fancy output but just want a quick display of some "

"variables for debugging purposes, you can convert any value to a string with "

"the :func:`repr` or :func:`str` functions."

msgstr ""

"Quando não é necessário sofisticar a saída, mas apenas exibir algumas "

"variáveis com propósito de depuração, pode-se converter qualquer valor para "

"uma string com as funções :func:`repr` ou :func:`str`."

#: ../../tutorial/inputoutput.rst:66

msgid ""

"The :func:`str` function is meant to return representations of values which "

"are fairly human-readable, while :func:`repr` is meant to generate "

"representations which can be read by the interpreter (or will force a :exc:"

"`SyntaxError` if there is no equivalent syntax). For objects which don't "

"have a particular representation for human consumption, :func:`str` will "

"return the same value as :func:`repr`. Many values, such as numbers or "

"structures like lists and dictionaries, have the same representation using "

"either function. Strings, in particular, have two distinct representations."

msgstr ""

"A função :func:`str` serve para retornar representações de valores que sejam "

"legíveis para as pessoas, enquanto :func:`repr` é para gerar representações "

"que o interpretador Python consegue ler (ou levantará uma exceção :exc:"

"`SyntaxError`, se não houver sintaxe equivalente). Para objetos que não têm "

"uma representação adequada para consumo humano, :func:`str` devolve o mesmo "

"valor que :func:`repr`. Muitos valores, tal como números ou estruturas, como "

"listas e dicionários, têm a mesma representação usando quaisquer das "

"funções. Strings, em particular, têm duas representações distintas."

#: ../../tutorial/inputoutput.rst:75

msgid "Some examples::"

msgstr "Alguns exemplos:"

#: ../../tutorial/inputoutput.rst:77

msgid ""

">>> s = 'Hello, world.'\n"

">>> str(s)\n"

"'Hello, world.'\n"

">>> repr(s)\n"

"\"'Hello, world.'\"\n"

">>> str(1/7)\n"

"'0.14285714285714285'\n"

">>> x = 10 * 3.25\n"

">>> y = 200 * 200\n"

">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n"

">>> print(s)\n"

"The value of x is 32.5, and y is 40000...\n"

">>> # The repr() of a string adds string quotes and backslashes:\n"

">>> hello = 'hello, world\\n'\n"

">>> hellos = repr(hello)\n"

">>> print(hellos)\n"

"'hello, world\\n'\n"

">>> # The argument to repr() may be any Python object:\n"

">>> repr((x, y, ('spam', 'eggs')))\n"

"\"(32.5, 40000, ('spam', 'eggs'))\""

msgstr ""

">>> s = 'Olá, mundo.'\n"

">>> str(s)\n"

"'Olá, mundo.'\n"

">>> repr(s)\n"

"\"'Olá, mundo.'\"\n"

">>> str(1/7)\n"

"'0.14285714285714285'\n"

">>> x = 10 * 3.25\n"

">>> y = 200 * 200\n"

">>> s = 'O valor de x é ' + repr(x) + ' e de y é ' + repr(y) + '...'\n"

">>> print(s)\n"

"O valor de x é 32.5 e de y é 40000...\n"

">>> # A repr() da string adiciona aspas e contrabarras:\n"

">>> olá = 'olá, mundo\\n'\n"

">>> olás = repr(olá)\n"

">>> print(olás)\n"

"'olá, mundo\\n'\n"

">>> # O argumento de repr() pode ser qualquer objeto Python:\n"

">>> repr((x, y, ('spam', 'ovos')))\n"

"\"(32.5, 40000, ('spam', 'ovos'))\""

#: ../../tutorial/inputoutput.rst:98

msgid ""

"The :mod:`string` module contains support for a simple templating approach "

"based upon regular expressions, via :class:`string.Template`. This offers "

"yet another way to substitute values into strings, using placeholders like "

"``$x`` and replacing them with values from a dictionary. This syntax is easy "

"to use, although it offers much less control for formatting."

msgstr ""

"O módulo :mod:`string` contém suporte para uma abordagem simples de criação "

"de modelos baseada em expressões regulares, via :class:`string.Template`. "

"Isso oferece outra maneira de substituir valores em strings, usando espaços "

"reservados como ``$x`` e substituindo-os por valores de um dicionário. Essa "

"sintaxe é fácil de usar, embora ofereça muito menos controle sobre a "

"formatação."

#: ../../tutorial/inputoutput.rst:115

msgid "Formatted string literals"

msgstr "Literais de string formatados"

#: ../../tutorial/inputoutput.rst:117

msgid ""

":ref:`Formatted string literals <f-strings>` (also called f-strings for "

"short) let you include the value of Python expressions inside a string by "

"prefixing the string with ``f`` or ``F`` and writing expressions as "

"``{expression}``."

msgstr ""

":ref:`Strings literais formatadas <f-strings>` (também chamadas f-strings, "

"para abreviar) permite que se inclua o valor de expressões Python dentro de "

"uma string, prefixando-a com ``f`` ou ``F`` e escrevendo expressões na forma "

"``{expression}``."

#: ../../tutorial/inputoutput.rst:122

msgid ""

"An optional format specifier can follow the expression. This allows greater "

"control over how the value is formatted. The following example rounds pi to "

"three places after the decimal::"

msgstr ""

"Um especificador opcional de formato pode ser incluído após a expressão. "

"Isso permite maior controle sobre como o valor é formatado. O exemplo a "

"seguir arredonda pi para três casas decimais::"

#: ../../tutorial/inputoutput.rst:126

msgid ""

">>> import math\n"

">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n"

"The value of pi is approximately 3.142."

msgstr ""

">>> import math\n"

">>> print(f'O valor de pi é aproximadamente {math.pi:.3f}.')\n"

"O valor de pi é aproximadamente 3.142."

#: ../../tutorial/inputoutput.rst:130

msgid ""

"Passing an integer after the ``':'`` will cause that field to be a minimum "

"number of characters wide. This is useful for making columns line up. ::"

msgstr ""

"Passando um inteiro após o ``':'`` fará com que o campo tenha um número "

"mínimo de caracteres de largura. Isso é útil para alinhar colunas. ::"

#: ../../tutorial/inputoutput.rst:133

msgid ""

">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"

">>> for name, phone in table.items():\n"

"... print(f'{name:10} ==> {phone:10d}')\n"

"...\n"

"Sjoerd ==> 4127\n"

"Jack ==> 4098\n"

"Dcab ==> 7678"

msgstr ""

">>> tabela = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"

">>> for nome, telefone in tabela.items():\n"

"... print(f'{nome:10} ==> {telefone:10d}')\n"

"...\n"

"Sjoerd ==> 4127\n"

"Jack ==> 4098\n"

"Dcab ==> 7678"

#: ../../tutorial/inputoutput.rst:141

msgid ""

"Other modifiers can be used to convert the value before it is formatted. ``'!"

"a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` "

"applies :func:`repr`::"

msgstr ""

"Outros modificadores podem ser usados para converter o valor antes de ser "

"formatado. ``'!a'`` aplica a função :func:`ascii`, ``'!s'`` aplica a função :"

"func:`str` e ``'!r'`` aplica a função :func:`repr` ::"

#: ../../tutorial/inputoutput.rst:145

msgid ""

">>> animals = 'eels'\n"

">>> print(f'My hovercraft is full of {animals}.')\n"

"My hovercraft is full of eels.\n"

">>> print(f'My hovercraft is full of {animals!r}.')\n"

"My hovercraft is full of 'eels'."

msgstr ""

">>> animais = 'enguias'\n"

">>> print(f'Meu hovercraft está cheio de {animais}.')\n"

"Meu hovercraft está cheio de enguias.\n"

">>> print(f'Meu hovercraft está cheio de {animais!r}.')\n"

"Meu hovercraft está cheio de 'enguias'."

#: ../../tutorial/inputoutput.rst:151

msgid ""

"The ``=`` specifier can be used to expand an expression to the text of the "

"expression, an equal sign, then the representation of the evaluated "

"expression:"

msgstr ""

"O especificador ``=`` pode ser usado para expandir uma expressão para o "

"texto da expressão, um sinal de igual e, então, a representação da expressão "

"avaliada:"

#: ../../tutorial/inputoutput.rst:160

msgid ""

"See :ref:`self-documenting expressions <bpo-36817-whatsnew>` for more "

"information on the ``=`` specifier. For a reference on these format "

"specifications, see the reference guide for the :ref:`formatspec`."

msgstr ""

"Veja :ref:`expressões autodocumentadas <bpo-36817-whatsnew>` para mais "

"informações sobre o especificador ``=``. Para obter uma referência sobre "

"essas especificações de formato, consulte o guia de referência para a :ref:"

"`formatspec`."

#: ../../tutorial/inputoutput.rst:167

msgid "The string format() method"

msgstr "O método format() de strings"

#: ../../tutorial/inputoutput.rst:169

msgid "Basic usage of the :meth:`str.format` method looks like this::"

msgstr "Um uso básico do método :meth:`str.format` tem esta forma::"

#: ../../tutorial/inputoutput.rst:171

msgid ""

">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n"

"We are the knights who say \"Ni!\""

msgstr ""

">>> print('Nós somos os {} que dizem \"{}!\"'.format('cavaleiros', 'Ni'))\n"

"Nós somos os cavaleiros que dizem \"Ni!\""

#: ../../tutorial/inputoutput.rst:174

msgid ""

"The brackets and characters within them (called format fields) are replaced "

"with the objects passed into the :meth:`str.format` method. A number in the "

"brackets can be used to refer to the position of the object passed into the :"

"meth:`str.format` method. ::"

msgstr ""

"As chaves e seus conteúdos (chamados campos de formatação) são substituídos "

"pelos objetos passados para o método :meth:`str.format`. Um número nas "

"chaves pode ser usado para referenciar a posição do objeto passado no "

"método :meth:`str.format`. ::"

#: ../../tutorial/inputoutput.rst:179

msgid ""

">>> print('{0} and {1}'.format('spam', 'eggs'))\n"

"spam and eggs\n"

">>> print('{1} and {0}'.format('spam', 'eggs'))\n"

"eggs and spam"

msgstr ""

">>> print('{0} e {1}'.format('spam', 'ovos'))\n"

"spam e eggs\n"

">>> print('{1} e {0}'.format('spam', 'ovos'))\n"

"eggs e spam"

#: ../../tutorial/inputoutput.rst:184

msgid ""

"If keyword arguments are used in the :meth:`str.format` method, their values "

"are referred to by using the name of the argument. ::"

msgstr ""

"Se argumentos nomeados são passados para o método :meth:`str.format`, seus "

"valores serão referenciados usando o nome do argumento::"

#: ../../tutorial/inputoutput.rst:187

msgid ""

">>> print('This {food} is {adjective}.'.format(\n"

"... food='spam', adjective='absolutely horrible'))\n"

"This spam is absolutely horrible."

msgstr ""

">>> print('Este {comida} está {adjetivo}.'.format(\n"

"... comida='spam', adjetivo='absolutamente horrível'))\n"

"Este spam está absolutamente horrível."

#: ../../tutorial/inputoutput.rst:191

msgid "Positional and keyword arguments can be arbitrarily combined::"

msgstr "Argumentos posicionais e nomeados podem ser combinados à vontade::"

#: ../../tutorial/inputoutput.rst:193

msgid ""

">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"

"... other='Georg'))\n"

"The story of Bill, Manfred, and Georg."

msgstr ""

">>> print('A história de {0}, {1} e {outro}.'.format('Bill', 'Manfred',\n"

"... outro='Georg'))\n"

"A história de Bill, Manfred e Georg."

#: ../../tutorial/inputoutput.rst:197

msgid ""

"If you have a really long format string that you don't want to split up, it "

"would be nice if you could reference the variables to be formatted by name "

"instead of by position. This can be done by simply passing the dict and "

"using square brackets ``'[]'`` to access the keys. ::"

msgstr ""

"Se uma string de formatação é muito longa, e não se deseja quebrá-la, pode "

"ser bom fazer referência aos valores a serem formatados por nome, em vez de "

"posição. Isto pode ser feito passando um dicionário usando colchetes "

"``'[]'`` para acessar as chaves. ::"

#: ../../tutorial/inputoutput.rst:202

msgid ""

">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"

">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"

"... 'Dcab: {0[Dcab]:d}'.format(table))\n"

"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

msgstr ""

">>> tabela = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"

">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"

"... 'Dcab: {0[Dcab]:d}'.format(tabela))\n"

"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

#: ../../tutorial/inputoutput.rst:207

msgid ""

"This could also be done by passing the ``table`` dictionary as keyword "

"arguments with the ``**`` notation. ::"

msgstr ""

"Isto também pode ser feito passando o dicionário ``table`` como argumentos "

"nomeados com a notação ``**``. ::"

#: ../../tutorial/inputoutput.rst:210

msgid ""

">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"

">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'."

"format(**table))\n"

"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

msgstr ""

">>> tabela = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"

">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'."

"format(**tabela))\n"

"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

#: ../../tutorial/inputoutput.rst:214

msgid ""

"This is particularly useful in combination with the built-in function :func:"

"`vars`, which returns a dictionary containing all local variables::"

msgstr ""

"Isto é particularmente útil em conjunto com a função embutida :func:`vars`, "

"que devolve um dicionário contendo todas as variáveis locais::"

#: ../../tutorial/inputoutput.rst:217

msgid ""

">>> table = {k: str(v) for k, v in vars().items()}\n"

">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"

">>> print(message.format(**table))\n"

"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."

msgstr ""

">>> tabela = {k: str(v) for k, v in vars().items()}\n"

">>> mensagem = \" \".join([f'{k}: ' + '{' + k +'};' for k in tabela."

"keys()])\n"

">>> print(mensagem.format(**tabela))\n"

"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."

#: ../../tutorial/inputoutput.rst:222

msgid ""

"As an example, the following lines produce a tidily aligned set of columns "

"giving integers and their squares and cubes::"

msgstr ""

"Como exemplo, as linhas seguintes produzem um conjunto de colunas alinhadas, "

"com alguns inteiros e seus quadrados e cubos::"

#: ../../tutorial/inputoutput.rst:225

msgid ""

">>> for x in range(1, 11):\n"

"... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"

"...\n"

" 1 1 1\n"

" 2 4 8\n"

" 3 9 27\n"

" 4 16 64\n"

" 5 25 125\n"

" 6 36 216\n"

" 7 49 343\n"

" 8 64 512\n"

" 9 81 729\n"

"10 100 1000"

msgstr ""

">>> for x in range(1, 11):\n"

"... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"

"...\n"

" 1 1 1\n"

" 2 4 8\n"

" 3 9 27\n"

" 4 16 64\n"

" 5 25 125\n"

" 6 36 216\n"

" 7 49 343\n"

" 8 64 512\n"

" 9 81 729\n"

"10 100 1000"

#: ../../tutorial/inputoutput.rst:239

msgid ""

"For a complete overview of string formatting with :meth:`str.format`, see :"

"ref:`formatstrings`."

msgstr ""

"Para uma visão completa da formatação de strings com :meth:`str.format`, "

"veja a seção :ref:`formatstrings`."

#: ../../tutorial/inputoutput.rst:244

msgid "Manual string formatting"

msgstr "Formatação manual de strings"

#: ../../tutorial/inputoutput.rst:246

msgid "Here's the same table of squares and cubes, formatted manually::"

msgstr ""

"Aqui está a mesma tabela de quadrados e cubos, formatados manualmente::"

#: ../../tutorial/inputoutput.rst:248

msgid ""

">>> for x in range(1, 11):\n"

"... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"

"... # Note use of 'end' on previous line\n"

"... print(repr(x*x*x).rjust(4))\n"

"...\n"

" 1 1 1\n"

" 2 4 8\n"

" 3 9 27\n"

" 4 16 64\n"

" 5 25 125\n"

" 6 36 216\n"

" 7 49 343\n"

" 8 64 512\n"

" 9 81 729\n"

"10 100 1000"

msgstr ""

">>> for x in range(1, 11):\n"

"... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"

"... # Observe o uso do 'end' na linha anterior\n"

"... print(repr(x*x*x).rjust(4))\n"

"...\n"

" 1 1 1\n"

" 2 4 8\n"

" 3 9 27\n"

" 4 16 64\n"

" 5 25 125\n"

" 6 36 216\n"

" 7 49 343\n"

" 8 64 512\n"

" 9 81 729\n"

"10 100 1000"

#: ../../tutorial/inputoutput.rst:264

msgid ""

"(Note that the one space between each column was added by the way :func:"

"`print` works: it always adds spaces between its arguments.)"

msgstr ""

"(Note que o espaço entre cada coluna foi adicionado pela forma que a função :"

"func:`print` funciona: sempre adiciona espaços entre seus argumentos.)"

#: ../../tutorial/inputoutput.rst:267

msgid ""

"The :meth:`str.rjust` method of string objects right-justifies a string in a "

"field of a given width by padding it with spaces on the left. There are "

"similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do "

"not write anything, they just return a new string. If the input string is "

"too long, they don't truncate it, but return it unchanged; this will mess up "

"your column lay-out but that's usually better than the alternative, which "

"would be lying about a value. (If you really want truncation you can always "

"add a slice operation, as in ``x.ljust(n)[:n]``.)"

msgstr ""

"O método :meth:`str.rjust` justifica uma string à direita, num campo de "

"tamanho definido, acrescentando espaços à esquerda. De forma similar, os "

"métodos :meth:`str.ljust`, justifica à esquerda, e :meth:`str.center`, para "

"centralizar. Esses métodos não escrevem nada, apenas retornam uma nova "

"string. Se a string de entrada é muito longa, os métodos não truncarão a "

"saída, e retornarão a mesma string, sem mudança; isso vai atrapalhar o "

"layout da coluna, mas geralmente é melhor do que a alternativa, que estaria "

"distorcendo o valor. (Se realmente quiser truncar, sempre se pode adicionar "

"uma operação de fatiamento, como em ``x.ljust(n)[:n]``.)"

#: ../../tutorial/inputoutput.rst:276

msgid ""

"There is another method, :meth:`str.zfill`, which pads a numeric string on "

"the left with zeros. It understands about plus and minus signs::"

msgstr ""

"Existe ainda o método :meth:`str.zfill` que preenche uma string numérica com "

"zeros à esquerda, e sabe lidar com sinais positivos e negativos::"

#: ../../tutorial/inputoutput.rst:279

msgid ""

">>> '12'.zfill(5)\n"

"'00012'\n"

">>> '-3.14'.zfill(7)\n"

"'-003.14'\n"

">>> '3.14159265359'.zfill(5)\n"

"'3.14159265359'"

msgstr ""

">>> '12'.zfill(5)\n"

"'00012'\n"

">>> '-3.14'.zfill(7)\n"

"'-003.14'\n"

">>> '3.14159265359'.zfill(5)\n"

"'3.14159265359'"

#: ../../tutorial/inputoutput.rst:288

msgid "Old string formatting"

msgstr "Formatação de strings à moda antiga"

#: ../../tutorial/inputoutput.rst:290

msgid ""

"The % operator (modulo) can also be used for string formatting. Given "

"``format % values`` (where *format* is a string), ``%`` conversion "

"specifications in *format* are replaced with zero or more elements of "

"*values*. This operation is commonly known as string interpolation. For "

"example::"

msgstr ""

"O operador % (módulo) também pode ser usado para formatação de string. Dado "

"``formato % valores`` (onde *formato* é uma string), as instâncias de ``%`` "

"em ``formato`` serão substituídas por zero ou mais elementos de ``valores``. "

"Essa operação é conhecida como interpolação de string. Por exemplo::"

#: ../../tutorial/inputoutput.rst:297

msgid ""

">>> import math\n"

">>> print('The value of pi is approximately %5.3f.' % math.pi)\n"

"The value of pi is approximately 3.142."

msgstr ""

">>> import math\n"

">>> print('O valor de pi é aproximadamente %5.3f.' % math.pi)\n"

"O valor de pi é aproximadamente 3.142."

#: ../../tutorial/inputoutput.rst:301

msgid ""

"More information can be found in the :ref:`old-string-formatting` section."

msgstr ""

"Mais informação pode ser encontrada na seção :ref:`old-string-formatting`."

#: ../../tutorial/inputoutput.rst:307

msgid "Reading and writing files"

msgstr "Lendo e escrevendo arquivos"

#: ../../tutorial/inputoutput.rst:313

msgid ""

":func:`open` returns a :term:`file object`, and is most commonly used with "

"two positional arguments: ``open(filename, mode)``"

msgstr ""

":func:`open` retorna um :term:`objeto arquivo`, e é mais utilizado com dois "

"argumentos posicionais: ``open(filename, mode)``"

#: ../../tutorial/inputoutput.rst:318

msgid ">>> f = open('workfile', 'w')"

msgstr ">>> f = open('arquivo_de_trabalho', 'w')"

#: ../../tutorial/inputoutput.rst:325

msgid ""

"The first argument is a string containing the filename. The second argument "

"is another string containing a few characters describing the way in which "

"the file will be used. *mode* can be ``'r'`` when the file will only be "

"read, ``'w'`` for only writing (an existing file with the same name will be "

"erased), and ``'a'`` opens the file for appending; any data written to the "

"file is automatically added to the end. ``'r+'`` opens the file for both "

"reading and writing. The *mode* argument is optional; ``'r'`` will be "

"assumed if it's omitted."

msgstr ""

"O primeiro argumento é uma string contendo o nome do arquivo. O segundo "

"argumento é outra string, contendo alguns caracteres que descrevem o modo "

"como o arquivo será usado. *modo* pode ser ``'r'`` quando o arquivo será "

"apenas lido, ``'w'`` para escrever (se o arquivo já existir seu conteúdo "

"prévio será apagado), e ``'a'`` para abrir o arquivo para adição; qualquer "

"escrita será adicionada ao final do arquivo. A opção ``'r+'`` abre o arquivo "

"tanto para leitura como para escrita. O argumento *modo* é opcional, em caso "

"de omissão será presumido ``'r'``."

#: ../../tutorial/inputoutput.rst:334

msgid ""

"Normally, files are opened in :dfn:`text mode`, that means, you read and "

"write strings from and to the file, which are encoded in a specific "

"*encoding*. If *encoding* is not specified, the default is UTF-8 (see :func:"

"`open`). Appending a ``'b'`` to the mode opens the file in :dfn:`binary "

"mode`. Binary mode data is read and written as :class:`bytes` objects. You "

"can not specify *encoding* when opening file in binary mode."

msgstr ""

"Normalmente, arquivos são abertos no :dfn:`modo texto`, o que significa que "

"você lê strings de e para o arquivo, o qual está em um codificação "

"específica. Se a *codificação* não for especificada, o padrão é UTF-8 (veja :"

"func:`open`). Adicionando ``'b'`` ao modo irá abrir o o arquivo em :dfn:"

"`modo binário`. Dados no modo binário são lidos e escritos como objetos :"

"class:`bytes`. Você não pode especificar a *codificação* quando estiver "

"abrindo os arquivos em modo binário."

#: ../../tutorial/inputoutput.rst:341

msgid ""

"In text mode, the default when reading is to convert platform-specific line "

"endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``. When "

"writing in text mode, the default is to convert occurrences of ``\\n`` back "

"to platform-specific line endings. This behind-the-scenes modification to "

"file data is fine for text files, but will corrupt binary data like that in :"

"file:`JPEG` or :file:`EXE` files. Be very careful to use binary mode when "

"reading and writing such files."

msgstr ""

"Em modo texto, o padrão durante a leitura é converter terminadores de linha "

"específicos da plataforma (``\\n`` no Unix, ``\\r\\n`` no Windows) para "

"apenas ``\\n``. Ao escrever no modo de texto, o padrão é converter as "

"ocorrências de ``\\n`` de volta para os finais de linha específicos da "

"plataforma. Essa modificação de bastidores nos dados do arquivo é adequada "

"para arquivos de texto, mas corromperá dados binários, como arquivos :file:"

"`JPEG` ou :file:`EXE`. Tenha muito cuidado para só usar o modo binário, ao "

"ler e gravar esses arquivos."

#: ../../tutorial/inputoutput.rst:349

msgid ""

"It is good practice to use the :keyword:`with` keyword when dealing with "

"file objects. The advantage is that the file is properly closed after its "

"suite finishes, even if an exception is raised at some point. Using :"

"keyword:`!with` is also much shorter than writing equivalent :keyword:"

"`try`\\ -\\ :keyword:`finally` blocks::"

msgstr ""

"É uma boa prática usar a palavra-chave :keyword:`with` ao lidar com "

"arquivos. A vantagem é que o arquivo é fechado corretamente após o término "

"de sua utilização, mesmo que uma exceção seja levantada em algum momento. "

"Usar :keyword:`!with` também é muito mais curto que escrever seu bloco "

"equivalente :keyword:`try`\\ -\\ :keyword:`finally`::"

#: ../../tutorial/inputoutput.rst:355

msgid ""

">>> with open('workfile') as f:\n"

"... read_data = f.read()\n"

"\n"

">>> # We can check that the file has been automatically closed.\n"

">>> f.closed\n"

"True"

msgstr ""

">>> with open('arquivo_de_trabalho') as f:\n"

"... read_data = f.read()\n"

"\n"

">>> # Podemos verificar se o arquivo foi fechado automaticamente.\n"

">>> f.closed\n"

"True"

#: ../../tutorial/inputoutput.rst:362

msgid ""

"If you're not using the :keyword:`with` keyword, then you should call ``f."

"close()`` to close the file and immediately free up any system resources "

"used by it."

msgstr ""

"Se você não está usando a palavra reservada :keyword:`with`, então você "

"deveria chamar ``f.close()`` para fechar o arquivo e imediatamente liberar "

"qualquer recurso do sistema usado por ele."

#: ../../tutorial/inputoutput.rst:367

msgid ""

"Calling ``f.write()`` without using the :keyword:`!with` keyword or calling "

"``f.close()`` **might** result in the arguments of ``f.write()`` not being "

"completely written to the disk, even if the program exits successfully."

msgstr ""

"Chamar ``f.write()`` sem usar a palavra reservada :keyword:`!with` ou chamar "

"``f.close()`` **pode** resultar nos argumentos de ``f.write()`` não serem "

"completamente escritos no disco, mesmo se o programa for encerrado com êxito."

#: ../../tutorial/inputoutput.rst:375

msgid ""

"After a file object is closed, either by a :keyword:`with` statement or by "

"calling ``f.close()``, attempts to use the file object will automatically "

"fail. ::"

msgstr ""

"Depois que um arquivo é fechado, seja por uma instrução :keyword:`with` ou "

"chamando ``f.close()``, as tentativas de usar o arquivo falharão "

"automaticamente. ::"

#: ../../tutorial/inputoutput.rst:379

msgid ""

">>> f.close()\n"

">>> f.read()\n"

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

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

"ValueError: I/O operation on closed file."

msgstr ""

">>> f.close()\n"

">>> f.read()\n"

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

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

"ValueError: I/O operation on closed file."

#: ../../tutorial/inputoutput.rst:389

msgid "Methods of file objects"

msgstr "Métodos de objetos arquivo"

#: ../../tutorial/inputoutput.rst:391

msgid ""

"The rest of the examples in this section will assume that a file object "

"called ``f`` has already been created."

msgstr ""

"Para simplificar, o resto dos exemplos nesta seção presumem que um objeto "

"arquivo chamado ``f`` já foi criado."

#: ../../tutorial/inputoutput.rst:394

msgid ""

"To read a file's contents, call ``f.read(size)``, which reads some quantity "

"of data and returns it as a string (in text mode) or bytes object (in binary "

"mode). *size* is an optional numeric argument. When *size* is omitted or "

"negative, the entire contents of the file will be read and returned; it's "

"your problem if the file is twice as large as your machine's memory. "

"Otherwise, at most *size* characters (in text mode) or *size* bytes (in "

"binary mode) are read and returned. If the end of the file has been reached, "

"``f.read()`` will return an empty string (``''``). ::"

msgstr ""

"Para ler o conteúdo de um arquivo, chame ``f.read(tamanho)``, que lê um "

"punhado de dados devolvendo-os como uma string (em modo texto) ou bytes (em "

"modo binário). *tamanho* é um argumento numérico opcional. Quando *tamanho* "

"é omitido ou negativo, todo o conteúdo do arquivo é lido e devolvido; se o "

"arquivo é duas vezes maior que memória da máquina, o problema é seu. Caso "

"contrário, no máximo *tamanho* caracteres (em modo texto) ou *tamanho* bytes "

"(em modo binário) são lidos e devolvidos. Se o fim do arquivo for atingido, "

"``f.read()`` devolve uma string vazia (``''``). ::"

#: ../../tutorial/inputoutput.rst:403

msgid ""

">>> f.read()\n"

"'This is the entire file.\\n'\n"

">>> f.read()\n"

"''"

msgstr ""

">>> f.read()\n"

"'Este é o arquivo inteiro.\\n'\n"

">>> f.read()\n"

"''"

#: ../../tutorial/inputoutput.rst:408

msgid ""

"``f.readline()`` reads a single line from the file; a newline character "

"(``\\n``) is left at the end of the string, and is only omitted on the last "

"line of the file if the file doesn't end in a newline. This makes the "

"return value unambiguous; if ``f.readline()`` returns an empty string, the "

"end of the file has been reached, while a blank line is represented by "

"``'\\n'``, a string containing only a single newline. ::"

msgstr ""

"O método ``f.readline()`` lê uma única linha do arquivo; o caractere de "

"quebra de linha (``\\n``) é mantido ao final da string, e só é omitido na "

"última linha do arquivo, se o arquivo não terminar com uma quebra de linha. "

"Isso elimina a ambiguidade do valor retornado; se ``f.readline()`` retorna "

"uma string vazia, o fim do arquivo foi atingido. Linhas em branco são "

"representadas por um ``'\\n'`` -- uma string contendo apenas o caractere "

"terminador de linha. ::"

#: ../../tutorial/inputoutput.rst:415

msgid ""

">>> f.readline()\n"

"'This is the first line of the file.\\n'\n"

">>> f.readline()\n"

"'Second line of the file\\n'\n"

">>> f.readline()\n"

"''"

msgstr ""

">>> f.readline()\n"

"'Está é a primeira linha do arquivo.\\n'\n"

">>> f.readline()\n"

"'Segunda linha do arquivo\\n'\n"

">>> f.readline()\n"

"''"

#: ../../tutorial/inputoutput.rst:422

msgid ""

"For reading lines from a file, you can loop over the file object. This is "

"memory efficient, fast, and leads to simple code::"

msgstr ""

"Uma maneira alternativa de ler linhas do arquivo é iterar diretamente pelo "

"objeto arquivo. É eficiente, rápido e resulta em código mais simples::"

#: ../../tutorial/inputoutput.rst:425

msgid ""

">>> for line in f:\n"

"... print(line, end='')\n"

"...\n"

"This is the first line of the file.\n"

"Second line of the file"

msgstr ""

">>> for line in f:\n"

"... print(line, end='')\n"

"...\n"

"Esta é a primeira linha do arquivo.\n"

"Segunda linha do arquivo"

#: ../../tutorial/inputoutput.rst:431

msgid ""

"If you want to read all the lines of a file in a list you can also use "

"``list(f)`` or ``f.readlines()``."

msgstr ""

"Se desejar ler todas as linhas de um arquivo em uma lista, pode-se usar "

"``list(f)`` ou ``f.readlines()``."

#: ../../tutorial/inputoutput.rst:434

msgid ""

"``f.write(string)`` writes the contents of *string* to the file, returning "

"the number of characters written. ::"

msgstr ""

"``f.write(string)`` escreve o conteúdo de *string* para o arquivo, "

"retornando o número de caracteres escritos. ::"

#: ../../tutorial/inputoutput.rst:437

msgid ""

">>> f.write('This is a test\\n')\n"

"15"

msgstr ""

">>> f.write('Este é um teste\\n')\n"

"15"

#: ../../tutorial/inputoutput.rst:440

msgid ""

"Other types of objects need to be converted -- either to a string (in text "

"mode) or a bytes object (in binary mode) -- before writing them::"

msgstr ""

"Outros tipos de objetos precisam ser convertidos -- seja para uma string (em "

"modo texto) ou para bytes (em modo binário) -- antes de escrevê-los::"

#: ../../tutorial/inputoutput.rst:443

msgid ""

">>> value = ('the answer', 42)\n"

">>> s = str(value) # convert the tuple to string\n"

">>> f.write(s)\n"

"18"

msgstr ""

">>> value = ('a resposta', 42)\n"

">>> s = str(value) # converte a tupla para string\n"

">>> f.write(s)\n"

"18"

#: ../../tutorial/inputoutput.rst:448

msgid ""

"``f.tell()`` returns an integer giving the file object's current position in "

"the file represented as number of bytes from the beginning of the file when "

"in binary mode and an opaque number when in text mode."

msgstr ""

"``f.tell()`` retorna um inteiro dando a posição atual do objeto arquivo, no "

"arquivo representado, como número de bytes desde o início do arquivo, no "

"modo binário, e um número ininteligível, quando no modo de texto."

#: ../../tutorial/inputoutput.rst:452

msgid ""

"To change the file object's position, use ``f.seek(offset, whence)``. The "

"position is computed from adding *offset* to a reference point; the "

"reference point is selected by the *whence* argument. A *whence* value of 0 "

"measures from the beginning of the file, 1 uses the current file position, "

"and 2 uses the end of the file as the reference point. *whence* can be "

"omitted and defaults to 0, using the beginning of the file as the reference "

"point. ::"

msgstr ""

"Para mudar a posição, use ``f.seek(offset, de_onde)``. A nova posição é "

"computada pela soma do deslocamento *offset* a um ponto de referência "

"especificado pelo argumento *de-onde*. Se o valor de *de_onde* é 0,a "

"referência é o início do arquivo, 1 refere-se à posição atual, e 2 refere-se "

"ao fim do arquivo. Este argumento pode ser omitido e o valor padrão é 0, "

"usando o início do arquivo como referência. ::"

#: ../../tutorial/inputoutput.rst:459

msgid ""

">>> f = open('workfile', 'rb+')\n"

">>> f.write(b'0123456789abcdef')\n"

"16\n"

">>> f.seek(5) # Go to the 6th byte in the file\n"

"5\n"

">>> f.read(1)\n"

"b'5'\n"

">>> f.seek(-3, 2) # Go to the 3rd byte before the end\n"

"13\n"

">>> f.read(1)\n"

"b'd'"

msgstr ""

">>> f = open('arquivo_de_trabalho', 'rb+')\n"

">>> f.write(b'0123456789abcdef')\n"

"16\n"

">>> f.seek(5) # Vai até o 6º byte no arquivo\n"

"5\n"

">>> f.read(1)\n"

"b'5'\n"

">>> f.seek(-3, 2) # Vai até o 3º byte antes do fim\n"

"13\n"

">>> f.read(1)\n"

"b'd'"

#: ../../tutorial/inputoutput.rst:471

msgid ""