Traducido hasta iteradores (20% aprox)

euribates · euribates · commit 9e28ba1a59e7 · 2020-05-13T18:55:33.000+01:00
diff --git a/library/stdtypes.po b/library/stdtypes.po
@@ -11,7 +11,7 @@ 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: 2020-05-10 20:13+0100\n"
+"PO-Revision-Date: 2020-05-13 18:54+0100\n"
 "Last-Translator: Juan Ignacio Rodríguez de León <euribates@gmail.com>\n"
 "Language-Team: python-doc-es\n"
 "MIME-Version: 1.0\n"
@@ -981,10 +981,9 @@ msgid ""
 "given, an :exc:`OverflowError` is raised. The default value for *signed* is "
 "``False``."
 msgstr ""
-"El argumento *signed* determina si se representará el signo usando "
-"complemento a dos. Si *signed* es ``False``, y se usa un valor entero "
-"negativo, se elevará la excepción :exec:`OverflowError`. El valor por "
-"defecto para *signed* es ``False``."
+"cazz Si *signed* es ``False``, y se usa un valor entero negativo, se elevará "
+"la excepción :exec:`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."
@@ -1003,37 +1002,54 @@ 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
+#, fuzzy
 msgid ""
 "Return a pair of integers whose ratio is exactly equal to the original "
 "integer and with a positive denominator. The integer ratio of integers "
 "(whole numbers) is always the integer as the numerator and ``1`` as the "
 "denominator."
 msgstr ""
+"Devuelve 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
+#, fuzzy
 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 ""
 "Return a pair of integers whose ratio is exactly equal to the original float "
 "and with a positive denominator.  Raises :exc:`OverflowError` on infinities "
 "and a :exc:`ValueError` on NaNs."
 msgstr ""
+"Devuelve una pareja de números enteros cuya proporción es exactamente igual "
+"que la del valor en coma flotante original, con un denominador positivo. Si "
+"se usa con valores infinitos o NaN (*NotANumber*) eleva una excepción de "
+"tipo :exec:`OverflowError`."
 
 #: ../Doc/library/stdtypes.rst:569
 msgid ""
 "Return ``True`` if the float instance is finite with integral value, and "
 "``False`` otherwise::"
 msgstr ""
+"Devuelve ``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 ""
@@ -1044,29 +1060,44 @@ 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 texto en "
+"hexadecimal. Como los valores en coma flotante en Python se almacenan "
+"internamente en binario, las conversiones desde o hacia cadenas de texto "
+"*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 ""
 "Return a representation of a floating-point number as a hexadecimal string.  "
 "For finite floating-point numbers, this representation will always include a "
 "leading ``0x`` and a trailing ``p`` and exponent."
 msgstr ""
+"Devuelve 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 devuelve el valor en coma flotante representado por la "
+"cadena de texto 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 texto en hexadecimal sigue este formato::"
 
 #: ../Doc/library/stdtypes.rst:608
 msgid ""
@@ -1081,6 +1112,17 @@ 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 texto 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 texto en hexadecimal en código C o Java, y las cadenas de texto "
+"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 ""
@@ -1089,16 +1131,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 texto 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`` devuelve una cadena de texto "
+"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 ""
@@ -1115,37 +1164,62 @@ 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 ""
 "If ``x = m / n`` is a nonnegative rational number and ``n`` is not divisible "
 "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)`` devuelve la inversa de ``n`` modulo ``P``."
 
 #: ../Doc/library/stdtypes.rst:667
+#, fuzzy
 msgid ""
 "If ``x = m / n`` is a nonnegative rational number and ``n`` is divisible by "
 "``P`` (but ``m`` is not) then ``n`` has no inverse modulo ``P`` and the rule "
 "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)``devuelve 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 ""
@@ -1154,6 +1228,10 @@ 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 ""
@@ -1163,17 +1241,27 @@ 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 ""
 "To clarify the above rules, here's some example Python code, equivalent to "
 "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 ""
@@ -1182,14 +1270,21 @@ 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 iteracion."
 
 #: ../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
+#, fuzzy
 msgid ""
 "Return an iterator object.  The object is required to support the iterator "
 "protocol described below.  If a container supports different types of "
@@ -1200,12 +1295,22 @@ msgid ""
 "member:`~PyTypeObject.tp_iter` slot of the type structure for Python objects "
 "in the Python/C API."
 msgstr ""
+"Devuelve 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 ""
@@ -1214,6 +1319,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 ""
+"Devuelve el propio objeto iterador. Este método es necesario para permitir "
+"tanto a los contendores como a los iterados usar la palabras clave :keyword:"
+"`for` e :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 ""
@@ -1222,6 +1332,10 @@ msgid ""
 "member:`~PyTypeObject.tp_iternext` slot of the type structure for Python "
 "objects in the Python/C API."
 msgstr ""
+"Devuelve 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 ""
