# SOME DESCRIPTIVE TITLE.

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

# This file is distributed under the same license as the Python en Español

# package.

# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.

#

msgid ""

msgstr ""

"Project-Id-Version: Python en Español 3.11\n"

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

"POT-Creation-Date: 2023-10-12 19:43+0200\n"

"PO-Revision-Date: 2023-11-13 00:32-0500\n"

"Last-Translator: \n"

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

"Language: es_US\n"

"MIME-Version: 1.0\n"

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

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

"Generated-By: Babel 2.13.0\n"

"X-Generator: Poedit 3.0.1\n"

#: ../Doc/howto/enum.rst:3

msgid "Enum HOWTO"

msgstr "HOWTO - Enum"

#: ../Doc/howto/enum.rst:9

msgid ""

"An :class:`Enum` is a set of symbolic names bound to unique values. They "

"are similar to global variables, but they offer a more useful :func:"

"`repr()`, grouping, type-safety, and a few other features."

msgstr ""

"Un :class:`Enum` es un conjunto de nombres simbólicos vinculados a valores "

"únicos. Son similares a las variables globales, pero ofrecen un :func:"

"`repr()` más útil, agrupación, seguridad de tipos y algunas otras "

"características."

#: ../Doc/howto/enum.rst:13

msgid ""

"They are most useful when you have a variable that can take one of a limited "

"selection of values. For example, the days of the week::"

msgstr ""

"Son más útiles cuando tiene una variable que puede tomar uno de una "

"selección limitada de valores. Por ejemplo, los días de la semana:"

#: ../Doc/howto/enum.rst:26

msgid "Or perhaps the RGB primary colors::"

msgstr "O quizás los colores primarios RGB::"

#: ../Doc/howto/enum.rst:34

msgid ""

"As you can see, creating an :class:`Enum` is as simple as writing a class "

"that inherits from :class:`Enum` itself."

msgstr ""

"Como puede ver, crear un :class:`Enum` es tan simple como escribir una clase "

"que herede del propio :class:`Enum`."

#: ../Doc/howto/enum.rst:37

msgid "Case of Enum Members"

msgstr "Caso de miembros de Enum"

#: ../Doc/howto/enum.rst:39

msgid ""

"Because Enums are used to represent constants, and to help avoid issues with "

"name clashes between mixin-class methods/attributes and enum names, we "

"strongly recommend using UPPER_CASE names for members, and will be using "

"that style in our examples."

msgstr ""

"Dado que las enumeraciones se utilizan para representar constantes y para "

"evitar problemas con conflictos de nombres entre los métodos/atributos de "

"las clases mixin y los nombres de las enumeraciones, recomendamos "

"encarecidamente utilizar nombres en MAYÚSCULAS para los miembros, y "

"utilizaremos ese estilo en nuestros ejemplos."

#: ../Doc/howto/enum.rst:44

msgid ""

"Depending on the nature of the enum a member's value may or may not be "

"important, but either way that value can be used to get the corresponding "

"member::"

msgstr ""

"Dependiendo de la naturaleza de la enumeración, el valor de un miembro puede "

"o no ser importante, pero de cualquier manera ese valor puede usarse para "

"obtener el miembro correspondiente:"

#: ../Doc/howto/enum.rst:51

msgid ""

"As you can see, the ``repr()`` of a member shows the enum name, the member "

"name, and the value. The ``str()`` of a member shows only the enum name and "

"member name::"

msgstr ""

"Como puede ver, el ``repr()`` de un miembro muestra el nombre de "

"enumeración, el nombre del miembro y el valor. El ``str()`` de un miembro "

"muestra solo el nombre de enumeración y el nombre del miembro:"

#: ../Doc/howto/enum.rst:58

msgid "The *type* of an enumeration member is the enum it belongs to::"

msgstr ""

"El *type* de un miembro de la enumeración es la enumeración a la que "

"pertenece:"

#: ../Doc/howto/enum.rst:65

msgid "Enum members have an attribute that contains just their :attr:`name`::"

msgstr ""

"Los miembros de enumeración tienen un atributo que contiene solo su :attr:"

"`name`::"

#: ../Doc/howto/enum.rst:70

msgid "Likewise, they have an attribute for their :attr:`value`::"

msgstr "Asimismo, tienen un atributo para su :attr:`value`:"

#: ../Doc/howto/enum.rst:76

msgid ""

"Unlike many languages that treat enumerations solely as name/value pairs, "

"Python Enums can have behavior added. For example, :class:`datetime.date` "

"has two methods for returning the weekday: :meth:`weekday` and :meth:"

"`isoweekday`. The difference is that one of them counts from 0-6 and the "

"other from 1-7. Rather than keep track of that ourselves we can add a method "

"to the :class:`Weekday` enum to extract the day from the :class:`date` "

"instance and return the matching enum member::"

msgstr ""

"A diferencia de muchos lenguajes que tratan las enumeraciones únicamente "

"como pares de nombre/valor, Python Enums puede tener un comportamiento "

"agregado. Por ejemplo, :class:`datetime.date` tiene dos métodos para "

"retornar el día de la semana: :meth:`weekday` y :meth:`isoweekday`. La "

"diferencia es que uno de ellos cuenta de 0 a 6 y el otro de 1 a 7. En lugar "

"de hacer un seguimiento de eso nosotros mismos, podemos agregar un método a "

"la enumeración :class:`Weekday` para extraer el día de la instancia :class:"

"`date` y retornar el miembro de enumeración coincidente:"

#: ../Doc/howto/enum.rst:88

msgid "The complete :class:`Weekday` enum now looks like this::"

msgstr "La enumeración :class:`Weekday` completa ahora se ve así:"

#: ../Doc/howto/enum.rst:103

msgid "Now we can find out what today is! Observe::"

msgstr "¡Ahora podemos averiguar qué día de la semana es hoy! Observe::"

#: ../Doc/howto/enum.rst:109

msgid ""

"Of course, if you're reading this on some other day, you'll see that day "

"instead."

msgstr ""

"Por supuesto, si estás leyendo esto en otro día, verás ese día en su lugar."

#: ../Doc/howto/enum.rst:111

msgid ""

"This :class:`Weekday` enum is great if our variable only needs one day, but "

"what if we need several? Maybe we're writing a function to plot chores "

"during a week, and don't want to use a :class:`list` -- we could use a "

"different type of :class:`Enum`::"

msgstr ""

"Esta enumeración :class:`Weekday` es excelente si nuestra variable solo "

"necesita un día, pero ¿y si necesitamos varios? Tal vez estamos escribiendo "

"una función para trazar tareas durante una semana y no queremos usar un :"

"class:`list`; podríamos usar un tipo diferente de :class:`Enum`:"

#: ../Doc/howto/enum.rst:126

msgid ""

"We've changed two things: we're inherited from :class:`Flag`, and the values "

"are all powers of 2."

msgstr ""

"Hemos cambiado dos cosas: somos heredados de :class:`Flag` y los valores son "

"todos potencia de 2."

#: ../Doc/howto/enum.rst:129

msgid ""

"Just like the original :class:`Weekday` enum above, we can have a single "

"selection::"

msgstr ""

"Al igual que la enumeración :class:`Weekday` original anterior, podemos "

"tener una sola selección:"

#: ../Doc/howto/enum.rst:135

msgid ""

"But :class:`Flag` also allows us to combine several members into a single "

"variable::"

msgstr ""

"Pero :class:`Flag` también nos permite combinar varios miembros en una sola "

"variable:"

#: ../Doc/howto/enum.rst:142

msgid "You can even iterate over a :class:`Flag` variable::"

msgstr "Incluso puede iterar sobre una variable :class:`Flag`:"

#: ../Doc/howto/enum.rst:149

msgid "Okay, let's get some chores set up::"

msgstr "Bien, preparemos algunas tareas::"

#: ../Doc/howto/enum.rst:157

msgid "And a function to display the chores for a given day::"

msgstr "Y una función para mostrar las tareas de un día determinado:"

#: ../Doc/howto/enum.rst:167

msgid ""

"In cases where the actual values of the members do not matter, you can save "

"yourself some work and use :func:`auto()` for the values::"

msgstr ""

"En los casos en que los valores reales de los miembros no importen, puede "

"ahorrarse algo de trabajo y usar :func:`auto()` para los valores:"

#: ../Doc/howto/enum.rst:186

msgid "Programmatic access to enumeration members and their attributes"

msgstr "Acceso programático a los miembros de la enumeración y sus atributos"

#: ../Doc/howto/enum.rst:188

msgid ""

"Sometimes it's useful to access members in enumerations programmatically (i."

"e. situations where ``Color.RED`` won't do because the exact color is not "

"known at program-writing time). ``Enum`` allows such access::"

msgstr ""

"A veces es útil acceder a los miembros en las enumeraciones "

"programáticamente (es decir, situaciones en las que ``Color.RED`` no "

"funcionará porque no se conoce el color exacto en el momento de escribir el "

"programa). ``Enum`` permite dicho acceso::"

#: ../Doc/howto/enum.rst:197

msgid "If you want to access enum members by *name*, use item access::"

msgstr ""

"Si desea acceder a los miembros de la enumeración por *name*, use el acceso "

"a elementos::"

#: ../Doc/howto/enum.rst:204

msgid "If you have an enum member and need its :attr:`name` or :attr:`value`::"

msgstr ""

"Si tiene un miembro de enumeración y necesita su :attr:`name` o :attr:"

"`value`:"

#: ../Doc/howto/enum.rst:214

msgid "Duplicating enum members and values"

msgstr "Duplicar miembros y valores de enumeración"

#: ../Doc/howto/enum.rst:216

msgid "Having two enum members with the same name is invalid::"

msgstr "Tener dos miembros de enumeración con el mismo nombre no es válido::"

#: ../Doc/howto/enum.rst:226

msgid ""

"However, an enum member can have other names associated with it. Given two "

"entries ``A`` and ``B`` with the same value (and ``A`` defined first), ``B`` "

"is an alias for the member ``A``. By-value lookup of the value of ``A`` "

"will return the member ``A``. By-name lookup of ``A`` will return the "

"member ``A``. By-name lookup of ``B`` will also return the member ``A``::"

msgstr ""

"Sin embargo, un miembro de enumeración puede tener otros nombres asociados. "

"Dadas dos entradas ``A`` y ``B`` con el mismo valor (y ``A`` definido "

"primero), ``B`` es un alias para el miembro ``A``. La búsqueda por valor del "

"valor de ``A`` retornará el miembro ``A``. La búsqueda por nombre de ``A`` "

"retornará el miembro ``A``. La búsqueda por nombre de ``B`` también "

"retornará el miembro ``A``::"

#: ../Doc/howto/enum.rst:247

msgid ""

"Attempting to create a member with the same name as an already defined "

"attribute (another member, a method, etc.) or attempting to create an "

"attribute with the same name as a member is not allowed."

msgstr ""

"No está permitido intentar crear un miembro con el mismo nombre que un "

"atributo ya definido (otro miembro, un método, etc.) o intentar crear un "

"atributo con el mismo nombre que un miembro."

#: ../Doc/howto/enum.rst:253

msgid "Ensuring unique enumeration values"

msgstr "Garantizar valores de enumeración únicos"

#: ../Doc/howto/enum.rst:255

msgid ""

"By default, enumerations allow multiple names as aliases for the same value. "

"When this behavior isn't desired, you can use the :func:`unique` decorator::"

msgstr ""

"De forma predeterminada, las enumeraciones permiten múltiples nombres como "

"alias para el mismo valor. Cuando no se desea este comportamiento, puede "

"usar el decorador :func:`unique`:"

#: ../Doc/howto/enum.rst:272

msgid "Using automatic values"

msgstr "Uso de valores automáticos"

#: ../Doc/howto/enum.rst:274

msgid "If the exact value is unimportant you can use :class:`auto`::"

msgstr "Si el valor exacto no es importante, puede usar :class:`auto`::"

#: ../Doc/howto/enum.rst:285

msgid ""

"The values are chosen by :func:`_generate_next_value_`, which can be "

"overridden::"

msgstr ""

"Los valores son elegidos por :func:`_generate_next_value_`, que se pueden "

"anular:"

#: ../Doc/howto/enum.rst:304

msgid ""

"The :meth:`_generate_next_value_` method must be defined before any members."

msgstr ""

"El método :meth:`_generate_next_value_` debe definirse antes que cualquier "

"miembro."

#: ../Doc/howto/enum.rst:307

msgid "Iteration"

msgstr "Iteración"

#: ../Doc/howto/enum.rst:309

msgid "Iterating over the members of an enum does not provide the aliases::"

msgstr "Iterar sobre los miembros de una enumeración no proporciona los alias:"

#: ../Doc/howto/enum.rst:316

msgid ""

"Note that the aliases ``Shape.ALIAS_FOR_SQUARE`` and ``Weekday.WEEKEND`` "

"aren't shown."

msgstr ""

"Note que los alias ``Shape.ALIAS_FOR_SQUARE`` y ``Weekday.WEEKEND`` no se "

"muestran."

#: ../Doc/howto/enum.rst:318

msgid ""

"The special attribute ``__members__`` is a read-only ordered mapping of "

"names to members. It includes all names defined in the enumeration, "

"including the aliases::"

msgstr ""

"El atributo especial ``__members__`` es una asignación ordenada de solo "

"lectura de nombres a miembros. Incluye todos los nombres definidos en la "

"enumeración, incluidos los alias::"

#: ../Doc/howto/enum.rst:330

msgid ""

"The ``__members__`` attribute can be used for detailed programmatic access "

"to the enumeration members. For example, finding all the aliases::"

msgstr ""

"El atributo ``__members__`` se puede utilizar para el acceso programático "

"detallado a los miembros de la enumeración. Por ejemplo, encontrar todos los "

"alias::"

#: ../Doc/howto/enum.rst:338

msgid ""

"Aliases for flags include values with multiple flags set, such as ``3``, and "

"no flags set, i.e. ``0``."

msgstr ""

"Los alias para las banderas incluyen valores con múltiples banderas "

"establecidas, como ``3``, y ningún conjunto de banderas, es decir, ``0``."

#: ../Doc/howto/enum.rst:343

msgid "Comparisons"

msgstr "Comparaciones"

#: ../Doc/howto/enum.rst:345

msgid "Enumeration members are compared by identity::"

msgstr "Los miembros de la enumeración se comparan por identidad::"

#: ../Doc/howto/enum.rst:354

msgid ""

"Ordered comparisons between enumeration values are *not* supported. Enum "

"members are not integers (but see `IntEnum`_ below)::"

msgstr ""

"Las comparaciones ordenadas entre valores de enumeración son compatibles con "

"*not*. Los miembros de la enumeración no son números enteros (pero consulte "

"`IntEnum`_ a continuación):"

#: ../Doc/howto/enum.rst:362

msgid "Equality comparisons are defined though::"

msgstr "Las comparaciones de igualdad se definen aunque:"

#: ../Doc/howto/enum.rst:371

msgid ""

"Comparisons against non-enumeration values will always compare not equal "

"(again, :class:`IntEnum` was explicitly designed to behave differently, see "

"below)::"

msgstr ""

"Las comparaciones con valores que no son de enumeración siempre comparan no "

"iguales (nuevamente, :class:`IntEnum` se diseñó explícitamente para "

"comportarse de manera diferente, consulte a continuación):"

#: ../Doc/howto/enum.rst:380

msgid ""

"It is possible to reload modules -- if a reloaded module contains enums, "

"they will be recreated, and the new members may not compare identical/equal "

"to the original members."

msgstr ""

"Es posible recargar módulos; si un módulo recargado contiene enumeraciones, "

"estas se crearán de nuevo y los nuevos miembros pueden no compararse como "

"idénticos/iguales a los miembros originales."

#: ../Doc/howto/enum.rst:385

msgid "Allowed members and attributes of enumerations"

msgstr "Miembros permitidos y atributos de enumeraciones"

#: ../Doc/howto/enum.rst:387

msgid ""

"Most of the examples above use integers for enumeration values. Using "

"integers is short and handy (and provided by default by the `Functional "

"API`_), but not strictly enforced. In the vast majority of use-cases, one "

"doesn't care what the actual value of an enumeration is. But if the value "

"*is* important, enumerations can have arbitrary values."

msgstr ""

"La mayoría de los ejemplos anteriores usan números enteros para los valores "

"de enumeración. El uso de números enteros es corto y práctico (y "

"proporcionado por defecto por el `Functional API`_), pero no se aplica "

"estrictamente. En la gran mayoría de los casos de uso, a uno no le importa "

"cuál es el valor real de una enumeración. Pero si el valor *is* es "

"importante, las enumeraciones pueden tener valores arbitrarios."

#: ../Doc/howto/enum.rst:393

msgid ""

"Enumerations are Python classes, and can have methods and special methods as "

"usual. If we have this enumeration::"

msgstr ""

"Las enumeraciones son clases de Python y pueden tener métodos y métodos "

"especiales como de costumbre. Si tenemos esta enumeración:"

#: ../Doc/howto/enum.rst:413

msgid "Then::"

msgstr "Después::"

#: ../Doc/howto/enum.rst:422

msgid ""

"The rules for what is allowed are as follows: names that start and end with "

"a single underscore are reserved by enum and cannot be used; all other "

"attributes defined within an enumeration will become members of this "

"enumeration, with the exception of special methods (:meth:`__str__`, :meth:"

"`__add__`, etc.), descriptors (methods are also descriptors), and variable "

"names listed in :attr:`_ignore_`."

msgstr ""

"Las reglas para lo que está permitido son las siguientes: los nombres que "

"comienzan y terminan con un solo guión bajo están reservados por enumeración "

"y no se pueden usar; todos los demás atributos definidos dentro de una "

"enumeración se convertirán en miembros de esta enumeración, con la excepción "

"de métodos especiales (:meth:`__str__`, :meth:`__add__`, etc.), descriptores "

"(los métodos también son descriptores) y nombres de variables enumerados en :"

"attr:`_ignore_`."

#: ../Doc/howto/enum.rst:429

msgid ""

"Note: if your enumeration defines :meth:`__new__` and/or :meth:`__init__`, "

"any value(s) given to the enum member will be passed into those methods. See "

"`Planet`_ for an example."

msgstr ""

"Nota: si su enumeración define :meth:`__new__` y/o :meth:`__init__`, "

"cualquier valor(es) dado(s) al miembro de la enumeración se pasará a esos "

"métodos. Consulte `Planet`_ para ver un ejemplo."

#: ../Doc/howto/enum.rst:435

msgid ""

"The :meth:`__new__` method, if defined, is used during creation of the Enum "

"members; it is then replaced by Enum's :meth:`__new__` which is used after "

"class creation for lookup of existing members. See :ref:`new-vs-init` for "

"more details."

msgstr ""

"El método :meth:`__new__`, si está definido, se usa durante la creación de "

"los miembros de Enum; luego se reemplaza por :meth:`__new__` de Enum, que se "

"usa después de la creación de clases para buscar miembros existentes. "

"Consulte :ref:`new-vs-init` para obtener más detalles."

#: ../Doc/howto/enum.rst:442

msgid "Restricted Enum subclassing"

msgstr "Subclases de Enum restringidas"

#: ../Doc/howto/enum.rst:444

msgid ""

"A new :class:`Enum` class must have one base enum class, up to one concrete "

"data type, and as many :class:`object`-based mixin classes as needed. The "

"order of these base classes is::"

msgstr ""

"Una nueva clase :class:`Enum` debe tener una clase de enumeración base, "

"hasta un tipo de datos concreto y tantas clases mixtas basadas en :class:"

"`object` como sea necesario. El orden de estas clases base es:"

#: ../Doc/howto/enum.rst:451

msgid ""

"Also, subclassing an enumeration is allowed only if the enumeration does not "

"define any members. So this is forbidden::"

msgstr ""

"Además, la subclasificación de una enumeración solo se permite si la "

"enumeración no define ningún miembro. Así que esto está prohibido::"

#: ../Doc/howto/enum.rst:461

msgid "But this is allowed::"

msgstr "Pero esto está permitido:"

#: ../Doc/howto/enum.rst:472

msgid ""

"Allowing subclassing of enums that define members would lead to a violation "

"of some important invariants of types and instances. On the other hand, it "

"makes sense to allow sharing some common behavior between a group of "

"enumerations. (See `OrderedEnum`_ for an example.)"

msgstr ""

"Permitir la subclasificación de enumeraciones que definen miembros "

"conduciría a una violación de algunas invariantes importantes de tipos e "

"instancias. Por otro lado, tiene sentido permitir compartir algún "

"comportamiento común entre un grupo de enumeraciones. (Consulte "

"`OrderedEnum`_ para ver un ejemplo)."

#: ../Doc/howto/enum.rst:481

msgid "Dataclass support"

msgstr "Soporte de Dataclass"

#: ../Doc/howto/enum.rst:483

msgid ""

"When inheriting from a :class:`~dataclasses.dataclass`, the :meth:`~Enum."

"__repr__` omits the inherited class' name. For example::"

msgstr ""

"Cuando se hereda de una :class:`~dataclasses.dataclass`, el :meth:`~Enum."

"__repr__` omite el nombre de la clase heredada. Por ejemplo::"

#: ../Doc/howto/enum.rst:499

msgid ""

"Use the :func:`!dataclass` argument ``repr=False`` to use the standard :func:"

"`repr`."

msgstr ""

"Utilice el argumento ``repr=False`` de :func:`!dataclass` para utilizar el :"

"func:`repr` estándar."

#: ../Doc/howto/enum.rst:502

msgid ""

"Only the dataclass fields are shown in the value area, not the dataclass' "

"name."

msgstr ""

"Solo se muestran los campos de la dataclass en el área de valores, no el "

"nombre de la dataclass."

#: ../Doc/howto/enum.rst:508

msgid "Pickling"

msgstr "Serialización (Pickling)"

#: ../Doc/howto/enum.rst:510

msgid "Enumerations can be pickled and unpickled::"

msgstr "Las enumeraciones se pueden serializar y deserializar:"

#: ../Doc/howto/enum.rst:517

msgid ""

"The usual restrictions for pickling apply: picklable enums must be defined "

"in the top level of a module, since unpickling requires them to be "

"importable from that module."

msgstr ""

"Se aplican las restricciones habituales para el *pickling*: las "

"enumeraciones serializables deben definirse en el nivel superior de un "

"módulo, ya que el decapado requiere que se puedan importar desde ese módulo."

#: ../Doc/howto/enum.rst:523

msgid ""

"With pickle protocol version 4 it is possible to easily pickle enums nested "

"in other classes."

msgstr ""

"Con la versión 4 del protocolo pickle es posible deserializar fácilmente "

"enumeraciones anidadas en otras clases."

#: ../Doc/howto/enum.rst:526

msgid ""

"It is possible to modify how enum members are pickled/unpickled by defining :"

"meth:`__reduce_ex__` in the enumeration class. The default method is by-"

"value, but enums with complicated values may want to use by-name::"

msgstr ""

"Es posible modificar la forma en que los miembros de la enumeración se "

"serialicen / deserialicen definiendo :meth:`__reduce_ex__` en la clase de "

"enumeración. El método predeterminado es por valor, pero las enumeraciones "

"con valores complicados pueden querer utilizar por nombre::"

#: ../Doc/howto/enum.rst:535

msgid ""

"Using by-name for flags is not recommended, as unnamed aliases will not "

"unpickle."

msgstr ""

"No se recomienda usar banderas por nombre , ya que los alias sin nombre no "

"se desempaquetarán."

#: ../Doc/howto/enum.rst:540

msgid "Functional API"

msgstr "API funcional"

#: ../Doc/howto/enum.rst:542

msgid ""

"The :class:`Enum` class is callable, providing the following functional API::"

msgstr ""

"Se puede llamar a la clase :class:`Enum`, que proporciona la siguiente API "

"funcional:"

#: ../Doc/howto/enum.rst:552

msgid ""

"The semantics of this API resemble :class:`~collections.namedtuple`. The "

"first argument of the call to :class:`Enum` is the name of the enumeration."

msgstr ""

"La semántica de esta API se asemeja a :class:`~collections.namedtuple`. El "

"primer argumento de la llamada a :class:`Enum` es el nombre de la "

"enumeración."

#: ../Doc/howto/enum.rst:555

msgid ""

"The second argument is the *source* of enumeration member names. It can be "

"a whitespace-separated string of names, a sequence of names, a sequence of 2-"

"tuples with key/value pairs, or a mapping (e.g. dictionary) of names to "

"values. The last two options enable assigning arbitrary values to "

"enumerations; the others auto-assign increasing integers starting with 1 "

"(use the ``start`` parameter to specify a different starting value). A new "

"class derived from :class:`Enum` is returned. In other words, the above "

"assignment to :class:`Animal` is equivalent to::"

msgstr ""

"El segundo argumento es el *source* de nombres de miembros de enumeración. "

"Puede ser una cadena de nombres separados por espacios en blanco, una "

"secuencia de nombres, una secuencia de 2 tuplas con pares clave/valor o una "

"asignación (por ejemplo, un diccionario) de nombres a valores. Las dos "

"últimas opciones permiten asignar valores arbitrarios a las enumeraciones; "

"los otros asignan automáticamente números enteros crecientes que comienzan "

"con 1 (use el parámetro ``start`` para especificar un valor inicial "

"diferente). Se retorna una nueva clase derivada de :class:`Enum`. En otras "

"palabras, la asignación anterior a :class:`Animal` es equivalente a:"

#: ../Doc/howto/enum.rst:571

msgid ""

"The reason for defaulting to ``1`` as the starting number and not ``0`` is "

"that ``0`` is ``False`` in a boolean sense, but by default enum members all "

"evaluate to ``True``."

msgstr ""

"La razón por la que se toma por defecto ``1`` como el número inicial y no "

"``0`` es que ``0`` es ``False`` en un sentido booleano, pero por defecto "

"todos los miembros de la enumeración se evalúan como ``True``."

#: ../Doc/howto/enum.rst:575

msgid ""

"Pickling enums created with the functional API can be tricky as frame stack "

"implementation details are used to try and figure out which module the "

"enumeration is being created in (e.g. it will fail if you use a utility "

"function in a separate module, and also may not work on IronPython or "

"Jython). The solution is to specify the module name explicitly as follows::"

msgstr ""

"Deserializar las enumeraciones creadas con la API funcional puede ser "

"complicado, ya que los detalles de implementación de la pila de marcos se "

"usan para tratar de averiguar en qué módulo se está creando la enumeración "

"(por ejemplo, fallará si usa una función de utilidad en un módulo separado, "

"y también puede no trabajar en IronPython o Jython). La solución es "

"especificar el nombre del módulo explícitamente de la siguiente manera:"

#: ../Doc/howto/enum.rst:585

msgid ""

"If ``module`` is not supplied, and Enum cannot determine what it is, the new "

"Enum members will not be unpicklable; to keep errors closer to the source, "

"pickling will be disabled."

msgstr ""

"Si no se proporciona ``module`` y Enum no puede determinar de qué se trata, "

"los nuevos miembros de Enum no serán seleccionables; para mantener los "

"errores más cerca de la fuente, se desactivará el decapado."

#: ../Doc/howto/enum.rst:589

msgid ""

"The new pickle protocol 4 also, in some circumstances, relies on :attr:"

"`~definition.__qualname__` being set to the location where pickle will be "

"able to find the class. For example, if the class was made available in "

"class SomeData in the global scope::"

msgstr ""

"El nuevo protocolo pickle 4 también, en algunas circunstancias, depende de "

"que :attr:`~definition.__qualname__` se establezca en la ubicación donde "

"pickle podrá encontrar la clase. Por ejemplo, si la clase estuvo disponible "

"en la clase SomeData en el ámbito global:"

#: ../Doc/howto/enum.rst:596

msgid "The complete signature is::"

msgstr "La firma completa es::"

#: ../Doc/howto/enum.rst

msgid "value"

msgstr "value"

#: ../Doc/howto/enum.rst:608

msgid "What the new enum class will record as its name."

msgstr "Lo que la nueva clase de enumeración registrará como su nombre."

#: ../Doc/howto/enum.rst

msgid "names"

msgstr "names"

#: ../Doc/howto/enum.rst:610

msgid ""

"The enum members. This can be a whitespace- or comma-separated string "

"(values will start at 1 unless otherwise specified)::"

msgstr ""

"Los miembros de la enumeración. Puede ser una cadena separada por comas o "

"espacios en blanco (los valores comenzarán en 1 a menos que se especifique "

"lo contrario):"

#: ../Doc/howto/enum.rst:615

msgid "or an iterator of names::"

msgstr "o un iterador de nombres::"

#: ../Doc/howto/enum.rst:619

msgid "or an iterator of (name, value) pairs::"

msgstr "o un iterador de (nombre, valor) pares::"

#: ../Doc/howto/enum.rst:623

msgid "or a mapping::"

msgstr "o un mapeo::"

#: ../Doc/howto/enum.rst

msgid "module"

msgstr "module"

#: ../Doc/howto/enum.rst:627

msgid "name of module where new enum class can be found."

msgstr ""

"nombre del módulo donde se puede encontrar la nueva clase de enumeración."

#: ../Doc/howto/enum.rst

msgid "qualname"

msgstr "qualname"

#: ../Doc/howto/enum.rst:629

msgid "where in module new enum class can be found."

msgstr "donde en el módulo se puede encontrar la nueva clase de enumeración."

#: ../Doc/howto/enum.rst

msgid "type"

msgstr "type"

#: ../Doc/howto/enum.rst:631

msgid "type to mix in to new enum class."

msgstr "tipo para mezclar en la nueva clase de enumeración."

#: ../Doc/howto/enum.rst

msgid "start"

msgstr "start"

#: ../Doc/howto/enum.rst:633

msgid "number to start counting at if only names are passed in."

msgstr "número para comenzar a contar si solo se pasan nombres."

#: ../Doc/howto/enum.rst:635

msgid "The *start* parameter was added."

msgstr "Se agregó el parámetro *start*."

#: ../Doc/howto/enum.rst:640

msgid "Derived Enumerations"

msgstr "Enumeraciones derivadas"

#: ../Doc/howto/enum.rst:643

msgid "IntEnum"

msgstr "IntEnum"

#: ../Doc/howto/enum.rst:645

msgid ""

"The first variation of :class:`Enum` that is provided is also a subclass of :"

"class:`int`. Members of an :class:`IntEnum` can be compared to integers; by "

"extension, integer enumerations of different types can also be compared to "

"each other::"

msgstr ""

"La primera variación de :class:`Enum` que se proporciona también es una "

"subclase de :class:`int`. Los miembros de un :class:`IntEnum` se pueden "

"comparar con números enteros; por extensión, las enumeraciones enteras de "

"diferentes tipos también se pueden comparar entre sí:"

#: ../Doc/howto/enum.rst:666

msgid ""

"However, they still can't be compared to standard :class:`Enum` "

"enumerations::"

msgstr ""

"Sin embargo, aún no se pueden comparar con las enumeraciones :class:`Enum` "

"estándar:"

#: ../Doc/howto/enum.rst:679

msgid ""

":class:`IntEnum` values behave like integers in other ways you'd expect::"

msgstr ""

"Los valores :class:`IntEnum` se comportan como números enteros en otras "

"formas que esperaría:"

#: ../Doc/howto/enum.rst:690

msgid "StrEnum"

msgstr "StrEnum"

#: ../Doc/howto/enum.rst:692

msgid ""

"The second variation of :class:`Enum` that is provided is also a subclass "

"of :class:`str`. Members of a :class:`StrEnum` can be compared to strings; "

"by extension, string enumerations of different types can also be compared to "

"each other."

msgstr ""

"La segunda variación de :class:`Enum` que se proporciona también es una "

"subclase de :class:`str`. Los miembros de un :class:`StrEnum` se pueden "

"comparar con cadenas; por extensión, las enumeraciones de cadenas de "

"diferentes tipos también se pueden comparar entre sí."

#: ../Doc/howto/enum.rst:701

msgid "IntFlag"

msgstr "IntFlag"

#: ../Doc/howto/enum.rst:703

msgid ""

"The next variation of :class:`Enum` provided, :class:`IntFlag`, is also "

"based on :class:`int`. The difference being :class:`IntFlag` members can be "

"combined using the bitwise operators (&, \\|, ^, ~) and the result is still "

"an :class:`IntFlag` member, if possible. Like :class:`IntEnum`, :class:"

"`IntFlag` members are also integers and can be used wherever an :class:`int` "

"is used."

msgstr ""

"La siguiente variación de :class:`Enum` proporcionada, :class:`IntFlag`, "

"también se basa en :class:`int`. La diferencia es que los miembros :class:"

"`IntFlag` se pueden combinar usando los operadores bit a bit (&, \\|, ^, ~) "

"y el resultado sigue siendo un miembro :class:`IntFlag`, si es posible. Al "

"igual que :class:`IntEnum`, los miembros :class:`IntFlag` también son "

"números enteros y se pueden utilizar siempre que se utilice un :class:`int`."

#: ../Doc/howto/enum.rst:711

msgid ""

"Any operation on an :class:`IntFlag` member besides the bit-wise operations "

"will lose the :class:`IntFlag` membership."

msgstr ""

"Cualquier operación en un miembro :class:`IntFlag` además de las operaciones "

"bit a bit perderá la pertenencia a :class:`IntFlag`."

#: ../Doc/howto/enum.rst:714

msgid ""

"Bit-wise operations that result in invalid :class:`IntFlag` values will lose "

"the :class:`IntFlag` membership. See :class:`FlagBoundary` for details."

msgstr ""

"Las operaciones bit a bit que den como resultado valores :class:`IntFlag` no "

"válidos perderán la pertenencia a :class:`IntFlag`. Ver :class:"

"`FlagBoundary` para más detalles."

#: ../Doc/howto/enum.rst:721

msgid "Sample :class:`IntFlag` class::"

msgstr "Ejemplo de clase :class:`IntFlag`::"

#: ../Doc/howto/enum.rst:737

msgid "It is also possible to name the combinations::"

msgstr "También es posible nombrar las combinaciones:"

#: ../Doc/howto/enum.rst:754

msgid ""

"Named combinations are considered aliases. Aliases do not show up during "

"iteration, but can be returned from by-value lookups."

msgstr ""

"Las combinaciones con nombre se consideran alias. Los alias no aparecen "

"durante la iteración, pero se pueden devolver a partir de búsquedas por "

"valor."

#: ../Doc/howto/enum.rst:759

msgid ""

"Another important difference between :class:`IntFlag` and :class:`Enum` is "

"that if no flags are set (the value is 0), its boolean evaluation is :data:"

"`False`::"

msgstr ""

"Otra diferencia importante entre :class:`IntFlag` y :class:`Enum` es que si "

"no se establecen banderas (el valor es 0), su evaluación booleana es :data:"

"`False`::"

#: ../Doc/howto/enum.rst:767

msgid ""

"Because :class:`IntFlag` members are also subclasses of :class:`int` they "

"can be combined with them (but may lose :class:`IntFlag` membership::"

msgstr ""

"Debido a que los miembros :class:`IntFlag` también son subclases de :class:"

"`int`, se pueden combinar con ellos (pero pueden perder la membresía :class:"

"`IntFlag`::"

#: ../Doc/howto/enum.rst:778

msgid ""

"The negation operator, ``~``, always returns an :class:`IntFlag` member with "

"a positive value::"

msgstr ""

"El operador de negación, ``~``, siempre retorna un miembro :class:`IntFlag` "

"con un valor positivo:"

#: ../Doc/howto/enum.rst:784

msgid ":class:`IntFlag` members can also be iterated over::"

msgstr "Los miembros :class:`IntFlag` también se pueden iterar sobre:"

#: ../Doc/howto/enum.rst:793

msgid "Flag"

msgstr "Bandera"

#: ../Doc/howto/enum.rst:795

msgid ""

"The last variation is :class:`Flag`. Like :class:`IntFlag`, :class:`Flag` "

"members can be combined using the bitwise operators (&, \\|, ^, ~). Unlike :"

"class:`IntFlag`, they cannot be combined with, nor compared against, any "

"other :class:`Flag` enumeration, nor :class:`int`. While it is possible to "

"specify the values directly it is recommended to use :class:`auto` as the "

"value and let :class:`Flag` select an appropriate value."

msgstr ""

"La última variación es :class:`Flag`. Al igual que :class:`IntFlag`, los "

"miembros de :class:`Flag` se pueden combinar mediante los operadores bit a "

"bit (&, \\|, ^, ~). A diferencia de :class:`IntFlag`, no se pueden combinar "

"ni comparar con ninguna otra enumeración :class:`Flag` ni con :class:`int`. "

"Si bien es posible especificar los valores directamente, se recomienda usar :"

"class:`auto` como valor y dejar que :class:`Flag` seleccione un valor "

"apropiado."

#: ../Doc/howto/enum.rst:804

msgid ""

"Like :class:`IntFlag`, if a combination of :class:`Flag` members results in "

"no flags being set, the boolean evaluation is :data:`False`::"

msgstr ""

"Al igual que :class:`IntFlag`, si una combinación de miembros :class:`Flag` "

"da como resultado que no se establezcan indicadores, la evaluación booleana "

"es :data:`False`::"

#: ../Doc/howto/enum.rst:818

msgid ""

"Individual flags should have values that are powers of two (1, 2, 4, "

"8, ...), while combinations of flags will not::"

msgstr ""

"Las banderas individuales deben tener valores que sean potencias de dos (1, "

"2, 4, 8, ...), mientras que las combinaciones de banderas no::"

#: ../Doc/howto/enum.rst:830

msgid ""

"Giving a name to the \"no flags set\" condition does not change its boolean "

"value::"

msgstr ""

"Dar un nombre a la condición \"sin banderas establecidas\" no cambia su "

"valor booleano:"

#: ../Doc/howto/enum.rst:844

msgid ":class:`Flag` members can also be iterated over::"

msgstr "Los miembros :class:`Flag` también se pueden iterar sobre:"

#: ../Doc/howto/enum.rst:854

msgid ""

"For the majority of new code, :class:`Enum` and :class:`Flag` are strongly "

"recommended, since :class:`IntEnum` and :class:`IntFlag` break some semantic "

"promises of an enumeration (by being comparable to integers, and thus by "

"transitivity to other unrelated enumerations). :class:`IntEnum` and :class:"

"`IntFlag` should be used only in cases where :class:`Enum` and :class:`Flag` "

"will not do; for example, when integer constants are replaced with "

"enumerations, or for interoperability with other systems."

msgstr ""

"Para la mayoría del código nuevo, se recomienda encarecidamente :class:"

"`Enum` y :class:`Flag`, ya que :class:`IntEnum` y :class:`IntFlag` rompen "

"algunas promesas semánticas de una enumeración (al ser comparables con los "

"números enteros y, por lo tanto, por la transitividad a otras enumeraciones "

"no relacionadas). :class:`IntEnum` y :class:`IntFlag` deben usarse solo en "

"los casos en que :class:`Enum` y :class:`Flag` no sirvan; por ejemplo, "

"cuando las constantes enteras se reemplazan con enumeraciones, o para la "

"interoperabilidad con otros sistemas."

#: ../Doc/howto/enum.rst:864

msgid "Others"

msgstr "Otros"

#: ../Doc/howto/enum.rst:866

msgid ""

"While :class:`IntEnum` is part of the :mod:`enum` module, it would be very "

"simple to implement independently::"

msgstr ""

"Si bien :class:`IntEnum` es parte del módulo :mod:`enum`, sería muy simple "

"de implementar de forma independiente:"

#: ../Doc/howto/enum.rst:872

msgid ""

"This demonstrates how similar derived enumerations can be defined; for "

"example a :class:`FloatEnum` that mixes in :class:`float` instead of :class:"

"`int`."

msgstr ""

"Esto demuestra cómo se pueden definir enumeraciones derivadas similares; por "

"ejemplo, un :class:`FloatEnum` que se mezcla en :class:`float` en lugar de :"

"class:`int`."

#: ../Doc/howto/enum.rst:875

msgid "Some rules:"

msgstr "Algunas reglas:"

#: ../Doc/howto/enum.rst:877

msgid ""

"When subclassing :class:`Enum`, mix-in types must appear before :class:"

"`Enum` itself in the sequence of bases, as in the :class:`IntEnum` example "

"above."

msgstr ""

"Al subclasificar :class:`Enum`, los tipos de combinación deben aparecer "

"antes que :class:`Enum` en la secuencia de bases, como en el ejemplo "

"anterior de :class:`IntEnum`."

#: ../Doc/howto/enum.rst:880

msgid ""

"Mix-in types must be subclassable. For example, :class:`bool` and :class:"

"`range` are not subclassable and will throw an error during Enum creation if "

"used as the mix-in type."

msgstr ""

"Los tipos mixtos deben ser subclasificables. Por ejemplo, :class:`bool` y :"

"class:`range` no son subclasificables y generarán un error durante la "

"creación de Enum si se usan como tipo de combinación."

#: ../Doc/howto/enum.rst:883

msgid ""

"While :class:`Enum` can have members of any type, once you mix in an "

"additional type, all the members must have values of that type, e.g. :class:"

"`int` above. This restriction does not apply to mix-ins which only add "

"methods and don't specify another type."

msgstr ""

"Si bien :class:`Enum` puede tener miembros de cualquier tipo, una vez que "

"mezcle un tipo adicional, todos los miembros deben tener valores de ese "

"tipo, p. :class:`int` anterior. Esta restricción no se aplica a los "

"complementos que solo agregan métodos y no especifican otro tipo."

#: ../Doc/howto/enum.rst:887

msgid ""

"When another data type is mixed in, the :attr:`value` attribute is *not the "

"same* as the enum member itself, although it is equivalent and will compare "

"equal."

msgstr ""

"Cuando se mezcla otro tipo de datos, el atributo :attr:`value` es *not the "

"same* como el propio miembro de la enumeración, aunque es equivalente y se "

"comparará igual."

#: ../Doc/howto/enum.rst:890

msgid ""

"A ``data type`` is a mixin that defines :meth:`__new__`, or a :class:"

"`~dataclasses.dataclass`"