enum.po

# 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.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python en Español 3.11\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.10.3\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 we recommend using UPPER_CASE "
"names for members, and will be using that style in our examples."
msgstr ""
"Debido a que las enumeraciones se usan para representar constantes, "
"recomendamos usar nombres en MAYÚSCULAS para los miembros, y usaremos ese "
"estilo en nuestros ejemplos."

#: ../Doc/howto/enum.rst:42
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:49
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:56
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:63
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:68
msgid "Likewise, they have an attribute for their :attr:`value`::"
msgstr "Asimismo, tienen un atributo para su :attr:`value`:"

#: ../Doc/howto/enum.rst:74
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:86
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:101
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:107
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:109
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:124
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:127
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:133
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:140
msgid "You can even iterate over a :class:`Flag` variable::"
msgstr "Incluso puede iterar sobre una variable :class:`Flag`:"

#: ../Doc/howto/enum.rst:147
msgid "Okay, let's get some chores set up::"
msgstr "Bien, preparemos algunas tareas::"

#: ../Doc/howto/enum.rst:155
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:164
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:182
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:184
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:193
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:200
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:210
msgid "Duplicating enum members and values"
msgstr "Duplicar miembros y valores de enumeración"

#: ../Doc/howto/enum.rst:212
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:222
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:243
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:249
msgid "Ensuring unique enumeration values"
msgstr "Garantizar valores de enumeración únicos"

#: ../Doc/howto/enum.rst:251
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:268
msgid "Using automatic values"
msgstr "Uso de valores automáticos"

#: ../Doc/howto/enum.rst:270
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:281
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:299
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:302
msgid "Iteration"
msgstr "Iteración"

#: ../Doc/howto/enum.rst:304
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:309
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:321
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:329
msgid "Comparisons"
msgstr "comparaciones"

#: ../Doc/howto/enum.rst:331
msgid "Enumeration members are compared by identity::"
msgstr "Los miembros de la enumeración se comparan por identidad::"

#: ../Doc/howto/enum.rst:340
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:348
msgid "Equality comparisons are defined though::"
msgstr "Las comparaciones de igualdad se definen aunque:"

#: ../Doc/howto/enum.rst:357
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:366
msgid "Allowed members and attributes of enumerations"
msgstr "Miembros permitidos y atributos de enumeraciones"

#: ../Doc/howto/enum.rst:368
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:374
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:394
msgid "Then::"
msgstr "Después::"

#: ../Doc/howto/enum.rst:403
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:410
msgid ""
"Note:  if your enumeration defines :meth:`__new__` and/or :meth:`__init__` "
"then 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 dado al miembro de la enumeración se pasará a esos métodos. "
"Consulte `Planet`_ para ver un ejemplo."

#: ../Doc/howto/enum.rst:416
msgid "Restricted Enum subclassing"
msgstr "Subclases de Enum restringidas"

#: ../Doc/howto/enum.rst:418
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:425
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:435
msgid "But this is allowed::"
msgstr "Pero esto está permitido:"

#: ../Doc/howto/enum.rst:446
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:453
msgid "Pickling"
msgstr "Serialización (Pickling)"

#: ../Doc/howto/enum.rst:455
msgid "Enumerations can be pickled and unpickled::"
msgstr "Las enumeraciones se pueden serializar y deserializar:"

#: ../Doc/howto/enum.rst:462
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:468
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:471
msgid ""
"It is possible to modify how enum members are pickled/unpickled by defining :"
"meth:`__reduce_ex__` in the enumeration class."
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."

#: ../Doc/howto/enum.rst:476
msgid "Functional API"
msgstr "API funcional"

#: ../Doc/howto/enum.rst:478
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:488
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:491
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:507
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:511
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:521
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:525
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:532
msgid "The complete signature is::"
msgstr "La firma completa es::"

#: ../Doc/howto/enum.rst
msgid "value"
msgstr "value"

#: ../Doc/howto/enum.rst:544
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:546
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:551
msgid "or an iterator of names::"
msgstr "o un iterador de nombres::"

#: ../Doc/howto/enum.rst:555
msgid "or an iterator of (name, value) pairs::"
msgstr "o un iterador de (nombre, valor) pares::"

#: ../Doc/howto/enum.rst:559
msgid "or a mapping::"
msgstr "o un mapeo::"

#: ../Doc/howto/enum.rst
msgid "module"
msgstr "module"

#: ../Doc/howto/enum.rst:563
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:565
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:567
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:569
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:571
msgid "The *start* parameter was added."
msgstr "Se agregó el parámetro *start*."

#: ../Doc/howto/enum.rst:576
msgid "Derived Enumerations"
msgstr "Enumeraciones derivadas"

#: ../Doc/howto/enum.rst:579
msgid "IntEnum"
msgstr "IntEnum"

#: ../Doc/howto/enum.rst:581
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:602
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:615
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:626
msgid "StrEnum"
msgstr "StrEnum"

#: ../Doc/howto/enum.rst:628
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:637
msgid "IntFlag"
msgstr "IntFlag"

#: ../Doc/howto/enum.rst:639
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:647
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:650
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:657
msgid "Sample :class:`IntFlag` class::"
msgstr "Ejemplo de clase :class:`IntFlag`::"

#: ../Doc/howto/enum.rst:673
msgid "It is also possible to name the combinations::"
msgstr "También es posible nombrar las combinaciones:"

#: ../Doc/howto/enum.rst:689
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:694
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:702
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:713
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:719
msgid ":class:`IntFlag` members can also be iterated over::"
msgstr "Los miembros :class:`IntFlag` también se pueden iterar sobre:"

#: ../Doc/howto/enum.rst:728
msgid "Flag"
msgstr "Bandera"

#: ../Doc/howto/enum.rst:730
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:739
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:753
msgid ""
"Individual flags should have values that are powers of two (1, 2, 4, "
"8, ...), while combinations of flags won't::"
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:765
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:779
msgid ":class:`Flag` members can also be iterated over::"
msgstr "Los miembros :class:`Flag` también se pueden iterar sobre:"

#: ../Doc/howto/enum.rst:789
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:799
msgid "Others"
msgstr "Otros"

#: ../Doc/howto/enum.rst:801
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:807
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:810
msgid "Some rules:"
msgstr "Algunas reglas:"

#: ../Doc/howto/enum.rst:812
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:815
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:818
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:822
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:825
#, python-format
msgid ""
"%-style formatting:  ``%s`` and ``%r`` call the :class:`Enum` class's :meth:"
"`__str__` and :meth:`__repr__` respectively; other codes (such as ``%i`` or "
"``%h`` for IntEnum) treat the enum member as its mixed-in type."
msgstr ""
"Formato de estilo %: ``%s`` y ``%r`` llaman a :meth:`__str__` y :meth:"
"`__repr__` de la clase :class:`Enum` respectivamente; otros códigos (como "
"``%i`` o ``%h`` para IntEnum) tratan el miembro de enumeración como su tipo "
"mixto."

#: ../Doc/howto/enum.rst:828
msgid ""
":ref:`Formatted string literals <f-strings>`, :meth:`str.format`, and :func:"
"`format` will use the enum's :meth:`__str__` method."
msgstr ""
":ref:`Formatted string literals <f-strings>`, :meth:`str.format` y :func:"
"`format` usarán el método :meth:`__str__` de la enumeración."

#: ../Doc/howto/enum.rst:833
msgid ""
"Because :class:`IntEnum`, :class:`IntFlag`, and :class:`StrEnum` are "
"designed to be drop-in replacements for existing constants, their :meth:"
"`__str__` method has been reset to their data types :meth:`__str__` method."
msgstr ""
"Debido a que :class:`IntEnum`, :class:`IntFlag` y :class:`StrEnum` están "
"diseñados para ser reemplazos directos de constantes existentes, su método :"
"meth:`__str__` se ha restablecido a su método de tipos de datos :meth:"
"`__str__`."

#: ../Doc/howto/enum.rst:839
msgid "When to use :meth:`__new__` vs. :meth:`__init__`"
msgstr "Cuándo usar :meth:`__new__` frente a :meth:`__init__`"

#: ../Doc/howto/enum.rst:841
msgid ""
":meth:`__new__` must be used whenever you want to customize the actual value "
"of the :class:`Enum` member.  Any other modifications may go in either :meth:"
"`__new__` or :meth:`__init__`, with :meth:`__init__` being preferred."
msgstr ""
":meth:`__new__` debe usarse siempre que desee personalizar el valor real del "
"miembro :class:`Enum`. Cualquier otra modificación puede ir en :meth:"
"`__new__` o :meth:`__init__`, siendo preferible :meth:`__init__`."

#: ../Doc/howto/enum.rst:845
msgid ""
"For example, if you want to pass several items to the constructor, but only "
"want one of them to be the value::"
msgstr ""
"Por ejemplo, si desea pasar varios elementos al constructor, pero solo desea "
"que uno de ellos sea el valor:"

#: ../Doc/howto/enum.rst:872
msgid "Finer Points"
msgstr "Puntos más finos"

#: ../Doc/howto/enum.rst:875
msgid "Supported ``__dunder__`` names"
msgstr "Nombres ``__dunder__`` admitidos"

#: ../Doc/howto/enum.rst:877
msgid ""
":attr:`__members__` is a read-only ordered mapping of ``member_name``:"
"``member`` items.  It is only available on the class."
msgstr ""
":attr:`__members__` es una asignación ordenada de solo lectura de elementos "
"``member_name``:``member``. Solo está disponible en la clase."

#: ../Doc/howto/enum.rst:880
msgid ""
":meth:`__new__`, if specified, must create and return the enum members; it "
"is also a very good idea to set the member's :attr:`_value_` appropriately.  "
"Once all the members are created it is no longer used."
msgstr ""
":meth:`__new__`, si se especifica, debe crear y devolver los miembros de "
"enumeración; también es una muy buena idea configurar correctamente el :attr:"
"`_value_` del miembro. Una vez que se crean todos los miembros, ya no se "
"utiliza."

#: ../Doc/howto/enum.rst:886
msgid "Supported ``_sunder_`` names"
msgstr "Nombres ``_sunder_`` admitidos"

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