# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001-2025, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # # Translators: # python-doc bot, 2025 # Rafael Fontenelle , 2025 # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.13\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2025-09-29 15:02+0000\n" "PO-Revision-Date: 2025-09-15 01:05+0000\n" "Last-Translator: Rafael Fontenelle , 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/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 "Refinando a formatação de saída" #: ../../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 `, 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 `, 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 a :class:`~string.Template` class that " "offers yet another way to substitute values into strings, using placeholders " "like ``$x`` and replacing them with values from a dictionary, but offers " "much less control of the formatting." msgstr "" "O módulo :mod:`string` contém uma classe :class:`~string.Template` que " "oferece ainda outra maneira de substituir valores em strings, usando espaços " "reservados como ``$x`` e substituindo-os por valores de um dicionário, mas " "oferece muito menos controle da formatação." #: ../../tutorial/inputoutput.rst:114 msgid "Formatted String Literals" msgstr "Strings literais formatadas" #: ../../tutorial/inputoutput.rst:116 msgid "" ":ref:`Formatted string literals ` (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 ` (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:121 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:125 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:129 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:132 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:140 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:144 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:150 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:159 msgid "" "See :ref:`self-documenting expressions ` 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 ` 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:166 msgid "The String format() Method" msgstr "O método format()" #: ../../tutorial/inputoutput.rst:168 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:170 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:173 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:178 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:183 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:186 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:190 msgid "Positional and keyword arguments can be arbitrarily combined::" msgstr "Argumentos posicionais e nomeados podem ser combinados à vontade::" #: ../../tutorial/inputoutput.rst:192 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:196 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:201 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:206 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:209 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:213 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:216 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:221 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:224 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:238 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:243 msgid "Manual String Formatting" msgstr "Formatação manual de string" #: ../../tutorial/inputoutput.rst:245 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:247 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:263 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:266 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:275 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:278 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:287 msgid "Old string formatting" msgstr "Formatação de strings à moda antiga" #: ../../tutorial/inputoutput.rst:289 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:296 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:300 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:306 msgid "Reading and Writing Files" msgstr "Leitura e escrita de arquivos" #: ../../tutorial/inputoutput.rst:312 msgid "" ":func:`open` returns a :term:`file object`, and is most commonly used with " "two positional arguments and one keyword argument: ``open(filename, mode, " "encoding=None)``" msgstr "" ":func:`open` retorna um :term:`objeto arquivo`, e é mais utilizado com dois " "argumentos posicionais e um argumento nomeado: ``open(filename, mode, " "encoding=None)``" #: ../../tutorial/inputoutput.rst:318 msgid ">>> f = open('workfile', 'w', encoding=\"utf-8\")" msgstr ">>> f = open('arquivo_de_trabalho', 'w', encoding=\"utf-8\")" #: ../../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 platform " "dependent (see :func:`open`). Because UTF-8 is the modern de-facto standard, " "``encoding=\"utf-8\"`` is recommended unless you know that you need to use a " "different encoding. 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 irá depender " "da plataforma (veja :func:`open`). Como o UTF-8 é o padrão mais moderno, " "``encoding=\"utf-8\"`` é recomendado a não ser que você precise utilizar uma " "*codificação* diferente. 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:344 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:352 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:358 msgid "" ">>> with open('workfile', encoding=\"utf-8\") 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', encoding=\"utf-8\") 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:365 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:370 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:378 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:382 msgid "" ">>> f.close()\n" ">>> f.read()\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "ValueError: I/O operation on closed file." msgstr "" ">>> f.close()\n" ">>> f.read()\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "ValueError: I/O operation on closed file." #: ../../tutorial/inputoutput.rst:392 msgid "Methods of File Objects" msgstr "Métodos de objetos arquivo" #: ../../tutorial/inputoutput.rst:394 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:397 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:406 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:411 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:418 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:425 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:428 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:434 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:437 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:440 msgid "" ">>> f.write('This is a test\\n')\n" "15" msgstr "" ">>> f.write('Este é um teste\\n')\n" "15" #: ../../tutorial/inputoutput.rst:443 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:446 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:451 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:455 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:462 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:474 msgid "" "In text files (those opened without a ``b`` in the mode string), only seeks " "relative to the beginning of the file are allowed (the exception being " "seeking to the very file end with ``seek(0, 2)``) and the only valid " "*offset* values are those returned from the ``f.tell()``, or zero. Any other " "*offset* value produces undefined behaviour." msgstr "" "Em arquivos texto (abertos sem um ``b``, em modo string), somente *seeks* " "relativos ao início do arquivo serão permitidos (exceto se for indicado o " "final do arquivo, com ``seek(0, 2)``) e o único valor válido para *offset* " "são aqueles retornados por chamada à ``f.tell()``, ou zero. Qualquer outro " "valor para *offset* produz um comportamento indefinido." #: ../../tutorial/inputoutput.rst:480 msgid "" "File objects have some additional methods, such as :meth:`~io.IOBase.isatty` " "and :meth:`~io.IOBase.truncate` which are less frequently used; consult the " "Library Reference for a complete guide to file objects." msgstr "" "Objetos arquivo tem alguns métodos adicionais, como :meth:`~io.IOBase." "isatty` e :meth:`~io.IOBase.truncate` que não são usados com frequência; " "consulte a Biblioteca de Referência para um guia completo de objetos arquivo." #: ../../tutorial/inputoutput.rst:488 msgid "Saving structured data with :mod:`json`" msgstr "Gravando dados estruturados com :mod:`json`" #: ../../tutorial/inputoutput.rst:492 msgid "" "Strings can easily be written to and read from a file. Numbers take a bit " "more effort, since the :meth:`~io.TextIOBase.read` method only returns " "strings, which will have to be passed to a function like :func:`int`, which " "takes a string like ``'123'`` and returns its numeric value 123. When you " "want to save more complex data types like nested lists and dictionaries, " "parsing and serializing by hand becomes complicated." msgstr "" "Strings podem ser facilmente gravadas e lidas em um arquivo. Números dão um " "pouco mais de trabalho, já que o método :meth:`~io.TextIOBase.read` só " "retorna strings, que terão que ser passadas para uma função como :func:" "`int`, que pega uma string como ``'123'`` e retorna seu valor numérico 123. " "Quando você deseja salvar tipos de dados mais complexos, como listas e " "dicionários aninhados, a análise e serialização manual tornam-se complicadas." #: ../../tutorial/inputoutput.rst:499 msgid "" "Rather than having users constantly writing and debugging code to save " "complicated data types to files, Python allows you to use the popular data " "interchange format called `JSON (JavaScript Object Notation) `_. The standard module called :mod:`json` can take Python data " "hierarchies, and convert them to string representations; this process is " "called :dfn:`serializing`. Reconstructing the data from the string " "representation is called :dfn:`deserializing`. Between serializing and " "deserializing, the string representing the object may have been stored in a " "file or data, or sent over a network connection to some distant machine." msgstr "" "Ao invés de ter usuários constantemente escrevendo e depurando código para " "gravar tipos complicados de dados em arquivos, o Python permite que se use o " "popular formato de troca de dados chamado `JSON (JavaScript Object Notation) " "`_. O módulo padrão chamado :mod:`json` pode pegar " "hierarquias de dados em Python e convertê-las em representações de strings; " "esse processo é chamado :dfn:`serialização`. Reconstruir os dados " "estruturados da representação string é chamado :dfn:`desserialização`. Entre " "serializar e desserializar, a string que representa o objeto pode ser " "armazenada em um arquivo, ou estrutura de dados, ou enviada por uma conexão " "de rede para alguma outra máquina." #: ../../tutorial/inputoutput.rst:510 msgid "" "The JSON format is commonly used by modern applications to allow for data " "exchange. Many programmers are already familiar with it, which makes it a " "good choice for interoperability." msgstr "" "O formato JSON é comumente usado por aplicativos modernos para permitir " "troca de dados. Pessoas que programam já estão familiarizadas com esse " "formato, o que o torna uma boa opção para interoperabilidade." #: ../../tutorial/inputoutput.rst:514 msgid "" "If you have an object ``x``, you can view its JSON string representation " "with a simple line of code::" msgstr "" "Um objeto ``x``, pode ser visualizado na sua representação JSON com uma " "simples linha de código::" #: ../../tutorial/inputoutput.rst:517 msgid "" ">>> import json\n" ">>> x = [1, 'simple', 'list']\n" ">>> json.dumps(x)\n" "'[1, \"simple\", \"list\"]'" msgstr "" ">>> import json\n" ">>> x = [1, 'lista', 'simples']\n" ">>> json.dumps(x)\n" "'[1, \"lista\", \"simples\"]'" #: ../../tutorial/inputoutput.rst:522 msgid "" "Another variant of the :func:`~json.dumps` function, called :func:`~json." "dump`, simply serializes the object to a :term:`text file`. So if ``f`` is " "a :term:`text file` object opened for writing, we can do this::" msgstr "" "Outra variação da função :func:`~json.dumps`, chamada :func:`~json.dump`, " "serializa o objeto para um :term:`arquivo texto`. Se ``f`` é um :term:" "`arquivo texto` aberto para escrita, podemos fazer isto::" #: ../../tutorial/inputoutput.rst:526 msgid "json.dump(x, f)" msgstr "json.dump(x, f)" #: ../../tutorial/inputoutput.rst:528 msgid "" "To decode the object again, if ``f`` is a :term:`binary file` or :term:`text " "file` object which has been opened for reading::" msgstr "" "Para decodificar o objeto novamente, se ``f`` é um objeto :term:`arquivo " "binário` ou :term:`arquivo texto` que foi aberto para leitura::" #: ../../tutorial/inputoutput.rst:531 msgid "x = json.load(f)" msgstr "x = json.load(f)" #: ../../tutorial/inputoutput.rst:534 msgid "" "JSON files must be encoded in UTF-8. Use ``encoding=\"utf-8\"`` when opening " "JSON file as a :term:`text file` for both of reading and writing." msgstr "" "Arquivos JSON devem ser codificados em UTF-8. Use ``encoding=\"utf-8\"`` " "quando abrir um arquivo JSON como um :term:`arquivo texto` tanto para " "leitura quanto para escrita." #: ../../tutorial/inputoutput.rst:537 msgid "" "This simple serialization technique can handle lists and dictionaries, but " "serializing arbitrary class instances in JSON requires a bit of extra " "effort. The reference for the :mod:`json` module contains an explanation of " "this." msgstr "" "Essa técnica de serialização simples pode manipular listas e dicionários, " "mas a serialização de instâncias de classes arbitrárias no JSON requer um " "pouco mais de esforço. A referência para o módulo :mod:`json` contém uma " "explicação disso." #: ../../tutorial/inputoutput.rst:543 msgid ":mod:`pickle` - the pickle module" msgstr "O módulo :mod:`pickle`" #: ../../tutorial/inputoutput.rst:545 msgid "" "Contrary to :ref:`JSON `, *pickle* is a protocol which allows the " "serialization of arbitrarily complex Python objects. As such, it is " "specific to Python and cannot be used to communicate with applications " "written in other languages. It is also insecure by default: deserializing " "pickle data coming from an untrusted source can execute arbitrary code, if " "the data was crafted by a skilled attacker." msgstr "" "Ao contrário do :ref:`JSON `, *pickle* é um protocolo que permite " "a serialização de objetos Python arbitrariamente complexos. Por isso, é " "específico do Python e não pode ser usado para se comunicar com aplicativos " "escritos em outros linguagens. Também é inseguro por padrão: desserializar " "dados de pickle, provenientes de uma fonte não confiável, pode executar " "código arbitrário, se os dados foram criados por um invasor habilidoso." #: ../../tutorial/inputoutput.rst:103 msgid "formatted string literal" msgstr "literal de string formatado" #: ../../tutorial/inputoutput.rst:103 msgid "interpolated string literal" msgstr "literal de string interpolada" #: ../../tutorial/inputoutput.rst:103 msgid "string" msgstr "string" #: ../../tutorial/inputoutput.rst:103 msgid "formatted literal" msgstr "literal formatado" #: ../../tutorial/inputoutput.rst:103 msgid "interpolated literal" msgstr "literal interpolado" #: ../../tutorial/inputoutput.rst:103 msgid "f-string" msgstr "f-string" #: ../../tutorial/inputoutput.rst:103 msgid "fstring" msgstr "fstring" #: ../../tutorial/inputoutput.rst:308 msgid "built-in function" msgstr "função embutida" #: ../../tutorial/inputoutput.rst:308 msgid "open" msgstr "open" #: ../../tutorial/inputoutput.rst:308 msgid "object" msgstr "objeto" #: ../../tutorial/inputoutput.rst:308 msgid "file" msgstr "arquivo" #: ../../tutorial/inputoutput.rst:490 msgid "module" msgstr "módulo" #: ../../tutorial/inputoutput.rst:490 msgid "json" msgstr "json"