diff --git a/TRANSLATORS b/TRANSLATORS index 5f300889fa..cd9b0678e5 100644 --- a/TRANSLATORS +++ b/TRANSLATORS @@ -39,6 +39,7 @@ Marco Richetta (@marcorichetta) Adolfo Hristo David Roque Gámez (@hristoroque) Elisabeth Ortega (@draentropia) Cristian Rengifo (@ingrengifo) +Juan Ignacio Rodríguez de León (@euribates) Pablo Lobariñas (@Qkolnek) Santiago Piccinini (@spiccinini) Sergio Delgado Quintero (@sdelquin) diff --git a/dictionaries/library_stdtypes.txt b/dictionaries/library_stdtypes.txt new file mode 100644 index 0000000000..fb3712313d --- /dev/null +++ b/dictionaries/library_stdtypes.txt @@ -0,0 +1,5 @@ +computacionalmente +Cardinalidad +superconjunto +superíndices +unaria diff --git a/library/stdtypes.po b/library/stdtypes.po index 9dd175d87a..b1e1587c3a 100644 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -6,35 +6,40 @@ # Check https://github.com/PyCampES/python-docs-es/blob/3.8/TRANSLATORS to # get the list of volunteers # -#, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2020-08-20 19:58+0200\n" +"Last-Translator: Cristián Maureira-Fredes \n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.8.0\n" +"Language: es\n" +"X-Generator: Poedit 2.3.1\n" #: ../Doc/library/stdtypes.rst:8 msgid "Built-in Types" -msgstr "" +msgstr "Tipos Integrados" #: ../Doc/library/stdtypes.rst:10 msgid "" "The following sections describe the standard types that are built into the " "interpreter." msgstr "" +"Esta sección describe los tipos de datos estándar que vienen incluidos en el " +"intérprete." #: ../Doc/library/stdtypes.rst:15 msgid "" "The principal built-in types are numerics, sequences, mappings, classes, " "instances and exceptions." msgstr "" +"Los principales tipos de datos son: numéricos, secuencias, mapas, clases, " +"instancias y excepciones." #: ../Doc/library/stdtypes.rst:18 msgid "" @@ -42,6 +47,10 @@ msgid "" "rearrange their members in place, and don't return a specific item, never " "return the collection instance itself but ``None``." msgstr "" +"Algunas clases de tipo colección son mutables. Los métodos que añaden, " +"retiran u ordenan los contenidos lo hacen internamente, y a no ser que " +"retornen un elemento concreto, nunca retornan la propia instancia " +"contenedora, sino ``None``." #: ../Doc/library/stdtypes.rst:22 msgid "" @@ -51,16 +60,26 @@ msgid "" "slightly different :func:`str` function). The latter function is implicitly " "used when an object is written by the :func:`print` function." msgstr "" +"Algunas operaciones son soportadas por varios tipos de objetos diferentes; " +"por ejemplo, prácticamente todos los objetos pueden ser comparados por " +"igualdad, evaluados para ser considerados como valores booleanos, o " +"representarse en forma de cadena de caracteres (Ya sea con la función :func:" +"`repr` o la ligeramente diferente :func:`str`). Esta última es la usada " +"implícitamente por la función :func:`print`." #: ../Doc/library/stdtypes.rst:32 msgid "Truth Value Testing" -msgstr "" +msgstr "Evaluar como valor verdadero/falso" #: ../Doc/library/stdtypes.rst:41 msgid "" "Any object can be tested for truth value, for use in an :keyword:`if` or :" "keyword:`while` condition or as operand of the Boolean operations below." msgstr "" +"Cualquier objeto puede ser evaluado como si fuera un valor verdadero o " +"falso, para ser usado directamente en sentencias :keyword:`if` o :keyword:" +"`while`, o como un operador en una operación booleana como las que veremos " +"más adelante." #: ../Doc/library/stdtypes.rst:46 msgid "" @@ -69,22 +88,31 @@ msgid "" "that returns zero, when called with the object. [1]_ Here are most of the " "built-in objects considered false:" msgstr "" +"Por defecto, un objeto se considera verdadero a no ser que su clase defina o " +"bien un método :meth:`__bool__` que retorna ``False`` o un método :meth:" +"`__len__` que retorna cero, cuando se invoque desde ese objeto. [1]_ Aquí " +"están listados la mayoría de los objetos predefinidos que se evalúan como " +"falsos:" #: ../Doc/library/stdtypes.rst:55 msgid "constants defined to be false: ``None`` and ``False``." -msgstr "" +msgstr "constantes definidas para tener valor falso: ``None`` y ``False``." #: ../Doc/library/stdtypes.rst:57 msgid "" "zero of any numeric type: ``0``, ``0.0``, ``0j``, ``Decimal(0)``, " "``Fraction(0, 1)``" msgstr "" +"cero en cualquiera de los diferentes tipos numéricos: ``0``, ``0.0``, " +"``0j``, ``Decimal(0)``, ``Fraction(0, 1)``" #: ../Doc/library/stdtypes.rst:60 msgid "" "empty sequences and collections: ``''``, ``()``, ``[]``, ``{}``, ``set()``, " "``range(0)``" msgstr "" +"cualquier colección o secuencia vacía: ``''``, ``()``, ``[]``, ``{}``, " +"``set()``, ``range(0)``" #: ../Doc/library/stdtypes.rst:69 msgid "" @@ -93,72 +121,79 @@ msgid "" "otherwise stated. (Important exception: the Boolean operations ``or`` and " "``and`` always return one of their operands.)" msgstr "" +"Las operaciones y funciones predefinidas que retornan como resultado un " +"booleano siempre retornan ``0`` o ``False`` para un valor falso, y ``1`` o " +"``True`` para un valor verdadero, a no ser que se indique otra cosa (Hay una " +"excepción importante: Los operadores booleanos ``or`` y ``and`` siempre " +"retornan uno de los dos operadores)." #: ../Doc/library/stdtypes.rst:78 msgid "Boolean Operations --- :keyword:`!and`, :keyword:`!or`, :keyword:`!not`" msgstr "" +"Operaciones booleanas --- :keyword:`!and`, :keyword:`!or`, :keyword:`!not`" #: ../Doc/library/stdtypes.rst:82 msgid "These are the Boolean operations, ordered by ascending priority:" msgstr "" +"Estas son las operaciones booleanas, ordenadas de menor a mayor prioridad:" #: ../Doc/library/stdtypes.rst:85 ../Doc/library/stdtypes.rst:143 #: ../Doc/library/stdtypes.rst:274 ../Doc/library/stdtypes.rst:363 #: ../Doc/library/stdtypes.rst:413 ../Doc/library/stdtypes.rst:863 #: ../Doc/library/stdtypes.rst:1058 msgid "Operation" -msgstr "" +msgstr "Operación" #: ../Doc/library/stdtypes.rst:85 ../Doc/library/stdtypes.rst:274 #: ../Doc/library/stdtypes.rst:363 ../Doc/library/stdtypes.rst:413 #: ../Doc/library/stdtypes.rst:863 ../Doc/library/stdtypes.rst:1058 msgid "Result" -msgstr "" +msgstr "Resultado" #: ../Doc/library/stdtypes.rst:85 ../Doc/library/stdtypes.rst:274 #: ../Doc/library/stdtypes.rst:413 ../Doc/library/stdtypes.rst:863 #: ../Doc/library/stdtypes.rst:1058 ../Doc/library/stdtypes.rst:2228 #: ../Doc/library/stdtypes.rst:3383 msgid "Notes" -msgstr "" +msgstr "Notas" #: ../Doc/library/stdtypes.rst:87 msgid "``x or y``" -msgstr "" +msgstr "``x or y``" #: ../Doc/library/stdtypes.rst:87 msgid "if *x* is false, then *y*, else *x*" -msgstr "" +msgstr "si *x* es falso, entonces *y*, si no, *x*" #: ../Doc/library/stdtypes.rst:87 ../Doc/library/stdtypes.rst:284 #: ../Doc/library/stdtypes.rst:865 ../Doc/library/stdtypes.rst:868 #: ../Doc/library/stdtypes.rst:1069 ../Doc/library/stdtypes.rst:2234 #: ../Doc/library/stdtypes.rst:3389 msgid "\\(1)" -msgstr "" +msgstr "\\(1)" #: ../Doc/library/stdtypes.rst:90 msgid "``x and y``" -msgstr "" +msgstr "``x and y``" #: ../Doc/library/stdtypes.rst:90 msgid "if *x* is false, then *x*, else *y*" -msgstr "" +msgstr "si *x* es falso, entonces *x*, si no, *y*" #: ../Doc/library/stdtypes.rst:90 ../Doc/library/stdtypes.rst:287 #: ../Doc/library/stdtypes.rst:307 ../Doc/library/stdtypes.rst:1097 #: ../Doc/library/stdtypes.rst:2238 ../Doc/library/stdtypes.rst:2240 #: ../Doc/library/stdtypes.rst:3393 ../Doc/library/stdtypes.rst:3395 msgid "\\(2)" -msgstr "" +msgstr "\\(2)" #: ../Doc/library/stdtypes.rst:93 msgid "``not x``" -msgstr "" +msgstr "``not x``" #: ../Doc/library/stdtypes.rst:93 msgid "if *x* is false, then ``True``, else ``False``" -msgstr "" +msgstr "si *x* es falso, entonces ``True``, si no, ``False``" #: ../Doc/library/stdtypes.rst:93 ../Doc/library/stdtypes.rst:877 #: ../Doc/library/stdtypes.rst:1100 ../Doc/library/stdtypes.rst:2242 @@ -167,36 +202,43 @@ msgstr "" #: ../Doc/library/stdtypes.rst:3399 ../Doc/library/stdtypes.rst:3401 #: ../Doc/library/stdtypes.rst:3403 msgid "\\(3)" -msgstr "" +msgstr "\\(3)" #: ../Doc/library/stdtypes.rst:102 ../Doc/library/stdtypes.rst:318 #: ../Doc/library/stdtypes.rst:431 ../Doc/library/stdtypes.rst:904 #: ../Doc/library/stdtypes.rst:1108 ../Doc/library/stdtypes.rst:2274 #: ../Doc/library/stdtypes.rst:3433 msgid "Notes:" -msgstr "" +msgstr "Notas:" #: ../Doc/library/stdtypes.rst:105 msgid "" "This is a short-circuit operator, so it only evaluates the second argument " "if the first one is false." msgstr "" +"Este operador usar lógica cortocircuitada, por lo que solo evalúa el segundo " +"argumentos si el primero es falso." #: ../Doc/library/stdtypes.rst:109 msgid "" "This is a short-circuit operator, so it only evaluates the second argument " "if the first one is true." msgstr "" +"Este operador usa lógica cortocircuitada, por lo que solo evalúa el segundo " +"argumentos si el primero es verdadero." #: ../Doc/library/stdtypes.rst:113 msgid "" "``not`` has a lower priority than non-Boolean operators, so ``not a == b`` " "is interpreted as ``not (a == b)``, and ``a == not b`` is a syntax error." msgstr "" +"El operador ``not`` tiene menos prioridad que los operadores no booleanos, " +"así que ``not a == b`` se interpreta como ``not (a == b)`, y ``a == not b`` " +"es un error sintáctico." #: ../Doc/library/stdtypes.rst:120 msgid "Comparisons" -msgstr "" +msgstr "Comparaciones" #: ../Doc/library/stdtypes.rst:134 msgid "" @@ -206,80 +248,86 @@ msgid "" "< y and y <= z``, except that *y* is evaluated only once (but in both cases " "*z* is not evaluated at all when ``x < y`` is found to be false)." msgstr "" +"Existen ocho operadores de comparación en Python. Todos comparten el mismo " +"nivel de prioridad (que es mayor que el nivel de las operaciones booleanas). " +"Las comparaciones pueden encadenarse de cualquier manera; por ejemplo, ``x < " +"y <= z`` equivale a ``x < y and y <= z``, excepto porque *y* solo se evalúa " +"una vez (No obstante, en ambos casos *z* no se evalúa si no es verdad que " +"``x < y``)." #: ../Doc/library/stdtypes.rst:140 msgid "This table summarizes the comparison operations:" -msgstr "" +msgstr "Esta tabla resumen las operaciones de comparación:" #: ../Doc/library/stdtypes.rst:143 ../Doc/library/stdtypes.rst:2205 #: ../Doc/library/stdtypes.rst:2228 ../Doc/library/stdtypes.rst:3360 #: ../Doc/library/stdtypes.rst:3383 msgid "Meaning" -msgstr "" +msgstr "Significado" #: ../Doc/library/stdtypes.rst:145 msgid "``<``" -msgstr "" +msgstr "``<``" #: ../Doc/library/stdtypes.rst:145 msgid "strictly less than" -msgstr "" +msgstr "estrictamente menor que" #: ../Doc/library/stdtypes.rst:147 msgid "``<=``" -msgstr "" +msgstr "``<=``" #: ../Doc/library/stdtypes.rst:147 msgid "less than or equal" -msgstr "" +msgstr "menor o igual que" #: ../Doc/library/stdtypes.rst:149 msgid "``>``" -msgstr "" +msgstr "``>``" #: ../Doc/library/stdtypes.rst:149 msgid "strictly greater than" -msgstr "" +msgstr "estrictamente mayor que" #: ../Doc/library/stdtypes.rst:151 msgid "``>=``" -msgstr "" +msgstr "``>=``" #: ../Doc/library/stdtypes.rst:151 msgid "greater than or equal" -msgstr "" +msgstr "mayor o igual que" #: ../Doc/library/stdtypes.rst:153 msgid "``==``" -msgstr "" +msgstr "``==``" #: ../Doc/library/stdtypes.rst:153 msgid "equal" -msgstr "" +msgstr "igual que" #: ../Doc/library/stdtypes.rst:155 msgid "``!=``" -msgstr "" +msgstr "``!=``" #: ../Doc/library/stdtypes.rst:155 msgid "not equal" -msgstr "" +msgstr "diferente que" #: ../Doc/library/stdtypes.rst:157 msgid "``is``" -msgstr "" +msgstr "``is``" #: ../Doc/library/stdtypes.rst:157 msgid "object identity" -msgstr "" +msgstr "igualdad a nivel de identidad (Son el mismo objeto)" #: ../Doc/library/stdtypes.rst:159 msgid "``is not``" -msgstr "" +msgstr "``is not``" #: ../Doc/library/stdtypes.rst:159 msgid "negated object identity" -msgstr "" +msgstr "desigualdad a nivel de identidad (no son el mismo objeto)" #: ../Doc/library/stdtypes.rst:166 msgid "" @@ -290,12 +338,21 @@ msgid "" "example, they raise a :exc:`TypeError` exception when one of the arguments " "is a complex number." msgstr "" +"Nunca se consideran iguales objetos que son de tipos diferentes, con la " +"excepción de los tipos numéricos. El operador ``==`` siempre está definido, " +"pero en algunos tipos de objetos (Como por ejemplo, las clases) es " +"equivalente al operador :keyword:`is`. Los operadores ``<``, ``<=``, ``>`` y " +"``>=`` solo están definidos cuando tienen sentido; por ejemplo, si uno de " +"los operadores es un número complejo, la comparación elevará una excepción " +"de tipo :exc:`TypeError`." #: ../Doc/library/stdtypes.rst:180 msgid "" "Non-identical instances of a class normally compare as non-equal unless the " "class defines the :meth:`__eq__` method." msgstr "" +"Instancias de una clase que no son idénticas normalmente se consideran como " +"diferentes, a no ser que la clase defina un método :meth:`__eq__`." #: ../Doc/library/stdtypes.rst:183 msgid "" @@ -305,6 +362,12 @@ msgid "" "`__ge__` (in general, :meth:`__lt__` and :meth:`__eq__` are sufficient, if " "you want the conventional meanings of the comparison operators)." msgstr "" +"Las instancias de una clase no pueden ordenarse con respecto a otras " +"instancias de la misma clases, ni con otro tipo de objetos, a no ser que la " +"clase defina un subconjunto suficiente de estos métodos: :meth:`__lt__`, :" +"meth:`__le__`, :meth:`__gt__` y :meth:`__ge__` (En general, :meth:`__lt__` " +"y :meth:`__eq__` son suficientes, si solo necesitas los significados " +"convencionales de los operadores de comparación)." #: ../Doc/library/stdtypes.rst:189 msgid "" @@ -312,6 +375,9 @@ msgid "" "customized; also they can be applied to any two objects and never raise an " "exception." msgstr "" +"El comportamiento de los operadores :keyword:`is` e :keyword:`is not` no se " +"puede personalizar; además, nunca elevan una excepción, no importa que dos " +"objetos se comparen." #: ../Doc/library/stdtypes.rst:197 msgid "" @@ -319,10 +385,13 @@ msgid "" "keyword:`not in`, are supported by types that are :term:`iterable` or " "implement the :meth:`__contains__` method." msgstr "" +"Hay otras dos operaciones con la misma prioridad sintáctica: :keyword:`in` " +"y :keyword:`not in`, que son soportadas por aquellos tipos de datos que son " +"de tipo :term:`iterable` o que implementen el método :meth:`__contains__`." #: ../Doc/library/stdtypes.rst:204 msgid "Numeric Types --- :class:`int`, :class:`float`, :class:`complex`" -msgstr "" +msgstr "Tipos numéricos --- :class:`int`, :class:`float`, :class:`complex`" #: ../Doc/library/stdtypes.rst:214 msgid "" @@ -338,6 +407,19 @@ msgid "" "numeric types :mod:`fractions.Fraction`, for rationals, and :mod:`decimal." "Decimal`, for floating-point numbers with user-definable precision.)" msgstr "" +"Hay tres tipos numéricos distintos: :dfn:`enteros`, :dfn:`números en coma " +"flotante`y :dfn:`números complejos`. Además, los booleanos son un subtipo de " +"los enteros. Los enteros tiene precisión ilimitada. Los números en coma " +"flotante se implementan normalmente usando el tipo :c:type:`double` de C; " +"Hay más información sobre la precisión y la representación interna de los " +"números en coma flotante usadas por la máquina sobre la que se ejecuta tu " +"programa en :data:`sys.float_info`. Los números complejos tienen una parte " +"real y otra imaginaria, ambas representadas con números en coma flotante. " +"Para extraer estas partes del número complejo *z* se usan los métodos ``z." +"real`` y ``z.imag``. (La librería estándar incluye tipos numéricos " +"adicionales: :mod:`fractions.Fraction` para números racionales y :mod:" +"`decimal.Decimal` para números en coma flotante con precisión definida por " +"el usuario)." #: ../Doc/library/stdtypes.rst:236 msgid "" @@ -349,6 +431,15 @@ msgid "" "with a zero real part) which you can add to an integer or float to get a " "complex number with real and imaginary parts." msgstr "" +"Los números se crean a partir de una expresión literal, o como resultado de " +"una combinación de funciones predefinidas y operadores. Expresiones " +"literales de números (incluyendo números expresados en hexadecimal, octal o " +"binario) producen enteros. Si la expresión literal contiene un punto decimal " +"o un signo de exponente, se genera un número en coma flotante. Si se añade " +"como sufijo una ``'j'`` o una ``'J'`` a un literal numérico, se genera un " +"número imaginario puro (Un número complejo con la parte real a cero), que se " +"puede sumar a un número entero o de coma flotante para obtener un número " +"complejo con parte real e imaginaria." #: ../Doc/library/stdtypes.rst:261 msgid "" @@ -359,177 +450,191 @@ msgid "" "of different types behaves as though the exact values of those numbers were " "being compared. [2]_" msgstr "" +"Python soporta completamente una aritmética mixta: Cuando un operador " +"binario de tipo aritmético se encuentra con que los operadores son de tipos " +"diferentes, el operando con el tipo de dato más \"estrecho\" o restrictivo " +"se convierte o amplia hasta el nivel del otro operando. Los enteros son más " +"\"estrechos\" que los de coma flotante, que a su vez son más estrechos que " +"los números complejos. Las comparaciones entre números de diferentes tipos " +"se comportan como si se compararan los valores exactos de estos. [2]_" #: ../Doc/library/stdtypes.rst:267 msgid "" "The constructors :func:`int`, :func:`float`, and :func:`complex` can be used " "to produce numbers of a specific type." msgstr "" +"Las funciones constructoras :func:`int`, :func:`float` y :func:`complex` se " +"pueden usar para generar números de cada tipo determinado." #: ../Doc/library/stdtypes.rst:270 msgid "" "All numeric types (except complex) support the following operations (for " "priorities of the operations, see :ref:`operator-summary`):" msgstr "" +"Todos los tipos numéricos (menos los complejos) soportan las siguientes " +"operaciones (Para las prioridades de las operaciones, véase :ref:`operator-" +"summary`):" #: ../Doc/library/stdtypes.rst:274 msgid "Full documentation" -msgstr "" +msgstr "Documentación completa" #: ../Doc/library/stdtypes.rst:276 msgid "``x + y``" -msgstr "" +msgstr "``x + y``" #: ../Doc/library/stdtypes.rst:276 msgid "sum of *x* and *y*" -msgstr "" +msgstr "suma de *x* e *y*" #: ../Doc/library/stdtypes.rst:278 msgid "``x - y``" -msgstr "" +msgstr "``x - y``" #: ../Doc/library/stdtypes.rst:278 msgid "difference of *x* and *y*" -msgstr "" +msgstr "resta de *x* e *y*" #: ../Doc/library/stdtypes.rst:280 msgid "``x * y``" -msgstr "" +msgstr "``x * y``" #: ../Doc/library/stdtypes.rst:280 msgid "product of *x* and *y*" -msgstr "" +msgstr "multiplicación de *x* por *y*" #: ../Doc/library/stdtypes.rst:282 msgid "``x / y``" -msgstr "" +msgstr "``x / y``" #: ../Doc/library/stdtypes.rst:282 msgid "quotient of *x* and *y*" -msgstr "" +msgstr "división de *x* por *y*" #: ../Doc/library/stdtypes.rst:284 msgid "``x // y``" -msgstr "" +msgstr "``x // y``" #: ../Doc/library/stdtypes.rst:284 msgid "floored quotient of *x* and *y*" -msgstr "" +msgstr "división entera de *x* por *y*" #: ../Doc/library/stdtypes.rst:287 msgid "``x % y``" -msgstr "" +msgstr "``x % y``" #: ../Doc/library/stdtypes.rst:287 msgid "remainder of ``x / y``" -msgstr "" +msgstr "resto o residuo de *x* por *y*" #: ../Doc/library/stdtypes.rst:289 msgid "``-x``" -msgstr "" +msgstr "``-x``" #: ../Doc/library/stdtypes.rst:289 msgid "*x* negated" -msgstr "" +msgstr "valor de *x*, negado" #: ../Doc/library/stdtypes.rst:291 msgid "``+x``" -msgstr "" +msgstr "``+x``" #: ../Doc/library/stdtypes.rst:291 msgid "*x* unchanged" -msgstr "" +msgstr "valor de *x*, sin cambiar" #: ../Doc/library/stdtypes.rst:293 msgid "``abs(x)``" -msgstr "" +msgstr "``abs(x)``" #: ../Doc/library/stdtypes.rst:293 msgid "absolute value or magnitude of *x*" -msgstr "" +msgstr "valor absoluto de la magnitud de *x*" #: ../Doc/library/stdtypes.rst:293 msgid ":func:`abs`" -msgstr "" +msgstr ":func:`abs`" #: ../Doc/library/stdtypes.rst:296 msgid "``int(x)``" -msgstr "" +msgstr "``int(x)``" #: ../Doc/library/stdtypes.rst:296 msgid "*x* converted to integer" -msgstr "" +msgstr "valor de *x* convertido a entero" #: ../Doc/library/stdtypes.rst:296 msgid "\\(3)\\(6)" -msgstr "" +msgstr "\\(3)\\(6)" #: ../Doc/library/stdtypes.rst:296 msgid ":func:`int`" -msgstr "" +msgstr ":func:`int`" #: ../Doc/library/stdtypes.rst:298 msgid "``float(x)``" -msgstr "" +msgstr "``float(x)``" #: ../Doc/library/stdtypes.rst:298 msgid "*x* converted to floating point" -msgstr "" +msgstr "valor de *x* convertido a número de punto flotante" #: ../Doc/library/stdtypes.rst:298 msgid "\\(4)\\(6)" -msgstr "" +msgstr "\\(4)\\(6)" #: ../Doc/library/stdtypes.rst:298 msgid ":func:`float`" -msgstr "" +msgstr ":func:`float`" #: ../Doc/library/stdtypes.rst:300 msgid "``complex(re, im)``" -msgstr "" +msgstr "``complex(re, im)``" #: ../Doc/library/stdtypes.rst:300 msgid "" "a complex number with real part *re*, imaginary part *im*. *im* defaults to " "zero." msgstr "" +"un número complejo, con parte real *re* y parte imaginaria *im*. El valor de " +"*im* por defecto vale cero." #: ../Doc/library/stdtypes.rst:300 ../Doc/library/stdtypes.rst:1090 #: ../Doc/library/stdtypes.rst:2236 ../Doc/library/stdtypes.rst:3420 msgid "\\(6)" -msgstr "" +msgstr "\\(6)" #: ../Doc/library/stdtypes.rst:300 msgid ":func:`complex`" -msgstr "" +msgstr ":func:`complex`" #: ../Doc/library/stdtypes.rst:304 msgid "``c.conjugate()``" -msgstr "" +msgstr "``c.conjugate()``" #: ../Doc/library/stdtypes.rst:304 msgid "conjugate of the complex number *c*" -msgstr "" +msgstr "conjugado del número complejo *c*" #: ../Doc/library/stdtypes.rst:307 msgid "``divmod(x, y)``" -msgstr "" +msgstr "``divmod(x, y)``" #: ../Doc/library/stdtypes.rst:307 msgid "the pair ``(x // y, x % y)``" -msgstr "" +msgstr "el par de valores ``(x // y, x % y)``" #: ../Doc/library/stdtypes.rst:307 msgid ":func:`divmod`" -msgstr "" +msgstr ":func:`divmod`" #: ../Doc/library/stdtypes.rst:309 msgid "``pow(x, y)``" -msgstr "" +msgstr "``pow(x, y)``" #: ../Doc/library/stdtypes.rst:309 ../Doc/library/stdtypes.rst:311 msgid "*x* to the power *y*" -msgstr "" +msgstr "*x* elevado a *y*" #: ../Doc/library/stdtypes.rst:309 ../Doc/library/stdtypes.rst:311 #: ../Doc/library/stdtypes.rst:1079 ../Doc/library/stdtypes.rst:1082 @@ -537,15 +642,15 @@ msgstr "" #: ../Doc/library/stdtypes.rst:2267 ../Doc/library/stdtypes.rst:3416 #: ../Doc/library/stdtypes.rst:3423 msgid "\\(5)" -msgstr "" +msgstr "\\(5)" #: ../Doc/library/stdtypes.rst:309 msgid ":func:`pow`" -msgstr "" +msgstr ":func:`pow`" #: ../Doc/library/stdtypes.rst:311 msgid "``x ** y``" -msgstr "" +msgstr "``x ** y``" #: ../Doc/library/stdtypes.rst:321 msgid "" @@ -554,12 +659,18 @@ msgid "" "always rounded towards minus infinity: ``1//2`` is ``0``, ``(-1)//2`` is " "``-1``, ``1//(-2)`` is ``-1``, and ``(-1)//(-2)`` is ``0``." msgstr "" +"También conocida como división entera. El resultado es un número entero en " +"el sentido matemático, pero no necesariamente de tipo entero. El resultado " +"se redondea de forma automática hacia menos infinito: ``1//2`` es ``0``, " +"``(-1)//2`` es ``-1``, ``1//(-2)`` es ``-1`` y ``(-1)//(-2)`` es ``0``." #: ../Doc/library/stdtypes.rst:327 msgid "" "Not for complex numbers. Instead convert to floats using :func:`abs` if " "appropriate." msgstr "" +"No es apropiada para números complejos. Es preferible convertir a valores en " +"coma flotante usando la función :func:`abs` si fuera apropiado." #: ../Doc/library/stdtypes.rst:339 msgid "" @@ -567,80 +678,101 @@ msgid "" "functions :func:`math.floor` and :func:`math.ceil` for well-defined " "conversions." msgstr "" +"Conversiones desde coma flotante a entero pueden redondearse o truncarse " +"como en C; véanse las funciones :func:`math.floor` y :func:`math.ceil` para " +"un mayor control." #: ../Doc/library/stdtypes.rst:344 msgid "" "float also accepts the strings \"nan\" and \"inf\" with an optional prefix " "\"+\" or \"-\" for Not a Number (NaN) and positive or negative infinity." msgstr "" +"float también acepta las cadenas de caracteres \"*nan*\" e \"*inf*\", con un " +"prefijo opcional \"+\" o \"-\", para los valores *Not a Number* (*NaN*) e " +"infinito positivo o negativo." #: ../Doc/library/stdtypes.rst:348 msgid "" "Python defines ``pow(0, 0)`` and ``0 ** 0`` to be ``1``, as is common for " "programming languages." msgstr "" +"Python define ``pow(0, 0)`` y ``0 ** 0`` para que valgan ``1``, como es " +"práctica habitual en los lenguajes de programación." #: ../Doc/library/stdtypes.rst:352 msgid "" "The numeric literals accepted include the digits ``0`` to ``9`` or any " "Unicode equivalent (code points with the ``Nd`` property)." msgstr "" +"Los literales numéricos aceptables incluyen los dígitos desde el ``0`` hasta " +"el ``9``, así como cualquier carácter Unicode equivalente (puntos de código " +"con la propiedad ``Nd``)." #: ../Doc/library/stdtypes.rst:355 msgid "" "See http://www.unicode.org/Public/12.1.0/ucd/extracted/DerivedNumericType." "txt for a complete list of code points with the ``Nd`` property." msgstr "" +"En http://www.unicode.org/Public/12.1.0/ucd/extracted/DerivedNumericType.txt " +"se puede consultar una lista completa de los puntos de código con la " +"propiedad ``Nd``." #: ../Doc/library/stdtypes.rst:359 msgid "" "All :class:`numbers.Real` types (:class:`int` and :class:`float`) also " "include the following operations:" msgstr "" +"Todas las clases derivadas de :class:`numbers.Real` (:class:`int` y :class:" +"`float`) también soportan las siguientes operaciones:" #: ../Doc/library/stdtypes.rst:365 msgid ":func:`math.trunc(\\ x) `" -msgstr "" +msgstr ":func:`math.trunc(\\ x) `" #: ../Doc/library/stdtypes.rst:365 msgid "*x* truncated to :class:`~numbers.Integral`" -msgstr "" +msgstr "*x* truncado a :class:`~numbers.Integral`" #: ../Doc/library/stdtypes.rst:368 msgid ":func:`round(x[, n]) `" -msgstr "" +msgstr ":func:`round(x[, n]) `" #: ../Doc/library/stdtypes.rst:368 msgid "" "*x* rounded to *n* digits, rounding half to even. If *n* is omitted, it " "defaults to 0." msgstr "" +"El valor de *x* redondeado a *n* dígitos, redondeando la mitad al número par " +"más cercano (Redondeo del banquero). Si no se especifica valor para *n*, se " +"asume 0." #: ../Doc/library/stdtypes.rst:372 msgid ":func:`math.floor(\\ x) `" -msgstr "" +msgstr ":func:`math.floor(\\ x) `" #: ../Doc/library/stdtypes.rst:372 msgid "the greatest :class:`~numbers.Integral` <= *x*" -msgstr "" +msgstr "el mayor número :class:`~numbers.Integral` que sea <= *x*" #: ../Doc/library/stdtypes.rst:375 msgid ":func:`math.ceil(x) `" -msgstr "" +msgstr ":func:`math.ceil(x) `" #: ../Doc/library/stdtypes.rst:375 msgid "the least :class:`~numbers.Integral` >= *x*" -msgstr "" +msgstr "el menor número :class:`~numbers.Integral` que sea >= *x*" #: ../Doc/library/stdtypes.rst:379 msgid "" "For additional numeric operations see the :mod:`math` and :mod:`cmath` " "modules." msgstr "" +"Para más operaciones numéricas consulta los módulos :mod:`math` y :mod:" +"`cmath`." #: ../Doc/library/stdtypes.rst:388 msgid "Bitwise Operations on Integer Types" -msgstr "" +msgstr "Operaciones de bits en números enteros" #: ../Doc/library/stdtypes.rst:402 msgid "" @@ -648,6 +780,10 @@ msgid "" "operations is calculated as though carried out in two's complement with an " "infinite number of sign bits." msgstr "" +"Las operaciones a nivel de bit solo tienen sentido con números enteros. El " +"resultado de una de estas operaciones se calcula como si se hubiera " +"realizado en una representación en complemento a dos que tuviera un número " +"infinito de bits de signo." #: ../Doc/library/stdtypes.rst:406 msgid "" @@ -656,90 +792,102 @@ msgid "" "``~`` has the same priority as the other unary numeric operations (``+`` and " "``-``)." msgstr "" +"La prioridad de todas las operaciones de bits son menores que las " +"operaciones numéricas, pero mayores que las comparaciones; la operación " +"unaria ``~`` tiene la misma prioridad que las otras operaciones unarias " +"numéricas (``+`` y ``-``)." #: ../Doc/library/stdtypes.rst:410 msgid "This table lists the bitwise operations sorted in ascending priority:" msgstr "" +"Esta tabla lista las operaciones de bits, ordenadas de menor a mayor " +"prioridad:" #: ../Doc/library/stdtypes.rst:415 msgid "``x | y``" -msgstr "" +msgstr "``x | y``" #: ../Doc/library/stdtypes.rst:415 msgid "bitwise :dfn:`or` of *x* and *y*" -msgstr "" +msgstr "la operación :dfn:`or` entre *x* e *y*" #: ../Doc/library/stdtypes.rst:415 ../Doc/library/stdtypes.rst:418 #: ../Doc/library/stdtypes.rst:421 ../Doc/library/stdtypes.rst:1103 #: ../Doc/library/stdtypes.rst:2250 ../Doc/library/stdtypes.rst:2254 #: ../Doc/library/stdtypes.rst:3405 ../Doc/library/stdtypes.rst:3409 msgid "\\(4)" -msgstr "" +msgstr "\\(4)" #: ../Doc/library/stdtypes.rst:418 msgid "``x ^ y``" -msgstr "" +msgstr "``x ^ y``" #: ../Doc/library/stdtypes.rst:418 msgid "bitwise :dfn:`exclusive or` of *x* and *y*" -msgstr "" +msgstr "la operación :dfn:`exclusive or` entre *x* e *y*" #: ../Doc/library/stdtypes.rst:421 msgid "``x & y``" -msgstr "" +msgstr "``x & y``" #: ../Doc/library/stdtypes.rst:421 msgid "bitwise :dfn:`and` of *x* and *y*" -msgstr "" +msgstr "la operación :dfn:`and` entre *x* e *y*" #: ../Doc/library/stdtypes.rst:424 msgid "``x << n``" -msgstr "" +msgstr "``x << n``" #: ../Doc/library/stdtypes.rst:424 msgid "*x* shifted left by *n* bits" -msgstr "" +msgstr "El valor *x* desplazado a la izquierda *n* bits" #: ../Doc/library/stdtypes.rst:424 msgid "(1)(2)" -msgstr "" +msgstr "(1)(2)" #: ../Doc/library/stdtypes.rst:426 msgid "``x >> n``" -msgstr "" +msgstr "``x >> n``" #: ../Doc/library/stdtypes.rst:426 msgid "*x* shifted right by *n* bits" -msgstr "" +msgstr "valor de *x* desplazado a la derecha *n* bits" #: ../Doc/library/stdtypes.rst:426 msgid "(1)(3)" -msgstr "" +msgstr "(1)(3)" #: ../Doc/library/stdtypes.rst:428 msgid "``~x``" -msgstr "" +msgstr "``~x``" #: ../Doc/library/stdtypes.rst:428 msgid "the bits of *x* inverted" -msgstr "" +msgstr "invierte los bits de *x*" #: ../Doc/library/stdtypes.rst:434 msgid "" "Negative shift counts are illegal and cause a :exc:`ValueError` to be raised." msgstr "" +"Los desplazamientos negativos son ilegales y elevan una excepción de tipo :" +"exc:`ValeError`." #: ../Doc/library/stdtypes.rst:437 msgid "" "A left shift by *n* bits is equivalent to multiplication by ``pow(2, n)`` " "without overflow check." msgstr "" +"Un desplazamiento de *n* bits a la izquierda es equivalente a multiplicar " +"por ``pow(2, n)``, sin comprobación de desbordamiento." #: ../Doc/library/stdtypes.rst:441 msgid "" "A right shift by *n* bits is equivalent to division by ``pow(2, n)`` without " "overflow check." msgstr "" +"Un desplazamiento de *n* bits a la derecha es equivalente a dividir por " +"``pow(2, n)``, sin comprobación de desbordamiento." #: ../Doc/library/stdtypes.rst:445 msgid "" @@ -748,22 +896,31 @@ msgid "" "bit_length(), y.bit_length())`` or more) is sufficient to get the same " "result as if there were an infinite number of sign bits." msgstr "" +"Realizar estos cálculos con al menos un bit extra de signo en una " +"representación finita de un número en complemento a dos (Un ancho de bits de " +"trabajo de ``1 + max(x.bit_length(), y.bit_length())`` o más) es suficiente " +"para obtener el mismo resultado que si se hubiera realizado con un número " +"infinito de bits de signo." #: ../Doc/library/stdtypes.rst:452 msgid "Additional Methods on Integer Types" -msgstr "" +msgstr "Métodos adicionales de los enteros" #: ../Doc/library/stdtypes.rst:454 msgid "" "The int type implements the :class:`numbers.Integral` :term:`abstract base " "class`. In addition, it provides a few more methods:" msgstr "" +"El tipo int implementa la :term:`clase base abstracta` :class:`numbers." +"Integral`. Además, proporciona los siguientes métodos:" #: ../Doc/library/stdtypes.rst:459 msgid "" "Return the number of bits necessary to represent an integer in binary, " "excluding the sign and leading zeros::" msgstr "" +"Retorna el número de bits necesarios para representar un número entero, " +"excluyendo el bit de signo y los ceros a la izquierda::" #: ../Doc/library/stdtypes.rst:468 msgid "" @@ -773,20 +930,29 @@ msgid "" "logarithm, then ``k = 1 + int(log(abs(x), 2))``. If ``x`` is zero, then ``x." "bit_length()`` returns ``0``." msgstr "" +"De forma más precisa, si ``x`` es distinto de cero, entonces ``x." +"bit_length()`` es el único número entero positivo ``k`` tal que ``2**(k-1) " +"<= abs(x) < 2**k``. De igual manera, cuando ``abs(x)`` es lo suficientemente " +"pequeño para tener un logaritmo redondeado correctamente, entonces ``k = 1 + " +"int(log(abs*x), 2))``. Si ``x`` es cero, entonces ``x.bit_length()`` retorna " +"``0``." #: ../Doc/library/stdtypes.rst:474 msgid "Equivalent to::" -msgstr "" +msgstr "Equivale a::" #: ../Doc/library/stdtypes.rst:485 msgid "Return an array of bytes representing an integer." -msgstr "" +msgstr "Retorna un array de bytes que representan el número entero." #: ../Doc/library/stdtypes.rst:497 msgid "" "The integer is represented using *length* bytes. An :exc:`OverflowError` is " "raised if the integer is not representable with the given number of bytes." msgstr "" +"El número entero se representa usando el número de bits indicados con " +"*length*. Se elevará la excepción :exc:`OverflowError` si no se puede " +"representar el valor con ese número de bits." #: ../Doc/library/stdtypes.rst:501 ../Doc/library/stdtypes.rst:533 msgid "" @@ -797,6 +963,12 @@ msgid "" "byte order of the host system, use :data:`sys.byteorder` as the byte order " "value." msgstr "" +"El argumento *byteorder* determina el orden de representación del número " +"entero. Si *byteorder* es ``\"big\"``, el byte más significativo ocupa la " +"primera posición en el vector. Si *byteorder* es ``\"little\"``, el byte más " +"significativo estará en la última posición. Para indicar que queremos usar " +"el ordenamiento propio de la plataforma, podemos usar :data:`sys.byteorder` " +"como valor del argumento." #: ../Doc/library/stdtypes.rst:508 msgid "" @@ -805,22 +977,30 @@ msgid "" "given, an :exc:`OverflowError` is raised. The default value for *signed* is " "``False``." msgstr "" +"El parámetro *signed* determina si se usa el complemento a dos para " +"representar los números enteros. Si *signed* es ``False``, y se usa un valor " +"entero negativo, se elevará la excepción :exc:`OverflowError`. El valor por " +"defecto para *signed* es ``False``." #: ../Doc/library/stdtypes.rst:517 msgid "Return the integer represented by the given array of bytes." -msgstr "" +msgstr "Retorna el número entero representado por el vector de bytes." #: ../Doc/library/stdtypes.rst:530 msgid "" "The argument *bytes* must either be a :term:`bytes-like object` or an " "iterable producing bytes." msgstr "" +"El argumento *bytes* debe ser o bien un :term:`objeto tipo binario ` o un iterable que produzca bytes." #: ../Doc/library/stdtypes.rst:540 msgid "" "The *signed* argument indicates whether two's complement is used to " "represent the integer." msgstr "" +"El argumento *signed* determina si se representará el número entero usando " +"complemento a dos." #: ../Doc/library/stdtypes.rst:547 msgid "" @@ -829,16 +1009,23 @@ msgid "" "(whole numbers) is always the integer as the numerator and ``1`` as the " "denominator." msgstr "" +"Retorna una pareja de números enteros cuya proporción es igual a la del " +"numero entero original, y con un denominador positivo. En el caso de números " +"enteros, la proporción siempre es el número original y ``1`` en el " +"denominador." #: ../Doc/library/stdtypes.rst:555 msgid "Additional Methods on Float" -msgstr "" +msgstr "Métodos adicionales de Float" +# Verificar que el glosario el termino aparezca como clase base abstracta #: ../Doc/library/stdtypes.rst:557 msgid "" "The float type implements the :class:`numbers.Real` :term:`abstract base " "class`. float also has the following additional methods." msgstr "" +"El tipo float implementa la clase :class:`numbers.Real` :term:`clase base " +"abstracta`. Los números float tienen además los siguientes métodos." #: ../Doc/library/stdtypes.rst:562 msgid "" @@ -846,12 +1033,19 @@ msgid "" "and with a positive denominator. Raises :exc:`OverflowError` on infinities " "and a :exc:`ValueError` on NaNs." msgstr "" +"Retorna una pareja de números enteros cuya proporción es exactamente igual " +"que la del valor en punto flotante original, con un denominador positivo. Si " +"se llama con valores infinitos eleva una excepción de tipo :exc:" +"`OverflowError` y si se llama con *NaN* (*Not A Number*) eleva una excepción " +"de tipo :exc:`ValueError`." #: ../Doc/library/stdtypes.rst:569 msgid "" "Return ``True`` if the float instance is finite with integral value, and " "``False`` otherwise::" msgstr "" +"Retorna ``True`` si el valor en coma flotante se puede representar sin " +"perdida con un número entero, y ``False`` si no se puede::" #: ../Doc/library/stdtypes.rst:577 msgid "" @@ -862,6 +1056,13 @@ msgid "" "of floating-point numbers. This can be useful when debugging, and in " "numerical work." msgstr "" +"Hay dos métodos que convierten desde y hacia cadenas de caracteres en " +"hexadecimal. Como los valores en coma flotante en Python se almacenan " +"internamente en binario, las conversiones desde o hacia cadenas *decimales* " +"pueden implicar un pequeño error de redondeo. Pero con cadenas de texto en " +"hexadecimal, las cadenas se corresponden y permiten representar de forma " +"exacta los números en coma flotante. Esto puede ser útil, ya sea a la hora " +"de depurar errores, o en procesos numéricos." #: ../Doc/library/stdtypes.rst:588 msgid "" @@ -869,22 +1070,30 @@ msgid "" "For finite floating-point numbers, this representation will always include a " "leading ``0x`` and a trailing ``p`` and exponent." msgstr "" +"Retorna la representación de un valor en coma flotante en forma de cadena de " +"texto en hexadecimal. Para números finitos, la representación siempre " +"empieza con el prefijo ``0x``, y con una ``p`` justo antes del exponente." #: ../Doc/library/stdtypes.rst:596 msgid "" "Class method to return the float represented by a hexadecimal string *s*. " "The string *s* may have leading and trailing whitespace." msgstr "" +"Método de clase que retorna el valor en coma flotante representado por la " +"cadena de caracteres en hexadecimal en *s*. La cadena *s* puede tener " +"espacios en blanco al principio o al final." #: ../Doc/library/stdtypes.rst:601 msgid "" "Note that :meth:`float.hex` is an instance method, while :meth:`float." "fromhex` is a class method." msgstr "" +"Nótese que :meth:`float.hex` es un método de instancia, mientras que :meth:" +"`float.fromhex` es un método de clase." #: ../Doc/library/stdtypes.rst:604 msgid "A hexadecimal string takes the form::" -msgstr "" +msgstr "Una cadena de caracteres en hexadecimal sigue este formato::" #: ../Doc/library/stdtypes.rst:608 msgid "" @@ -899,6 +1108,18 @@ msgid "" "by C's ``%a`` format character or Java's ``Double.toHexString`` are accepted " "by :meth:`float.fromhex`." msgstr "" +"donde el componente opcional ``sign`` puede ser o bien ``+`` o ``-``. Las " +"componentes ``integer`` y ``fraction`` son cadenas de caracteres que solo " +"usan dígitos hexadecimales, y ``exponent`` es un número decimal, precedido " +"con un signo opcional. No se distingue entre mayúsculas y minúsculas, y debe " +"haber al menos un dígito hexadecimal tanto en la parte entera como en la " +"fracción. Esta sintaxis es similar a la sintaxis especificada en la sección " +"6.4.4.2 del estándar C99, y es también la sintaxis usada en Java desde la " +"versión 1.5. En particular, la salida de :meth:`float.hex` se puede usar " +"como una cadena de caracteres en hexadecimal en código C o Java, y las " +"cadenas de caracteres hexadecimal producidas por el carácter de formato ``" +"%a``en C, o por el método Java, ``Double.toHexString``, son aceptadas por :" +"meth:`float.fromhex`." #: ../Doc/library/stdtypes.rst:621 msgid "" @@ -907,16 +1128,23 @@ msgid "" "example, the hexadecimal string ``0x3.a7p10`` represents the floating-point " "number ``(3 + 10./16 + 7./16**2) * 2.0**10``, or ``3740.0``::" msgstr "" +"Nótese que el valor del exponente está expresado en decimal, no en " +"hexadecimal, e indica la potencia de 2 por la que debemos multiplicar el " +"coeficiente. Por ejemplo, la cadena de caracteres hexadecimal ``0x3.a7p10`` " +"representa el número en coma flotante ``(3 + 10./16 + 7./16**2) * 2.0**10``, " +"o ``3740.0``::" #: ../Doc/library/stdtypes.rst:631 msgid "" "Applying the reverse conversion to ``3740.0`` gives a different hexadecimal " "string representing the same number::" msgstr "" +"Si aplicamos la operación inversa a ``3740.0`` retorna una cadena de " +"caracteres hexadecimal diferente que, aun así, representa el mismo número::" #: ../Doc/library/stdtypes.rst:641 msgid "Hashing of numeric types" -msgstr "" +msgstr "Calculo del *hash* de tipos numéricos" #: ../Doc/library/stdtypes.rst:643 msgid "" @@ -933,16 +1161,31 @@ msgid "" "is made available to Python as the :attr:`modulus` attribute of :data:`sys." "hash_info`." msgstr "" +"Para dos números ``x`` e ``y``, posiblemente de tipos diferentes, se " +"requiere que ``hash(x) == hash(y)`` sea verdadero siempre que ``x == y`` " +"(Véase la documentación sobre el método :meth:`__hash__` para más detalles). " +"Por razones tanto de eficiencia como de facilidad de implementación entre " +"los tipos numéricos diferentes (Incluyendo :class:`int`, :class:`float`, :" +"class:`decimal.Decimal` y :class:`fractions.Fraction`), el método de *hash* " +"de Python se basa en una función matemática sencilla que está definida para " +"cualquier número racional, con lo cual se puede aplicar a todas las " +"instancias de :class:`int` y :class:`fractions.Fraction`, y a todas las " +"instancias finitas de :class:`float` y :class:`decimal.Decimal`. En esencia, " +"lo que hace esta función es una reducción modulo ``P`` para un valor fijo " +"del número primo ``P``. El valor de ``P`` está disponible en Python como " +"atributo de :data:`sys.hash_info` con el nombre de :attr:`modulus`." #: ../Doc/library/stdtypes.rst:658 msgid "" "Currently, the prime used is ``P = 2**31 - 1`` on machines with 32-bit C " "longs and ``P = 2**61 - 1`` on machines with 64-bit C longs." msgstr "" +"Actualmente, el número primo usado es ``P = 2**31 - 1`` para máquinas de 32 " +"bits, y ``P = 2**61 - 1`` en máquinas de 64 bits." #: ../Doc/library/stdtypes.rst:661 msgid "Here are the rules in detail:" -msgstr "" +msgstr "Aquí están las reglas en detalle:" #: ../Doc/library/stdtypes.rst:663 msgid "" @@ -950,6 +1193,9 @@ msgid "" "by ``P``, define ``hash(x)`` as ``m * invmod(n, P) % P``, where ``invmod(n, " "P)`` gives the inverse of ``n`` modulo ``P``." msgstr "" +"Si ``x = m / n`` es un número racional no negativo y ``n`` no es divisible " +"por ``P``, se define ``hash(x)`` como ``m * invmod(n, P) % P``, donde " +"``invmod(n, P)`` retorna la inversa de ``n`` modulo ``P``." #: ../Doc/library/stdtypes.rst:667 msgid "" @@ -958,12 +1204,18 @@ msgid "" "above doesn't apply; in this case define ``hash(x)`` to be the constant " "value ``sys.hash_info.inf``." msgstr "" +"Si ``x = m / n`` es un número racional no negativo y ``n`` es divisible por " +"``P`` (Pero no así ``m``), entonces ``n`` no tiene módulo inverso de ``P`` y " +"no se puede aplicar la regla anterior; en este caso, ``hash(x)``retorna el " +"valor constante definido en ``sys.hash_info.inf``." #: ../Doc/library/stdtypes.rst:672 msgid "" "If ``x = m / n`` is a negative rational number define ``hash(x)`` as ``-" "hash(-x)``. If the resulting hash is ``-1``, replace it with ``-2``." msgstr "" +"Si ``x = m / n`` es un número racional negativo se define ``hash(x)`` como " +"``-hash(x)``. Si el resultado fuera ``-1``, lo cambia por ``-2``." #: ../Doc/library/stdtypes.rst:676 msgid "" @@ -972,6 +1224,11 @@ msgid "" "negative infinity, or nans (respectively). (All hashable nans have the same " "hash value.)" msgstr "" +"Los valores concretos ``sys.hash_info.inf``, ``-sys.hash_info.inf`` y ``sys." +"hash_info.nan`` se usan como valores *hash* de \n" +"infinito positivo, infinito negativo y *NaN* (*Not a Number*), " +"respectivamente. (Todos los valores *NaN* comparten el mismo valor de " +"*hash*)." #: ../Doc/library/stdtypes.rst:681 msgid "" @@ -981,6 +1238,13 @@ msgid "" "lies in ``range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - " "1))``. Again, if the result is ``-1``, it's replaced with ``-2``." msgstr "" +"Para un número complejo ``z`` (Una instancia de la clase :class:`complex`), " +"el valor de *hash* se calcula combinando los valores de *hash* de la parte " +"real e imaginaria, usando la fórmula ``hash(z.real) + sys.hash_info.imag * " +"hash(z.imag)``, módulo reducido ``2**sys.hash_info.width``, de forma que el " +"valor obtenido esté en en rango ``range(-2**(sys.hash_info.width - 1), " +"2**(sys.hash_info.width - 1))``. De nuevo, si el resultado fuera ``-1``, se " +"reemplaza por ``-2``." #: ../Doc/library/stdtypes.rst:689 msgid "" @@ -988,10 +1252,13 @@ msgid "" "the built-in hash, for computing the hash of a rational number, :class:" "`float`, or :class:`complex`::" msgstr "" +"Para clarificar las reglas previas, aquí mostramos un ejemplo de código " +"Python, equivalente al cálculo realizado en la función *hash*, para calcular " +"el *hash* de un número racional, de tipo :class:`float`, o :class:`complex`::" #: ../Doc/library/stdtypes.rst:744 msgid "Iterator Types" -msgstr "" +msgstr "Tipos de iteradores" #: ../Doc/library/stdtypes.rst:752 msgid "" @@ -1000,13 +1267,19 @@ msgid "" "support iteration. Sequences, described below in more detail, always " "support the iteration methods." msgstr "" +"Python soporta el concepto de iteradores sobre contenedores. Esto se " +"implementa usando dos métodos diferentes: Estos son usados por las clases " +"definidas por el usuario para soportar iteración. Las secuencias, que se " +"describirán con mayor detalle, siempre soportan la iteración." #: ../Doc/library/stdtypes.rst:757 msgid "" "One method needs to be defined for container objects to provide iteration " "support:" msgstr "" +"Para que un objeto contenedor soporte iteración, debe definir un método:" +# Como traducimos slot? #: ../Doc/library/stdtypes.rst:764 msgid "" "Return an iterator object. The object is required to support the iterator " @@ -1018,12 +1291,22 @@ msgid "" "member:`~PyTypeObject.tp_iter` slot of the type structure for Python objects " "in the Python/C API." msgstr "" +"Retorna un objeto iterador. Este objeto es requerido para soportar el " +"protocolo de iteración que se describe a continuación. Si un contenedor " +"soporta diferentes tipos de iteración, se pueden implementar métodos " +"adicionales para estos iteradores (por ejemplo, un tipo de contenedor que " +"puede soportar distintas formas de iteración podría ser una estructura de " +"tipo árbol que proporcione a la vez un recorrido en profundidad o en " +"anchura). Este método se corresponde al *slot* :c:member:`~PyTypeObject." +"tp_iter` de la estructura usada para los objetos Python en la API Python/C." #: ../Doc/library/stdtypes.rst:773 msgid "" "The iterator objects themselves are required to support the following two " "methods, which together form the :dfn:`iterator protocol`:" msgstr "" +"Los objetos iteradores en si necesitan definir los siguientes dos métodos, " +"que forma juntos el :dfn:`protocolo iterador`:" #: ../Doc/library/stdtypes.rst:779 msgid "" @@ -1032,6 +1315,11 @@ msgid "" "`in` statements. This method corresponds to the :c:member:`~PyTypeObject." "tp_iter` slot of the type structure for Python objects in the Python/C API." msgstr "" +"Retorna el propio objeto iterador. Este método es necesario para permitir " +"tanto a los contenedores como a los iteradores usar la palabras clave :" +"keyword:`for` o :keyword:`in`. Este método se corresponde con el *slot* :c:" +"member:`~PyTypeObject.tp_iter` de la estructura usada para los objetos " +"Python en la API Python/C." #: ../Doc/library/stdtypes.rst:787 msgid "" @@ -1040,6 +1328,10 @@ msgid "" "member:`~PyTypeObject.tp_iternext` slot of the type structure for Python " "objects in the Python/C API." msgstr "" +"Retorna el siguiente elemento del contenedor. Si no hubiera más elementos, " +"eleva la excepción :exc:`StopIteration`. Este método se corresponde con el " +"*slot* :c:member:`~PyTypeObject.tp_iternext` de la estructura usada para los " +"objetos Python en la API Python/C." #: ../Doc/library/stdtypes.rst:792 msgid "" @@ -1048,6 +1340,10 @@ msgid "" "forms. The specific types are not important beyond their implementation of " "the iterator protocol." msgstr "" +"Python define varios objetos iteradores que permiten iterar sobre las " +"secuencias, ya sean generales o específicas, diccionarios y otras " +"estructuras de datos especializadas. Los tipos específicos no son tan " +"importantes como la implementación del protocolo iterador." #: ../Doc/library/stdtypes.rst:797 msgid "" @@ -1055,10 +1351,13 @@ msgid "" "`StopIteration`, it must continue to do so on subsequent calls. " "Implementations that do not obey this property are deemed broken." msgstr "" +"Una vez que la ejecución del método :meth:`~iterator.__next__` eleva la " +"excepción :exc:`StopIteration`, debe continuar haciéndolo en subsiguientes " +"llamadas al método. Si una implementación no cumple esto, se considera rota." #: ../Doc/library/stdtypes.rst:805 msgid "Generator Types" -msgstr "" +msgstr "Tipos Generador" #: ../Doc/library/stdtypes.rst:807 msgid "" @@ -1069,10 +1368,17 @@ msgid "" "`~generator.__next__` methods. More information about generators can be " "found in :ref:`the documentation for the yield expression `." msgstr "" +"Los :term:`generator` de Python proporcionan una manera cómoda de " +"implementar el protocolo iterador. Si un objeto de tipo contenedor " +"implementa el método :meth:`__iter__` como un generador, de forma automática " +"este retornará un objeto iterador (Técnicamente, un objeto generador) que " +"implementa los métodos :meth:`__iter__` y :meth:`~generator.__next__`. Se " +"puede obtener más información acerca de los generadores en :ref:`la " +"documentación de la expresión yield `." #: ../Doc/library/stdtypes.rst:819 msgid "Sequence Types --- :class:`list`, :class:`tuple`, :class:`range`" -msgstr "" +msgstr "Tipos secuencia --- :class:`list`, :class:`tuple`, :class:`range`" #: ../Doc/library/stdtypes.rst:821 msgid "" @@ -1081,10 +1387,14 @@ msgid "" "` and :ref:`text strings ` are described in dedicated " "sections." msgstr "" +"Hay tres tipos básicos de secuencia: listas, tuplas y objetos de tipo rango. " +"Existen tipos de secuencia especiales usados para el procesado de :ref:" +"`datos binarios ` y :ref:`cadenas de caracteres ` que se " +"describirán en secciones específicas." #: ../Doc/library/stdtypes.rst:830 msgid "Common Sequence Operations" -msgstr "" +msgstr "Operaciones comunes de las secuencias" #: ../Doc/library/stdtypes.rst:834 msgid "" @@ -1093,6 +1403,10 @@ msgid "" "provided to make it easier to correctly implement these operations on custom " "sequence types." msgstr "" +"Las operaciones de la siguiente tabla están soportadas por la mayoría de los " +"tipos secuencia, tanto mutables como inmutables. La clase ABC :class:" +"`collections.abc.Sequence` se incluye para facilitar la implementación " +"correcta de estas operaciones en nuestros propios tipos de secuencias." #: ../Doc/library/stdtypes.rst:839 msgid "" @@ -1101,6 +1415,10 @@ msgid "" "are integers and *x* is an arbitrary object that meets any type and value " "restrictions imposed by *s*." msgstr "" +"La tabla lista las operaciones ordenadas de menor a mayor prioridad. En la " +"tabla, *s* y *t* representan secuencias del mismo tipo, *n*, *i*, *j* y *k* " +"son números enteros y *x* es un objeto arbitrario que cumple con cualquier " +"restricción de tipo o valor impuesta por *s*." #: ../Doc/library/stdtypes.rst:844 msgid "" @@ -1109,124 +1427,131 @@ msgid "" "operations have the same priority as the corresponding numeric operations. " "[3]_" msgstr "" +"Las operaciones ``in`` y ``not in`` tienen la misma prioridad que los " +"operadores de comparación. Las operaciones ``+`` (Concatenación) y ``*`` " +"(Repetición) tienen la misma prioridad que sus equivalentes numéricos [3]_" #: ../Doc/library/stdtypes.rst:865 msgid "``x in s``" -msgstr "" +msgstr "``x in s``" #: ../Doc/library/stdtypes.rst:865 msgid "``True`` if an item of *s* is equal to *x*, else ``False``" msgstr "" +"``True`` si un elemento de *s* es igual a *x*, ``False`` en caso contrario" #: ../Doc/library/stdtypes.rst:868 msgid "``x not in s``" -msgstr "" +msgstr "``x not in s``" #: ../Doc/library/stdtypes.rst:868 msgid "``False`` if an item of *s* is equal to *x*, else ``True``" msgstr "" +"``False`` si un elemento de *s* es igual a *x*, ``True`` en caso contrario" #: ../Doc/library/stdtypes.rst:871 msgid "``s + t``" -msgstr "" +msgstr "``s + t``" #: ../Doc/library/stdtypes.rst:871 msgid "the concatenation of *s* and *t*" -msgstr "" +msgstr "la concatenación de *s* y *t*" #: ../Doc/library/stdtypes.rst:871 msgid "(6)(7)" -msgstr "" +msgstr "(6)(7)" #: ../Doc/library/stdtypes.rst:874 msgid "``s * n`` or ``n * s``" -msgstr "" +msgstr "``s * n`` o ``n * s``" #: ../Doc/library/stdtypes.rst:874 msgid "equivalent to adding *s* to itself *n* times" -msgstr "" +msgstr "equivale a concatenar *s* consigo mismo *n* veces" #: ../Doc/library/stdtypes.rst:874 msgid "(2)(7)" -msgstr "" +msgstr "(2)(7)" #: ../Doc/library/stdtypes.rst:877 msgid "``s[i]``" -msgstr "" +msgstr "``s[i]``" #: ../Doc/library/stdtypes.rst:877 msgid "*i*\\ th item of *s*, origin 0" -msgstr "" +msgstr "El elemento *i-esimo* de *s*, empezando a contar en 0" #: ../Doc/library/stdtypes.rst:879 msgid "``s[i:j]``" -msgstr "" +msgstr "``s[i:j]``" #: ../Doc/library/stdtypes.rst:879 msgid "slice of *s* from *i* to *j*" -msgstr "" +msgstr "la rebanada de *s* desde *i* hasta *j*" #: ../Doc/library/stdtypes.rst:879 msgid "(3)(4)" -msgstr "" +msgstr "(3)(4)" #: ../Doc/library/stdtypes.rst:881 msgid "``s[i:j:k]``" -msgstr "" +msgstr "``s[i:j:k]``" #: ../Doc/library/stdtypes.rst:881 msgid "slice of *s* from *i* to *j* with step *k*" -msgstr "" +msgstr "la rebanada de *s* desde *i* hasta *j*, con paso *j*" #: ../Doc/library/stdtypes.rst:881 msgid "(3)(5)" -msgstr "" +msgstr "(3)(5)" #: ../Doc/library/stdtypes.rst:884 msgid "``len(s)``" -msgstr "" +msgstr "``len(s)``" #: ../Doc/library/stdtypes.rst:884 msgid "length of *s*" -msgstr "" +msgstr "longitud de *s*" #: ../Doc/library/stdtypes.rst:886 msgid "``min(s)``" -msgstr "" +msgstr "``min(s)``" #: ../Doc/library/stdtypes.rst:886 msgid "smallest item of *s*" -msgstr "" +msgstr "el elemento más pequeño de *s*" #: ../Doc/library/stdtypes.rst:888 msgid "``max(s)``" -msgstr "" +msgstr "``max(s)``" #: ../Doc/library/stdtypes.rst:888 msgid "largest item of *s*" -msgstr "" +msgstr "el elemento más grande de *s*" #: ../Doc/library/stdtypes.rst:890 msgid "``s.index(x[, i[, j]])``" -msgstr "" +msgstr "``s.index(x[, i[, j]])``" #: ../Doc/library/stdtypes.rst:890 msgid "" "index of the first occurrence of *x* in *s* (at or after index *i* and " "before index *j*)" msgstr "" +"índice de la primera ocurrencia de *x* en *s* (en la posición *i* o " +"superior, y antes de *j*)" #: ../Doc/library/stdtypes.rst:890 ../Doc/library/stdtypes.rst:3391 msgid "\\(8)" -msgstr "" +msgstr "\\(8)" #: ../Doc/library/stdtypes.rst:894 msgid "``s.count(x)``" -msgstr "" +msgstr "``s.count(x)``" #: ../Doc/library/stdtypes.rst:894 msgid "total number of occurrences of *x* in *s*" -msgstr "" +msgstr "número total de ocurrencias de *x* en *s*" #: ../Doc/library/stdtypes.rst:898 msgid "" @@ -1236,6 +1561,12 @@ msgid "" "and the two sequences must be of the same type and have the same length. " "(For full details see :ref:`comparisons` in the language reference.)" msgstr "" +"También se pueden comparar secuencias del mismo tipo. En particular, las " +"tuplas y las listas se comparan por orden lexicográfico, comparando los " +"elementos en la misma posición. Esto significa que, para que se consideren " +"iguales, todos los elementos correspondientes deben ser iguales entre si, y " +"las dos secuencias deben ser del mismo tipo y de la misma longitud (Para más " +"detalles, véase :ref:`comparisons` en la referencia del lenguaje)." #: ../Doc/library/stdtypes.rst:907 msgid "" @@ -1244,6 +1575,10 @@ msgid "" "as :class:`str`, :class:`bytes` and :class:`bytearray`) also use them for " "subsequence testing::" msgstr "" +"Aunque las operaciones ``in`` y ``not in`` se usan generalmente para " +"comprobar si un elemento está dentro de un contenedor, en algunas secuencias " +"especializadas (Como :class:`str`, :class:`bytes` y :class:`bytearray`) " +"también se pueden usar para comprobar si está incluida una secuencia::" #: ../Doc/library/stdtypes.rst:916 msgid "" @@ -1252,6 +1587,10 @@ msgid "" "not copied; they are referenced multiple times. This often haunts new " "Python programmers; consider::" msgstr "" +"Valores de *n* menores que ``0`` se consideran como ``0`` (Que produce una " +"secuencia vacía del mismo tipo que *s*). Nótese que los elementos de la " +"secuencia *s* no se copian, sino que se referencian múltiples veces. Esto a " +"menudo confunde a programadores noveles de Python; considérese::" #: ../Doc/library/stdtypes.rst:928 msgid "" @@ -1260,12 +1599,19 @@ msgid "" "empty list. Modifying any of the elements of ``lists`` modifies this single " "list. You can create a list of different lists this way::" msgstr "" +"Lo que ha pasado es que ``[[]]`` es una lista de un elemento, siendo este " +"elemento una lista vacía, así que los tres elementos de ``[[]] * 3`` son " +"referencias a la misma lista vacía. Modificar cualquiera de los elementos de " +"``lists`` modifica la lista inicial. Para crear una lista de listas " +"independientes entre si, se puede hacer::" #: ../Doc/library/stdtypes.rst:940 msgid "" "Further explanation is available in the FAQ entry :ref:`faq-multidimensional-" "list`." msgstr "" +"Se puede consultar una explicación más completa en esta entrada de la lista " +"de preguntas más frecuentes :ref:`faq-multidimensional-list`." #: ../Doc/library/stdtypes.rst:944 msgid "" @@ -1273,6 +1619,9 @@ msgid "" "``len(s) + i`` or ``len(s) + j`` is substituted. But note that ``-0`` is " "still ``0``." msgstr "" +"Si *i* o *j* es negativo, el índice es relativo al final de la secuencia " +"*s*: Se realiza la sustitución ``len(s) + i`` o ``len(s) + j``. Nótese que " +"``-0`` sigue siendo ``0``." #: ../Doc/library/stdtypes.rst:949 msgid "" @@ -1282,6 +1631,11 @@ msgid "" "*j* is omitted or ``None``, use ``len(s)``. If *i* is greater than or equal " "to *j*, the slice is empty." msgstr "" +"La rebanada de *s* desde *i* a *j* se define como la secuencia de elementos " +"con índice *k*, de forma que ``i <= k < j``. Si *i* o *j* es mayor que " +"``len(s)`` se usa ``len(s)``. Si *i* se omite o es ``None``, se usa ``0``. " +"Si *j* se omite o es ``None``, se usa ``len(s)``. Si *i* es mayor o igual a " +"*j*, la rebanada estaría vacía." #: ../Doc/library/stdtypes.rst:956 msgid "" @@ -1295,6 +1649,16 @@ msgid "" "(which end depends on the sign of *k*). Note, *k* cannot be zero. If *k* is " "``None``, it is treated like ``1``." msgstr "" +"La rebanada de *s*, desde *i* hasta *j* con paso *k*, se define como la " +"secuencia de elementos con índice ``x = i + n*k`` tal que ``0 <= n < (j-i)/" +"k``. En otras palabras, los índices son ``i``, ``i+k``, ``i+2*k``, ``i+3*k`` " +"y así consecutivamente, hasta que se alcance el valor de *j* (Pero sin " +"incluir nunca *j*). Cuando *k* es positivo, *i* y *j* se limitan al valor de " +"``len(s)``, si fueran mayores. Si *k* es negativo, *i* y *j* se reducen de " +"``len(s) - 1``. Si *i* o *j* se omiten o su valor es ``None``, se convierten " +"es valores \"finales\" (Donde el sentido de final depende del signo de *k*). " +"Nótese que *k* no puede valer ``0``. Si *k* vale ``None``, se considera como " +"``1``." #: ../Doc/library/stdtypes.rst:967 msgid "" @@ -1303,6 +1667,11 @@ msgid "" "quadratic runtime cost in the total sequence length. To get a linear " "runtime cost, you must switch to one of the alternatives below:" msgstr "" +"La concatenación de secuencias inmutables siempre produce un nuevo objeto. " +"Esto significa que construir una secuencia usando la concatenación tiene un " +"coste en ejecución cuadrático respecto al tamaño de la secuencia final. Para " +"obtener un rendimiento lineal, se puede optar por una de las alternativas " +"siguientes:" #: ../Doc/library/stdtypes.rst:972 msgid "" @@ -1310,7 +1679,12 @@ msgid "" "`str.join` at the end or else write to an :class:`io.StringIO` instance and " "retrieve its value when complete" msgstr "" +"en vez de concatenar objetos de tipo :class:`str`, se puede construir una " +"lista y usar finalmente el método :meth:`str.join`, o bien utilizar una " +"instancia de la clase :class:`io.StringIO` y recuperar el valor final " +"completo" +# Duda sobre como traducir *in place* #: ../Doc/library/stdtypes.rst:976 msgid "" "if concatenating :class:`bytes` objects, you can similarly use :meth:`bytes." @@ -1318,14 +1692,21 @@ msgid "" "class:`bytearray` object. :class:`bytearray` objects are mutable and have " "an efficient overallocation mechanism" msgstr "" +"de forma similar, en vez de concatenar objetos de tipo :class:`bytes` se " +"puede usar el método :meth:`bytes.join`, la clase :class:`io.BytesIO`, o se " +"puede realizar una modificación interna usando un objeto de la clase :class:" +"`bytearray`. Los objetos de tipo :class:`bytearray` son mutables y tienen un " +"mecanismo interno de gestión muy eficiente" #: ../Doc/library/stdtypes.rst:981 msgid "if concatenating :class:`tuple` objects, extend a :class:`list` instead" msgstr "" +"en vez de concatenar tuplas (Instancias de :class:`tuple`), usar una lista (:" +"class:`list`) y expandirla" #: ../Doc/library/stdtypes.rst:983 msgid "for other types, investigate the relevant class documentation" -msgstr "" +msgstr "para otros tipos, investiga la documentación relevante de la clase" #: ../Doc/library/stdtypes.rst:987 msgid "" @@ -1333,6 +1714,9 @@ msgid "" "that follow specific patterns, and hence don't support sequence " "concatenation or repetition." msgstr "" +"Algunos tipos de secuencia (como la clase :class:`range`) solo soportan " +"elementos que siguen un patrón específico, y por tanto no soportan la " +"concatenación ni la repetición." #: ../Doc/library/stdtypes.rst:992 msgid "" @@ -1343,10 +1727,17 @@ msgid "" "without copying any data and with the returned index being relative to the " "start of the sequence rather than the start of the slice." msgstr "" +"El método ``index`` eleva la excepción :exc:`ValueError` si *x* no se " +"encuentra en *s*. No todas las implementaciones soportan los parámetros " +"opcionales *i* y *j*. Estos parámetros permiten una búsqueda eficiente de " +"partes de una secuencia. Usar estos parámetros es más o menos equivalente a " +"usar ``s[i:j].index(x)``, pero sin copiar ningún dato y con el valor de " +"índice retornado como valor relativo al inicio de la secuencia, en vez de al " +"inicio de la rebanada." #: ../Doc/library/stdtypes.rst:1003 msgid "Immutable Sequence Types" -msgstr "" +msgstr "Tipos de secuencia inmutables" #: ../Doc/library/stdtypes.rst:1010 msgid "" @@ -1354,6 +1745,9 @@ msgid "" "not also implemented by mutable sequence types is support for the :func:" "`hash` built-in." msgstr "" +"La única operación que las secuencias inmutables implementan generalmente, y " +"que no esta definida también en las secuencias mutables, es el soporte para " +"el cálculo de la función predefinida :func:`hash`." #: ../Doc/library/stdtypes.rst:1014 msgid "" @@ -1361,16 +1755,22 @@ msgid "" "to be used as :class:`dict` keys and stored in :class:`set` and :class:" "`frozenset` instances." msgstr "" +"Este soporte permite usar secuencias inmutables, como por ejemplo las " +"instancias de la clase :class:`tuple`, como claves para diccionarios (:class:" +"`dict`), así como ser almacenadas en conjuntos (:class:`set`) o conjuntos " +"congelados (:class:`frozenset`)." #: ../Doc/library/stdtypes.rst:1018 msgid "" "Attempting to hash an immutable sequence that contains unhashable values " "will result in :exc:`TypeError`." msgstr "" +"Intentar calcular el *hash* de una secuencia inmutable que contenga objetos " +"mutables producirá una excepción de tipo :exc:`TypeError`." #: ../Doc/library/stdtypes.rst:1025 msgid "Mutable Sequence Types" -msgstr "" +msgstr "Tipos de secuencia mutables" #: ../Doc/library/stdtypes.rst:1032 msgid "" @@ -1378,6 +1778,10 @@ msgid "" "The :class:`collections.abc.MutableSequence` ABC is provided to make it " "easier to correctly implement these operations on custom sequence types." msgstr "" +"Las operaciones de la siguiente tabla están definidas para todas los tipos " +"de secuencia mutables. La clase ABC :class:`collections.abc.MutableSequence` " +"se incluye para facilitar la implementación correcta de un tipo de secuencia " +"propio." #: ../Doc/library/stdtypes.rst:1036 msgid "" @@ -1386,144 +1790,172 @@ msgid "" "restrictions imposed by *s* (for example, :class:`bytearray` only accepts " "integers that meet the value restriction ``0 <= x <= 255``)." msgstr "" +"En la tabla, *s* es una instancia de una secuencia de tipo mutable, *t* es " +"cualquier objeto iterable y *x* es un objeto arbitrario que cumple las " +"restricciones de tipo y valor que vengan impuestas por *s* (Como ejemplo, la " +"clase :class:`bytearray` solo acepta enteros que cumplan la condición ``0 <= " +"x <= 255``)." #: ../Doc/library/stdtypes.rst:1060 msgid "``s[i] = x``" -msgstr "" +msgstr "``s[i] = x``" #: ../Doc/library/stdtypes.rst:1060 msgid "item *i* of *s* is replaced by *x*" -msgstr "" +msgstr "el elemento *i* de *s* es reemplazado por *x*" #: ../Doc/library/stdtypes.rst:1063 msgid "``s[i:j] = t``" -msgstr "" +msgstr "``s[i:j] = t``" #: ../Doc/library/stdtypes.rst:1063 msgid "" "slice of *s* from *i* to *j* is replaced by the contents of the iterable *t*" msgstr "" +"la rebanada de valores de *s* que van de *i* a *j* es reemplazada por el " +"contenido del iterador *t*" #: ../Doc/library/stdtypes.rst:1067 msgid "``del s[i:j]``" -msgstr "" +msgstr "``del s[i:j]``" #: ../Doc/library/stdtypes.rst:1067 msgid "same as ``s[i:j] = []``" -msgstr "" +msgstr "equivalente a ``s[i:j] = []``" #: ../Doc/library/stdtypes.rst:1069 msgid "``s[i:j:k] = t``" -msgstr "" +msgstr "``s[i:j:k] = t``" #: ../Doc/library/stdtypes.rst:1069 msgid "the elements of ``s[i:j:k]`` are replaced by those of *t*" msgstr "" +"los elementos de ``s[i:j:k]`` son reemplazados por los elementos de *t*" #: ../Doc/library/stdtypes.rst:1072 msgid "``del s[i:j:k]``" -msgstr "" +msgstr "``del s[i:j:k]``" #: ../Doc/library/stdtypes.rst:1072 msgid "removes the elements of ``s[i:j:k]`` from the list" -msgstr "" +msgstr "borra los elementos de ``s[i:j:k]`` de la lista" #: ../Doc/library/stdtypes.rst:1075 msgid "``s.append(x)``" -msgstr "" +msgstr "``s.append(x)``" #: ../Doc/library/stdtypes.rst:1075 msgid "" "appends *x* to the end of the sequence (same as ``s[len(s):len(s)] = [x]``)" msgstr "" +"añade *x* al final de la secuencia (Equivale a ``s[len(s):len(s)] = [x]``)" #: ../Doc/library/stdtypes.rst:1079 msgid "``s.clear()``" -msgstr "" +msgstr "``s.clear()``" #: ../Doc/library/stdtypes.rst:1079 msgid "removes all items from *s* (same as ``del s[:]``)" -msgstr "" +msgstr "elimina todos los elementos de *s* (Equivale a ``del s[:]``)" #: ../Doc/library/stdtypes.rst:1082 msgid "``s.copy()``" -msgstr "" +msgstr "``s.copy()``" #: ../Doc/library/stdtypes.rst:1082 msgid "creates a shallow copy of *s* (same as ``s[:]``)" -msgstr "" +msgstr "crea una copia superficial de *s* (Equivale a ``s[:]``)" #: ../Doc/library/stdtypes.rst:1085 msgid "``s.extend(t)`` or ``s += t``" -msgstr "" +msgstr "``s.extend(t)`` o ``s += t``" #: ../Doc/library/stdtypes.rst:1085 msgid "" "extends *s* with the contents of *t* (for the most part the same as " "``s[len(s):len(s)] = t``)" msgstr "" +"extiende *s* con los contenidos de *t* (En la mayoría de los casos equivale " +"a ``s[len(s):len(s)] = t``)" #: ../Doc/library/stdtypes.rst:1090 msgid "``s *= n``" -msgstr "" +msgstr "``s *= n``" #: ../Doc/library/stdtypes.rst:1090 msgid "updates *s* with its contents repeated *n* times" -msgstr "" +msgstr "actualiza *s* con su contenido repetido *n* veces" #: ../Doc/library/stdtypes.rst:1093 msgid "``s.insert(i, x)``" -msgstr "" +msgstr "``s.insert(i, x)``" #: ../Doc/library/stdtypes.rst:1093 msgid "" "inserts *x* into *s* at the index given by *i* (same as ``s[i:i] = [x]``)" msgstr "" +"inserta *x* en *s* en la posición indicada por el índice *i* (Equivale a " +"``s[i:i] = [x]``)" #: ../Doc/library/stdtypes.rst:1097 msgid "``s.pop([i])``" -msgstr "" +msgstr "``s.pop([i])``" #: ../Doc/library/stdtypes.rst:1097 msgid "retrieves the item at *i* and also removes it from *s*" msgstr "" +"retorna el elemento en la posición indicada por *i*, y a la vez lo elimina " +"de la secuencia *s*" #: ../Doc/library/stdtypes.rst:1100 msgid "``s.remove(x)``" -msgstr "" +msgstr "``s.remove(x)``" #: ../Doc/library/stdtypes.rst:1100 msgid "remove the first item from *s* where ``s[i]`` is equal to *x*" -msgstr "" +msgstr "elimina el primer elemento de *s* tal que ``s[i]`` sea igual a *x*" #: ../Doc/library/stdtypes.rst:1103 msgid "``s.reverse()``" -msgstr "" +msgstr "``s.reverse()``" +# Duda sobre como traducir *in place* #: ../Doc/library/stdtypes.rst:1103 msgid "reverses the items of *s* in place" -msgstr "" +msgstr "invierte el orden de los elementos de *s*, a nivel interno" #: ../Doc/library/stdtypes.rst:1111 msgid "*t* must have the same length as the slice it is replacing." msgstr "" +"La secuencia *t* debe tener la misma longitud que la rebanada a la que " +"reemplaza." #: ../Doc/library/stdtypes.rst:1114 msgid "" "The optional argument *i* defaults to ``-1``, so that by default the last " "item is removed and returned." msgstr "" +"El parámetro opcional *i* tiene un valor por defecto de ``-1``, así que si " +"no se especifica se retorna el último valor y este se elimina de la " +"secuencia." #: ../Doc/library/stdtypes.rst:1118 msgid ":meth:`remove` raises :exc:`ValueError` when *x* is not found in *s*." msgstr "" +"El método :meth:`remove` eleva la excepción :exc:`ValueError` cuando no se " +"encuentra *x* en *s*." +# side effect ' efecto secundario? #: ../Doc/library/stdtypes.rst:1121 msgid "" "The :meth:`reverse` method modifies the sequence in place for economy of " "space when reversing a large sequence. To remind users that it operates by " "side effect, it does not return the reversed sequence." msgstr "" +"El método :meth:`reverse` modifica la secuencia internamente, por motivos de " +"eficiencia espacial para secuencias muy grandes. Como recordatorio al " +"usuario de que el método produce un efecto secundario, no se retorna la " +"secuencia invertida." #: ../Doc/library/stdtypes.rst:1126 msgid "" @@ -1533,10 +1965,15 @@ msgid "" "`collections.abc.MutableSequence` ABC, but most concrete mutable sequence " "classes provide it." msgstr "" +"Ambos métodos :meth:`clear` y :meth:`!copy` se incluyen por consistencia con " +"las interfaces de clases que no soportan operaciones de rebanado (Como las " +"clases :class:`dict` y :class:`set`). El método :meth:`!copy` no es parte de " +"la clase ABC :class:`collections.abc.MutableSequence`, pero la mayoría de " +"las clases finales de tipo secuencia mutable lo incluyen." #: ../Doc/library/stdtypes.rst:1132 msgid ":meth:`clear` and :meth:`!copy` methods." -msgstr "" +msgstr "Los métodos :meth:`clear` y :meth:`!copy`." #: ../Doc/library/stdtypes.rst:1136 msgid "" @@ -1545,10 +1982,15 @@ msgid "" "the sequence are not copied; they are referenced multiple times, as " "explained for ``s * n`` under :ref:`typesseq-common`." msgstr "" +"El valor de *n* es un entero, o un objeto que implemente el método :meth:" +"`~object.__index__`. Los valores negativos, junto con el cero, producen una " +"lista vacía. Los elementos de la secuencia no son copiados, sino que se " +"referencian múltiples veces, tal y como se explicó para ``s * n`` en :ref:" +"`typesseq-common`." #: ../Doc/library/stdtypes.rst:1145 msgid "Lists" -msgstr "" +msgstr "Listas" #: ../Doc/library/stdtypes.rst:1149 msgid "" @@ -1556,27 +1998,33 @@ msgid "" "homogeneous items (where the precise degree of similarity will vary by " "application)." msgstr "" +"Las listas son secuencia mutables, usadas normalmente para almacenar " +"colecciones de elementos homogéneos (Donde el grado de similitud de los " +"mismo depende de la aplicación)." #: ../Doc/library/stdtypes.rst:1155 msgid "Lists may be constructed in several ways:" -msgstr "" +msgstr "Las listas se pueden construir de diferentes formas:" #: ../Doc/library/stdtypes.rst:1157 msgid "Using a pair of square brackets to denote the empty list: ``[]``" -msgstr "" +msgstr "Usando un par de corchetes para definir una lista vacía: ``[]``" #: ../Doc/library/stdtypes.rst:1158 msgid "" "Using square brackets, separating items with commas: ``[a]``, ``[a, b, c]``" msgstr "" +"Usando corchetes, separando los elementos incluidos con comas: ``[a]``, " +"``[a, b, c]``" #: ../Doc/library/stdtypes.rst:1159 msgid "Using a list comprehension: ``[x for x in iterable]``" msgstr "" +"Usando una lista intensiva o por comprensión: ``[x for x in iterable]``" #: ../Doc/library/stdtypes.rst:1160 msgid "Using the type constructor: ``list()`` or ``list(iterable)``" -msgstr "" +msgstr "Usando el constructor de tipo: ``list()`` o ``list(iterable)``" #: ../Doc/library/stdtypes.rst:1162 msgid "" @@ -1588,12 +2036,22 @@ msgid "" "returns ``[1, 2, 3]``. If no argument is given, the constructor creates a " "new empty list, ``[]``." msgstr "" +"La lista se construye con los mismos elementos y en el mismo orden que " +"*iterable*, donde *iterable* puede ser una secuencia, un contenedor que " +"soporta iteración, o un objeto iterador. Si *iterable* es de por si una " +"lista, se construye y retorna una copia, como si se hubiera llamado a " +"``iterable[:]``. Por ejemplo, ``list('abc')`` retorna ``['a', 'b', 'c']`` y " +"``list( (1, 2, 3) )`` retorna ``[1, 2, 3]``. Si no se pasan parámetros, se " +"construye una nueva lista vacía, ``[]``." +# Traduccion de built-ins #: ../Doc/library/stdtypes.rst:1171 msgid "" "Many other operations also produce lists, including the :func:`sorted` built-" "in." msgstr "" +"Muchas otras operaciones también producen listas, incluyendo la función " +"básica :func:`sorted`." #: ../Doc/library/stdtypes.rst:1174 msgid "" @@ -1601,6 +2059,9 @@ msgid "" "` sequence operations. Lists also provide the following " "additional method:" msgstr "" +"Las listas implementan todas las operaciones :ref:`comunes ` y :ref:`mutables ` propias de las secuencias. " +"Además, las listas incorporan los siguientes métodos:" #: ../Doc/library/stdtypes.rst:1180 msgid "" @@ -1609,12 +2070,19 @@ msgid "" "the entire sort operation will fail (and the list will likely be left in a " "partially modified state)." msgstr "" +"Este método ordena la lista *in situ* (se modifica internamente), usando " +"unicamente comparaciones de tipo ``<``. Las excepciones no son capturadas " +"internamente: si alguna comparación falla, la operación entera de ordenación " +"falla (Y la lista probablemente haya quedado modificada parcialmente)." +# Ver como se ha traducido la referencia. #: ../Doc/library/stdtypes.rst:1185 msgid "" ":meth:`sort` accepts two arguments that can only be passed by keyword (:ref:" "`keyword-only arguments `):" msgstr "" +"El método :meth:`sort` acepta dos parámetros, que solo pueden pasarse por " +"nombre (:ref:`keyword-only arguments `):" #: ../Doc/library/stdtypes.rst:1188 msgid "" @@ -1624,18 +2092,30 @@ msgid "" "for the entire sorting process. The default value of ``None`` means that " "list items are sorted directly without calculating a separate key value." msgstr "" +"El parámetro *key* especifica una función de un argumento que se usa para " +"obtener, para cada elemento de la lista, un valor concreto o clave (*key*) a " +"usar en las operaciones de comparación (Por ejemplo, ``key=str.lower``). El " +"elemento clave para cada elemento se calcula una única vez y se reutiliza " +"para todo el proceso de ordenamiento. El valor por defecto, ``None``, hace " +"que la lista se ordene comparando directamente los elementos, sin obtener " +"valores clave." #: ../Doc/library/stdtypes.rst:1195 msgid "" "The :func:`functools.cmp_to_key` utility is available to convert a 2.x style " "*cmp* function to a *key* function." msgstr "" +"La utilidad :func:`functools.cmp_to_key` se puede usar para convertir una " +"función *cmp* del estilo de la versión 2.x a una función *key*." #: ../Doc/library/stdtypes.rst:1198 msgid "" "*reverse* is a boolean value. If set to ``True``, then the list elements " "are sorted as if each comparison were reversed." msgstr "" +"El valor de *reverse* es un valor booleano. Si se define como ``True``, " +"entonces los elementos de la lista se ordenan como si las operaciones de " +"comparación se hubiesen invertido." #: ../Doc/library/stdtypes.rst:1201 msgid "" @@ -1644,6 +2124,10 @@ msgid "" "not return the sorted sequence (use :func:`sorted` to explicitly request a " "new sorted list instance)." msgstr "" +"Este método modifica la lista *in situ*, para ahorrar espacio cuando se " +"ordena una secuencia muy grande. Para recordar a los usuarios que funciona " +"de esta manera, no se retorna la secuencia ordenada (Puedes usar :func:" +"`sorted` para obtener de forma explicita una nueva secuencia ordenada)." #: ../Doc/library/stdtypes.rst:1206 msgid "" @@ -1652,11 +2136,18 @@ msgid "" "--- this is helpful for sorting in multiple passes (for example, sort by " "department, then by salary grade)." msgstr "" +"El método :meth:`sort` es estable. Una algoritmo de ordenación es estable si " +"garantiza que no se cambia el orden relativo que mantienen inicialmente los " +"elementos que se consideran iguales --- Esto es útil para realizar " +"ordenaciones en múltiples fases (Por ejemplo, ordenar por departamento y " +"después por salario)." #: ../Doc/library/stdtypes.rst:1211 msgid "" "For sorting examples and a brief sorting tutorial, see :ref:`sortinghowto`." msgstr "" +"Para ver ejemplos de ordenación y un breve tutorial sobre el tema, véase :" +"ref:`sortinghowto`." #: ../Doc/library/stdtypes.rst:1215 msgid "" @@ -1665,10 +2156,15 @@ msgid "" "list appear empty for the duration, and raises :exc:`ValueError` if it can " "detect that the list has been mutated during a sort." msgstr "" +"Mientras una lista está siendo ordenada, los efectos de intentar " +"modificarla, o incluso examinarla, no están definidos. La implementación en " +"C de Python hace que la lista parezca vacía durante la ordenación, y eleva " +"una excepción del tipo :exc:`ValueError` si detecta un cambio en la lista " +"durante el proceso de ordenación." #: ../Doc/library/stdtypes.rst:1224 msgid "Tuples" -msgstr "" +msgstr "Tuplas" #: ../Doc/library/stdtypes.rst:1228 msgid "" @@ -1678,26 +2174,37 @@ msgid "" "homogeneous data is needed (such as allowing storage in a :class:`set` or :" "class:`dict` instance)." msgstr "" +"Las tuplas son secuencias inmutables, usadas normalmente para almacenar " +"colecciones de datos heterogéneos (Como las duplas o tuplas de dos elementos " +"producidas por la función básica :func:`enumerate`). También son usadas en " +"aquellos casos donde se necesite una secuencia inmutable de datos " +"heterogéneos (Como por ejemplo permitir el almacenamiento en un objeto de " +"tipo :class:`set` o :class:`dict`)." #: ../Doc/library/stdtypes.rst:1236 msgid "Tuples may be constructed in a number of ways:" -msgstr "" +msgstr "Las tuplas se pueden construir de diferentes maneras:" #: ../Doc/library/stdtypes.rst:1238 msgid "Using a pair of parentheses to denote the empty tuple: ``()``" msgstr "" +"Usando un par de símbolos de paréntesis, para indicar una tupla vacía: ``()``" #: ../Doc/library/stdtypes.rst:1239 msgid "Using a trailing comma for a singleton tuple: ``a,`` or ``(a,)``" msgstr "" +"Usando una coma al final, para crear una tupla de un único elemento: ``a,`` " +"o ``(a,)``" #: ../Doc/library/stdtypes.rst:1240 msgid "Separating items with commas: ``a, b, c`` or ``(a, b, c)``" -msgstr "" +msgstr "Separando los elementos por comas: ``a, b, c`` o ``(a, b, c)``" #: ../Doc/library/stdtypes.rst:1241 msgid "Using the :func:`tuple` built-in: ``tuple()`` or ``tuple(iterable)``" msgstr "" +"Usando la función básica :func:`tuple` built-in: ``tuple()`` o " +"``tuple(iterable)``" #: ../Doc/library/stdtypes.rst:1243 msgid "" @@ -1709,6 +2216,13 @@ msgid "" "3)``. If no argument is given, the constructor creates a new empty tuple, " "``()``." msgstr "" +"El constructor genera una tupla cuyos elementos son los mismos y están en el " +"mismo orden que los elementos del *iterable*, donde *iterable* puede ser una " +"secuencia, un contenedor que soporta iteración, o un objeto de tipo " +"*iterator*. Si *iterable* es ya de por si una tupla, se retorna sin cambiar. " +"Por ejemplo, ``tuple('abc')`` retorna ``('a', 'b', 'c')`` y ``tuple( [1, 2, " +"3] )`` retorna ``(1, 2, 3)``. Si no se indica ningún parámetro, el " +"constructor creará una nueva tupla vacía. ``()``." #: ../Doc/library/stdtypes.rst:1251 msgid "" @@ -1718,12 +2232,20 @@ msgid "" "function call with three arguments, while ``f((a, b, c))`` is a function " "call with a 3-tuple as the sole argument." msgstr "" +"Nótese que es la coma la que realmente construye la tupla, no los " +"paréntesis. Los paréntesis son opcionales, excepto en el caso de la tupla " +"vacía, o cuando se necesitan para evitar una ambigüedad sintáctica. Por " +"ejemplo, ``f(a, b, c)`` es una llamada a una función con tres parámetros, " +"pero ``f((a, b, c))`` es una llamada a una función con un único parámetro, " +"en este caso una tupla de tres elementos." #: ../Doc/library/stdtypes.rst:1257 msgid "" "Tuples implement all of the :ref:`common ` sequence " "operations." msgstr "" +"Las tuplas implementan todas las operaciones de secuencia :ref:`common " +"`." #: ../Doc/library/stdtypes.rst:1260 msgid "" @@ -1731,16 +2253,22 @@ msgid "" "access by index, :func:`collections.namedtuple` may be a more appropriate " "choice than a simple tuple object." msgstr "" +"Para colecciones de datos heterogéneos donde el acceso por nombre resulta " +"más claro que por índice, quizá crear una tupla con nombres (:func:" +"`collections.namedtuple`) pueden ser más apropiado." #: ../Doc/library/stdtypes.rst:1268 msgid "Ranges" -msgstr "" +msgstr "Rangos" #: ../Doc/library/stdtypes.rst:1272 msgid "" "The :class:`range` type represents an immutable sequence of numbers and is " "commonly used for looping a specific number of times in :keyword:`for` loops." msgstr "" +"Los objetos de tipo :class:`range` representan una secuencia inmutable de " +"números y se usan habitualmente para ejecutar un bucle :keyword:`for` un " +"número determinado de veces." #: ../Doc/library/stdtypes.rst:1279 msgid "" @@ -1750,12 +2278,21 @@ msgid "" "*start* argument is omitted, it defaults to ``0``. If *step* is zero, :exc:" "`ValueError` is raised." msgstr "" +"Los parámetros usados por el constructor del rango deben ser números enteros " +"(O bien objetos de tipo :class:`int` o instancias de una clase que " +"implemente el método especial ``__index__``). Si el parámetro *step* se " +"omite, se asume el valor ``1``. Si se omite el parámetro ``start``, se toma " +"como ``0``. Si se intenta usar ``0`` como valor de ``step``, se eleva una " +"excepción de tipo :exc:`ValueError`." #: ../Doc/library/stdtypes.rst:1285 msgid "" "For a positive *step*, the contents of a range ``r`` are determined by the " "formula ``r[i] = start + step*i`` where ``i >= 0`` and ``r[i] < stop``." msgstr "" +"Para un valor positivo de *step*, el contenido del rango ``r`` viene " +"determinado por la fórmula ``r[i] = start + step*i`` donde ``i >= 0`` y " +"``r[i] < stop``." #: ../Doc/library/stdtypes.rst:1289 msgid "" @@ -1763,6 +2300,9 @@ msgid "" "formula ``r[i] = start + step*i``, but the constraints are ``i >= 0`` and " "``r[i] > stop``." msgstr "" +"Para un valor negativo de *step*, el contenido del rango sigue estando " +"determinado por la fórmula ``r[i] = start + step*i``, pero las restricciones " +"ahora son ``i >= 0`` y ``r[i] > stop``." #: ../Doc/library/stdtypes.rst:1293 msgid "" @@ -1770,6 +2310,10 @@ msgid "" "Ranges do support negative indices, but these are interpreted as indexing " "from the end of the sequence determined by the positive indices." msgstr "" +"Un objeto de tipo rango se considera vacío si ``r[0]`` no cumple con las " +"restricciones de valor. Los rangos soportan índices negativos, pero estos " +"son interpretados como índices considerados desde el final de la secuencia " +"determinada por los índices positivos." #: ../Doc/library/stdtypes.rst:1298 msgid "" @@ -1777,10 +2321,13 @@ msgid "" "permitted but some features (such as :func:`len`) may raise :exc:" "`OverflowError`." msgstr "" +"Los rangos que contengan valores mayores que :data:`sys.maxsize` se " +"permiten, pero algunas capacidades (como la función :func:`len`) pueden " +"elevar una excepción de tipo :exc:`OverflowError`." #: ../Doc/library/stdtypes.rst:1302 msgid "Range examples::" -msgstr "" +msgstr "Ejemplos de rangos::" #: ../Doc/library/stdtypes.rst:1319 msgid "" @@ -1789,22 +2336,27 @@ msgid "" "objects can only represent sequences that follow a strict pattern and " "repetition and concatenation will usually violate that pattern)." msgstr "" +"Los rangos implementan todas las operaciones :ref:`comunes ` de las secuencias, excepto la concatenación y la repetición (Esto " +"es porque los objetos de tipo rango solamente pueden representar secuencias " +"que siguen un patrón estricto, y tanto la repetición como la concatenación " +"pueden romperlo)." #: ../Doc/library/stdtypes.rst:1326 msgid "" "The value of the *start* parameter (or ``0`` if the parameter was not " "supplied)" -msgstr "" +msgstr "El valor del parámetro ``start`` (``0`` si no se utiliza el parámetro)" #: ../Doc/library/stdtypes.rst:1331 msgid "The value of the *stop* parameter" -msgstr "" +msgstr "El valor del parámetro ``stop``" #: ../Doc/library/stdtypes.rst:1335 msgid "" "The value of the *step* parameter (or ``1`` if the parameter was not " "supplied)" -msgstr "" +msgstr "El valor del parámetro ``step`` (``1`` si no se utiliza el parámetro)" #: ../Doc/library/stdtypes.rst:1338 msgid "" @@ -1814,6 +2366,12 @@ msgid "" "it only stores the ``start``, ``stop`` and ``step`` values, calculating " "individual items and subranges as needed)." msgstr "" +"La ventaja de usar un objeto de tipo :class:`range` en vez de uno de tipo :" +"class:`list` o :class:`tuple` es que con :class:`range` siempre se usa una " +"cantidad fija (y pequeña) de memoria, independientemente del rango que " +"represente (Ya que solamente necesita almacenar los valores para ``start``, " +"``stop`` y ``step``, y calcula los valores intermedios a medida que los va " +"necesitando)." #: ../Doc/library/stdtypes.rst:1344 msgid "" @@ -1821,6 +2379,10 @@ msgid "" "provide features such as containment tests, element index lookup, slicing " "and support for negative indices (see :ref:`typesseq`):" msgstr "" +"Los objetos rango implementan la clase ABC :class:`collections.abc." +"Sequence`, y proporcionan capacidades como comprobación de inclusión, " +"búsqueda de elementos por índice, operaciones de rebanadas y soporte de " +"índices negativos (Véase :ref:`typesseq`):" #: ../Doc/library/stdtypes.rst:1364 msgid "" @@ -1831,6 +2393,13 @@ msgid "" "and :attr:`~range.step` attributes, for example ``range(0) == range(2, 1, " "3)`` or ``range(0, 3, 2) == range(0, 4, 2)``.)" msgstr "" +"La comparación entre rangos usando los operadores ``==`` y ``!=`` se realiza " +"como con las secuencias. Esto es, dos rangos se consideran iguales si " +"representan exactamente la misma secuencia de elementos. (Fíjate que, según " +"esta definición, dos rangos pueden considerarse iguales aunque tengan " +"diferentes valores para :attr:`~range.start`, :attr:`~range.stop` y :attr:" +"`~range.step`, por ejemplo ``range(0) == range(2, 1, 3)`` y ``range(0, 3, 2) " +"== range(0, 4, 2)``)." #: ../Doc/library/stdtypes.rst:1371 msgid "" @@ -1838,18 +2407,27 @@ msgid "" "class:`int` objects for membership in constant time instead of iterating " "through all items." msgstr "" +"Implementa la clase abstracta ``Sequence``. Soportan operaciones de rebanado " +"e índices negativos. Comprobar si un entero de tipo :class:`int` está " +"incluido en un rango se realiza en un tiempo constante, no se realiza una " +"iteración a través de todos los elementos." #: ../Doc/library/stdtypes.rst:1377 msgid "" "Define '==' and '!=' to compare range objects based on the sequence of " "values they define (instead of comparing based on object identity)." msgstr "" +"Define los operadores '==' y '!=' para comparar rangos en base a la " +"secuencia de valores que definen (En vez de compararse en base a la " +"identidad)." #: ../Doc/library/stdtypes.rst:1382 msgid "" "The :attr:`~range.start`, :attr:`~range.stop` and :attr:`~range.step` " "attributes." msgstr "" +"Los atributos :attr:`~range.start`, :attr:`~range.stop` y :attr:`~range." +"step`." #: ../Doc/library/stdtypes.rst:1388 msgid "" @@ -1857,37 +2435,51 @@ msgid "" "how to implement a lazy version of range suitable for floating point " "applications." msgstr "" +"En `linspace recipe `_ se " +"muestra como implementar una versión *lazy* o perezosa de una función para " +"``range`` que funciona con valores en coma flotante." #: ../Doc/library/stdtypes.rst:1400 msgid "Text Sequence Type --- :class:`str`" -msgstr "" +msgstr "Cadenas de caracteres --- :class:`str`" +# Comprobar la definicion de cadenas #: ../Doc/library/stdtypes.rst:1402 msgid "" "Textual data in Python is handled with :class:`str` objects, or :dfn:" "`strings`. Strings are immutable :ref:`sequences ` of Unicode code " "points. String literals are written in a variety of ways:" msgstr "" +"La información textual se representa en Python con objetos de tipo :class:" +"`str`, normalmente llamados cadenas de caracteres o simplemente :dfn:" +"`cadenas`. Las cadenas de caracteres son :ref:`secuencias ` " +"inmutables de puntos de código Unicode. Las cadenas se pueden definir de " +"diferentes maneras:" #: ../Doc/library/stdtypes.rst:1407 msgid "Single quotes: ``'allows embedded \"double\" quotes'``" -msgstr "" +msgstr "Comillas simples: ``'permite incluir comillas \"dobles\"'``" #: ../Doc/library/stdtypes.rst:1408 msgid "Double quotes: ``\"allows embedded 'single' quotes\"``." -msgstr "" +msgstr "Comillas dobles: ``\"permite incluir comillas 'simples'\"``." #: ../Doc/library/stdtypes.rst:1409 msgid "" "Triple quoted: ``'''Three single quotes'''``, ``\"\"\"Three double quotes" "\"\"\"``" msgstr "" +"Triples comillas: ya sea con comillas simples ``'''Triples comillas " +"simples'''`` o dobles ``\"\"\"Triples comillas dobles\"\"\"``" #: ../Doc/library/stdtypes.rst:1411 msgid "" "Triple quoted strings may span multiple lines - all associated whitespace " "will be included in the string literal." msgstr "" +"Las cadenas definidas con comillas tripes pueden incluir varias líneas. " +"Todos los espacios en blancos incluidos se incorporan a la cadena de forma " +"literal." #: ../Doc/library/stdtypes.rst:1414 msgid "" @@ -1895,6 +2487,9 @@ msgid "" "whitespace between them will be implicitly converted to a single string " "literal. That is, ``(\"spam \" \"eggs\") == \"spam eggs\"``." msgstr "" +"Cadenas literales que forman parte de una expresión y que solo estén " +"separados por espacios en blanco, se convertirán implícitamente a una única " +"cadena. Esto es, ``(\"spam \" \"eggs\") == \"spam eggs\"``." #: ../Doc/library/stdtypes.rst:1418 msgid "" @@ -1902,25 +2497,38 @@ msgid "" "including supported escape sequences, and the ``r`` (\"raw\") prefix that " "disables most escape sequence processing." msgstr "" +"Véase :ref:`strings` para más información acerca de las diferentes formas de " +"expresar cadenas de forma literal, incluidos los caracteres de escape, y del " +"prefijo ``r`` (\"*raw*\") que deshabilita el procesamiento de la mayoría de " +"dichas secuencias de escape." #: ../Doc/library/stdtypes.rst:1422 msgid "" "Strings may also be created from other objects using the :class:`str` " "constructor." msgstr "" +"Las cadenas de caracteres también se pueden crear usando el constructor :" +"class:`str`." #: ../Doc/library/stdtypes.rst:1425 msgid "" "Since there is no separate \"character\" type, indexing a string produces " "strings of length 1. That is, for a non-empty string *s*, ``s[0] == s[0:1]``." msgstr "" +"Como no hay un tipo separado para los caracteres, indexar una cadena produce " +"una cadena de longitud 1. Esto es, para una cadena de caracteres no vacía " +"*s*, ``s[0] == s[0:1]``." +# fragmentos suena raro #: ../Doc/library/stdtypes.rst:1431 msgid "" "There is also no mutable string type, but :meth:`str.join` or :class:`io." "StringIO` can be used to efficiently construct strings from multiple " "fragments." msgstr "" +"Tampoco hay una versión mutable de las cadenas de caracteres, pero el " +"método :meth:`str.join` o la clase :class:`io.StringIO` pueden usarse para " +"construir de forma eficiente una cadena de caracteres a partir de fragmentos." #: ../Doc/library/stdtypes.rst:1435 msgid "" @@ -1928,6 +2536,9 @@ msgid "" "once again permitted on string literals. It has no effect on the meaning of " "string literals and cannot be combined with the ``r`` prefix." msgstr "" +"Para facilitar la compatibilidad hacia atrás con la versión 2, el prefijo " +"``u`` se permite en las cadenas de caracteres. No tiene ningún efecto en la " +"interpretación del literal y no se puede combinar con el prefijo ``r``." #: ../Doc/library/stdtypes.rst:1447 msgid "" @@ -1935,6 +2546,10 @@ msgid "" "provided, returns the empty string. Otherwise, the behavior of ``str()`` " "depends on whether *encoding* or *errors* is given, as follows." msgstr "" +"Retorna una representación en forma de :ref:`cadena de caracteres ` " +"de *object*. Si no se proporciona ningún valor, retorna una cadena vacía. Si " +"se proporciona, el comportamiento de ``str()`` depende de los valores " +"pasados en los parámetros *encoding* y *errors*, como veremos." #: ../Doc/library/stdtypes.rst:1451 msgid "" @@ -1944,6 +2559,12 @@ msgid "" "the string itself. If *object* does not have a :meth:`~object.__str__` " "method, then :func:`str` falls back to returning :meth:`repr(object) `." msgstr "" +"Si no se especifica ni *encoding* ni *errors*, ``str(object)`` retorna :meth:" +"`object.__str__() `, que es la representación \"informal\" o " +"mas cómoda de usar, en forma de cadena de caracteres, del valor de *object*. " +"Para una cadena de caracteres, es la cadena en sí. Si *object* no tiene un " +"método :meth:`~object.__str__`, entonces :func:`str` usará como reemplazo el " +"método :meth:`repr(object) `." #: ../Doc/library/stdtypes.rst:1462 msgid "" @@ -1956,7 +2577,17 @@ msgid "" "decode`. See :ref:`binaryseq` and :ref:`bufferobjects` for information on " "buffer objects." msgstr "" - +"Si se indica alguno de los dos parámetros *encoding* o *errors*, entonces " +"*object* debe ser un objeto binario o similar (:term:`bytes-like object`, es " +"decir, una instancia de :class:`bytes` o :class:`bytearray`). En este caso, " +"si *object* es de tipo :class:`bytes` o :class:`bytearray`, la llamada a " +"``str(bytes, encoding, errors)`` es equivalente a :meth:`bytes." +"decode(encoding, errors) `. Si no, el objeto de tipo *bytes* " +"que esta subyacente en el objeto *buffer* se obtiene mediante una llamada a :" +"meth:`bytes.decode`. Véase :ref:`binaryseq` y :ref:`bufferobjects` para más " +"información sobre los objetos *buffer*." + +# comand-line? #: ../Doc/library/stdtypes.rst:1471 msgid "" "Passing a :class:`bytes` object to :func:`str` without the *encoding* or " @@ -1964,6 +2595,10 @@ msgid "" "string representation (see also the :option:`-b` command-line option to " "Python). For example::" msgstr "" +"Si se pasa un objeto de tipo :class:`bytes` a la función :func:`str` sin " +"especificar o bien el parámetro *encoding* o bien el *errors*, se vuelve al " +"caso normal donde se retorna la representación informal (Véase también la :" +"option:`-b` de las opciones de línea de órdenes de Python). Por ejemplo::" #: ../Doc/library/stdtypes.rst:1479 msgid "" @@ -1972,16 +2607,23 @@ msgid "" "strings, see the :ref:`f-strings` and :ref:`formatstrings` sections. In " "addition, see the :ref:`stringservices` section." msgstr "" +"Para más información sobre la clase ``str`` y sus métodos, consulta :ref:" +"`textseq` y la sección :ref:`string-methods` a continuación. Para las " +"opciones de formateo de cadenas, lee las secciones :ref:`f-strings` y :ref:" +"`formatstrings`. También puedes consultar la sección :ref:`stringservices`." #: ../Doc/library/stdtypes.rst:1491 msgid "String Methods" -msgstr "" +msgstr "Métodos de las cadenas de caracteres" #: ../Doc/library/stdtypes.rst:1496 msgid "" "Strings implement all of the :ref:`common ` sequence " "operations, along with the additional methods described below." msgstr "" +"Todas las cadenas de caracteres implementan las operaciones :ref:`comunes " +"` de las secuencias, junto con los métodos descritos a " +"continuación." #: ../Doc/library/stdtypes.rst:1499 msgid "" @@ -1992,6 +2634,12 @@ msgid "" "slightly harder to use correctly, but is often faster for the cases it can " "handle (:ref:`old-string-formatting`)." msgstr "" +"Las cadenas soportan dos estilos de formateo, uno proporciona un grado muy " +"completo de flexibilidad y personalización (Véase :meth:`str.format`, :ref:" +"`formatstrings` y :ref:`string-formatting`) mientras que el otro se basa en " +"la función C ``printf``, que soporta un menor número de tipos y es " +"ligeramente más complicada de usar, pero es a menudo más rápida para los " +"casos que puede manejar (:ref:`old-string-formatting`)." #: ../Doc/library/stdtypes.rst:1506 msgid "" @@ -1999,25 +2647,37 @@ msgid "" "other modules that provide various text related utilities (including regular " "expression support in the :mod:`re` module)." msgstr "" +"La sección :ref:`textservices` de la librería estándar cubre una serie de " +"módulos que proporcionan varias utilidades para trabajar con textos " +"(Incluyendo las expresiones regulares en el módulo :mod:`re`)." #: ../Doc/library/stdtypes.rst:1512 msgid "" "Return a copy of the string with its first character capitalized and the " "rest lowercased." msgstr "" +"Retorna una copia de la cadena con el primer carácter en mayúsculas y el " +"resto en minúsculas." +# no se si titular sera lo adecuado #: ../Doc/library/stdtypes.rst:1515 msgid "" "The first character is now put into titlecase rather than uppercase. This " "means that characters like digraphs will only have their first letter " "capitalized, instead of the full character." msgstr "" +"El primer carácter se pasa ahora a título, más que a mayúsculas. Esto " +"significa que caracteres como dígrafos solo tendrán la primera letra en " +"mayúsculas, en ves de todo el carácter." #: ../Doc/library/stdtypes.rst:1522 msgid "" "Return a casefolded copy of the string. Casefolded strings may be used for " "caseless matching." msgstr "" +"Retorna el texto de la cadena, normalizado a minúsculas. Los textos así " +"normalizados pueden usarse para realizar búsquedas textuales independientes " +"de mayúsculas y minúsculas." #: ../Doc/library/stdtypes.rst:1525 msgid "" @@ -2027,12 +2687,19 @@ msgid "" "already lowercase, :meth:`lower` would do nothing to ``'ß'``; :meth:" "`casefold` converts it to ``\"ss\"``." msgstr "" +"El texto normalizado a minúsculas es más agresivo que el texto en minúsculas " +"normal, porque se intenta unificar todas las grafías distintas de la letras. " +"Por ejemplo, En Alemán la letra minúscula ``'ß'`` equivale a ``\"ss\"``. " +"Como ya está en minúsculas, el método :meth:`lower` no modifica ``'ß'``, " +"pero el método :meth:`casefold` lo convertirá a ``\"ss\"``." #: ../Doc/library/stdtypes.rst:1531 msgid "" "The casefolding algorithm is described in section 3.13 of the Unicode " "Standard." msgstr "" +"El algoritmo de normalización a minúsculas se describe en la sección 3.13 " +"del estándar Unicode." #: ../Doc/library/stdtypes.rst:1539 msgid "" @@ -2040,6 +2707,11 @@ msgid "" "specified *fillchar* (default is an ASCII space). The original string is " "returned if *width* is less than or equal to ``len(s)``." msgstr "" +"Retorna el texto de la cadena, centrado en una cadena de longitud *width*. " +"El relleno a izquierda y derecha se realiza usando el carácter definido por " +"el parámetro *fillchar* (Por defecto se usa el carácter espacio ASCII). Si " +"la cadena original tiene una longitud ``len(s)`` igual o superior a *width*, " +"se retorna el texto sin modificar." #: ../Doc/library/stdtypes.rst:1547 msgid "" @@ -2047,6 +2719,9 @@ msgid "" "range [*start*, *end*]. Optional arguments *start* and *end* are " "interpreted as in slice notation." msgstr "" +"Retorna el número de ocurrencias no solapadas de la cadena *sub* en el rango " +"[*start*, *end*]. Los parámetros opcionales *start* y *end* Se interpretan " +"como en una expresión de rebanada." #: ../Doc/library/stdtypes.rst:1554 msgid "" @@ -2059,10 +2734,20 @@ msgid "" "handlers`. For a list of possible encodings, see section :ref:`standard-" "encodings`." msgstr "" +"Retorna una versión codificada en forma de bytes. La codificación por " +"defecto es ``'utf-8'``. El parámetro *errors* permite especificar diferentes " +"esquemas de gestión de errores. El valor por defecto de *errors* es " +"``'strict'``, que significa que cualquier error en la codificación eleva una " +"excepción de tipo :exc:`UnicodeError`. Otros valores posibles son " +"``'ignore'``, ``'replace'``, ``'xmlcharrefreplace'``, ``'backslashreplace'`` " +"y cualquier otro nombre que se haya registrado mediante la función :func:" +"`codecs.register_error`, véase la sección :ref:`error-handlers`. Para una " +"lista de los posibles sistemas de codificación, véase la sección :ref:" +"`standard-encodings`." #: ../Doc/library/stdtypes.rst:1563 msgid "Support for keyword arguments added." -msgstr "" +msgstr "Añade soporte para el uso de parámetros por nombre." #: ../Doc/library/stdtypes.rst:1569 msgid "" @@ -2071,6 +2756,11 @@ msgid "" "With optional *start*, test beginning at that position. With optional " "*end*, stop comparing at that position." msgstr "" +"Retorna ``True`` si la cadena termina con el sufijo especificado con el " +"parámetro *prefix*, y ``False`` en caso contrario. También podemos usar " +"*suffix* para pasar una tupla de sufijos a buscar. Si especificamos el " +"parámetro opcional *start*, la comprobación empieza en esa posición. Con el " +"parámetro opcional *stop*, la comprobación termina en esa posición." #: ../Doc/library/stdtypes.rst:1577 msgid "" @@ -2087,6 +2777,19 @@ msgid "" "incremented by one regardless of how the character is represented when " "printed." msgstr "" +"Retorna una copia de la cadena, con todos los caracteres de tipo tabulador " +"reemplazados por uno o más espacios, dependiendo de la columna actual y del " +"tamaño definido para el tabulador. Las posiciones de tabulación ocurren cada " +"*tabsize* caracteres (Siendo el valor por defecto de *tabsize* 8, lo que " +"produce las posiciones de tabulación 0, 8, 16,...). Para expandir la cadena, " +"la columna actual se pone a cero y se va examinando el texto carácter a " +"carácter. Si se encuentra un tabulador, (``\\t``), se insertan uno o más " +"espacios hasta que sea igual a la siguiente posición de tabulación (El " +"carácter tabulador en sí es descartado). Si el carácter en un indicador de " +"salto de línea (``\\n``) o de retorno (``\\r``), se copia y el valor de " +"columna actual se vuelve a poner a cero. Cualquier otro carácter es copiado " +"sin cambios y hace que el contador de columna se incremente en 1, sin tener " +"en cuenta como se representa gráficamente el carácter." #: ../Doc/library/stdtypes.rst:1598 msgid "" @@ -2094,6 +2797,10 @@ msgid "" "the slice ``s[start:end]``. Optional arguments *start* and *end* are " "interpreted as in slice notation. Return ``-1`` if *sub* is not found." msgstr "" +"Retorna el menor índice de la cadena *s* donde se puede encontrar la cadena " +"*sub*, considerando solo el intervalo ``s[start:end]``. Los parámetros " +"opcionales *start* y *end* se interpretan como si fueran 'indices de una " +"rebanada. retorna ``-1`` si no se encuentra la cadena." #: ../Doc/library/stdtypes.rst:1604 msgid "" @@ -2101,6 +2808,9 @@ msgid "" "position of *sub*. To check if *sub* is a substring or not, use the :" "keyword:`in` operator::" msgstr "" +"El método :meth:`~str.find` se debe usar solo si se necesita saber la " +"posición de la cadena *sub*. Si solo se necesita comprobar si *sub* es una " +"parte de *s*, es mejor usar el operador :keyword:`in`::" #: ../Doc/library/stdtypes.rst:1614 msgid "" @@ -2111,12 +2821,21 @@ msgid "" "the string where each replacement field is replaced with the string value of " "the corresponding argument." msgstr "" +"Realiza una operación de formateo. La cadena de caracteres sobre la que se " +"está ejecutando este método puede contener texto literal y también marcas de " +"reemplazo de texto definidas mediante llaves ``{}``. Cada sección a " +"reemplazar contiene o bien un índice numérico que hace referencia a un " +"parámetro por posición, o el nombre de un parámetro por nombre. retorna una " +"copia de la cadena donde se han sustituido las marcas de reemplazo por los " +"valores correspondientes pasados como parámetros." #: ../Doc/library/stdtypes.rst:1624 msgid "" "See :ref:`formatstrings` for a description of the various formatting options " "that can be specified in format strings." msgstr "" +"Véase :ref:`formatstrings` para una descripción de las distintas opciones de " +"formateo que se pueden usar." #: ../Doc/library/stdtypes.rst:1628 msgid "" @@ -2128,12 +2847,23 @@ msgid "" "and the ``LC_NUMERIC`` locale is different than the ``LC_CTYPE`` locale. " "This temporary change affects other threads." msgstr "" +"Cuando se formatea un número (:class:`int`, :class:`float`, :class:" +"`complex`, :class:`decimal.Decimal` y clases derivadas) usando la ``n`` (Por " +"ejemplo, ``'{:n}'.format(1234)``), las función ajusta temporalmente el valor " +"de la variable de entorno local ``LC_TYPE`` a ``LC_NUMERIC`` para " +"decodificar los campos ``*decimal_point*`` y ``*thousands_sep*`` de la " +"función :c:func:`localeconv`, si usan caracteres que no son ASCII o si " +"ocupan más de un byte, y el valor definido en ``LC_NUMERIC`` es diferente " +"del definido en ``LC_CTYPE``. Estos cambios temporales pueden afectar a " +"otros *threads*." #: ../Doc/library/stdtypes.rst:1637 msgid "" "When formatting a number with the ``n`` type, the function sets temporarily " "the ``LC_CTYPE`` locale to the ``LC_NUMERIC`` locale in some cases." msgstr "" +"Cuando se formatea un número usando la ``n``, la función puede asignar de " +"forma temporal la variable ``LC_CTYPE``." #: ../Doc/library/stdtypes.rst:1645 msgid "" @@ -2141,12 +2871,17 @@ msgid "" "directly and not copied to a :class:`dict`. This is useful if for example " "``mapping`` is a dict subclass:" msgstr "" +"Similar a ``str.format(**mapping)`, pero se usa ``*mapping*`` de forma " +"directa y no se copia a una diccionario. Esto es útil si ``*mapping*`` es, " +"por ejemplo, una instancia de una subclase de :class:`dict`:" #: ../Doc/library/stdtypes.rst:1661 msgid "" "Like :meth:`~str.find`, but raise :exc:`ValueError` when the substring is " "not found." msgstr "" +"Como :meth:`~str.find`, pero eleva una excepción de tipo :exc:`ValueError` " +"si no se encuentra la cadena a buscar." #: ../Doc/library/stdtypes.rst:1667 msgid "" @@ -2155,6 +2890,11 @@ msgid "" "alphanumeric if one of the following returns ``True``: ``c.isalpha()``, ``c." "isdecimal()``, ``c.isdigit()``, or ``c.isnumeric()``." msgstr "" +"Retorna ``True`` si todos los caracteres de la cadena son alfanuméricos y " +"hay, al menos, un carácter. En caso contrario, retorna ``False``. Un " +"carácter ``c`` se considera alfanumérico si alguna de las siguientes " +"funciones retorna ``True``: ``c.isalpha()``, ``c.isdecimal()``, ``c." +"isdigit()`` o ``c.isnumeric()``." #: ../Doc/library/stdtypes.rst:1675 msgid "" @@ -2165,6 +2905,12 @@ msgid "" "\", \"Ll\", or \"Lo\". Note that this is different from the \"Alphabetic\" " "property defined in the Unicode Standard." msgstr "" +"Retorna ``True`` si todos los caracteres de la cadena son alfabéticos y hay, " +"al menos, un carácter. En caso contrario, retorna ``False``. Los caracteres " +"alfabéticos son aquellos definidos en la base de datos de Unicode como " +"\"``*Letter*``, es decir, aquellos cuya propiedad categoría general es \"*Lm*" +"\", \"*Lt*\", \"*Lu*\", \"*Ll*\" o \"*Lo*\". Nótese que esta definición de " +"\"Alfabético\" es diferente de la que usa el estándar Unicode." #: ../Doc/library/stdtypes.rst:1684 msgid "" @@ -2172,6 +2918,10 @@ msgid "" "ASCII, ``False`` otherwise. ASCII characters have code points in the range U" "+0000-U+007F." msgstr "" +"Retorna ``True`` si la cadena de caracteres está vacía, o si todos los " +"caracteres de la cadena son ASCII. En caso contrario, retorna ``False``. Los " +"caracteres ASCII son aquellos cuyos puntos de código Unicode están en el " +"rango U+0000-U+007F." #: ../Doc/library/stdtypes.rst:1693 msgid "" @@ -2181,6 +2931,12 @@ msgid "" "DIGIT ZERO. Formally a decimal character is a character in the Unicode " "General Category \"Nd\"." msgstr "" +"Retorna ``True`` si todos los caracteres de la cadena son caracteres " +"decimales y hay, al menos, un carácter. En caso contrario, retorna " +"``False``. Los caracteres decimales son aquellos que se pueden usar para " +"formar números en base 10, por ejemplo, ``U+0660, ARABIC-INDIC DIGIT ZERO``. " +"Formalmente, un carácter decimal es un carácter en la categoría general " +"\"`Nd`\" de Unicode." #: ../Doc/library/stdtypes.rst:1703 msgid "" @@ -2191,28 +2947,43 @@ msgid "" "like the Kharosthi numbers. Formally, a digit is a character that has the " "property value Numeric_Type=Digit or Numeric_Type=Decimal." msgstr "" +"Retorna ``True`` si todos los caracteres de la cadena son dígitos y hay, al " +"menos, un carácter. En caso contrario, retorna ``False``. Los dígitos " +"incluyen los caracteres decimales y dígitos que requieren un tratamiento " +"especial, como por ejemplo los usados para superíndices. Esto incluye " +"dígitos que no pueden ser usados para formar números en base 10, como los " +"números *Kharosthi*. Formalmente, un dígito es un carácter que tiene la " +"propiedad ``*Numeric_Type*`` definida como ``*Digit*`` o ``*Decimal*``." #: ../Doc/library/stdtypes.rst:1713 msgid "" "Return ``True`` if the string is a valid identifier according to the " "language definition, section :ref:`identifiers`." msgstr "" +"Retorna ``True`` si la cadena de caracteres es un identificar válido de " +"acuerdo a la especificación del lenguaje, véase :ref:`identifiers`." #: ../Doc/library/stdtypes.rst:1716 msgid "" "Call :func:`keyword.iskeyword` to test whether string ``s`` is a reserved " "identifier, such as :keyword:`def` and :keyword:`class`." msgstr "" +"Se puede usar la función :func:`keyword.iskeyword` para comprobar si la " +"cadena ``s`` es una palabra reservada, como :keyword:`def` o :keyword:" +"`class`." #: ../Doc/library/stdtypes.rst:1719 msgid "Example: ::" -msgstr "" +msgstr "Ejemplo: ::" #: ../Doc/library/stdtypes.rst:1732 msgid "" "Return ``True`` if all cased characters [4]_ in the string are lowercase and " "there is at least one cased character, ``False`` otherwise." msgstr "" +"Retorna ``True`` si todos los caracteres de la cadena que tengan formas en " +"mayúsculas y minúsculas [4]_ están en minúsculas y hay, al menos, un " +"carácter de ese tipo. En caso contrario, retorna ``False``." #: ../Doc/library/stdtypes.rst:1738 msgid "" @@ -2223,6 +2994,13 @@ msgid "" "characters are those with the property value Numeric_Type=Digit, " "Numeric_Type=Decimal or Numeric_Type=Numeric." msgstr "" +"Retorna ``True`` si todos los caracteres de la cadena son caracteres " +"numéricos y hay, al menos, un carácter. En caso contrario, retorna " +"``False``. Los caracteres numéricos incluyen los dígitos, y todos los " +"caracteres Unicode que tiene definida la propiedad valor numérico, por " +"ejemplo U+2155, VULGAR FRACTION ONE FIFTH. Formalmente, los caracteres " +"numéricos son aquellos que la propiedad ``Numeric_Type`` definida como " +"``Digit``, ``Decimal`` o ``Numeric``." #: ../Doc/library/stdtypes.rst:1748 msgid "" @@ -2234,12 +3012,22 @@ msgid "" "when :func:`repr` is invoked on a string. It has no bearing on the handling " "of strings written to :data:`sys.stdout` or :data:`sys.stderr`.)" msgstr "" +"Retorna ``True`` si todos los caracteres de la cadena son imprimibles o si " +"la cadena está vacía. En caso contrario, retorna ``False``. Los caracteres " +"no imprimibles son aquellos definidos en la base de datos de Unicode como " +"\"``other``\" o \"``Separator``\", con la excepción del carácter ASCII " +"\"espacio\" (``0x20``), que se considera imprimible (Nótese que en este " +"contexto, imprimible son aquellos caracteres que no necesitan ser escapados " +"cuando se imprimen con la función :func:`repr`. No tiene relevancia en " +"cadenas escritas a :data:`sys.stdout` o :data:`sys.stderr`)." #: ../Doc/library/stdtypes.rst:1759 msgid "" "Return ``True`` if there are only whitespace characters in the string and " "there is at least one character, ``False`` otherwise." msgstr "" +"Retorna ``True`` si todos los caracteres de la cadena son espacios en blanco " +"y hay, al menos, un carácter. En caso contrario, retorna ``False``." #: ../Doc/library/stdtypes.rst:1762 msgid "" @@ -2247,6 +3035,10 @@ msgid "" "`unicodedata`), either its general category is ``Zs`` (\"Separator, space" "\"), or its bidirectional class is one of ``WS``, ``B``, or ``S``." msgstr "" +"Un carácter se considera espacio en blanco si, en la base de datos de " +"Unicode (Véase :mod:`unicodedata`), está clasificado en la categoría general " +"``Zs``(\"Espacio, separador\") o la clase bidireccional es ``WS``, ``B``, or " +"``S``." #: ../Doc/library/stdtypes.rst:1770 msgid "" @@ -2255,12 +3047,21 @@ msgid "" "characters and lowercase characters only cased ones. Return ``False`` " "otherwise." msgstr "" +"Retorna ``True`` si las palabras en la cadena tiene forma de título y hay, " +"al menos, un carácter, por ejemplo una mayúscula solo puede aparecer al " +"principio o después de un carácter que no tenga formas alternativas " +"mayúsculas-minúsculas, y las minúsculas solo después de carácter que si " +"tiene formas alternativas mayúsculas-minúsculas. En caso contrario, retorna " +"``False``." #: ../Doc/library/stdtypes.rst:1777 msgid "" "Return ``True`` if all cased characters [4]_ in the string are uppercase and " "there is at least one cased character, ``False`` otherwise." msgstr "" +"Retorna ``True`` si todos los caracteres de la cadena que tengan formas en " +"mayúsculas y minúsculas [4]_ están en mayúsculas y hay, al menos, un " +"carácter de ese tipo. En caso contrario, retorna ``False``." #: ../Doc/library/stdtypes.rst:1783 msgid "" @@ -2269,6 +3070,11 @@ msgid "" "*iterable*, including :class:`bytes` objects. The separator between " "elements is the string providing this method." msgstr "" +"Retorna una cadena de caracteres formada por la concatenación de las cadenas " +"en el *iterable*. Se eleva una excepción de tipo :exc:`TypeError` si alguno " +"de los elementos en el *iterable* no es una cadena, incluyendo objetos de " +"tipo :class:`bytes`. Se usa como separador entre los elementos la cadena de " +"caracteres pasada como parámetro." #: ../Doc/library/stdtypes.rst:1791 msgid "" @@ -2276,18 +3082,27 @@ msgid "" "done using the specified *fillchar* (default is an ASCII space). The " "original string is returned if *width* is less than or equal to ``len(s)``." msgstr "" +"Retorna el texto de la cadena, justificado a la izquierda en una cadena de " +"longitud *width*. El carácter de relleno a usar viene definido por el " +"parámetro *fillchar* (Por defecto se usa el carácter espacio ASCII). Si la " +"cadena original tiene una longitud ``len(s)`` igual o superior a *width*, se " +"Retorna el texto sin modificar." #: ../Doc/library/stdtypes.rst:1798 msgid "" "Return a copy of the string with all the cased characters [4]_ converted to " "lowercase." msgstr "" +"Retorna una copia de la cadena de caracteres con todas las letras en " +"minúsculas [4]_." #: ../Doc/library/stdtypes.rst:1801 msgid "" "The lowercasing algorithm used is described in section 3.13 of the Unicode " "Standard." msgstr "" +"El algoritmo usado para la conversión a minúsculas está descrito en la " +"sección 3..13 del estándar Unicode." #: ../Doc/library/stdtypes.rst:1807 msgid "" @@ -2297,12 +3112,19 @@ msgid "" "The *chars* argument is not a prefix; rather, all combinations of its values " "are stripped::" msgstr "" +"Retorna una copia de la cadena, eliminado determinados caracteres si se " +"encuentren al principio. El parámetro *chars* especifica el conjunto de " +"caracteres a eliminar. Si se omite o si se especifica ``None``, se eliminan " +"todos los espacios en blanco. No debe entenderse el valor de *chars* como un " +"prefijo, sino que se elimina cualquier combinación de sus caracteres::" #: ../Doc/library/stdtypes.rst:1820 msgid "" "This static method returns a translation table usable for :meth:`str." "translate`." msgstr "" +"Este método estático retorna una tabla de traducción apta para ser usada por " +"el método :meth:`str.translate`." #: ../Doc/library/stdtypes.rst:1822 msgid "" @@ -2311,6 +3133,10 @@ msgid "" "strings (of arbitrary lengths) or ``None``. Character keys will then be " "converted to ordinals." msgstr "" +"Si solo se usa un parámetro, este debe ser un diccionario que mapea valores " +"de punto Unicode (enteros) o caracteres (Cadenas de longitud 1) a valores " +"Unicode, cadenas (De cualquier longitud) o ``None``. Las claves se " +"convertirán a ordinales." #: ../Doc/library/stdtypes.rst:1827 msgid "" @@ -2319,6 +3145,10 @@ msgid "" "the same position in y. If there is a third argument, it must be a string, " "whose characters will be mapped to ``None`` in the result." msgstr "" +"Si se pasan dos parámetros, deben ser cadenas de la misma longitud, y en la " +"tabla resultante, cada carácter en *x* se mapea al carácter en la misma " +"posición en *y*. Si se añade un tercer parámetro, debe ser una cadena de " +"caracteres, todos los cuales se mapearán a ``None`` en la tabla resultante." #: ../Doc/library/stdtypes.rst:1835 msgid "" @@ -2327,6 +3157,11 @@ msgid "" "after the separator. If the separator is not found, return a 3-tuple " "containing the string itself, followed by two empty strings." msgstr "" +"Divide la cadena en la primera ocurrencia de *sep*, y retorna una tupla de " +"tres elementos, conteniendo la parte anterior al separador, el separador en " +"sí y la parte posterior al separador. Si no se encuentra el separador, " +"Retorna una tupla de tres elementos, el primero la cadena original y los dos " +"siguientes son cadenas vacías." #: ../Doc/library/stdtypes.rst:1843 msgid "" @@ -2334,6 +3169,9 @@ msgid "" "by *new*. If the optional argument *count* is given, only the first *count* " "occurrences are replaced." msgstr "" +"Retorna una copia de la cadena con todas las ocurrencias de la cadena *old* " +"sustituidas por *new*. Si se utiliza el parámetro *count*, solo se cambian " +"las primeras *count* ocurrencias." #: ../Doc/library/stdtypes.rst:1850 msgid "" @@ -2341,12 +3179,18 @@ msgid "" "that *sub* is contained within ``s[start:end]``. Optional arguments *start* " "and *end* are interpreted as in slice notation. Return ``-1`` on failure." msgstr "" +"Retorna el mayor índice dentro de la cadena *s* donde se puede encontrar la " +"cadena *sub*, estando *sub* incluida en ``s[start:end]``. Los parámetros " +"opcionales *start* y *end* se interpretan igual que en las operaciones de " +"rebanado. retorna ``-1`` si no se encuentra *sub*." #: ../Doc/library/stdtypes.rst:1857 msgid "" "Like :meth:`rfind` but raises :exc:`ValueError` when the substring *sub* is " "not found." msgstr "" +"Como el método :meth:`rfind`, pero eleva la excepción :exc:`ValueError` si " +"no se encuentra la cadena *sub*." #: ../Doc/library/stdtypes.rst:1863 msgid "" @@ -2354,6 +3198,10 @@ msgid "" "done using the specified *fillchar* (default is an ASCII space). The " "original string is returned if *width* is less than or equal to ``len(s)``." msgstr "" +"Retorna el texto de la cadena, justificado a la derecha en una cadena de " +"longitud *width*. El carácter de relleno a usar viene definido por el " +"parámetro *fillchar* (Por defecto se usa el carácter espacio ASCII). Si " +"*width* es menor o igual que ``len(s)``, se retorna el texto sin modificar." #: ../Doc/library/stdtypes.rst:1870 msgid "" @@ -2362,6 +3210,11 @@ msgid "" "after the separator. If the separator is not found, return a 3-tuple " "containing two empty strings, followed by the string itself." msgstr "" +"Divide la cadena en la última ocurrencia de *sep*, y retorna una tupla de " +"tres elementos, conteniendo la parte anterior al separador, el separador en " +"sí y la parte posterior al separador. Si no se encuentra el separador, " +"Retorna una tupla de tres elementos, los dos primeras posiciones con cadenas " +"vacías y en la tercera la cadena original." #: ../Doc/library/stdtypes.rst:1878 msgid "" @@ -2371,6 +3224,14 @@ msgid "" "string is a separator. Except for splitting from the right, :meth:`rsplit` " "behaves like :meth:`split` which is described in detail below." msgstr "" +"Retorna una lista con las palabras que componen la cadena de caracteres " +"original, usando como separador el valor de *sep*. Si se utiliza el " +"parámetro *maxsplit*, se realizan como máximo *maxsplit* divisiones, " +"retornando los que están más a la derecha. Si no se especifica *sep* o se " +"pasa con valor ``None``, se usa como separador cualquier carácter de espacio " +"en blanco. Si no contamos la diferencia de empezar las divisiones desde la " +"derecha, el comportamiento de este método :meth:`rsplit` es equivalente al " +"de :meth:`split`, que se describe con detalle más adelante." #: ../Doc/library/stdtypes.rst:1887 msgid "" @@ -2380,6 +3241,11 @@ msgid "" "The *chars* argument is not a suffix; rather, all combinations of its values " "are stripped::" msgstr "" +"Retorna una copia de la cadena, eliminado determinados caracteres si se " +"encuentren al final. El parámetro *chars* especifica el conjunto de " +"caracteres a eliminar. Si se omite o si se especifica ``None``, se eliminan " +"todos los espacios en blanco. No debe entenderse el valor de *chars* como un " +"prefijo, sino que se elimina cualquier combinación de sus caracteres::" #: ../Doc/library/stdtypes.rst:1900 msgid "" @@ -2389,6 +3255,12 @@ msgid "" "specified or ``-1``, then there is no limit on the number of splits (all " "possible splits are made)." msgstr "" +"Retorna una lista con las palabras que componen la cadena de caracteres " +"original, usando como separador el valor de *sep*. Si se utiliza el " +"parámetro *maxsplit*, se realizan como máximo *maxsplit* divisiones, (Por " +"tanto, la lista resultante tendrá ``maxsplit+1`` elementos). Si no se " +"especifica *maxsplit* o se pasa con valor ``-1``, entonces no hay límite al " +"número de divisiones a realizar (Se harán todas las que se puedan)." #: ../Doc/library/stdtypes.rst:1906 msgid "" @@ -2398,6 +3270,12 @@ msgid "" "(for example, ``'1<>2<>3'.split('<>')`` returns ``['1', '2', '3']``). " "Splitting an empty string with a specified separator returns ``['']``." msgstr "" +"Si se especifica *sep*, las repeticiones de caracteres delimitadores no se " +"agrupan juntos, sino que se considera que están delimitando cadenas vacías " +"(Por ejemplo, ``'1,,2'.split(',')`` retorna ``['1', '', '2']``). El " +"parámetro *sep* puede contener más de un carácter (Por ejemplo, ``'1<>2<>3'." +"split('<>')`` retorna ``['1', '2', '3']``). Dividir una cadena vacía con un " +"separador determinado retornará ``['']``." #: ../Doc/library/stdtypes.rst:1912 ../Doc/library/stdtypes.rst:1928 #: ../Doc/library/stdtypes.rst:1980 ../Doc/library/stdtypes.rst:2048 @@ -2410,7 +3288,7 @@ msgstr "" #: ../Doc/library/stdtypes.rst:3194 ../Doc/library/stdtypes.rst:3236 #: ../Doc/library/stdtypes.rst:3260 msgid "For example::" -msgstr "" +msgstr "Por ejemplo::" #: ../Doc/library/stdtypes.rst:1921 msgid "" @@ -2421,6 +3299,13 @@ msgid "" "string or a string consisting of just whitespace with a ``None`` separator " "returns ``[]``." msgstr "" +"Si no se especifica *sep* o es ``None``, se usa un algoritmo de división " +"diferente: Secuencias consecutivas de caracteres de espacio en blanco se " +"consideran como un único separador, y el resultado no contendrá cadenas " +"vacías ni al principio ni al final de la lista, aunque la cadena original " +"tuviera espacios en blanco al principio o al final. En consecuencia, dividir " +"una cadena vacía o una cadena que solo contenga espacios en blanco usando " +"``None`` como separador siempre retornará una lista vacía ``[]``." #: ../Doc/library/stdtypes.rst:1943 msgid "" @@ -2428,112 +3313,119 @@ msgid "" "breaks are not included in the resulting list unless *keepends* is given and " "true." msgstr "" +"Retorna una lista con las líneas en la cadena, dividiendo por los saltos de " +"línea. Los caracteres de salto de línea en sí no se incluyen a no ser que se " +"especifique lo contrario pasando el valor ``True`` en al parámetro " +"*keepends*." #: ../Doc/library/stdtypes.rst:1947 msgid "" "This method splits on the following line boundaries. In particular, the " "boundaries are a superset of :term:`universal newlines`." msgstr "" +"Este método considera como saltos de línea los siguientes caracteres. En " +"concreto, estos son un superconjunto de los :term:`saltos de líneas " +"universales`." #: ../Doc/library/stdtypes.rst:1951 msgid "Representation" -msgstr "" +msgstr "Representación" #: ../Doc/library/stdtypes.rst:1951 msgid "Description" -msgstr "" +msgstr "Descripción" #: ../Doc/library/stdtypes.rst:1953 msgid "``\\n``" -msgstr "" +msgstr "``\\n``" #: ../Doc/library/stdtypes.rst:1953 msgid "Line Feed" -msgstr "" +msgstr "Salto de línea" #: ../Doc/library/stdtypes.rst:1955 msgid "``\\r``" -msgstr "" +msgstr "``\\r``" #: ../Doc/library/stdtypes.rst:1955 msgid "Carriage Return" -msgstr "" +msgstr "Retorno de carro" #: ../Doc/library/stdtypes.rst:1957 msgid "``\\r\\n``" -msgstr "" +msgstr "``\\r\\n``" #: ../Doc/library/stdtypes.rst:1957 msgid "Carriage Return + Line Feed" -msgstr "" +msgstr "Retorno de carro + salto de línea" #: ../Doc/library/stdtypes.rst:1959 msgid "``\\v`` or ``\\x0b``" -msgstr "" +msgstr "``\\v`` o ``\\x0b``" #: ../Doc/library/stdtypes.rst:1959 msgid "Line Tabulation" -msgstr "" +msgstr "Tabulación de línea" #: ../Doc/library/stdtypes.rst:1961 msgid "``\\f`` or ``\\x0c``" -msgstr "" +msgstr "``\\f`` o ``\\x0c``" #: ../Doc/library/stdtypes.rst:1961 msgid "Form Feed" -msgstr "" +msgstr "Avance de página" #: ../Doc/library/stdtypes.rst:1963 msgid "``\\x1c``" -msgstr "" +msgstr "``\\x1c``" #: ../Doc/library/stdtypes.rst:1963 msgid "File Separator" -msgstr "" +msgstr "Separador de archivo" #: ../Doc/library/stdtypes.rst:1965 msgid "``\\x1d``" -msgstr "" +msgstr "``\\x1d``" #: ../Doc/library/stdtypes.rst:1965 msgid "Group Separator" -msgstr "" +msgstr "Separador de grupo" #: ../Doc/library/stdtypes.rst:1967 msgid "``\\x1e``" -msgstr "" +msgstr "``\\x1e``" #: ../Doc/library/stdtypes.rst:1967 msgid "Record Separator" -msgstr "" +msgstr "Separador de registro" #: ../Doc/library/stdtypes.rst:1969 msgid "``\\x85``" -msgstr "" +msgstr "``\\x85``" #: ../Doc/library/stdtypes.rst:1969 msgid "Next Line (C1 Control Code)" -msgstr "" +msgstr "Siguiente línea (Código de control *C1*)" #: ../Doc/library/stdtypes.rst:1971 msgid "``\\u2028``" -msgstr "" +msgstr "``\\u2028``" #: ../Doc/library/stdtypes.rst:1971 msgid "Line Separator" -msgstr "" +msgstr "Separador de línea" #: ../Doc/library/stdtypes.rst:1973 msgid "``\\u2029``" -msgstr "" +msgstr "``\\u2029``" #: ../Doc/library/stdtypes.rst:1973 msgid "Paragraph Separator" -msgstr "" +msgstr "Separador de párrafo" #: ../Doc/library/stdtypes.rst:1978 msgid "``\\v`` and ``\\f`` added to list of line boundaries." -msgstr "" +msgstr "Se añaden ``\\v`` y ``\\f`` a la lista de separadores." #: ../Doc/library/stdtypes.rst:1987 msgid "" @@ -2541,10 +3433,13 @@ msgid "" "method returns an empty list for the empty string, and a terminal line break " "does not result in an extra line::" msgstr "" +"Al contrario que con :meth:`~str.split`, cuando se especifica una cadena con " +"*sep*, el método retorna una lista vacía para la cadena vacía, y un salto de " +"línea al final del texto no produce una línea extra::" #: ../Doc/library/stdtypes.rst:1996 msgid "For comparison, ``split('\\n')`` gives::" -msgstr "" +msgstr "Por comparación, ``split('\\n')`` entrega::" #: ../Doc/library/stdtypes.rst:2006 msgid "" @@ -2553,6 +3448,10 @@ msgid "" "optional *start*, test string beginning at that position. With optional " "*end*, stop comparing string at that position." msgstr "" +"Retorna ``True`` si la cadena empieza por *prefix*, en caso contrario " +"Retorna ``False``. El valor de *prefix* puede ser también una tupla de " +"prefijos por los que buscar. Con el parámetro opcional *start*, la " +"comprobación empieza en esa posición de la cadena." #: ../Doc/library/stdtypes.rst:2014 msgid "" @@ -2562,6 +3461,12 @@ msgid "" "removing whitespace. The *chars* argument is not a prefix or suffix; rather, " "all combinations of its values are stripped::" msgstr "" +"Retorna una copia de la cadena con los caracteres indicados eliminados, " +"tanto si están al principio como al final de la cadena. El parámetro " +"opcional *chars* es una cadena que especifica el conjunto de caracteres a " +"eliminar. Si se omite o se usa ``None``, se eliminan los caracteres de " +"espacio en blanco. No debe entenderse el valor de *chars* como un prefijo, " +"sino que se elimina cualquier combinación de sus caracteres::" #: ../Doc/library/stdtypes.rst:2025 msgid "" @@ -2570,6 +3475,11 @@ msgid "" "string character that is not contained in the set of characters in *chars*. " "A similar action takes place on the trailing end. For example::" msgstr "" +"Los caracteres indicados por *chars* se eliminan de los extremos al " +"principio y al final de la cadena. Se elimina los caracteres del inicio " +"hasta que se encuentra un carácter que no esté incluido en el conjunto " +"definido por *chars*. Se procede de manera similar para los caracteres al " +"final. Por ejemplo::" #: ../Doc/library/stdtypes.rst:2038 msgid "" @@ -2577,12 +3487,17 @@ msgid "" "and vice versa. Note that it is not necessarily true that ``s.swapcase()." "swapcase() == s``." msgstr "" +"Retorna una copia de la cadena con los caracteres en mayúsculas convertidos " +"a minúsculas, y viceversa. Nótese que no es necesariamente cierto que ``s." +"swapcase().swapcase() == s``." #: ../Doc/library/stdtypes.rst:2045 msgid "" "Return a titlecased version of the string where words start with an " "uppercase character and the remaining characters are lowercase." msgstr "" +"Retorna una versión en forma de título de la cadena, con la primera letra de " +"cada palabra en mayúsculas y el resto en minúsculas." #: ../Doc/library/stdtypes.rst:2053 ../Doc/library/stdtypes.rst:3204 msgid "" @@ -2591,11 +3506,19 @@ msgid "" "means that apostrophes in contractions and possessives form word boundaries, " "which may not be the desired result::" msgstr "" +"El algoritmo usa una definición sencilla e independiente del lenguaje, " +"consistente en considerar una palabra como un grupo de letras consecutivas. " +"Esta definición funciona en varios entornos, pero implica que, por ejemplo " +"en inglés, los apóstrofos en las contracciones y en los posesivos " +"constituyen una separación entre palabras, que puede que no sea el efecto " +"deseado::" #: ../Doc/library/stdtypes.rst:2061 ../Doc/library/stdtypes.rst:3212 msgid "" "A workaround for apostrophes can be constructed using regular expressions::" msgstr "" +"Se puede solucionar parcialmente el problema de los apóstrofos usando " +"expresiones regulares::" #: ../Doc/library/stdtypes.rst:2075 msgid "" @@ -2608,18 +3531,33 @@ msgid "" "delete the character from the return string; or raise a :exc:`LookupError` " "exception, to map the character to itself." msgstr "" +"Retorna una copia de la cadena en la que cada carácter ha sido sustituido " +"por su equivalente definido en la tabla de traducción dada. La tabla puede " +"ser cualquier objeto que soporta el acceso mediante índices implementado en " +"método :meth:`__getitem__`, normalmente un objeto de tipo :term:" +"`mapa` o :term:`secuencia`. Cuando se accede como índice " +"con un código Unicode (Un entero), el objeto tabla puede hacer una de las " +"siguientes cosas: retornar otro código Unicode o retornar una cadena de " +"caracteres, de forma que se usaran uno u otro como reemplazo en la cadena de " +"salida; retornar ``None`` para eliminar el carácter en la cadena de salida, " +"o elevar una excepción de tipo :exc:`LookupError`, que hará que el carácter " +"se copie igual en la cadena de salida." #: ../Doc/library/stdtypes.rst:2084 msgid "" "You can use :meth:`str.maketrans` to create a translation map from character-" "to-character mappings in different formats." msgstr "" +"Se puede usar :meth:`str.maketrans` para crear un mapa de traducción " +"carácter a carácter de diferentes formas." #: ../Doc/library/stdtypes.rst:2087 msgid "" "See also the :mod:`codecs` module for a more flexible approach to custom " "character mappings." msgstr "" +"Véase también el módulo :mod:`codecs` para una aproximación más flexible al " +"mapeo de caracteres." #: ../Doc/library/stdtypes.rst:2093 msgid "" @@ -2629,12 +3567,20 @@ msgid "" "character(s) is not \"Lu\" (Letter, uppercase), but e.g. \"Lt\" (Letter, " "titlecase)." msgstr "" +"Retorna una copia de la cadena, con todos los caracteres con formas " +"mayúsculas/minúsculas [4]_ pasados a minúsculas. Nótese que ``s.upper()." +"isupper()`` puede retornar falso si ``s`` contiene caracteres que no tengan " +"las dos formas, o si la categoría Unicode del carácter o caracteres " +"resultantes no es \"*Lu*\" (Letra, mayúsculas), sino, por ejemplo, \"*Lt*" +"\" (Letra, Título)." #: ../Doc/library/stdtypes.rst:2099 msgid "" "The uppercasing algorithm used is described in section 3.13 of the Unicode " "Standard." msgstr "" +"El algoritmo de paso a mayúsculas es el descrito en la sección 3.13 del " +"estándar Unicode." #: ../Doc/library/stdtypes.rst:2105 msgid "" @@ -2643,10 +3589,15 @@ msgid "" "by inserting the padding *after* the sign character rather than before. The " "original string is returned if *width* is less than or equal to ``len(s)``." msgstr "" +"Retorna una copia de la cadena, rellena por la izquierda con los carácter " +"ASCII ``'0'`` necesarios para conseguir una cadena de longitud *width*. El " +"carácter prefijo de signo (``'+'``/``'-'``) se gestiona insertando el " +"relleno *después* del carácter de signo en vez de antes. Si *width* es menor " +"o igual que ``len(s)``, se retorna la cadena original." #: ../Doc/library/stdtypes.rst:2123 msgid "``printf``-style String Formatting" -msgstr "" +msgstr "Formateo de cadenas al estilo ``*printf*``" #: ../Doc/library/stdtypes.rst:2136 msgid "" @@ -2658,6 +3609,14 @@ msgid "" "provides their own trade-offs and benefits of simplicity, flexibility, and/" "or extensibility." msgstr "" +"Las operaciones de formateo explicadas aquí tienen una serie de " +"peculiaridades que conducen a ciertos errores comunes (Como fallar al " +"representar tuplas y diccionarios correctamente). Se pueden evitar estos " +"errores usando las nuevas :ref:`cadenas de caracteres con formato `, el método :meth:`str.format`, o :ref:`plantillas de cadenas de " +"caracteres `. Cada una de estas alternativas proporcionan " +"sus propios compromisos entre facilidad de uso, flexibilidad y capacidad de " +"extensión." #: ../Doc/library/stdtypes.rst:2144 msgid "" @@ -2668,6 +3627,13 @@ msgid "" "elements of *values*. The effect is similar to using the :c:func:`sprintf` " "in the C language." msgstr "" +"Las cadenas de caracteres tienen una operación básica: El operador ``%`` " +"(módulo). Esta operación se conoce también como *formateo* de cadenas y " +"operador de interpolación. Dada la expresión ``formato % valores`` (Donde " +"*formato* es una cadena), las especificaciones de conversión indicadas en la " +"cadena con el símbolo ``%`` son reemplazadas por cero o más elementos de " +"*valores*. El efecto es similar a usar la función del lenguaje C :c:func:" +"`sprintf`." #: ../Doc/library/stdtypes.rst:2150 msgid "" @@ -2676,28 +3642,39 @@ msgid "" "items specified by the format string, or a single mapping object (for " "example, a dictionary)." msgstr "" +"Si *formato* tiene un único marcador, *valores* puede ser un objeto " +"sencillo, no una tupla. [5]_ En caso contrario, *valores* debe ser una tupla " +"con exactamente el mismo número de elementos que marcadores usados en la " +"cadena de formato, o un único objeto de tipo mapa (Por ejemplo, un " +"diccionario)." #: ../Doc/library/stdtypes.rst:2160 ../Doc/library/stdtypes.rst:3315 msgid "" "A conversion specifier contains two or more characters and has the following " "components, which must occur in this order:" msgstr "" +"Un especificador de conversión consiste en dos o más caracteres y tiene los " +"siguientes componentes, que deben aparecer en el siguiente orden:" #: ../Doc/library/stdtypes.rst:2163 ../Doc/library/stdtypes.rst:3318 msgid "The ``'%'`` character, which marks the start of the specifier." -msgstr "" +msgstr "El carácter ``'%'``, que identifica el inicio del marcador." #: ../Doc/library/stdtypes.rst:2165 ../Doc/library/stdtypes.rst:3320 msgid "" "Mapping key (optional), consisting of a parenthesised sequence of characters " "(for example, ``(somename)``)." msgstr "" +"Una clave de mapeo (opcional), consistente en una secuencia de caracteres " +"entre paréntesis, como por ejemplo, ``(somename)``." #: ../Doc/library/stdtypes.rst:2168 ../Doc/library/stdtypes.rst:3323 msgid "" "Conversion flags (optional), which affect the result of some conversion " "types." msgstr "" +"Indicador de conversión (opcional), que afecta el resultado de ciertas " +"conversiones de tipos." #: ../Doc/library/stdtypes.rst:2171 ../Doc/library/stdtypes.rst:3326 msgid "" @@ -2705,6 +3682,10 @@ msgid "" "actual width is read from the next element of the tuple in *values*, and the " "object to convert comes after the minimum field width and optional precision." msgstr "" +"Valor de ancho mínimo (opcional). Si se especifica un ``'*'`` (asterisco), " +"el ancho real se lee del siguiente elemento de la tupla *valores*, y el " +"objeto a convertir viene después del ancho mínimo, con un indicador de " +"precisión opcional." #: ../Doc/library/stdtypes.rst:2175 ../Doc/library/stdtypes.rst:3330 msgid "" @@ -2713,14 +3694,18 @@ msgid "" "next element of the tuple in *values*, and the value to convert comes after " "the precision." msgstr "" +"Precisión (Opcional), en la forma ``'.'`` (punto) seguido de la precisión. " +"Si se especifica un ``'*'`` (Asterisco), el valor de precisión real se lee " +"del siguiente elemento de la tupla *valores*, y el valor a convertir viene " +"después de la precisión." #: ../Doc/library/stdtypes.rst:2180 ../Doc/library/stdtypes.rst:3335 msgid "Length modifier (optional)." -msgstr "" +msgstr "Modificador de longitud (Opcional)." #: ../Doc/library/stdtypes.rst:2182 ../Doc/library/stdtypes.rst:3337 msgid "Conversion type." -msgstr "" +msgstr "Tipo de conversión." #: ../Doc/library/stdtypes.rst:2184 msgid "" @@ -2729,67 +3714,84 @@ msgid "" "dictionary inserted immediately after the ``'%'`` character. The mapping key " "selects the value to be formatted from the mapping. For example:" msgstr "" +"Cuando el operador derecho es un diccionario (o cualquier otro objeto de " +"tipo mapa), los marcadores en la cadena *deben* incluir un valor de clave " +"entre paréntesis, inmediatamente después del carácter ``'%'``. El valor de " +"la clave se usa para seleccionar el valor a formatear desde el mapa. Por " +"ejemplo::" #: ../Doc/library/stdtypes.rst:2193 ../Doc/library/stdtypes.rst:3348 msgid "" "In this case no ``*`` specifiers may occur in a format (since they require a " "sequential parameter list)." msgstr "" +"En este caso, no se pueden usar el especificador ``*`` en la cadena de " +"formato (Dado que requiere una lista secuencial de parámetros)." #: ../Doc/library/stdtypes.rst:2196 ../Doc/library/stdtypes.rst:3351 msgid "The conversion flag characters are:" -msgstr "" +msgstr "Los indicadores de conversión son:" #: ../Doc/library/stdtypes.rst:2205 ../Doc/library/stdtypes.rst:3360 msgid "Flag" -msgstr "" +msgstr "Flag" #: ../Doc/library/stdtypes.rst:2207 ../Doc/library/stdtypes.rst:3362 msgid "``'#'``" -msgstr "" +msgstr "``'#'``" #: ../Doc/library/stdtypes.rst:2207 ../Doc/library/stdtypes.rst:3362 msgid "" "The value conversion will use the \"alternate form\" (where defined below)." msgstr "" +"El valor a convertir usara la \"forma alternativa\" (Que se definirá más " +"adelante)" #: ../Doc/library/stdtypes.rst:2210 ../Doc/library/stdtypes.rst:3365 msgid "``'0'``" -msgstr "" +msgstr "``'0'``" #: ../Doc/library/stdtypes.rst:2210 ../Doc/library/stdtypes.rst:3365 msgid "The conversion will be zero padded for numeric values." msgstr "" +"La conversión rellena con ceros por la izquierda para valores numéricos." #: ../Doc/library/stdtypes.rst:2212 ../Doc/library/stdtypes.rst:3367 msgid "``'-'``" -msgstr "" +msgstr "``'-'``" +# Sobreescribe no me acaba de gustar #: ../Doc/library/stdtypes.rst:2212 ../Doc/library/stdtypes.rst:3367 msgid "" "The converted value is left adjusted (overrides the ``'0'`` conversion if " "both are given)." msgstr "" +"El valor convertido se ajusta a la izquierda (Sobreescribe la conversión " +"``'0'`` si se especifican los dos)" #: ../Doc/library/stdtypes.rst:2215 ../Doc/library/stdtypes.rst:3370 msgid "``' '``" -msgstr "" +msgstr "``' '``" #: ../Doc/library/stdtypes.rst:2215 ../Doc/library/stdtypes.rst:3370 msgid "" "(a space) A blank should be left before a positive number (or empty string) " "produced by a signed conversion." msgstr "" +"(Un espacio) Se deba añadir un espacio en blanco antes de un número positivo " +"(O una cadena vacía) si se usa una conversión con signo." #: ../Doc/library/stdtypes.rst:2218 ../Doc/library/stdtypes.rst:3373 msgid "``'+'``" -msgstr "" +msgstr "``'+'``" #: ../Doc/library/stdtypes.rst:2218 ../Doc/library/stdtypes.rst:3373 msgid "" "A sign character (``'+'`` or ``'-'``) will precede the conversion (overrides " "a \"space\" flag)." msgstr "" +"Un carácter signo (``'+'`` o ``'-'``) precede a la conversión (Sobreescribe " +"el indicador de \"espacio\")" #: ../Doc/library/stdtypes.rst:2222 ../Doc/library/stdtypes.rst:3377 #, python-format @@ -2797,154 +3799,175 @@ msgid "" "A length modifier (``h``, ``l``, or ``L``) may be present, but is ignored as " "it is not necessary for Python -- so e.g. ``%ld`` is identical to ``%d``." msgstr "" +"Puede estar presente un modificador de longitud (``h``, ``l`` o ``L``), pero " +"se ignora y no es necesario para Python -- por lo que, por ejemplo, la " +"salida de ``%ld`` es idéntica a ``%d``." #: ../Doc/library/stdtypes.rst:2225 ../Doc/library/stdtypes.rst:3380 msgid "The conversion types are:" -msgstr "" +msgstr "Los tipos de conversión son:" #: ../Doc/library/stdtypes.rst:2228 ../Doc/library/stdtypes.rst:3383 msgid "Conversion" -msgstr "" +msgstr "Conversión" #: ../Doc/library/stdtypes.rst:2230 ../Doc/library/stdtypes.rst:3385 msgid "``'d'``" -msgstr "" +msgstr "``'d'``" #: ../Doc/library/stdtypes.rst:2230 ../Doc/library/stdtypes.rst:2232 #: ../Doc/library/stdtypes.rst:3385 ../Doc/library/stdtypes.rst:3387 msgid "Signed integer decimal." -msgstr "" +msgstr "Entero decimal con signo." #: ../Doc/library/stdtypes.rst:2232 ../Doc/library/stdtypes.rst:3387 msgid "``'i'``" -msgstr "" +msgstr "``'i'``" #: ../Doc/library/stdtypes.rst:2234 ../Doc/library/stdtypes.rst:3389 msgid "``'o'``" -msgstr "" +msgstr "``'o'``" #: ../Doc/library/stdtypes.rst:2234 ../Doc/library/stdtypes.rst:3389 msgid "Signed octal value." -msgstr "" +msgstr "Valor octal con signo." #: ../Doc/library/stdtypes.rst:2236 ../Doc/library/stdtypes.rst:3391 msgid "``'u'``" -msgstr "" +msgstr "``'u'``" #: ../Doc/library/stdtypes.rst:2236 ../Doc/library/stdtypes.rst:3391 msgid "Obsolete type -- it is identical to ``'d'``." -msgstr "" +msgstr "Obsoleto -- es idéntico a ``'d'``." #: ../Doc/library/stdtypes.rst:2238 ../Doc/library/stdtypes.rst:3393 msgid "``'x'``" -msgstr "" +msgstr "``'x'``" #: ../Doc/library/stdtypes.rst:2238 ../Doc/library/stdtypes.rst:3393 msgid "Signed hexadecimal (lowercase)." -msgstr "" +msgstr "Hexadecimal con signo (En minúsculas)" #: ../Doc/library/stdtypes.rst:2240 ../Doc/library/stdtypes.rst:3395 msgid "``'X'``" -msgstr "" +msgstr "``'X'``" #: ../Doc/library/stdtypes.rst:2240 ../Doc/library/stdtypes.rst:3395 msgid "Signed hexadecimal (uppercase)." -msgstr "" +msgstr "Hexadecimal con signo (En mayúsculas)" #: ../Doc/library/stdtypes.rst:2242 ../Doc/library/stdtypes.rst:3397 msgid "``'e'``" -msgstr "" +msgstr "``'e'``" #: ../Doc/library/stdtypes.rst:2242 ../Doc/library/stdtypes.rst:3397 msgid "Floating point exponential format (lowercase)." -msgstr "" +msgstr "Formato en coma flotante exponencial (En minúsculas)." #: ../Doc/library/stdtypes.rst:2244 ../Doc/library/stdtypes.rst:3399 msgid "``'E'``" -msgstr "" +msgstr "``'E'``" #: ../Doc/library/stdtypes.rst:2244 ../Doc/library/stdtypes.rst:3399 msgid "Floating point exponential format (uppercase)." -msgstr "" +msgstr "Formato en coma flotante exponencial (En mayúsculas)." #: ../Doc/library/stdtypes.rst:2246 ../Doc/library/stdtypes.rst:3401 msgid "``'f'``" -msgstr "" +msgstr "``'f'``" #: ../Doc/library/stdtypes.rst:2246 ../Doc/library/stdtypes.rst:2248 #: ../Doc/library/stdtypes.rst:3401 ../Doc/library/stdtypes.rst:3403 msgid "Floating point decimal format." -msgstr "" +msgstr "Formato en coma flotante decimal." #: ../Doc/library/stdtypes.rst:2248 ../Doc/library/stdtypes.rst:3403 msgid "``'F'``" -msgstr "" +msgstr "``'F'``" #: ../Doc/library/stdtypes.rst:2250 ../Doc/library/stdtypes.rst:3405 msgid "``'g'``" -msgstr "" +msgstr "``'g'``" #: ../Doc/library/stdtypes.rst:2250 ../Doc/library/stdtypes.rst:3405 msgid "" "Floating point format. Uses lowercase exponential format if exponent is less " "than -4 or not less than precision, decimal format otherwise." msgstr "" +"Formato en coma flotante. Usa formato exponencial con minúsculas si el " +"exponente es menor que -4 o no es menor que la precisión, en caso contrario " +"usa el formato decimal." #: ../Doc/library/stdtypes.rst:2254 ../Doc/library/stdtypes.rst:3409 msgid "``'G'``" -msgstr "" +msgstr "``'G'``" #: ../Doc/library/stdtypes.rst:2254 ../Doc/library/stdtypes.rst:3409 msgid "" "Floating point format. Uses uppercase exponential format if exponent is less " "than -4 or not less than precision, decimal format otherwise." msgstr "" +"Formato en coma flotante. Usa formato exponencial con mayúsculas si el " +"exponente es menor que -4 o no es menor que la precisión, en caso contrario " +"usa el formato decimal." #: ../Doc/library/stdtypes.rst:2258 ../Doc/library/stdtypes.rst:3413 msgid "``'c'``" -msgstr "" +msgstr "``'c'``" #: ../Doc/library/stdtypes.rst:2258 msgid "Single character (accepts integer or single character string)." msgstr "" +"Un único carácter (Acepta números enteros o cadenas de caracteres de " +"longitud 1)" #: ../Doc/library/stdtypes.rst:2261 ../Doc/library/stdtypes.rst:3426 msgid "``'r'``" -msgstr "" +msgstr "``'r'``" #: ../Doc/library/stdtypes.rst:2261 msgid "String (converts any Python object using :func:`repr`)." msgstr "" +"Cadena de texto (Representará cualquier objeto usando la función :func:" +"`repr`)." #: ../Doc/library/stdtypes.rst:2264 ../Doc/library/stdtypes.rst:3420 msgid "``'s'``" -msgstr "" +msgstr "``'s'``" #: ../Doc/library/stdtypes.rst:2264 msgid "String (converts any Python object using :func:`str`)." msgstr "" +"Cadena de texto (Representará cualquier objeto usando la función :func:" +"`str`)." #: ../Doc/library/stdtypes.rst:2267 ../Doc/library/stdtypes.rst:3423 msgid "``'a'``" -msgstr "" +msgstr "``'a'``" #: ../Doc/library/stdtypes.rst:2267 msgid "String (converts any Python object using :func:`ascii`)." msgstr "" +"Cadena de texto (Representará cualquier objeto usando la función :func:" +"`ascii`)." #: ../Doc/library/stdtypes.rst:2270 ../Doc/library/stdtypes.rst:3429 msgid "``'%'``" -msgstr "" +msgstr "``'%'``" #: ../Doc/library/stdtypes.rst:2270 ../Doc/library/stdtypes.rst:3429 msgid "No argument is converted, results in a ``'%'`` character in the result." msgstr "" +"No se representa ningún argumento, obteniéndose en el resultado la cadena " +"``'%'``." #: ../Doc/library/stdtypes.rst:2277 ../Doc/library/stdtypes.rst:3436 msgid "" "The alternate form causes a leading octal specifier (``'0o'``) to be " "inserted before the first digit." msgstr "" +"La forma alternativa hace que se inserte antes del primer dígito un prefijo " +"indicativo del formato octal (``'0o'``)" #: ../Doc/library/stdtypes.rst:2281 ../Doc/library/stdtypes.rst:3440 msgid "" @@ -2952,38 +3975,51 @@ msgid "" "whether the ``'x'`` or ``'X'`` format was used) to be inserted before the " "first digit." msgstr "" +"La forma alternativa hace que se inserte antes del primer dígito uno de los " +"dos prefijos indicativos del formato hexadecimal ``'0x'`` or ``'0X'`` (Que " +"se use uno u otro depende de que indicador de formato se haya usado, ``'x'`` " +"or ``'X'``)." #: ../Doc/library/stdtypes.rst:2285 ../Doc/library/stdtypes.rst:3444 msgid "" "The alternate form causes the result to always contain a decimal point, even " "if no digits follow it." msgstr "" +"La forma alternativa hace que se incluya siempre el símbolo del punto o coma " +"decimal, incluso si no hubiera dígitos después." #: ../Doc/library/stdtypes.rst:2288 ../Doc/library/stdtypes.rst:3447 msgid "" "The precision determines the number of digits after the decimal point and " "defaults to 6." msgstr "" +"La precisión determina el número de dígitos que vienen después del punto " +"decimal, y por defecto es 6." #: ../Doc/library/stdtypes.rst:2292 ../Doc/library/stdtypes.rst:3451 msgid "" "The alternate form causes the result to always contain a decimal point, and " "trailing zeroes are not removed as they would otherwise be." msgstr "" +"La forma alternativa hace que se incluya siempre el símbolo del punto o coma " +"decimal, y los ceros a su derecha no se eliminan, como seria el caso en la " +"forma normal." #: ../Doc/library/stdtypes.rst:2295 ../Doc/library/stdtypes.rst:3454 msgid "" "The precision determines the number of significant digits before and after " "the decimal point and defaults to 6." msgstr "" +"La precisión determina el número de dígitos significativos que vienen antes " +"y después del punto decimal, y por defecto es 6." #: ../Doc/library/stdtypes.rst:2299 ../Doc/library/stdtypes.rst:3458 msgid "If precision is ``N``, the output is truncated to ``N`` characters." -msgstr "" +msgstr "Si la precisión es ``N``, la salida se trunca a ``N`` caracteres." #: ../Doc/library/stdtypes.rst:2302 ../Doc/library/stdtypes.rst:3467 msgid "See :pep:`237`." -msgstr "" +msgstr "Véase :pep:`237`." #: ../Doc/library/stdtypes.rst:2304 #, python-format @@ -2991,6 +4027,8 @@ msgid "" "Since Python strings have an explicit length, ``%s`` conversions do not " "assume that ``'\\0'`` is the end of the string." msgstr "" +"Como en Python las cadenas de caracteres tiene una longitud explícita, la " +"conversión de ``%s`` no requiere que la cadena termine con ``'\\0'``." #: ../Doc/library/stdtypes.rst:2309 #, python-format @@ -2998,12 +4036,16 @@ msgid "" "``%f`` conversions for numbers whose absolute value is over 1e50 are no " "longer replaced by ``%g`` conversions." msgstr "" +"Las conversiones ``%f`` para números con valores absolutos mayores que 1e50 " +"ya no son reemplazadas por conversiones ``%g``." #: ../Doc/library/stdtypes.rst:2320 msgid "" "Binary Sequence Types --- :class:`bytes`, :class:`bytearray`, :class:" "`memoryview`" msgstr "" +"Tipos de secuencias binarias --- :class:`bytes`, :class:`bytearray` y :class:" +"`memoryview`" #: ../Doc/library/stdtypes.rst:2328 msgid "" @@ -3012,16 +4054,24 @@ msgid "" "ref:`buffer protocol ` to access the memory of other binary " "objects without needing to make a copy." msgstr "" +"Los tipos básicos para trabajar con datos binarios son las clases :class:" +"`bytes` y :class:`bytearray`. Ambas pueden ser usadas por la clase :class:" +"`memoryview`, que usa el :ref:`protocolo buffer ` para " +"acceder a la memoria de otros objetos binarios sin necesidad de hacer una " +"copia." #: ../Doc/library/stdtypes.rst:2333 msgid "" "The :mod:`array` module supports efficient storage of basic data types like " "32-bit integers and IEEE754 double-precision floating values." msgstr "" +"El módulo :mod:`array` soporta un almacenamiento eficiente de tipos de datos " +"básicos como enteros de 32 bits o números en formato de doble precisión en " +"coma flotante IEEE754." #: ../Doc/library/stdtypes.rst:2339 msgid "Bytes Objects" -msgstr "" +msgstr "Objetos de tipo Bytes" #: ../Doc/library/stdtypes.rst:2343 msgid "" @@ -3030,25 +4080,37 @@ msgid "" "several methods that are only valid when working with ASCII compatible data " "and are closely related to string objects in a variety of other ways." msgstr "" +"Los objetos *bytes* son secuencias inmutables de bytes. Como muchos de los " +"protocolos binarios más usados se basan en la codificación ASCII para texto, " +"los objetos *bytes* ofrecen varios métodos que solo son válidos cuando se " +"trabaja con datos compatibles ASCII y son, en varios aspectos, muy cercanos " +"a los cadenas de texto." #: ../Doc/library/stdtypes.rst:2350 msgid "" "Firstly, the syntax for bytes literals is largely the same as that for " "string literals, except that a ``b`` prefix is added:" msgstr "" +"Para empezar, la sintaxis de los valores literales de *bytes* son " +"prácticamente iguales que para las cadenas de texto, con la diferencia de " +"que se añade el carácter ``b`` como prefijo:" #: ../Doc/library/stdtypes.rst:2353 msgid "Single quotes: ``b'still allows embedded \"double\" quotes'``" msgstr "" +"Comillas sencillas: ``b'Se siguen aceptando comillas \"dobles\" embebidas'``" #: ../Doc/library/stdtypes.rst:2354 msgid "Double quotes: ``b\"still allows embedded 'single' quotes\"``." msgstr "" +"Comillas dobles: ``b'Se siguen aceptando comillas 'simples' embebidas'``." #: ../Doc/library/stdtypes.rst:2355 msgid "" "Triple quoted: ``b'''3 single quotes'''``, ``b\"\"\"3 double quotes\"\"\"``" msgstr "" +"Comillas triples: ``b'''3 comillas simples'''``, ``b\"\"\"3 comillas dobles" +"\"\"\"``" #: ../Doc/library/stdtypes.rst:2357 msgid "" @@ -3056,6 +4118,9 @@ msgid "" "declared source code encoding). Any binary values over 127 must be entered " "into bytes literals using the appropriate escape sequence." msgstr "" +"Solo se admiten caracteres ASCII en representaciones literales de *bytes* " +"(Con independencia del tipo de codificación declarado). Cualquier valor por " +"encima de 127 debe ser definido usando su secuencia de escape." #: ../Doc/library/stdtypes.rst:2361 msgid "" @@ -3063,6 +4128,11 @@ msgid "" "disable processing of escape sequences. See :ref:`strings` for more about " "the various forms of bytes literal, including supported escape sequences." msgstr "" +"Al igual que con las cadenas, los literales de *bytes* pueden usar el " +"prefijo ``r`` para deshabilitar el procesado de las secuencias de escape. " +"Véase :ref:`strings` para más información acerca de los diferentes formas de " +"expresar *bytes* de forma literal, incluyendo el soporte de secuencias de " +"escape." #: ../Doc/library/stdtypes.rst:2365 msgid "" @@ -3076,28 +4146,44 @@ msgid "" "text processing algorithms to binary data formats that are not ASCII " "compatible will usually lead to data corruption)." msgstr "" +"Aunque las secuencias de bytes y sus representaciones se basen en texto " +"ASCII, los objetos *bytes* se comportan más como secuencias inmutables de " +"números enteros, donde cada elemento de la secuencia está restringido a los " +"valores de *x* tal que ``0 <= x < 256`` (Si se intenta violar esta " +"restricción se elevará una excepción de tipo :exc:`ValueError`). Esto se ha " +"hecho de forma intencionada para enfatizar que, aunque muchos formatos " +"binarios incluyen elementos basados en caracteres ASCII y pueden ser " +"manipulados mediante algunas técnicas de procesado de textos, este no es el " +"caso general para los datos binarios (Aplicar algoritmos pensados para " +"proceso de textos a datos binarios que no se compatibles con ASCII " +"normalmente corromperán dichos datos." #: ../Doc/library/stdtypes.rst:2375 msgid "" "In addition to the literal forms, bytes objects can be created in a number " "of other ways:" msgstr "" +"Además de con literales, se pueden crear objetos de tipo *byte* de las " +"siguientes maneras:" #: ../Doc/library/stdtypes.rst:2378 msgid "A zero-filled bytes object of a specified length: ``bytes(10)``" msgstr "" +"Un secuencia de una longitud especificada rellena con ceros: ``bytes(10)``" #: ../Doc/library/stdtypes.rst:2379 msgid "From an iterable of integers: ``bytes(range(20))``" -msgstr "" +msgstr "A partir de un iterable de números enteros: ``bytes(range(20))``" #: ../Doc/library/stdtypes.rst:2380 msgid "Copying existing binary data via the buffer protocol: ``bytes(obj)``" msgstr "" +"Copiando datos binarios ya existentes mediante el protocolo *buffer*: " +"``bytes(obj)``" #: ../Doc/library/stdtypes.rst:2382 msgid "Also see the :ref:`bytes ` built-in." -msgstr "" +msgstr "Véase además la función básica :ref:`bytes `." #: ../Doc/library/stdtypes.rst:2384 msgid "" @@ -3106,6 +4192,10 @@ msgid "" "Accordingly, the bytes type has an additional class method to read data in " "that format:" msgstr "" +"Como dos dígitos hexadecimales se corresponden exactamente con un byte, " +"suelen usase números hexadecimales para describir datos binarios. Por ello, " +"los objetos de tipo *byte* disponen de un método adicional para leer datos " +"en ese formato:" #: ../Doc/library/stdtypes.rst:2390 msgid "" @@ -3113,24 +4203,34 @@ msgid "" "string object. The string must contain two hexadecimal digits per byte, " "with ASCII whitespace being ignored." msgstr "" +"Este método de clase de :class:`bytes` retorna un objeto binario, " +"decodificado a partir de la cadena suministrada como parámetro. La cadena de " +"texto debe consistir en dos dígitos hexadecimales por cada byte, ignorándose " +"los caracteres ASCII de espacio en blanco, si los hubiera." #: ../Doc/library/stdtypes.rst:2397 msgid "" ":meth:`bytes.fromhex` now skips all ASCII whitespace in the string, not just " "spaces." msgstr "" +"El método :meth:`bytes.fromhex` ignora ahora todos los caracteres ASCII de " +"espacio en blanco, no solo el carácter espacio." #: ../Doc/library/stdtypes.rst:2401 msgid "" "A reverse conversion function exists to transform a bytes object into its " "hexadecimal representation." msgstr "" +"Existe una función que realiza la operación inversa, es decir, transforma un " +"objeto binario en una representación textual usando hexadecimal." #: ../Doc/library/stdtypes.rst:2406 ../Doc/library/stdtypes.rst:2500 msgid "" "Return a string object containing two hexadecimal digits for each byte in " "the instance." msgstr "" +"Retorna una cadena de texto que contiene dos dígitos hexadecimales por cada " +"byte de la instancia." #: ../Doc/library/stdtypes.rst:2412 msgid "" @@ -3140,12 +4240,20 @@ msgid "" "spacing. Positive values calculate the separator position from the right, " "negative values from the left." msgstr "" +"Si quieres que la cadena en hexadecimal sea más fácil de leer, se puede " +"especificar un único carácter separador con el parámetro *sep* para que se " +"añada a la salida. Un segundo parámetro opcional, *bytes_per_sep*, controla " +"los espacios. Valores positivos calculan la posición del separador desde la " +"derecha, los negativos lo hacen desde la izquierda." #: ../Doc/library/stdtypes.rst:2428 msgid "" ":meth:`bytes.hex` now supports optional *sep* and *bytes_per_sep* parameters " "to insert separators between bytes in the hex output." msgstr "" +"El método :meth:`bytes.hex` ahora soporta los parámetros opcionales *sep* y " +"*bytes_per_sep*, que permiten insertar separadores entre los bytes de la " +"cadena de salida." #: ../Doc/library/stdtypes.rst:2432 msgid "" @@ -3154,6 +4262,12 @@ msgid "" "object of length 1. (This contrasts with text strings, where both indexing " "and slicing will produce a string of length 1)" msgstr "" +"Como los objetos de tipo *bytes* son secuencias de números enteros " +"(Similares a tuplas), para un objeto binario *b*, ``b[0]`` retorna un " +"entero, mientras que ``b[0:1]`` retorna un objeto de tipo *bytes* de " +"longitud 1 (Mientras que las cadenas de texto siempre retornan una cadena de " +"longitud 1, ya sea accediendo por índice o mediante una operación de " +"rebanada)." #: ../Doc/library/stdtypes.rst:2437 msgid "" @@ -3161,6 +4275,10 @@ msgid "" "since it is often more useful than e.g. ``bytes([46, 46, 46])``. You can " "always convert a bytes object into a list of integers using ``list(b)``." msgstr "" +"La representación de los objetos tipo *bytes* usa el formato literal " +"(``b'...'``) ya que es, por lo general, más útil que, digamos, ``bytes([46, " +"46, 46])``. Siempre se puede convertir un objeto binario en una lista de " +"enteros usando ``list(b)``." #: ../Doc/library/stdtypes.rst:2442 msgid "" @@ -3173,39 +4291,57 @@ msgid "" "bit binary data and Unicode text must be explicit, and bytes and string " "objects will always compare unequal." msgstr "" +"Para usuarios de Python 2.x: En la serie Python 2.x, se permitía una " +"variedad de conversiones implícitas entre cadenas de caracteres de 8 bits " +"(El tipo de datos más cercano que se podía usar en estas versiones) y " +"cadenas de caracteres Unicode. Esto se implemento como una forma de " +"compatibilidad hacia atrás para reflejar el hecho de que originalmente " +"Python solo soportaba textos de 8 bits, siendo el texto Unicode un añadido " +"posterior. En Python 3.x, estas conversiones implícitas se han eliminado: " +"Todas las conversiones entre datos binarios y textos Unicode deben ser " +"explícitas, y objetos de tipo *bytes* y objetos de tipo cadena de caracteres " +"siempre serán considerados diferentes." #: ../Doc/library/stdtypes.rst:2455 msgid "Bytearray Objects" -msgstr "" +msgstr "Objetos de tipo *Bytearray*" #: ../Doc/library/stdtypes.rst:2459 msgid "" ":class:`bytearray` objects are a mutable counterpart to :class:`bytes` " "objects." msgstr "" +"Los objetos de tipo :class:`bytearray` son versiones mutables de los objetos " +"de tipo :class:`bytes`." #: ../Doc/library/stdtypes.rst:2464 msgid "" "There is no dedicated literal syntax for bytearray objects, instead they are " "always created by calling the constructor:" msgstr "" +"No existe una sintaxis específica para crear objetos de tipo *bytearray*, " +"hay que crearlos siempre llamando a su constructor:" #: ../Doc/library/stdtypes.rst:2467 msgid "Creating an empty instance: ``bytearray()``" -msgstr "" +msgstr "Creando una secuencia vacía: ``bytearray()``" #: ../Doc/library/stdtypes.rst:2468 msgid "Creating a zero-filled instance with a given length: ``bytearray(10)``" msgstr "" +"Creando una instancia de una longitud determinada, rellena con ceros: " +"``bytearray(10)``" #: ../Doc/library/stdtypes.rst:2469 msgid "From an iterable of integers: ``bytearray(range(20))``" -msgstr "" +msgstr "A partir de un iterable de números enteros: ``bytearray(range(20))``" #: ../Doc/library/stdtypes.rst:2470 msgid "" "Copying existing binary data via the buffer protocol: ``bytearray(b'Hi!')``" msgstr "" +"Copiando datos binarios ya existentes mediante el protocolo *buffer*: " +"``bytearray(b'Hi!')``" #: ../Doc/library/stdtypes.rst:2472 msgid "" @@ -3213,10 +4349,13 @@ msgid "" "mutable>` sequence operations in addition to the common bytes and bytearray " "operations described in :ref:`bytes-methods`." msgstr "" +"Como los objetos *bytearray* son mutables, soportan todas las operaciones " +"aplicables a tipos :ref:`mutables `, además de las " +"operaciones propias de los *bytearrays* descritas en :ref:`bytes-methods`." #: ../Doc/library/stdtypes.rst:2476 msgid "Also see the :ref:`bytearray ` built-in." -msgstr "" +msgstr "Véase también la función básica :ref:`bytearray `." #: ../Doc/library/stdtypes.rst:2478 msgid "" @@ -3225,6 +4364,10 @@ msgid "" "Accordingly, the bytearray type has an additional class method to read data " "in that format:" msgstr "" +"Como dos dígitos hexadecimales se corresponden exactamente con un byte, " +"suelen usase números hexadecimales para describir datos binarios. Por ello, " +"los objetos de tipo *bytearray* disponen de un método de clase adicional " +"para leer datos en ese formato:" #: ../Doc/library/stdtypes.rst:2484 msgid "" @@ -3232,18 +4375,26 @@ msgid "" "given string object. The string must contain two hexadecimal digits per " "byte, with ASCII whitespace being ignored." msgstr "" +"Este método de clase de :class:`bytes` retorna un objeto *bytearray*, " +"decodificado a partir de la cadena suministrada como parámetro. La cadena de " +"texto debe consistir en dos dígitos hexadecimales por cada byte, ignorándose " +"los caracteres ASCII de espacio en blanco, si los hubiera." #: ../Doc/library/stdtypes.rst:2491 msgid "" ":meth:`bytearray.fromhex` now skips all ASCII whitespace in the string, not " "just spaces." msgstr "" +"El método :meth:`bytearray.fromhex` ignora ahora todos los caracteres ASCII " +"de espacio en blanco, no solo el carácter espacio." #: ../Doc/library/stdtypes.rst:2495 msgid "" "A reverse conversion function exists to transform a bytearray object into " "its hexadecimal representation." msgstr "" +"Existe una función que realiza la operación inversa, es decir, transforma un " +"objeto *bytearray* en una representación textual usando hexadecimal." #: ../Doc/library/stdtypes.rst:2508 msgid "" @@ -3251,6 +4402,9 @@ msgid "" "*sep* and *bytes_per_sep* parameters to insert separators between bytes in " "the hex output." msgstr "" +"De forma similar a :meth:`bytes.hex`, :meth:`bytearray.hex` soporta ahora " +"los parámetros opcionales *sep* y *bytes_per_sep* para insertar separadores " +"entre los bytes en la cadena hexadecimal de salida." #: ../Doc/library/stdtypes.rst:2513 msgid "" @@ -3259,6 +4413,12 @@ msgid "" "a bytearray object of length 1. (This contrasts with text strings, where " "both indexing and slicing will produce a string of length 1)" msgstr "" +"Como los objetos de tipo *bytearray* son secuencias de números enteros " +"(Similares a listas), para un objeto *bytearray* *b*, ``b[0]`` retorna un " +"entero, mientras que ``b[0:1]`` retorna un objeto de tipo *bytearray* de " +"longitud 1 (Mientras que las cadenas de texto siempre retornan una cadena de " +"longitud 1, ya sea accediendo por índice o mediante una operación de " +"rebanada)." #: ../Doc/library/stdtypes.rst:2518 msgid "" @@ -3267,10 +4427,14 @@ msgid "" "``bytearray([46, 46, 46])``. You can always convert a bytearray object into " "a list of integers using ``list(b)``." msgstr "" +"La representación de los objetos tipo *bytearray* usa el formato literal " +"(``bytearray(b'...')``) ya que es, por lo general, más útil que, digamos, " +"``bytearray([46, 46, 46])``. Siempre se puede convertir un objeto " +"*bytearray* en una lista de enteros usando ``list(b)``." #: ../Doc/library/stdtypes.rst:2527 msgid "Bytes and Bytearray Operations" -msgstr "" +msgstr "Operaciones de *bytes* y *bytearray*" #: ../Doc/library/stdtypes.rst:2532 msgid "" @@ -3280,6 +4444,13 @@ msgid "" "can be freely mixed in operations without causing errors. However, the " "return type of the result may depend on the order of operands." msgstr "" +"Ambos tipos, *bytes* y *bytearray* soportan las operaciones :ref:`comunes " +"` de las secuencias. Los operadores no funcionan solo con " +"operandos del mismo tipo, sino con cualquier :term:`objeto tipo binario " +"`. Gracias a esta flexibilidad, estos tipos pueden " +"combinarse libremente en expresiones sin que se produzcan errores. Sin " +"embargo, el tipo del valor resultante puede depender del orden de los " +"operandos." #: ../Doc/library/stdtypes.rst:2540 msgid "" @@ -3287,10 +4458,14 @@ msgid "" "arguments, just as the methods on strings don't accept bytes as their " "arguments. For example, you have to write::" msgstr "" +"Los métodos de objetos de tipo *bytes* y *bytesarray* no aceptan cadenas de " +"caracteres como parámetros, de la misma manera que los métodos de las " +"cadenas tampoco aceptan *bytes* como parámetros. Por ejemplo, debes " +"escribir::" #: ../Doc/library/stdtypes.rst:2547 msgid "and::" -msgstr "" +msgstr "y::" #: ../Doc/library/stdtypes.rst:2552 msgid "" @@ -3298,18 +4473,27 @@ msgid "" "binary formats, and hence should be avoided when working with arbitrary " "binary data. These restrictions are covered below." msgstr "" +"Algunas operaciones de *bytes* y *bytearrays* asumen el uso de formatos " +"binarios compatibles ASCII, y por tanto deben ser evitadas cuando trabajamos " +"con datos binarios arbitrarios. Estas restricciones se explican a " +"continuación." #: ../Doc/library/stdtypes.rst:2557 msgid "" "Using these ASCII based operations to manipulate binary data that is not " "stored in an ASCII based format may lead to data corruption." msgstr "" +"Usar estas operaciones basadas en ASCII para manipular datos binarios que no " +"se almacenan en un formato basado en ASCII pueden producir corrupción de " +"datos." #: ../Doc/library/stdtypes.rst:2560 msgid "" "The following methods on bytes and bytearray objects can be used with " "arbitrary binary data." msgstr "" +"Los siguientes métodos de *bytes* y *bytearrays* pueden ser usados con datos " +"en formatos binarios arbitrarios." #: ../Doc/library/stdtypes.rst:2566 msgid "" @@ -3317,6 +4501,9 @@ msgid "" "range [*start*, *end*]. Optional arguments *start* and *end* are " "interpreted as in slice notation." msgstr "" +"Retorna el número de secuencias no solapadas de la subsecuencia *sub* en el " +"rango [*start*, *end*]. Los parámetros opcionales *start* y *end* se " +"interpretan como en las operaciones de rebanado." #: ../Doc/library/stdtypes.rst:2570 ../Doc/library/stdtypes.rst:2617 #: ../Doc/library/stdtypes.rst:2639 ../Doc/library/stdtypes.rst:2705 @@ -3325,13 +4512,16 @@ msgid "" "The subsequence to search for may be any :term:`bytes-like object` or an " "integer in the range 0 to 255." msgstr "" +"La subsecuencia a buscar puede ser cualquier :term:`objeto tipo binario " +"` o un número entero entre 0 y 255." #: ../Doc/library/stdtypes.rst:2573 ../Doc/library/stdtypes.rst:2629 #: ../Doc/library/stdtypes.rst:2642 ../Doc/library/stdtypes.rst:2708 #: ../Doc/library/stdtypes.rst:2721 msgid "Also accept an integer in the range 0 to 255 as the subsequence." -msgstr "" +msgstr "También acepta como subsecuencia un número entero entre 0 y 255." +# Hay que ver si estas referencias se han traducido #: ../Doc/library/stdtypes.rst:2580 msgid "" "Return a string decoded from the given bytes. Default encoding is " @@ -3342,6 +4532,15 @@ msgid "" "register_error`, see section :ref:`error-handlers`. For a list of possible " "encodings, see section :ref:`standard-encodings`." msgstr "" +"Retorna una cadena de caracteres decodificada a partir de la secuencia de " +"bytes. La codificación por defecto es ``'utf-8'``. El parámetro *errors* " +"puede definir diferentes estrategias de gestión de errores. El valor por " +"defecto de *errors* es ``'strict'``, que hace que cualquier error de la " +"decodificación eleva una excepción de tipo :exc:`UnicodeError`. Otros " +"valores posibles son``'ignore'``, ``'replace'`` y cualquier otro nombre " +"definido mediante la función :func:`codecs.register_error`, véase la " +"sección :ref:`error-handlers`. Para un listado de todos los valores de " +"codificación posibles, véase :ref:`standard-encodings`." #: ../Doc/library/stdtypes.rst:2590 msgid "" @@ -3349,10 +4548,13 @@ msgid "" "`bytes-like object` directly, without needing to make a temporary bytes or " "bytearray object." msgstr "" +"Pasando el parámetro *encoding* a la clase :class:`str` permite decodificar " +"cualquier :term:`objeto tipo binario ` directamente, sin " +"necesidad de crear una objeto temporal de tipo *bytes* o *bytearray*." #: ../Doc/library/stdtypes.rst:2594 msgid "Added support for keyword arguments." -msgstr "" +msgstr "Añadido soporte para poder usar parámetros por nombre." #: ../Doc/library/stdtypes.rst:2601 msgid "" @@ -3361,10 +4563,17 @@ msgid "" "look for. With optional *start*, test beginning at that position. With " "optional *end*, stop comparing at that position." msgstr "" +"Retorna ``True`` si los datos binarios acaban con el valor indicado por " +"*suffix*, en caso contrario retorna ``False``. El valor de *suffix* puede " +"ser también una tupla de sufijos para buscar. Con el parámetro opcional " +"*start*, la comparación empieza a partir de esa posición. Si se especifica " +"el parámetro opcional *end*, la comparación termina en esa posición." #: ../Doc/library/stdtypes.rst:2606 msgid "The suffix(es) to search for may be any :term:`bytes-like object`." msgstr "" +"El sufijo (o sufijos) a buscar puede ser cualquier :term:`objeto tipo " +"binario `." #: ../Doc/library/stdtypes.rst:2612 msgid "" @@ -3373,6 +4582,11 @@ msgid "" "arguments *start* and *end* are interpreted as in slice notation. Return " "``-1`` if *sub* is not found." msgstr "" +"Retorna el mínimo índice dentro de los datos donde se ha encontrado la " +"subsecuencia *sub*, de forma que *sub* está contenida en la rebanada " +"``s[start:end]``. Los parámetros opcionales *start* y *end* se interpretan " +"como en las operaciones de rebanadas. retorna ``-1`` si no se puede " +"encontrar *sub*." #: ../Doc/library/stdtypes.rst:2622 msgid "" @@ -3380,12 +4594,17 @@ msgid "" "position of *sub*. To check if *sub* is a substring or not, use the :" "keyword:`in` operator::" msgstr "" +"El método :meth:`~bytes.find` se debe usar solo si se necesita saber la " +"posición de *sub*. Si solo se necesita comprobar si *sub* es una parte de " +"*s*, es mejor usar el operador :keyword:`in`::" #: ../Doc/library/stdtypes.rst:2636 msgid "" "Like :meth:`~bytes.find`, but raise :exc:`ValueError` when the subsequence " "is not found." msgstr "" +"Como :meth:`~bytes.find`, pero eleva una excepción de tipo :exc:`ValueError` " +"si no se encuentra la subsecuencia a buscar." #: ../Doc/library/stdtypes.rst:2649 msgid "" @@ -3396,6 +4615,12 @@ msgid "" "elements is the contents of the bytes or bytearray object providing this " "method." msgstr "" +"Retorna un objeto de tipo *bytes* o *bytearray* que es la concatenación de " +"las secuencias binarias en *iterable*. Si alguno de los objetos de la " +"secuencia no es un :term:`objeto tipo binario ` se eleva " +"la excepción :exc:`TypeError`, incluso si son cadenas de caracteres " +"(objetos :class:`str`). El separador entre los distintos elementos es el " +"contenido del objeto *bytes* o *bytearray* usando para invocar el método." #: ../Doc/library/stdtypes.rst:2660 msgid "" @@ -3404,6 +4629,10 @@ msgid "" "same position in *to*; *from* and *to* must both be :term:`bytes-like " "objects ` and have the same length." msgstr "" +"Este método estático retorna una tabla de traducción apta para ser usada por " +"el método :meth:`bytes.translate`, que mapea cada carácter en *from* en la " +"misma posición en *to*; tanto *from* como *to* debe ser :term:`objetos tipo " +"binario ` y deben tener la misma longitud." #: ../Doc/library/stdtypes.rst:2671 msgid "" @@ -3413,10 +4642,18 @@ msgid "" "found, return a 3-tuple containing a copy of the original sequence, followed " "by two empty bytes or bytearray objects." msgstr "" +"Retorna la secuencia en la primera ocurrencia de *sep*, y retorna una tupla " +"de tres elementos que contiene la parte antes del separador, el separador en " +"sí o una copia de tipo *bytearray* y la parte después del separador. Si no " +"se encuentra el separador, retorna una tupla de tres elementos, con la " +"primera posición ocupada por la secuencia original, y las dos posiciones " +"siguientes rellenas con objetos *bytes* o *bytearray* vacíos." #: ../Doc/library/stdtypes.rst:2678 ../Doc/library/stdtypes.rst:2735 msgid "The separator to search for may be any :term:`bytes-like object`." msgstr "" +"El separador a buscar puede ser cualquier :term:`objeto tipo binario `." #: ../Doc/library/stdtypes.rst:2684 msgid "" @@ -3424,13 +4661,19 @@ msgid "" "replaced by *new*. If the optional argument *count* is given, only the " "first *count* occurrences are replaced." msgstr "" +"Retorna una copia de la secuencia con todas las ocurrencias de *old* " +"sustituidas por *new*. Si se utiliza el parámetro *count*, solo se cambian " +"las primeras *count* ocurrencias." #: ../Doc/library/stdtypes.rst:2688 msgid "" "The subsequence to search for and its replacement may be any :term:`bytes-" "like object`." msgstr "" +"La subsecuencia a buscar y su reemplazo puede ser cualquier :term:`objeto " +"tipo binario `." +# La traduccion de in place #: ../Doc/library/stdtypes.rst:2693 ../Doc/library/stdtypes.rst:2786 #: ../Doc/library/stdtypes.rst:2800 ../Doc/library/stdtypes.rst:2824 #: ../Doc/library/stdtypes.rst:2838 ../Doc/library/stdtypes.rst:2873 @@ -3443,6 +4686,9 @@ msgid "" "The bytearray version of this method does *not* operate in place - it always " "produces a new object, even if no changes were made." msgstr "" +"La versión *bytearray* de este método *no* modifica los valores internamente " +"(no opera *in place*): siempre produce un nuevo objeto, aun si no se hubiera " +"realizado ningún cambio." #: ../Doc/library/stdtypes.rst:2700 msgid "" @@ -3451,12 +4697,18 @@ msgid "" "arguments *start* and *end* are interpreted as in slice notation. Return " "``-1`` on failure." msgstr "" +"Retorna el mayor índice dentro de la secuencia *s* donde se puede encontrar " +"*sub*, estando *sub* incluida en ``s[start:end]``. Los parámetros opcionales " +"*start* y *end* se interpretan igual que en las operaciones de rebanado. " +"Retorna ``-1`` si no se encuentra *sub*." #: ../Doc/library/stdtypes.rst:2715 msgid "" "Like :meth:`~bytes.rfind` but raises :exc:`ValueError` when the subsequence " "*sub* is not found." msgstr "" +"Como el método :meth:`~bytes.rfind`, pero eleva la excepción :exc:" +"`ValueError` si no se encuentra *sub*." #: ../Doc/library/stdtypes.rst:2728 msgid "" @@ -3466,6 +4718,12 @@ msgid "" "found, return a 3-tuple containing two empty bytes or bytearray objects, " "followed by a copy of the original sequence." msgstr "" +"Divide la secuencia en la primera ocurrencia de *sep*, y retorna una tupla " +"de tres elementos que contiene la parte antes del separador, el separador en " +"sí o una copia de tipo *bytearray* y la parte después del separador. Si no " +"se encuentra el separador, retorna una tupla de tres elementos, con las dos " +"primeras posiciones rellenas con objetos *bytes* o *bytearray* vacíos, y la " +"tercera posición ocupada por la secuencia original." #: ../Doc/library/stdtypes.rst:2741 msgid "" @@ -3474,10 +4732,17 @@ msgid "" "look for. With optional *start*, test beginning at that position. With " "optional *end*, stop comparing at that position." msgstr "" +"Retorna ``True`` si los datos binarios empiezan con el valor indicado por " +"*prefix*, en caso contrario retorna ``False``. El valor de *prefix* puede " +"ser también una tupla de prefijos para buscar. Con el parámetro opcional " +"*start*, la comparación empieza a partir de esa posición. Si se especifica " +"el parámetro opcional *end*, la comparación termina en esa posición." #: ../Doc/library/stdtypes.rst:2746 msgid "The prefix(es) to search for may be any :term:`bytes-like object`." msgstr "" +"El prefijo (o prefijos) a buscar puede ser cualquier :term:`objeto tipo " +"binario `." #: ../Doc/library/stdtypes.rst:2752 msgid "" @@ -3486,21 +4751,30 @@ msgid "" "been mapped through the given translation table, which must be a bytes " "object of length 256." msgstr "" +"Retorna una copia del objeto *bytes* o *bytearray* donde todas las " +"ocurrencias de bytes especificados en el parámetro *delete* han sido " +"borrados, y el resto han sido mapeados a través de la tabla de traducción " +"indicada, que debe ser un objeto de tipo *bytes* con una longitud de 256 " +"elementos." #: ../Doc/library/stdtypes.rst:2757 msgid "" "You can use the :func:`bytes.maketrans` method to create a translation table." msgstr "" +"Puedes usar el método :func:`bytes.maketrans` para crear la tabla de " +"traducción." #: ../Doc/library/stdtypes.rst:2760 msgid "" "Set the *table* argument to ``None`` for translations that only delete " "characters::" msgstr "" +"Se puede ajustar el parámetro *table* a ``None`` para conseguir una " +"traducción que solo borra caracteres::" #: ../Doc/library/stdtypes.rst:2766 msgid "*delete* is now supported as a keyword argument." -msgstr "" +msgstr "El parámetro *delete* se puede ahora especificar por nombre." #: ../Doc/library/stdtypes.rst:2770 msgid "" @@ -3510,6 +4784,12 @@ msgid "" "all of the bytearray methods in this section do *not* operate in place, and " "instead produce new objects." msgstr "" +"Los siguientes métodos de los objetos *bytes* y *bytearray* presentan un " +"comportamiento por defecto que asume el uso de formatos binarios compatibles " +"con ASCII, pero aun así pueden ser usados con datos binarios arbitrarios " +"usando los parámetros apropiados. Nótese que todos los métodos de " +"*bytearray* en esta sección nunca modifican los datos internamente, sino que " +"siempre retornan objetos nuevos." #: ../Doc/library/stdtypes.rst:2779 msgid "" @@ -3518,6 +4798,11 @@ msgid "" "For :class:`bytes` objects, the original sequence is returned if *width* is " "less than or equal to ``len(s)``." msgstr "" +"Retorna una copia del objeto centrado en una secuencia de longitud *width*. " +"El relleno se realiza usando el valor definido en el parámetro *fillbyte* " +"(Por defecto, el carácter espacio en ASCII). Para los objetos de tipo :class:" +"`bytes`, se retorna la secuencia original intacta si *width* es menor o " +"igual que ``len(s)``." #: ../Doc/library/stdtypes.rst:2793 msgid "" @@ -3526,6 +4811,11 @@ msgid "" "For :class:`bytes` objects, the original sequence is returned if *width* is " "less than or equal to ``len(s)``." msgstr "" +"Retorna una copia del objeto justificado por la izquierda en una secuencia " +"de longitud *width*. El relleno se realiza usando el valor definido en el " +"parámetro *fillbyte* (Por defecto, el carácter espacio en ASCII). Para los " +"objetos de tipo :class:`bytes`, se retorna la secuencia original intacta si " +"*width* es menor o igual que ``len(s)``." #: ../Doc/library/stdtypes.rst:2807 msgid "" @@ -3536,6 +4826,13 @@ msgid "" "removing ASCII whitespace. The *chars* argument is not a prefix; rather, " "all combinations of its values are stripped::" msgstr "" +"Retorna una copia de la secuencia con los caracteres iniciales especificados " +"eliminados. El parámetro *chars* es una secuencia binaria que especifica el " +"conjunto bytes a ser eliminados; el nombre hace referencia a que este método " +"se usa normalmente con secuencias de caracteres ASCII. Si no se indica o si " +"se especifica ``None``, el comportamiento por defecto será eliminar los " +"caracteres de espacio ASCII. No debe entenderse el valor de *chars* como un " +"prefijo, sino que se elimina cualquier combinación de sus caracteres::" #: ../Doc/library/stdtypes.rst:2819 ../Doc/library/stdtypes.rst:2868 #: ../Doc/library/stdtypes.rst:2938 @@ -3543,6 +4840,8 @@ msgid "" "The binary sequence of byte values to remove may be any :term:`bytes-like " "object`." msgstr "" +"La secuencia binaria de bytes a eliminar deber ser un :term:`objeto tipo " +"binario `." #: ../Doc/library/stdtypes.rst:2831 msgid "" @@ -3551,6 +4850,11 @@ msgid "" "For :class:`bytes` objects, the original sequence is returned if *width* is " "less than or equal to ``len(s)``." msgstr "" +"Retorna una copia del objeto justificado por la derecha en una secuencia de " +"longitud *width*. El relleno se realiza usando el valor definido en el " +"parámetro *fillbyte* (Por defecto, el carácter espacio en ASCII). Para los " +"objetos de tipo :class:`bytes`, se retorna la secuencia original intacta si " +"*width* es menor o igual que ``len(s)``." #: ../Doc/library/stdtypes.rst:2845 msgid "" @@ -3561,6 +4865,14 @@ msgid "" "splitting from the right, :meth:`rsplit` behaves like :meth:`split` which is " "described in detail below." msgstr "" +"Divide una secuencia binaria en subsecuencias del mismo tipo, usando como " +"separador el valor de *sep*. Si se utiliza el parámetro *maxsplit*, se " +"realizan como máximo *maxsplit* divisiones, retornando los que están más a " +"la derecha. Si no se especifica *sep* o se pasa con valor ``None``, se usa " +"como separador el carácter espacio en ASCII. Si no contamos la diferencia de " +"empezar las divisiones desde la derecha, el comportamiento de este método :" +"meth:`rsplit` es equivalente al de :meth:`split`, que se describe con " +"detalle más adelante." #: ../Doc/library/stdtypes.rst:2856 msgid "" @@ -3571,6 +4883,13 @@ msgid "" "removing ASCII whitespace. The *chars* argument is not a suffix; rather, " "all combinations of its values are stripped::" msgstr "" +"Retorna una copia de la cadena, eliminado determinados bytes si se " +"encuentren al final. El parámetro *chars* es una secuencia binaria que " +"especifica el conjunto de bytes a eliminar; el nombre hace referencia a que " +"este método se usa normalmente con secuencias de caracteres ASCII. Si se " +"omite o si se especifica ``None``, se eliminan los caracteres espacio en " +"ASCII. No debe entenderse el valor de *chars* como un prefijo, sino que se " +"elimina cualquier combinación de sus caracteres::" #: ../Doc/library/stdtypes.rst:2880 msgid "" @@ -3580,6 +4899,11 @@ msgid "" "elements). If *maxsplit* is not specified or is ``-1``, then there is no " "limit on the number of splits (all possible splits are made)." msgstr "" +"Divide una secuencia binaria en subsecuencias del mismo tipo, usando como " +"separador el valor de *sep*. Si se utiliza el parámetro *maxsplit* y es un " +"número positivo, se realizan como máximo *maxsplit* divisiones (Resultando " +"en una secuencia de como mucho ``maxsplit+1`` elementos). Si no se " +"especifica *sep* o se pasa ``'1``, no hay límite al número de divisiones." #: ../Doc/library/stdtypes.rst:2886 msgid "" @@ -3591,6 +4915,14 @@ msgid "" "separator returns ``[b'']`` or ``[bytearray(b'')]`` depending on the type of " "object being split. The *sep* argument may be any :term:`bytes-like object`." msgstr "" +"Si se especifica *sep*, las repeticiones de caracteres delimitadores no se " +"agrupan juntos, sino que se considera que están delimitando cadenas vacías " +"(Por ejemplo, ``b'1,,2'.split(b',')`` retorna ``[b'1', b'', b'2']``). El " +"parámetro *sep* puede contener más de un carácter (Por ejemplo, ``b'1<>2<>3'." +"split(b'<>')`` retorna ``[b'1', b'2', b'3']``). Dividir una cadena vacía con " +"un separador determinado retornará ``[b'']`` o ``[bytearray(b'')]`` " +"dependiendo del tipo de objeto dividido. El parámetro *sep* puede ser " +"cualquier :term:`objeto tipo binario `." #: ../Doc/library/stdtypes.rst:2904 msgid "" @@ -3601,6 +4933,13 @@ msgid "" "an empty sequence or a sequence consisting solely of ASCII whitespace " "without a specified separator returns ``[]``." msgstr "" +"Si no se especifica *sep* o es ``None``, se usa un algoritmo de división " +"diferente: Secuencias consecutivas de caracteres de espacio en ASCII se " +"consideran como un único separador, y el resultado no contendrá cadenas " +"vacías ni al principio ni al final de la lista, aunque la cadena original " +"tuviera espacios en blanco al principio o al final. En consecuencia, dividir " +"una secuencia vacía o que solo contenga espacios en blanco usando ``None`` " +"como separador siempre retornará una lista vacía ``[]``." #: ../Doc/library/stdtypes.rst:2925 msgid "" @@ -3611,6 +4950,14 @@ msgid "" "argument defaults to removing ASCII whitespace. The *chars* argument is not " "a prefix or suffix; rather, all combinations of its values are stripped::" msgstr "" +"Retorna una copia de la secuencia con los bytes indicados eliminados, tanto " +"si están al principio como al final de la cadena. El parámetro opcional " +"*chars* es una secuencia de bytes que especifica el conjunto de caracteres a " +"eliminar; el nombre hace referencia a que este método se usa normalmente con " +"secuencias de caracteres ASCII. Si se omite o se usa ``None``, se eliminan " +"los caracteres de espacio ASCII. No debe entenderse el valor de *chars* como " +"un prefijo o sufijo, sino que se elimina cualquier combinación de sus " +"valores::" #: ../Doc/library/stdtypes.rst:2947 msgid "" @@ -3619,6 +4966,11 @@ msgid "" "data. Note that all of the bytearray methods in this section do *not* " "operate in place, and instead produce new objects." msgstr "" +"Los siguientes métodos de los objetos *bytes* y *bytearray* asumen el uso de " +"formatos binarios compatibles con ASCII, y no deben ser usados con datos " +"binarios arbitrarios. Nótese que todos los métodos de *bytearray* en esta " +"sección nunca modifican los datos internamente, sino que siempre retornan " +"objetos nuevos." #: ../Doc/library/stdtypes.rst:2955 msgid "" @@ -3626,6 +4978,9 @@ msgid "" "character, and the first byte capitalized and the rest lowercased. Non-ASCII " "byte values are passed through unchanged." msgstr "" +"Retorna una copia de la secuencia con cada byte interpretado como un " +"carácter ASCII, y el primer byte en mayúsculas y el resto en minúsculas. Los " +"valores que no sean ASCII no se ven modificados." #: ../Doc/library/stdtypes.rst:2968 msgid "" @@ -3642,6 +4997,19 @@ msgid "" "other byte value is copied unchanged and the current column is incremented " "by one regardless of how the byte value is represented when printed::" msgstr "" +"Retorna una copia de la secuencia, con todos los caracteres ASCII *tab/* " +"reemplazados por uno o más espacios ASCII, dependiendo de la columna actual " +"y del tamaño definido para el tabulador. Las posiciones de tabulación " +"ocurren cada *tabsize* caracteres (Siendo el valor por defecto de *tabsize* " +"8, lo que produce las posiciones de tabulación 0, 8, 16,...). Para expandir " +"la secuencia, la columna actual se pone a cero y se va examinando byte a " +"byte. Si se encuentra un tabulador, (``b'\\t'``), se insertan uno o más " +"espacios hasta que sea igual a la siguiente posición de tabulación (El " +"carácter tabulador en sí es descartado). Si el byte en un indicador de salto " +"de línea (``b'\\n'``) o de retorno (``b'\\r'``), se copia y el valor de " +"columna actual se vuelve a poner a cero. Cualquier otro carácter es copiado " +"sin cambios y hace que el contador de columna se incremente en 1, sin tener " +"en cuenta como se representa impreso el byte::" #: ../Doc/library/stdtypes.rst:2996 msgid "" @@ -3651,6 +5019,12 @@ msgid "" "``b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'``. ASCII decimal " "digits are those byte values in the sequence ``b'0123456789'``." msgstr "" +"Retorna ``True`` si todos los bytes de la secuencia son caracteres " +"alfabéticos ASCII o caracteres decimales ASCII y la secuencia no está vacía. " +"En cualquier otro caso retorna ``False``. Los caracteres alfabéticos ASCII " +"son los bytes incluidos en la secuencia " +"``b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'``. Los caracteres " +"decimales ASCII son los bytes incluidos en la secuencia ``b'0123456789'``." #: ../Doc/library/stdtypes.rst:3013 msgid "" @@ -3659,12 +5033,19 @@ msgid "" "characters are those byte values in the sequence " "``b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'``." msgstr "" +"Retorna ``True`` si todos los bytes de la secuencia son caracteres " +"alfabéticos ASCII y la secuencia no está vacía. En cualquier otro caso " +"Retorna ``False``. Los caracteres alfabéticos ASCII son los bytes incluidos " +"en la secuencia ``b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'``." #: ../Doc/library/stdtypes.rst:3029 msgid "" "Return ``True`` if the sequence is empty or all bytes in the sequence are " "ASCII, ``False`` otherwise. ASCII bytes are in the range 0-0x7F." msgstr "" +"Retorna ``True`` si la secuencia está vacía o si todos los bytes de la " +"secuencia son caracteres ASCII. En cualquier otro caso retorna ``False``. " +"Los caracteres ASCII son los bytes incluidos en el rango 0-0x7F." #: ../Doc/library/stdtypes.rst:3039 msgid "" @@ -3672,12 +5053,19 @@ msgid "" "the sequence is not empty, ``False`` otherwise. ASCII decimal digits are " "those byte values in the sequence ``b'0123456789'``." msgstr "" +"Retorna ``True`` si todos los bytes de la secuencia son caracteres decimales " +"ASCII y la secuencia no está vacía. En cualquier otro caso retorna " +"``False``. Los caracteres decimales ASCII son los bytes incluidos en la " +"secuencia ``b'0123456789'``." #: ../Doc/library/stdtypes.rst:3054 msgid "" "Return ``True`` if there is at least one lowercase ASCII character in the " "sequence and no uppercase ASCII characters, ``False`` otherwise." msgstr "" +"Retorna ``True`` si hay al menos un carácter ASCII en minúsculas, y no hay " +"ningún carácter ASCII en mayúsculas. En cualquier otro caso retorna " +"``False``." #: ../Doc/library/stdtypes.rst:3064 ../Doc/library/stdtypes.rst:3106 #: ../Doc/library/stdtypes.rst:3122 ../Doc/library/stdtypes.rst:3172 @@ -3687,6 +5075,9 @@ msgid "" "``b'abcdefghijklmnopqrstuvwxyz'``. Uppercase ASCII characters are those byte " "values in the sequence ``b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``." msgstr "" +"Los caracteres ASCII en minúsculas son los bytes incluidos en la secuencia " +"``b'abcdefghijklmnopqrstuvwxyz'``. los caracteres ASCII en mayúsculas son " +"los bytes en la secuencia ``b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``." #: ../Doc/library/stdtypes.rst:3072 msgid "" @@ -3695,6 +5086,11 @@ msgid "" "those byte values in the sequence ``b' \\t\\n\\r\\x0b\\f'`` (space, tab, " "newline, carriage return, vertical tab, form feed)." msgstr "" +"Retorna ``True`` si todos los bytes de la secuencia son caracteres ASCII de " +"espacio en blanco y la secuencia no está vacía. En cualquier otro caso " +"Retorna ``False``. Los caracteres de espacio en blanco ASCII son los bytes " +"incluidos en la secuencia ``b' \\t\\n\\r\\x0b\\f'`` (Espacio, tabulador, " +"nueva línea, retorno de carro, tabulador vertical y avance de página)." #: ../Doc/library/stdtypes.rst:3081 msgid "" @@ -3702,6 +5098,10 @@ msgid "" "empty, ``False`` otherwise. See :meth:`bytes.title` for more details on the " "definition of \"titlecase\"." msgstr "" +"Retorna ``True`` si la secuencia ASCII está en forma de título, y la " +"secuencio no está vacía. En cualquier otro caso retorna ``False``. Véase el " +"método :meth:`bytes.title` para más detalles en la definición de \"En forma " +"de título\"." #: ../Doc/library/stdtypes.rst:3096 msgid "" @@ -3709,12 +5109,17 @@ msgid "" "character in the sequence and no lowercase ASCII characters, ``False`` " "otherwise." msgstr "" +"Retorna ``True`` si hay al menos un carácter ASCII en mayúsculas, y no hay " +"ningún carácter ASCII en minúsculas. En cualquier otro caso retorna " +"``False``." #: ../Doc/library/stdtypes.rst:3114 msgid "" "Return a copy of the sequence with all the uppercase ASCII characters " "converted to their corresponding lowercase counterpart." msgstr "" +"Retorna una copia de la secuencia con todos los caracteres ASCII en " +"mayúsculas sustituidos por su versión correspondiente en minúsculas." #: ../Doc/library/stdtypes.rst:3139 msgid "" @@ -3723,6 +5128,10 @@ msgid "" "splitting lines. Line breaks are not included in the resulting list unless " "*keepends* is given and true." msgstr "" +"Retorna una lista de las líneas en la secuencia binaría, usando como " +"separadores los :term:`saltos de líneas universales`. Los caracteres usados " +"como separadores no se incluyen en la lista de resultados a no ser que se " +"pase el parámetro *keepends* a ``True``." #: ../Doc/library/stdtypes.rst:3151 msgid "" @@ -3730,12 +5139,19 @@ msgid "" "method returns an empty list for the empty string, and a terminal line break " "does not result in an extra line::" msgstr "" +"Al contrario que el método :meth:`~bytes.split`, cuando se especifica una " +"cadena delimitadora con el parámetro *sep*, este método retorna una lista " +"vacía para la cadena vacía, y un carácter de salto de línea al final de la " +"secuencia no resulta en una línea extra::" #: ../Doc/library/stdtypes.rst:3164 msgid "" "Return a copy of the sequence with all the lowercase ASCII characters " "converted to their corresponding uppercase counterpart and vice-versa." msgstr "" +"Retorna una copia de la secuencia con todos los caracteres ASCII en " +"minúsculas sustituidos por su versión correspondiente en mayúsculas, y " +"viceversa." #: ../Doc/library/stdtypes.rst:3176 msgid "" @@ -3744,6 +5160,10 @@ msgid "" "symmetrical in ASCII, even though that is not generally true for arbitrary " "Unicode code points." msgstr "" +"Al contrario que la función :func:`str.swapcase()`, en este caso siempre se " +"cumple que ``bin.swapcase().swapcase() == bin`` para las versiones binarias. " +"La conversión de mayúsculas a minúsculas son simétricas en ASCII, aunque " +"esto no es el caso general para códigos de punto Unicode." #: ../Doc/library/stdtypes.rst:3190 msgid "" @@ -3751,6 +5171,8 @@ msgid "" "uppercase ASCII character and the remaining characters are lowercase. " "Uncased byte values are left unmodified." msgstr "" +"Retorna una versión en forma de título de la secuencia binaria, con la " +"primera letra de cada palabra en mayúsculas y el resto en minúsculas." #: ../Doc/library/stdtypes.rst:3199 msgid "" @@ -3759,12 +5181,18 @@ msgid "" "values in the sequence ``b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``. All other byte " "values are uncased." msgstr "" +"Los caracteres ASCII en minúsculas son los bytes incluidos en la secuencia " +"``b'abcdefghijklmnopqrstuvwxyz'``. los caracteres ASCII en mayúsculas son " +"los bytes en la secuencia ``b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``. El resto de los " +"caracteres no presentan diferencias entre mayúsculas y minúsculas." #: ../Doc/library/stdtypes.rst:3233 msgid "" "Return a copy of the sequence with all the lowercase ASCII characters " "converted to their corresponding uppercase counterpart." msgstr "" +"Retorna una copia de la secuencia con todos los caracteres ASCII en " +"minúsculas sustituidos por su versión correspondiente en mayúsculas." #: ../Doc/library/stdtypes.rst:3254 msgid "" @@ -3774,10 +5202,16 @@ msgid "" "before. For :class:`bytes` objects, the original sequence is returned if " "*width* is less than or equal to ``len(seq)``." msgstr "" +"Retorna una copia de la secuencia rellenada por la izquierda con los " +"caracteres ASCII ``b'0'`` necesarios para conseguir una cadena de longitud " +"*width*. El carácter prefijo de signo (``b'+'``/``b'-'``) se gestiona " +"insertando el relleno *después* del carácter de signo en vez de antes.Para " +"objetos :class:`bytes`, se retorna la secuencia original si *width* es menor " +"o igual que ``len(s)``." #: ../Doc/library/stdtypes.rst:3276 msgid "``printf``-style Bytes Formatting" -msgstr "" +msgstr "Usando el formateo tipo ``printf`` con bytes" #: ../Doc/library/stdtypes.rst:3293 msgid "" @@ -3786,6 +5220,10 @@ msgid "" "dictionaries correctly). If the value being printed may be a tuple or " "dictionary, wrap it in a tuple." msgstr "" +"Las operaciones de formateo explicadas aquí tienen una serie de " +"peculiaridades que conducen a ciertos errores comunes (Como fallar al " +"representar tuplas y diccionarios correctamente). Si el valor a representar " +"es una tupla o un diccionario, hay que envolverlos en una tupla." #: ../Doc/library/stdtypes.rst:3298 msgid "" @@ -3796,6 +5234,13 @@ msgid "" "zero or more elements of *values*. The effect is similar to using the :c:" "func:`sprintf` in the C language." msgstr "" +"Los objetos binarios (``bytes``/``bytearray``) tienen una operación básica: " +"El operador ``%`` (módulo). Esta operación se conoce también como operador " +"de *formateo* o de *interpolación*. Dada la expresión ``formato % valores`` " +"(Donde *formato* es un objeto binario), las especificaciones de conversión " +"indicadas en la cadena con el símbolo ``%`` son reemplazadas por cero o más " +"elementos de *valores*. El efecto es similar a usar la función del lenguaje " +"C :c:func:`sprintf`." #: ../Doc/library/stdtypes.rst:3305 msgid "" @@ -3804,6 +5249,10 @@ msgid "" "items specified by the format bytes object, or a single mapping object (for " "example, a dictionary)." msgstr "" +"Si *formato* tiene un único marcador, *valores* puede ser un objeto " +"sencillo, no una tupla. [5]_ En caso contrario, *valores* debe ser una tupla " +"con exactamente el mismo número de elementos que marcadores usados en el " +"objeto binario, o un único objeto de tipo mapa (Por ejemplo, un diccionario)." #: ../Doc/library/stdtypes.rst:3339 msgid "" @@ -3812,61 +5261,73 @@ msgid "" "that dictionary inserted immediately after the ``'%'`` character. The " "mapping key selects the value to be formatted from the mapping. For example:" msgstr "" +"Cuando el operador derecho es un diccionario (o cualquier otro objeto de " +"tipo mapa), los marcadores en el objeto binario *deben* incluir un valor de " +"clave entre paréntesis, inmediatamente después del carácter ``'%'``. El " +"valor de la clave se usa para seleccionar el valor a formatear desde el " +"mapa. Por ejemplo::" #: ../Doc/library/stdtypes.rst:3413 msgid "Single byte (accepts integer or single byte objects)." -msgstr "" +msgstr "Byte único (Acepta números enteros o binarios de un único byte)" #: ../Doc/library/stdtypes.rst:3416 msgid "``'b'``" -msgstr "" +msgstr "``'b'``" #: ../Doc/library/stdtypes.rst:3416 msgid "" "Bytes (any object that follows the :ref:`buffer protocol ` or " "has :meth:`__bytes__`)." msgstr "" +"Bytes (Cualquier objeto que siga el protocolo de :ref:`objetos de tipo " +"binario ` o implemente el método :meth:`__bytes__`)." #: ../Doc/library/stdtypes.rst:3420 msgid "" "``'s'`` is an alias for ``'b'`` and should only be used for Python2/3 code " "bases." msgstr "" +"``'s'`` es un alias de ``'b'`` y solo debe ser usado para bases de código " +"Python2/3." #: ../Doc/library/stdtypes.rst:3423 msgid "" "Bytes (converts any Python object using ``repr(obj)." "encode('ascii','backslashreplace)``)." msgstr "" +"Bytes (Convierte cualquier objeto Python usando ``repr(obj)." +"encode('ascii','backslashreplace)``)." #: ../Doc/library/stdtypes.rst:3426 msgid "" "``'r'`` is an alias for ``'a'`` and should only be used for Python2/3 code " "bases." msgstr "" +"``'r'`` es un alias de ``'a'`` y solo debe ser usado para bases de código " +"Python2/3." #: ../Doc/library/stdtypes.rst:3426 msgid "\\(7)" -msgstr "" +msgstr "\\(7)" #: ../Doc/library/stdtypes.rst:3461 #, python-format msgid "``b'%s'`` is deprecated, but will not be removed during the 3.x series." -msgstr "" +msgstr "``b'%s'`` está obsoleto, pero no se retirará durante la serie 3.x." #: ../Doc/library/stdtypes.rst:3464 #, python-format msgid "``b'%r'`` is deprecated, but will not be removed during the 3.x series." -msgstr "" +msgstr "``b'%r'`` está obsoleto, pero no se retirará durante la serie 3.x." #: ../Doc/library/stdtypes.rst:3476 -#, python-format msgid ":pep:`461` - Adding % formatting to bytes and bytearray" -msgstr "" +msgstr ":pep:`461` - Añadir formateo usando % con bytes y *bytearray*" #: ../Doc/library/stdtypes.rst:3483 msgid "Memory Views" -msgstr "" +msgstr "Vistas de memoria" #: ../Doc/library/stdtypes.rst:3485 msgid "" @@ -3874,6 +5335,9 @@ msgid "" "an object that supports the :ref:`buffer protocol ` without " "copying." msgstr "" +"Los objetos de tipo :class:`memoryview` permiten al código Python acceder a " +"los datos internos de objetos que soporten el :ref:`protocolo buffer " +"` sin necesidad de hacer copias." #: ../Doc/library/stdtypes.rst:3491 msgid "" @@ -3881,6 +5345,9 @@ msgid "" "buffer protocol. Built-in objects that support the buffer protocol include :" "class:`bytes` and :class:`bytearray`." msgstr "" +"Crea un :class:`memoryview` que referencia *obj*. La variable *obj* debe " +"soportar el protocolo buffer. Los tipos de datos básicos que soportan el " +"protocolo buffer incluyen los :class:`bytes` y :class:`bytearray`." #: ../Doc/library/stdtypes.rst:3495 msgid "" @@ -3889,6 +5356,11 @@ msgid "" "such as :class:`bytes` and :class:`bytearray`, an element is a single byte, " "but other types such as :class:`array.array` may have bigger elements." msgstr "" +"La clase :class:`memoryview` usa el concepto de *elemento*, que es la unidad " +"de memoria atómica gestionada por el objeto original *obj*. Para muchos " +"tipos de datos simples como :class:`bytes` y :class:`bytearray`, un elemento " +"es un único byte, pero otros tipos, como la clase :class:`array.array` " +"pueden tener elementos más grandes." #: ../Doc/library/stdtypes.rst:3501 msgid "" @@ -3899,12 +5371,21 @@ msgid "" "The :class:`~memoryview.itemsize` attribute will give you the number of " "bytes in a single element." msgstr "" +"El resultado de ``len(view)`` es igual a la longitud de :class:`~memoryview." +"tolist`. Si ``view.ndim = 0``, la longitud es 1. Si ``view.ndim = 1``, la " +"longitud es igual al número de elementos en la vista. Para dimensiones " +"superiores, la longitud es igual a la de la representación como lista " +"anidada de la vista. El atributo :class:`~memoryview.itemsize` contiene el " +"número de bytes que ocupa un único elemento." #: ../Doc/library/stdtypes.rst:3508 msgid "" "A :class:`memoryview` supports slicing and indexing to expose its data. One-" "dimensional slicing will result in a subview::" msgstr "" +"Un objeto de tipo :class:`memoryview` soporta operaciones de rebanado y " +"acceso por índices a sus datos. Un rebanado unidimensional producirá una sub-" +"vista::" #: ../Doc/library/stdtypes.rst:3521 msgid "" @@ -3916,16 +5397,27 @@ msgid "" "*ndim* integers where *ndim* is the number of dimensions. Zero-dimensional " "memoryviews can be indexed with the empty tuple." msgstr "" +"Si :class:`~memoryview.format` es uno de los especificadores de formato " +"nativos del módulo :mod:`struct`, el indexado con un número entero o una " +"tupla de números enteros también es posible, y retorna un único *elemento* " +"con el tipo adecuado. Objetos *memoryview* unidimensionales pueden ser " +"indexados con un entero o con una tupla de enteros. Los *memoryview* con " +"múltiples dimensiones pueden ser indexados con tuplas de exactamente *ndim* " +"enteros, donde *ndim* es el número de dimensiones. Vistas *memoryviews* con " +"cero dimensiones pueden ser indexados con una tupla vacía." #: ../Doc/library/stdtypes.rst:3530 msgid "Here is an example with a non-byte format::" -msgstr "" +msgstr "Aquí hay un ejemplo con un formato que no es un byte::" #: ../Doc/library/stdtypes.rst:3542 msgid "" "If the underlying object is writable, the memoryview supports one-" "dimensional slice assignment. Resizing is not allowed::" msgstr "" +"Si el objeto usado para crear la vista es modificable, la vista *memoryview* " +"soporta asignación unidimensional mediante rebanadas. Sin embargo, no se " +"permite el cambio de tamaño::" #: ../Doc/library/stdtypes.rst:3563 msgid "" @@ -3933,26 +5425,37 @@ msgid "" "'b' or 'c' are also hashable. The hash is defined as ``hash(m) == hash(m." "tobytes())``::" msgstr "" +"Los objetos *memoryviews* de una única dimensión que contienen tipos de " +"datos *hashables* (De solo lectura) con formatos ``'B'``, ``'b'`` o ``'c'`` " +"son también *hashables*. El *hash* se define como ``hash(m) == hash(m." +"tobytes())``::" #: ../Doc/library/stdtypes.rst:3575 msgid "" "One-dimensional memoryviews can now be sliced. One-dimensional memoryviews " "with formats 'B', 'b' or 'c' are now hashable." msgstr "" +"Los objetos *memoryviews* de una única dimensión pueden ahora ser usados con " +"operaciones de rebanado. Los objetos *memoryviews* de una única dimensión " +"con formatos ``'B'``, ``'b'`` o ``'c'`` son ahora *hashables*." #: ../Doc/library/stdtypes.rst:3579 msgid "" "memoryview is now registered automatically with :class:`collections.abc." "Sequence`" msgstr "" +"los objetos *memoryview* son registrados automáticamente con la clase :class:" +"`collections.abc.Sequence`" #: ../Doc/library/stdtypes.rst:3583 msgid "memoryviews can now be indexed with tuple of integers." msgstr "" +"los objetos *memoryviews* se pueden ahora acceder usando como índices una " +"tupla de números enteros." #: ../Doc/library/stdtypes.rst:3586 msgid ":class:`memoryview` has several methods:" -msgstr "" +msgstr "La clase :class:`memoryview` tiene varios métodos:" #: ../Doc/library/stdtypes.rst:3590 msgid "" @@ -3960,12 +5463,18 @@ msgid "" "equivalent and if all corresponding values are equal when the operands' " "respective format codes are interpreted using :mod:`struct` syntax." msgstr "" +"Un objeto *memoryview* y un exportador :pep:`3118` son iguales si sus formas " +"son equivalentes y todos los valores correspondientes son iguales cuando los " +"formatos respectivos de los operandos son interpretados usando la sintaxis " +"de :mod:`struct`." #: ../Doc/library/stdtypes.rst:3594 msgid "" "For the subset of :mod:`struct` format strings currently supported by :meth:" "`tolist`, ``v`` and ``w`` are equal if ``v.tolist() == w.tolist()``::" msgstr "" +"Para el subconjunto de formatos de :mod:`struct` soportados actualmente por :" +"meth:`tolist`, ``v`` y ``w`` son iguales si ``v.tolist() == w.tolist()``::" #: ../Doc/library/stdtypes.rst:3613 msgid "" @@ -3973,24 +5482,34 @@ msgid "" "the objects will always compare as unequal (even if the format strings and " "buffer contents are identical)::" msgstr "" +"Si cualquiera de las cadenas de formato no es soportada por el módulo :mod:" +"`struct`, entonces la comparación de los objetos siempre los considerará " +"diferentes (Incluso si las cadenas de formato y el contenido del *buffer* " +"son idénticos)::" #: ../Doc/library/stdtypes.rst:3629 msgid "" "Note that, as with floating point numbers, ``v is w`` does *not* imply ``v " "== w`` for memoryview objects." msgstr "" +"Nótese que, al igual que con los números en coma flotante, ``v is w`` *no* " +"implica que ``v == w`` para objetos del tipo *memoryview*." #: ../Doc/library/stdtypes.rst:3632 msgid "" "Previous versions compared the raw memory disregarding the item format and " "the logical array structure." msgstr "" +"Versiones previas comparaban la memoria directamente, sin considerar ni el " +"formato de los elementos ni la estructura lógica de *array*." #: ../Doc/library/stdtypes.rst:3638 msgid "" "Return the data in the buffer as a bytestring. This is equivalent to " "calling the :class:`bytes` constructor on the memoryview. ::" msgstr "" +"Retorna los datos en el *buffer* en forma de cadena de bytes. Equivale a " +"llamar al constructor de la clase :class:`bytes` en el objeto *memoryview*::" #: ../Doc/library/stdtypes.rst:3647 msgid "" @@ -3999,6 +5518,10 @@ msgid "" "supports all format strings, including those that are not in :mod:`struct` " "module syntax." msgstr "" +"Para *arrays* no contiguos el resultado es igual a la representación en " +"forma de lista aplanada, con todos los elementos convertidos a bytes. El " +"método :meth:`tobytes` soporta todos los formatos de texto, incluidos " +"aquellos que no se encuentran en la sintaxis del módulo :mod:`struct`." #: ../Doc/library/stdtypes.rst:3652 msgid "" @@ -4008,12 +5531,20 @@ msgid "" "Fortran order is preserved. For non-contiguous views, the data is converted " "to C first. *order=None* is the same as *order='C'*." msgstr "" +"El valor de *order* puede ser {'C', 'F', 'A'}. Cuando *order* es 'C' o 'F', " +"los datos en el *array* original se convierten al orden de C o Fortran. Para " +"vistas contiguas, 'A' retorna una copia exacta de la memoria física. En " +"particular, el orden en memoria de Fortran se mantiene inalterado. Para " +"vista no contiguas, los datos se convierten primero a C. Definir " +"*order=None* es lo mismo que *order='C'*." #: ../Doc/library/stdtypes.rst:3661 msgid "" "Return a string object containing two hexadecimal digits for each byte in " "the buffer. ::" msgstr "" +"Retorna una cadena de caracteres que contiene dos dígitos hexadecimales por " +"cada byte en el *buffer*::" #: ../Doc/library/stdtypes.rst:3670 msgid "" @@ -4021,22 +5552,30 @@ msgid "" "*sep* and *bytes_per_sep* parameters to insert separators between bytes in " "the hex output." msgstr "" +"De forma similar a :meth:`bytes.hex`, :meth:`memoryview.hex` soporta ahora " +"los parámetros opcionales *sep* y *bytes_per_sep* para insertar separadores " +"entre los bytes en la cadena hexadecimal de salida." #: ../Doc/library/stdtypes.rst:3677 msgid "Return the data in the buffer as a list of elements. ::" -msgstr "" +msgstr "Retorna los datos en el *buffer* como una lista de elementos. ::" #: ../Doc/library/stdtypes.rst:3687 msgid "" ":meth:`tolist` now supports all single character native formats in :mod:" "`struct` module syntax as well as multi-dimensional representations." msgstr "" +"El método :meth:`tolist` soporta ahora todos los formatos nativos de un solo " +"carácter definidos en el módulo :mod:`struct`, así como las representaciones " +"de múltiples dimensiones." #: ../Doc/library/stdtypes.rst:3694 msgid "" "Return a readonly version of the memoryview object. The original memoryview " "object is unchanged. ::" msgstr "" +"Retorna una versión de solo lectura del objeto *memoryview*. El objeto " +"original permanece inalterado::" #: ../Doc/library/stdtypes.rst:3713 msgid "" @@ -4046,6 +5585,12 @@ msgid "" "release() is handy to remove these restrictions (and free any dangling " "resources) as soon as possible." msgstr "" +"Libera el buffer subyacente expuesto por el objeto *memoryview*. Muchos " +"objetos realizan operaciones especiales cuando una vista los está " +"conteniendo (Por ejemplo, un objeto :class:`bytearray` temporalmente prohíbe " +"el cambio de tamaño); la llamada a *release()* sirve para eliminar estas " +"restricciones (Así como para tratar con los recursos pendientes) lo más " +"pronto posible." #: ../Doc/library/stdtypes.rst:3719 msgid "" @@ -4053,12 +5598,18 @@ msgid "" "a :class:`ValueError` (except :meth:`release()` itself which can be called " "multiple times)::" msgstr "" +"Después de que se ha llamado a este método, cualquier operación posterior " +"sobre la vista producirá una excepción de tipo :class:`ValueError` (Excepto " +"por el propio método :meth:`release()`, que puede ser llamado las veces que " +"se quiera)::" #: ../Doc/library/stdtypes.rst:3730 msgid "" "The context management protocol can be used for a similar effect, using the " "``with`` statement::" msgstr "" +"El protocolo de gestión de contexto puede ser usado para obtener un efecto " +"similar, usando la sentencia ``with``::" #: ../Doc/library/stdtypes.rst:3746 msgid "" @@ -4068,6 +5619,11 @@ msgid "" "is not copied. Supported casts are 1D -> C-:term:`contiguous` and C-" "contiguous -> 1D." msgstr "" +"Transforma el formato o el tamaño de un objeto *memoryview*. El parámetro " +"*shape* por defecto vale ``[byte_length//new_itemsize]``, lo que significa " +"que el resultado será unidimensional. El valor de retorno es un nuevo objeto " +"de tipo *memoryview*, pero el buffer en sí no se copia. Las transformaciones " +"pueden ser 1D -> C-:term:`contiguo` y C-contiguo -> 1D." #: ../Doc/library/stdtypes.rst:3752 msgid "" @@ -4075,34 +5631,40 @@ msgid "" "mod:`struct` syntax. One of the formats must be a byte format ('B', 'b' or " "'c'). The byte length of the result must be the same as the original length." msgstr "" +"El formato de destino está restringido a un único elemento de formato nativo " +"en la sintaxis de :mod:`struct`. Uno de los formatos debe ser un formato de " +"byte (``'B'``, ``'b'`` o ``'c'``). La longitud en bytes del resultado debe " +"coincidir con la longitud original." #: ../Doc/library/stdtypes.rst:3757 msgid "Cast 1D/long to 1D/unsigned bytes::" -msgstr "" +msgstr "Transforma de ``1D/long`` a bytes ``1D/unsigned``::" #: ../Doc/library/stdtypes.rst:3780 msgid "Cast 1D/unsigned bytes to 1D/char::" -msgstr "" +msgstr "Transforma de ``1D/unsigned`` a bytes ``1D/char``::" #: ../Doc/library/stdtypes.rst:3793 msgid "Cast 1D/bytes to 3D/ints to 1D/signed char::" -msgstr "" +msgstr "Transforma de ``1D/bytes`` a ``3D/ints`` a caracteres ``1D/signed``::" #: ../Doc/library/stdtypes.rst:3819 msgid "Cast 1D/unsigned long to 2D/unsigned long::" -msgstr "" +msgstr "Transforma de *long* ``1D/unsigned`` a *long* ``2D/unsigned``::" #: ../Doc/library/stdtypes.rst:3833 msgid "The source format is no longer restricted when casting to a byte view." msgstr "" +"El formato de origen ya no está restringido cuando se transforma a una vista " +"de bytes." #: ../Doc/library/stdtypes.rst:3836 msgid "There are also several readonly attributes available:" -msgstr "" +msgstr "Hay disponibles varios atributos de solo lectura:" #: ../Doc/library/stdtypes.rst:3840 msgid "The underlying object of the memoryview::" -msgstr "" +msgstr "El objeto subyacente del *memoryview*::" #: ../Doc/library/stdtypes.rst:3851 msgid "" @@ -4110,14 +5672,17 @@ msgid "" "amount of space in bytes that the array would use in a contiguous " "representation. It is not necessarily equal to ``len(m)``::" msgstr "" +"``nbytes == product(shape) * itemsize == len(m.tobytes())``. Este es el " +"espacio, medido en bytes, que usará el *array* en una representación " +"continua. No tiene que ser necesariamente igual a ``len(m)``::" #: ../Doc/library/stdtypes.rst:3870 msgid "Multi-dimensional arrays::" -msgstr "" +msgstr "Matrices de múltiples dimensiones::" #: ../Doc/library/stdtypes.rst:3887 msgid "A bool indicating whether the memory is read only." -msgstr "" +msgstr "Un booleano que indica si la memoria es de solo lectura." #: ../Doc/library/stdtypes.rst:3891 msgid "" @@ -4126,58 +5691,75 @@ msgid "" "arbitrary format strings, but some methods (e.g. :meth:`tolist`) are " "restricted to native single element formats." msgstr "" +"Una cadena de caracteres que contiene el formato (En el estilo del módulo :" +"mod:`struct`) para cada elemento de la vista. Un objeto *memoryview* se " +"puede crear a partir de un exportador con textos de formato arbitrarios, " +"pero algunos métodos (Como, por ejemplo, :meth:`tolist`) están restringidos " +"a usar formatos de elementos nativos sencillos." #: ../Doc/library/stdtypes.rst:3896 msgid "" "format ``'B'`` is now handled according to the struct module syntax. This " "means that ``memoryview(b'abc')[0] == b'abc'[0] == 97``." msgstr "" +"el formato ``'B'`` se gestiona ahora de acuerdo a la sintaxis descrita en el " +"módulo ``struct``. Esto significa que ``memoryview(b'abc')[0] == b'abc'[0] " +"== 97``." #: ../Doc/library/stdtypes.rst:3902 msgid "The size in bytes of each element of the memoryview::" -msgstr "" +msgstr "El tamaño en bytes de cada elemento del objeto *memoryview*::" #: ../Doc/library/stdtypes.rst:3915 msgid "" "An integer indicating how many dimensions of a multi-dimensional array the " "memory represents." msgstr "" +"Un número entero que indica cuantas dimensiones de una matriz multi-" +"dimensional representa la memoria." #: ../Doc/library/stdtypes.rst:3920 msgid "" "A tuple of integers the length of :attr:`ndim` giving the shape of the " "memory as an N-dimensional array." msgstr "" +"Una tupla de números enteros, de longitud :attr:`ndim`, que indica la forma " +"de la memoria en una matriz de *N* dimensiones." #: ../Doc/library/stdtypes.rst:3923 ../Doc/library/stdtypes.rst:3931 msgid "An empty tuple instead of ``None`` when ndim = 0." -msgstr "" +msgstr "Una tupla vacía, en vez de ``None``, cuando ``ndom = 0``." #: ../Doc/library/stdtypes.rst:3928 msgid "" "A tuple of integers the length of :attr:`ndim` giving the size in bytes to " "access each element for each dimension of the array." msgstr "" +"Una tupla de números enteros, de longitud :attr:`ndim`, que indica el tamaño " +"en bytes para acceder a cada dimensión de la matriz." #: ../Doc/library/stdtypes.rst:3936 msgid "Used internally for PIL-style arrays. The value is informational only." msgstr "" +"De uso interno para las matrices estilo *PIL*. El valor es solo informativo." #: ../Doc/library/stdtypes.rst:3940 msgid "A bool indicating whether the memory is C-:term:`contiguous`." msgstr "" +"Un booleano que indica si la memoria es :term:`contiguous` al estilo *C*." #: ../Doc/library/stdtypes.rst:3946 msgid "A bool indicating whether the memory is Fortran :term:`contiguous`." msgstr "" +"Un booleano que indica si la memoria es :term:`contiguous` al estilo Fortran." #: ../Doc/library/stdtypes.rst:3952 msgid "A bool indicating whether the memory is :term:`contiguous`." -msgstr "" +msgstr "Un booleano que indica si la memoria es :term:`contiguous`." #: ../Doc/library/stdtypes.rst:3960 msgid "Set Types --- :class:`set`, :class:`frozenset`" -msgstr "" +msgstr "Conjuntos --- :class:`set`, :class:`frozenset`" #: ../Doc/library/stdtypes.rst:3964 msgid "" @@ -4188,6 +5770,13 @@ msgid "" "in :class:`dict`, :class:`list`, and :class:`tuple` classes, and the :mod:" "`collections` module.)" msgstr "" +"Un objeto de tipo :dfn:`conjunto` o :dfn:`set` es una colección no ordenada " +"de distintos objetos :term:`hashable`. Los casos de uso habituales incluyen " +"comprobar la pertenencia al conjunto de un elemento, eliminar duplicados de " +"una secuencia y realizar operaciones matemáticas como la intersección, la " +"unión, la diferencia o la diferencia simétrica (Para otros tipos de " +"contenedores véanse las clases básicas :class:`dict`, :class:`list`, y :" +"class:`tuple`, así como el módulo :mod:`collections`)." #: ../Doc/library/stdtypes.rst:3971 msgid "" @@ -4196,6 +5785,11 @@ msgid "" "position or order of insertion. Accordingly, sets do not support indexing, " "slicing, or other sequence-like behavior." msgstr "" +"Como otras colecciones, los conjuntos soportan ``x in set``, ``len(set)`` y " +"``for x in set``. Como es una colección sin orden, los conjuntos no " +"registran ni la posición ni el orden de inserción de los elementos. Por lo " +"mismo, los conjuntos no soportan indexado, ni operaciones de rebanadas, ni " +"otras capacidades propias de las secuencias." #: ../Doc/library/stdtypes.rst:3976 msgid "" @@ -4208,6 +5802,14 @@ msgid "" "it is created; it can therefore be used as a dictionary key or as an element " "of another set." msgstr "" +"En la actualidad hay dos tipos básicos de conjuntos: :class:`set` y :class:" +"`frozenset`. La clase :class:`set` es mutable, es decir, el contenido del " +"conjunto puede ser modificado con métodos como :meth:`~set.add` y :meth:" +"`~set.remove`. Como es mutable, no tiene un valor de *hash* y no pueden ser " +"usados como claves de diccionarios ni como elementos de otros conjuntos. La " +"clase :class:`frozenset` es inmutable y :term:`hashable`, es decir, que sus " +"contenidos no pueden ser modificados después de creados. Puede ser usado, " +"por tanto, como claves de diccionario o como elemento de otro conjunto." #: ../Doc/library/stdtypes.rst:3984 msgid "" @@ -4215,10 +5817,14 @@ msgid "" "list of elements within braces, for example: ``{'jack', 'sjoerd'}``, in " "addition to the :class:`set` constructor." msgstr "" +"Se pueden crear conjuntos no vacíos (*sets*, no *frozensets*) escribiendo " +"una lista de elementos separados por comas, entre llaves, por ejemplo " +"``{'jack', 'sjoerd'}``, además de con el constructor de la clase :class:" +"`set`." #: ../Doc/library/stdtypes.rst:3988 msgid "The constructors for both classes work the same:" -msgstr "" +msgstr "El constructor para ambas clases se usa de la misma forma:" #: ../Doc/library/stdtypes.rst:3993 msgid "" @@ -4227,71 +5833,96 @@ msgid "" "sets of sets, the inner sets must be :class:`frozenset` objects. If " "*iterable* is not specified, a new empty set is returned." msgstr "" +"Retorna un nuevo *set* o *frozenset*, tomando los elementos a partir de " +"*iterable*. Los elementos de un conjunto tienen que tener la propiedad de " +"ser :term:`hashable`. Para representar conjuntos anidados, o conjuntos de " +"conjuntos, los conjuntos interiores tienen que ser instancias de :class:" +"`frozenset`. Si no se especifica el parámetro *iterable*, se retorna un " +"conjunto vacío." #: ../Doc/library/stdtypes.rst:3999 msgid "" "Instances of :class:`set` and :class:`frozenset` provide the following " "operations:" msgstr "" +"Las instancias de :class:`set` y :class:`frozenset` proporcionan las " +"siguientes operaciones:" #: ../Doc/library/stdtypes.rst:4004 msgid "Return the number of elements in set *s* (cardinality of *s*)." msgstr "" +"Retorna el número de elementos en el conjunto *s* (Cardinalidad de *s*)" #: ../Doc/library/stdtypes.rst:4008 msgid "Test *x* for membership in *s*." -msgstr "" +msgstr "Comprueba que el elemento *x* está incluido en *s*." #: ../Doc/library/stdtypes.rst:4012 msgid "Test *x* for non-membership in *s*." -msgstr "" +msgstr "Comprueba que el elemento *x* no está incluido en *s*." #: ../Doc/library/stdtypes.rst:4016 msgid "" "Return ``True`` if the set has no elements in common with *other*. Sets are " "disjoint if and only if their intersection is the empty set." msgstr "" +"Retorna ``True`` si el conjunto no tienen ningún elemento en común con " +"*other*. Dos conjuntos son disjuntos si y solo si su intersección es el " +"conjunto vacío." #: ../Doc/library/stdtypes.rst:4022 msgid "Test whether every element in the set is in *other*." msgstr "" +"Comprueba si cada elemento del conjunto también se encuentra en *other*." #: ../Doc/library/stdtypes.rst:4026 msgid "" "Test whether the set is a proper subset of *other*, that is, ``set <= other " "and set != other``." msgstr "" +"Comprueba si el conjunto es un subconjunto propio de *other*, es decir, " +"``set <= other and set != other``." #: ../Doc/library/stdtypes.rst:4032 msgid "Test whether every element in *other* is in the set." -msgstr "" +msgstr "Comprueba que cada elemento de *other* está incluido en el conjunto." #: ../Doc/library/stdtypes.rst:4036 msgid "" "Test whether the set is a proper superset of *other*, that is, ``set >= " "other and set != other``." msgstr "" +"Comprueba si el conjunto es un superconjunto propio de *other*, es decir, " +"``set >= other and set != other``." #: ../Doc/library/stdtypes.rst:4042 msgid "Return a new set with elements from the set and all others." msgstr "" +"Retorna un conjunto nuevo que contiene todos los elementos del conjunto y de " +"*others*." #: ../Doc/library/stdtypes.rst:4047 msgid "Return a new set with elements common to the set and all others." msgstr "" +"Retorna un conjunto nuevo que contiene todos los elementos que están a la " +"vez en conjunto y en *others*." #: ../Doc/library/stdtypes.rst:4052 msgid "Return a new set with elements in the set that are not in the others." msgstr "" +"Retorna un conjunto nuevo que contiene todos los elementos del conjunto y " +"que no están incluidos en *others*." #: ../Doc/library/stdtypes.rst:4057 msgid "" "Return a new set with elements in either the set or *other* but not both." msgstr "" +"Retorna un conjunto nuevo que contiene elementos que están incluidos en el " +"conjunto o en *others*, pero no en los dos a la vez." #: ../Doc/library/stdtypes.rst:4061 msgid "Return a shallow copy of the set." -msgstr "" +msgstr "Retorna una copia superficial del conjunto." #: ../Doc/library/stdtypes.rst:4064 msgid "" @@ -4302,6 +5933,13 @@ msgid "" "sets. This precludes error-prone constructions like ``set('abc') & 'cbs'`` " "in favor of the more readable ``set('abc').intersection('cbs')``." msgstr "" +"Hay que señalar que las versiones de las operaciones que son métodos (no los " +"operadores) como :meth:`union`, :meth:`intersection`, :meth:`difference`, :" +"meth:`symmetric_difference`, :meth:`issubset`, y :meth:`issuperset` aceptan " +"cualquier iterable como parámetro. Por el contrario, los operadores " +"requieren que los argumentos sean siempre conjuntos. Esto evita ciertas " +"construcciones propensas a errores como ``set('abc') & 'cbs'``, favoreciendo " +"el uso formas más legibles como ``set('abc').intersection('cbs')``." #: ../Doc/library/stdtypes.rst:4071 msgid "" @@ -4312,6 +5950,13 @@ msgid "" "is not equal). A set is greater than another set if and only if the first " "set is a proper superset of the second set (is a superset, but is not equal)." msgstr "" +"Ambas clases :class:`set` y :class:`frozenset` soportan comparaciones entre " +"si. Dos conjuntos son iguales si y solo si cada elemento de cada conjunto " +"está incluido en el otro (Cada uno de ellos es subconjunto del otro). Un " +"conjunto es menor que otro si y solo si el primero es un subconjunto propio " +"del segundo (Es un subconjunto, pero no son iguales). Un conjunto es mayor " +"que otro si y solo si el primero en un superconjunto propio del segundo (Es " +"un superconjunto, pero no son iguales)." #: ../Doc/library/stdtypes.rst:4078 msgid "" @@ -4319,6 +5964,10 @@ msgid "" "based on their members. For example, ``set('abc') == frozenset('abc')`` " "returns ``True`` and so does ``set('abc') in set([frozenset('abc')])``." msgstr "" +"Las instancias de :class:`set` se comparan con las instancias de :class:" +"`frozenset` en base a sus elementos. Por ejemplo ``set('abc') == " +"frozenset('abc')`` retorna ``True`` y lo mismo hace ``set('abc') in " +"set([frozenset('abc')])``." #: ../Doc/library/stdtypes.rst:4082 msgid "" @@ -4327,16 +5976,26 @@ msgid "" "not subsets of each other, so *all* of the following return ``False``: " "``ab``." msgstr "" +"Las comparaciones de subconjunto e igualdad no son tan generales que " +"permitan una función de ordenación total. Por ejemplo, dos conjuntos " +"cualesquiera que no estén vacíos y que sean disjuntos no son iguales y " +"tampoco son subconjuntos uno del otro, así que todas estas operaciones " +"retornan ``False``: ``ab``." #: ../Doc/library/stdtypes.rst:4087 msgid "" "Since sets only define partial ordering (subset relationships), the output " "of the :meth:`list.sort` method is undefined for lists of sets." msgstr "" +"Como los conjuntos solo definen un orden parcial (Relaciones de conjuntos), " +"la salida del método :meth:`list.sort` no está definida para listas de " +"conjuntos." #: ../Doc/library/stdtypes.rst:4090 msgid "Set elements, like dictionary keys, must be :term:`hashable`." msgstr "" +"Los elementos de un conjunto, al igual que las claves de un diccionario, " +"deben ser :term:`hashable`." #: ../Doc/library/stdtypes.rst:4092 msgid "" @@ -4344,53 +6003,69 @@ msgid "" "return the type of the first operand. For example: ``frozenset('ab') | " "set('bc')`` returns an instance of :class:`frozenset`." msgstr "" +"Las operaciones binarias que mezclan instancias de :class:`set` y :class:" +"`frozenset` retornan el tipo del primer operando. Por ejemplo " +"``frozenset('ab') | set('bc')`` retornará una instancia de :class:" +"`frozenset`." #: ../Doc/library/stdtypes.rst:4096 msgid "" "The following table lists operations available for :class:`set` that do not " "apply to immutable instances of :class:`frozenset`:" msgstr "" +"La siguiente tabla muestra las operaciones disponibles para la clase :class:" +"`set` que no son aplicables a los conjuntos inmutables :class:`frozenset`:" #: ../Doc/library/stdtypes.rst:4102 msgid "Update the set, adding elements from all others." msgstr "" +"Actualiza el conjunto, añadiendo los elementos que se encuentren en *others*." #: ../Doc/library/stdtypes.rst:4107 msgid "Update the set, keeping only elements found in it and all others." msgstr "" +"Actualiza el conjunto, manteniendo solo los elementos que se encuentren en " +"si mismo y en *others*." #: ../Doc/library/stdtypes.rst:4112 msgid "Update the set, removing elements found in others." msgstr "" +"Actualiza el conjunto, eliminado los elementos que se encuentren en *others*." #: ../Doc/library/stdtypes.rst:4117 msgid "" "Update the set, keeping only elements found in either set, but not in both." msgstr "" +"Actualiza el conjunto, manteniendo solo los elementos que se encuentren en " +"el conjunto o en *others*, pero no en los dos a la vez." #: ../Doc/library/stdtypes.rst:4121 msgid "Add element *elem* to the set." -msgstr "" +msgstr "Añade al conjunto el elemento *elem*." #: ../Doc/library/stdtypes.rst:4125 msgid "" "Remove element *elem* from the set. Raises :exc:`KeyError` if *elem* is not " "contained in the set." msgstr "" +"Elimina del conjunto el elemento *elem*. Eleva la excepción :exc:`KeyError` " +"si *elem* no estaba incluido en el conjunto." #: ../Doc/library/stdtypes.rst:4130 msgid "Remove element *elem* from the set if it is present." -msgstr "" +msgstr "Elimina del conjunto el elemento *elem*, si estuviera incluido." #: ../Doc/library/stdtypes.rst:4134 msgid "" "Remove and return an arbitrary element from the set. Raises :exc:`KeyError` " "if the set is empty." msgstr "" +"Elimina y retorna un elemento cualquiera del conjunto. Eleva la excepción :" +"exc:`KeyError` si el conjunto estaba vacío." #: ../Doc/library/stdtypes.rst:4139 msgid "Remove all elements from the set." -msgstr "" +msgstr "Elimina todos los elementos del conjunto." #: ../Doc/library/stdtypes.rst:4142 msgid "" @@ -4399,6 +6074,9 @@ msgid "" "`symmetric_difference_update` methods will accept any iterable as an " "argument." msgstr "" +"Hay que señalar que los métodos (no los operadores) :meth:`update`, :meth:" +"`intersection_update`, :meth:`difference_update`, y :meth:" +"`symmetric_difference_update` aceptan cualquier iterable como parámetro." #: ../Doc/library/stdtypes.rst:4147 msgid "" @@ -4406,10 +6084,13 @@ msgid "" "meth:`discard` methods may be a set. To support searching for an equivalent " "frozenset, a temporary one is created from *elem*." msgstr "" +"Nótese que el parámetro *elem* de los métodos :meth:`__contains__`, :meth:" +"`remove` y :meth:`discard` puede ser un conjunto. Para soportar la búsqueda " +"por un *frozenset* equivalente se crea uno temporal a partir de *elem*." #: ../Doc/library/stdtypes.rst:4155 msgid "Mapping Types --- :class:`dict`" -msgstr "" +msgstr "Tipos Mapa --- :class:`dict`" #: ../Doc/library/stdtypes.rst:4165 msgid "" @@ -4419,6 +6100,11 @@ msgid "" "`list`, :class:`set`, and :class:`tuple` classes, and the :mod:`collections` " "module.)" msgstr "" +"Un objeto de tipo :term:`mapping` relaciona valores (que deben ser :term:" +"`hashable`) con objetos de cualquier tipo. Los mapas son objetos mutables. " +"En este momento solo hay un tipo estándar de mapa, los :dfn:`diccionarios` " +"(Para otros tipos contenedores, véanse las clases básicas :class:`list`, :" +"class:`set`, y :class:`tuple`, así como el módulo :mod:`collections`)." #: ../Doc/library/stdtypes.rst:4171 msgid "" @@ -4431,6 +6117,16 @@ msgid "" "entry. (Note however, that since computers store floating-point numbers as " "approximations it is usually unwise to use them as dictionary keys.)" msgstr "" +"Las claves de un diccionario pueden ser *casi* de cualquier tipo. Los " +"valores que no son :term:`hashable`, como por ejemplo valores que contengan " +"listas, diccionarios u otros tipo mutables (que son comparados por valor, no " +"por referencia) no se pueden usar como claves. Los tipos numéricos, cuando " +"se usan como claves siguen las reglas habituales de la comparación numérica: " +"Si dos números se consideran iguales (Como ``1`` y ``1.0``), ambos valores " +"pueden ser usados indistintamente para acceder al mismo valor (Pero hay que " +"tener en cuenta que los ordenadores almacenan algunos números en coma " +"flotante como aproximaciones, por lo que normalmente no es recomendable " +"usarlos como claves)." #: ../Doc/library/stdtypes.rst:4180 msgid "" @@ -4438,12 +6134,18 @@ msgid "" "value`` pairs within braces, for example: ``{'jack': 4098, 'sjoerd': 4127}`` " "or ``{4098: 'jack', 4127: 'sjoerd'}``, or by the :class:`dict` constructor." msgstr "" +"Los diccionarios se pueden crear colocando una lista separada por comas de " +"pares ``key: value`` entre llaves, por ejemplo: ``{'jack': 4098, 'sjoerd': " +"4127}`` o ``{4098: 'jack', 4127: 'sjoerd'}``, o por el constructor :class:" +"`dict`." #: ../Doc/library/stdtypes.rst:4188 msgid "" "Return a new dictionary initialized from an optional positional argument and " "a possibly empty set of keyword arguments." msgstr "" +"Retorna un diccionario creado a partir de un parámetro opcional por " +"posición, y por una serie de parámetros por nombre, también opcionales." #: ../Doc/library/stdtypes.rst:4191 msgid "" @@ -4456,6 +6158,14 @@ msgid "" "object the corresponding value. If a key occurs more than once, the last " "value for that key becomes the corresponding value in the new dictionary." msgstr "" +"Si no se especifica el parámetro por posición, se crea un diccionario vacío. " +"Si se pasa un parámetro por posición y es un objeto de tipo mapa, se crear " +"el diccionario a partir de las parejas clave-valor definidos en el mapa. Si " +"no fuera un mapa, se espera que el parámetro sea un objeto :term:`iterable`. " +"Cada elemento del iterable debe ser una dupla (Una tupla de dos elementos); " +"el primer componente de la dupla se usará como clave y el segundo como valor " +"a almacenar en el nuevo diccionario. Si una clave aparece más de una vez, el " +"último valor será el que se almacene en el diccionario resultante." #: ../Doc/library/stdtypes.rst:4201 msgid "" @@ -4464,38 +6174,53 @@ msgid "" "being added is already present, the value from the keyword argument replaces " "the value from the positional argument." msgstr "" +"Si se usan parámetros por nombre, los nombres de los parámetros y los " +"valores asociados se añaden al diccionario creado a partir del parámetro por " +"posición. Si un valor de clave ya estaba presente, el valor pasado con el " +"parámetro por nombre reemplazara el valor del parámetro por posición." #: ../Doc/library/stdtypes.rst:4206 msgid "" "To illustrate, the following examples all return a dictionary equal to " "``{\"one\": 1, \"two\": 2, \"three\": 3}``::" msgstr "" +"A modo de ejemplo, los siguientes ejemplo retornan todos el mismo " +"diccionario ``{\"one\": 1, \"two\": 2, \"three\": 3}``::" #: ../Doc/library/stdtypes.rst:4217 msgid "" "Providing keyword arguments as in the first example only works for keys that " "are valid Python identifiers. Otherwise, any valid keys can be used." msgstr "" +"Si queremos definir claves con parámetros por nombre, como en el primer " +"ejemplo, entonces los valores de clave solo puede ser cadenas de texto " +"conteniendo identificadores de Python válidos. En los otros casos, se puede " +"usar cualquier valor como clave." #: ../Doc/library/stdtypes.rst:4221 msgid "" "These are the operations that dictionaries support (and therefore, custom " "mapping types should support too):" msgstr "" +"Estas son las operaciones soportados por los diccionarios (Y que, por tanto, " +"deberían ser soportados por los tipos de mapa personalizados):" #: ../Doc/library/stdtypes.rst:4226 msgid "Return a list of all the keys used in the dictionary *d*." -msgstr "" +msgstr "Retorna una lista de todas las claves usadas en el diccionario *d*." #: ../Doc/library/stdtypes.rst:4230 msgid "Return the number of items in the dictionary *d*." -msgstr "" +msgstr "Retorna el número de elementos almacenados en el diccionario *d*." #: ../Doc/library/stdtypes.rst:4234 msgid "" "Return the item of *d* with key *key*. Raises a :exc:`KeyError` if *key* is " "not in the map." msgstr "" +"Retorna el elemento dentro de *d* almacenado bajo la clave *key*. Eleva una " +"excepción de tipo :exc:`KeyError` si la clave *key* no se encuentra en el " +"diccionario *d*." #: ../Doc/library/stdtypes.rst:4239 msgid "" @@ -4507,6 +6232,14 @@ msgid "" "exc:`KeyError` is raised. :meth:`__missing__` must be a method; it cannot be " "an instance variable::" msgstr "" +"Si una subclase de un diccionario define el método :meth:`__missing__` y " +"*key* no está presente, la operación ``d[key]`` llama a este método pasando " +"como parámetro el valor de *key*. La operación ``d[key]`` o bien retorna un " +"valor o eleva la excepción que sea retornada por la llamada a " +"``__missing__(key)``. Ninguna otra operación o método llama a :meth:" +"`__missing__`. Si el método :meth:`__missing__` no está definido, se eleva :" +"exc:`KeyError`. Si se define :meth:`__missing__`, debe ser de forma " +"obligatoria un método, no puede ser una variable de instancia::" #: ../Doc/library/stdtypes.rst:4257 msgid "" @@ -4514,43 +6247,54 @@ msgid "" "Counter`. A different ``__missing__`` method is used by :class:`collections." "defaultdict`." msgstr "" +"El ejemplo anterior muestra parte de la implementación de la clase :class:" +"`collections.Counter`. Otro ejemplo de uso del método ``__missing__`` se " +"puede encontrar en la clase :class:`collections.defaultdict`." #: ../Doc/library/stdtypes.rst:4263 msgid "Set ``d[key]`` to *value*." -msgstr "" +msgstr "Asigna el valor *value* a ``d[key]``." #: ../Doc/library/stdtypes.rst:4267 msgid "" "Remove ``d[key]`` from *d*. Raises a :exc:`KeyError` if *key* is not in the " "map." msgstr "" +"Elimina ``d[key]`` de *d*. Eleva una excepción :exc:`KeyError` si *key* no " +"está en el mapa." #: ../Doc/library/stdtypes.rst:4272 msgid "Return ``True`` if *d* has a key *key*, else ``False``." msgstr "" +"Retorna ``True`` si *d* tiene una entrada en la clave *key*, ``False`` en " +"caso contrario." #: ../Doc/library/stdtypes.rst:4276 msgid "Equivalent to ``not key in d``." -msgstr "" +msgstr "Equivale a ``not key in d``." #: ../Doc/library/stdtypes.rst:4280 msgid "" "Return an iterator over the keys of the dictionary. This is a shortcut for " "``iter(d.keys())``." msgstr "" +"Retorna un *iterador* que recorre todas las claves de un diccionario. Es una " +"forma abreviada de ``iter(d.keys())``." #: ../Doc/library/stdtypes.rst:4285 msgid "Remove all items from the dictionary." -msgstr "" +msgstr "Elimina todos los contenidos del diccionario." #: ../Doc/library/stdtypes.rst:4289 msgid "Return a shallow copy of the dictionary." -msgstr "" +msgstr "Retorna una copia superficial del diccionario." #: ../Doc/library/stdtypes.rst:4293 msgid "" "Create a new dictionary with keys from *iterable* and values set to *value*." msgstr "" +"Crea un nuevo diccionario con las claves obtenidos a partir del *iterable* y " +"con valor *value*." #: ../Doc/library/stdtypes.rst:4295 msgid "" @@ -4560,6 +6304,12 @@ msgid "" "an empty list. To get distinct values, use a :ref:`dict comprehension " "` instead." msgstr "" +"El método :meth:`fromkeys` es un método de clase que retorna un diccionario " +"nuevo. El valor de *value* por defecto es ``None``. Todos los valores harán " +"referencia a una única instancia, por lo que en general no tiene sentido que " +"*value* sea un objeto mutable, como una lista vacía. Para poder obtener " +"valores diferentes, se puede usar mejor un :ref:`diccionario por comprensión " +"`." #: ../Doc/library/stdtypes.rst:4303 msgid "" @@ -4567,18 +6317,26 @@ msgid "" "*default* is not given, it defaults to ``None``, so that this method never " "raises a :exc:`KeyError`." msgstr "" +"Retorna el elemento dentro de *d* almacenado bajo la clave *key*, si *key* " +"está en el diccionario; si no, retorna *default*. El valor de *default* por " +"defecto es ``None``, por lo que esta función nunca eleva la excepción :exc:" +"`KeyError`." #: ../Doc/library/stdtypes.rst:4309 msgid "" "Return a new view of the dictionary's items (``(key, value)`` pairs). See " "the :ref:`documentation of view objects `." msgstr "" +"Retorna una nueva vista de los contenidos del diccionario (Pares ``(key, " +"value)``). Vea :ref:`documentación de los objetos vistas `." #: ../Doc/library/stdtypes.rst:4314 msgid "" "Return a new view of the dictionary's keys. See the :ref:`documentation of " "view objects `." msgstr "" +"Retorna una nueva vista de las claves del diccionario. Véase la :ref:" +"`documentación de las vistas `." #: ../Doc/library/stdtypes.rst:4319 msgid "" @@ -4586,12 +6344,19 @@ msgid "" "*default*. If *default* is not given and *key* is not in the dictionary, a :" "exc:`KeyError` is raised." msgstr "" +"Si *key* está en el diccionario, lo elimina del diccionario y retorna su " +"valor; si no está, retorna *default*. Si no se especifica valor para " +"*default* y la clave no se encuentra en el diccionario, se eleva la " +"excepción :exc:`KeyError`." #: ../Doc/library/stdtypes.rst:4325 msgid "" "Remove and return a ``(key, value)`` pair from the dictionary. Pairs are " "returned in :abbr:`LIFO (last-in, first-out)` order." msgstr "" +"Elimina y retorna una pareja ``(key, value)`` del diccionario. Las parejas " +"se retornan en el orden :abbr:`LIFO (*last-in, first-out*: Último en entrar, " +"primero en salir)`." #: ../Doc/library/stdtypes.rst:4328 msgid "" @@ -4599,30 +6364,43 @@ msgid "" "often used in set algorithms. If the dictionary is empty, calling :meth:" "`popitem` raises a :exc:`KeyError`." msgstr "" +"El método :meth:`popitem` es útil para recorrer y a la vez vaciar un " +"diccionario, un proceso usado a menudo en algoritmos de conjuntos. Si el " +"diccionario está vacío, llamar a :meth:`popitem` eleva la excepción :exc:" +"`KeyError`." #: ../Doc/library/stdtypes.rst:4332 msgid "" "LIFO order is now guaranteed. In prior versions, :meth:`popitem` would " "return an arbitrary key/value pair." msgstr "" +"El orden *LIFO* ahora está garantizado. En versiones anteriores, el método :" +"meth:`popitem` retorna una pareja clave/valor arbitraria." #: ../Doc/library/stdtypes.rst:4338 msgid "" "Return a reverse iterator over the keys of the dictionary. This is a " "shortcut for ``reversed(d.keys())``." msgstr "" +"Retorna un *iterador* que recorre las claves en orden inverso. Es una forma " +"abreviada de ``reversed(d.keys())``." #: ../Doc/library/stdtypes.rst:4345 msgid "" "If *key* is in the dictionary, return its value. If not, insert *key* with " "a value of *default* and return *default*. *default* defaults to ``None``." msgstr "" +"Si *key* está incluida en el diccionario, retorna el valor almacenado. Si " +"no, inserta con la clave *key* el valor definido en *default* y retorna " +"*default*. El valor por defecto de *default* es ``None``." #: ../Doc/library/stdtypes.rst:4351 msgid "" "Update the dictionary with the key/value pairs from *other*, overwriting " "existing keys. Return ``None``." msgstr "" +"Actualiza el diccionario con las parejas clave/valor obtenidas de *other*, " +"escribiendo encima de las claves existentes. retorna ``None``." #: ../Doc/library/stdtypes.rst:4354 msgid "" @@ -4631,12 +6409,19 @@ msgid "" "arguments are specified, the dictionary is then updated with those key/value " "pairs: ``d.update(red=1, blue=2)``." msgstr "" +"El método :meth:`update` acepta tanto un diccionario como un iterable que " +"Retorna parejas de claves, valor (ya sea como tuplas o como otros iterables " +"de longitud 2). Si se especifican parámetros por nombre, el diccionario se " +"actualiza con esas combinaciones de clave y valor: ``d.update(red=1, " +"blue=2)``." #: ../Doc/library/stdtypes.rst:4361 msgid "" "Return a new view of the dictionary's values. See the :ref:`documentation " "of view objects `." msgstr "" +"Retorna una nueva vista de los valores del diccionario. Véase la :ref:" +"`documentación sobre objetos vistas `." #: ../Doc/library/stdtypes.rst:4364 msgid "" @@ -4644,6 +6429,9 @@ msgid "" "always return ``False``. This also applies when comparing ``dict.values()`` " "to itself::" msgstr "" +"Una comparación de igualdad entre una vista ``dict.values()`` y otra siempre " +"retornará ``False``. Esto también pasa cuando se compara ``dict.values()`` " +"consigo mismo::" #: ../Doc/library/stdtypes.rst:4372 msgid "" @@ -4651,36 +6439,50 @@ msgid "" "value)`` pairs (regardless of ordering). Order comparisons ('<', '<=', '>=', " "'>') raise :exc:`TypeError`." msgstr "" +"Los diccionarios se consideran iguales si y solo si tienen el mismo conjunto " +"de parejas ``(key, value)`` (Independiente de su orden). Los intentos de " +"comparar usando los operadores '<', '<=', '>=', '>' elevan una excepción de " +"tipo :exc:`TypeError`." #: ../Doc/library/stdtypes.rst:4376 msgid "" "Dictionaries preserve insertion order. Note that updating a key does not " "affect the order. Keys added after deletion are inserted at the end. ::" msgstr "" +"Los diccionarios mantiene de forma interna el orden de inserción. Actualizar " +"una entrada no modifica ese orden. Las claves que vuelven a ser insertadas " +"después de haber sido borradas se añaden al final.::" #: ../Doc/library/stdtypes.rst:4394 msgid "" "Dictionary order is guaranteed to be insertion order. This behavior was an " "implementation detail of CPython from 3.6." msgstr "" +"Se garantiza que el orden del diccionario es el de inserción. Este " +"comportamiento era un detalle de implementación en CPython desde la versión " +"3.6." #: ../Doc/library/stdtypes.rst:4398 msgid "Dictionaries and dictionary views are reversible. ::" msgstr "" +"Tanto los diccionarios como las vistas basadas en diccionarios son " +"reversibles::" #: ../Doc/library/stdtypes.rst:4410 msgid "Dictionaries are now reversible." -msgstr "" +msgstr "Los diccionarios son ahora reversibles." #: ../Doc/library/stdtypes.rst:4415 msgid "" ":class:`types.MappingProxyType` can be used to create a read-only view of a :" "class:`dict`." msgstr "" +"Se puede usar un objeto de tipo :class:`types.MappingProxyType` para crear " +"una vista de solo lectura de un objeto :class:`dict`." #: ../Doc/library/stdtypes.rst:4422 msgid "Dictionary view objects" -msgstr "" +msgstr "Objetos tipos vista de diccionario" #: ../Doc/library/stdtypes.rst:4424 msgid "" @@ -4689,22 +6491,30 @@ msgid "" "dictionary's entries, which means that when the dictionary changes, the view " "reflects these changes." msgstr "" +"Los objetos retornados por los métodos :meth:`dict.keys`, :meth:`dict." +"values` y :meth:`dict.items` son objetos tipo vista o *view*. Estos objetos " +"proporcionan una vista dinámica del contenido del diccionario, lo que " +"significa que si el diccionario cambia, las vistas reflejan estos cambios." #: ../Doc/library/stdtypes.rst:4429 msgid "" "Dictionary views can be iterated over to yield their respective data, and " "support membership tests:" msgstr "" +"Las vistas de un diccionario pueden ser iteradas para retornar sus datos " +"respectivos, y soportan operaciones de comprobación de pertenencia:" #: ../Doc/library/stdtypes.rst:4434 msgid "Return the number of entries in the dictionary." -msgstr "" +msgstr "Retorna el número de entradas en un diccionario." #: ../Doc/library/stdtypes.rst:4438 msgid "" "Return an iterator over the keys, values or items (represented as tuples of " "``(key, value)``) in the dictionary." msgstr "" +"Retorna un *iterador* sobre las claves, valores o elementos (representados " +"en forma de tuplas ``(key, value)``) de un diccionario." #: ../Doc/library/stdtypes.rst:4441 msgid "" @@ -4713,32 +6523,44 @@ msgid "" "values(), d.keys())``. Another way to create the same list is ``pairs = " "[(v, k) for (k, v) in d.items()]``." msgstr "" +"Las claves y los valores se iteran en orden de inserción. Esto permite la " +"creación de parejas ``(value, key)`` usando la función :func:`zip`: ``pairs " +"= zip(d.values(), d.keys())``. Otra forma de crear la misma lista es ``pairs " +"= [(v, k) for (k, v) in d.items()]``." #: ../Doc/library/stdtypes.rst:4446 msgid "" "Iterating views while adding or deleting entries in the dictionary may raise " "a :exc:`RuntimeError` or fail to iterate over all entries." msgstr "" +"Iterar sobre un diccionario a la vez que se borran o añaden entradas puede " +"elevar una excepción de tipo :exc:`RuntimeError`, o puede provocar que no se " +"iteren sobre todas las entradas." #: ../Doc/library/stdtypes.rst:4449 msgid "Dictionary order is guaranteed to be insertion order." -msgstr "" +msgstr "Se garantiza que el orden de los diccionarios es el de inserción." #: ../Doc/library/stdtypes.rst:4454 msgid "" "Return ``True`` if *x* is in the underlying dictionary's keys, values or " "items (in the latter case, *x* should be a ``(key, value)`` tuple)." msgstr "" +"Retorna ``True`` si *x* está incluido en las claves, los valores o los " +"elementos del diccionario. En el último caso, *x* debe ser una tupla ``(key, " +"value)``." #: ../Doc/library/stdtypes.rst:4459 msgid "" "Return a reverse iterator over the keys, values or items of the dictionary. " "The view will be iterated in reverse order of the insertion." msgstr "" +"Retorna un iterador inverso sobre las claves y valores del diccionario. El " +"orden de la vista sera el inverso del orden de inserción." #: ../Doc/library/stdtypes.rst:4462 msgid "Dictionary views are now reversible." -msgstr "" +msgstr "Las vistas de un diccionario no son reversibles." #: ../Doc/library/stdtypes.rst:4466 msgid "" @@ -4749,14 +6571,23 @@ msgid "" "of the operations defined for the abstract base class :class:`collections." "abc.Set` are available (for example, ``==``, ``<``, or ``^``)." msgstr "" +"Las vistas de claves son similares a conjuntos, dado que todas las claves " +"deben ser únicas y *hashables*. Si todos los valores son también " +"*hashables*, de forma que las parejas ``(key, value)`` son también únicas y " +"*hashables*, entonces la vista *items* es también similar a un conjunto (La " +"vista *values* no son consideradas similar a un conjunto porque las valores " +"almacenados en el diccionario no tiene que ser únicos). Las vistas similares " +"a conjuntos pueden usar todas las operaciones definidas en la clase " +"abstracta :class:`collections.abc.Set`, como por ejemplo ``==``, ``<``, or " +"``^``." #: ../Doc/library/stdtypes.rst:4473 msgid "An example of dictionary view usage::" -msgstr "" +msgstr "Un ejemplo de uso de una vista de diccionario::" #: ../Doc/library/stdtypes.rst:4508 msgid "Context Manager Types" -msgstr "" +msgstr "Tipos Gestores de Contexto" #: ../Doc/library/stdtypes.rst:4515 msgid "" @@ -4765,6 +6596,11 @@ msgid "" "that allow user-defined classes to define a runtime context that is entered " "before the statement body is executed and exited when the statement ends:" msgstr "" +"La expresión :keyword:`with` de Python soporta el concepto de un contexto en " +"tiempo de ejecución definido mediante un gestor de contexto. Para " +"implementar esto, se permite al usuario crear clases para definir estos " +"contextos definiendo dos métodos, uno a ejecutar ante de entrar del bloque " +"de código y otro a ejecutar justo después de salir del mismo:" #: ../Doc/library/stdtypes.rst:4523 msgid "" @@ -4773,6 +6609,10 @@ msgid "" "to the identifier in the :keyword:`!as` clause of :keyword:`with` statements " "using this context manager." msgstr "" +"Entra en el contexto en tiempo de ejecución, y retorna o bien este objeto u " +"otro relacionado con el contexto. El valor retornado por este método se " +"vincula al identificador que viene tras la palabra clave :keyword:`!as` " +"usada en la sentencia :keyword:`with` que define el contexto." #: ../Doc/library/stdtypes.rst:4528 msgid "" @@ -4780,6 +6620,10 @@ msgid "" "object`. File objects return themselves from __enter__() to allow :func:" "`open` to be used as the context expression in a :keyword:`with` statement." msgstr "" +"Un ejemplo de gestor de contexto que se retorna a si mismo es un objeto de " +"tipo :term:`file object`. Los objetos de tipo ``File`` se retornan a si " +"mismo en la llamada a ``__enter__()``, lo que permite que :func:`open` sea " +"usado como gestores de contexto en una sentencia :keyword:`with`." #: ../Doc/library/stdtypes.rst:4532 msgid "" @@ -4790,6 +6634,12 @@ msgid "" "the body of the :keyword:`with` statement without affecting code outside " "the :keyword:`!with` statement." msgstr "" +"Un ejemplo de gestor de contexto que retorna otro objeto relacionado en el " +"que define la función :func:`decimal.localcontext`. Este gestor define el " +"contexto de uso en operaciones decimales a partir de una copia del contexto " +"original, y retorna esa copia. De esta manera se puede cambiar el contexto " +"decimal dentro del cuerpo del :keyword:`with` sin afectar al código fuera " +"del mismo." #: ../Doc/library/stdtypes.rst:4542 msgid "" @@ -4799,6 +6649,13 @@ msgid "" "the exception type, value and traceback information. Otherwise, all three " "arguments are ``None``." msgstr "" +"Sale del contexto y retorna un indicador booleano que indica si se debe " +"ignorar cualquier posible excepción que hubiera ocurrido dentro del mismo. " +"Si se produce una excepción mientras se ejecutan las sentencias definidas en " +"el cuerpo de la sentencia :keyword:`with`, los parámetros de esta función " +"contienen el tipo y valor de la excepción, así como la información relativa " +"a la traza de ejecución. Si no se produce ninguna excepción, los tres " +"parámetros valen ``None``." #: ../Doc/library/stdtypes.rst:4547 msgid "" @@ -4810,6 +6667,13 @@ msgid "" "replace any exception that occurred in the body of the :keyword:`!with` " "statement." msgstr "" +"Si este método retorna un valor ``True``, la sentencia :keyword:`with` " +"ignora la excepción y el flujo del programa continua con la primera " +"sentencia inmediatamente después del cuerpo. En caso contrario la excepción " +"producida continua propagándose después de que este método termine de " +"ejecutarse. Cualquier excepción que pudieran producirse dentro de este " +"método reemplaza a la excepción que se hubiera producido en el cuerpo del :" +"keyword:`!with`." #: ../Doc/library/stdtypes.rst:4554 msgid "" @@ -4819,6 +6683,11 @@ msgid "" "context management code to easily detect whether or not an :meth:`__exit__` " "method has actually failed." msgstr "" +"La excepción pasada nunca debe volver a elevarse explícitamente; en vez de " +"eso, el método debería retornar un valor falso para indicar que el método ha " +"terminado de ejecutarse sin problemas y que no se desea suprimir la " +"excepción. Esto permite a los gestores de contexto detectar fácilmente si el " +"método :meth:`__exit__` ha podido terminar o no." #: ../Doc/library/stdtypes.rst:4560 msgid "" @@ -4828,6 +6697,12 @@ msgid "" "are not treated specially beyond their implementation of the context " "management protocol. See the :mod:`contextlib` module for some examples." msgstr "" +"Python define varios gestores de contexto para facilitar la sincronía entre " +"hilos, asegurarse del cierre de ficheros y otros objetos similares y para " +"modificar de forma simple el contexto para las expresiones aritméticas con " +"decimales.Los tipos específicos no se tratan especialmente fuera de su " +"implementación del protocolo de administración de contexto.Ver el módulo :" +"mod:`contextlib` para algunos ejemplos." #: ../Doc/library/stdtypes.rst:4566 msgid "" @@ -4838,6 +6713,12 @@ msgid "" "`__enter__` and :meth:`__exit__` methods, rather than the iterator produced " "by an undecorated generator function." msgstr "" +"Los :term:`generator` y el decoradores definidos en la clase :class:" +"`contextlib.contextmanager` permiten implementar de forma sencilla estos " +"protocolos. Si una función generadora se decora con la clase :class:" +"`contextlib.contextmanager`, retornará un gestor de contexto que incluye los " +"necesarios métodos :meth:`__enter__` y :meth:`__exit__`, en vez del " +"*iterador* que se produciría si no se decora la función." #: ../Doc/library/stdtypes.rst:4573 msgid "" @@ -4847,20 +6728,27 @@ msgid "" "Compared to the overhead of setting up the runtime context, the overhead of " "a single class dictionary lookup is negligible." msgstr "" +"Nótese que no hay una ranura específica para ninguno de estos métodos en la " +"estructura usada para los objetos Python en el nivel de la API C. Objetos " +"que quieran definir estos métodos deben implementarlos como métodos normales " +"de Python. Comparado con la complejidad de definir un contexto en tiempo de " +"ejecución, lo complejidad de una búsqueda simple en un diccionario es mínima." #: ../Doc/library/stdtypes.rst:4583 msgid "Other Built-in Types" -msgstr "" +msgstr "Otros tipos predefinidos" #: ../Doc/library/stdtypes.rst:4585 msgid "" "The interpreter supports several other kinds of objects. Most of these " "support only one or two operations." msgstr "" +"El intérprete soporta otros tipos de objetos variados. La mayoría de ellos " +"solo implementan una o dos operaciones." #: ../Doc/library/stdtypes.rst:4592 msgid "Modules" -msgstr "" +msgstr "Módulos" #: ../Doc/library/stdtypes.rst:4594 msgid "" @@ -4872,6 +6760,14 @@ msgid "" "exist, rather it requires an (external) *definition* for a module named " "*foo* somewhere.)" msgstr "" +"La única operación especial que implementan los módulos es el acceso como " +"atributos: ``m.name``, donde *m* es un módulo y *name* accede a un nombre " +"definido en la tabla de símbolos del módulo *m*. También se puede asignar " +"valores a los atributos de un módulo (Nótese que la sentencia :keyword:" +"`import` no es, estrictamente hablando, una operación del objeto de tipo " +"módulo. La sentencia ``import foo`` no requiere la existencia de un módulo " +"llamado *foo*, sino una *definición* (externa) de un módulo *foo* en alguna " +"parte)." #: ../Doc/library/stdtypes.rst:4601 msgid "" @@ -4883,6 +6779,14 @@ msgid "" "``m.__dict__ = {}``). Modifying :attr:`~object.__dict__` directly is not " "recommended." msgstr "" +"Un atributo especial de cada módulo es :attr:`~object.__dict__`. Es un " +"diccionario que contiene la tabla de símbolos del módulo. Cambiar el " +"diccionario cambiará por tanto el contenido de la tabla de símbolos, pero no " +"es posible realizar una asignación directa al atributo :attr:`~object." +"__dict__` (Se puede realizar una asignación como ``m.__dict__['a'] = 1``, " +"que define el valor de ``m.a`` como ``1``, pero no se puede hacer ``m." +"__dict__ = {}``). No se recomiendo manipular los contenidos del atributo :" +"attr:`~object.__dict__` directamente." #: ../Doc/library/stdtypes.rst:4609 msgid "" @@ -4890,24 +6794,30 @@ msgid "" "'sys' (built-in)>``. If loaded from a file, they are written as ````." msgstr "" +"Los módulos incluidos en el intérprete se escriben así: ````. Si se cargan desde un archivo, se escriben como " +"````." #: ../Doc/library/stdtypes.rst:4617 msgid "Classes and Class Instances" -msgstr "" +msgstr "Clases e instancias de clase" #: ../Doc/library/stdtypes.rst:4619 msgid "See :ref:`objects` and :ref:`class` for these." -msgstr "" +msgstr "Véase :ref:`objects` y :ref:`class` para más información." #: ../Doc/library/stdtypes.rst:4625 msgid "Functions" -msgstr "" +msgstr "Funciones" #: ../Doc/library/stdtypes.rst:4627 msgid "" "Function objects are created by function definitions. The only operation on " "a function object is to call it: ``func(argument-list)``." msgstr "" +"Los objetos de tipo función se crean mediante definiciones de función. La " +"única operación posible con un objeto de tipo función en llamarla: " +"``func(argument-list)``." #: ../Doc/library/stdtypes.rst:4630 msgid "" @@ -4916,14 +6826,18 @@ msgid "" "function), but the implementation is different, hence the different object " "types." msgstr "" +"Hay dos tipos de funciones: Las funciones básicas o predefinidas y las " +"funciones definidas por el usuario. Las dos soportan la misma operación (ser " +"llamadas), pero la implementación es diferente, de ahí que se consideren de " +"distintos tipo." #: ../Doc/library/stdtypes.rst:4634 msgid "See :ref:`function` for more information." -msgstr "" +msgstr "Véase :ref:`function` para más información." #: ../Doc/library/stdtypes.rst:4640 msgid "Methods" -msgstr "" +msgstr "Métodos" #: ../Doc/library/stdtypes.rst:4644 msgid "" @@ -4932,6 +6846,10 @@ msgid "" "class instance methods. Built-in methods are described with the types that " "support them." msgstr "" +"Los métodos son funciones que se llaman usando la notación de atributos. Hay " +"de dos tipos: métodos básicos o predefinidos (Como el método :meth:`append` " +"en las listas) y métodos de instancia de clase. Los métodos básicos o " +"predefinidos se describen junto con los tipos que los soportan." #: ../Doc/library/stdtypes.rst:4649 msgid "" @@ -4944,6 +6862,13 @@ msgid "" "n)`` is completely equivalent to calling ``m.__func__(m.__self__, arg-1, " "arg-2, ..., arg-n)``." msgstr "" +"Si se accede a un método (Una función definida dentro de un espacio de " +"nombres de una clase) a través de una instancia,se obtiene un objeto " +"especial, un :dfn:`método ligado` (También llamado :dfn:`método de " +"instancia`). Cuando se llama, se añade automáticamente el parámetro ``self`` " +"a la lista de parámetros. Los métodos ligados tienen dos atributos " +"especiales de solo lectura: ``m.__self__`` es el objeto sobre el que está " +"operando el método, y ``m.__func__`` es la función que implementa el método." #: ../Doc/library/stdtypes.rst:4658 msgid "" @@ -4954,14 +6879,21 @@ msgid "" "results in an :exc:`AttributeError` being raised. In order to set a method " "attribute, you need to explicitly set it on the underlying function object::" msgstr "" +"Al igual que los objetos de tipo función, los métodos ligados o de instancia " +"soportan asignación de atributos arbitrarios. Sin embargo, como los " +"atributos de los métodos se almacenan en la función subyacente (``meth." +"__func__``), definir cualquier atributo en métodos ligados está " +"desaconsejado. Intentar asignar un atributo a un método produce que se eleve " +"una excepción de tipo :exc:`AttributeError`. Para poder definir un atributo " +"a un método, este debe ser definido explícitamente en la función subyacente::" #: ../Doc/library/stdtypes.rst:4678 ../Doc/library/stdtypes.rst:4706 msgid "See :ref:`types` for more information." -msgstr "" +msgstr "Véase :ref:`types` para más información." #: ../Doc/library/stdtypes.rst:4686 msgid "Code Objects" -msgstr "" +msgstr "Objetos código" #: ../Doc/library/stdtypes.rst:4692 msgid "" @@ -4972,16 +6904,26 @@ msgid "" "function and can be extracted from function objects through their :attr:" "`__code__` attribute. See also the :mod:`code` module." msgstr "" +"Los objetos de tipo código son usados por la implementación del lenguaje " +"para representar código ejecutable \"pseudo-compilado\", como por ejemplo el " +"cuerpo de una función. A diferencia de los objetos de tipo función, no " +"contienen una referencia a un entorno global de ejecución. Los objetos de " +"tipo código se pueden obtener usando la función básica :func:`compile` o se " +"pueden extraer a partir de objetos de tipo función a través de su atributo :" +"attr:`__code__`. Para más detalle véase el módulo :mod:`code`." #: ../Doc/library/stdtypes.rst:4703 msgid "" "A code object can be executed or evaluated by passing it (instead of a " "source string) to the :func:`exec` or :func:`eval` built-in functions." msgstr "" +"Un objeto de tipo código puede ser evaluado o ejecutando pasándolo como " +"parámetros a las funciones básicas :func:`exec` o :func:`eval` (Que también " +"aceptan código Python en forma de cadena de texto)." #: ../Doc/library/stdtypes.rst:4712 msgid "Type Objects" -msgstr "" +msgstr "Objetos Tipo" #: ../Doc/library/stdtypes.rst:4718 msgid "" @@ -4990,14 +6932,19 @@ msgid "" "operations on types. The standard module :mod:`types` defines names for all " "standard built-in types." msgstr "" +"Los objetos de tipo Tipo (*Type*) representan a los distintos tipos de " +"datos. El tipo de un objeto particular puede ser consultado usando la " +"función básica :func:`type`. Los objetos Tipo no tienen ninguna operación " +"especial. El módulo :mod:`types` define nombres para todos los tipos básicos " +"definidos en la biblioteca estándar." #: ../Doc/library/stdtypes.rst:4723 msgid "Types are written like this: ````." -msgstr "" +msgstr "Los tipos se escriben de la siguiente forma: ````." #: ../Doc/library/stdtypes.rst:4729 msgid "The Null Object" -msgstr "" +msgstr "El objeto nulo (*Null*)" #: ../Doc/library/stdtypes.rst:4731 msgid "" @@ -5005,14 +6952,19 @@ msgid "" "It supports no special operations. There is exactly one null object, named " "``None`` (a built-in name). ``type(None)()`` produces the same singleton." msgstr "" +"Todas las funciones que no definen de forma explícita un valor de retorno " +"retornan este objeto. Los objetos nulos no soportan ninguna operación " +"especial. Solo existe un único objeto nulo, llamado ``None`` (Un nombre " +"predefinido o básico). La expresión ``type(None)()`` produce el mismo objeto " +"``None``, esto se conoce como *Singleton*." #: ../Doc/library/stdtypes.rst:4735 msgid "It is written as ``None``." -msgstr "" +msgstr "Se escribe ``None``." #: ../Doc/library/stdtypes.rst:4742 msgid "The Ellipsis Object" -msgstr "" +msgstr "El objeto puntos suspensivos (*Ellipsis*)" #: ../Doc/library/stdtypes.rst:4744 msgid "" @@ -5021,14 +6973,19 @@ msgid "" "`Ellipsis` (a built-in name). ``type(Ellipsis)()`` produces the :const:" "`Ellipsis` singleton." msgstr "" +"Este objeto es usado a menudo en operaciones de rebanadas (Véase :ref:" +"`slicings`). No soporta ninguna operación especial. Solo existe un único " +"objeto de puntos suspensivos, llamado :const:`Ellipsis` (Un nombre " +"predefinido o básico). La expresión ``type(Ellipsis)()`` produce el mismo " +"objeto :const:`Ellipsis`, esto se conoce como *Singleton*." #: ../Doc/library/stdtypes.rst:4749 msgid "It is written as ``Ellipsis`` or ``...``." -msgstr "" +msgstr "Se puede escribir como ``Ellipsis`` o ``...``." #: ../Doc/library/stdtypes.rst:4755 msgid "The NotImplemented Object" -msgstr "" +msgstr "El objeto *NotImplemented*" #: ../Doc/library/stdtypes.rst:4757 msgid "" @@ -5037,14 +6994,19 @@ msgid "" "more information. There is exactly one ``NotImplemented`` object. " "``type(NotImplemented)()`` produces the singleton instance." msgstr "" +"Este objeto se retorna en todas las operaciones binarias y comparaciones " +"cuando se intenta operar con tipos que no están soportados. Véase :ref:" +"`comparisons` para más información. Solo existe un objeto de tipo " +"``NotImplemented``. La expresión ``type(NotImplemented)()`` produce el mismo " +"objeto, esto se conoce como *Singleton*." #: ../Doc/library/stdtypes.rst:4762 msgid "It is written as ``NotImplemented``." -msgstr "" +msgstr "Se escribe ``NotImplemented``." #: ../Doc/library/stdtypes.rst:4768 msgid "Boolean Values" -msgstr "" +msgstr "Valores booleanos" #: ../Doc/library/stdtypes.rst:4770 msgid "" @@ -5056,24 +7018,35 @@ msgid "" "any value to a Boolean, if the value can be interpreted as a truth value " "(see section :ref:`truth` above)." msgstr "" +"Los valores booleanos o lógicos son los dos objetos constantes ``False`` y " +"``True``. Su usan para representar valores de verdad (Aunque otros valores " +"pueden ser considerados también como verdaderos o falsos). En contextos " +"numéricos (Por ejemplo, cuando se usan como argumentos de una operación " +"aritmética) se comportan como los números enteros 0 y 1 respectivamente. Se " +"puede usar la función incorporada :func:`bool` para convertir valores de " +"cualquiera tipo a Booleanos, si dicho valor puede ser interpretado como " +"valores verdaderos/falsos (Véase la sección :ref:`truth` anterior)." #: ../Doc/library/stdtypes.rst:4783 msgid "They are written as ``False`` and ``True``, respectively." -msgstr "" +msgstr "Se escriben ``False`` y ``True`` respectivamente." #: ../Doc/library/stdtypes.rst:4789 msgid "Internal Objects" -msgstr "" +msgstr "Objetos internos" #: ../Doc/library/stdtypes.rst:4791 msgid "" "See :ref:`types` for this information. It describes stack frame objects, " "traceback objects, and slice objects." msgstr "" +"Véase la sección :ref:`types` para saber más de estos objetos. Se describen " +"los objetos marco de pila, los objetos de traza de ejecución (*traceback*) y " +"los objetos de tipo rebanada (*slice*)." #: ../Doc/library/stdtypes.rst:4798 msgid "Special Attributes" -msgstr "" +msgstr "Atributos especiales" #: ../Doc/library/stdtypes.rst:4800 msgid "" @@ -5081,37 +7054,47 @@ msgid "" "types, where they are relevant. Some of these are not reported by the :func:" "`dir` built-in function." msgstr "" +"La implementación añade unos cuantos atributos de solo lectura a varios " +"tipos de objetos, cuando resulta relevante. Algunos de estos atributos son " +"reportados por la función incorporada :func:`dir`." #: ../Doc/library/stdtypes.rst:4807 msgid "" "A dictionary or other mapping object used to store an object's (writable) " "attributes." msgstr "" +"Un diccionario u otro tipo de mapa usado para almacenar los atributos de un " +"objeto (Si son modificables)." #: ../Doc/library/stdtypes.rst:4813 msgid "The class to which a class instance belongs." -msgstr "" +msgstr "La clase a la que pertenece una instancia." #: ../Doc/library/stdtypes.rst:4818 msgid "The tuple of base classes of a class object." -msgstr "" +msgstr "La tupla de clases base de las que deriva una clase." #: ../Doc/library/stdtypes.rst:4823 msgid "" "The name of the class, function, method, descriptor, or generator instance." msgstr "" +"El nombre de la clase, función, método, descriptor o instancia generadora." #: ../Doc/library/stdtypes.rst:4829 msgid "" "The :term:`qualified name` of the class, function, method, descriptor, or " "generator instance." msgstr "" +"El nombre calificado (:term:`qualified name`) de la clase, función, método, " +"descriptor o instancia generadora." #: ../Doc/library/stdtypes.rst:4837 msgid "" "This attribute is a tuple of classes that are considered when looking for " "base classes during method resolution." msgstr "" +"Este atributo es una tupla de las clases que serán consideradas cuando se " +"busque en las clases base para resolver un método." #: ../Doc/library/stdtypes.rst:4843 msgid "" @@ -5119,32 +7102,45 @@ msgid "" "resolution order for its instances. It is called at class instantiation, " "and its result is stored in :attr:`~class.__mro__`." msgstr "" +"Este método puede ser reescrito por una *metaclase* para personalizar el " +"orden de resolución de métodos para sus instancias. Es llamado en la " +"creación de la clase, y el resultado se almacena en el atributo :attr:" +"`~class.__mro__`." #: ../Doc/library/stdtypes.rst:4850 msgid "" "Each class keeps a list of weak references to its immediate subclasses. " "This method returns a list of all those references still alive. Example::" msgstr "" +"Cada clase mantiene una lista de referencias débiles a sus subclase " +"inmediatamente anteriores. Este método retorna una lista de todas las " +"referencias que todavía estén vivas. Por ejemplo::" #: ../Doc/library/stdtypes.rst:4859 msgid "Footnotes" -msgstr "" +msgstr "Notas al pie" #: ../Doc/library/stdtypes.rst:4860 msgid "" "Additional information on these special methods may be found in the Python " "Reference Manual (:ref:`customization`)." msgstr "" +"Se puede consultar información adicional sobre estos métodos especiales en " +"el Manual de Referencia de Python (:ref:`customization`)." #: ../Doc/library/stdtypes.rst:4863 msgid "" "As a consequence, the list ``[1, 2]`` is considered equal to ``[1.0, 2.0]``, " "and similarly for tuples." msgstr "" +"En consecuencia, la lista ``[1, 2]`` se considera igual que ``[1.0, 2.0]``, " +"y de forma similar para las tuplas." #: ../Doc/library/stdtypes.rst:4866 msgid "They must have since the parser can't tell the type of the operands." msgstr "" +"Deben haberlo hecho, ya que el analizador no puede decir el tipo de " +"operandos." #: ../Doc/library/stdtypes.rst:4868 msgid "" @@ -5152,9 +7148,14 @@ msgid "" "\" (Letter, uppercase), \"Ll\" (Letter, lowercase), or \"Lt\" (Letter, " "titlecase)." msgstr "" +"Los caracteres con versiones mayúsculas/minúsculas son aquellos cuya " +"categoría general corresponde con \"Lu\" (Letra, Mayúscula), \"Ll\" (Letra, " +"minúscula) o \"Lt\" (Letra, *titlecase*)." #: ../Doc/library/stdtypes.rst:4871 msgid "" "To format only a tuple you should therefore provide a singleton tuple whose " "only element is the tuple to be formatted." msgstr "" +"Para formatear solo una tupla se debe, por tanto, usar una tupla conteniendo " +"un único elemento, que sería la tupla a ser formateada."