# 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 , 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`" msgstr "" "Un ``data type`` es un mixin que define :meth:`__new__`, o una :class:" "`~dataclasses.dataclass`" #: ../Doc/howto/enum.rst:892 #, 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:895 msgid "" ":ref:`Formatted string literals `, :meth:`str.format`, and :func:" "`format` will use the enum's :meth:`__str__` method." msgstr "" ":ref:`Formatted string literals `, :meth:`str.format` y :func:" "`format` usarán el método :meth:`__str__` de la enumeración." #: ../Doc/howto/enum.rst:900 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 "" "Dado 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 al método :meth:`__str__` de sus tipos de " "datos." #: ../Doc/howto/enum.rst:908 msgid "When to use :meth:`__new__` vs. :meth:`__init__`" msgstr "Cuándo usar :meth:`__new__` frente a :meth:`__init__`" #: ../Doc/howto/enum.rst:910 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:914 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:941 msgid "" "*Do not* call ``super().__new__()``, as the lookup-only ``__new__`` is the " "one that is found; instead, use the data type directly." msgstr "" "*No* llame a ``super().__new__()``, ya que encontrará el ``__new__`` de solo " "búsqueda; en su lugar, utilice directamente el tipo de datos." #: ../Doc/howto/enum.rst:946 msgid "Finer Points" msgstr "Puntos más finos" #: ../Doc/howto/enum.rst:949 msgid "Supported ``__dunder__`` names" msgstr "Nombres ``__dunder__`` admitidos" #: ../Doc/howto/enum.rst:951 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:954 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:960 msgid "Supported ``_sunder_`` names" msgstr "Nombres ``_sunder_`` admitidos" #: ../Doc/howto/enum.rst:962 msgid "``_name_`` -- name of the member" msgstr "``_name_`` -- nombre del miembro" #: ../Doc/howto/enum.rst:963 msgid "" "``_value_`` -- value of the member; can be set / modified in ``__new__``" msgstr "" "``_value_`` -- valor del miembro; se puede configurar/modificar en " "``__new__``" #: ../Doc/howto/enum.rst:965 msgid "" "``_missing_`` -- a lookup function used when a value is not found; may be " "overridden" msgstr "" "``_missing_``: una función de búsqueda utilizada cuando no se encuentra un " "valor; puede ser anulado" #: ../Doc/howto/enum.rst:967 msgid "" "``_ignore_`` -- a list of names, either as a :class:`list` or a :class:" "`str`, that will not be transformed into members, and will be removed from " "the final class" msgstr "" "``_ignore_`` -- una lista de nombres, ya sea como :class:`list` o :class:" "`str`, que no se transformarán en miembros y se eliminarán de la clase final" #: ../Doc/howto/enum.rst:970 msgid "" "``_order_`` -- used in Python 2/3 code to ensure member order is consistent " "(class attribute, removed during class creation)" msgstr "" "``_order_``: se usa en el código Python 2/3 para garantizar que el orden de " "los miembros sea coherente (atributo de clase, eliminado durante la creación " "de la clase)" #: ../Doc/howto/enum.rst:972 msgid "" "``_generate_next_value_`` -- used by the `Functional API`_ and by :class:" "`auto` to get an appropriate value for an enum member; may be overridden" msgstr "" "``_generate_next_value_``: utilizado por `Functional API`_ y por :class:" "`auto` para obtener un valor apropiado para un miembro de enumeración; puede " "ser anulado" #: ../Doc/howto/enum.rst:978 msgid "" "For standard :class:`Enum` classes the next value chosen is the last value " "seen incremented by one." msgstr "" "Para las clases :class:`Enum` estándar, el siguiente valor elegido es el " "último valor visto incrementado en uno." #: ../Doc/howto/enum.rst:981 msgid "" "For :class:`Flag` classes the next value chosen will be the next highest " "power-of-two, regardless of the last value seen." msgstr "" "Para las clases :class:`Flag`, el siguiente valor elegido será la siguiente " "potencia de dos más alta, independientemente del último valor visto." #: ../Doc/howto/enum.rst:984 msgid "``_missing_``, ``_order_``, ``_generate_next_value_``" msgstr "``_missing_``, ``_order_``, ``_generate_next_value_``" #: ../Doc/howto/enum.rst:985 msgid "``_ignore_``" msgstr "``_ignore_``" #: ../Doc/howto/enum.rst:987 msgid "" "To help keep Python 2 / Python 3 code in sync an :attr:`_order_` attribute " "can be provided. It will be checked against the actual order of the " "enumeration and raise an error if the two do not match::" msgstr "" "Para ayudar a mantener sincronizado el código de Python 2/Python 3, se puede " "proporcionar un atributo :attr:`_order_`. Se comparará con el orden real de " "la enumeración y lanzará un error si los dos no coinciden:" #: ../Doc/howto/enum.rst:1005 msgid "" "In Python 2 code the :attr:`_order_` attribute is necessary as definition " "order is lost before it can be recorded." msgstr "" "En el código de Python 2, el atributo :attr:`_order_` es necesario ya que el " "orden de definición se pierde antes de que se pueda registrar." #: ../Doc/howto/enum.rst:1010 msgid "_Private__names" msgstr "_Private__names" #: ../Doc/howto/enum.rst:1012 msgid "" ":ref:`Private names ` are not converted to enum " "members, but remain normal attributes." msgstr "" ":ref:`Private names ` no se convierten en miembros de " "enumeración, sino que siguen siendo atributos normales." #: ../Doc/howto/enum.rst:1019 msgid "``Enum`` member type" msgstr "Tipo de miembro ``Enum``" #: ../Doc/howto/enum.rst:1021 msgid "" "Enum members are instances of their enum class, and are normally accessed as " "``EnumClass.member``. In certain situations, such as writing custom enum " "behavior, being able to access one member directly from another is useful, " "and is supported; however, in order to avoid name clashes between member " "names and attributes/methods from mixed-in classes, upper-case names are " "strongly recommended." msgstr "" "Los miembros de una enumeración son instancias de su clase de enumeración y " "se acceden normalmente como ``EnumClass.member``. En ciertas situaciones, " "como al escribir comportamiento personalizado para una enumeración, es útil " "poder acceder a un miembro directamente desde otro, y esto está soportado; " "sin embargo, para evitar conflictos de nombres entre los nombres de los " "miembros y los atributos/métodos de las clases mezcladas, se recomienda " "encarecidamente utilizar nombres en mayúsculas." #: ../Doc/howto/enum.rst:1032 msgid "Creating members that are mixed with other data types" msgstr "Creación de miembros que se mezclan con otros tipos de datos" #: ../Doc/howto/enum.rst:1034 msgid "" "When subclassing other data types, such as :class:`int` or :class:`str`, " "with an :class:`Enum`, all values after the ``=`` are passed to that data " "type's constructor. For example::" msgstr "" "Al crear subclases de otros tipos de datos, como :class:`int` o :class:" "`str`, con un :class:`Enum`, todos los valores después de ``=`` se pasan al " "constructor de ese tipo de datos. Por ejemplo::" #: ../Doc/howto/enum.rst:1046 msgid "Boolean value of ``Enum`` classes and members" msgstr "Valor booleano de clases y miembros ``Enum``" #: ../Doc/howto/enum.rst:1048 msgid "" "Enum classes that are mixed with non-:class:`Enum` types (such as :class:" "`int`, :class:`str`, etc.) are evaluated according to the mixed-in type's " "rules; otherwise, all members evaluate as :data:`True`. To make your own " "enum's boolean evaluation depend on the member's value add the following to " "your class::" msgstr "" "Las clases de enumeración que se mezclan con tipos que no son :class:`Enum` " "(como :class:`int`, :class:`str`, etc.) se evalúan de acuerdo con las reglas " "del tipo combinado; de lo contrario, todos los miembros se evalúan como :" "data:`True`. Para hacer que la evaluación booleana de su propia enumeración " "dependa del valor del miembro, agregue lo siguiente a su clase:" #: ../Doc/howto/enum.rst:1057 msgid "Plain :class:`Enum` classes always evaluate as :data:`True`." msgstr "Las clases simples :class:`Enum` siempre se evalúan como :data:`True`." #: ../Doc/howto/enum.rst:1061 msgid "``Enum`` classes with methods" msgstr "Clases ``Enum`` con métodos" #: ../Doc/howto/enum.rst:1063 msgid "" "If you give your enum subclass extra methods, like the `Planet`_ class " "below, those methods will show up in a :func:`dir` of the member, but not of " "the class::" msgstr "" "Si le da a su subclase de enumeración métodos adicionales, como la clase " "`Planet`_ a continuación, esos métodos aparecerán en un :func:`dir` del " "miembro, pero no de la clase:" #: ../Doc/howto/enum.rst:1074 msgid "Combining members of ``Flag``" msgstr "Combinación de miembros de ``Flag``" #: ../Doc/howto/enum.rst:1076 msgid "" "Iterating over a combination of :class:`Flag` members will only return the " "members that are comprised of a single bit::" msgstr "" "La iteración sobre una combinación de miembros :class:`Flag` solo devolverá " "los miembros que se componen de un solo bit:" #: ../Doc/howto/enum.rst:1094 msgid "``Flag`` and ``IntFlag`` minutia" msgstr "Minuciosidades ``Flag`` y ``IntFlag``" #: ../Doc/howto/enum.rst:1096 msgid "Using the following snippet for our examples::" msgstr "Usando el siguiente fragmento para nuestros ejemplos:" #: ../Doc/howto/enum.rst:1107 msgid "the following are true:" msgstr "lo siguiente es cierto:" #: ../Doc/howto/enum.rst:1109 msgid "single-bit flags are canonical" msgstr "las banderas de un solo bit son canónicas" #: ../Doc/howto/enum.rst:1110 msgid "multi-bit and zero-bit flags are aliases" msgstr "las banderas multibit y zero-bit son alias" #: ../Doc/howto/enum.rst:1111 msgid "only canonical flags are returned during iteration::" msgstr "solo se retornan banderas canónicas durante la iteración:" #: ../Doc/howto/enum.rst:1116 msgid "" "negating a flag or flag set returns a new flag/flag set with the " "corresponding positive integer value::" msgstr "" "negar una bandera o un conjunto de banderas retorna una nueva bandera/" "conjunto de banderas con el valor entero positivo correspondiente:" #: ../Doc/howto/enum.rst:1125 msgid "names of pseudo-flags are constructed from their members' names::" msgstr "" "los nombres de las pseudo-banderas se construyen a partir de los nombres de " "sus miembros:" #: ../Doc/howto/enum.rst:1130 msgid "multi-bit flags, aka aliases, can be returned from operations::" msgstr "" "las banderas de varios bits, también conocidas como alias, se pueden " "devolver desde las operaciones:" #: ../Doc/howto/enum.rst:1141 msgid "" "membership / containment checking: zero-valued flags are always considered " "to be contained::" msgstr "" "comprobación de pertenencia / contención: las banderas de valor cero siempre " "se consideran contenidas:" #: ../Doc/howto/enum.rst:1147 msgid "" "otherwise, only if all bits of one flag are in the other flag will True be " "returned::" msgstr "" "de lo contrario, solo si todos los bits de una bandera están en la otra " "bandera, se devolverá True:" #: ../Doc/howto/enum.rst:1156 msgid "" "There is a new boundary mechanism that controls how out-of-range / invalid " "bits are handled: ``STRICT``, ``CONFORM``, ``EJECT``, and ``KEEP``:" msgstr "" "Hay un nuevo mecanismo de límite que controla cómo se manejan los bits no " "válidos/fuera de rango: ``STRICT``, ``CONFORM``, ``EJECT`` y ``KEEP``:" #: ../Doc/howto/enum.rst:1159 msgid "STRICT --> raises an exception when presented with invalid values" msgstr "STRICT --> lanza una excepción cuando se presentan valores no válidos" #: ../Doc/howto/enum.rst:1160 msgid "CONFORM --> discards any invalid bits" msgstr "CONFORM --> descarta cualquier bit inválido" #: ../Doc/howto/enum.rst:1161 msgid "EJECT --> lose Flag status and become a normal int with the given value" msgstr "" "EJECT -> pierde el estado de la bandera y se convierte en un int normal con " "el valor dado" #: ../Doc/howto/enum.rst:1165 msgid "KEEP --> keep the extra bits" msgstr "KEEP --> mantener los bits adicionales" #: ../Doc/howto/enum.rst:1163 msgid "keeps Flag status and extra bits" msgstr "mantiene el estado de la bandera y bits adicionales" #: ../Doc/howto/enum.rst:1164 msgid "extra bits do not show up in iteration" msgstr "los bits adicionales no aparecen en la iteración" #: ../Doc/howto/enum.rst:1165 msgid "extra bits do show up in repr() and str()" msgstr "bits adicionales aparecen en repr() y str()" #: ../Doc/howto/enum.rst:1167 msgid "" "The default for Flag is ``STRICT``, the default for ``IntFlag`` is " "``EJECT``, and the default for ``_convert_`` is ``KEEP`` (see ``ssl." "Options`` for an example of when ``KEEP`` is needed)." msgstr "" "El valor predeterminado para Flag es ``STRICT``, el valor predeterminado " "para ``IntFlag`` es ``EJECT`` y el valor predeterminado para ``_convert_`` " "es ``KEEP`` (consulte ``ssl.Options`` para ver un ejemplo de cuándo se " "necesita ``KEEP``)." #: ../Doc/howto/enum.rst:1175 msgid "How are Enums and Flags different?" msgstr "" "¿En qué se diferencian las Enumeraciones (Enums) y las Banderas (Flags)?" #: ../Doc/howto/enum.rst:1177 msgid "" "Enums have a custom metaclass that affects many aspects of both derived :" "class:`Enum` classes and their instances (members)." msgstr "" "Las enumeraciones tienen una metaclase personalizada que afecta a muchos " "aspectos de las clases :class:`Enum` derivadas y sus instancias (miembros)." #: ../Doc/howto/enum.rst:1182 msgid "Enum Classes" msgstr "Clases de enumeración" #: ../Doc/howto/enum.rst:1184 msgid "" "The :class:`EnumType` metaclass is responsible for providing the :meth:" "`__contains__`, :meth:`__dir__`, :meth:`__iter__` and other methods that " "allow one to do things with an :class:`Enum` class that fail on a typical " "class, such as ``list(Color)`` or ``some_enum_var in Color``. :class:" "`EnumType` is responsible for ensuring that various other methods on the " "final :class:`Enum` class are correct (such as :meth:`__new__`, :meth:" "`__getnewargs__`, :meth:`__str__` and :meth:`__repr__`)." msgstr "" "La metaclase :class:`EnumType` es responsable de proporcionar :meth:" "`__contains__`, :meth:`__dir__`, :meth:`__iter__` y otros métodos que " "permiten hacer cosas con una clase :class:`Enum` que fallan en una clase " "típica, como ``list(Color)`` o ``some_enum_var in Color``. :class:`EnumType` " "es responsable de garantizar que varios otros métodos en la clase :class:" "`Enum` final sean correctos (como :meth:`__new__`, :meth:`__getnewargs__`, :" "meth:`__str__` y :meth:`__repr__`)." #: ../Doc/howto/enum.rst:1193 msgid "Flag Classes" msgstr "Clases de Banderas" #: ../Doc/howto/enum.rst:1195 msgid "" "Flags have an expanded view of aliasing: to be canonical, the value of a " "flag needs to be a power-of-two value, and not a duplicate name. So, in " "addition to the :class:`Enum` definition of alias, a flag with no value (a.k." "a. ``0``) or with more than one power-of-two value (e.g. ``3``) is " "considered an alias." msgstr "" "Las banderas tienen una vista ampliada de la creación de alias: para ser " "canónico, el valor de una bandera debe ser un valor de potencia de dos y no " "un nombre duplicado. Por lo tanto, además de la definición de alias de :" "class:`Enum`, una bandera sin valor (también conocida como ``0``) o con más " "de un valor de potencia de dos (por ejemplo, ``3``) se considera un alias." #: ../Doc/howto/enum.rst:1201 msgid "Enum Members (aka instances)" msgstr "Miembros de enumeración (también conocidos como instancias)" #: ../Doc/howto/enum.rst:1203 msgid "" "The most interesting thing about enum members is that they are singletons. :" "class:`EnumType` creates them all while it is creating the enum class " "itself, and then puts a custom :meth:`__new__` in place to ensure that no " "new ones are ever instantiated by returning only the existing member " "instances." msgstr "" "Lo más interesante de los miembros de la enumeración es que son únicos. :" "class:`EnumType` los crea a todos mientras crea la propia clase de " "enumeración, y luego coloca un :meth:`__new__` personalizado para garantizar " "que nunca se creen instancias nuevas al devolver solo las instancias de " "miembros existentes." #: ../Doc/howto/enum.rst:1209 msgid "Flag Members" msgstr "Miembros de Banderas" #: ../Doc/howto/enum.rst:1211 msgid "" "Flag members can be iterated over just like the :class:`Flag` class, and " "only the canonical members will be returned. For example::" msgstr "" "Los miembros de las Banderas se pueden recorrer de la misma manera que la " "clase :class:`Flag`, y solo se devolverán los miembros canónicos. Por " "ejemplo::" #: ../Doc/howto/enum.rst:1217 msgid "(Note that ``BLACK``, ``PURPLE``, and ``WHITE`` do not show up.)" msgstr "(Note que ``BLACK``, ``PURPLE``, y ``WHITE`` no se muestran.)" #: ../Doc/howto/enum.rst:1219 msgid "" "Inverting a flag member returns the corresponding positive value, rather " "than a negative value --- for example::" msgstr "" "Invertir un miembro de la bandera devuelve el valor positivo " "correspondiente, en lugar de un valor negativo --- por ejemplo::" #: ../Doc/howto/enum.rst:1225 msgid "" "Flag members have a length corresponding to the number of power-of-two " "values they contain. For example::" msgstr "" "Los miembros de las Banderas tienen una longitud que corresponde al número " "de valores de potencia de dos que contienen. Por ejemplo::" #: ../Doc/howto/enum.rst:1235 msgid "Enum Cookbook" msgstr "Recetario de Enumeraciones" #: ../Doc/howto/enum.rst:1238 msgid "" "While :class:`Enum`, :class:`IntEnum`, :class:`StrEnum`, :class:`Flag`, and :" "class:`IntFlag` are expected to cover the majority of use-cases, they cannot " "cover them all. Here are recipes for some different types of enumerations " "that can be used directly, or as examples for creating one's own." msgstr "" "Si bien se espera que :class:`Enum`, :class:`IntEnum`, :class:`StrEnum`, :" "class:`Flag` y :class:`IntFlag` cubran la mayoría de los casos de uso, no " "pueden cubrirlos todos. Aquí hay recetas para algunos tipos diferentes de " "enumeraciones que se pueden usar directamente o como ejemplos para crear las " "propias." #: ../Doc/howto/enum.rst:1245 msgid "Omitting values" msgstr "Omitir valores" #: ../Doc/howto/enum.rst:1247 msgid "" "In many use-cases, one doesn't care what the actual value of an enumeration " "is. There are several ways to define this type of simple enumeration:" msgstr "" "En muchos casos de uso, a uno no le importa cuál es el valor real de una " "enumeración. Hay varias formas de definir este tipo de enumeración simple:" #: ../Doc/howto/enum.rst:1250 msgid "use instances of :class:`auto` for the value" msgstr "usar instancias de :class:`auto` para el valor" #: ../Doc/howto/enum.rst:1251 msgid "use instances of :class:`object` as the value" msgstr "usar instancias de :class:`object` como valor" #: ../Doc/howto/enum.rst:1252 msgid "use a descriptive string as the value" msgstr "use una cadena descriptiva como el valor" #: ../Doc/howto/enum.rst:1253 msgid "" "use a tuple as the value and a custom :meth:`__new__` to replace the tuple " "with an :class:`int` value" msgstr "" "use una tupla como valor y un :meth:`__new__` personalizado para reemplazar " "la tupla con un valor :class:`int`" #: ../Doc/howto/enum.rst:1256 msgid "" "Using any of these methods signifies to the user that these values are not " "important, and also enables one to add, remove, or reorder members without " "having to renumber the remaining members." msgstr "" "El uso de cualquiera de estos métodos significa para el usuario que estos " "valores no son importantes y también permite agregar, eliminar o reordenar " "miembros sin tener que volver a numerar los miembros restantes." #: ../Doc/howto/enum.rst:1262 msgid "Using :class:`auto`" msgstr "Usando :class:`auto`" #: ../Doc/howto/enum.rst:1264 msgid "Using :class:`auto` would look like::" msgstr "El uso de :class:`auto` se vería así:" #: ../Doc/howto/enum.rst:1276 msgid "Using :class:`object`" msgstr "Usando :class:`object`" #: ../Doc/howto/enum.rst:1278 msgid "Using :class:`object` would look like::" msgstr "El uso de :class:`object` se vería así:" #: ../Doc/howto/enum.rst:1288 msgid "" "This is also a good example of why you might want to write your own :meth:" "`__repr__`::" msgstr "" "Este también es un buen ejemplo de por qué es posible que desee escribir su " "propio :meth:`__repr__`::" #: ../Doc/howto/enum.rst:1304 msgid "Using a descriptive string" msgstr "Usar una cadena descriptiva" #: ../Doc/howto/enum.rst:1306 msgid "Using a string as the value would look like::" msgstr "Usando una cadena como el valor se vería así:" #: ../Doc/howto/enum.rst:1318 msgid "Using a custom :meth:`__new__`" msgstr "Usando un :meth:`__new__` personalizado" #: ../Doc/howto/enum.rst:1320 msgid "Using an auto-numbering :meth:`__new__` would look like::" msgstr "El uso de un :meth:`__new__` de numeración automática se vería así:" #: ../Doc/howto/enum.rst:1337 msgid "" "To make a more general purpose ``AutoNumber``, add ``*args`` to the " "signature::" msgstr "" "Para hacer un ``AutoNumber`` de uso más general, agregue ``*args`` a la " "firma:" #: ../Doc/howto/enum.rst:1347 msgid "" "Then when you inherit from ``AutoNumber`` you can write your own " "``__init__`` to handle any extra arguments::" msgstr "" "Luego, cuando hereda de ``AutoNumber``, puede escribir su propio " "``__init__`` para manejar cualquier argumento adicional:" #: ../Doc/howto/enum.rst:1366 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." 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." #: ../Doc/howto/enum.rst:1372 msgid "" "*Do not* call ``super().__new__()``, as the lookup-only ``__new__`` is the " "one that is found; instead, use the data type directly -- e.g.::" msgstr "" "*No* llame a ``super().__new__()``, ya que encontrará el ``__new__`` de solo " "búsqueda; en su lugar, utilice directamente el tipo de datos -- por ejemplo::" #: ../Doc/howto/enum.rst:1379 msgid "OrderedEnum" msgstr "Enum ordenado" #: ../Doc/howto/enum.rst:1381 msgid "" "An ordered enumeration that is not based on :class:`IntEnum` and so " "maintains the normal :class:`Enum` invariants (such as not being comparable " "to other enumerations)::" msgstr "" "Una enumeración ordenada que no se basa en :class:`IntEnum` y, por lo tanto, " "mantiene las invariantes normales de :class:`Enum` (como no ser comparable " "con otras enumeraciones):" #: ../Doc/howto/enum.rst:1415 msgid "DuplicateFreeEnum" msgstr "DuplicateFreeEnum" #: ../Doc/howto/enum.rst:1417 msgid "" "Raises an error if a duplicate member value is found instead of creating an " "alias::" msgstr "" "Lanza un error si se encuentra un nombre de miembro duplicado en lugar de " "crear un alias::" #: ../Doc/howto/enum.rst:1442 msgid "" "This is a useful example for subclassing Enum to add or change other " "behaviors as well as disallowing aliases. If the only desired change is " "disallowing aliases, the :func:`unique` decorator can be used instead." msgstr "" "Este es un ejemplo útil para subclasificar Enum para agregar o cambiar otros " "comportamientos, así como para no permitir alias. Si el único cambio deseado " "es prohibir los alias, se puede usar el decorador :func:`unique` en su lugar." #: ../Doc/howto/enum.rst:1448 msgid "Planet" msgstr "Planeta" #: ../Doc/howto/enum.rst:1450 msgid "" "If :meth:`__new__` or :meth:`__init__` is defined, the value of the enum " "member will be passed to those methods::" msgstr "" "Si se define :meth:`__new__` o :meth:`__init__`, el valor del miembro de " "enumeración se pasará a esos métodos:" #: ../Doc/howto/enum.rst:1479 msgid "TimePeriod" msgstr "Periodo de tiempo" #: ../Doc/howto/enum.rst:1481 msgid "An example to show the :attr:`_ignore_` attribute in use::" msgstr "Un ejemplo para mostrar el atributo :attr:`_ignore_` en uso:" #: ../Doc/howto/enum.rst:1500 msgid "Subclassing EnumType" msgstr "Subclase EnumType" #: ../Doc/howto/enum.rst:1502 msgid "" "While most enum needs can be met by customizing :class:`Enum` subclasses, " "either with class decorators or custom functions, :class:`EnumType` can be " "subclassed to provide a different Enum experience." msgstr "" "Si bien la mayoría de las necesidades de enumeración se pueden satisfacer " "mediante la personalización de las subclases :class:`Enum`, ya sea con " "decoradores de clase o funciones personalizadas, :class:`EnumType` se puede " "dividir en subclases para proporcionar una experiencia de enumeración " "diferente." #~ msgid "" #~ "Enum members are instances of their enum class, and are normally accessed " #~ "as ``EnumClass.member``. In Python versions ``3.5`` to ``3.10`` you " #~ "could access members from other members -- this practice was discouraged, " #~ "and in ``3.11`` :class:`Enum` returns to not allowing it::" #~ msgstr "" #~ "Los miembros de enumeración son instancias de su clase de enumeración y " #~ "normalmente se accede a ellos como ``EnumClass.member``. En las versiones " #~ "de Python ``3.5`` a ``3.10``, podía acceder a miembros de otros miembros; " #~ "esta práctica se desaconsejó, y en ``3.11``, :class:`Enum` vuelve a no " #~ "permitirlo:"