From e03e3a491a18175e9f5644d672ca9780af91eb4a Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Tue, 8 Nov 2022 23:49:24 -0600 Subject: [PATCH 01/10] =?UTF-8?q?Archivo=20hasta=20la=20l=C3=ADnea=20395?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/stdtypes.po | 69 +++++++++++++++++++++++---------------------- 1 file changed, 35 insertions(+), 34 deletions(-) mode change 100644 => 100755 library/stdtypes.po diff --git a/library/stdtypes.po b/library/stdtypes.po old mode 100644 new mode 100755 index 7cd9efbda5..8fb50a4d4f --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -11,15 +11,16 @@ msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2022-10-25 19:47+0200\n" -"PO-Revision-Date: 2022-01-05 15:30+0100\n" -"Last-Translator: Marcos Medrano \n" -"Language: es\n" +"PO-Revision-Date: 2022-11-08 23:30-0600\n" +"Last-Translator: José Luis Salgado Banda\n" "Language-Team: python-doc-es\n" -"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Language: es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" "Generated-By: Babel 2.10.3\n" +"X-Generator: Poedit 3.2\n" #: ../Doc/library/stdtypes.rst:8 msgid "Built-in Types" @@ -48,9 +49,9 @@ msgid "" "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``." +"retiran u ordenan sus miembros en su lugar, y a no ser que retornen un " +"elemento concreto, nunca retornan la propia instancia contenedora, sino " +"``None``." #: ../Doc/library/stdtypes.rst:22 msgid "" @@ -63,9 +64,10 @@ 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`." +"representarse en forma de cadena de caracteres (ya sea con la función :func:" +"`repr` o con la función ligeramente diferente :func:`str`). Esta última es " +"la usada implícitamente cuando un objeto se escribe con la función :func:" +"`print`." #: ../Doc/library/stdtypes.rst:32 msgid "Truth Value Testing" @@ -91,7 +93,7 @@ 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 " +"están listados la mayoría de los objetos integrados que se evalúan como " "falsos:" #: ../Doc/library/stdtypes.rst:55 @@ -121,11 +123,11 @@ 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)." +"Las operaciones y funciones integradas que tienen 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: Las operaciones booleanas ``or`` y ``and`` siempre " +"retornan uno de los dos operadores.)" #: ../Doc/library/stdtypes.rst:78 msgid "Boolean Operations --- :keyword:`!and`, :keyword:`!or`, :keyword:`!not`" @@ -216,8 +218,8 @@ 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." +"Este operador usa lógica cortocircuitada, por lo que solo evalúa el segundo " +"argumento si el primero es falso." #: ../Doc/library/stdtypes.rst:109 msgid "" @@ -225,7 +227,7 @@ msgid "" "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." +"argumento si el primero es verdadero." #: ../Doc/library/stdtypes.rst:113 msgid "" @@ -252,12 +254,12 @@ msgstr "" "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 " +"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 "Esta tabla resumen las operaciones de comparación:" +msgstr "Esta tabla resume las operaciones de comparación:" #: ../Doc/library/stdtypes.rst:143 ../Doc/library/stdtypes.rst:2342 #: ../Doc/library/stdtypes.rst:2365 ../Doc/library/stdtypes.rst:3554 @@ -338,25 +340,24 @@ 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 " +"Nunca se comparan iguales los 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 " +"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 lanzará una excepción " "de tipo :exc:`TypeError`." #: ../Doc/library/stdtypes.rst:180 -#, fuzzy msgid "" "Non-identical instances of a class normally compare as non-equal unless the " "class defines the :meth:`~object.__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__`." +"Las instancias de una clase que no son idénticas normalmente se comparan " +"como diferentes, a no ser que la clase defina el método :meth:`~object." +"__eq__`." #: ../Doc/library/stdtypes.rst:183 -#, fuzzy msgid "" "Instances of a class cannot be ordered with respect to other instances of " "the same class, or other types of object, unless the class defines enough of " @@ -366,11 +367,11 @@ msgid "" "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)." +"instancias de la misma clase, ni con otro tipo de objetos, a no ser que la " +"clase defina suficientes métodos :meth:`~object.__lt__`, :meth:`~object." +"__le__`, :meth:`~object.__gt__` y :meth:`~object.__ge__` (en general, :meth:" +"`~object.__lt__` y :meth:`~object.__eq__` son suficientes, si solo necesitas " +"los significados convencionales de los operadores de comparación)." #: ../Doc/library/stdtypes.rst:190 msgid "" @@ -379,8 +380,8 @@ msgid "" "exception." msgstr "" "El comportamiento de los operadores :keyword:`is` e :keyword:`is not` no se " -"puede personalizar; además, nunca lanzarán una excepción, no importa que dos " -"objetos se comparen." +"puede personalizar; además, se pueden aplicar a dos objetos cualquiera y " +"nunca lanzar una excepción." #: ../Doc/library/stdtypes.rst:198 msgid "" From e6ee37c7be0663ab90c9f25c761cb1554b193c49 Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Sun, 13 Nov 2022 20:28:10 -0600 Subject: [PATCH 02/10] =?UTF-8?q?Archivo=20hasta=20la=20l=C3=ADnea=20775?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/stdtypes.po | 59 +++++++++++++++++++++------------------------ 1 file changed, 28 insertions(+), 31 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 8fb50a4d4f..71e7c61474 100755 --- 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: 2022-10-25 19:47+0200\n" -"PO-Revision-Date: 2022-11-08 23:30-0600\n" +"PO-Revision-Date: 2022-11-13 20:22-0600\n" "Last-Translator: José Luis Salgado Banda\n" "Language-Team: python-doc-es\n" "Language: es\n" @@ -398,7 +398,6 @@ msgid "Numeric Types --- :class:`int`, :class:`float`, :class:`complex`" msgstr "Tipos numéricos --- :class:`int`, :class:`float`, :class:`complex`" #: ../Doc/library/stdtypes.rst:215 -#, fuzzy msgid "" "There are three distinct numeric types: :dfn:`integers`, :dfn:`floating " "point numbers`, and :dfn:`complex numbers`. In addition, Booleans are a " @@ -412,11 +411,11 @@ 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 " +"Hay tres tipos numéricos distintos: :dfn:`integers`, :dfn:`floating point " +"numbers` y :dfn:`complex numbers`. 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 " +"flotante se implementan normalmente usando el tipo :c:expr:`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. " @@ -424,7 +423,7 @@ msgstr "" "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)." +"el usuario.)" #: ../Doc/library/stdtypes.rst:237 msgid "" @@ -436,15 +435,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." +"Los números se crean a partir de literales numéricos, o como resultado de " +"una combinación de funciones integradas 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:262 msgid "" @@ -455,13 +454,13 @@ 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]_" +"Python soporta completamente una aritmética mixta: cuando un operador " +"binario de tipo aritmético se encuentra con que los operandos son de tipos " +"numéricos diferentes, el operando con el tipo de dato más \"estrecho\" o " +"restrictivo se convierte o amplía hasta el nivel del otro operando, donde el " +"número entero es más estrecho que el coma flotante, que es más estrecho que " +"el número complejo. Las comparaciones entre números de diferentes tipos se " +"comportan como si se compararan los valores exactos de estos. [2]_" #: ../Doc/library/stdtypes.rst:268 msgid "" @@ -477,7 +476,7 @@ msgid "" "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-" +"operaciones (para las prioridades de las operaciones, véase :ref:`operator-" "summary`):" #: ../Doc/library/stdtypes.rst:275 @@ -530,7 +529,7 @@ msgstr "``x % y``" #: ../Doc/library/stdtypes.rst:288 msgid "remainder of ``x / y``" -msgstr "resto o residuo de *x* por *y*" +msgstr "resto o residuo de ``x / y``" #: ../Doc/library/stdtypes.rst:290 msgid "``-x``" @@ -582,7 +581,7 @@ msgstr "``float(x)``" #: ../Doc/library/stdtypes.rst:299 msgid "*x* converted to floating point" -msgstr "valor de *x* convertido a número de punto flotante" +msgstr "valor de *x* convertido a número de coma flotante" #: ../Doc/library/stdtypes.rst:299 msgid "\\(4)\\(6)" @@ -714,14 +713,12 @@ msgstr "" "con la propiedad ``Nd``)." #: ../Doc/library/stdtypes.rst:356 -#, fuzzy msgid "" "See https://www.unicode.org/Public/14.0.0/ucd/extracted/DerivedNumericType." "txt for a complete list of code points with the ``Nd`` property." msgstr "" -"En https://www.unicode.org/Public/13.0.0/ucd/extracted/DerivedNumericType." -"txt se puede consultar una lista completa de los puntos de código con la " -"propiedad ``Nd``." +"Véase https://www.unicode.org/Public/14.0.0/ucd/extracted/DerivedNumericType." +"txt para una lista completa de los puntos de código con la propiedad ``Nd``." #: ../Doc/library/stdtypes.rst:360 msgid "" @@ -749,7 +746,7 @@ msgid "" "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 " +"más cercano (redondeo del banquero). Si no se especifica valor para *n*, se " "asume 0." #: ../Doc/library/stdtypes.rst:373 From 04036d2c246d1c25823f9bbb877c9b45c441e6ec Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Fri, 18 Nov 2022 17:26:42 -0600 Subject: [PATCH 03/10] =?UTF-8?q?Archivo=20hasta=20la=20l=C3=ADnea=201301?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/stdtypes.po | 128 ++++++++++++++++++++++---------------------- 1 file changed, 65 insertions(+), 63 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 71e7c61474..da31dbbe07 100755 --- 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: 2022-10-25 19:47+0200\n" -"PO-Revision-Date: 2022-11-13 20:22-0600\n" +"PO-Revision-Date: 2022-11-18 17:23-0600\n" "Last-Translator: José Luis Salgado Banda\n" "Language-Team: python-doc-es\n" "Language: es\n" @@ -843,7 +843,7 @@ msgstr "``x << n``" #: ../Doc/library/stdtypes.rst:425 msgid "*x* shifted left by *n* bits" -msgstr "El valor *x* desplazado a la izquierda *n* bits" +msgstr "valor de *x* desplazado a la izquierda *n* bits" #: ../Doc/library/stdtypes.rst:425 msgid "(1)(2)" @@ -874,7 +874,7 @@ msgid "" "Negative shift counts are illegal and cause a :exc:`ValueError` to be raised." msgstr "" "Los desplazamientos negativos son ilegales y lanzarán una excepción de tipo :" -"exc:`ValeError`." +"exc:`ValueError`." #: ../Doc/library/stdtypes.rst:438 msgid "" @@ -898,7 +898,7 @@ msgid "" "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 " +"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." @@ -935,7 +935,7 @@ msgstr "" "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 " +"int(log(abs(x), 2))``. Si ``x`` es cero, entonces ``x.bit_length()`` retorna " "``0``." #: ../Doc/library/stdtypes.rst:473 ../Doc/library/stdtypes.rst:496 @@ -954,21 +954,19 @@ msgstr "" #: ../Doc/library/stdtypes.rst:505 msgid "Return an array of bytes representing an integer." -msgstr "Retorna un array de bytes que representan el número entero." +msgstr "Retorna un arreglo de bytes que representan el número entero." #: ../Doc/library/stdtypes.rst:517 -#, fuzzy msgid "" "The integer is represented using *length* bytes, and defaults to 1. 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 lanzará la excepción :exc:`OverflowError` si no se puede " -"representar el valor con ese número de bits." +"*length* y el valor predeterminado es 1. Se lanzará la excepción :exc:" +"`OverflowError` si no se puede representar el entero con ese número de bits." #: ../Doc/library/stdtypes.rst:521 -#, fuzzy msgid "" "The *byteorder* argument determines the byte order used to represent the " "integer, and defaults to ``\"big\"``. If *byteorder* is ``\"big\"``, the " @@ -976,11 +974,10 @@ msgid "" "is ``\"little\"``, the most significant byte is at the end of the byte array." 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." +"entero y el valor predeterminado es ``\"big\"``. Si *byteorder* es " +"``\"big\"``, el byte más significativo ocupa la primera posición del arreglo " +"del byte. Si *byteorder* es ``\"little\"``, el byte más significativo estará " +"en la última posición." #: ../Doc/library/stdtypes.rst:527 msgid "" @@ -1000,14 +997,20 @@ msgid "" "byte object. However, when using the default arguments, don't try to " "convert a value greater than 255 or you'll get an :exc:`OverflowError`::" msgstr "" +"Los valores por defecto se pueden usar para convertir convenientemente un " +"número entero en un objeto de un solo byte. Sim embargo, cuando utilices los " +"argumentos predeterminados, no intentes convertir un valor mayor a 255 u " +"obtendrás una excepción :exc:`OverflowError`::" #: ../Doc/library/stdtypes.rst:552 msgid "Added default argument values for ``length`` and ``byteorder``." msgstr "" +"Se agregaron valores de argumentos predeterminados para ``length`` y " +"``byteorder``." #: ../Doc/library/stdtypes.rst:557 msgid "Return the integer represented by the given array of bytes." -msgstr "Retorna el número entero representado por el vector de bytes." +msgstr "Retorna el número entero que se representa por el arreglo de bytes." #: ../Doc/library/stdtypes.rst:570 msgid "" @@ -1018,7 +1021,6 @@ msgstr "" "like object>` o un iterable que produzca bytes." #: ../Doc/library/stdtypes.rst:573 -#, fuzzy msgid "" "The *byteorder* argument determines the byte order used to represent the " "integer, and defaults to ``\"big\"``. If *byteorder* is ``\"big\"``, the " @@ -1028,23 +1030,24 @@ msgid "" "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." +"entero y el valor predeterminado es ``\"big\"``. Si *byteorder* es " +"``\"big\"``, el byte más significativo ocupa la primera posición en el " +"arreglo del byte. Si *byteorder* es ``\"little\"``, el byte más " +"significativo estará en la última posición. Para solicitar el orden de bytes " +"nativo del sistema host, usa :data:`sys.byteorder` como valor de orden de " +"bytes." #: ../Doc/library/stdtypes.rst:580 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 " +"El argumento *signed* indica si se representará el número entero usando " "complemento a dos." #: ../Doc/library/stdtypes.rst:600 msgid "Added default argument value for ``byteorder``." -msgstr "" +msgstr "Se agregó valor de argumento predeterminado para ``byteorder``." #: ../Doc/library/stdtypes.rst:605 msgid "" @@ -1055,12 +1058,12 @@ msgid "" 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 " +"enteros, la proporción siempre es el entero en el numerador y ``1`` en el " "denominador." #: ../Doc/library/stdtypes.rst:613 msgid "Additional Methods on Float" -msgstr "Métodos adicionales de Float" +msgstr "Métodos adicionales de float" # Verificar que el glosario el termino aparezca como clase base abstracta #: ../Doc/library/stdtypes.rst:615 @@ -1068,8 +1071,8 @@ 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." +"El tipo float implementa la :term:`clase base abstracta` :class:`numbers." +"Real`. Los números float tienen además los siguientes métodos." #: ../Doc/library/stdtypes.rst:620 msgid "" @@ -1088,8 +1091,8 @@ 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::" +"Retorna ``True`` si el valor en coma flotante es finita con valor integral, " +"y ``False`` en caso contrario::" #: ../Doc/library/stdtypes.rst:635 msgid "" @@ -1103,8 +1106,8 @@ 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 " +"pueden implicar un pequeño error de redondeo. Pero con cadenas de caracteres " +"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." @@ -1115,7 +1118,7 @@ msgid "" "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 " +"caracteres 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:654 @@ -1123,9 +1126,9 @@ 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." +"Método de clase que retorna el valor en coma flotante que se representa por " +"la cadena de caracteres en hexadecimal *s*. La cadena de caracteres *s* " +"puede tener espacios en blanco al principio o al final." #: ../Doc/library/stdtypes.rst:659 msgid "" @@ -1152,7 +1155,7 @@ 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 " +"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 " @@ -1172,11 +1175,10 @@ 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``::" +"Nótese que el valor del exponente se expresa 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:689 msgid "" @@ -1191,7 +1193,6 @@ msgid "Hashing of numeric types" msgstr "Calculo del *hash* de tipos numéricos" #: ../Doc/library/stdtypes.rst:701 -#, fuzzy msgid "" "For numbers ``x`` and ``y``, possibly of different types, it's a requirement " "that ``hash(x) == hash(y)`` whenever ``x == y`` (see the :meth:`~object." @@ -1208,17 +1209,18 @@ msgid "" 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`." +"(véase la documentación sobre el método :meth:`~object.__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 " +"módulo ``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:716 msgid "" @@ -1240,7 +1242,7 @@ msgid "" 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``." +"``invmod(n, P)`` retorna la inversa de ``n`` módulo ``P``." #: ../Doc/library/stdtypes.rst:725 msgid "" @@ -1250,7 +1252,7 @@ msgid "" "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 " +"``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``." @@ -1260,7 +1262,7 @@ msgid "" "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``." +"``-hash(-x)``. Si el resultado fuera ``-1``, lo cambia por ``-2``." #: ../Doc/library/stdtypes.rst:734 msgid "" @@ -1268,8 +1270,8 @@ msgid "" "used as hash values for positive infinity or negative infinity " "(respectively)." msgstr "" -"Los valores concretos ``sys.hash_info.inf``, ``-sys.hash_info.inf`` se usan " -"como valores hash para infinito positivo o infinito negativo " +"Los valores concretos ``sys.hash_info.inf`` y ``-sys.hash_info.inf`` se usan " +"como valores *hash* para infinito positivo o infinito negativo " "(respectivamente)." #: ../Doc/library/stdtypes.rst:738 @@ -1280,12 +1282,12 @@ 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`), " +"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 " +"valor obtenido esté 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:746 @@ -1296,7 +1298,7 @@ msgid "" 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`::" +"el *hash* de un número racional de tipo :class:`float` o :class:`complex`::" #: ../Doc/library/stdtypes.rst:801 msgid "Iterator Types" From 7f4861016e18f62b3487c7c9f81878511da8623a Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Thu, 24 Nov 2022 09:55:21 -0600 Subject: [PATCH 04/10] =?UTF-8?q?Archivo=20hasta=20la=20l=C3=ADnea=202500?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/stdtypes.po | 178 ++++++++++++++++++++++---------------------- 1 file changed, 89 insertions(+), 89 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index da31dbbe07..70e59023e8 100755 --- 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: 2022-10-25 19:47+0200\n" -"PO-Revision-Date: 2022-11-18 17:23-0600\n" +"PO-Revision-Date: 2022-11-24 09:51-0600\n" "Last-Translator: José Luis Salgado Banda\n" "Language-Team: python-doc-es\n" "Language: es\n" @@ -1317,16 +1317,15 @@ msgstr "" "describirán con mayor detalle, siempre soportan la iteración." #: ../Doc/library/stdtypes.rst:814 -#, fuzzy msgid "" "One method needs to be defined for container objects to provide :term:" "`iterable` support:" msgstr "" -"Para que un objeto contenedor soporte iteración, debe definir un método:" +"Es necesario definir un método para que los objetos contenedores " +"proporcionen compatibilidad :term:`iterable`:" # Como traducimos slot? #: ../Doc/library/stdtypes.rst:821 -#, fuzzy msgid "" "Return an :term:`iterator` object. The object is required to support the " "iterator protocol described below. If a container supports different types " @@ -1337,10 +1336,10 @@ 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 " +"Retorna un objeto :term:`iterator`. 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 " +"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." @@ -1352,34 +1351,32 @@ msgid "" "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`:" +"que forma juntos el :dfn:`iterator protocol`:" #: ../Doc/library/stdtypes.rst:836 -#, fuzzy msgid "" "Return the :term:`iterator` object itself. This is required to allow both " "containers and iterators to be used with the :keyword:`for` and :keyword:" "`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." +"Retorna el propio objeto :term:`iterator`. 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:845 -#, fuzzy msgid "" "Return the next item from the :term:`iterator`. If there are no further " "items, raise the :exc:`StopIteration` exception. This method corresponds to " "the :c: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, " -"lanza 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." +"Retorna el siguiente elemento del :term:`iterator`. Si no hubiera más " +"elementos, lanza 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:850 msgid "" @@ -1405,7 +1402,7 @@ msgstr "" #: ../Doc/library/stdtypes.rst:863 msgid "Generator Types" -msgstr "Tipos Generador" +msgstr "Tipos generador" #: ../Doc/library/stdtypes.rst:865 msgid "" @@ -1419,7 +1416,7 @@ 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 " +"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 `." @@ -1476,8 +1473,8 @@ msgid "" "[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]_" +"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:923 msgid "``x in s``" @@ -1535,7 +1532,7 @@ msgstr "``s[i:j]``" #: ../Doc/library/stdtypes.rst:937 msgid "slice of *s* from *i* to *j*" -msgstr "la rebanada de *s* desde *i* hasta *j*" +msgstr "el segmento de *s* desde *i* hasta *j*" #: ../Doc/library/stdtypes.rst:937 msgid "(3)(4)" @@ -1547,7 +1544,7 @@ msgstr "``s[i:j:k]``" #: ../Doc/library/stdtypes.rst:939 msgid "slice of *s* from *i* to *j* with step *k*" -msgstr "la rebanada de *s* desde *i* hasta *j*, con paso *j*" +msgstr "el segmento de *s* desde *i* hasta *j*, con paso *j*" #: ../Doc/library/stdtypes.rst:939 msgid "(3)(5)" @@ -1613,8 +1610,8 @@ msgstr "" "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)." +"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:966 msgid "" @@ -1624,6 +1621,11 @@ msgid "" "`IndexError` or a :exc:`StopIteration` is encountered (or when the index " "drops below zero)." msgstr "" +"Los iteradores directos e inversos sobre secuencias mutables acceden a " +"valores al usar un índice. Este índice continuará avanzando (o " +"retrocediendo) incluso si la secuencia subyacente está mutada. El iterador " +"termina solo cuando se encuentra un :exc:`IndexError` o un :exc:" +"`StopIteration` (o cuando el índice cae por debajo de cero)." #: ../Doc/library/stdtypes.rst:975 msgid "" @@ -1634,7 +1636,7 @@ msgid "" 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`) " +"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:984 @@ -1644,7 +1646,7 @@ 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 " +"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::" @@ -1688,11 +1690,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." +"El segmento de *s* desde *i* hasta *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*, el segmento está vacío." #: ../Doc/library/stdtypes.rst:1024 msgid "" @@ -1706,14 +1708,14 @@ 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 " +"El segmento 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 " +"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*). " +"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``." @@ -1758,7 +1760,7 @@ msgstr "" #: ../Doc/library/stdtypes.rst:1049 msgid "if concatenating :class:`tuple` objects, extend a :class:`list` instead" msgstr "" -"en vez de concatenar tuplas (Instancias de :class:`tuple`), usar una lista (:" +"en vez de concatenar tuplas (instancias de :class:`tuple`), usar una lista (:" "class:`list`) y expandirla" #: ../Doc/library/stdtypes.rst:1051 @@ -1790,7 +1792,7 @@ msgstr "" "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." +"inicio del segmento." #: ../Doc/library/stdtypes.rst:1071 msgid "Immutable Sequence Types" @@ -1849,7 +1851,7 @@ msgid "" 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 " +"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``)." @@ -1869,7 +1871,7 @@ msgstr "``s[i:j] = t``" 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 " +"el segmento de valores de *s* que van de *i* a *j* es reemplazada por el " "contenido del iterador *t*" #: ../Doc/library/stdtypes.rst:1135 @@ -1905,7 +1907,7 @@ msgstr "``s.append(x)``" 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]``)" +"añade *x* al final de la secuencia (equivale a ``s[len(s):len(s)] = [x]``)" #: ../Doc/library/stdtypes.rst:1147 msgid "``s.clear()``" @@ -1913,7 +1915,7 @@ msgstr "``s.clear()``" #: ../Doc/library/stdtypes.rst:1147 msgid "removes all items from *s* (same as ``del s[:]``)" -msgstr "elimina todos los elementos de *s* (Equivale a ``del s[:]``)" +msgstr "elimina todos los elementos de *s* (equivale a ``del s[:]``)" #: ../Doc/library/stdtypes.rst:1150 msgid "``s.copy()``" @@ -1921,7 +1923,7 @@ msgstr "``s.copy()``" #: ../Doc/library/stdtypes.rst:1150 msgid "creates a shallow copy of *s* (same as ``s[:]``)" -msgstr "crea una copia superficial de *s* (Equivale a ``s[:]``)" +msgstr "crea una copia superficial de *s* (equivale a ``s[:]``)" #: ../Doc/library/stdtypes.rst:1153 msgid "``s.extend(t)`` or ``s += t``" @@ -1932,7 +1934,7 @@ 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 " +"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:1158 @@ -1951,7 +1953,7 @@ msgstr "``s.insert(i, x)``" 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 " +"inserta *x* en *s* en la posición indicada por el índice *i* (equivale a " "``s[i:i] = [x]``)" #: ../Doc/library/stdtypes.rst:1165 @@ -1984,7 +1986,7 @@ msgstr "invierte el orden de los elementos de *s*, a nivel interno" #: ../Doc/library/stdtypes.rst:1179 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 " +"La secuencia *t* debe tener la misma longitud que el segmento a la que " "reemplaza." #: ../Doc/library/stdtypes.rst:1182 @@ -2023,10 +2025,10 @@ msgid "" "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." +"las interfaces de clases que no soportan operaciones de segmentación (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:1200 msgid ":meth:`clear` and :meth:`!copy` methods." @@ -2056,8 +2058,8 @@ msgid "" "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)." +"colecciones de elementos homogéneos (donde el grado de similitud de los " +"mismos depende de la aplicación)." #: ../Doc/library/stdtypes.rst:1223 msgid "Lists may be constructed in several ways:" @@ -2108,7 +2110,7 @@ msgid "" "in." msgstr "" "Muchas otras operaciones también producen listas, incluyendo la función " -"básica :func:`sorted`." +"incorporada :func:`sorted`." #: ../Doc/library/stdtypes.rst:1242 msgid "" @@ -2128,9 +2130,9 @@ msgid "" "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 " +"únicamente 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)." +"falla (y la lista probablemente haya quedado modificada parcialmente)." # Ver como se ha traducido la referencia. #: ../Doc/library/stdtypes.rst:1253 @@ -2151,7 +2153,7 @@ msgid "" 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 " +"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 " @@ -2183,7 +2185,7 @@ msgid "" 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:" +"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:1274 @@ -2193,10 +2195,10 @@ 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 " +"El método :meth:`sort` es estable. Un 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 " +"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:1279 @@ -2232,10 +2234,10 @@ msgid "" "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 " +"colecciones de datos heterogéneos (como las duplas o tuplas de dos elementos " +"producidas por la función incorporada :func:`enumerate`). También son usadas " +"en aquellos casos donde se necesite una secuencia inmutable de datos " +"homogéneos (como por ejemplo permitir el almacenamiento en un objeto de " "tipo :class:`set` o :class:`dict`)." #: ../Doc/library/stdtypes.rst:1304 @@ -2260,7 +2262,7 @@ msgstr "Separando los elementos por comas: ``a, b, c`` o ``(a, b, c)``" #: ../Doc/library/stdtypes.rst:1309 msgid "Using the :func:`tuple` built-in: ``tuple()`` or ``tuple(iterable)``" msgstr "" -"Usando la función básica :func:`tuple` built-in: ``tuple()`` o " +"Usando la función incorporada :func:`tuple`: ``tuple()`` o " "``tuple(iterable)``" #: ../Doc/library/stdtypes.rst:1311 @@ -2301,7 +2303,7 @@ msgid "" "Tuples implement all of the :ref:`common ` sequence " "operations." msgstr "" -"Las tuplas implementan todas las operaciones de secuencia :ref:`common " +"Las tuplas implementan todas las operaciones de secuencia :ref:`comunes " "`." #: ../Doc/library/stdtypes.rst:1328 @@ -2328,7 +2330,6 @@ msgstr "" "número determinado de veces." #: ../Doc/library/stdtypes.rst:1347 -#, fuzzy msgid "" "The arguments to the range constructor must be integers (either built-in :" "class:`int` or any object that implements the :meth:`~object.__index__` " @@ -2337,11 +2338,11 @@ msgid "" "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 lanza una " -"excepción de tipo :exc:`ValueError`." +"(o bien objetos de tipo :class:`int` o instancias de una clase que " +"implemente el método especial :meth:`~object.__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 *step* es cero, se lanza una excepción de " +"tipo :exc:`ValueError`." #: ../Doc/library/stdtypes.rst:1353 msgid "" @@ -2395,7 +2396,7 @@ msgid "" "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 " +"common>` 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)." @@ -2404,17 +2405,17 @@ msgstr "" msgid "" "The value of the *start* parameter (or ``0`` if the parameter was not " "supplied)" -msgstr "El valor del parámetro ``start`` (``0`` si no se utiliza el parámetro)" +msgstr "El valor del parámetro *start* (``0`` si no se utiliza el parámetro)" #: ../Doc/library/stdtypes.rst:1399 msgid "The value of the *stop* parameter" -msgstr "El valor del parámetro ``stop``" +msgstr "El valor del parámetro *stop*" #: ../Doc/library/stdtypes.rst:1403 msgid "" "The value of the *step* parameter (or ``1`` if the parameter was not " "supplied)" -msgstr "El valor del parámetro ``step`` (``1`` si no se utiliza el parámetro)" +msgstr "El valor del parámetro *step* (``1`` si no se utiliza el parámetro)" #: ../Doc/library/stdtypes.rst:1406 msgid "" @@ -2427,7 +2428,7 @@ 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``, " +"represente (ya que solamente necesita almacenar los valores para ``start``, " "``stop`` y ``step``, y calcula los valores intermedios a medida que los va " "necesitando)." @@ -2439,8 +2440,8 @@ msgid "" 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`):" +"búsqueda de elementos por índice, operaciones de segmentación y soporte de " +"índices negativos (véase :ref:`typesseq`):" #: ../Doc/library/stdtypes.rst:1432 msgid "" @@ -2465,10 +2466,10 @@ 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." +"Implementa la secuencia ABC. Soporta operaciones de segmentación e índices " +"negativos. Comprueba si un entero de tipo :class:`int` está incluido en un " +"rango que se realiza en un tiempo constante, en lugar de iterar a través de " +"todos los elementos." #: ../Doc/library/stdtypes.rst:1445 msgid "" @@ -2476,7 +2477,7 @@ msgid "" "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 " +"secuencia de valores que definen (en vez de compararse en base a la " "identidad)." #: ../Doc/library/stdtypes.rst:1450 @@ -2488,15 +2489,14 @@ msgstr "" "step`." #: ../Doc/library/stdtypes.rst:1456 -#, fuzzy msgid "" "The `linspace recipe `_ shows " "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." +"En `linspace recipe `_ se " +"muestra como implementar una versión *lazy* o perezosa de rango adecuada " +"para aplicaciones de coma flotante." #: ../Doc/library/stdtypes.rst:1468 msgid "Text Sequence Type --- :class:`str`" From c2d6175d6adf317ee59864aee2134930c699a75e Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Thu, 1 Dec 2022 02:50:07 -0600 Subject: [PATCH 05/10] =?UTF-8?q?Archivo=20hasta=20la=20l=C3=ADnea=203723?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dictionaries/library_stdtypes.txt | 4 +- library/stdtypes.po | 236 +++++++++++++++--------------- 2 files changed, 121 insertions(+), 119 deletions(-) diff --git a/dictionaries/library_stdtypes.txt b/dictionaries/library_stdtypes.txt index e0170a2be1..68d7bbf1d6 100644 --- a/dictionaries/library_stdtypes.txt +++ b/dictionaries/library_stdtypes.txt @@ -5,4 +5,6 @@ superconjunto superíndices unaria Ll -Lu \ No newline at end of file +Lm +Lu +Kharosthi \ No newline at end of file diff --git a/library/stdtypes.po b/library/stdtypes.po index 70e59023e8..8b7146489d 100755 --- 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: 2022-10-25 19:47+0200\n" -"PO-Revision-Date: 2022-11-24 09:51-0600\n" +"PO-Revision-Date: 2022-12-01 02:37-0600\n" "Last-Translator: José Luis Salgado Banda\n" "Language-Team: python-doc-es\n" "Language: es\n" @@ -2511,7 +2511,7 @@ msgid "" 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 ` " +"`strings`. Las cadenas de caracteres son :ref:`secuencias ` " "inmutables de puntos de código Unicode. Las cadenas se pueden definir de " "diferentes maneras:" @@ -2520,9 +2520,8 @@ msgid "Single quotes: ``'allows embedded \"double\" quotes'``" msgstr "Comillas simples: ``'permite incluir comillas \"dobles\"'``" #: ../Doc/library/stdtypes.rst:1476 -#, fuzzy msgid "Double quotes: ``\"allows embedded 'single' quotes\"``" -msgstr "Comillas dobles: ``\"permite incluir comillas 'simples'\"``." +msgstr "Comillas dobles: ``\"permite incluir comillas 'simples'\"``" #: ../Doc/library/stdtypes.rst:1477 msgid "" @@ -2537,8 +2536,8 @@ 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 " +"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:1482 @@ -2575,9 +2574,9 @@ 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]``." +"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:1499 @@ -2612,7 +2611,6 @@ msgstr "" "pasados en los parámetros *encoding* y *errors*, como veremos." #: ../Doc/library/stdtypes.rst:1519 -#, fuzzy msgid "" "If neither *encoding* nor *errors* is given, ``str(object)`` returns :meth:" "`type(object).__str__(object) `, which is the \"informal\" " @@ -2622,11 +2620,11 @@ msgid "" "`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) `." +"`type(object).__str__(object) `, 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:1531 msgid "" @@ -2659,8 +2657,9 @@ msgid "" 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::" +"caso normal donde se retorna la representación informal de la cadena de " +"caracteres (véase también la :option:`-b` de las opciones de línea de " +"órdenes de Python). Por ejemplo::" #: ../Doc/library/stdtypes.rst:1548 msgid "" @@ -2697,7 +2696,7 @@ msgid "" "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:" +"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 " @@ -2711,7 +2710,7 @@ msgid "" 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`)." +"(incluyendo las expresiones regulares en el módulo :mod:`re`)." #: ../Doc/library/stdtypes.rst:1581 msgid "" @@ -2730,7 +2729,7 @@ msgid "" 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." +"mayúsculas, en vez de todo el carácter." #: ../Doc/library/stdtypes.rst:1591 msgid "" @@ -2751,7 +2750,7 @@ msgid "" 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\"``. " +"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\"``." @@ -2771,7 +2770,7 @@ msgid "" 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 " +"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." @@ -2782,8 +2781,8 @@ msgid "" "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." +"[*start*, *end*]. Los parámetros opcionales *start* y *end* se interpretan " +"como en una expresión de segmento." #: ../Doc/library/stdtypes.rst:1623 msgid "" @@ -2815,8 +2814,8 @@ msgid "" msgstr "" "Por defecto, el argumento *errors* no se verifica para mejor rendimiento, " "solo se usa con el primer error de codificación encontrado. Se puede " -"habilitar el :ref:`Python Development Mode `, o utilizar una :ref:" -"`debug build ` para verificar *errors*." +"habilitar el :ref:`modo de desarrollo de Python `, o utilizar una :" +"ref:`compilación de depuración ` para verificar *errors*." #: ../Doc/library/stdtypes.rst:1637 msgid "Support for keyword arguments added." @@ -2827,8 +2826,8 @@ msgid "" "The *errors* is now checked in development mode and in :ref:`debug mode " "`." msgstr "" -"El argumento *errors* ahora se verifica en modo de desarrollo y en :ref:" -"`debug mode `." +"El argumento *errors* ahora se verifica en modo de desarrollo y en una :ref:" +"`compilación de depuración `." #: ../Doc/library/stdtypes.rst:1647 msgid "" @@ -2837,11 +2836,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." +"Retorna ``True`` si la cadena termina con el *suffix* especificado 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:1655 msgid "" @@ -2861,7 +2860,7 @@ 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 " +"*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 " @@ -2880,8 +2879,8 @@ msgid "" 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." +"opcionales *start* y *end* se interpretan como notación de segmento. Retorna " +"``-1`` si no se encuentra la cadena." #: ../Doc/library/stdtypes.rst:1682 msgid "" @@ -2906,7 +2905,7 @@ msgstr "" "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 " +"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." @@ -2929,14 +2928,13 @@ msgid "" "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 " +"`complex`, :class:`decimal.Decimal` y clases derivadas) usando la ``n`` (por " +"ejemplo, ``'{:n}'.format(1234)``), la 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*." +"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:1715 msgid "" @@ -2944,7 +2942,7 @@ msgid "" "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``." +"forma temporal la variable ``LC_CTYPE`` a ``LC_NUMERIC`` en algunos casos." #: ../Doc/library/stdtypes.rst:1723 msgid "" @@ -2952,9 +2950,9 @@ 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`:" +"Similar a ``str.format(**mapping)`, pero se usa ``mapping`` de forma directa " +"y no se copia a un diccionario. Esto es útil si ``mapping`` es, por ejemplo, " +"una instancia de una subclase de :class:`dict`:" #: ../Doc/library/stdtypes.rst:1739 msgid "" @@ -2972,7 +2970,7 @@ msgid "" "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 " +"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()``." @@ -2987,11 +2985,11 @@ msgid "" "\"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 " +"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." +"\"Letter\", es decir, aquellos cuya propiedad de 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:1762 msgid "" @@ -3000,8 +2998,8 @@ msgid "" "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 " +"caracteres de la cadena son ASCII, en caso contrario, retorna ``False``. Los " +"caracteres ASCII son aquellos cuyos puntos de código Unicode que están en el " "rango U+0000-U+007F." #: ../Doc/library/stdtypes.rst:1771 @@ -3013,9 +3011,9 @@ msgid "" "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 " +"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``. " +"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." @@ -3029,19 +3027,19 @@ msgid "" "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 " +"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*``." +"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:1791 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 " +"Retorna ``True`` si la cadena de caracteres es un identificador válido de " "acuerdo a la especificación del lenguaje, véase :ref:`identifiers`." #: ../Doc/library/stdtypes.rst:1794 @@ -3050,7 +3048,7 @@ msgid "" "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:" +"cadena ``s`` es un identificador reservado, como :keyword:`def` o :keyword:" "`class`." #: ../Doc/library/stdtypes.rst:1797 @@ -3064,7 +3062,7 @@ msgid "" 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``." +"carácter de ese tipo, en caso contrario, retorna ``False``." #: ../Doc/library/stdtypes.rst:1816 msgid "" @@ -3076,9 +3074,9 @@ msgid "" "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 " +"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 " +"caracteres Unicode que tienen definida la propiedad de 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``." @@ -3094,13 +3092,13 @@ msgid "" "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 " +"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`)." +"\"*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:1837 msgid "" @@ -3108,7 +3106,7 @@ msgid "" "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``." +"y hay, al menos, un carácter, en caso contrario, retorna ``False``." #: ../Doc/library/stdtypes.rst:1840 msgid "" @@ -3117,8 +3115,8 @@ msgid "" "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 " +"Unicode (véase :mod:`unicodedata`), está clasificado en la categoría general " +"``Zs`` (\"Separador, espacio\") o la clase bidireccional es ``WS``, ``B`` o " "``S``." #: ../Doc/library/stdtypes.rst:1848 @@ -3142,7 +3140,7 @@ msgid "" 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``." +"carácter de ese tipo, en caso contrario, retorna ``False``." #: ../Doc/library/stdtypes.rst:1873 msgid "" @@ -3165,9 +3163,9 @@ msgid "" 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 " +"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." +"retorna el texto sin modificar." #: ../Doc/library/stdtypes.rst:1888 msgid "" @@ -3183,7 +3181,7 @@ msgid "" "Standard." msgstr "" "El algoritmo usado para la conversión a minúsculas está descrito en la " -"sección 3..13 del estándar Unicode." +"sección 3.13 del estándar Unicode." #: ../Doc/library/stdtypes.rst:1897 msgid "" @@ -3224,8 +3222,8 @@ msgid "" "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 " +"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:1925 @@ -3238,7 +3236,7 @@ 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." +"caracteres, los cuales se mapearán a ``None`` en la tabla resultante." #: ../Doc/library/stdtypes.rst:1933 msgid "" @@ -3248,10 +3246,10 @@ msgid "" "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 " +"tres elementos, que contiene 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." +"retorna una tupla de tres elementos, el primero contiene la cadena original " +"y los dos siguientes son cadenas vacías." #: ../Doc/library/stdtypes.rst:1941 msgid "" @@ -3268,9 +3266,9 @@ msgid "" "return ``string[:-len(suffix)]``. Otherwise, return a copy of the original " "string::" msgstr "" -"Si la cadena de caracteres termina con la cadena *suffix*, retorna " -"``string[:-len(suffix)]``. De otra manera, retorna una copia de la cadena " -"original::" +"Si la cadena de caracteres termina con la cadena *suffix* y *suffix* no está " +"vacío, retorna ``string[:-len(suffix)]``. De otra manera, retorna una copia " +"de la cadena original::" #: ../Doc/library/stdtypes.rst:1969 msgid "" @@ -3291,7 +3289,7 @@ 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*." +"segmentado. Retorna ``-1`` si no se encuentra *sub*." #: ../Doc/library/stdtypes.rst:1983 msgid "" @@ -3309,7 +3307,7 @@ msgid "" 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 " +"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:1996 @@ -3322,8 +3320,8 @@ 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." +"retorna una tupla de tres elementos, los dos primeras son posiciones con " +"cadenas vacías y en la tercera la cadena original." #: ../Doc/library/stdtypes.rst:2004 msgid "" @@ -3354,7 +3352,7 @@ msgstr "" "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::" +"sufijo, sino que se elimina cualquier combinación de sus caracteres::" #: ../Doc/library/stdtypes.rst:2023 msgid "" @@ -3362,8 +3360,8 @@ msgid "" "string rather than all of a set of characters. For example::" msgstr "" "Véase :meth:`str.removesuffix` para un método que removerá una única cadena " -"de sufijo en lugar de de todas las ocurrencias dentro de un set de " -"caracteres. Por ejemplo::" +"de sufijo en lugar de todas las ocurrencias dentro de un set de caracteres. " +"Por ejemplo::" #: ../Doc/library/stdtypes.rst:2033 msgid "" @@ -3375,10 +3373,10 @@ msgid "" 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 " +"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)." +"número de divisiones a realizar (se harán todas las que se puedan)." #: ../Doc/library/stdtypes.rst:2039 msgid "" @@ -3390,8 +3388,8 @@ msgid "" 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'." +"(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á ``['']``." @@ -3418,7 +3416,7 @@ msgid "" "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 " +"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 " @@ -3523,7 +3521,7 @@ msgstr "``\\x85``" #: ../Doc/library/stdtypes.rst:2102 msgid "Next Line (C1 Control Code)" -msgstr "Siguiente línea (Código de control *C1*)" +msgstr "Siguiente línea (Código de control C1)" #: ../Doc/library/stdtypes.rst:2104 msgid "``\\u2028``" @@ -3543,7 +3541,7 @@ msgstr "Separador de párrafo" #: ../Doc/library/stdtypes.rst:2111 msgid "``\\v`` and ``\\f`` added to list of line boundaries." -msgstr "Se añaden ``\\v`` y ``\\f`` a la lista de separadores." +msgstr "Se añadieron ``\\v`` y ``\\f`` a la lista de separadores." #: ../Doc/library/stdtypes.rst:2120 msgid "" @@ -3567,9 +3565,10 @@ msgid "" "*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 " +"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." +"comprobación empieza en esa posición de la cadena. Con el parámetro opcional " +"*end*, la comprobación se detiene en esa posición de la cadena." #: ../Doc/library/stdtypes.rst:2147 msgid "" @@ -3583,8 +3582,8 @@ msgstr "" "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::" +"espacio en blanco. No debe entenderse el valor de *chars* como un prefijo o " +"sufijo, sino que se elimina cualquier combinación de sus caracteres::" #: ../Doc/library/stdtypes.rst:2158 msgid "" @@ -3636,15 +3635,16 @@ msgid "" "The :func:`string.capwords` function does not have this problem, as it " "splits words on spaces only." msgstr "" +"La función :func:`string.capwords` no tiene este problema, ya que solo " +"divide palabras en espacios." #: ../Doc/library/stdtypes.rst:2197 -#, fuzzy msgid "" "Alternatively, a workaround for apostrophes can be constructed using regular " "expressions::" msgstr "" -"Se puede solucionar parcialmente el problema de los apóstrofos usando " -"expresiones regulares::" +"Alternativamente, se puede solucionar parcialmente el problema de los " +"apóstrofos usando expresiones regulares::" #: ../Doc/library/stdtypes.rst:2212 msgid "" @@ -3662,12 +3662,12 @@ msgstr "" "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 " +"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 lanzar una excepción de tipo :exc:`LookupError`, que hará que el carácter " -"se copie igual en la cadena de salida." +"caracteres, de forma que se usarán uno u otro como reemplazo en la cadena de " +"salida; retorna ``None`` para eliminar el carácter en la cadena de salida, o " +"lanza 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:2221 msgid "" @@ -3695,10 +3695,10 @@ msgid "" 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 " +"isupper()`` puede ser ``False`` 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)." +"resultantes no es \"Lu\" (Letra, mayúsculas), sino, por ejemplo, " +"\"Lt\" (Letra, Título)." #: ../Doc/library/stdtypes.rst:2236 msgid "" @@ -3715,8 +3715,8 @@ 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 " +"Retorna una copia de la cadena, rellena por la izquierda con dígitos ``'0'`` " +"de ASCII 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." From 6e39fe49c0fdbecd78f251aefcbb4fb85f65cebd Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Sun, 4 Dec 2022 02:52:12 -0600 Subject: [PATCH 06/10] =?UTF-8?q?Archivo=20hasta=20la=20l=C3=ADnea=204540?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/stdtypes.po | 114 ++++++++++++++++++++++---------------------- 1 file changed, 57 insertions(+), 57 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 8b7146489d..923e75abdf 100755 --- 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: 2022-10-25 19:47+0200\n" -"PO-Revision-Date: 2022-12-01 02:37-0600\n" +"PO-Revision-Date: 2022-12-04 02:47-0600\n" "Last-Translator: José Luis Salgado Banda\n" "Language-Team: python-doc-es\n" "Language: es\n" @@ -20,7 +20,7 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "Generated-By: Babel 2.10.3\n" -"X-Generator: Poedit 3.2\n" +"X-Generator: Poedit 3.2.2\n" #: ../Doc/library/stdtypes.rst:8 msgid "Built-in Types" @@ -3736,7 +3736,7 @@ msgid "" "or extensibility." msgstr "" "Las operaciones de formateo explicadas aquí tienen una serie de " -"peculiaridades que conducen a ciertos errores comunes (Como fallar al " +"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 " @@ -3755,7 +3755,7 @@ msgid "" 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 " +"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:" @@ -3771,7 +3771,7 @@ 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 " +"cadena de formato, o un único objeto de tipo mapa (por ejemplo, un " "diccionario)." #: ../Doc/library/stdtypes.rst:2297 ../Doc/library/stdtypes.rst:3509 @@ -3820,14 +3820,14 @@ 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 " +"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:2317 ../Doc/library/stdtypes.rst:3529 msgid "Length modifier (optional)." -msgstr "Modificador de longitud (Opcional)." +msgstr "Modificador de longitud (opcional)." #: ../Doc/library/stdtypes.rst:2319 ../Doc/library/stdtypes.rst:3531 msgid "Conversion type." @@ -3851,8 +3851,8 @@ 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)." +"En este caso, no se puede usar el especificador ``*`` en la cadena de " +"formato (dado que requiere una lista secuencial de parámetros)." #: ../Doc/library/stdtypes.rst:2333 ../Doc/library/stdtypes.rst:3545 msgid "The conversion flag characters are:" @@ -3870,7 +3870,7 @@ msgstr "``'#'``" 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 " +"El valor a convertir usara la \"forma alternativa\" (que se definirá más " "adelante)" #: ../Doc/library/stdtypes.rst:2347 ../Doc/library/stdtypes.rst:3559 @@ -3892,7 +3892,7 @@ 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 " +"El valor convertido se ajusta a la izquierda (sobreescribe la conversión " "``'0'`` si se especifican los dos)" #: ../Doc/library/stdtypes.rst:2352 ../Doc/library/stdtypes.rst:3564 @@ -3904,8 +3904,8 @@ 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." +"(Un espacio) Se debe 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:2355 ../Doc/library/stdtypes.rst:3567 msgid "``'+'``" @@ -3916,7 +3916,7 @@ 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 " +"Un carácter signo (``'+'`` o ``'-'``) precede a la conversión (sobreescribe " "el indicador de \"espacio\")" #: ../Doc/library/stdtypes.rst:2359 ../Doc/library/stdtypes.rst:3571 @@ -3972,7 +3972,7 @@ msgstr "``'x'``" #: ../Doc/library/stdtypes.rst:2375 ../Doc/library/stdtypes.rst:3587 msgid "Signed hexadecimal (lowercase)." -msgstr "Hexadecimal con signo (En minúsculas)" +msgstr "Hexadecimal con signo (en minúsculas)." #: ../Doc/library/stdtypes.rst:2377 ../Doc/library/stdtypes.rst:3589 msgid "``'X'``" @@ -3980,7 +3980,7 @@ msgstr "``'X'``" #: ../Doc/library/stdtypes.rst:2377 ../Doc/library/stdtypes.rst:3589 msgid "Signed hexadecimal (uppercase)." -msgstr "Hexadecimal con signo (En mayúsculas)" +msgstr "Hexadecimal con signo (en mayúsculas)." #: ../Doc/library/stdtypes.rst:2379 ../Doc/library/stdtypes.rst:3591 msgid "``'e'``" @@ -3988,7 +3988,7 @@ msgstr "``'e'``" #: ../Doc/library/stdtypes.rst:2379 ../Doc/library/stdtypes.rst:3591 msgid "Floating point exponential format (lowercase)." -msgstr "Formato en coma flotante exponencial (En minúsculas)." +msgstr "Formato en coma flotante exponencial (en minúsculas)." #: ../Doc/library/stdtypes.rst:2381 ../Doc/library/stdtypes.rst:3593 msgid "``'E'``" @@ -3996,7 +3996,7 @@ msgstr "``'E'``" #: ../Doc/library/stdtypes.rst:2381 ../Doc/library/stdtypes.rst:3593 msgid "Floating point exponential format (uppercase)." -msgstr "Formato en coma flotante exponencial (En mayúsculas)." +msgstr "Formato en coma flotante exponencial (en mayúsculas)." #: ../Doc/library/stdtypes.rst:2383 ../Doc/library/stdtypes.rst:3595 msgid "``'f'``" @@ -4044,8 +4044,8 @@ msgstr "``'c'``" #: ../Doc/library/stdtypes.rst:2395 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)" +"Un único carácter (acepta números enteros o cadenas de caracteres de " +"longitud 1)." #: ../Doc/library/stdtypes.rst:2398 ../Doc/library/stdtypes.rst:3620 msgid "``'r'``" @@ -4054,7 +4054,7 @@ msgstr "``'r'``" #: ../Doc/library/stdtypes.rst:2398 msgid "String (converts any Python object using :func:`repr`)." msgstr "" -"Cadena de texto (Representará cualquier objeto usando la función :func:" +"Cadena de caracteres (representará cualquier objeto usando la función :func:" "`repr`)." #: ../Doc/library/stdtypes.rst:2401 ../Doc/library/stdtypes.rst:3614 @@ -4064,7 +4064,7 @@ msgstr "``'s'``" #: ../Doc/library/stdtypes.rst:2401 msgid "String (converts any Python object using :func:`str`)." msgstr "" -"Cadena de texto (Representará cualquier objeto usando la función :func:" +"Cadena de caracteres (representará cualquier objeto usando la función :func:" "`str`)." #: ../Doc/library/stdtypes.rst:2404 ../Doc/library/stdtypes.rst:3617 @@ -4074,7 +4074,7 @@ msgstr "``'a'``" #: ../Doc/library/stdtypes.rst:2404 msgid "String (converts any Python object using :func:`ascii`)." msgstr "" -"Cadena de texto (Representará cualquier objeto usando la función :func:" +"Cadena de caracteres (representará cualquier objeto usando la función :func:" "`ascii`)." #: ../Doc/library/stdtypes.rst:2407 ../Doc/library/stdtypes.rst:3623 @@ -4102,9 +4102,9 @@ msgid "" "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'``)." +"dos prefijos indicativos del formato hexadecimal ``'0x'`` o ``'0X'`` (que se " +"use uno u otro depende de que indicador de formato se haya usado, ``'x'`` o " +"``'X'``)." #: ../Doc/library/stdtypes.rst:2422 ../Doc/library/stdtypes.rst:3638 msgid "" @@ -4210,7 +4210,7 @@ msgstr "" "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." +"a los cadenas de caracteres." #: ../Doc/library/stdtypes.rst:2487 msgid "" @@ -4218,8 +4218,8 @@ msgid "" "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:" +"prácticamente iguales que para las cadenas de caracteres, con la diferencia " +"de que se añade el carácter ``b`` como prefijo:" #: ../Doc/library/stdtypes.rst:2490 msgid "Single quotes: ``b'still allows embedded \"double\" quotes'``" @@ -4227,10 +4227,9 @@ msgstr "" "Comillas sencillas: ``b'Se siguen aceptando comillas \"dobles\" embebidas'``" #: ../Doc/library/stdtypes.rst:2491 -#, fuzzy msgid "Double quotes: ``b\"still allows embedded 'single' quotes\"``" msgstr "" -"Comillas dobles: ``b'Se siguen aceptando comillas 'simples' embebidas'``." +"Comillas dobles: ``b\"Se siguen aceptando comillas 'simples' embebidas\"``" #: ../Doc/library/stdtypes.rst:2492 msgid "" @@ -4246,7 +4245,7 @@ msgid "" "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 " +"(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:2498 @@ -4276,14 +4275,14 @@ 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 " +"valores de *x* tal que ``0 <= x < 256`` (si se intenta violar esta " "restricción se lanzará 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 " +"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." +"normalmente corromperán dichos datos)." #: ../Doc/library/stdtypes.rst:2512 msgid "" @@ -4310,7 +4309,7 @@ msgstr "" #: ../Doc/library/stdtypes.rst:2519 msgid "Also see the :ref:`bytes ` built-in." -msgstr "Véase además la función básica :ref:`bytes `." +msgstr "Véase además la función incorporada :ref:`bytes `." #: ../Doc/library/stdtypes.rst:2521 msgid "" @@ -4332,8 +4331,8 @@ msgid "" 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." +"caracteres 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:2534 msgid "" @@ -4356,11 +4355,10 @@ 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." +"Retorna una cadena de caracteres que contiene dos dígitos hexadecimales por " +"cada byte de la instancia." #: ../Doc/library/stdtypes.rst:2549 -#, fuzzy msgid "" "If you want to make the hex string easier to read, you can specify a single " "character separator *sep* parameter to include in the output. By default, " @@ -4370,9 +4368,10 @@ msgid "" 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." +"añada a la salida. Por defecto, este separador se incluirá entre cada byte. " +"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:2566 msgid "" @@ -4391,11 +4390,11 @@ msgid "" "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 " +"(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)." +"longitud 1. (Mientras que las cadenas de caracteres siempre retornan una " +"cadena de longitud 1, ya sea accediendo por índice o mediante una operación " +"de segmentado)." #: ../Doc/library/stdtypes.rst:2575 msgid "" @@ -4461,7 +4460,8 @@ msgstr "" #: ../Doc/library/stdtypes.rst:2604 msgid "Also see the :ref:`bytearray ` built-in." -msgstr "Véase también la función básica :ref:`bytearray `." +msgstr "" +"Véase también la función incorporada :ref:`bytearray `." #: ../Doc/library/stdtypes.rst:2606 msgid "" @@ -4481,10 +4481,10 @@ 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*, " +"Este método de clase de :class:`bytearray` 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." +"caracteres 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:2619 msgid "" @@ -4520,11 +4520,11 @@ msgid "" "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 " +"(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)." +"longitud 1. (Mientras que las cadenas de caracteres siempre retornan una " +"cadena de longitud 1, ya sea accediendo por índice o mediante una operación " +"de segmentado)." #: ../Doc/library/stdtypes.rst:2646 msgid "" From af9de4598ed625d814c47aa006f1d3b7f661f6dd Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Sun, 4 Dec 2022 21:01:10 -0600 Subject: [PATCH 07/10] =?UTF-8?q?Archivo=20hasta=20la=20l=C3=ADnea=205940?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/stdtypes.po | 197 ++++++++++++++++++++++---------------------- 1 file changed, 98 insertions(+), 99 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index 923e75abdf..f693fd7c18 100755 --- 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: 2022-10-25 19:47+0200\n" -"PO-Revision-Date: 2022-12-04 02:47-0600\n" +"PO-Revision-Date: 2022-12-04 20:56-0600\n" "Last-Translator: José Luis Salgado Banda\n" "Language-Team: python-doc-es\n" "Language: es\n" @@ -4609,7 +4609,7 @@ msgid "" 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." +"interpretan como en las operaciones de segmentado." #: ../Doc/library/stdtypes.rst:2698 ../Doc/library/stdtypes.rst:2797 #: ../Doc/library/stdtypes.rst:2819 ../Doc/library/stdtypes.rst:2885 @@ -4657,9 +4657,8 @@ 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." +"La versión *bytearray* de este método *no* opera in situ - siempre produce " +"un nuevo objeto, aún si no se hubiera realizado ningún cambio." #: ../Doc/library/stdtypes.rst:2730 msgid "" @@ -4706,8 +4705,8 @@ msgid "" msgstr "" "Por defecto, el argumento *errors* no se verifica para mejor rendimiento, " "solo se usa con el primer error de codificación encontrado. Se puede " -"habilitar el :ref:`Python Development Mode `, o utilizar una :ref:" -"`debug build ` para verificar *errors*." +"habilitar el :ref:`modo de desarrollo de Python `, o utilizar una :" +"ref:`compilación de depuración ` para verificar *errors*." #: ../Doc/library/stdtypes.rst:2766 msgid "" @@ -4750,9 +4749,9 @@ msgid "" "``-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 " +"subsecuencia *sub*, de forma que *sub* está contenida en el segmento " "``s[start:end]``. Los parámetros opcionales *start* y *end* se interpretan " -"como en las operaciones de rebanadas. retorna ``-1`` si no se puede " +"como en las operaciones de segmentado. Retorna ``-1`` si no se puede " "encontrar *sub*." #: ../Doc/library/stdtypes.rst:2802 @@ -4798,7 +4797,7 @@ msgid "" 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 " +"misma posición en *to*; tanto *from* como *to* deben ser :term:`objetos tipo " "binario ` y deben tener la misma longitud." #: ../Doc/library/stdtypes.rst:2851 @@ -4809,7 +4808,7 @@ 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 " +"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 la " @@ -4849,7 +4848,7 @@ msgid "" 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. " +"*start* y *end* se interpretan igual que en las operaciones de segmentado. " "Retorna ``-1`` si no se encuentra *sub*." #: ../Doc/library/stdtypes.rst:2895 @@ -4938,8 +4937,8 @@ msgstr "" "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." +"*bytearray* en esta sección nunca operan in situ, sino que siempre retornan " +"objetos nuevos." #: ../Doc/library/stdtypes.rst:2959 msgid "" @@ -4950,7 +4949,7 @@ msgid "" 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:" +"(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)``." @@ -4963,7 +4962,7 @@ msgid "" 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 " +"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)``." @@ -4993,7 +4992,7 @@ msgstr "" "La secuencia binaria que especifica el conjunto bytes a ser eliminados puede " "ser cualquier :term:`objeto de tipo binario`. Véase :meth:" "`~bytes.removeprefix` para un método que removerá una única cadena de " -"prefijo en lugar de de todas las ocurrencias dentro de un set de caracteres. " +"prefijo en lugar de todas las ocurrencias dentro de un set de caracteres. " "Por ejemplo::" #: ../Doc/library/stdtypes.rst:3018 @@ -5005,7 +5004,7 @@ msgid "" 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 " +"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)``." @@ -5053,7 +5052,7 @@ msgstr "" "La secuencia binaria que especifica el conjunto bytes a ser eliminados puede " "ser cualquier :term:`objeto de tipo binario`. Véase :meth:" "`~bytes.removesuffix` para un método que removerá una única cadena de sufijo " -"en lugar de de todas las ocurrencias dentro de un set de caracteres. Por " +"en lugar de todas las ocurrencias dentro de un set de caracteres. Por " "ejemplo::" #: ../Doc/library/stdtypes.rst:3074 @@ -5066,9 +5065,10 @@ msgid "" 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 " +"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." +"especifica *maxsplit* o se pasa ``'-1``, no hay límite al número de " +"divisiones (se hacen todas las posibles divisiones)." #: ../Doc/library/stdtypes.rst:3080 msgid "" @@ -5082,8 +5082,8 @@ msgid "" 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'." +"(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 " @@ -5099,7 +5099,7 @@ msgid "" "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 " +"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 " @@ -5129,7 +5129,7 @@ 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 " +"La secuencia binaria de bytes a eliminar debe ser un :term:`objeto tipo " "binario `." #: ../Doc/library/stdtypes.rst:3141 @@ -5142,8 +5142,7 @@ 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." +"sección nunca operan in situ, sino que siempre retornan objetos nuevos." #: ../Doc/library/stdtypes.rst:3149 msgid "" @@ -5170,15 +5169,15 @@ 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/* " +"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* " +"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 " +"espacios hasta que sea igual a la siguiente posición de tabulación. (El " +"carácter tabulador en sí es descartado). Si el byte es 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 " @@ -5193,8 +5192,8 @@ msgid "" "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 " +"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'``." @@ -5207,8 +5206,8 @@ msgid "" "``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 " +"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:3223 @@ -5217,7 +5216,7 @@ msgid "" "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``. " +"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:3233 @@ -5227,7 +5226,7 @@ msgid "" "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 " +"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'``." @@ -5237,7 +5236,7 @@ msgid "" "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 " +"ningún carácter ASCII en mayúsculas, en cualquier otro caso retorna " "``False``." #: ../Doc/library/stdtypes.rst:3258 ../Doc/library/stdtypes.rst:3300 @@ -5249,7 +5248,7 @@ msgid "" "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 " +"``b'abcdefghijklmnopqrstuvwxyz'``. Los caracteres ASCII en mayúsculas son " "los bytes en la secuencia ``b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``." #: ../Doc/library/stdtypes.rst:3266 @@ -5260,9 +5259,9 @@ msgid "" "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, " +"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:3275 @@ -5272,7 +5271,7 @@ msgid "" "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 " +"secuencia 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\"." @@ -5283,7 +5282,7 @@ msgid "" "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 " +"ningún carácter ASCII en minúsculas, en cualquier otro caso retorna " "``False``." #: ../Doc/library/stdtypes.rst:3308 @@ -5301,7 +5300,7 @@ 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 " +"Retorna una lista de las líneas en la secuencia binaria, 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``." @@ -5345,7 +5344,8 @@ msgid "" "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." +"primera letra de cada palabra en mayúsculas y el resto en minúsculas. Los " +"valores de bytes sin mayúsculas y minúsculas se dejan sin modificar." #: ../Doc/library/stdtypes.rst:3393 msgid "" @@ -5355,7 +5355,7 @@ msgid "" "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 " +"``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." @@ -5385,7 +5385,7 @@ 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 " +"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)``." @@ -5401,7 +5401,7 @@ msgid "" "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 " +"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." @@ -5414,13 +5414,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`." +"Los objetos binarios (``bytes``/``bytearray``) tienen una operación " +"incorporada: 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:3499 msgid "" @@ -5432,7 +5432,7 @@ 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)." +"objeto binario, o un único objeto de tipo mapa (por ejemplo, un diccionario)." #: ../Doc/library/stdtypes.rst:3533 msgid "" @@ -5441,7 +5441,7 @@ 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 " +"Cuando el argumento 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 " @@ -5449,7 +5449,7 @@ msgstr "" #: ../Doc/library/stdtypes.rst:3607 msgid "Single byte (accepts integer or single byte objects)." -msgstr "Byte único (Acepta números enteros o binarios de un único byte)" +msgstr "Byte único (acepta números enteros o binarios de un único byte)." #: ../Doc/library/stdtypes.rst:3610 msgid "``'b'``" @@ -5460,8 +5460,8 @@ 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__`)." +"Bytes (cualquier objeto que siga el :ref:`protocolo búfer ` o " +"implemente el método :meth:`__bytes__`)." #: ../Doc/library/stdtypes.rst:3614 msgid "" @@ -5472,13 +5472,12 @@ msgstr "" "Python2/3." #: ../Doc/library/stdtypes.rst:3617 -#, fuzzy msgid "" "Bytes (converts any Python object using ``repr(obj).encode('ascii', " "'backslashreplace')``)." msgstr "" -"Bytes (Convierte cualquier objeto Python usando ``repr(obj)." -"encode('ascii','backslashreplace)``)." +"Bytes (convierte cualquier objeto Python usando ``repr(obj)." +"encode('ascii','backslashreplace')``)." #: ../Doc/library/stdtypes.rst:3620 msgid "" @@ -5528,8 +5527,8 @@ msgid "" "protocol include :class:`bytes` and :class:`bytearray`." msgstr "" "Crea un :class:`memoryview` que referencia *object*. La variable *object* " -"debe soportar el protocolo buffer. Los tipos de datos básicos que soportan " -"el protocolo buffer incluyen los :class:`bytes` y :class:`bytearray`." +"debe soportar el protocolo buffer. Los objetos incorporados que soportan el " +"protocolo buffer incluyen los :class:`bytes` y :class:`bytearray`." #: ../Doc/library/stdtypes.rst:3689 msgid "" @@ -5565,9 +5564,9 @@ 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::" +"Un objeto de tipo :class:`memoryview` soporta operaciones de segmentado y " +"acceso por índices a sus datos. Un segmentado unidimensional producirá una " +"sub-vista::" #: ../Doc/library/stdtypes.rst:3714 msgid "" @@ -5598,7 +5597,7 @@ msgid "" "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 " +"soporta asignación unidimensional mediante segmentos. Sin embargo, no se " "permite el cambio de tamaño::" #: ../Doc/library/stdtypes.rst:3756 @@ -5608,9 +5607,8 @@ msgid "" "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())``::" +"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:3768 msgid "" @@ -5618,21 +5616,21 @@ msgid "" "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*." +"operaciones de segmentado. Los objetos *memoryviews* de una única dimensión " +"con formatos 'B', 'b' o 'c' son ahora *hashables*." #: ../Doc/library/stdtypes.rst:3772 msgid "" "memoryview is now registered automatically with :class:`collections.abc." "Sequence`" msgstr "" -"los objetos *memoryview* son registrados automáticamente con la clase :class:" +"Los objetos *memoryview* son registrados automáticamente con la clase :class:" "`collections.abc.Sequence`" #: ../Doc/library/stdtypes.rst:3776 msgid "memoryviews can now be indexed with tuple of integers." msgstr "" -"los objetos *memoryviews* se pueden ahora acceder usando como índices una " +"Los objetos *memoryviews* se pueden ahora acceder usando como índices una " "tupla de números enteros." #: ../Doc/library/stdtypes.rst:3779 @@ -5666,7 +5664,7 @@ msgid "" 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* " +"diferentes (incluso si las cadenas de formato y el contenido del *buffer* " "son idénticos)::" #: ../Doc/library/stdtypes.rst:3822 @@ -5683,7 +5681,7 @@ msgid "" "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*." +"formato de los elementos ni la estructura lógica del arreglo." #: ../Doc/library/stdtypes.rst:3831 msgid "" @@ -5700,10 +5698,11 @@ 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 " +"Para arreglos 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`." +"método :meth:`tobytes` soporta todos los formatos de cadenas de caracteres, " +"incluidos aquellos que no se encuentran en la sintaxis del módulo :mod:" +"`struct`." #: ../Doc/library/stdtypes.rst:3845 msgid "" @@ -5714,10 +5713,10 @@ msgid "" "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 " +"los datos en el arreglo 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 " +"vistas no contiguas, los datos se convierten primero a C. Definir " "*order=None* es lo mismo que *order='C'*." #: ../Doc/library/stdtypes.rst:3854 @@ -5769,9 +5768,9 @@ msgid "" 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 " +"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 " +"restricciones (así como para tratar con los recursos pendientes) lo más " "pronto posible." #: ../Doc/library/stdtypes.rst:3912 @@ -5781,7 +5780,7 @@ msgid "" "multiple times)::" msgstr "" "Después de que se ha llamado a este método, cualquier operación posterior " -"sobre la vista lanzará una excepción de tipo :class:`ValueError` (Excepto " +"sobre la vista lanzará una excepción de tipo :class:`ValueError` (excepto " "por el propio método :meth:`release()`, que puede ser llamado las veces que " "se quiera)::" @@ -5815,8 +5814,8 @@ msgid "" 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." +"byte ('B', 'b' o 'c'). La longitud en bytes del resultado debe coincidir con " +"la longitud original." #: ../Doc/library/stdtypes.rst:3950 msgid "Cast 1D/long to 1D/unsigned bytes::" @@ -5855,12 +5854,12 @@ msgid "" "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 " +"espacio, medido en bytes, que usará el arreglo en una representación " "continua. No tiene que ser necesariamente igual a ``len(m)``::" #: ../Doc/library/stdtypes.rst:4063 msgid "Multi-dimensional arrays::" -msgstr "Matrices de múltiples dimensiones::" +msgstr "Arreglos de múltiples dimensiones::" #: ../Doc/library/stdtypes.rst:4080 msgid "A bool indicating whether the memory is read only." @@ -5873,10 +5872,10 @@ 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 :" +"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 " +"pero algunos métodos (como, por ejemplo, :meth:`tolist`) están restringidos " "a usar formatos de elementos nativos sencillos." #: ../Doc/library/stdtypes.rst:4089 @@ -5897,7 +5896,7 @@ 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-" +"Un número entero que indica cuantas dimensiones de un arreglo multi-" "dimensional representa la memoria." #: ../Doc/library/stdtypes.rst:4113 @@ -5906,11 +5905,11 @@ msgid "" "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." +"de la memoria en un arreglo de *N* dimensiones." #: ../Doc/library/stdtypes.rst:4116 ../Doc/library/stdtypes.rst:4124 msgid "An empty tuple instead of ``None`` when ndim = 0." -msgstr "Una tupla vacía, en vez de ``None``, cuando ``ndom = 0``." +msgstr "Una tupla vacía, en vez de ``None``, cuando ``ndim = 0``." #: ../Doc/library/stdtypes.rst:4121 msgid "" @@ -5918,17 +5917,17 @@ msgid "" "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." +"en bytes para acceder a cada dimensión del arreglo." #: ../Doc/library/stdtypes.rst:4129 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." +"De uso interno para los arreglos estilo *PIL*. El valor es solo informativo." #: ../Doc/library/stdtypes.rst:4133 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*." +"Un booleano que indica si la memoria es :term:`contiguous` al estilo C." #: ../Doc/library/stdtypes.rst:4139 msgid "A bool indicating whether the memory is Fortran :term:`contiguous`." From fce45dfc551ad8bc151039f7e39fc3254feb3a94 Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Mon, 5 Dec 2022 11:36:17 -0600 Subject: [PATCH 08/10] Archivo traducido por completo --- dictionaries/library_stdtypes.txt | 5 +- library/stdtypes.po | 496 ++++++++++++++++++------------ 2 files changed, 301 insertions(+), 200 deletions(-) diff --git a/dictionaries/library_stdtypes.txt b/dictionaries/library_stdtypes.txt index 68d7bbf1d6..51aa7d252f 100644 --- a/dictionaries/library_stdtypes.txt +++ b/dictionaries/library_stdtypes.txt @@ -1,5 +1,6 @@ computacionalmente Cardinalidad +cardinalidad subindicando superconjunto superíndices @@ -7,4 +8,6 @@ unaria Ll Lm Lu -Kharosthi \ No newline at end of file +Kharosthi +subcuadrática +precompilar \ No newline at end of file diff --git a/library/stdtypes.po b/library/stdtypes.po index f693fd7c18..6aa5e586ca 100755 --- 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: 2022-10-25 19:47+0200\n" -"PO-Revision-Date: 2022-12-04 20:56-0600\n" +"PO-Revision-Date: 2022-12-05 11:32-0600\n" "Last-Translator: José Luis Salgado Banda\n" "Language-Team: python-doc-es\n" "Language: es\n" @@ -5624,13 +5624,13 @@ msgid "" "memoryview is now registered automatically with :class:`collections.abc." "Sequence`" msgstr "" -"Los objetos *memoryview* son registrados automáticamente con la clase :class:" +"los objetos *memoryview* son registrados automáticamente con la clase :class:" "`collections.abc.Sequence`" #: ../Doc/library/stdtypes.rst:3776 msgid "memoryviews can now be indexed with tuple of integers." msgstr "" -"Los objetos *memoryviews* se pueden ahora acceder usando como índices una " +"los objetos *memoryviews* se pueden ahora acceder usando como índices una " "tupla de números enteros." #: ../Doc/library/stdtypes.rst:3779 @@ -5951,13 +5951,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`)." +"Un objeto de tipo :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 incorporadas :class:`dict`, :class:`list`, y :class:" +"`tuple`, así como el módulo :mod:`collections`)." #: ../Doc/library/stdtypes.rst:4164 msgid "" @@ -5969,7 +5969,7 @@ 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 " +"mismo, los conjuntos no soportan indexado, ni operaciones de segmentado, ni " "otras capacidades propias de las secuencias." #: ../Doc/library/stdtypes.rst:4169 @@ -5983,9 +5983,9 @@ 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:" +"En la actualidad hay dos tipos de conjuntos incorporados: :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 " @@ -6058,7 +6058,7 @@ msgstr "" #: ../Doc/library/stdtypes.rst:4203 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*)" +"Retorna el número de elementos en el conjunto *s* (cardinalidad de *s*)." #: ../Doc/library/stdtypes.rst:4207 msgid "Test *x* for membership in *s*." @@ -6146,7 +6146,7 @@ msgstr "" "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')``." +"el uso de formas más legibles como ``set('abc').intersection('cbs')``." #: ../Doc/library/stdtypes.rst:4270 msgid "" @@ -6158,11 +6158,11 @@ msgid "" "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 " +"sí. 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 " +"del segundo (es un subconjunto, pero no son iguales). Un conjunto es mayor " +"que otro si y solo si el primero es un superconjunto propio del segundo (es " "un superconjunto, pero no son iguales)." #: ../Doc/library/stdtypes.rst:4277 @@ -6187,14 +6187,14 @@ msgstr "" "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``." +"retornan ``False``: ``ab``." #: ../Doc/library/stdtypes.rst:4286 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), " +"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." @@ -6211,7 +6211,7 @@ msgid "" "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` retornan el tipo del primer operando. Por ejemplo: " "``frozenset('ab') | set('bc')`` retornará una instancia de :class:" "`frozenset`." @@ -6268,7 +6268,7 @@ msgid "" "if the set is empty." msgstr "" "Elimina y retorna un elemento cualquiera del conjunto. Lanza la excepción :" -"exc:`KeyError` si el conjunto estaba vacío." +"exc:`KeyError` si el conjunto está vacío." #: ../Doc/library/stdtypes.rst:4338 msgid "Remove all elements from the set." @@ -6309,9 +6309,10 @@ msgid "" 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`)." +"En este momento solo hay un tipo estándar de mapa, los :dfn:`dictionary`. " +"(Para otros tipos contenedores, véanse las clases incorporadas :class:" +"`list`, :class:`set`, y :class:`tuple`, así como el módulo :mod:" +"`collections`)." #: ../Doc/library/stdtypes.rst:4370 msgid "" @@ -6329,8 +6330,8 @@ msgstr "" "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 " +"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)." @@ -6352,8 +6353,8 @@ msgid "" "Use a comma-separated list of ``key: value`` pairs within braces: ``{'jack': " "4098, 'sjoerd': 4127}`` or ``{4098: 'jack', 4127: 'sjoerd'}``" msgstr "" -"Usando una lista separada por comas de pares ``key: value`` entre llaves:" -"``{'jack': 4098, 'sjoerd': 4127}`` or ``{4098: 'jack', 4127: 'sjoerd'}``" +"Usando una lista separada por comas de pares ``key: value`` entre llaves: " +"``{'jack': 4098, 'sjoerd': 4127}`` o ``{4098: 'jack', 4127: 'sjoerd'}``" #: ../Doc/library/stdtypes.rst:4390 msgid "Use a dict comprehension: ``{}``, ``{x: x ** 2 for x in range(10)}``" @@ -6381,10 +6382,10 @@ msgid "" "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); " +"Si se pasa un parámetro por posición y es un objeto de tipo mapa, se crea 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." @@ -6399,14 +6400,14 @@ 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." +"parámetro por nombre reemplazará el valor del parámetro por posición." #: ../Doc/library/stdtypes.rst:4409 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 " +"A modo de ejemplo, los siguientes ejemplos retornan todos el mismo " "diccionario ``{\"one\": 1, \"two\": 2, \"three\": 3}``::" #: ../Doc/library/stdtypes.rst:4421 @@ -6424,7 +6425,7 @@ 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, " +"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:4430 @@ -6500,12 +6501,12 @@ 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 " +"Retorna un iterador que recorre todas las claves de un diccionario. Es una " "forma abreviada de ``iter(d.keys())``." #: ../Doc/library/stdtypes.rst:4489 msgid "Remove all items from the dictionary." -msgstr "Elimina todos los contenidos del diccionario." +msgstr "Elimina todos los elementos del diccionario." #: ../Doc/library/stdtypes.rst:4493 msgid "Return a shallow copy of the dictionary." @@ -6549,8 +6550,8 @@ 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 `." +"Retorna una nueva vista de los elementos del diccionario (pares ``(key, " +"value)``). Véase la :ref:`documentación de los objetos vistas `." #: ../Doc/library/stdtypes.rst:4518 msgid "" @@ -6568,7 +6569,7 @@ msgid "" 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 lanza la " +"*default* y la *key* no se encuentra en el diccionario, se lanza la " "excepción :exc:`KeyError`." #: ../Doc/library/stdtypes.rst:4529 @@ -6604,7 +6605,7 @@ 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 " +"Retorna un iterador que recorre las claves en orden inverso. Es una forma " "abreviada de ``reversed(d.keys())``." #: ../Doc/library/stdtypes.rst:4549 @@ -6622,7 +6623,7 @@ msgid "" "existing keys. Return ``None``." msgstr "" "Actualiza el diccionario con las parejas clave/valor obtenidas de *other*, " -"escribiendo encima de las claves existentes. retorna ``None``." +"escribiendo encima de las claves existentes. Retorna ``None``." #: ../Doc/library/stdtypes.rst:4558 msgid "" @@ -6632,10 +6633,9 @@ msgid "" "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 " +"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)``." +"actualiza con esas combinaciones de clave/valor: ``d.update(red=1, blue=2)``." #: ../Doc/library/stdtypes.rst:4565 msgid "" @@ -6683,7 +6683,7 @@ msgid "" "'>') 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 " +"de parejas ``(key, value)`` (independiente de su orden). Los intentos de " "comparar usando los operadores '<', '<=', '>=', '>' lanzan una excepción de " "tipo :exc:`TypeError`." @@ -6692,9 +6692,9 @@ 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.::" +"Los diccionarios mantienen de forma interna el orden de inserción. " +"Actualizar una clave 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:4614 msgid "" @@ -6756,8 +6756,8 @@ 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." +"Retorna un iterador sobre las claves, valores o elementos (representados en " +"forma de tuplas ``(key, value)``) de un diccionario." #: ../Doc/library/stdtypes.rst:4661 msgid "" @@ -6790,16 +6790,16 @@ msgid "" "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)``." +"elementos del diccionario (en el último caso, *x* debe ser una tupla ``(key, " +"value)``)." #: ../Doc/library/stdtypes.rst:4679 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." +"Retorna un iterador inverso sobre las claves, los valores o los elementos " +"del diccionario. El orden de la vista será el inverso del orden de inserción." #: ../Doc/library/stdtypes.rst:4682 msgid "Dictionary views are now reversible." @@ -6825,12 +6825,12 @@ 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 " +"*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 " -"``^``." +"abstracta :class:`collections.abc.Set` (como por ejemplo ``==``, ``<`` o " +"``^``)." #: ../Doc/library/stdtypes.rst:4699 msgid "An example of dictionary view usage::" @@ -6838,7 +6838,7 @@ msgstr "Un ejemplo de uso de una vista de diccionario::" #: ../Doc/library/stdtypes.rst:4740 msgid "Context Manager Types" -msgstr "Tipos Gestores de Contexto" +msgstr "Tipos gestores de contexto" #: ../Doc/library/stdtypes.rst:4747 msgid "" @@ -6850,7 +6850,7 @@ 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 " +"contextos definiendo dos métodos, uno a ejecutar antes de entrar del bloque " "de código y otro a ejecutar justo después de salir del mismo:" #: ../Doc/library/stdtypes.rst:4755 @@ -6890,7 +6890,7 @@ msgstr "" "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." +"de :keyword:`!with`." #: ../Doc/library/stdtypes.rst:4774 msgid "" @@ -6920,11 +6920,11 @@ msgid "" 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`." +"sentencia inmediatamente después de la sentencia :keyword:`!with`. 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:4786 msgid "" @@ -6951,12 +6951,11 @@ 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 :" +"decimales. Los tipos específicos no se tratan especialmente fuera de su " +"implementación del protocolo de administración de contexto. Véase el módulo :" "mod:`contextlib` para algunos ejemplos." #: ../Doc/library/stdtypes.rst:4798 -#, fuzzy msgid "" "Python's :term:`generator`\\s and the :class:`contextlib.contextmanager` " "decorator provide a convenient way to implement these protocols. If a " @@ -6965,12 +6964,13 @@ msgid "" "`~contextmanager.__enter__` and :meth:`~contextmanager.__exit__` methods, " "rather than the iterator produced by an undecorated generator function." msgstr "" -"Los :term:`generator` y el decoradores definidos en la clase :class:" +"Los :term:`generator` de Python y el decorador 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." +"métodos necesarios :meth:`~contextmanager.__enter__` y :meth:" +"`~contextmanager.__exit__`, en vez del iterador que se produciría si no se " +"decora la función generadora." #: ../Doc/library/stdtypes.rst:4805 msgid "" @@ -6981,26 +6981,29 @@ msgid "" "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." +"estructura usada para los objetos Python en el nivel de la API de Python/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:4813 msgid "" "Type Annotation Types --- :ref:`Generic Alias `, :ref:" "`Union `" msgstr "" -"Tipos de Anotaciones de Tipo — :ref:`Generic Alias `, :" +"Tipos de anotaciones de type — :ref:`alias genérico `, :" "ref:`Union `" +# Hace referencia al tipo o al objeto 'type'? #: ../Doc/library/stdtypes.rst:4818 msgid "" "The core built-in types for :term:`type annotations ` are :ref:" "`Generic Alias ` and :ref:`Union `." msgstr "" -"Los tipos principales integrados para :term:`type annotations ` " -"son :ref:`Generic Alias ` y :ref:`Union `." +"Los tipos principales integrados para :term:`anotaciones de tipo " +"` son :ref:`alias genérico ` y :ref:`Union " +"`." #: ../Doc/library/stdtypes.rst:4825 msgid "Generic Alias Type" @@ -7015,22 +7018,29 @@ msgid "" "the ``list`` class with the argument :class:`int`. ``GenericAlias`` objects " "are intended primarily for use with :term:`type annotations `." msgstr "" +"Los objetos ``GenericAlias`` generalmente se crean para :ref:`suscribir " +"` a una clase. Se utilizan con mayor frecuencia con :ref:" +"`clases contenedoras `, como :class:`list` o :class:`dict`. " +"Por ejemplo, ``list[int]`` es un objeto ``GenericAlias`` que se creó para " +"suscribir la clase ``list`` con el argumento :class:`int`. Los objetos " +"``GenericAlias`` están pensados principalmente para usar con :term:" +"`anotaciones de tipo `." #: ../Doc/library/stdtypes.rst:4841 msgid "" "It is generally only possible to subscript a class if the class implements " "the special method :meth:`~object.__class_getitem__`." msgstr "" +"Generalmente solo es posible suscribir a una clase si ésta implementa el " +"método especial :meth:`~object.__class_getitem__`." #: ../Doc/library/stdtypes.rst:4844 -#, fuzzy msgid "" "A ``GenericAlias`` object acts as a proxy for a :term:`generic type`, " "implementing *parameterized generics*." msgstr "" "El objeto ``GenericAlias`` actúa como *proxy* para :term:`tipo genérico " -"`, implementando *parametrized generics* -una instancia " -"específica de genérico que provee tipos para contenedores de elementos." +"`, implementando *parameterized generics*." #: ../Doc/library/stdtypes.rst:4847 msgid "" @@ -7040,6 +7050,11 @@ msgid "" "to signify a :class:`set` in which all the elements are of type :class:" "`bytes`." msgstr "" +"Para una clase contenedora, el argumento (o los argumentos) proporcionado(s) " +"a una :ref:`suscripción ` de la clase puede indicar el tipo " +"(o tipos) de los elementos que contiene un objeto. Por ejemplo, se puede " +"usar ``set[bytes]`` en anotaciones de tipo para significar un :class:`set` " +"en el que todos los elementos son del tipo :class:`bytes`." #: ../Doc/library/stdtypes.rst:4853 msgid "" @@ -7049,6 +7064,12 @@ msgid "" "object. For example, :mod:`regular expressions ` can be used on both " "the :class:`str` data type and the :class:`bytes` data type:" msgstr "" +"Para una clase que define el método :meth:`~object.__class_getitem__` pero " +"no es un contenedor, el argumento (o los argumentos) proporcionado(s) a una " +"suscripción de la clase a menudo indicarán el tipo (o los tipos) de retorno " +"de uno o más métodos definidos en un objeto. Por ejemplo, las :mod:" +"`expresiones regulares ` se pueden usar tanto para el tipo de datos :" +"class:`str` y el tipo de datos :class:`bytes`:" #: ../Doc/library/stdtypes.rst:4859 msgid "" @@ -7057,6 +7078,10 @@ msgid "" "both be of type :class:`str`. We can represent this kind of object in type " "annotations with the ``GenericAlias`` ``re.Match[str]``." msgstr "" +"Si ``x = re.search('foo', 'foo')``, ``x`` será un objeto :ref:`re.Match " +"` donde los valores de retorno de ``x.group(0)`` y ``x[0]`` " +"serán de tipo :class:`str`. Podemos representar este tipo de objeto en " +"anotaciones de type con el ``GenericAlias`` de ``re.Match[str]``." #: ../Doc/library/stdtypes.rst:4865 msgid "" @@ -7066,18 +7091,21 @@ msgid "" "annotations, we would represent this variety of :ref:`re.Match ` objects with ``re.Match[bytes]``." msgstr "" +"Si ``y = re.search(b'bar', b'bar')``, (nótese que ``b`` es para :class:" +"`bytes`), ``y`` también será una instancia de ``re.Match``, pero los valores " +"de retorno de ``y.group(0)`` y ``y[0]``serán de tipo :class:`bytes`. En " +"anotaciones de type, representaríamos esta variedad de objetos :ref:`re." +"Match ` con ``re.Match[bytes]``." #: ../Doc/library/stdtypes.rst:4871 -#, fuzzy msgid "" "``GenericAlias`` objects are instances of the class :class:`types." "GenericAlias`, which can also be used to create ``GenericAlias`` objects " "directly." msgstr "" -"El tipo expuesto por el usuario para el objeto ``GenericAlias`` puede ser " -"accedido desde :class:`types.GenericAlias` y usado por chequeos :func:" -"`isinstance`. También puede ser usado para crear objetos ``GenericAlias`` " -"directamente." +"Los objetos ``GenericAlias`` son instancias de la clase :class:`types." +"GenericAlias`, que también se puede usar para crear directamente objetos " +"``GenericAlias``." #: ../Doc/library/stdtypes.rst:4877 msgid "" @@ -7085,6 +7113,9 @@ msgid "" "*X*, *Y*, and more depending on the ``T`` used. For example, a function " "expecting a :class:`list` containing :class:`float` elements::" msgstr "" +"Crea un ``GenericAlias`` que representa un tipo ``T`` parametrizado por " +"tipos *X*, *Y* y más dependiendo de la ``T`` usada. Por ejemplo, una función " +"espera un :class:`list` que contenga elementos :class:`float`::" #: ../Doc/library/stdtypes.rst:4885 msgid "" @@ -7107,7 +7138,6 @@ msgstr "" "tipos ``GenericAlias`` como segundo argumento::" #: ../Doc/library/stdtypes.rst:4901 -#, fuzzy msgid "" "The Python runtime does not enforce :term:`type annotations `. " "This extends to generic types and their type parameters. When creating a " @@ -7117,16 +7147,16 @@ msgid "" msgstr "" "Python en tiempo de ejecución no hace cumplir las :term:`anotaciones de tipo " "`. Esto se extiende para tipos genéricos y sus parámetros. " -"Cuando se crea un objeto desde un ``GenericAlias``, los elementos del " -"contenedor no se verifican con su tipo. Por ejemplo, el siguiente código no " -"es recomendado en lo absoluto, pero correrá sin errores::" +"Cuando se crea un objeto contenedor desde un ``GenericAlias``, los elementos " +"del contenedor no se verifican con su tipo. Por ejemplo, el siguiente código " +"no es recomendado en lo absoluto, pero correrá sin errores::" #: ../Doc/library/stdtypes.rst:4911 msgid "" "Furthermore, parameterized generics erase type parameters during object " "creation::" msgstr "" -"Además, los tipos de los parámetros de tipos genéricos se borran durante la " +"Además, los genéricos parametrizados borran parámetros de type durante la " "creación de objetos::" #: ../Doc/library/stdtypes.rst:4922 @@ -7138,38 +7168,36 @@ msgstr "" "parametrizado::" #: ../Doc/library/stdtypes.rst:4930 -#, fuzzy msgid "" "The :meth:`~object.__getitem__` method of generic containers will raise an " "exception to disallow mistakes like ``dict[str][str]``::" msgstr "" -"El método :meth:`__getitem__` de tipos genéricos lanzarán una excepción para " -"rechazar los errores como ``dict[str][str]``::" +"El método :meth:`~object.__getitem__` de contenedores genéricos lanzarán una " +"excepción para rechazar los errores como ``dict[str][str]``::" +# Tipo u objeto 'type'? #: ../Doc/library/stdtypes.rst:4938 -#, fuzzy msgid "" "However, such expressions are valid when :ref:`type variables ` " "are used. The index must have as many elements as there are type variable " "items in the ``GenericAlias`` object's :attr:`~genericalias.__args__`. ::" msgstr "" -"Sin embargo, estas expresiones son válidas cuando se usa :ref:`variables de " -"tipo `. El índice debe tener tantos elementos como los elementos " -"de variable de tipo que hayan en los :attr:`__args__ `. :: del objeto ``GenericAlias``::" +"Sin embargo, estas expresiones son válidas cuando se usan :ref:`variables de " +"type `. El índice debe tener tantos elementos como los elementos " +"de variable de type en los :attr:`~genericalias.__args__` del objeto " +"``GenericAlias``::" #: ../Doc/library/stdtypes.rst:4949 -#, fuzzy msgid "Standard Generic Classes" -msgstr "Colecciones de Genéricos Estándar" +msgstr "Clases genéricas estándar" #: ../Doc/library/stdtypes.rst:4951 -#, fuzzy msgid "" "The following standard library classes support parameterized generics. This " "list is non-exhaustive." msgstr "" -"Esta librería de colecciones estándar soporta genéricos parametrizados." +"Las siguientes clases de la biblioteca estándar soportan genéricos " +"parametrizados. Esta lista no es exhaustiva." #: ../Doc/library/stdtypes.rst:4954 msgid ":class:`tuple`" @@ -7316,41 +7344,36 @@ msgid ":class:`contextlib.AbstractAsyncContextManager`" msgstr ":class:`contextlib.AbstractAsyncContextManager`" #: ../Doc/library/stdtypes.rst:4990 -#, fuzzy msgid ":class:`dataclasses.Field`" -msgstr ":class:`tuple`" +msgstr ":class:`dataclasses.Field`" #: ../Doc/library/stdtypes.rst:4991 msgid ":class:`functools.cached_property`" -msgstr "" +msgstr ":class:`functools.cached_property`" #: ../Doc/library/stdtypes.rst:4992 msgid ":class:`functools.partialmethod`" -msgstr "" +msgstr ":class:`functools.partialmethod`" #: ../Doc/library/stdtypes.rst:4993 -#, fuzzy msgid ":class:`os.PathLike`" -msgstr ":class:`tuple`" +msgstr ":class:`os.PathLike`" #: ../Doc/library/stdtypes.rst:4994 -#, fuzzy msgid ":class:`queue.LifoQueue`" -msgstr ":class:`tuple`" +msgstr ":class:`queue.LifoQueue`" #: ../Doc/library/stdtypes.rst:4995 -#, fuzzy msgid ":class:`queue.Queue`" -msgstr ":class:`tuple`" +msgstr ":class:`queue.Queue`" #: ../Doc/library/stdtypes.rst:4996 msgid ":class:`queue.PriorityQueue`" -msgstr "" +msgstr ":class:`queue.PriorityQueue`" #: ../Doc/library/stdtypes.rst:4997 -#, fuzzy msgid ":class:`queue.SimpleQueue`" -msgstr ":class:`tuple`" +msgstr ":class:`queue.SimpleQueue`" #: ../Doc/library/stdtypes.rst:4998 msgid ":ref:`re.Pattern `" @@ -7362,42 +7385,39 @@ msgstr ":ref:`re.Match `" #: ../Doc/library/stdtypes.rst:5000 msgid ":class:`shelve.BsdDbShelf`" -msgstr "" +msgstr ":class:`shelve.BsdDbShelf`" #: ../Doc/library/stdtypes.rst:5001 msgid ":class:`shelve.DbfilenameShelf`" -msgstr "" +msgstr ":class:`shelve.DbfilenameShelf`" #: ../Doc/library/stdtypes.rst:5002 -#, fuzzy msgid ":class:`shelve.Shelf`" -msgstr ":class:`set`" +msgstr ":class:`shelve.Shelf`" #: ../Doc/library/stdtypes.rst:5003 msgid ":class:`types.MappingProxyType`" -msgstr "" +msgstr ":class:`types.MappingProxyType`" #: ../Doc/library/stdtypes.rst:5004 msgid ":class:`weakref.WeakKeyDictionary`" -msgstr "" +msgstr ":class:`weakref.WeakKeyDictionary`" #: ../Doc/library/stdtypes.rst:5005 msgid ":class:`weakref.WeakMethod`" -msgstr "" +msgstr ":class:`weakref.WeakMethod`" #: ../Doc/library/stdtypes.rst:5006 -#, fuzzy msgid ":class:`weakref.WeakSet`" -msgstr ":class:`set`" +msgstr ":class:`weakref.WeakSet`" #: ../Doc/library/stdtypes.rst:5007 msgid ":class:`weakref.WeakValueDictionary`" -msgstr "" +msgstr ":class:`weakref.WeakValueDictionary`" #: ../Doc/library/stdtypes.rst:5012 -#, fuzzy msgid "Special Attributes of ``GenericAlias`` objects" -msgstr "Atributos especiales de Alias Genérico" +msgstr "Atributos especiales de los objetos ``GenericAlias``" #: ../Doc/library/stdtypes.rst:5014 msgid "All parameterized generics implement special read-only attributes." @@ -7410,15 +7430,14 @@ msgid "This attribute points at the non-parameterized generic class::" msgstr "Este atributo apunta a la clase genérica no parametrizada::" #: ../Doc/library/stdtypes.rst:5026 -#, fuzzy msgid "" "This attribute is a :class:`tuple` (possibly of length 1) of generic types " "passed to the original :meth:`~object.__class_getitem__` of the generic " "class::" msgstr "" -"Este atributo es un :class:`tuple` (posiblemente de longitud 1) de tipos " -"genéricos pasados al método original :meth:`__class_getitem__` de un " -"contenedor genérico::" +"Este atributo es una clase :class:`tuple` (posiblemente de longitud 1) de " +"tipos genéricos pasados al método original :meth:`~object.__class_getitem__` " +"de la clase genérica::" #: ../Doc/library/stdtypes.rst:5036 msgid "" @@ -7444,20 +7463,20 @@ msgid "" "A boolean that is true if the alias has been unpacked using the ``*`` " "operator (see :data:`~typing.TypeVarTuple`)." msgstr "" +"Un booleano que es verdadero si el alias ha sido desempaquetado usando el " +"operador ``*`` (véase :data:`~typing.TypeVarTuple`)." #: ../Doc/library/stdtypes.rst:5063 msgid ":pep:`484` - Type Hints" -msgstr "" +msgstr ":pep:`484` - Type Hints" #: ../Doc/library/stdtypes.rst:5063 msgid "Introducing Python's framework for type annotations." -msgstr "" +msgstr "Presentación del marco de trabajo de Python para anotaciones de tipo." #: ../Doc/library/stdtypes.rst:5068 -#, fuzzy msgid ":pep:`585` - Type Hinting Generics In Standard Collections" -msgstr "" -":pep:`585` -- \"Sugerencias de tipo genéricas en las Colecciones Estándar\"" +msgstr ":pep:`585` - Sugerencias de tipo genéricas en colecciones estándar" #: ../Doc/library/stdtypes.rst:5066 msgid "" @@ -7465,18 +7484,26 @@ msgid "" "provided they implement the special class method :meth:`~object." "__class_getitem__`." msgstr "" +"Introducción a la capacidad de parametrizar de forma nativa clases de la " +"biblioteca estándar, siempre que implementen el método de clase especial :" +"meth:`~object.__class_getitem__`." #: ../Doc/library/stdtypes.rst:5071 msgid "" ":ref:`Generics`, :ref:`user-defined generics ` and :" "class:`typing.Generic`" msgstr "" +":ref:`Generics`, :ref:`tipos genéricos definidos por el usuario ` y :class:`typing.Generic`" #: ../Doc/library/stdtypes.rst:5071 msgid "" "Documentation on how to implement generic classes that can be parameterized " "at runtime and understood by static type-checkers." msgstr "" +"Documentación sobre cómo implementar clases genéricas que se pueden " +"parametrizar en tiempo de ejecución y que los validadores estático de tipos " +"pueden entender." #: ../Doc/library/stdtypes.rst:5080 msgid "Union Type" @@ -7491,8 +7518,8 @@ msgid "" "Union`." msgstr "" "Un objeto de conversión contiene el valor de la operación ``|`` (bit a bit " -"o) en varios :ref:`type objects `. Estos tipos están " -"destinados principalmente a :term:`type annotations `. La " +"o) en varios :ref:`objetos de tipo `. Estos tipos están " +"destinados principalmente a :term:`anotaciones de tipo `. La " "expresión de tipo de conversión permite una sintaxis de sugerencia de tipo " "más limpia en comparación con :data:`typing.Union`." @@ -7548,8 +7575,8 @@ msgid "" "However, union objects containing :ref:`parameterized generics ` cannot be used::" msgstr "" -"Sin embargo, los objetos de unión que contienen :ref:`parameterized generics " -"` no se pueden utilizar::" +"Sin embargo, los objetos de unión que contienen :ref:`genéricos " +"parametrizados ` no se pueden utilizar::" #: ../Doc/library/stdtypes.rst:5142 msgid "" @@ -7604,9 +7631,9 @@ 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:" +"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 " +"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)." @@ -7624,9 +7651,9 @@ msgstr "" "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``, " +"__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 :" +"__dict__ = {}``). No se recomienda manipular los contenidos del atributo :" "attr:`~object.__dict__` directamente." #: ../Doc/library/stdtypes.rst:5207 @@ -7657,7 +7684,7 @@ msgid "" "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: " +"única operación posible con un objeto de tipo función es llamarla: " "``func(argument-list)``." #: ../Doc/library/stdtypes.rst:5228 @@ -7688,7 +7715,7 @@ msgid "" "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` " +"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." @@ -7703,13 +7730,15 @@ 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." +"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:`bound method` (también llamado :dfn:`instance method`). " +"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. Llamar ``m(arg-1, " +"arg-2, ..., arg-n)`` es completamente equivalente a llamar ``m.__func__(m." +"__self__, arg-1, arg-2, ..., arg-n)``." #: ../Doc/library/stdtypes.rst:5256 msgid "" @@ -7767,8 +7796,8 @@ msgid "" "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)." +"parámetros a las funciones incorporadas :func:`exec` o :func:`eval` (que " +"también aceptan código Python en forma de cadena de caracteres)." #: ../Doc/library/stdtypes.rst:5313 msgid "Type Objects" @@ -7783,9 +7812,9 @@ msgid "" 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." +"función incorporada :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:5324 msgid "Types are written like this: ````." @@ -7803,7 +7832,7 @@ msgid "" 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 " +"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*." @@ -7822,9 +7851,9 @@ 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:" +"Este objeto es usado a menudo en operaciones de segmentado (véase :ref:" "`slicings`). No soporta ninguna operación especial. Solo existe un único " -"objeto de puntos suspensivos, llamado :const:`Ellipsis` (Un nombre " +"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*." @@ -7868,17 +7897,17 @@ msgid "" "(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 " +"``True``. Se 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 " +"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)." +"valores verdaderos/falsos (véase la sección :ref:`truth` anterior)." #: ../Doc/library/stdtypes.rst:5384 msgid "They are written as ``False`` and ``True``, respectively." -msgstr "Se escriben ``False`` y ``True`` respectivamente." +msgstr "Se escriben ``False`` y ``True``, respectivamente." #: ../Doc/library/stdtypes.rst:5390 msgid "Internal Objects" @@ -7891,7 +7920,7 @@ msgid "" 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*)." +"los objetos de tipo segmento (*slice*)." #: ../Doc/library/stdtypes.rst:5399 msgid "Special Attributes" @@ -7913,7 +7942,7 @@ msgid "" "attributes." msgstr "" "Un diccionario u otro tipo de mapa usado para almacenar los atributos de un " -"objeto (Si son modificables)." +"objeto (si son modificables)." #: ../Doc/library/stdtypes.rst:5414 msgid "The class to which a class instance belongs." @@ -7951,10 +7980,9 @@ 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__`." +"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:5451 msgid "" @@ -7962,14 +7990,14 @@ msgid "" "This method returns a list of all those references still alive. The list is " "in definition order. Example::" msgstr "" -"Cada clase mantiene una lista de referencias débiles a sus subclase " +"Cada clase mantiene una lista de referencias débiles a sus subclases " "inmediatamente anteriores. Este método retorna una lista de todas las " "referencias que todavía estén vivas. La lista está en orden de definición. " "Por ejemplo::" #: ../Doc/library/stdtypes.rst:5462 msgid "Integer string conversion length limitation" -msgstr "" +msgstr "Limitación de longitud de conversión de cadena de tipo entero" #: ../Doc/library/stdtypes.rst:5464 msgid "" @@ -7978,6 +8006,11 @@ msgid "" "decimal or other non-power-of-two number bases. Hexadecimal, octal, and " "binary conversions are unlimited. The limit can be configured." msgstr "" +"CPython tiene un límite global para conversiones entre :class:`int` y :class:" +"`str` para mitigar los ataques de denegación de servicio. Este límite *solo* " +"se aplica a decimales u otras bases numéricas que no sean potencias de dos. " +"Las conversiones hexadecimales, octales y binarias son ilimitadas. Se puede " +"configurar el límite." #: ../Doc/library/stdtypes.rst:5469 msgid "" @@ -7988,12 +8021,23 @@ msgid "" "algorithms for base 10 have sub-quadratic complexity. Converting a large " "value such as ``int('1' * 500_000)`` can take over a second on a fast CPU." msgstr "" +"El tipo :class:`int` en CPython es un número con longitud arbitrario que se " +"almacena en forma binaria (se conoce comúnmente como \"bignum\"). No existe " +"ningún algoritmo que pueda convertir una cadena de caracteres a un entero " +"binario o un entero binario a una cadena de caracteres en tiempo lineal, *a " +"menos* que la base sea una potencia de 2. Incluso los algoritmos más " +"conocidos para la base a 10 tienen una complejidad subcuadrática. Convertir " +"un valor grande como ``int('1' * 500_000)`` puede tomar más de un segundo en " +"una CPU rápida." #: ../Doc/library/stdtypes.rst:5476 msgid "" "Limiting conversion size offers a practical way to avoid `CVE-2020-10735 " "`_." msgstr "" +"Limitar el tamaño de la conversión ofrece una forma práctica para evitar " +"`CVE-2020-10735 `_." #: ../Doc/library/stdtypes.rst:5479 msgid "" @@ -8001,11 +8045,16 @@ msgid "" "output string when a non-linear conversion algorithm would be involved. " "Underscores and the sign are not counted towards the limit." msgstr "" +"El límite se aplica al número de caracteres de dígitos en la cadena de " +"entrada o salida cuando estaría involucrado un algoritmo de conversión no " +"lineal. Los guiones bajos y el signo no se cuentan para el límite." #: ../Doc/library/stdtypes.rst:5483 msgid "" "When an operation would exceed the limit, a :exc:`ValueError` is raised:" msgstr "" +"Cuando una operación excede el límite, se lanza una excepción :exc:" +"`ValueError`:" #: ../Doc/library/stdtypes.rst:5505 msgid "" @@ -8014,38 +8063,43 @@ msgid "" "configured is 640 digits as provided in :data:`sys.int_info." "str_digits_check_threshold `." msgstr "" +"El límite predeterminado es de 4300 dígitos como se indica en :data:`sys." +"int_info.default_max_str_digits `. El límite más bajo que se " +"puede configurar es de 640 dígitos como se indica en :data:`sys.int_info." +"str_digits_check_threshold `." #: ../Doc/library/stdtypes.rst:5510 -#, fuzzy msgid "Verification:" -msgstr "Operación" +msgstr "Verificación:" #: ../Doc/library/stdtypes.rst:5525 msgid "Affected APIs" -msgstr "" +msgstr "APIs afectadas" #: ../Doc/library/stdtypes.rst:5527 msgid "" "The limitation only applies to potentially slow conversions between :class:" "`int` and :class:`str` or :class:`bytes`:" msgstr "" +"La limitación solo se aplica a conversiones potencialmente lentas entre :" +"class:`int` y :class:`str` o :class:`bytes`:" #: ../Doc/library/stdtypes.rst:5530 msgid "``int(string)`` with default base 10." -msgstr "" +msgstr "``int(string)`` con base predeterminada a 10." #: ../Doc/library/stdtypes.rst:5531 msgid "``int(string, base)`` for all bases that are not a power of 2." msgstr "" +"``int(string, base)`` para todas las bases que no sean una potencia de 2." #: ../Doc/library/stdtypes.rst:5532 -#, fuzzy msgid "``str(integer)``." -msgstr "``s.reverse()``" +msgstr "``str(integer)``." #: ../Doc/library/stdtypes.rst:5533 msgid "``repr(integer)``" -msgstr "" +msgstr "``repr(integer)``" #: ../Doc/library/stdtypes.rst:5534 #, python-format @@ -8053,45 +8107,48 @@ msgid "" "any other string conversion to base 10, for example ``f\"{integer}\"``, " "``\"{}\".format(integer)``, or ``b\"%d\" % integer``." msgstr "" +"cualquier otra conversión de cadena a base 10, por ejemplo, " +"``f\"{integer}\"``, ``\"{}\".format(integer)`` o ``b\"%d\" % integer``." #: ../Doc/library/stdtypes.rst:5537 msgid "The limitations do not apply to functions with a linear algorithm:" -msgstr "" +msgstr "Las limitaciones no se aplican a funciones con un algoritmo lineal:" #: ../Doc/library/stdtypes.rst:5539 msgid "``int(string, base)`` with base 2, 4, 8, 16, or 32." -msgstr "" +msgstr "``int(string, base)`` con base 2, 4, 8, 16 o 32." #: ../Doc/library/stdtypes.rst:5540 msgid ":func:`int.from_bytes` and :func:`int.to_bytes`." -msgstr "" +msgstr ":func:`int.from_bytes` y :func:`int.to_bytes`." #: ../Doc/library/stdtypes.rst:5541 msgid ":func:`hex`, :func:`oct`, :func:`bin`." -msgstr "" +msgstr ":func:`hex`, :func:`oct`, :func:`bin`." #: ../Doc/library/stdtypes.rst:5542 msgid ":ref:`formatspec` for hex, octal, and binary numbers." -msgstr "" +msgstr ":ref:`formatspec` para números hexadecimales, octales y binarios." #: ../Doc/library/stdtypes.rst:5543 -#, fuzzy msgid ":class:`str` to :class:`float`." -msgstr "Conjuntos --- :class:`set`, :class:`frozenset`" +msgstr ":class:`str` a :class:`float`." #: ../Doc/library/stdtypes.rst:5544 msgid ":class:`str` to :class:`decimal.Decimal`." -msgstr "" +msgstr ":class:`str` a :class:`decimal.Decimal`." #: ../Doc/library/stdtypes.rst:5547 msgid "Configuring the limit" -msgstr "" +msgstr "Configuración del límite" #: ../Doc/library/stdtypes.rst:5549 msgid "" "Before Python starts up you can use an environment variable or an " "interpreter command line flag to configure the limit:" msgstr "" +"Antes de que se inicie Python, puedes usar una variable de entorno o un " +"indicador de línea de comandos del intérprete para configurar el límite:" #: ../Doc/library/stdtypes.rst:5552 msgid "" @@ -8099,12 +8156,17 @@ msgid "" "to set the limit to 640 or ``PYTHONINTMAXSTRDIGITS=0 python3`` to disable " "the limitation." msgstr "" +":envvar:`PYTHONINTMAXSTRDIGITS`, por ejemplo, ``PYTHONINTMAXSTRDIGITS=640 " +"python3`` para configurar el límite a 640 o ``PYTHONINTMAXSTRDIGITS=0 " +"python3`` para desactivar la limitación." #: ../Doc/library/stdtypes.rst:5555 msgid "" ":option:`-X int_max_str_digits <-X>`, e.g. ``python3 -X " "int_max_str_digits=640``" msgstr "" +":option:`-X int_max_str_digits <-X>`, por ejemplo, ``python3 -X " +"int_max_str_digits=640``" #: ../Doc/library/stdtypes.rst:5557 msgid "" @@ -8114,12 +8176,20 @@ msgid "" "value of *-1* indicates that both were unset, thus a value of :data:`sys." "int_info.default_max_str_digits` was used during initilization." msgstr "" +":data:`sys.flags.int_max_str_digits` contiene el valor de :envvar:" +"`PYTHONINTMAXSTRDIGITS` o :option:`-X int_max_str_digits <-X>`. Si tanto la " +"variable env como la opción ``-X`` están configuradas, la opción ``-X`` " +"tiene prioridad. Un valor de *-1* indica que ambos no están configurados, " +"por lo que se usó un valor de :data:`sys.int_info.default_max_str_digits` " +"durante la inicialización." #: ../Doc/library/stdtypes.rst:5563 msgid "" "From code, you can inspect the current limit and set a new one using these :" "mod:`sys` APIs:" msgstr "" +"Desde el código, puedes inspeccionar el límite actual y configurar uno nuevo " +"al usar estas APIs de :mod:`sys`:" #: ../Doc/library/stdtypes.rst:5566 msgid "" @@ -8127,24 +8197,33 @@ msgid "" "are a getter and setter for the interpreter-wide limit. Subinterpreters have " "their own limit." msgstr "" +":func:`sys.get_int_max_str_digits` y :func:`sys.set_int_max_str_digits` son " +"un getter y un setter para el límite de todo el intérprete. Los " +"subintérpretes tienen su propio límite." #: ../Doc/library/stdtypes.rst:5570 msgid "" "Information about the default and minimum can be found in :attr:`sys." "int_info`:" msgstr "" +"La información sobre el valor predeterminado y mínimo se puede encontrar en :" +"attr:`sys.int_info`:" #: ../Doc/library/stdtypes.rst:5572 msgid "" ":data:`sys.int_info.default_max_str_digits ` is the compiled-" "in default limit." msgstr "" +":data:`sys.int_info.default_max_str_digits ` es el límite " +"predeterminado compilado." #: ../Doc/library/stdtypes.rst:5574 msgid "" ":data:`sys.int_info.str_digits_check_threshold ` is the lowest " "accepted value for the limit (other than 0 which disables it)." msgstr "" +":data:`sys.int_info.str_digits_check_threshold ` es el valor " +"más bajo aceptado para el límite (aparte de 0, que lo desactiva)." #: ../Doc/library/stdtypes.rst:5581 msgid "" @@ -8157,6 +8236,15 @@ msgid "" "exist for the code. A workaround for source that contains such large " "constants is to convert them to ``0x`` hexadecimal form as it has no limit." msgstr "" +"Configurar un límite bajo *puede* generar problemas. Si bien es raro, existe " +"un código que contiene constantes enteras en decimal en su origen que excede " +"el umbral mínimo. Una consecuencia de configurar el límite es que el código " +"fuente de Python que contiene literales enteros decimales más grandes que el " +"límite encontrará un error durante el análisis, generalmente en el momento " +"de inicio o en el momento de importación o incluso en el momento de " +"instalación - en cualquier momento y actualizado, ``.pyc``no existe ya para " +"el código. Una solución para la fuente que contiene constantes tan grandes " +"es convertirlas a la forma hexadecimal ``0x`` ya que no tiene límite." #: ../Doc/library/stdtypes.rst:5590 msgid "" @@ -8165,10 +8253,15 @@ msgid "" "during startup and even during any installation step that may invoke Python " "to precompile ``.py`` sources to ``.pyc`` files." msgstr "" +"Prueba tu aplicación minuciosamente si utilizas un límite bajo. Asegúrate de " +"que tus pruebas se ejecuten con el límite configurado temprano a través del " +"entorno o del indicador para que se aplique durante el inicio e incluso " +"durante cualquier paso de instalación que pueda invocar a Python para " +"precompilar las fuentes ``.py`` a los archivos ``.pyc``." #: ../Doc/library/stdtypes.rst:5596 msgid "Recommended configuration" -msgstr "" +msgstr "Configuración recomendada" #: ../Doc/library/stdtypes.rst:5598 msgid "" @@ -8177,15 +8270,20 @@ msgid "" "limit, set it from your main entry point using Python version agnostic code " "as these APIs were added in security patch releases in versions before 3.11." msgstr "" +"Se espera que el valor predeterminado :data:`sys.int_info." +"default_max_str_digits` sea razonable para la mayoría de las aplicaciones. " +"Si tu aplicación requiere un límite diferente, configúralo desde el punto de " +"entrada principal utilizando el código independiente de la versión de " +"Python, ya que estas APIs se agregaron en versiones de parches de seguridad " +"en versiones anteriores a la 3.11." #: ../Doc/library/stdtypes.rst:5603 -#, fuzzy msgid "Example::" msgstr "Por ejemplo::" #: ../Doc/library/stdtypes.rst:5615 msgid "If you need to disable it entirely, set it to ``0``." -msgstr "" +msgstr "Si necesitas deshabilitarlo por completo, configúralo en ``0``." #: ../Doc/library/stdtypes.rst:5619 msgid "Footnotes" @@ -8197,7 +8295,7 @@ msgid "" "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`)." +"el manual de referencia de Python (:ref:`customization`)." #: ../Doc/library/stdtypes.rst:5623 msgid "" From b9929b4f2b773e6aa5fc7f5fb281f3f1af555ca3 Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Wed, 7 Dec 2022 14:08:18 -0600 Subject: [PATCH 09/10] =?UTF-8?q?Correci=C3=B3n=20l=C3=ADneas=20por=20el?= =?UTF-8?q?=20merge?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/stdtypes.po | 23 +++-------------------- 1 file changed, 3 insertions(+), 20 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index cc823cad7c..b07c5fd8e7 100755 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -1252,13 +1252,8 @@ msgid "" "value ``sys.hash_info.inf``." msgstr "" "Si ``x = m / n`` es un número racional no negativo y ``n`` es divisible por " -<<<<<<< HEAD "``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 " -======= -"``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 " ->>>>>>> origin/3.11 "valor constante definido en ``sys.hash_info.inf``." #: ../Doc/library/stdtypes.rst:730 @@ -2955,15 +2950,9 @@ msgid "" "directly and not copied to a :class:`dict`. This is useful if for example " "``mapping`` is a dict subclass:" msgstr "" -<<<<<<< HEAD -"Similar a ``str.format(**mapping)`, pero se usa ``mapping`` de forma directa " -"y no se copia a un diccionario. Esto es útil si ``mapping`` es, por ejemplo, " -"una instancia de una subclase de :class:`dict`:" -======= -"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`:" ->>>>>>> origin/3.11 +"Similar a ``str.format(**mapping)``, pero se usa ``mapping`` de forma " +"directa y no se copia a un diccionario. Esto es útil si ``mapping`` es, por " +"ejemplo, una instancia de una subclase de :class:`dict`:" #: ../Doc/library/stdtypes.rst:1739 msgid "" @@ -3126,15 +3115,9 @@ msgid "" "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 " -<<<<<<< HEAD "Unicode (véase :mod:`unicodedata`), está clasificado en la categoría general " "``Zs`` (\"Separador, espacio\") o la clase bidireccional es ``WS``, ``B`` o " "``S``." -======= -"Unicode (Véase :mod:`unicodedata`), está clasificado en la categoría general " -"``Zs`` (\"Espacio, separador\") o la clase bidireccional es ``WS``, ``B``, " -"or ``S``." ->>>>>>> origin/3.11 #: ../Doc/library/stdtypes.rst:1848 msgid "" From d31253d24becd6ee685a9f1125f58ebf42f5d29f Mon Sep 17 00:00:00 2001 From: josephLSalgado Date: Wed, 7 Dec 2022 14:17:58 -0600 Subject: [PATCH 10/10] =?UTF-8?q?Correcci=C3=B3n=20errores=20de=20sphinx?= =?UTF-8?q?=20lint?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/stdtypes.po | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/library/stdtypes.po b/library/stdtypes.po index b07c5fd8e7..20bd56a815 100755 --- a/library/stdtypes.po +++ b/library/stdtypes.po @@ -1253,7 +1253,7 @@ msgid "" 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 " +"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:730 @@ -7093,7 +7093,7 @@ msgid "" msgstr "" "Si ``y = re.search(b'bar', b'bar')``, (nótese que ``b`` es para :class:" "`bytes`), ``y`` también será una instancia de ``re.Match``, pero los valores " -"de retorno de ``y.group(0)`` y ``y[0]``serán de tipo :class:`bytes`. En " +"de retorno de ``y.group(0)`` y ``y[0]`` serán de tipo :class:`bytes`. En " "anotaciones de type, representaríamos esta variedad de objetos :ref:`re." "Match ` con ``re.Match[bytes]``." @@ -8242,7 +8242,7 @@ msgstr "" "fuente de Python que contiene literales enteros decimales más grandes que el " "límite encontrará un error durante el análisis, generalmente en el momento " "de inicio o en el momento de importación o incluso en el momento de " -"instalación - en cualquier momento y actualizado, ``.pyc``no existe ya para " +"instalación - en cualquier momento y actualizado, ``.pyc`` no existe ya para " "el código. Una solución para la fuente que contiene constantes tan grandes " "es convertirlas a la forma hexadecimal ``0x`` ya que no tiene límite."