# Copyright (C) 2001-2020, Python Software Foundation # This file is distributed under the same license as the Python package. # Maintained by the python-doc-es workteam. # docs-es@python.org / # https://mail.python.org/mailman3/lists/docs-es.python.org/ # Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to # get the list of volunteers # msgid "" msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2026-02-26 18:44-0300\n" "PO-Revision-Date: 2023-11-01 15:13+0100\n" "Last-Translator: Marcos Medrano \n" "Language: es\n" "Language-Team: python-doc-es\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.18.0\n" #: ../Doc/tutorial/datastructures.rst:5 msgid "Data Structures" msgstr "Estructuras de datos" #: ../Doc/tutorial/datastructures.rst:7 msgid "" "This chapter describes some things you've learned about already in more " "detail, and adds some new things as well." msgstr "" "Este capítulo describe en más detalle algunas cosas que ya has aprendido y " "agrega algunas cosas nuevas también." #: ../Doc/tutorial/datastructures.rst:13 msgid "More on Lists" msgstr "Más sobre listas" #: ../Doc/tutorial/datastructures.rst:15 msgid "" "The list data type has some more methods. Here are all of the methods of " "list objects:" msgstr "" "El tipo de dato lista tiene algunos métodos más. Aquí están todos los " "métodos de los objetos lista:" #: ../Doc/tutorial/datastructures.rst:22 #, fuzzy msgid "Add an item to the end of the list. Similar to ``a[len(a):] = [x]``." msgstr "Agrega un ítem al final de la lista. Equivale a ``a[len(a):] = [x]``." #: ../Doc/tutorial/datastructures.rst:28 #, fuzzy msgid "" "Extend the list by appending all the items from the iterable. Similar to " "``a[len(a):] = iterable``." msgstr "" "Extiende la lista agregándole todos los ítems del iterable. Equivale a " "``a[len(a):] = iterable``." #: ../Doc/tutorial/datastructures.rst:35 msgid "" "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)``." msgstr "" "Inserta un ítem en una posición dada. El primer argumento es el índice del " "ítem delante del cual se insertará, por lo tanto ``a.insert(0, x)`` inserta " "al principio de la lista y ``a.insert(len(a), x)`` equivale a ``a." "append(x)``." #: ../Doc/tutorial/datastructures.rst:43 msgid "" "Remove the first item from the list whose value is equal to *x*. It raises " "a :exc:`ValueError` if there is no such item." msgstr "" "Quita el primer ítem de la lista cuyo valor sea *x*. Lanza un :exc:" "`ValueError` si no existe tal ítem." #: ../Doc/tutorial/datastructures.rst:50 #, fuzzy msgid "" "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. It raises an :exc:`IndexError` if the list is empty or the index is " "outside the list range." msgstr "" "Quita el ítem en la posición dada de la lista y lo retorna. Si no se " "especifica un índice, ``a.pop()`` quita y retorna el último elemento de la " "lista. (Los corchetes que encierran a *i* en la firma del método denotan que " "el parámetro es opcional, no que deberías escribir corchetes en esa " "posición. Verás esta notación con frecuencia en la Referencia de la " "Biblioteca de Python.)" #: ../Doc/tutorial/datastructures.rst:59 #, fuzzy msgid "Remove all items from the list. Similar to ``del a[:]``." msgstr "Elimina todos los elementos de la lista. Equivalente a ``del a[:]``." #: ../Doc/tutorial/datastructures.rst:65 #, fuzzy msgid "" "Return zero-based index of the first occurrence of *x* in the list. Raises " "a :exc:`ValueError` if there is no such item." msgstr "" "Retorna el índice basado en cero del primer elemento cuyo valor sea igual a " "*x*. Lanza una excepción :exc:`ValueError` si no existe tal elemento." #: ../Doc/tutorial/datastructures.rst:68 msgid "" "The optional arguments *start* and *end* are interpreted as in the slice " "notation and are used to limit the search to a particular subsequence of the " "list. The returned index is computed relative to the beginning of the full " "sequence rather than the *start* argument." msgstr "" "Los argumentos opcionales *start* y *end* son interpretados como la notación " "de rebanadas y se usan para limitar la búsqueda a un segmento particular de " "la lista. El índice retornado se calcula de manera relativa al inicio de la " "secuencia completa en lugar de hacerlo con respecto al argumento *start*." #: ../Doc/tutorial/datastructures.rst:77 msgid "Return the number of times *x* appears in the list." msgstr "Retorna el número de veces que *x* aparece en la lista." #: ../Doc/tutorial/datastructures.rst:83 msgid "" "Sort the items of the list in place (the arguments can be used for sort " "customization, see :func:`sorted` for their explanation)." msgstr "" "Ordena los elementos de la lista in situ (los argumentos pueden ser usados " "para personalizar el orden de la lista, ver :func:`sorted` para su " "explicación)." #: ../Doc/tutorial/datastructures.rst:90 msgid "Reverse the elements of the list in place." msgstr "Invierte los elementos de la lista in situ." #: ../Doc/tutorial/datastructures.rst:96 #, fuzzy msgid "Return a shallow copy of the list. Similar to ``a[:]``." msgstr "Retorna una copia superficial de la lista. Equivalente a ``a[:]``." #: ../Doc/tutorial/datastructures.rst:99 msgid "An example that uses most of the list methods::" msgstr "Un ejemplo que usa la mayoría de los métodos de la lista::" #: ../Doc/tutorial/datastructures.rst:101 msgid "" ">>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', " "'banana']\n" ">>> fruits.count('apple')\n" "2\n" ">>> fruits.count('tangerine')\n" "0\n" ">>> fruits.index('banana')\n" "3\n" ">>> fruits.index('banana', 4) # Find next banana starting at position 4\n" "6\n" ">>> fruits.reverse()\n" ">>> fruits\n" "['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']\n" ">>> fruits.append('grape')\n" ">>> fruits\n" "['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']\n" ">>> fruits.sort()\n" ">>> fruits\n" "['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']\n" ">>> fruits.pop()\n" "'pear'" msgstr "" #: ../Doc/tutorial/datastructures.rst:122 msgid "" "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." msgstr "" "Quizás hayas notado que métodos como ``insert``, ``remove`` o ``sort`` que " "únicamente modifican la lista no tienen un valor de retorno impreso -- " "retornan el valor por defecto ``None``. [#]_ Esto es un principio de diseño " "para todas las estructuras de datos mutables en Python." #: ../Doc/tutorial/datastructures.rst:127 #, fuzzy msgid "" "Another thing you might notice is that not all data can be sorted or " "compared. For instance, ``[None, 'hello', 10]`` doesn't sort because " "integers can't be compared to strings and ``None`` can't be compared to " "other types. Also, there are some types that don't have a defined ordering " "relation. For example, ``3+4j < 5+7j`` isn't a valid comparison." msgstr "" "Otra cosa que puedes observar es que no todos los datos se pueden ordenar o " "comparar. Por ejemplo, ``[None, 'hello', 10]`` no se puede ordenar ya que " "los enteros no se pueden comparar con strings y *None* no se puede comparar " "con los otros tipos. También hay algunos tipos que no tienen una relación de " "orden definida. Por ejemplo, ``3+4j < 5+7j`` no es una comparación válida." #: ../Doc/tutorial/datastructures.rst:138 msgid "Using Lists as Stacks" msgstr "Usar listas como pilas" #: ../Doc/tutorial/datastructures.rst:143 msgid "" "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:`~list.append`. To retrieve " "an item from the top of the stack, use :meth:`~list.pop` without an explicit " "index. For example::" msgstr "" "Los métodos de lista hacen que resulte muy fácil usar una lista como una " "pila, donde el último elemento añadido es el primer elemento retirado " "(\"último en entrar, primero en salir\"). Para agregar un elemento a la cima " "de la pila, utiliza :meth:`~list.append`. Para retirar un elemento de la " "cima de la pila, utiliza :meth:`~list.pop` sin un índice explícito. Por " "ejemplo:" #: ../Doc/tutorial/datastructures.rst:148 msgid "" ">>> stack = [3, 4, 5]\n" ">>> stack.append(6)\n" ">>> stack.append(7)\n" ">>> stack\n" "[3, 4, 5, 6, 7]\n" ">>> stack.pop()\n" "7\n" ">>> stack\n" "[3, 4, 5, 6]\n" ">>> stack.pop()\n" "6\n" ">>> stack.pop()\n" "5\n" ">>> stack\n" "[3, 4]" msgstr "" #: ../Doc/tutorial/datastructures.rst:168 msgid "Using Lists as Queues" msgstr "Usar listas como colas" #: ../Doc/tutorial/datastructures.rst:172 msgid "" "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)." msgstr "" "También es posible usar una lista como una cola, donde el primer elemento " "añadido es el primer elemento retirado (\"primero en entrar, primero en " "salir\"); sin embargo, las listas no son eficientes para este propósito. " "Agregar y sacar del final de la lista es rápido, pero insertar o sacar del " "comienzo de una lista es lento (porque todos los otros elementos tienen que " "ser desplazados en uno)." #: ../Doc/tutorial/datastructures.rst:178 msgid "" "To implement a queue, use :class:`collections.deque` which was designed to " "have fast appends and pops from both ends. For example::" msgstr "" "Para implementar una cola, utiliza :class:`collections.deque` el cual fue " "diseñado para añadir y quitar de ambas puntas de forma rápida. Por ejemplo::" #: ../Doc/tutorial/datastructures.rst:181 msgid "" ">>> from collections import deque\n" ">>> queue = deque([\"Eric\", \"John\", \"Michael\"])\n" ">>> queue.append(\"Terry\") # Terry arrives\n" ">>> queue.append(\"Graham\") # Graham arrives\n" ">>> queue.popleft() # The first to arrive now leaves\n" "'Eric'\n" ">>> queue.popleft() # The second to arrive now leaves\n" "'John'\n" ">>> queue # Remaining queue in order of arrival\n" "deque(['Michael', 'Terry', 'Graham'])" msgstr "" #: ../Doc/tutorial/datastructures.rst:196 msgid "List Comprehensions" msgstr "Comprensión de listas" #: ../Doc/tutorial/datastructures.rst:198 msgid "" "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." msgstr "" "Las comprensiones de listas ofrecen una manera concisa de crear listas. Sus " "usos comunes son para hacer nuevas listas donde cada elemento es el " "resultado de algunas operaciones aplicadas a cada miembro de otra secuencia " "o iterable, o para crear un segmento de la secuencia de esos elementos para " "satisfacer una condición determinada." #: ../Doc/tutorial/datastructures.rst:203 msgid "For example, assume we want to create a list of squares, like::" msgstr "" "Por ejemplo, asumamos que queremos crear una lista de cuadrados, como::" #: ../Doc/tutorial/datastructures.rst:205 msgid "" ">>> squares = []\n" ">>> for x in range(10):\n" "... squares.append(x**2)\n" "...\n" ">>> squares\n" "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]" msgstr "" #: ../Doc/tutorial/datastructures.rst:212 msgid "" "Note that this creates (or overwrites) a variable named ``x`` that still " "exists after the loop completes. We can calculate the list of squares " "without any side effects using::" msgstr "" "Nótese que esto crea (o sobreescribe) una variable llamada ``x`` que sigue " "existiendo luego de que el bucle haya terminado. Podemos calcular la lista " "de cuadrados sin ningún efecto secundario haciendo::" #: ../Doc/tutorial/datastructures.rst:216 msgid "squares = list(map(lambda x: x**2, range(10)))" msgstr "" #: ../Doc/tutorial/datastructures.rst:218 msgid "or, equivalently::" msgstr "o, un equivalente::" #: ../Doc/tutorial/datastructures.rst:220 msgid "squares = [x**2 for x in range(10)]" msgstr "" #: ../Doc/tutorial/datastructures.rst:222 msgid "which is more concise and readable." msgstr "que es más conciso y legible." #: ../Doc/tutorial/datastructures.rst:224 msgid "" "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::" msgstr "" "Una lista de comprensión consiste de corchetes rodeando una expresión " "seguida de la declaración :keyword:`!for` y luego cero o más declaraciones :" "keyword:`!for` o :keyword:`!if`. El resultado será una nueva lista que sale " "de evaluar la expresión en el contexto de los :keyword:`!for` o :keyword:`!" "if` que le siguen. Por ejemplo, esta lista de comprensión combina los " "elementos de dos listas si no son iguales::" #: ../Doc/tutorial/datastructures.rst:231 msgid "" ">>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]\n" "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]" msgstr "" #: ../Doc/tutorial/datastructures.rst:234 msgid "and it's equivalent to::" msgstr "y es equivalente a::" #: ../Doc/tutorial/datastructures.rst:236 msgid "" ">>> combs = []\n" ">>> for x in [1,2,3]:\n" "... for y in [3,1,4]:\n" "... if x != y:\n" "... combs.append((x, y))\n" "...\n" ">>> combs\n" "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]" msgstr "" #: ../Doc/tutorial/datastructures.rst:245 msgid "" "Note how the order of the :keyword:`for` and :keyword:`if` statements is the " "same in both these snippets." msgstr "" "Nótese como el orden de los :keyword:`for` y :keyword:`if` es el mismo en " "ambos pedacitos de código." #: ../Doc/tutorial/datastructures.rst:248 msgid "" "If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), " "it must be parenthesized. ::" msgstr "" "Si la expresión es una tupla (como el ``(x, y)`` en el ejemplo anterior), " "debe estar entre paréntesis. ::" #: ../Doc/tutorial/datastructures.rst:251 msgid "" ">>> vec = [-4, -2, 0, 2, 4]\n" ">>> # create a new list with the values doubled\n" ">>> [x*2 for x in vec]\n" "[-8, -4, 0, 4, 8]\n" ">>> # filter the list to exclude negative numbers\n" ">>> [x for x in vec if x >= 0]\n" "[0, 2, 4]\n" ">>> # apply a function to all the elements\n" ">>> [abs(x) for x in vec]\n" "[4, 2, 0, 2, 4]\n" ">>> # call a method on each element\n" ">>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']\n" ">>> [weapon.strip() for weapon in freshfruit]\n" "['banana', 'loganberry', 'passion fruit']\n" ">>> # create a list of 2-tuples like (number, square)\n" ">>> [(x, x**2) for x in range(6)]\n" "[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]\n" ">>> # the tuple must be parenthesized, otherwise an error is raised\n" ">>> [x, x**2 for x in range(6)]\n" " File \"\", line 1\n" " [x, x**2 for x in range(6)]\n" " ^^^^^^^\n" "SyntaxError: did you forget parentheses around the comprehension target?\n" ">>> # flatten a list using a listcomp with two 'for'\n" ">>> vec = [[1,2,3], [4,5,6], [7,8,9]]\n" ">>> [num for elem in vec for num in elem]\n" "[1, 2, 3, 4, 5, 6, 7, 8, 9]" msgstr "" #: ../Doc/tutorial/datastructures.rst:279 msgid "" "List comprehensions can contain complex expressions and nested functions::" msgstr "" "Las comprensiones de listas pueden contener expresiones complejas y " "funciones anidadas::" #: ../Doc/tutorial/datastructures.rst:281 msgid "" ">>> from math import pi\n" ">>> [str(round(pi, i)) for i in range(1, 6)]\n" "['3.1', '3.14', '3.142', '3.1416', '3.14159']" msgstr "" #: ../Doc/tutorial/datastructures.rst:286 msgid "Nested List Comprehensions" msgstr "Listas por comprensión anidadas" #: ../Doc/tutorial/datastructures.rst:288 msgid "" "The initial expression in a list comprehension can be any arbitrary " "expression, including another list comprehension." msgstr "" "La expresión inicial de una comprensión de listas puede ser cualquier " "expresión arbitraria, incluyendo otra comprensión de listas." #: ../Doc/tutorial/datastructures.rst:291 msgid "" "Consider the following example of a 3x4 matrix implemented as a list of 3 " "lists of length 4::" msgstr "" "Considerá el siguiente ejemplo de una matriz de 3x4 implementada como una " "lista de tres listas de largo 4::" #: ../Doc/tutorial/datastructures.rst:294 msgid "" ">>> matrix = [\n" "... [1, 2, 3, 4],\n" "... [5, 6, 7, 8],\n" "... [9, 10, 11, 12],\n" "... ]" msgstr "" #: ../Doc/tutorial/datastructures.rst:300 msgid "The following list comprehension will transpose rows and columns::" msgstr "La siguiente comprensión de lista transpondrá las filas y columnas::" #: ../Doc/tutorial/datastructures.rst:302 msgid "" ">>> [[row[i] for row in matrix] for i in range(4)]\n" "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]" msgstr "" #: ../Doc/tutorial/datastructures.rst:305 msgid "" "As we saw in the previous section, the inner list comprehension is evaluated " "in the context of the :keyword:`for` that follows it, so this example is " "equivalent to::" msgstr "" "Como vimos en la sección anterior, la lista de comprensión anidada se evalúa " "en el contexto del :keyword:`for` que lo sigue, por lo que este ejemplo " "equivale a::" #: ../Doc/tutorial/datastructures.rst:309 msgid "" ">>> transposed = []\n" ">>> for i in range(4):\n" "... transposed.append([row[i] for row in matrix])\n" "...\n" ">>> transposed\n" "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]" msgstr "" #: ../Doc/tutorial/datastructures.rst:316 msgid "which, in turn, is the same as::" msgstr "el cual, a la vez, es lo mismo que::" #: ../Doc/tutorial/datastructures.rst:318 msgid "" ">>> transposed = []\n" ">>> for i in range(4):\n" "... # the following 3 lines implement the nested listcomp\n" "... transposed_row = []\n" "... for row in matrix:\n" "... transposed_row.append(row[i])\n" "... transposed.append(transposed_row)\n" "...\n" ">>> transposed\n" "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]" msgstr "" #: ../Doc/tutorial/datastructures.rst:329 msgid "" "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 case::" msgstr "" "En el mundo real, deberías preferir funciones predefinidas a declaraciones " "con flujo complejo. La función :func:`zip` haría un buen trabajo para este " "caso de uso::" #: ../Doc/tutorial/datastructures.rst:332 msgid "" ">>> list(zip(*matrix))\n" "[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]" msgstr "" #: ../Doc/tutorial/datastructures.rst:335 msgid "" "See :ref:`tut-unpacking-arguments` for details on the asterisk in this line." msgstr "" "Ver :ref:`tut-unpacking-arguments` para detalles sobre el asterisco de esta " "línea." #: ../Doc/tutorial/datastructures.rst:340 msgid "The :keyword:`!del` statement" msgstr "La instrucción :keyword:`del`" #: ../Doc/tutorial/datastructures.rst:342 msgid "" "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:`~list." "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::" msgstr "" "Hay una manera de quitar un ítem de una lista dado su índice en lugar de su " "valor: la instrucción :keyword:`del`. Esta es diferente del método :meth:" "`~list.pop`, el cual retorna un valor. La instrucción :keyword:`!del` " "también puede usarse para quitar secciones de una lista o vaciar la lista " "completa (lo que hacíamos antes asignando una lista vacía a la rebanada). " "Por ejemplo::" #: ../Doc/tutorial/datastructures.rst:348 msgid "" ">>> a = [-1, 1, 66.25, 333, 333, 1234.5]\n" ">>> del a[0]\n" ">>> a\n" "[1, 66.25, 333, 333, 1234.5]\n" ">>> del a[2:4]\n" ">>> a\n" "[1, 66.25, 1234.5]\n" ">>> del a[:]\n" ">>> a\n" "[]" msgstr "" #: ../Doc/tutorial/datastructures.rst:359 msgid ":keyword:`del` can also be used to delete entire variables::" msgstr ":keyword:`del` puede usarse también para eliminar variables::" #: ../Doc/tutorial/datastructures.rst:361 msgid ">>> del a" msgstr "" #: ../Doc/tutorial/datastructures.rst:363 msgid "" "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." msgstr "" "Hacer referencia al nombre ``a`` de aquí en más es un error (al menos hasta " "que se le asigne otro valor). Veremos otros usos para :keyword:`del` más " "adelante." #: ../Doc/tutorial/datastructures.rst:370 msgid "Tuples and Sequences" msgstr "Tuplas y secuencias" #: ../Doc/tutorial/datastructures.rst:372 msgid "" "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*." msgstr "" "Vimos que las listas y cadenas tienen propiedades en común, como el indexado " "y las operaciones de rebanado. Estas son dos ejemplos de datos de tipo " "*secuencia* (ver :ref:`typesseq`). Como Python es un lenguaje en evolución, " "otros datos de tipo secuencia pueden agregarse. Existe otro dato de tipo " "secuencia estándar: la *tupla*." #: ../Doc/tutorial/datastructures.rst:378 msgid "" "A tuple consists of a number of values separated by commas, for instance::" msgstr "" "Una tupla está formada por un número de valores separados por comas, por " "ejemplo::" #: ../Doc/tutorial/datastructures.rst:380 msgid "" ">>> t = 12345, 54321, 'hello!'\n" ">>> t[0]\n" "12345\n" ">>> t\n" "(12345, 54321, 'hello!')\n" ">>> # Tuples may be nested:\n" ">>> u = t, (1, 2, 3, 4, 5)\n" ">>> u\n" "((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))\n" ">>> # Tuples are immutable:\n" ">>> t[0] = 88888\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "TypeError: 'tuple' object does not support item assignment\n" ">>> # but they can contain mutable objects:\n" ">>> v = ([1, 2, 3], [3, 2, 1])\n" ">>> v\n" "([1, 2, 3], [3, 2, 1])" msgstr "" #: ../Doc/tutorial/datastructures.rst:400 msgid "" "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." msgstr "" "Como puedes ver, en la salida las tuplas siempre se encierran entre " "paréntesis para que las tuplas anidadas puedan interpretarse correctamente; " "pueden ingresarse con o sin paréntesis, aunque a menudo los paréntesis son " "necesarios de todas formas (si la tupla es parte de una expresión más " "grande). No es posible asignar a los ítems individuales de una tupla, pero " "sin embargo sí se puede crear tuplas que contengan objetos mutables, como " "las listas." #: ../Doc/tutorial/datastructures.rst:407 msgid "" "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 `). Lists are :term:" "`mutable`, and their elements are usually homogeneous and are accessed by " "iterating over the list." msgstr "" "A pesar de que las tuplas puedan parecerse a las listas, frecuentemente se " "utilizan en distintas situaciones y para distintos propósitos. Las tuplas " "son :term:`immutable` y normalmente contienen una secuencia heterogénea de " "elementos que son accedidos al desempaquetar (ver más adelante en esta " "sección) o indizar (o incluso acceder por atributo en el caso de las :func:" "`namedtuples `). Las listas son :term:`mutable`, y " "sus elementos son normalmente homogéneos y se acceden iterando a la lista." #: ../Doc/tutorial/datastructures.rst:415 msgid "" "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::" msgstr "" "Un problema particular es la construcción de tuplas que contengan 0 o 1 " "ítem: la sintaxis presenta algunas peculiaridades para estos casos. Las " "tuplas vacías se construyen mediante un par de paréntesis vacío; una tupla " "con un ítem se construye poniendo una coma a continuación del valor (no " "alcanza con encerrar un único valor entre paréntesis). Feo, pero efectivo. " "Por ejemplo::" #: ../Doc/tutorial/datastructures.rst:421 msgid "" ">>> empty = ()\n" ">>> singleton = 'hello', # <-- note trailing comma\n" ">>> len(empty)\n" "0\n" ">>> len(singleton)\n" "1\n" ">>> singleton\n" "('hello',)" msgstr "" #: ../Doc/tutorial/datastructures.rst:430 msgid "" "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::" msgstr "" "La declaración ``t = 12345, 54321, 'hola!'`` es un ejemplo de *empaquetado " "de tuplas*: los valores ``12345``, ``54321`` y ``'hola!'`` se empaquetan " "juntos en una tupla. La operación inversa también es posible::" #: ../Doc/tutorial/datastructures.rst:434 msgid ">>> x, y, z = t" msgstr "" #: ../Doc/tutorial/datastructures.rst:436 msgid "" "This is called, appropriately enough, *sequence unpacking* and works for any " "sequence on the right-hand side. Sequence unpacking requires that there are " "as many variables on the left side of the equals sign as there are elements " "in the sequence. Note that multiple assignment is really just a combination " "of tuple packing and sequence unpacking." msgstr "" "Esto se llama, apropiadamente, *desempaquetado de secuencias*, y funciona " "para cualquier secuencia en el lado derecho del igual. El desempaquetado de " "secuencias requiere que la cantidad de variables a la izquierda del signo " "igual sea el tamaño de la secuencia. Nótese que la asignación múltiple es en " "realidad sólo una combinación de empaquetado de tuplas y desempaquetado de " "secuencias." #: ../Doc/tutorial/datastructures.rst:446 msgid "Sets" msgstr "Conjuntos" #: ../Doc/tutorial/datastructures.rst:448 msgid "" "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." msgstr "" "Python también incluye un tipo de dato para *conjuntos*. Un conjunto es una " "colección no ordenada y sin elementos repetidos. Los usos básicos de éstos " "incluyen verificación de pertenencia y eliminación de entradas duplicadas. " "Los conjuntos también soportan operaciones matemáticas como la unión, " "intersección, diferencia, y diferencia simétrica." #: ../Doc/tutorial/datastructures.rst:453 #, python-brace-format msgid "" "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 " "section." msgstr "" "Las llaves o la función :func:`set` pueden usarse para crear conjuntos. Notá " "que para crear un conjunto vacío tenés que usar ``set()``, no ``{}``; esto " "último crea un diccionario vacío, una estructura de datos que discutiremos " "en la sección siguiente." #: ../Doc/tutorial/datastructures.rst:457 msgid "Here is a brief demonstration::" msgstr "Una pequeña demostración::" #: ../Doc/tutorial/datastructures.rst:459 #, python-brace-format msgid "" ">>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\n" ">>> print(basket) # show that duplicates have been " "removed\n" "{'orange', 'banana', 'pear', 'apple'}\n" ">>> 'orange' in basket # fast membership testing\n" "True\n" ">>> 'crabgrass' in basket\n" "False\n" "\n" ">>> # Demonstrate set operations on unique letters from two words\n" ">>>\n" ">>> a = set('abracadabra')\n" ">>> b = set('alacazam')\n" ">>> a # unique letters in a\n" "{'a', 'r', 'b', 'c', 'd'}\n" ">>> a - b # letters in a but not in b\n" "{'r', 'd', 'b'}\n" ">>> a | b # letters in a or b or both\n" "{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}\n" ">>> a & b # letters in both a and b\n" "{'a', 'c'}\n" ">>> a ^ b # letters in a or b but not both\n" "{'r', 'd', 'b', 'm', 'z', 'l'}" msgstr "" #: ../Doc/tutorial/datastructures.rst:482 msgid "" "Similarly to :ref:`list comprehensions `, set comprehensions " "are also supported::" msgstr "" "De forma similar a las :ref:`comprensiones de listas `, la " "comprensión de conjuntos está también soportada::" #: ../Doc/tutorial/datastructures.rst:485 #, python-brace-format msgid "" ">>> a = {x for x in 'abracadabra' if x not in 'abc'}\n" ">>> a\n" "{'r', 'd'}" msgstr "" #: ../Doc/tutorial/datastructures.rst:493 msgid "Dictionaries" msgstr "Diccionarios" #: ../Doc/tutorial/datastructures.rst:495 msgid "" "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:" "`~list.append` and :meth:`~list.extend`." msgstr "" "Otro tipo de dato útil incluido en Python es el *diccionario* (ver :ref:" "`typesmapping`). Los diccionarios se encuentran a veces en otros lenguajes " "como \"memorias asociativas\" o \"arreglos asociativos\". A diferencia de " "las secuencias, que se indexan mediante un rango numérico, los diccionarios " "se indexan con *claves*, que pueden ser cualquier tipo inmutable; las " "cadenas y números siempre pueden ser claves. Las tuplas pueden usarse como " "claves si solamente contienen cadenas, números o tuplas; si una tupla " "contiene cualquier objeto mutable directa o indirectamente, no puede usarse " "como clave. No podés usar listas como claves, ya que las listas pueden " "modificarse usando asignación por índice, asignación por sección, o métodos " "como :meth:`~list.append` y :meth:`~list.extend`." #: ../Doc/tutorial/datastructures.rst:506 #, python-brace-format msgid "" "It is best to think of a dictionary as a 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." msgstr "" "Es mejor pensar en un diccionario como un conjunto de pares *clave:valor* " "con el requerimiento de que las claves sean únicas (dentro de un " "diccionario). Un par de llaves crean un diccionario vacío: ``{}``. Colocar " "una lista de pares clave:valor separada por comas dentro de las llaves añade " "pares clave:valor iniciales al diccionario; esta es también la forma en que " "los diccionarios se muestran en la salida." #: ../Doc/tutorial/datastructures.rst:512 #, fuzzy msgid "" "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." msgstr "" "Las operaciones principales sobre un diccionario son guardar un valor con " "una clave y extraer ese valor dada la clave. También es posible borrar un " "par clave:valor con ``del``. Si usás una clave que ya está en uso para " "guardar un valor, el valor que estaba asociado con esa clave se pierde. Es " "un error extraer un valor usando una clave inexistente." #: ../Doc/tutorial/datastructures.rst:517 msgid "" "Extracting a value for a non-existent key by subscripting (``d[key]``) " "raises a :exc:`KeyError`. To avoid getting this error when trying to access " "a possibly non-existent key, use the :meth:`~dict.get` method instead, which " "returns ``None`` (or a specified default value) if the key is not in the " "dictionary." msgstr "" #: ../Doc/tutorial/datastructures.rst:522 msgid "" "Performing ``list(d)`` on a dictionary returns a list of all the keys used " "in the dictionary, in insertion order (if you want it sorted, just use " "``sorted(d)`` instead). To check whether a single key is in the dictionary, " "use the :keyword:`in` keyword." msgstr "" "Ejecutando ``list(d)`` en un diccionario retornará una lista con todas las " "claves usadas en el diccionario, en el orden de inserción (si deseas que " "esté ordenada simplemente usa ``sorted(d)`` en su lugar). Para comprobar si " "una clave está en el diccionario usa la palabra clave :keyword:`in`." #: ../Doc/tutorial/datastructures.rst:527 msgid "Here is a small example using a dictionary::" msgstr "Un pequeño ejemplo de uso de un diccionario::" #: ../Doc/tutorial/datastructures.rst:529 #, python-brace-format msgid "" ">>> tel = {'jack': 4098, 'sape': 4139}\n" ">>> tel['guido'] = 4127\n" ">>> tel\n" "{'jack': 4098, 'sape': 4139, 'guido': 4127}\n" ">>> tel['jack']\n" "4098\n" ">>> tel['irv']\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "KeyError: 'irv'\n" ">>> print(tel.get('irv'))\n" "None\n" ">>> del tel['sape']\n" ">>> tel['irv'] = 4127\n" ">>> tel\n" "{'jack': 4098, 'guido': 4127, 'irv': 4127}\n" ">>> list(tel)\n" "['jack', 'guido', 'irv']\n" ">>> sorted(tel)\n" "['guido', 'irv', 'jack']\n" ">>> 'guido' in tel\n" "True\n" ">>> 'jack' not in tel\n" "False" msgstr "" #: ../Doc/tutorial/datastructures.rst:554 msgid "" "The :func:`dict` constructor builds dictionaries directly from sequences of " "key-value pairs::" msgstr "" "El constructor :func:`dict` crea un diccionario directamente desde " "secuencias de pares clave-valor::" #: ../Doc/tutorial/datastructures.rst:557 #, python-brace-format msgid "" ">>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])\n" "{'sape': 4139, 'guido': 4127, 'jack': 4098}" msgstr "" #: ../Doc/tutorial/datastructures.rst:560 msgid "" "In addition, dict comprehensions can be used to create dictionaries from " "arbitrary key and value expressions::" msgstr "" "Además, las comprensiones de diccionarios se pueden usar para crear " "diccionarios desde expresiones arbitrarias de clave y valor::" #: ../Doc/tutorial/datastructures.rst:563 #, python-brace-format msgid "" ">>> {x: x**2 for x in (2, 4, 6)}\n" "{2: 4, 4: 16, 6: 36}" msgstr "" #: ../Doc/tutorial/datastructures.rst:566 msgid "" "When the keys are simple strings, it is sometimes easier to specify pairs " "using keyword arguments::" msgstr "" "Cuando las claves son cadenas simples, a veces resulta más fácil especificar " "los pares usando argumentos por palabra clave::" #: ../Doc/tutorial/datastructures.rst:569 #, python-brace-format msgid "" ">>> dict(sape=4139, guido=4127, jack=4098)\n" "{'sape': 4139, 'guido': 4127, 'jack': 4098}" msgstr "" #: ../Doc/tutorial/datastructures.rst:576 msgid "Looping Techniques" msgstr "Técnicas de iteración" #: ../Doc/tutorial/datastructures.rst:578 msgid "" "When looping through dictionaries, the key and corresponding value can be " "retrieved at the same time using the :meth:`~dict.items` method. ::" msgstr "" "Cuando iteramos sobre diccionarios, se pueden obtener al mismo tiempo la " "clave y su valor correspondiente usando el método :meth:`~dict.items`. ::" #: ../Doc/tutorial/datastructures.rst:581 #, python-brace-format msgid "" ">>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}\n" ">>> for k, v in knights.items():\n" "... print(k, v)\n" "...\n" "gallahad the pure\n" "robin the brave" msgstr "" #: ../Doc/tutorial/datastructures.rst:588 msgid "" "When looping through a sequence, the position index and corresponding value " "can be retrieved at the same time using the :func:`enumerate` function. ::" msgstr "" "Cuando se itera sobre una secuencia, se puede obtener el índice de posición " "junto a su valor correspondiente usando la función :func:`enumerate`. ::" #: ../Doc/tutorial/datastructures.rst:591 msgid "" ">>> for i, v in enumerate(['tic', 'tac', 'toe']):\n" "... print(i, v)\n" "...\n" "0 tic\n" "1 tac\n" "2 toe" msgstr "" #: ../Doc/tutorial/datastructures.rst:598 msgid "" "To loop over two or more sequences at the same time, the entries can be " "paired with the :func:`zip` function. ::" msgstr "" "Para iterar sobre dos o más secuencias al mismo tiempo, los valores pueden " "emparejarse con la función :func:`zip`. ::" #: ../Doc/tutorial/datastructures.rst:601 #, python-brace-format msgid "" ">>> questions = ['name', 'quest', 'favorite color']\n" ">>> answers = ['lancelot', 'the holy grail', 'blue']\n" ">>> for q, a in zip(questions, answers):\n" "... print('What is your {0}? It is {1}.'.format(q, a))\n" "...\n" "What is your name? It is lancelot.\n" "What is your quest? It is the holy grail.\n" "What is your favorite color? It is blue." msgstr "" #: ../Doc/tutorial/datastructures.rst:610 msgid "" "To loop over a sequence in reverse, first specify the sequence in a forward " "direction and then call the :func:`reversed` function. ::" msgstr "" "Para iterar sobre una secuencia en orden inverso, se especifica primero la " "secuencia al derecho y luego se llama a la función :func:`reversed`. ::" #: ../Doc/tutorial/datastructures.rst:613 msgid "" ">>> for i in reversed(range(1, 10, 2)):\n" "... print(i)\n" "...\n" "9\n" "7\n" "5\n" "3\n" "1" msgstr "" #: ../Doc/tutorial/datastructures.rst:622 msgid "" "To loop over a sequence in sorted order, use the :func:`sorted` function " "which returns a new sorted list while leaving the source unaltered. ::" msgstr "" "Para iterar sobre una secuencia ordenada, se utiliza la función :func:" "`sorted` la cual retorna una nueva lista ordenada dejando a la original " "intacta. ::" #: ../Doc/tutorial/datastructures.rst:625 msgid "" ">>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']\n" ">>> for i in sorted(basket):\n" "... print(i)\n" "...\n" "apple\n" "apple\n" "banana\n" "orange\n" "orange\n" "pear" msgstr "" #: ../Doc/tutorial/datastructures.rst:636 msgid "" "Using :func:`set` on a sequence eliminates duplicate elements. The use of :" "func:`sorted` in combination with :func:`set` over a sequence is an " "idiomatic way to loop over unique elements of the sequence in sorted " "order. ::" msgstr "" "El uso de :func:`set` en una secuencia elimina los elementos duplicados. El " "uso de :func:`sorted` en combinación con :func:`set` sobre una secuencia es " "una forma idiomática de recorrer elementos únicos de la secuencia " "ordenada. ::" #: ../Doc/tutorial/datastructures.rst:640 msgid "" ">>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']\n" ">>> for f in sorted(set(basket)):\n" "... print(f)\n" "...\n" "apple\n" "banana\n" "orange\n" "pear" msgstr "" #: ../Doc/tutorial/datastructures.rst:649 msgid "" "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. ::" msgstr "" "A veces uno intenta cambiar una lista mientras la está iterando; sin " "embargo, a menudo es más simple y seguro crear una nueva lista::" #: ../Doc/tutorial/datastructures.rst:652 msgid "" ">>> import math\n" ">>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]\n" ">>> filtered_data = []\n" ">>> for value in raw_data:\n" "... if not math.isnan(value):\n" "... filtered_data.append(value)\n" "...\n" ">>> filtered_data\n" "[56.2, 51.7, 55.3, 52.5, 47.8]" msgstr "" #: ../Doc/tutorial/datastructures.rst:666 msgid "More on Conditions" msgstr "Más acerca de condiciones" #: ../Doc/tutorial/datastructures.rst:668 msgid "" "The conditions used in ``while`` and ``if`` statements can contain any " "operators, not just comparisons." msgstr "" "Las condiciones usadas en las instrucciones ``while`` e ``if`` pueden " "contener cualquier operador, no sólo comparaciones." #: ../Doc/tutorial/datastructures.rst:672 msgid "" "The comparison operators ``in`` and ``not in`` are membership tests that " "determine whether a value is in (or not in) a container. The operators " "``is`` and ``is not`` compare whether two objects are really the same " "object. All comparison operators have the same priority, which is lower " "than that of all numerical operators." msgstr "" "Los operadores de comparación ``in`` y ``not in`` verifican si un valor " "ocurre (o no ocurre) en una secuencia. Los operadores ``is`` e ``is not`` " "comparan si dos objetos son realmente el mismo objeto. Todos los operadores " "de comparación tienen la misma prioridad, que es menor que la de todos los " "operadores numéricos." #: ../Doc/tutorial/datastructures.rst:678 msgid "" "Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` " "is less than ``b`` and moreover ``b`` equals ``c``." msgstr "" "Las comparaciones pueden encadenarse. Por ejemplo, ``a < b == c`` verifica " "si ``a`` es menor que ``b`` y además si ``b`` es igual a ``c``." #: ../Doc/tutorial/datastructures.rst:681 msgid "" "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." msgstr "" "Las comparaciones pueden combinarse mediante los operadores booleanos " "``and`` y ``or``, y el resultado de una comparación (o de cualquier otra " "expresión booleana) puede negarse con ``not``. Estos tienen prioridades " "menores que los operadores de comparación; entre ellos ``not`` tiene la " "mayor prioridad y ``or`` la menor, o sea que ``A and not B or C`` equivale a " "``(A and (not B)) or C``. Como siempre, los paréntesis pueden usarse para " "expresar la composición deseada." #: ../Doc/tutorial/datastructures.rst:688 msgid "" "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." msgstr "" "Los operadores booleanos ``and`` y ``or`` son los llamados operadores " "*cortocircuito*: sus argumentos se evalúan de izquierda a derecha, y la " "evaluación se detiene en el momento en que se determina su resultado. Por " "ejemplo, si ``A`` y ``C`` son verdaderas pero ``B`` es falsa, en ``A and B " "and C`` no se evalúa la expresión ``C``. Cuando se usa como un valor general " "y no como un booleano, el valor retornado de un operador cortocircuito es el " "último argumento evaluado." #: ../Doc/tutorial/datastructures.rst:695 msgid "" "It is possible to assign the result of a comparison or other Boolean " "expression to a variable. For example, ::" msgstr "" "Es posible asignar el resultado de una comparación u otra expresión booleana " "a una variable. Por ejemplo, ::" #: ../Doc/tutorial/datastructures.rst:698 msgid "" ">>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'\n" ">>> non_null = string1 or string2 or string3\n" ">>> non_null\n" "'Trondheim'" msgstr "" #: ../Doc/tutorial/datastructures.rst:703 msgid "" "Note that in Python, unlike C, assignment inside expressions must be done " "explicitly with the :ref:`walrus operator ` ``:=``. This avoids a common class of problems encountered " "in C programs: typing ``=`` in an expression when ``==`` was intended." msgstr "" "Nótese que en Python, a diferencia de C, asignaciones dentro de expresiones " "deben realizarse explícitamente con el :ref:`operador walrus ` ``:=``. Esto soluciona algunos " "problemas comunes encontrados en C: escribiendo ``=`` en una expresión " "cuando se intentaba escribir ``==``." #: ../Doc/tutorial/datastructures.rst:713 msgid "Comparing Sequences and Other Types" msgstr "Comparando secuencias y otros tipos" #: ../Doc/tutorial/datastructures.rst:714 msgid "" "Sequence objects typically 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 Unicode code point number to " "order individual characters. Some examples of comparisons between sequences " "of the same type::" msgstr "" "Las secuencias pueden compararse con otros objetos del mismo tipo de " "secuencia. La comparación usa orden *lexicográfico*: primero se comparan los " "dos primeros ítems, si son diferentes esto ya determina el resultado de la " "comparación; si son iguales, se comparan los siguientes dos ítems, y así " "sucesivamente hasta llegar al final de alguna de las secuencias. Si dos " "ítems a comparar son ambos secuencias del mismo tipo, la comparación " "lexicográfica es recursiva. Si todos los ítems de dos secuencias resultan " "iguales, se considera que las secuencias son iguales. Si una secuencia es la " "parte inicial de la otra, la secuencia más corta es la más pequeña. El orden " "lexicográfico de las cadenas de caracteres utiliza el punto de código " "Unicode para ordenar caracteres individuales. Algunos ejemplos de " "comparación entre secuencias del mismo tipo::" #: ../Doc/tutorial/datastructures.rst:726 msgid "" "(1, 2, 3) < (1, 2, 4)\n" "[1, 2, 3] < [1, 2, 4]\n" "'ABC' < 'C' < 'Pascal' < 'Python'\n" "(1, 2, 3, 4) < (1, 2, 4)\n" "(1, 2) < (1, 2, -1)\n" "(1, 2, 3) == (1.0, 2.0, 3.0)\n" "(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)" msgstr "" #: ../Doc/tutorial/datastructures.rst:734 msgid "" "Note that comparing objects of different types with ``<`` or ``>`` is legal " "provided that the objects have appropriate comparison methods. For example, " "mixed numeric types are compared according to their numeric value, so 0 " "equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, " "the interpreter will raise a :exc:`TypeError` exception." msgstr "" "Observá que comparar objetos de diferentes tipos con ``<`` o ``>`` es legal " "siempre y cuando los objetos tenga los métodos de comparación apropiados. " "Por ejemplo, los tipos de números mezclados son comparados de acuerdo a su " "valor numérico, o sea 0 es igual a 0.0, etc. Si no es el caso, en lugar de " "proveer un ordenamiento arbitrario, el intérprete lanzará una excepción :exc:" "`TypeError`." #: ../Doc/tutorial/datastructures.rst:742 msgid "Footnotes" msgstr "Notas al pie" #: ../Doc/tutorial/datastructures.rst:743 msgid "" "Other languages may return the mutated object, which allows method chaining, " "such as ``d->insert(\"a\")->remove(\"b\")->sort();``." msgstr "" "Otros lenguajes podrían retornar un objeto mutado, que permite " "encadenamiento de métodos como ``d->insert(\"a\")->remove(\"b\")->sort();``."