# 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: # Rafael Fontenelle , 2021 # Hildeberto Abreu Magalhães , 2021 # Claudio Rogerio Carvalho Filho , 2021 # Adson Rodrigues , 2021 # Adorilson Bezerra , 2021 # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.10\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-06-29 12:56+0000\n" "PO-Revision-Date: 2021-06-28 01:50+0000\n" "Last-Translator: Adorilson Bezerra , 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/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:`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:`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: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." 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." #: ../../tutorial/inputoutput.rst:50 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:55 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:59 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:68 msgid "Some examples::" msgstr "Alguns exemplos:" #: ../../tutorial/inputoutput.rst:91 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:100 msgid "Formatted String Literals" msgstr "Strings literais formatadas" #: ../../tutorial/inputoutput.rst:102 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:107 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:115 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:126 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:136 msgid "" "For a reference on these format specifications, see the reference guide for " "the :ref:`formatspec`." msgstr "" "Para uma referência dessas especificações de formatos, veja o guia de " "referência para :ref:`formatspec`." #: ../../tutorial/inputoutput.rst:142 msgid "The String format() Method" msgstr "O método format()" #: ../../tutorial/inputoutput.rst:144 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:149 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:159 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:166 msgid "Positional and keyword arguments can be arbitrarily combined::" msgstr "Argumentos posicionais e nomeados podem ser combinados à vontade::" #: ../../tutorial/inputoutput.rst:172 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:182 msgid "" "This could also be done by passing the table as keyword arguments with the " "'**' notation. ::" msgstr "" "Isto também pode ser feito passando o dicionário como argumento do método, " "usando a notação `**`::" #: ../../tutorial/inputoutput.rst:189 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:192 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:209 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:214 msgid "Manual String Formatting" msgstr "Formatação manual de string" #: ../../tutorial/inputoutput.rst:216 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:234 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:237 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:246 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:258 msgid "Old string formatting" msgstr "Formatação de strings à moda antiga" #: ../../tutorial/inputoutput.rst:260 msgid "" "The % operator (modulo) can also be used for string formatting. Given " "``'string' % values``, instances of ``%`` in ``string`` 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 " "``'string' % valores``, as instâncias de ``%`` em ``string`` são " "substituídas por zero ou mais elementos de ``valores``. Essa operação é " "conhecida como interpolação de string. Por exemplo::" #: ../../tutorial/inputoutput.rst:269 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:275 msgid "Reading and Writing Files" msgstr "Leitura e escrita de arquivos" #: ../../tutorial/inputoutput.rst:281 msgid "" ":func:`open` returns a :term:`file object`, and is most commonly used with " "two arguments: ``open(filename, mode)``." msgstr "" "A função :func:`open` devolve um :term:`objeto arquivo`, e é frequentemente " "usada com dois argumentos: ``open(nome_do_arquivo, modo)``." #: ../../tutorial/inputoutput.rst:293 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á assumido ``'r'``." #: ../../tutorial/inputoutput.rst:302 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`). ``'b'`` appended to the mode opens the file in :dfn:" "`binary mode`: now the data is read and written in the form of bytes " "objects. This mode should be used for all files that don't contain text." msgstr "" "Normalmente, arquivos são abertos em :dfn:`modo texto`, ou seja, você lê e " "grava strings, de e para o arquivo, numa codificação específica. Se a " "codificação não for especificada, o padrão é dependente da plataforma/" "sistema operacional (consulte :func:`open`). Incluir ``'b'`` ao *modo* abre " "o arquivo em :dfn:`modo binário`: os dados são lidos e escritos na forma de " "bytes. Esse modo deve ser usado para todos os arquivos que não contenham " "texto." #: ../../tutorial/inputoutput.rst:309 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:317 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:330 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:335 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:343 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:357 msgid "Methods of File Objects" msgstr "Métodos de objetos arquivo" #: ../../tutorial/inputoutput.rst:359 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 assumem que um objeto " "arquivo chamado ``f`` já foi criado." #: ../../tutorial/inputoutput.rst:362 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:376 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:390 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:399 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:402 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:408 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:416 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:420 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:439 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:445 msgid "" "File objects have some additional methods, such as :meth:`~file.isatty` and :" "meth:`~file.truncate` which are less frequently used; consult the Library " "Reference for a complete guide to file objects." msgstr "" "Objetos arquivo tem alguns método adicionais, como :meth:`~file.isatty` e :" "meth:`~file.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:453 msgid "Saving structured data with :mod:`json`" msgstr "Gravando dados estruturados com :mod:`json`" #: ../../tutorial/inputoutput.rst:457 msgid "" "Strings can easily be written to and read from a file. Numbers take a bit " "more effort, since the :meth:`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:`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:464 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:475 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:479 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:487 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:493 msgid "" "To decode the object again, if ``f`` is a :term:`text file` object which has " "been opened for reading::" msgstr "" "Para decodificar o objeto novamente, se ``f`` é um objeto :term:`arquivo " "texto` que foi aberto para leitura::" #: ../../tutorial/inputoutput.rst:498 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:504 msgid ":mod:`pickle` - the pickle module" msgstr "O módulo :mod:`pickle`" #: ../../tutorial/inputoutput.rst:506 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."