# Copyright (C) 2001-2020, Python Software Foundation

# This file is distributed under the same license as the Python package.

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

# https://mail.python.org/mailman3/lists/docs-es.python.org/

# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to

# get the list of volunteers

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.8\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-02-26 18:44-0300\n"

"PO-Revision-Date: 2026-02-15 16:32-0300\n"

"Last-Translator: Carlos A. Crespo <lvccrespo@gmail.com>\n"

"Language: es\n"

"Language-Team: python-doc-es\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=utf-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Generated-By: Babel 2.18.0\n"

#: ../Doc/reference/datamodel.rst:6

msgid "Data model"

msgstr "Modelo de datos"

#: ../Doc/reference/datamodel.rst:12

msgid "Objects, values and types"

msgstr "Objetos, valores y tipos"

#: ../Doc/reference/datamodel.rst:18

msgid ""

":dfn:`Objects` are Python's abstraction for data. All data in a Python "

"program is represented by objects or by relations between objects. (In a "

"sense, and in conformance to Von Neumann's model of a \"stored program "

"computer\", code is also represented by objects.)"

msgstr ""

":dfn:`Objects` son la abstracción de Python para los datos. Todos los datos "

"en un programa Python están representados por objetos o por relaciones entre "

"objetos. (En cierto sentido y de conformidad con el modelo de Von Neumann de "

"una \"programa almacenado de computadora\", el código también está "

"representado por objetos.)"

#: ../Doc/reference/datamodel.rst:35

msgid ""

"Every object has an identity, a type and a value. An object's *identity* "

"never changes once it has been created; you may think of it as the object's "

"address in memory. The :keyword:`is` operator compares the identity of two "

"objects; the :func:`id` function returns an integer representing its "

"identity."

msgstr ""

"Cada objeto tiene una identidad, un tipo y un valor. La *identidad* de un "

"objeto nunca cambia una vez que ha sido creado; puede pensar en ello como la "

"dirección del objeto en la memoria. El operador :keyword:`is` compara la "

"identidad de dos objetos; la función :func:`id` retorna un número entero que "

"representa su identidad."

#: ../Doc/reference/datamodel.rst:42

msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored."

msgstr ""

"Para CPython, ``id(x)`` es la dirección de memoria donde se almacena ``x``."

#: ../Doc/reference/datamodel.rst:44

msgid ""

"An object's type determines the operations that the object supports (e.g., "

"\"does it have a length?\") and also defines the possible values for objects "

"of that type. The :func:`type` function returns an object's type (which is "

"an object itself). Like its identity, an object's :dfn:`type` is also "

"unchangeable. [#]_"

msgstr ""

"El tipo de un objeto determina las operaciones que admite el objeto (por "

"ejemplo, \"¿tiene una longitud?\") y también define los posibles valores "

"para los objetos de ese tipo. La función :func:`type` retorna el tipo de un "

"objeto (que es un objeto en sí mismo). Al igual que su identidad, también "

"el :dfn:`type` de un objeto es inmutable. [#]_"

#: ../Doc/reference/datamodel.rst:50

msgid ""

"The *value* of some objects can change. Objects whose value can change are "

"said to be *mutable*; objects whose value is unchangeable once they are "

"created are called *immutable*. (The value of an immutable container object "

"that contains a reference to a mutable object can change when the latter's "

"value is changed; however the container is still considered immutable, "

"because the collection of objects it contains cannot be changed. So, "

"immutability is not strictly the same as having an unchangeable value, it is "

"more subtle.) An object's mutability is determined by its type; for "

"instance, numbers, strings and tuples are immutable, while dictionaries and "

"lists are mutable."

msgstr ""

"El *valor* de algunos objetos puede cambiar. Se dice que los objetos cuyo "

"valor puede cambiar son *mutables*; Los objetos cuyo valor no se puede "

"modificar una vez que se crean se denominan *inmutables*. (El valor de un "

"objeto contenedor inmutable que contiene una referencia a un objeto mutable "

"puede cambiar cuando se cambia el valor de este último; sin embargo, el "

"contenedor todavía se considera inmutable, porque la colección de objetos "

"que contiene no se puede cambiar. Por lo tanto, la inmutabilidad no es "

"estrictamente lo mismo que tener un valor inmutable, es más sutil). La "

"mutabilidad de un objeto está determinada por su tipo; por ejemplo, los "

"números, las cadenas de caracteres y las tuplas son inmutables, mientras que "

"los diccionarios y las listas son mutables."

#: ../Doc/reference/datamodel.rst:65

msgid ""

"Objects are never explicitly destroyed; however, when they become "

"unreachable they may be garbage-collected. An implementation is allowed to "

"postpone garbage collection or omit it altogether --- it is a matter of "

"implementation quality how garbage collection is implemented, as long as no "

"objects are collected that are still reachable."

msgstr ""

"Los objetos nunca se destruyen explícitamente; sin embargo, cuando se "

"vuelven inalcanzables, se pueden recolectar basura. Se permite a una "

"implementación posponer la recolección de basura u omitirla por completo; es "

"una cuestión de calidad de la implementación cómo se implementa la "

"recolección de basura, siempre que no se recolecten objetos que todavía sean "

"accesibles."

#: ../Doc/reference/datamodel.rst:73

msgid ""

"CPython currently uses a reference-counting scheme with (optional) delayed "

"detection of cyclically linked garbage, which collects most objects as soon "

"as they become unreachable, but is not guaranteed to collect garbage "

"containing circular references. See the documentation of the :mod:`gc` "

"module for information on controlling the collection of cyclic garbage. "

"Other implementations act differently and CPython may change. Do not depend "

"on immediate finalization of objects when they become unreachable (so you "

"should always close files explicitly)."

msgstr ""

"CPython actualmente utiliza un esquema de conteo de referencias con "

"detección retardada (opcional) de basura enlazada cíclicamente, que "

"recolecta la mayoría de los objetos tan pronto como se vuelven "

"inalcanzables, pero no se garantiza que recolecte basura que contenga "

"referencias circulares. Vea la documentación del módulo :mod:`gc` para "

"información sobre el control de la recolección de basura cíclica. Otras "

"implementaciones actúan de manera diferente y CPython puede cambiar. No "

"dependa de la finalización inmediata de los objetos cuando se vuelvan "

"inalcanzables (por lo que siempre debe cerrar los archivos explícitamente)."

#: ../Doc/reference/datamodel.rst:82

msgid ""

"Note that the use of the implementation's tracing or debugging facilities "

"may keep objects alive that would normally be collectable. Also note that "

"catching an exception with a :keyword:`try`...\\ :keyword:`except` statement "

"may keep objects alive."

msgstr ""

"Tenga en cuenta que el uso de las funciones de rastreo o depuración de la "

"implementación puede mantener activos los objetos que normalmente serían "

"coleccionables. También tenga en cuenta que la captura de una excepción con "

"una sentencia :keyword:`try`...\\ :keyword:`except` puede mantener objetos "

"activos."

#: ../Doc/reference/datamodel.rst:87

msgid ""

"Some objects contain references to \"external\" resources such as open files "

"or windows. It is understood that these resources are freed when the object "

"is garbage-collected, but since garbage collection is not guaranteed to "

"happen, such objects also provide an explicit way to release the external "

"resource, usually a :meth:`!close` method. Programs are strongly recommended "

"to explicitly close such objects. The :keyword:`try`...\\ :keyword:"

"`finally` statement and the :keyword:`with` statement provide convenient "

"ways to do this."

msgstr ""

"Algunos objetos contienen referencias a recursos \"externos\" como archivos "

"abiertos o ventanas. Se entiende que estos recursos se liberan cuando el "

"objeto es eliminado por el recolector de basura, pero como no se garantiza "

"que la recolección de basura suceda, dichos objetos también proporcionan una "

"forma explícita de liberar el recurso externo, generalmente un método :meth:"

"`!close`. Se recomienda encarecidamente a los programas cerrar "

"explícitamente dichos objetos. La declaración :keyword:`try` ... \\ :keyword:"

"`finally` y la declaración :keyword:`with` proporcionan formas convenientes "

"de hacer esto."

#: ../Doc/reference/datamodel.rst:97

msgid ""

"Some objects contain references to other objects; these are called "

"*containers*. Examples of containers are tuples, lists and dictionaries. "

"The references are part of a container's value. In most cases, when we talk "

"about the value of a container, we imply the values, not the identities of "

"the contained objects; however, when we talk about the mutability of a "

"container, only the identities of the immediately contained objects are "

"implied. So, if an immutable container (like a tuple) contains a reference "

"to a mutable object, its value changes if that mutable object is changed."

msgstr ""

"Algunos objetos contienen referencias a otros objetos; estos se llaman "

"*contenedores*. Ejemplos de contenedores son tuplas, listas y diccionarios. "

"Las referencias son parte del valor de un contenedor. En la mayoría de los "

"casos, cuando hablamos del valor de un contenedor, implicamos los valores, "

"no las identidades de los objetos contenidos; sin embargo, cuando hablamos "

"de la mutabilidad de un contenedor, solo se implican las identidades de los "

"objetos contenidos inmediatamente. Entonces, si un contenedor inmutable "

"(como una tupla) contiene una referencia a un objeto mutable, su valor "

"cambia si se cambia ese objeto mutable."

#: ../Doc/reference/datamodel.rst:106

msgid ""

"Types affect almost all aspects of object behavior. Even the importance of "

"object identity is affected in some sense: for immutable types, operations "

"that compute new values may actually return a reference to any existing "

"object with the same type and value, while for mutable objects this is not "

"allowed. For example, after ``a = 1; b = 1``, *a* and *b* may or may not "

"refer to the same object with the value one, depending on the "

"implementation. This is because :class:`int` is an immutable type, so the "

"reference to ``1`` can be reused. This behaviour depends on the "

"implementation used, so should not be relied upon, but is something to be "

"aware of when making use of object identity tests. However, after ``c = []; "

"d = []``, *c* and *d* are guaranteed to refer to two different, unique, "

"newly created empty lists. (Note that ``e = f = []`` assigns the *same* "

"object to both *e* and *f*.)"

msgstr ""

"Los tipos afectan a casi todos los aspectos del comportamiento del objeto. "

"Incluso la importancia de la identidad del objeto se ve afectada en cierto "

"sentido: para los tipos inmutables, las operaciones que calculan nuevos "

"valores en realidad pueden retornar una referencia a cualquier objeto "

"existente con el mismo tipo y valor, mientras que para los objetos mutables "

"esto no está permitido. Por ejemplo, al hacer ``a = 1; b = 1``, *a* y *b* "

"puede o no referirse al mismo objeto con el valor 1, dependiendo de la "

"implementación. Esto se debe a que :class:`int` es un tipo inmutable, así "

"que la referencia a ``1`` se puede reusar. Este comportamiento depende de la "

"implementación utilizada, así que no se debe confiar en ello, pero es algo "

"que hay que tener en cuenta al utilizar pruebas de identidad de objetos. Sin "

"embargo, al hacer ``c = []; d = []``, *c* y *d* se garantiza que se refieren "

"a dos listas vacías diferentes, únicas y recién creadas. (Tenga en cuenta "

"que ``e = f = []`` asigna el *mismo* objeto a ambos *e* y *f*.)"

#: ../Doc/reference/datamodel.rst:124

msgid "The standard type hierarchy"

msgstr "Jerarquía de tipos estándar"

#: ../Doc/reference/datamodel.rst:133

msgid ""

"Below is a list of the types that are built into Python. Extension modules "

"(written in C, Java, or other languages, depending on the implementation) "

"can define additional types. Future versions of Python may add types to the "

"type hierarchy (e.g., rational numbers, efficiently stored arrays of "

"integers, etc.), although such additions will often be provided via the "

"standard library instead."

msgstr ""

"A continuación se muestra una lista de los tipos integrados en Python. Los "

"módulos de extensión (escritos en C, Java u otros lenguajes, dependiendo de "

"la implementación) pueden definir tipos adicionales. Las versiones futuras "

"de Python pueden agregar tipos a la jerarquía de tipos (por ejemplo, números "

"racionales, matrices de enteros almacenados de manera eficiente, etc.), "

"aunque tales adiciones a menudo se proporcionarán a través de la biblioteca "

"estándar."

#: ../Doc/reference/datamodel.rst:144

msgid ""

"Some of the type descriptions below contain a paragraph listing 'special "

"attributes.' These are attributes that provide access to the implementation "

"and are not intended for general use. Their definition may change in the "

"future."

msgstr ""

"Algunas de las descripciones de tipos a continuación contienen un párrafo "

"que enumera 'atributos especiales'. Estos son atributos que proporcionan "

"acceso a la implementación y no están destinados para uso general. Su "

"definición puede cambiar en el futuro."

#: ../Doc/reference/datamodel.rst:150 ../Doc/reference/datamodel.rst:152

msgid "None"

msgstr "None"

#: ../Doc/reference/datamodel.rst:154

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the built-in name ``None``. It is used to "

"signify the absence of a value in many situations, e.g., it is returned from "

"functions that don't explicitly return anything. Its truth value is false."

msgstr ""

"Este tipo tiene un solo valor. Hay un solo objeto con este valor. Se accede "

"a este objeto a través del nombre incorporado ``None``. Se utiliza para "

"indicar la ausencia de un valor en muchas situaciones, por ejemplo, se "

"retorna desde funciones que no retornan nada explícitamente. Su valor de "

"verdad es falso."

#: ../Doc/reference/datamodel.rst:161 ../Doc/reference/datamodel.rst:163

msgid "NotImplemented"

msgstr "NotImplemented"

#: ../Doc/reference/datamodel.rst:165

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the built-in name :data:`NotImplemented`. "

"Numeric methods and rich comparison methods should return this value if they "

"do not implement the operation for the operands provided. (The interpreter "

"will then try the reflected operation, or some other fallback, depending on "

"the operator.) It should not be evaluated in a boolean context."

msgstr ""

"Este tipo tiene un solo valor. Hay un solo objeto con este valor. Se accede "

"a este objeto a través del nombre integrado :data:`NotImplemented`. Los "

"métodos numéricos y los métodos de comparación enriquecidos deben retornar "

"este valor si no implementan la operación para los operandos proporcionados. "

"(El intérprete intentará entonces la operación reflejada, o alguna otra "

"alternativa, dependiendo del operador). No debe evaluarse en un contexto "

"booleano."

#: ../Doc/reference/datamodel.rst:172

msgid "See :ref:`implementing-the-arithmetic-operations` for more details."

msgstr "Vea :ref:`implementing-the-arithmetic-operations` para más detalles."

#: ../Doc/reference/datamodel.rst:176

msgid "Evaluating :data:`NotImplemented` in a boolean context was deprecated."

msgstr ""

#: ../Doc/reference/datamodel.rst:179

#, fuzzy

msgid ""

"Evaluating :data:`NotImplemented` in a boolean context now raises a :exc:"

"`TypeError`. It previously evaluated to :const:`True` and emitted a :exc:"

"`DeprecationWarning` since Python 3.9."

msgstr ""

"La evaluación de :data:`NotImplemented` en un contexto booleano está en "

"desuso. Si bien actualmente se evalúa como verdadero, emitirá un :exc:"

"`DeprecationWarning`. Lanzará un :exc:`TypeError` en una versión futura de "

"Python."

#: ../Doc/reference/datamodel.rst:186 ../Doc/reference/datamodel.rst:187

msgid "Ellipsis"

msgstr "Elipsis"

#: ../Doc/reference/datamodel.rst:191

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the literal ``...`` or the built-in name "

"``Ellipsis``. Its truth value is true."

msgstr ""

"Este tipo tiene un solo valor. Hay un solo objeto con este valor. Se accede "

"a este objeto a través del literal ``...`` o el nombre incorporado "

"``Ellipsis``. Su valor de verdad es verdadero."

#: ../Doc/reference/datamodel.rst:197

msgid ":class:`numbers.Number`"

msgstr ":class:`numbers.Number`"

#: ../Doc/reference/datamodel.rst:201

msgid ""

"These are created by numeric literals and returned as results by arithmetic "

"operators and arithmetic built-in functions. Numeric objects are immutable; "

"once created their value never changes. Python numbers are of course "

"strongly related to mathematical numbers, but subject to the limitations of "

"numerical representation in computers."

msgstr ""

"Estos son creados por literales numéricos y retornados como resultados por "

"operadores aritméticos y funciones aritméticas integradas. Los objetos "

"numéricos son inmutables; una vez creado su valor nunca cambia. Los números "

"de Python están, por supuesto, fuertemente relacionados con los números "

"matemáticos, pero están sujetos a las limitaciones de la representación "

"numérica en las computadoras."

#: ../Doc/reference/datamodel.rst:207

msgid ""

"The string representations of the numeric classes, computed by :meth:"

"`~object.__repr__` and :meth:`~object.__str__`, have the following "

"properties:"

msgstr ""

"Las representaciones de cadena de caracteres de las clases numéricas, "

"calculadas por :meth:`~object.__repr__` y :meth:`~object.__str__`, tienen "

"las siguientes propiedades:"

#: ../Doc/reference/datamodel.rst:211

msgid ""

"They are valid numeric literals which, when passed to their class "

"constructor, produce an object having the value of the original numeric."

msgstr ""

"Son literales numéricos válidos que, cuando se pasan a su constructor de "

"clase, producen un objeto que tiene el valor del numérico original."

#: ../Doc/reference/datamodel.rst:215

msgid "The representation is in base 10, when possible."

msgstr "La representación está en base 10, cuando sea posible."

#: ../Doc/reference/datamodel.rst:217

msgid ""

"Leading zeros, possibly excepting a single zero before a decimal point, are "

"not shown."

msgstr ""

"Los ceros iniciales, posiblemente excepto un solo cero antes de un punto "

"decimal, no se muestran."

#: ../Doc/reference/datamodel.rst:220

msgid ""

"Trailing zeros, possibly excepting a single zero after a decimal point, are "

"not shown."

msgstr ""

"Los ceros finales, posiblemente excepto un solo cero después de un punto "

"decimal, no se muestran."

#: ../Doc/reference/datamodel.rst:223

msgid "A sign is shown only when the number is negative."

msgstr "Solo se muestra un signo cuando el número es negativo."

#: ../Doc/reference/datamodel.rst:225

msgid ""

"Python distinguishes between integers, floating-point numbers, and complex "

"numbers:"

msgstr ""

"Python distingue entre números enteros, números de coma flotante y números "

"complejos:"

#: ../Doc/reference/datamodel.rst:230

msgid ":class:`numbers.Integral`"

msgstr ":class:`numbers.Integral`"

#: ../Doc/reference/datamodel.rst:234

msgid ""

"These represent elements from the mathematical set of integers (positive and "

"negative)."

msgstr ""

"Estos representan elementos del conjunto matemático de números enteros "

"(positivo y negativo)."

#: ../Doc/reference/datamodel.rst:240

msgid ""

"The rules for integer representation are intended to give the most "

"meaningful interpretation of shift and mask operations involving negative "

"integers."

msgstr ""

"Las reglas para la representación de enteros están destinadas a dar la "

"interpretación más significativa de las operaciones de cambio y máscara que "

"involucran enteros negativos."

#: ../Doc/reference/datamodel.rst:243

msgid "There are two types of integers:"

msgstr "Hay dos tipos de números enteros:"

#: ../Doc/reference/datamodel.rst:245

msgid "Integers (:class:`int`)"

msgstr "Enteros (:class:`int`)"

#: ../Doc/reference/datamodel.rst:246

msgid ""

"These represent numbers in an unlimited range, subject to available "

"(virtual) memory only. For the purpose of shift and mask operations, a "

"binary representation is assumed, and negative numbers are represented in a "

"variant of 2's complement which gives the illusion of an infinite string of "

"sign bits extending to the left."

msgstr ""

"Estos representan números en un rango ilimitado, sujetos solo a la memoria "

"(virtual) disponible. Para las operaciones de desplazamiento y máscara, se "

"asume una representación binaria, y los números negativos se representan en "

"una variante del complemento de 2 que da la ilusión de una cadena de "

"caracteres infinita de bits con signo que se extiende hacia la izquierda."

#: ../Doc/reference/datamodel.rst:252

msgid "Booleans (:class:`bool`)"

msgstr "Booleanos (:class:`bool`)"

#: ../Doc/reference/datamodel.rst:258

msgid ""

"These represent the truth values False and True. The two objects "

"representing the values ``False`` and ``True`` are the only Boolean objects. "

"The Boolean type is a subtype of the integer type, and Boolean values behave "

"like the values 0 and 1, respectively, in almost all contexts, the exception "

"being that when converted to a string, the strings ``\"False\"`` or "

"``\"True\"`` are returned, respectively."

msgstr ""

"Estos representan los valores de verdad Falso y Verdadero. Los dos objetos "

"que representan los valores ``False`` y ``True`` son los únicos objetos "

"booleanos. El tipo booleano es un subtipo del tipo entero y los valores "

"booleanos se comportan como los valores 0 y 1 respectivamente, en casi todos "

"los contextos, con la excepción de que cuando se convierten en una cadena de "

"caracteres, las cadenas de caracteres ``\"False\"`` o ``\"True\"`` son "

"retornadas respectivamente."

#: ../Doc/reference/datamodel.rst:268

msgid ":class:`numbers.Real` (:class:`float`)"

msgstr ":class:`numbers.Real` (:class:`float`)"

#: ../Doc/reference/datamodel.rst:276

msgid ""

"These represent machine-level double precision floating-point numbers. You "

"are at the mercy of the underlying machine architecture (and C or Java "

"implementation) for the accepted range and handling of overflow. Python does "

"not support single-precision floating-point numbers; the savings in "

"processor and memory usage that are usually the reason for using these are "

"dwarfed by the overhead of using objects in Python, so there is no reason to "

"complicate the language with two kinds of floating-point numbers."

msgstr ""

"Estos representan números de punto flotante de precisión doble a nivel de "

"máquina. Está a merced de la arquitectura de la máquina subyacente (y la "

"implementación de C o Java) para el rango aceptado y el manejo del "

"desbordamiento. Python no admite números de coma flotante de precisión "

"simple; el ahorro en el uso del procesador y la memoria, que generalmente "

"son la razón para usarlos, se ven reducidos por la sobrecarga del uso de "

"objetos en Python, por lo que no hay razón para complicar el lenguaje con "

"dos tipos de números de coma flotante."

#: ../Doc/reference/datamodel.rst:286

msgid ":class:`numbers.Complex` (:class:`complex`)"

msgstr ":class:`numbers.Complex` (:class:`complex`)"

#: ../Doc/reference/datamodel.rst:292

msgid ""

"These represent complex numbers as a pair of machine-level double precision "

"floating-point numbers. The same caveats apply as for floating-point "

"numbers. The real and imaginary parts of a complex number ``z`` can be "

"retrieved through the read-only attributes ``z.real`` and ``z.imag``."

msgstr ""

"Estos representan números complejos como un par de números de coma flotante "

"de precisión doble a nivel de máquina. Se aplican las mismas advertencias "

"que para los números de coma flotante. Las partes reales e imaginarias de un "

"número complejo ``z`` se pueden obtener a través de los atributos de solo "

"lectura ``z.real`` y ``z.imag``."

#: ../Doc/reference/datamodel.rst:299

msgid "Sequences"

msgstr "Secuencias"

#: ../Doc/reference/datamodel.rst:308

msgid ""

"These represent finite ordered sets indexed by non-negative numbers. The "

"built-in function :func:`len` returns the number of items of a sequence. "

"When the length of a sequence is *n*, the index set contains the numbers 0, "

"1, ..., *n*-1. Item *i* of sequence *a* is selected by ``a[i]``. Some "

"sequences, including built-in sequences, interpret negative subscripts by "

"adding the sequence length. For example, ``a[-2]`` equals ``a[n-2]``, the "

"second to last item of sequence a with length ``n``."

msgstr ""

"Estos representan conjuntos ordenados finitos indexados por números no "

"negativos. La función incorporada :func:`len` retorna el número de elementos "

"de una secuencia. Cuando la longitud de una secuencia es *n*, el conjunto de "

"índices contiene los números 0, 1, ..., *n*-1. El elemento *i* de la "

"secuencia *a* se selecciona mediante ``a[i]``. Algunas secuencias, incluidas "

"las secuencias integradas, interpretan los subíndices negativos sumando la "

"longitud de la secuencia. Por ejemplo, ``a[-2]`` es igual a ``a[n-2]``, el "

"penúltimo elemento de la secuencia a con longitud ``n``."

#: ../Doc/reference/datamodel.rst:318

msgid ""

"Sequences also support slicing: ``a[i:j]`` selects all items with index *k* "

"such that *i* ``<=`` *k* ``<`` *j*. When used as an expression, a slice is "

"a sequence of the same type. The comment above about negative indexes also "

"applies to negative slice positions."

msgstr ""

"Las secuencias también admiten segmentación: ``a[i:j]`` selecciona todos los "

"elementos con índice *k* de modo que *i* ``<=`` *k* ``<`` *j*. Cuando se usa "

"como una expresión, un segmento es una secuencia del mismo tipo. El "

"comentario anterior sobre los índices negativos también aplica a las "

"posiciones de segmento negativas."

#: ../Doc/reference/datamodel.rst:323

msgid ""

"Some sequences also support \"extended slicing\" with a third \"step\" "

"parameter: ``a[i:j:k]`` selects all items of *a* with index *x* where ``x = "

"i + n*k``, *n* ``>=`` ``0`` and *i* ``<=`` *x* ``<`` *j*."

msgstr ""

"Algunas secuencias también admiten \"segmentación extendida\" con un tercer "

"parámetro \"paso\" : ``a[i:j:k]`` selecciona todos los elementos de *a* con "

"índice *x* donde ``x = i + n*k``, *n* ``>=`` ``0`` y *i* ``<=`` *x* ``<`` "

"*j*."

#: ../Doc/reference/datamodel.rst:327

msgid "Sequences are distinguished according to their mutability:"

msgstr "Las secuencias se distinguen según su mutabilidad:"

#: ../Doc/reference/datamodel.rst:331

msgid "Immutable sequences"

msgstr "Secuencias inmutables"

#: ../Doc/reference/datamodel.rst:337

msgid ""

"An object of an immutable sequence type cannot change once it is created. "

"(If the object contains references to other objects, these other objects may "

"be mutable and may be changed; however, the collection of objects directly "

"referenced by an immutable object cannot change.)"

msgstr ""

"Un objeto de un tipo de secuencia inmutable no puede cambiar una vez que se "

"crea. (Si el objeto contiene referencias a otros objetos, estos otros "

"objetos pueden ser mutables y pueden cambiarse; sin embargo, la colección de "

"objetos a los que hace referencia directamente un objeto inmutable no puede "

"cambiar)."

#: ../Doc/reference/datamodel.rst:342

msgid "The following types are immutable sequences:"

msgstr "Los siguientes tipos son secuencias inmutables:"

#: ../Doc/reference/datamodel.rst:347

msgid "Strings"

msgstr "Cadenas de caracteres"

#: ../Doc/reference/datamodel.rst:355

msgid ""

"A string is a sequence of values that represent Unicode code points. All the "

"code points in the range ``U+0000 - U+10FFFF`` can be represented in a "

"string. Python doesn't have a :c:expr:`char` type; instead, every code "

"point in the string is represented as a string object with length ``1``. "

"The built-in function :func:`ord` converts a code point from its string form "

"to an integer in the range ``0 - 10FFFF``; :func:`chr` converts an integer "

"in the range ``0 - 10FFFF`` to the corresponding length ``1`` string "

"object. :meth:`str.encode` can be used to convert a :class:`str` to :class:"

"`bytes` using the given text encoding, and :meth:`bytes.decode` can be used "

"to achieve the opposite."

msgstr ""

"Una cadena es una secuencia de valores que representan puntos de código "

"Unicode. Todos los puntos de código en el rango ``U+0000 - U+10FFFF`` se "

"pueden representar en una cadena. Python no tiene un tipo :c:expr:`char`; en "

"su lugar, cada punto de código de la cadena se representa como un objeto de "

"cadena con una longitud ``1``. La función integrada :func:`ord` convierte un "

"punto de código de su forma de cadena a un entero en el rango ``0 - "

"10FFFF``; :func:`chr` convierte un entero en el rango ``0 - 10FFFF`` al "

"objeto de cadena ``1`` de longitud correspondiente. :meth:`str.encode` se "

"puede usar para convertir un :class:`str` a :class:`bytes` usando la "

"codificación de texto dada, y :meth:`bytes.decode` se puede usar para lograr "

"lo contrario."

#: ../Doc/reference/datamodel.rst:367

msgid "Tuples"

msgstr "Tuplas"

#: ../Doc/reference/datamodel.rst:373

msgid ""

"The items of a tuple are arbitrary Python objects. Tuples of two or more "

"items are formed by comma-separated lists of expressions. A tuple of one "

"item (a 'singleton') can be formed by affixing a comma to an expression (an "

"expression by itself does not create a tuple, since parentheses must be "

"usable for grouping of expressions). An empty tuple can be formed by an "

"empty pair of parentheses."

msgstr ""

"Los elementos de una tupla son objetos arbitrarios de Python. Las tuplas de "

"dos o más elementos están formadas por listas de expresiones separadas por "

"comas. Se puede formar una tupla de un elemento (un 'singleton') al colocar "

"una coma en una expresión (una expresión en sí misma no crea una tupla, ya "

"que los paréntesis deben ser utilizables para agrupar expresiones). Una "

"tupla vacía puede estar formada por un par de paréntesis vacío."

#: ../Doc/reference/datamodel.rst:380

msgid "Bytes"

msgstr "Bytes"

#: ../Doc/reference/datamodel.rst:383

msgid ""

"A bytes object is an immutable array. The items are 8-bit bytes, "

"represented by integers in the range 0 <= x < 256. Bytes literals (like "

"``b'abc'``) and the built-in :func:`bytes` constructor can be used to create "

"bytes objects. Also, bytes objects can be decoded to strings via the :meth:"

"`~bytes.decode` method."

msgstr ""

"Un objeto de bytes es una colección inmutable. Los elementos son bytes de 8 "

"bits, representados por enteros en el rango 0 <= x < 256. Literales de bytes "

"(como ``b'abc'``) y el constructor incorporado :func:`bytes` se puede "

"utilizar para crear objetos de bytes. Además, los objetos de bytes se pueden "

"decodificar en cadenas de caracteres a través del método :meth:`~bytes."

"decode`."

#: ../Doc/reference/datamodel.rst:391

msgid "Mutable sequences"

msgstr "Secuencias mutables"

#: ../Doc/reference/datamodel.rst:400

msgid ""

"Mutable sequences can be changed after they are created. The subscription "

"and slicing notations can be used as the target of assignment and :keyword:"

"`del` (delete) statements."

msgstr ""

"Las secuencias mutables se pueden cambiar después de su creación. Las "

"anotaciones de suscripción y segmentación se pueden utilizar como el "

"objetivo de asignaciones y declaraciones :keyword:`del` (eliminar)."

#: ../Doc/reference/datamodel.rst:408

msgid ""

"The :mod:`collections` and :mod:`array` module provide additional examples "

"of mutable sequence types."

msgstr ""

"Los módulos :mod:`collections` y :mod:`array` proporcionan ejemplos "

"adicionales de tipos de secuencias mutables."

#: ../Doc/reference/datamodel.rst:411

msgid "There are currently two intrinsic mutable sequence types:"

msgstr "Actualmente hay dos tipos intrínsecos de secuencias mutable:"

#: ../Doc/reference/datamodel.rst:413

msgid "Lists"

msgstr "Listas"

#: ../Doc/reference/datamodel.rst:416

msgid ""

"The items of a list are arbitrary Python objects. Lists are formed by "

"placing a comma-separated list of expressions in square brackets. (Note that "

"there are no special cases needed to form lists of length 0 or 1.)"

msgstr ""

"Los elementos de una lista son objetos de Python arbitrarios. Las listas se "

"forman colocando una lista de expresiones separadas por comas entre "

"corchetes. (Tome en cuenta que no hay casos especiales necesarios para "

"formar listas de longitud 0 o 1.)"

#: ../Doc/reference/datamodel.rst:420

msgid "Byte Arrays"

msgstr "Colecciones de bytes"

#: ../Doc/reference/datamodel.rst:423

msgid ""

"A bytearray object is a mutable array. They are created by the built-in :"

"func:`bytearray` constructor. Aside from being mutable (and hence "

"unhashable), byte arrays otherwise provide the same interface and "

"functionality as immutable :class:`bytes` objects."

msgstr ""

"Un objeto bytearray es una colección mutable. Son creados por el constructor "

"incorporado :func:`bytearray`. Además de ser mutables (y, por lo tanto, "

"inquebrantable), las colecciones de bytes proporcionan la misma interfaz y "

"funcionalidad que los objetos inmutables :class:`bytes`."

#: ../Doc/reference/datamodel.rst:430

msgid "Set types"

msgstr "Tipos de conjuntos"

#: ../Doc/reference/datamodel.rst:436

msgid ""

"These represent unordered, finite sets of unique, immutable objects. As "

"such, they cannot be indexed by any subscript. However, they can be iterated "

"over, and the built-in function :func:`len` returns the number of items in a "

"set. Common uses for sets are fast membership testing, removing duplicates "

"from a sequence, and computing mathematical operations such as intersection, "

"union, difference, and symmetric difference."

msgstr ""

"Estos representan conjuntos finitos no ordenados de objetos únicos e "

"inmutables. Como tal, no pueden ser indexados por ningún *subscript*. Sin "

"embargo, pueden repetirse y la función incorporada :func:`len` retorna el "

"número de elementos en un conjunto. Los usos comunes de los conjuntos son "

"pruebas rápidas de membresía, eliminación de duplicados de una secuencia y "

"cálculo de operaciones matemáticas como intersección, unión, diferencia y "

"diferencia simétrica."

#: ../Doc/reference/datamodel.rst:443

msgid ""

"For set elements, the same immutability rules apply as for dictionary keys. "

"Note that numeric types obey the normal rules for numeric comparison: if two "

"numbers compare equal (e.g., ``1`` and ``1.0``), only one of them can be "

"contained in a set."

msgstr ""

"Para elementos del conjunto, se aplican las mismas reglas de inmutabilidad "

"que para las claves de diccionario. Tenga en cuenta que los tipos numéricos "

"obedecen las reglas normales para la comparación numérica: si dos números se "

"comparan igual (por ejemplo, ``1`` y ``1.0``), solo uno de ellos puede estar "

"contenido en un conjunto."

#: ../Doc/reference/datamodel.rst:448

msgid "There are currently two intrinsic set types:"

msgstr "Actualmente hay dos tipos de conjuntos intrínsecos:"

#: ../Doc/reference/datamodel.rst:451

msgid "Sets"

msgstr "Conjuntos"

#: ../Doc/reference/datamodel.rst:454

#, fuzzy

msgid ""

"These represent a mutable set. They are created by the built-in :func:`set` "

"constructor and can be modified afterwards by several methods, such as :meth:"

"`add <frozenset.add>`."

msgstr ""

"Estos representan un conjunto mutable. Son creados por el constructor "

"incorporado :func:`set` y puede ser modificado posteriormente por varios "

"métodos, como :meth:`~set.add`."

#: ../Doc/reference/datamodel.rst:459

msgid "Frozen sets"

msgstr "Conjuntos congelados"

#: ../Doc/reference/datamodel.rst:462

msgid ""

"These represent an immutable set. They are created by the built-in :func:"

"`frozenset` constructor. As a frozenset is immutable and :term:`hashable`, "

"it can be used again as an element of another set, or as a dictionary key."

msgstr ""

"Estos representan un conjunto inmutable. Son creados por el constructor "

"incorporado :func:`frozenset`. Como un conjunto congelado es inmutable y :"

"term:`hashable`, se puede usar nuevamente como un elemento de otro conjunto "

"o como una clave de un diccionario."

#: ../Doc/reference/datamodel.rst:469

msgid "Mappings"

msgstr "Mapeos"

#: ../Doc/reference/datamodel.rst:476

msgid ""

"These represent finite sets of objects indexed by arbitrary index sets. The "

"subscript notation ``a[k]`` selects the item indexed by ``k`` from the "

"mapping ``a``; this can be used in expressions and as the target of "

"assignments or :keyword:`del` statements. The built-in function :func:`len` "

"returns the number of items in a mapping."

msgstr ""

"Estos representan conjuntos finitos de objetos indexados por conjuntos de "

"índices arbitrarios. La notación de subíndice ``a[k]`` selecciona el "

"elemento indexado por ``k`` del mapeo ``a``; esto se puede usar en "

"expresiones y como el objetivo de asignaciones o declaraciones :keyword:"

"`del`. La función incorporada :func:`len` retorna el número de elementos en "

"un mapeo."

#: ../Doc/reference/datamodel.rst:482

msgid "There is currently a single intrinsic mapping type:"

msgstr "Actualmente hay un único tipo de mapeo intrínseco:"

#: ../Doc/reference/datamodel.rst:486

msgid "Dictionaries"

msgstr "Diccionarios"

#: ../Doc/reference/datamodel.rst:490

msgid ""

"These represent finite sets of objects indexed by nearly arbitrary values. "

"The only types of values not acceptable as keys are values containing lists "

"or dictionaries or other mutable types that are compared by value rather "

"than by object identity, the reason being that the efficient implementation "

"of dictionaries requires a key's hash value to remain constant. Numeric "

"types used for keys obey the normal rules for numeric comparison: if two "

"numbers compare equal (e.g., ``1`` and ``1.0``) then they can be used "

"interchangeably to index the same dictionary entry."

msgstr ""

"Estos representan conjuntos finitos de objetos indexados por valores casi "

"arbitrarios. Los únicos tipos de valores no aceptables como claves son "

"valores que contienen listas o diccionarios u otros tipos mutables que se "

"comparan por valor en lugar de por identidad de objeto, la razón es que la "

"implementación eficiente de los diccionarios requiere que el valor *hash* de "

"una clave permanezca constante. Los tipos numéricos utilizados para las "

"claves obedecen las reglas normales para la comparación numérica: si dos "

"números se comparan igual (por ejemplo, ``1`` y ``1.0``) entonces se pueden "

"usar indistintamente para indexar la misma entrada del diccionario."

#: ../Doc/reference/datamodel.rst:499

msgid ""

"Dictionaries preserve insertion order, meaning that keys will be produced in "

"the same order they were added sequentially over the dictionary. Replacing "

"an existing key does not change the order, however removing a key and re-"

"inserting it will add it to the end instead of keeping its old place."

msgstr ""

"Los diccionarios conservan el orden de inserción, lo que significa que las "

"claves se mantendrán en el mismo orden en que se agregaron secuencialmente "

"sobre el diccionario. Reemplazar una clave existente no cambia el orden, sin "

"embargo, eliminar una clave y volver a insertarla la agregará al final en "

"lugar de mantener su lugar anterior."

#: ../Doc/reference/datamodel.rst:504

#, python-brace-format

msgid ""

"Dictionaries are mutable; they can be created by the ``{}`` notation (see "

"section :ref:`dict`)."

msgstr ""

"Los diccionarios son mutables; pueden ser creados por la notación ``{}`` "

"(vea la sección :ref:`dict`)."

#: ../Doc/reference/datamodel.rst:511

msgid ""

"The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide additional "

"examples of mapping types, as does the :mod:`collections` module."

msgstr ""

"Los módulos de extensión :mod:`dbm.ndbm` y :mod:`dbm.gnu` proporcionan "

"ejemplos adicionales de tipos de mapeo, al igual que el módulo :mod:"

"`collections`."

#: ../Doc/reference/datamodel.rst:515

msgid ""

"Dictionaries did not preserve insertion order in versions of Python before "

"3.6. In CPython 3.6, insertion order was preserved, but it was considered an "

"implementation detail at that time rather than a language guarantee."

msgstr ""

"Los diccionarios no conservaban el orden de inserción en las versiones de "

"Python anteriores a 3.6. En CPython 3.6, el orden de inserción se conserva, "

"pero se consideró un detalle de implementación en ese momento en lugar de "

"una garantía de idioma."

#: ../Doc/reference/datamodel.rst:522

msgid "Callable types"

msgstr "Tipos invocables"

#: ../Doc/reference/datamodel.rst:530

msgid ""

"These are the types to which the function call operation (see section :ref:"

"`calls`) can be applied:"

msgstr ""

"Estos son los tipos a los que la operación de llamada de función (vea la "

"sección :ref:`calls`) puede ser aplicado:"

#: ../Doc/reference/datamodel.rst:537

msgid "User-defined functions"

msgstr "Funciones definidas por el usuario"

#: ../Doc/reference/datamodel.rst:544

msgid ""

"A user-defined function object is created by a function definition (see "

"section :ref:`function`). It should be called with an argument list "

"containing the same number of items as the function's formal parameter list."

msgstr ""

"Un objeto función definido por el usuario, es creado por un definición de "

"función (vea la sección :ref:`function`). Debe llamarse con una lista de "

"argumentos que contenga el mismo número de elementos que la lista de "

"parámetros formales de la función."

#: ../Doc/reference/datamodel.rst:550 ../Doc/reference/datamodel.rst:1443

#: ../Doc/reference/datamodel.rst:1644

msgid "Special read-only attributes"

msgstr "Atributos especiales de solo lectura"

#: ../Doc/reference/datamodel.rst:560 ../Doc/reference/datamodel.rst:596

#: ../Doc/reference/datamodel.rst:1198

msgid "Attribute"

msgstr "Atributo"

#: ../Doc/reference/datamodel.rst:561 ../Doc/reference/datamodel.rst:597

#: ../Doc/reference/datamodel.rst:1199

msgid "Meaning"

msgstr "Significado"

#: ../Doc/reference/datamodel.rst:564

msgid ""

"A reference to the :class:`dictionary <dict>` that holds the function's :ref:"

"`global variables <naming>` -- the global namespace of the module in which "

"the function was defined."

msgstr ""

"Una referencia al :class:`dictionary <dict>` que contiene las :ref:`global "

"variables <naming>` de la función -- el espacio de nombres global del módulo "

"en el que se definió la función."

#: ../Doc/reference/datamodel.rst:569

msgid ""

"``None`` or a :class:`tuple` of cells that contain bindings for the names "

"specified in the :attr:`~codeobject.co_freevars` attribute of the "

"function's :attr:`code object <function.__code__>`."

msgstr ""

#: ../Doc/reference/datamodel.rst:573

msgid ""

"A cell object has the attribute ``cell_contents``. This can be used to get "

"the value of the cell, as well as set the value."

msgstr ""

"Un objeto de celda tiene el atributo ``cell_contents``. Esto se puede usar "

"para obtener el valor de la celda, así como para establecer el valor."

#: ../Doc/reference/datamodel.rst:577 ../Doc/reference/datamodel.rst:1692

msgid "Special writable attributes"

msgstr "Atributos especiales de escritura"

#: ../Doc/reference/datamodel.rst:591

msgid "Most of these attributes check the type of the assigned value:"

msgstr "La mayoría de estos atributos verifican el tipo del valor asignado:"

#: ../Doc/reference/datamodel.rst:600

msgid "The function's documentation string, or ``None`` if unavailable."

msgstr ""

"El texto de documentación de la función, o ``None`` si no está disponible."

#: ../Doc/reference/datamodel.rst:603

msgid ""

"The function's name. See also: :attr:`__name__ attributes <definition."

"__name__>`."

msgstr ""

"El nombre de la función. Vea también: :attr:`atributos __name__ <definition."

"__name__>`."

#: ../Doc/reference/datamodel.rst:607

msgid ""

"The function's :term:`qualified name`. See also: :attr:`__qualname__ "

"attributes <definition.__qualname__>`."

msgstr ""

"El :term:`qualified name` de la función. Vea también :attr:`atributos "

"__qualname__ <definition.__qualname__>`."

#: ../Doc/reference/datamodel.rst:613

msgid ""

"The name of the module the function was defined in, or ``None`` if "

"unavailable."

msgstr ""

"El nombre del módulo en el que se definió la función, o ``None`` si no está "

"disponible."

#: ../Doc/reference/datamodel.rst:617

msgid ""

"A :class:`tuple` containing default :term:`parameter` values for those "

"parameters that have defaults, or ``None`` if no parameters have a default "

"value."

msgstr ""

"Una :class:`tuple` que contiene valores de :term:`parameter` predeterminados "

"para aquellos argumentos que tienen valores predeterminados, o ``None`` si "

"ningún parámetro tiene un valor predeterminado."

#: ../Doc/reference/datamodel.rst:622

msgid ""

"The :ref:`code object <code-objects>` representing the compiled function "

"body."

msgstr ""

"El :ref:`objeto de código <code-objects>` que representa el cuerpo de la "

"función compilada."

#: ../Doc/reference/datamodel.rst:626

msgid ""

"The namespace supporting arbitrary function attributes. See also: :attr:"

"`__dict__ attributes <object.__dict__>`."

msgstr ""

"El espacio de nombres que admite atributos de funciones arbitrarias. Vea "

"también: :attr:`atributos __dict__ <object.__dict__>`."

#: ../Doc/reference/datamodel.rst:630

#, fuzzy

msgid ""

"A :class:`dictionary <dict>` containing annotations of :term:`parameters "

"<parameter>`. The keys of the dictionary are the parameter names, and "

"``'return'`` for the return annotation, if provided. See also: :attr:`object."

"__annotations__`."

msgstr ""

"Un :class:`diccionario <dict>` que contiene anotaciones de :term:`parámetros "

"<parameter>`. Las claves del diccionario son los nombres de los parámetros, "

"y ``'return'`` para la anotación de retorno, si se proporciona. Para más "

"información sobre trabajar con este atributo, ve :ref:`annotations-howto`."