python-docs-pt-br/tutorial/datastructures.po at 2.7 · python/python-docs-pt-br

867 lines (774 loc) · 40.2 KB
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Translators:
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2017
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:46+0900\n"
"PO-Revision-Date: 2019-09-01 05:18+0000\n"
"Last-Translator: Adorilson Bezerra <adorilson@gmail.com>\n"
"Language-Team: Portuguese (Brazil) (http://www.transifex.com/python-doc/python-27/language/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=2; plural=(n > 1);\n"
#: ../../tutorial/datastructures.rst:5
msgid "Data Structures"
msgstr "Estrutura de Dados"
#: ../../tutorial/datastructures.rst:7
"This chapter describes some things you've learned about already in more "
"detail, and adds some new things as well."
"Esse capítulo descreve algumas coisas que você já aprendeu em detalhes e "
"adiciona algumas coisas novas também."
#: ../../tutorial/datastructures.rst:14
msgid "More on Lists"
msgstr "Mais sobre Listas"
#: ../../tutorial/datastructures.rst:16
"The list data type has some more methods.  Here are all of the methods of "
"list objects:"
"O tipo de dado lista tem ainda mais métodos. Aqui estão apresentados todos "
"os métodos de objetos do tipo lista:"
#: ../../tutorial/datastructures.rst:23
"Add an item to the end of the list; equivalent to ``a[len(a):] = [x]``."
msgstr " Adiciona um item ao fim da lista; equivale a ``a[len(a):] = [x]``."
#: ../../tutorial/datastructures.rst:29
"Extend the list by appending all the items in the given list; equivalent to "
"``a[len(a):] = L``."
" Prolonga a lista, adicionando no fim todos os elementos da lista ``L``\n"
" passada como argumento; equivalente a ``a[len(a):] = L``."
#: ../../tutorial/datastructures.rst:36
"Insert an item at a given position.  The first argument is the index of the "
"element before which to insert, so ``a.insert(0, x)`` inserts at the front "
"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
"Insere um item em uma dada posição. O primeiro argumento é o índice do "
"elemento anterior ao qual você deseja inserir, então ``a.insert(0, x)`` "
"insere um elemento na frente da lista e ``a.insert(len(a), x)`` é "
"equivalente a ``a.append(x)``."
#: ../../tutorial/datastructures.rst:44
"Remove the first item from the list whose value is *x*. It is an error if "
"there is no such item."
"Remove o primeiro item encontrado na lista cujo valor é igual a *x*. Se não "
"existir valor igual, uma exceção ``ValueError`` é levantada."
#: ../../tutorial/datastructures.rst:51
"Remove the item at the given position in the list, and return it.  If no "
"index is specified, ``a.pop()`` removes and returns the last item in the "
"list.  (The square brackets around the *i* in the method signature denote "
"that the parameter is optional, not that you should type square brackets at "
"that position.  You will see this notation frequently in the Python Library "
"Reference.)"
"Remove um item em uma dada posição na lista e o retorna. Se nenhum índice é "
"especificado, ``a.pop()`` remove e retorna o último item da lista. (O "
"colchetes na frente do *i* na demonstração do método indica que o parâmetro "
"é opcional, e não que é necessário escrever estes colchetes ao chamar o "
"método. Você verá este tipo de notação frequentemente na Biblioteca de "
"Referência Python.)"
#: ../../tutorial/datastructures.rst:61
"Return the index in the list of the first item whose value is *x*. It is an "
"error if there is no such item."
" Devolve o índice do primeiro item cujo valor é igual a *x*, gerando "
"``ValueError`` se este valor não existe"
#: ../../tutorial/datastructures.rst:68
msgid "Return the number of times *x* appears in the list."
msgstr "Retorna o número de vezes em que *x* aparece na lista."
#: ../../tutorial/datastructures.rst:74
"Sort the items of the list in place (the arguments can be used for sort "
"customization, see :func:`sorted` for their explanation)."
"Ordena os itens da lista em questão (os argumentos podem ser usados para "
"customizar a ordenação, veja a função :func:`sorted` para maiores "
"explicações)."
#: ../../tutorial/datastructures.rst:81
msgid "Reverse the elements of the list, in place."
" Inverte a ordem dos elementos na lista *in place* (sem gerar uma nova "
#: ../../tutorial/datastructures.rst:83
msgid "An example that uses most of the list methods::"
msgstr "Um exemplo que usa a maior parte dos métodos das listas::"
#: ../../tutorial/datastructures.rst:108
"You might have noticed that methods like ``insert``, ``remove`` or ``sort`` "
"that only modify the list have no return value printed -- they return the "
"default ``None``.  This is a design principle for all mutable data "
"structures in Python."
"Talvez tenhas observado que métodos como ``insert``, ``remove`` ou ``sort`` que modificam apenas a lista não têm nenhum valor de retorno impresso (que pode ser enviado para a saída padrão) - eles retornam simplesmente o valor ``None`` padrão. Isso foi definido como um princípio de design e utilizado em todas as estruturas de dados mutáveis em Python.\n"
"(N.d.T. Note que os métodos que alteram a lista, inclusive ``sort`` e\n"
"``reverse``, devolvem ``None`` para lembrar o programador de que modificam a\n"
"própria lista, e não criam uma nova. O único método que altera a lista e\n"
"devolve um valor é o ``pop``)"
#: ../../tutorial/datastructures.rst:117
msgid "Using Lists as Stacks"
msgstr "Usando listas como pilhas"
#: ../../tutorial/datastructures.rst:122
"The list methods make it very easy to use a list as a stack, where the last "
"element added is the first element retrieved (\"last-in, first-out\").  To "
"add an item to the top of the stack, use :meth:`append`.  To retrieve an "
"item from the top of the stack, use :meth:`pop` without an explicit index.  "
"For example::"
"Os métodos de lista tornam muito fácil utilizar listas como pilhas, onde o "
"item adicionado por último é o primeiro a ser recuperado (política “último a"
" entrar, primeiro a sair”). Para adicionar um item ao topo da pilha, use "
":meth:`append`. Para recuperar um item do topo da pilha use :meth:`pop` sem "
"nenhum índice. Por exemplo::"
#: ../../tutorial/datastructures.rst:147
msgid "Using Lists as Queues"
msgstr "Usando listas como filas"
#: ../../tutorial/datastructures.rst:151
"It is also possible to use a list as a queue, where the first element added "
"is the first element retrieved (\"first-in, first-out\"); however, lists are"
" not efficient for this purpose.  While appends and pops from the end of "
"list are fast, doing inserts or pops from the beginning of a list is slow "
"(because all of the other elements have to be shifted by one)."
"Você também pode usar uma lista como uma fila, onde o primeiro item "
"adicionado é o primeiro a ser recuperado (política “primeiro a entrar, "
"primeiro a sair”); porém, listas não são eficientes para esta finalidade. "
"Embora *appends* e *pops* no final da lista sejam rápidos, fazer *inserts* "
"ou *pops* no início da lista é lento (porque todos os demais elementos têm "
"que ser deslocados)."
#: ../../tutorial/datastructures.rst:157
"To implement a queue, use :class:`collections.deque` which was designed to "
"have fast appends and pops from both ends.  For example::"
"Para implementar uma fila, use a classe :class:`collections.deque` que foi\n"
"projetada para permitir *appends* e *pops* eficientes nas duas extremidades.\n"
"Por exemplo::"
#: ../../tutorial/datastructures.rst:175
msgid "Functional Programming Tools"
msgstr "Ferramentas de programação funcional"
#: ../../tutorial/datastructures.rst:177
"There are three built-in functions that are very useful when used with "
"lists: :func:`filter`, :func:`map`, and :func:`reduce`."
"Existem três funções embutidas que são muito úteis para processar listas: "
":func:`filter`, :func:`map`, e :func:`reduce`."
#: ../../tutorial/datastructures.rst:180
"``filter(function, sequence)`` returns a sequence consisting of those items "
"from the sequence for which ``function(item)`` is true. If *sequence* is a "
":class:`str`, :class:`unicode` or :class:`tuple`, the result will be of the "
"same type; otherwise, it is always a :class:`list`.  For example, to compute"
" a sequence of numbers divisible by 3 or 5::"
"``filter(funcao, sequencia)`` devolve uma nova sequência formada pelos itens do\n"
"segundo argumento para os quais ``funcao(item)`` é verdadeiro. Se a sequencia\n"
"de entrada for string ou tupla, a saída será do mesmo tipo; caso contrário, o\n"
"resultado será sempre uma lista. Por exemplo, para computar uma sequência de\n"
"números não divisíveis por 2 ou 3::"
#: ../../tutorial/datastructures.rst:191
"``map(function, sequence)`` calls ``function(item)`` for each of the "
"sequence's items and returns a list of the return values.  For example, to "
"compute some cubes::"
"``map(funcao, sequencia)`` aplica ``funcao(item)`` a cada item da sequência e\n"
"devolve uma lista formada pelo resultado de cada aplicação. Por exemplo, para\n"
"computar cubos::"
#: ../../tutorial/datastructures.rst:200
"More than one sequence may be passed; the function must then have as many "
"arguments as there are sequences and is called with the corresponding item "
"from each sequence (or ``None`` if some sequence is shorter than another).  "
"For example::"
"Mais de uma sequência pode ser passada; a função a ser aplicada deve aceitar\n"
"tantos argumentos quantas sequências forem passadas, e é invocada com o item\n"
"correspondente de cada sequência (ou ``None``, se alguma sequência for menor\n"
"que outra). Por exemplo::"
#: ../../tutorial/datastructures.rst:211
"``reduce(function, sequence)`` returns a single value constructed by calling"
" the binary function *function* on the first two items of the sequence, then"
" on the result and the next item, and so on.  For example, to compute the "
"sum of the numbers 1 through 10::"
"A função ``reduce(funcao, sequencia)`` devolve um único valor construído a\n"
"partir da sucessiva aplicação da função binária (N.d.T. que recebe dois\n"
"argumentos) a todos os elementos da lista fornecida, começando pelos dois\n"
"primeiros itens, depois aplicando a função ao primeiro resultado obtido e ao\n"
"próximo item, e assim por diante. Por exemplo, para computar a soma dos\n"
"inteiros de 1 a 10::"
#: ../../tutorial/datastructures.rst:221
"If there's only one item in the sequence, its value is returned; if the "
"sequence is empty, an exception is raised."
"Se houver um único elemento na sequência fornecida, seu valor será devolvido.\n"
"Se a sequência estiver vazia, uma exceção será levantada."
#: ../../tutorial/datastructures.rst:224
"A third argument can be passed to indicate the starting value.  In this case"
" the starting value is returned for an empty sequence, and the function is "
"first applied to the starting value and the first sequence item, then to the"
" result and the next item, and so on.  For example, ::"
"Um terceiro argumento pode ser passado para definir o valor inicial. Neste\n"
"caso, redução de uma sequência vazia devolve o valor inicial. Do contrário, a\n"
"redução se inicia aplicando a função ao valor inicial e ao primeiro elemento\n"
"da sequência, e continuando a partir daí. ::"
#: ../../tutorial/datastructures.rst:238
"Don't use this example's definition of :func:`sum`: since summing numbers is"
" such a common need, a built-in function ``sum(sequence)`` is already "
"provided, and works exactly like this."
"Não use a função ``somatória`` deste exemplo; somar sequências de números é uma\n"
"necessidade comum, e para isso Python tem a função embutida :func:`sum`, que\n"
"faz exatamente isto, e também aceita um valor inicial (opcional)."
#: ../../tutorial/datastructures.rst:245
msgid "List Comprehensions"
msgstr "Compreensões de lista"
#: ../../tutorial/datastructures.rst:247
"List comprehensions provide a concise way to create lists. Common "
"applications are to make new lists where each element is the result of some "
"operations applied to each member of another sequence or iterable, or to "
"create a subsequence of those elements that satisfy a certain condition."
"Uma *list comprehension* é uma maneira concisa de construir uma lista "
"preenchida. (N.d.T. literalmente, *abrangência de lista* mas no Brasil o "
"termo em inglês é muito usado; também se usa a abreviação *listcomp*)"
#: ../../tutorial/datastructures.rst:252
msgid "For example, assume we want to create a list of squares, like::"
"Por exemplo, suponha que queremos criar uma lista de quadrados, assim::"
#: ../../tutorial/datastructures.rst:261
msgid "We can obtain the same result with::"
msgstr "Podemos obter o mesmo resultado desta forma::"
#: ../../tutorial/datastructures.rst:265
"This is also equivalent to ``squares = map(lambda x: x**2, range(10))``, but"
" it's more concise and readable."
"Isso equivale a ``quadrados = map(lambda x: x**2, range(10))``, mas é mais\n"
"conciso e legível."
#: ../../tutorial/datastructures.rst:268
"A list comprehension consists of brackets containing an expression followed "
"by a :keyword:`for` clause, then zero or more :keyword:`for` or "
":keyword:`if` clauses.  The result will be a new list resulting from "
"evaluating the expression in the context of the :keyword:`for` and "
":keyword:`if` clauses which follow it. For example, this listcomp combines "
"the elements of two lists if they are not equal::"
"Uma abrangência de lista é formada por um par de colchetes contendo uma\n"
"expressão seguida de uma cláusula :keyword:`for`, e então zero ou mais\n"
"cláusulas :keyword:`for` ou :keyword:`if`. O resultado será uma lista\n"
"resultante da avaliação da expressão no contexto das cláusulas :keyword:`for`\n"
"e :keyword:`if`."
#: ../../tutorial/datastructures.rst:278
msgid "and it's equivalent to:"
msgstr "e isso é equivalente a:"
#: ../../tutorial/datastructures.rst:289
"Note how the order of the :keyword:`for` and :keyword:`if` statements is the"
" same in both these snippets."
"Uma abrangência de lista é formada por um par de colchetes contendo uma\n"
"expressão seguida de uma cláusula :keyword:`for`, e então zero ou mais\n"
"cláusulas :keyword:`for` ou :keyword:`if`. O resultado será uma lista\n"
"resultante da avaliação da expressão no contexto das cláusulas :keyword:`for`\n"
"e :keyword:`if`."
#: ../../tutorial/datastructures.rst:292
"If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), "
"it must be parenthesized. ::"
"Se a expressão é uma tupla, ela deve ser inserida entre parênteses (ex., "
"``(x, y)`` no exemplo anterior). ::"
#: ../../tutorial/datastructures.rst:323
"List comprehensions can contain complex expressions and nested functions::"
"List comprehensions podem conter expressões complexas e funções aninhadas::"
#: ../../tutorial/datastructures.rst:331
msgid "Nested List Comprehensions"
msgstr "List Comprehensions aninhadas"
#: ../../tutorial/datastructures.rst:333
"The initial expression in a list comprehension can be any arbitrary "
"expression, including another list comprehension."
"A expressão inicial em uma list comprehension pode ser qualquer expressão "
"arbitrária, incluindo outra list comprehension."
#: ../../tutorial/datastructures.rst:336
"Consider the following example of a 3x4 matrix implemented as a list of 3 "
"lists of length 4::"
"Considere o exemplo seguinte de uma matriz 3x4 implementada com uma lista de"
" 3 listas de tamanho 4::"
#: ../../tutorial/datastructures.rst:345
msgid "The following list comprehension will transpose rows and columns::"
msgstr "A abrangência de listas abaixo transpõe as linhas e colunas::"
#: ../../tutorial/datastructures.rst:350
"As we saw in the previous section, the nested listcomp is evaluated in the "
"context of the :keyword:`for` that follows it, so this example is equivalent"
"Como vimos na seção anterior, a listcomp aninhada é computada no contexto\n"
"da cláusula :keyword:`for` seguinte, portanto o exemplo acima equivale a::"
#: ../../tutorial/datastructures.rst:361
msgid "which, in turn, is the same as::"
msgstr "e isso, por sua vez, faz o mesmo que isto::"
#: ../../tutorial/datastructures.rst:375
"In the real world, you should prefer built-in functions to complex flow "
"statements. The :func:`zip` function would do a great job for this use "
"Na prática, você deve dar preferência a funções embutidas em vez de expressões\n"
"complexas. A função :func:`zip` resolve muito bem este caso de uso::"
#: ../../tutorial/datastructures.rst:381
"See :ref:`tut-unpacking-arguments` for details on the asterisk in this line."
"Veja :ref:`tut-unpacking-arguments` para entender o uso do asterisco neste "
#: ../../tutorial/datastructures.rst:386
msgid "The :keyword:`del` statement"
msgstr "O comando :keyword:`del`"
#: ../../tutorial/datastructures.rst:388
"There is a way to remove an item from a list given its index instead of its "
"value: the :keyword:`del` statement.  This differs from the :meth:`pop` "
"method which returns a value.  The :keyword:`del` statement can also be used"
" to remove slices from a list or clear the entire list (which we did earlier"
" by assignment of an empty list to the slice).  For example::"
"Existe uma maneira de remover um item de uma lista conhecendo seu índice, ao\n"
"invés de seu valor: o comando :keyword:`del`. Ele difere do método\n"
":meth:`list.pop`, que devolve o item removido. O comando :keyword:`del` também\n"
"pode ser utilizado para remover fatias (slices) da lista, ou mesmo limpar a\n"
"lista toda (que fizemos antes atribuindo uma lista vazia à fatia ``a[:]``). Por\n"
"exemplo::"
#: ../../tutorial/datastructures.rst:405
msgid ":keyword:`del` can also be used to delete entire variables::"
":keyword:`del` também pode ser usado para remover totalmente uma variável::"
#: ../../tutorial/datastructures.rst:409
"Referencing the name ``a`` hereafter is an error (at least until another "
"value is assigned to it).  We'll find other uses for :keyword:`del` later."
"Referenciar a variável ``a`` depois de sua remoção constitui erro (pelo menos\n"
"até que seja feita uma nova atribuição para ela). Encontraremos outros\n"
"usos para o comando :keyword:`del` mais tarde."
#: ../../tutorial/datastructures.rst:416
msgid "Tuples and Sequences"
msgstr "Tuplas e Sequências"
#: ../../tutorial/datastructures.rst:418
"We saw that lists and strings have many common properties, such as indexing "
"and slicing operations.  They are two examples of *sequence* data types (see"
" :ref:`typesseq`).  Since Python is an evolving language, other sequence "
"data types may be added.  There is also another standard sequence data type:"
" the *tuple*."
"Vimos que listas e strings têm muitas propriedades em comum, como indexação e\n"
"operações de fatiamento (*slicing*). Elas são dois exemplos de *sequências*\n"
"(veja :ref:`typesseq`). Como Python é uma linguagem em evolução, outros tipos\n"
"de sequências podem ser adicionados. Existe ainda um outro tipo de sequência\n"
"padrão na linguagem: a tupla (*tuple*)."
#: ../../tutorial/datastructures.rst:424
"A tuple consists of a number of values separated by commas, for instance::"
"Uma tupla consiste em uma sequência de valores separados por vírgulas::"
#: ../../tutorial/datastructures.rst:446
"As you see, on output tuples are always enclosed in parentheses, so that "
"nested tuples are interpreted correctly; they may be input with or without "
"surrounding parentheses, although often parentheses are necessary anyway (if"
" the tuple is part of a larger expression).  It is not possible to assign to"
" the individual items of a tuple, however it is possible to create tuples "
"which contain mutable objects, such as lists."
"Como você pode ver no trecho acima, na saída do console as tuplas são sempre\n"
"envolvidas por parênteses, assim tuplas aninhadas podem ser lidas\n"
"corretamente. Na criação, tuplas podem ser envolvidas ou não por parênteses,\n"
"desde que o contexto não exija os parênteses (como no caso da tupla dentro\n"
"a uma expressão maior)."
#: ../../tutorial/datastructures.rst:453
"Though tuples may seem similar to lists, they are often used in different "
"situations and for different purposes. Tuples are :term:`immutable`, and "
"usually contain a heterogeneous sequence of elements that are accessed via "
"unpacking (see later in this section) or indexing (or even by attribute in "
"the case of :func:`namedtuples <collections.namedtuple>`). Lists are "
":term:`mutable`, and their elements are usually homogeneous and are accessed"
" by iterating over the list."
"Tuplas podem ser usadas de diversas formas: pares ordenados ``(x, y)``,\n"
"registros de funcionário extraídos uma base de dados, etc. Tuplas, assim como\n"
"strings, são imutáveis: não é possível atribuir valores a itens individuais de\n"
"uma tupla (você pode simular o mesmo efeito através de operações de fatiamento\n"
"e concatenação; N.d.T. mas neste caso nunca estará modificando tuplas, apenas\n"
"criando novas). Também é possível criar tuplas contendo objetos mutáveis,\n"
"como listas."
#: ../../tutorial/datastructures.rst:461
"A special problem is the construction of tuples containing 0 or 1 items: the"
" syntax has some extra quirks to accommodate these.  Empty tuples are "
"constructed by an empty pair of parentheses; a tuple with one item is "
"constructed by following a value with a comma (it is not sufficient to "
"enclose a single value in parentheses). Ugly, but effective.  For example::"
"Um problema especial é a criação de tuplas contendo 0 ou 1 itens: a sintaxe\n"
"usa certos truques para acomodar estes casos. Tuplas vazias são construídas\n"
"por uma par de parênteses vazios; uma tupla unitária é construída por um\n"
"único valor e uma vírgula entre parênteses (não basta colocar um único valor\n"
"entre parênteses). Feio, mas funciona::"
#: ../../tutorial/datastructures.rst:476
"The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple "
"packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "
"together in a tuple. The reverse operation is also possible::"
"O comando ``t = 12345, 54321, 'hello!'`` é um exemplo de *empacotamento de\n"
"tupla* (*tuple packing*): os valores ``12345``, ``54321`` e ``'bom dia!'`` são\n"
"empacotados juntos em uma tupla. A operação inversa também é possível::"
#: ../../tutorial/datastructures.rst:482
"This is called, appropriately enough, *sequence unpacking* and works for any"
" sequence on the right-hand side.  Sequence unpacking requires the list of "
"variables on the left to have the same number of elements as the length of "
"the sequence.  Note that multiple assignment is really just a combination of"
" tuple packing and sequence unpacking."
"Isto é chamado de desempacotamento de sequência (*sequence unpacking*), funciona\n"
"para qualquer tipo de sequência do lado direito. Para funcionar, é necessário\n"
"que a lista de variáveis do lado esquerdo tenha o mesmo comprimento da\n"
"sequência à direita. Sendo assim, a atribuição múltipla é um caso de\n"
"empacotamento de tupla e desempacotamento de sequência::"
#: ../../tutorial/datastructures.rst:492
msgid "Sets"
msgstr "Sets (conjuntos)"
#: ../../tutorial/datastructures.rst:494
"Python also includes a data type for *sets*.  A set is an unordered "
"collection with no duplicate elements.  Basic uses include membership "
"testing and eliminating duplicate entries.  Set objects also support "
"mathematical operations like union, intersection, difference, and symmetric "
"difference."
"Python também inclui um tipo de dados para conjuntos, chamado ``set``. Um\n"
"conjunto é uma coleção desordenada de elementos, sem elementos repetidos. Usos\n"
"comuns para sets incluem a verificação eficiente da existência de objetos e a\n"
"eliminação de itens duplicados. Conjuntos também suportam operações\n"
"matemáticas como união, interseção, diferença e diferença simétrica."
#: ../../tutorial/datastructures.rst:499
"Curly braces or the :func:`set` function can be used to create sets.  Note: "
"to create an empty set you have to use ``set()``, not ``{}``; the latter "
"creates an empty dictionary, a data structure that we discuss in the next "
"Chaves ou a função :func:`set` podem ser usados para criar conjuntos. Note: "
"para criar um conjunto vazio você precisa usar ``set()``, não ``{}``; este "
"último cria um dicionário vazio, uma estrutura de dados que discutiremos na "
"próxima seção."
#: ../../tutorial/datastructures.rst:503
msgid "Here is a brief demonstration::"
msgstr "Uma pequena demonstração:"
#: ../../tutorial/datastructures.rst:529
"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
"are also supported::"
"Da mesma forma que :ref:`list comprehensions <tut-listcomps>`, set "
"comprehensions também são suportadas::"
#: ../../tutorial/datastructures.rst:540
msgid "Dictionaries"
msgstr "Dicionários"
#: ../../tutorial/datastructures.rst:542
"Another useful data type built into Python is the *dictionary* (see "
":ref:`typesmapping`). Dictionaries are sometimes found in other languages as"
" \"associative memories\" or \"associative arrays\".  Unlike sequences, "
"which are indexed by a range of numbers, dictionaries are indexed by *keys*,"
" which can be any immutable type; strings and numbers can always be keys.  "
"Tuples can be used as keys if they contain only strings, numbers, or tuples;"
" if a tuple contains any mutable object either directly or indirectly, it "
"cannot be used as a key. You can't use lists as keys, since lists can be "
"modified in place using index assignments, slice assignments, or methods "
"like :meth:`append` and :meth:`extend`."
"Outra estrutura de dados muito útil embutida em Python é o *dicionário*, cujo\n"
"tipo é ``dict`` (ver :ref:`typesmapping`). Dicionários são também chamados de\n"
"“memória associativa” ou “vetor associativo” em outras linguagens. Diferente\n"
"de sequências que são indexadas por inteiros, dicionários são indexados por\n"
"chaves (*keys*), que podem ser de qualquer tipo imutável (como strings e\n"
"inteiros). Tuplas também podem ser chaves se contiverem apenas strings,\n"
"inteiros ou outras tuplas. Se a tupla contiver, direta ou indiretamente,\n"
"qualquer valor mutável, não poderá ser chave. Listas não podem ser usadas como\n"
"chaves porque podem ser modificadas *in place* pela atribuição em índices ou\n"
"fatias, e por métodos como :meth:`append` e :meth:`extend`."
#: ../../tutorial/datastructures.rst:553
"It is best to think of a dictionary as an unordered set of *key: value* "
"pairs, with the requirement that the keys are unique (within one "
"dictionary). A pair of braces creates an empty dictionary: ``{}``. Placing a"
" comma-separated list of key:value pairs within the braces adds initial "
"key:value pairs to the dictionary; this is also the way dictionaries are "
"written on output."
"Um bom modelo mental é imaginar um dicionário como um conjunto não ordenado de\n"
"pares chave-valor, onde as chaves são únicas em uma dada instância do\n"
"dicionário. Dicionários são delimitados por chaves: ``{}``, e contém uma lista\n"
"de pares *chave:valor* separada por vírgulas. Dessa forma também será exibido\n"
"o conteúdo de um dicionário no console do Python. O dicionário vazio é ``{}``."
#: ../../tutorial/datastructures.rst:559
"The main operations on a dictionary are storing a value with some key and "
"extracting the value given the key.  It is also possible to delete a "
"key:value pair with ``del``. If you store using a key that is already in "
"use, the old value associated with that key is forgotten.  It is an error to"
" extract a value using a non-existent key."
"As principais operações em um dicionário são armazenar e recuperar valores a\n"
"partir de chaves. Também é possível remover um par *chave:valor* com o comando\n"
"``del``. Se você armazenar um valor utilizando uma chave já presente, o antigo\n"
"valor será substituído pelo novo. Se tentar recuperar um valor usando uma chave\n"
"inexistente, será gerado um erro."
#: ../../tutorial/datastructures.rst:565
"The :meth:`keys` method of a dictionary object returns a list of all the "
"keys used in the dictionary, in arbitrary order (if you want it sorted, just"
" apply the :func:`sorted` function to it).  To check whether a single key is"
" in the dictionary, use the :keyword:`in` keyword."
"O método :meth:`keys` do dicionário devolve a lista de todas as chaves\n"
"presentes no dicionário, em ordem arbitrária (se desejar ordená-las basta\n"
"aplicar o a função :func:`sorted` à lista devolvida). Para verificar a\n"
"existência de uma chave, use o operador :keyword:`in`."
#: ../../tutorial/datastructures.rst:570
msgid "Here is a small example using a dictionary::"
msgstr "A seguir, um exemplo de uso do dicionário:"
#: ../../tutorial/datastructures.rst:587
"The :func:`dict` constructor builds dictionaries directly from sequences of "
"key-value pairs::"
"O construtor :func:`dict` produz dicionários diretamente a partir de uma "
"lista de chaves-valores, armazenadas como duplas (tuplas de 2 elementos). "
"Quando os pares formam um padrão, uma list comprehensions pode especificar a"
" lista de chaves-valores de forma mais compacta. ::"
#: ../../tutorial/datastructures.rst:593
"In addition, dict comprehensions can be used to create dictionaries from "
"arbitrary key and value expressions::"
"Além disso, os dict comprehensions podem ser usadas para criar dicionários a"
" partir de expressões arbitrárias de chave e valor::"
#: ../../tutorial/datastructures.rst:599
"When the keys are simple strings, it is sometimes easier to specify pairs "
"using keyword arguments::"
"Quando chaves são strings simples, é mais fácil especificar os pares usando\n"
"argumentos nomeados no construtor:"
#: ../../tutorial/datastructures.rst:609
msgid "Looping Techniques"
msgstr "Técnicas de Iteração"
#: ../../tutorial/datastructures.rst:611
"When looping through a sequence, the position index and corresponding value "
"can be retrieved at the same time using the :func:`enumerate` function. ::"
"Ao percorrer um dicionário em um laço, a variável de iteração receberá uma "
"chave de cada vez::"
#: ../../tutorial/datastructures.rst:621
"To loop over two or more sequences at the same time, the entries can be "
"paired with the :func:`zip` function. ::"
"Para percorrer duas ou mais sequências simultaneamente com o laço, os itens\n"
"podem ser agrupados com a função :func:`zip`. ::"
#: ../../tutorial/datastructures.rst:633
"To loop over a sequence in reverse, first specify the sequence in a forward "
"direction and then call the :func:`reversed` function. ::"
"Para percorrer uma sequência em ordem inversa, chame a função "
":func:`reversed` com a sequência na ordem original. ::"
#: ../../tutorial/datastructures.rst:645
"To loop over a sequence in sorted order, use the :func:`sorted` function "
"which returns a new sorted list while leaving the source unaltered. ::"
"Para percorrer uma sequência de maneira ordenada, use a função :func:`sorted`,\n"
"que retorna uma lista ordenada com os itens, mantendo a sequência original\n"
"inalterada. ::"
#: ../../tutorial/datastructures.rst:657
"When looping through dictionaries, the key and corresponding value can be "
"retrieved at the same time using the :meth:`iteritems` method. ::"
#: ../../tutorial/datastructures.rst:667
"It is sometimes tempting to change a list while you are looping over it; "
"however, it is often simpler and safer to create a new list instead. ::"
"Às vezes é tentador alterar uma lista enquanto você itera sobre ela; porém, "
"costuma ser mais simples e seguro criar uma nova lista. ::"
#: ../../tutorial/datastructures.rst:684
msgid "More on Conditions"
msgstr "Mais sobre condições"
#: ../../tutorial/datastructures.rst:686
"The conditions used in ``while`` and ``if`` statements can contain any "
"operators, not just comparisons."
"As condições de controle usadas em ``while`` e ``if`` podem conter quaisquer"
" operadores, não apenas comparações."
#: ../../tutorial/datastructures.rst:689
"The comparison operators ``in`` and ``not in`` check whether a value occurs "
"(does not occur) in a sequence.  The operators ``is`` and ``is not`` compare"
" whether two objects are really the same object; this only matters for "
"mutable objects like lists.  All comparison operators have the same "
"priority, which is lower than that of all numerical operators."
"Os operadores de comparação ``in`` e ``not in`` verificam se um valor ocorre\n"
"(ou não ocorre) em uma dada sequência. Os operadores ``is`` e ``is not``\n"
"comparam se dois objetos são na verdade o mesmo objeto; isto só é relevante no\n"
"contexto de objetos mutáveis, como listas. Todos os operadores de comparação\n"
"possuem a mesma precedência, que é menor do que a prioridade de todos os\n"
"operadores numéricos."
#: ../../tutorial/datastructures.rst:695
"Comparisons can be chained.  For example, ``a < b == c`` tests whether ``a``"
" is less than ``b`` and moreover ``b`` equals ``c``."
"Comparações podem ser encadeadas: Por exemplo ``a < b == c`` testa se ``a`` é menor\n"
"que ``b`` e também se ``b`` é igual a ``c``."
#: ../../tutorial/datastructures.rst:698
"Comparisons may be combined using the Boolean operators ``and`` and ``or``, "
"and the outcome of a comparison (or of any other Boolean expression) may be "
"negated with ``not``.  These have lower priorities than comparison "
"operators; between them, ``not`` has the highest priority and ``or`` the "
"lowest, so that ``A and not B or C`` is equivalent to ``(A and (not B)) or "
"C``. As always, parentheses can be used to express the desired composition."
"Comparações podem ser combinadas através de operadores booleanos ``and`` e\n"
"``or``, e o resultado de uma comparação (ou de qualquer outra expressão), pode\n"
"ter seu valor booleano negado através de ``not``. Estes possuem menor\n"
"prioridade que os demais operadores de comparação. Entre eles, ``not`` é o de\n"
"maior prioridade e ``or`` o de menor. Dessa forma, a condição ``A and not B or\n"
"C`` é equivalente a ``(A and (not B)) or C``. Naturalmente, parênteses podem\n"
"ser usados para expressar o agrupamento desejado."
#: ../../tutorial/datastructures.rst:705
"The Boolean operators ``and`` and ``or`` are so-called *short-circuit* "
"operators: their arguments are evaluated from left to right, and evaluation "
"stops as soon as the outcome is determined.  For example, if ``A`` and ``C``"
" are true but ``B`` is false, ``A and B and C`` does not evaluate the "
"expression ``C``.  When used as a general value and not as a Boolean, the "
"return value of a short-circuit operator is the last evaluated argument."
"Os operadores booleanos ``and`` e ``or`` são operadores *short-circuit*: seus\n"
"argumentos são avaliados da esquerda para a direita, e a avaliação para quando\n"
"o resultado é determinado. Por exemplo, se ``A`` e ``C`` são expressões\n"
"verdadeiras, mas ``B`` é falsa, então ``A and B and C`` não chega a avaliar a\n"
"expressão ``C``. Em geral, quando usado sobre valores genéricos e não\n"
"como booleanos, o valor do resultado de um operador atalho é o último valor\n"
"avaliado na expressão."
#: ../../tutorial/datastructures.rst:712
"It is possible to assign the result of a comparison or other Boolean "
"expression to a variable.  For example, ::"
"É possível atribuir o resultado de uma comparação ou outra expressão booleana\n"
"para uma variável. Por exemplo::"
#: ../../tutorial/datastructures.rst:720
"Note that in Python, unlike C, assignment cannot occur inside expressions. C"
" programmers may grumble about this, but it avoids a common class of "
"problems encountered in C programs: typing ``=`` in an expression when "
"``==`` was intended."
"Observe que em Python, diferente de C, atribuição não pode ocorrer dentro\n"
"de uma expressão. Programadores C podem resmungar, mas isso evita toda uma\n"
"classe de problemas frequentemente encontrados em programas C: digitar ``=``\n"
"numa expressão quando a intenção era ``==``."
#: ../../tutorial/datastructures.rst:729
msgid "Comparing Sequences and Other Types"
msgstr "Comparando sequências e outros tipos"
#: ../../tutorial/datastructures.rst:731
"Sequence objects may be compared to other objects with the same sequence "
"type. The comparison uses *lexicographical* ordering: first the first two "
"items are compared, and if they differ this determines the outcome of the "
"comparison; if they are equal, the next two items are compared, and so on, "
"until either sequence is exhausted. If two items to be compared are "
"themselves sequences of the same type, the lexicographical comparison is "
"carried out recursively.  If all items of two sequences compare equal, the "
"sequences are considered equal. If one sequence is an initial sub-sequence "
"of the other, the shorter sequence is the smaller (lesser) one.  "
"Lexicographical ordering for strings uses the ASCII ordering for individual "
"characters.  Some examples of comparisons between sequences of the same "
"Objetos sequência podem ser comparados com outros objetos sequência, desde que\n"
"o tipo das sequências seja o mesmo. A comparação utiliza a ordem\n"
"*lexicográfica*: primeiramente os dois primeiros itens são comparados, e se\n"
"diferirem isto determinará o resultado da comparação, caso contrário os\n"
"próximos dois itens serão comparados, e assim por diante até que se tenha\n"
"exaurido alguma das sequências. Se em uma comparação de itens, os mesmos forem\n"
"também sequências (aninhadas), então é disparada recursivamente outra\n"
"comparação lexicográfica. Se todos os itens da sequência forem iguais, então\n"
"as sequências são ditas iguais. Se uma das sequências é uma subsequência da\n"
"outra, então a subsequência é a menor. A comparação lexicográfica de strings\n"
"utiliza ASCII para definir a ordenação. Alguns exemplos de comparações entre\n"
"sequências do mesmo tipo::"
#: ../../tutorial/datastructures.rst:751
"Note that comparing objects of different types is legal.  The outcome is "
"deterministic but arbitrary: the types are ordered by their name. Thus, a "
"list is always smaller than a string, a string is always smaller than a "
"tuple, etc. [#]_ Mixed numeric types are compared according to their numeric"
" value, so 0 equals 0.0, etc."
"É permitido comparar objetos de diferentes tipos. O resultado é\n"
"determinístico, porém, arbitrário: os tipos são ordenados pelos seus nomes.\n"
"Então, uma ``list`` é sempre menor do que uma ``str``, uma ``str`` é sempre\n"
"menor do que uma ``tuple``, etc. [#]_ Tipos numéricos misturados são\n"
"comparados de acordo com seus valores numéricos, logo 0 é igual a 0.0, etc."
#: ../../tutorial/datastructures.rst:759
msgid "Footnotes"
msgstr "Notas de Rodapé"
#: ../../tutorial/datastructures.rst:760
"The rules for comparing objects of different types should not be relied "
"upon; they may change in a future version of the language."
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

datastructures.po

Latest commit

History

datastructures.po

File metadata and controls
