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

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

# Maintained by the python-doc-es workteam.

# docs-es@python.org /

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

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

# get the list of volunteers

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2024-11-21 16:38-0300\n"

"PO-Revision-Date: 2023-02-17 16:40-0300\n"

"Last-Translator: Francisco Mora <fr.morac@duocuc.cl>\n"

"Language: es_ES\n"

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

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

"MIME-Version: 1.0\n"

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

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

"Generated-By: Babel 2.16.0\n"

#: ../Doc/library/dataclasses.rst:2

#, fuzzy

msgid ":mod:`!dataclasses` --- Data Classes"

msgstr ":mod:`dataclasses` --- Clases de datos"

#: ../Doc/library/dataclasses.rst:10

msgid "**Source code:** :source:`Lib/dataclasses.py`"

msgstr "**Código fuente:** :source:`Lib/dataclasses.py`"

#: ../Doc/library/dataclasses.rst:14

#, fuzzy

msgid ""

"This module provides a decorator and functions for automatically adding "

"generated :term:`special methods <special method>` such as :meth:`~object."

"__init__` and :meth:`~object.__repr__` to user-defined classes. It was "

"originally described in :pep:`557`."

msgstr ""

"Este módulo provee un decorador y funciones para añadir :term:`métodos "

"especiales <special method>` automáticamente, como :meth:`__init__` y :meth:"

"`__repr__` por ejemplo, a clases definidas por el usuario. Fue originalmente "

"descrito en :pep:`557`."

#: ../Doc/library/dataclasses.rst:19

msgid ""

"The member variables to use in these generated methods are defined using :"

"pep:`526` type annotations. For example, this code::"

msgstr ""

"Las variables miembro a utilizar en estos métodos generados son definidas "

"teniendo en cuenta anotaciones de tipo :pep:`526`. Por ejemplo, en este "

"código::"

#: ../Doc/library/dataclasses.rst:22

msgid ""

"from dataclasses import dataclass\n"

"\n"

"@dataclass\n"

"class InventoryItem:\n"

" \"\"\"Class for keeping track of an item in inventory.\"\"\"\n"

" name: str\n"

" unit_price: float\n"

" quantity_on_hand: int = 0\n"

"\n"

" def total_cost(self) -> float:\n"

" return self.unit_price * self.quantity_on_hand"

msgstr ""

#: ../Doc/library/dataclasses.rst:34

#, fuzzy

msgid "will add, among other things, a :meth:`!__init__` that looks like::"

msgstr ""

"Añadirá, además de otros métodos, un método :meth:`__init__` con la "

"siguiente estructura::"

#: ../Doc/library/dataclasses.rst:36

msgid ""

"def __init__(self, name: str, unit_price: float, quantity_on_hand: int = "

"0):\n"

" self.name = name\n"

" self.unit_price = unit_price\n"

" self.quantity_on_hand = quantity_on_hand"

msgstr ""

#: ../Doc/library/dataclasses.rst:41

#, fuzzy

msgid ""

"Note that this method is automatically added to the class: it is not "

"directly specified in the :class:`!InventoryItem` definition shown above."

msgstr ""

"Es importante observar que este método es añadido a la clase "

"automáticamente; está implícito en la definición de ``InventoryItem`` "

"implementada arriba."

#: ../Doc/library/dataclasses.rst:47

msgid "Module contents"

msgstr "Contenidos del módulo"

#: ../Doc/library/dataclasses.rst:51

#, fuzzy

msgid ""

"This function is a :term:`decorator` that is used to add generated :term:"

"`special methods <special method>` to classes, as described below."

msgstr ""

"Esta función es un :term:`decorator` utilizado para añadir a las clases :"

"term:`los métodos especiales <special method>` generados, como se describe a "

"continuación."

#: ../Doc/library/dataclasses.rst:54

#, fuzzy

msgid ""

"The ``@dataclass`` decorator examines the class to find ``field``\\s. A "

"``field`` is defined as a class variable that has a :term:`type annotation "

"<variable annotation>`. With two exceptions described below, nothing in "

"``@dataclass`` examines the type specified in the variable annotation."

msgstr ""

"El decorador :func:`dataclass` examina la clase para encontrar ``fields``. "

"Un ``field`` ('campo') se define como una variable de clase que tiene una :"

"term:`anotación de variable <variable annotation>`. A excepción de los dos "

"casos descritos debajo, nada en :func:`dataclass` examina el tipo "

"especificado en la anotación de variable."

#: ../Doc/library/dataclasses.rst:60

msgid ""

"The order of the fields in all of the generated methods is the order in "

"which they appear in the class definition."

msgstr ""

"El orden de los campos en los métodos generados es el mismo en el que se "

"encuentran en la definición de la clase."

#: ../Doc/library/dataclasses.rst:63

#, fuzzy

msgid ""

"The ``@dataclass`` decorator will add various \"dunder\" methods to the "

"class, described below. If any of the added methods already exist in the "

"class, the behavior depends on the parameter, as documented below. The "

"decorator returns the same class that it is called on; no new class is "

"created."

msgstr ""

"El decorador :func:`dataclass` añade varios métodos \"*dunder*\" "

"(abreviación de *double underline*) a la clase, descritos a continuación. Si "

"alguno de los métodos añadidos ya existe en la definición de la clase, el "

"comportamiento dependerá del parámetro, como se documenta abajo. El "

"decorador retorna la misma clase con la que es llamado, no crea una nueva."

#: ../Doc/library/dataclasses.rst:69

#, fuzzy

msgid ""

"If ``@dataclass`` is used just as a simple decorator with no parameters, it "

"acts as if it has the default values documented in this signature. That is, "

"these three uses of ``@dataclass`` are equivalent::"

msgstr ""

"Si :func:`dataclass` es llamado como un simple decorador sin parámetros, "

"actúa con los valores por defecto documentados aquí. Específicamente, los "

"siguientes tres usos de :func:`dataclass` son equivalentes::"

#: ../Doc/library/dataclasses.rst:74

msgid ""

"@dataclass\n"

"class C:\n"

" ...\n"

"\n"

"@dataclass()\n"

"class C:\n"

" ...\n"

"\n"

"@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, "

"frozen=False,\n"

" match_args=True, kw_only=False, slots=False, weakref_slot=False)\n"

"class C:\n"

" ..."

msgstr ""

#: ../Doc/library/dataclasses.rst:87

#, fuzzy

msgid "The parameters to ``@dataclass`` are:"

msgstr "Los parámetros de :func:`dataclass` son:"

#: ../Doc/library/dataclasses.rst:89

#, fuzzy

msgid ""

"*init*: If true (the default), a :meth:`~object.__init__` method will be "

"generated."

msgstr ""

"``init``: Si es verdadero (valor por defecto), el método :meth:`__init__` "

"será generado."

#: ../Doc/library/dataclasses.rst:92

#, fuzzy

msgid ""

"If the class already defines :meth:`!__init__`, this parameter is ignored."

msgstr "Si la clase ya define :meth:`__init__`, este parámetro es ignorado."

#: ../Doc/library/dataclasses.rst:95

#, fuzzy

msgid ""

"*repr*: If true (the default), a :meth:`~object.__repr__` method will be "

"generated. The generated repr string will have the class name and the name "

"and repr of each field, in the order they are defined in the class. Fields "

"that are marked as being excluded from the repr are not included. For "

"example: ``InventoryItem(name='widget', unit_price=3.0, "

"quantity_on_hand=10)``."

msgstr ""

"``repr``: Si es verdadero (valor por defecto), el método :meth:`__repr__` es "

"generado. La cadena de representación generada tendrá el nombre de la clase "

"junto al nombre y la representación de cada uno de sus campos, en el mismo "

"orden en el que están definidos en la clase. Es posible indicar que ciertos "

"campos no sean incluidos en la representación. Por ejemplo: "

"``InventoryItem(name='widget', unit_price=3.0, quantity_on_hand=10)``."

#: ../Doc/library/dataclasses.rst:102

#, fuzzy

msgid ""

"If the class already defines :meth:`!__repr__`, this parameter is ignored."

msgstr "Si la clase ya define :meth:`__repr__`, este parámetro es ignorado."

#: ../Doc/library/dataclasses.rst:105

#, fuzzy

msgid ""

"*eq*: If true (the default), an :meth:`~object.__eq__` method will be "

"generated. This method compares the class as if it were a tuple of its "

"fields, in order. Both instances in the comparison must be of the identical "

"type."

msgstr ""

"``eq``: Si es verdadero (por defecto), el método :meth:`__eq__` es generado. "

"Este método compara entre instancias de la clase representando cada una de "

"ellas mediante una tupla, siendo los elementos de la misma los campos de la "

"clase ubicados en el mismo orden en el que fueron definidos (dos tuplas son "

"iguales si, y sólo si, sus campos son iguales)."

#: ../Doc/library/dataclasses.rst:110

#, fuzzy

msgid ""

"If the class already defines :meth:`!__eq__`, this parameter is ignored."

msgstr "Si la clase ya define :meth:`__eq__`, este parámetro es ignorado."

#: ../Doc/library/dataclasses.rst:113

#, fuzzy

msgid ""

"*order*: If true (the default is ``False``), :meth:`~object.__lt__`, :meth:"

"`~object.__le__`, :meth:`~object.__gt__`, and :meth:`~object.__ge__` methods "

"will be generated. These compare the class as if it were a tuple of its "

"fields, in order. Both instances in the comparison must be of the identical "

"type. If *order* is true and *eq* is false, a :exc:`ValueError` is raised."

msgstr ""

"``order``: Si es verdadero (``False`` es el valor por defecto), los métodos :"

"meth:`__lt__`, :meth:`__le__`, :meth:`__gt__` y :meth:`__ge__` serán "

"generados. Estos métodos comparan la clase como si fuera una tupla con sus "

"campos, en orden. Ambas instancias en la comparación deben ser del mismo "

"tipo. Si ``order`` es verdadero y ``eq`` falso, se lanza una excepción :exc:"

"`ValueError`."

#: ../Doc/library/dataclasses.rst:120

#, fuzzy

msgid ""

"If the class already defines any of :meth:`!__lt__`, :meth:`!__le__`, :meth:"

"`!__gt__`, or :meth:`!__ge__`, then :exc:`TypeError` is raised."

msgstr ""

"Si la clase ya define :meth:`__lt__`, :meth:`__le__`, :meth:`__gt__` o :meth:"

"`__ge__`, se lanza una excepción :exc:`TypeError`."

#: ../Doc/library/dataclasses.rst:124

#, fuzzy

msgid ""

"*unsafe_hash*: If ``False`` (the default), a :meth:`~object.__hash__` method "

"is generated according to how *eq* and *frozen* are set."

msgstr ""

"``unsafe_hash``: Si es ``False`` (por defecto), se genera el método :meth:"

"`__hash__` de acuerdo a los valores de ``eq`` y ``frozen`` definidos."

#: ../Doc/library/dataclasses.rst:127

#, fuzzy

msgid ""

":meth:`!__hash__` is used by built-in :meth:`hash`, and when objects are "

"added to hashed collections such as dictionaries and sets. Having a :meth:`!"

"__hash__` implies that instances of the class are immutable. Mutability is a "

"complicated property that depends on the programmer's intent, the existence "

"and behavior of :meth:`!__eq__`, and the values of the *eq* and *frozen* "

"flags in the ``@dataclass`` decorator."

msgstr ""

":meth:`__hash__` es utilizado por la función incorporada :meth:`hash()` y "

"cuando los objetos definidos por la clase son añadidos a colecciones hash, "

"como por ejemplo diccionarios y conjuntos. Definir el método :meth:"

"`__hash__` en una clase implica que sus instancias son inmutables. La "

"mutabilidad es una propiedad compleja, ya que depende de cómo el programador "

"utilice el objeto, la existencia y comportamiento de :meth:`__eq__` y del "

"valor asignado a las flags ``eq`` y ``frozen`` en el decorador :func:"

"`dataclass`."

#: ../Doc/library/dataclasses.rst:134

#, fuzzy

msgid ""

"By default, ``@dataclass`` will not implicitly add a :meth:`~object."

"__hash__` method unless it is safe to do so. Neither will it add or change "

"an existing explicitly defined :meth:`!__hash__` method. Setting the class "

"attribute ``__hash__ = None`` has a specific meaning to Python, as described "

"in the :meth:`!__hash__` documentation."

msgstr ""

"Por defecto, :func:`dataclass` no añade de forma implícita el método :meth:"

"`__hash__` a menos que sea seguro hacerlo. Tampoco añade o cambia un método :"

"meth:`__hash__` previamente definido de forma explícita. Definir el atributo "

"de clase ``__hash__ = None`` tiene un significado específico en Python, "

"descrito en la documentación dedicada a :meth:`__hash__`."

#: ../Doc/library/dataclasses.rst:140

#, fuzzy

msgid ""

"If :meth:`!__hash__` is not explicitly defined, or if it is set to ``None``, "

"then ``@dataclass`` *may* add an implicit :meth:`!__hash__` method. Although "

"not recommended, you can force ``@dataclass`` to create a :meth:`!__hash__` "

"method with ``unsafe_hash=True``. This might be the case if your class is "

"logically immutable but can still be mutated. This is a specialized use case "

"and should be considered carefully."

msgstr ""

"Si :meth:`__hash__` no está definido explícitamente, o si está configurado "

"como ``None``, entonces :func:`dataclass` *puede* agregar un método "

"implícito :meth:`__hash__`. Aunque no se recomienda, puede forzar un :func:"

"`dataclass` a crear un método :meth:`__hash__` con ``unsafe_hash=True``. "

"Este podría ser el caso si su clase es lógicamente inmutable pero, no "

"obstante, puede mutar. Este es un caso de uso especializado y debe "

"considerarse detenidamente."

#: ../Doc/library/dataclasses.rst:147

#, fuzzy

msgid ""

"Here are the rules governing implicit creation of a :meth:`!__hash__` "

"method. Note that you cannot both have an explicit :meth:`!__hash__` method "

"in your dataclass and set ``unsafe_hash=True``; this will result in a :exc:"

"`TypeError`."

msgstr ""

"A continuación se explican las reglas que se aplican en la creación "

"implícita del método :meth:`__hash__`. Observar que no es compatible definir "

"explícitamente un método :meth:`__hash__` en su clase de datos y al mismo "

"tiempo asignar ``unsafe_hash=True``; esto lanza una excepción :exc:"

"`TypeError`."

#: ../Doc/library/dataclasses.rst:152

#, fuzzy

msgid ""

"If *eq* and *frozen* are both true, by default ``@dataclass`` will generate "

"a :meth:`!__hash__` method for you. If *eq* is true and *frozen* is false, :"

"meth:`!__hash__` will be set to ``None``, marking it unhashable (which it "

"is, since it is mutable). If *eq* is false, :meth:`!__hash__` will be left "

"untouched meaning the :meth:`!__hash__` method of the superclass will be "

"used (if the superclass is :class:`object`, this means it will fall back to "

"id-based hashing)."

msgstr ""

"Si ``eq`` y ``frozen`` son ambos verdaderos, :func:`dataclass` genera por "

"defecto un método :meth:`hash` por ti. En el caso que ``eq`` sea verdadero y "

"``frozen`` falso, a :meth:`__hash__` se le asigna ``None``, en consecuencia "

"será *unhashable* (lo cual es deseable, ya que es mutable). Si ``eq`` es "

"falso, :meth:`__hash__` permanece sin cambios, por lo que en este caso se "

"hará uso del método :meth:`hash` heredado de la superclase (lo que implica "

"que si la superclase es :class:`object`, se aplicará el *hashing* basado en "

"el id de los objetos)."

#: ../Doc/library/dataclasses.rst:160

#, fuzzy

msgid ""

"*frozen*: If true (the default is ``False``), assigning to fields will "

"generate an exception. This emulates read-only frozen instances. If :meth:"

"`~object.__setattr__` or :meth:`~object.__delattr__` is defined in the "

"class, then :exc:`TypeError` is raised. See the discussion below."

msgstr ""

"``frozen``: Si es verdadero (el valor por defecto es ``False``), cualquier "

"intento de asignación a un campo de la clase lanza una excepción. Esto emula "

"el comportamiento de las instancias congeladas (*frozen*) de sólo lectura. "

"Si :meth:`__setattr__` o :meth:`__delattr__` son definidos en la clase, se "

"lanzará una excepción :exc:`TypeError`. Esto es ampliado más abajo."

#: ../Doc/library/dataclasses.rst:165

#, fuzzy

msgid ""

"*match_args*: If true (the default is ``True``), the :attr:`~object."

"__match_args__` tuple will be created from the list of parameters to the "

"generated :meth:`~object.__init__` method (even if :meth:`!__init__` is not "

"generated, see above). If false, or if :attr:`!__match_args__` is already "

"defined in the class, then :attr:`!__match_args__` will not be generated."

msgstr ""

"``match_args``: si es verdadero (el valor predeterminado es ``True``), la "

"tupla ``__match_args__`` se creará a partir de la lista de parámetros para "

"el método :meth:`__init__` generado (incluso si no se genera :meth:"

"`__init__`, consulte más arriba). Si es falso, o si ``__match_args__`` ya "

"está definido en la clase, no se generará ``__match_args__``."

#: ../Doc/library/dataclasses.rst:174

#, fuzzy

msgid ""

"*kw_only*: If true (the default value is ``False``), then all fields will be "

"marked as keyword-only. If a field is marked as keyword-only, then the only "

"effect is that the :meth:`~object.__init__` parameter generated from a "

"keyword-only field must be specified with a keyword when :meth:`!__init__` "

"is called. There is no effect on any other aspect of dataclasses. See the :"

"term:`parameter` glossary entry for details. Also see the :const:`KW_ONLY` "

"section."

msgstr ""

"``kw_only``: si es verdadero (el valor predeterminado es ``False``), todos "

"los campos se marcarán solo como palabra clave. Si un campo está marcado "

"como solo de palabra clave, el único efecto es que el parámetro :meth:"

"`__init__` generado a partir de un campo de solo palabra clave debe "

"especificarse con una palabra clave cuando se llama a :meth:`__init__`. No "

"hay ningún efecto sobre ningún otro aspecto de las clases de datos. Consulte "

"la entrada del glosario :term:`parameter` para obtener más detalles. "

"Consulte también la sección :const:`KW_ONLY`."

#: ../Doc/library/dataclasses.rst:185

#, fuzzy

msgid ""

"*slots*: If true (the default is ``False``), :attr:`~object.__slots__` "

"attribute will be generated and new class will be returned instead of the "

"original one. If :attr:`!__slots__` is already defined in the class, then :"

"exc:`TypeError` is raised."

msgstr ""

"``slots``: si es verdadero (el valor predeterminado es ``False``), se "

"generará el atributo :attr:`__slots__` y se devolverá una nueva clase en "

"lugar de la original. Si :attr:`__slots__` ya está definido en la clase, se "

"genera :exc:`TypeError`."

#: ../Doc/library/dataclasses.rst:191

msgid ""

"Calling no-arg :func:`super` in dataclasses using ``slots=True`` will result "

"in the following exception being raised: ``TypeError: super(type, obj): obj "

"must be an instance or subtype of type``. The two-arg :func:`super` is a "

"valid workaround. See :gh:`90562` for full details."

msgstr ""

#: ../Doc/library/dataclasses.rst:198

msgid ""

"Passing parameters to a base class :meth:`~object.__init_subclass__` when "

"using ``slots=True`` will result in a :exc:`TypeError`. Either use "

"``__init_subclass__`` with no parameters or use default values as a "

"workaround. See :gh:`91126` for full details."

msgstr ""

#: ../Doc/library/dataclasses.rst:206

#, fuzzy

msgid ""

"If a field name is already included in the :attr:`!__slots__` of a base "

"class, it will not be included in the generated :attr:`!__slots__` to "

"prevent :ref:`overriding them <datamodel-note-slots>`. Therefore, do not "

"use :attr:`!__slots__` to retrieve the field names of a dataclass. Use :func:"

"`fields` instead. To be able to determine inherited slots, base class :attr:"

"`!__slots__` may be any iterable, but *not* an iterator."

msgstr ""

"Si un nombre de campo ya está incluido en las ``__slots__`` de una clase "

"base, no se incluirá en las ``__slots__`` generadas para evitar que se "

"`sobreescriban <https://docs.python.org/3/reference/datamodel.html#notes-on-"

"using-slots>`_. Por lo tanto, no utilice ``__slots__`` para recuperar los "

"nombres de campo de una clase de datos. Utilice :func:`fields` en su lugar. "

"Para poder determinar las ranuras heredadas, la clase base ``__slots__`` "

"puede ser cualquier iterable, pero *no* un iterador."

# No estoy seguro de si es correcto traducir slot por "ranura".

#: ../Doc/library/dataclasses.rst:216

#, fuzzy

msgid ""

"*weakref_slot*: If true (the default is ``False``), add a slot named "

"\"__weakref__\", which is required to make an instance :func:`weakref-able "

"<weakref.ref>`. It is an error to specify ``weakref_slot=True`` without also "

"specifying ``slots=True``."

msgstr ""

"``weakref_slot``: Si es verdadero (por defecto es ``False``), añade una "

"ranura llamada \"__weakref__\", que es necesaria para generar una instancia "

"referenciable de forma débil. Es un error especificar ``weakref_slot=True`` "

"sin especificar también ``slots=True``."

#: ../Doc/library/dataclasses.rst:224

msgid ""

"``field``\\s may optionally specify a default value, using normal Python "

"syntax::"

msgstr ""

"Los ``fields`` pueden especificar un valor por defecto opcionalmente, "

"simplemente usando la sintaxis normal de Python::"

#: ../Doc/library/dataclasses.rst:227

msgid ""

"@dataclass\n"

"class C:\n"

" a: int # 'a' has no default value\n"

" b: int = 0 # assign a default value for 'b'"

msgstr ""

#: ../Doc/library/dataclasses.rst:232

#, fuzzy

msgid ""

"In this example, both :attr:`!a` and :attr:`!b` will be included in the "

"added :meth:`~object.__init__` method, which will be defined as::"

msgstr ""

"En este ejemplo, tanto ``a`` como ``b`` serán incluidos en el método :meth:"

"`__init__` agregado, el cual será definido como sigue::"

#: ../Doc/library/dataclasses.rst:235

msgid "def __init__(self, a: int, b: int = 0):"

msgstr ""

#: ../Doc/library/dataclasses.rst:237

msgid ""

":exc:`TypeError` will be raised if a field without a default value follows a "

"field with a default value. This is true whether this occurs in a single "

"class, or as a result of class inheritance."

msgstr ""

"Si, en la definición de una clase, a un campo con valor por defecto le sigue "

"un campo sin valor por defecto será lanzada una excepción :exc:`TypeError`. "

"Esto se aplica también a la implementación de una clase única o como "

"resultado de herencia de clases."

#: ../Doc/library/dataclasses.rst:243

#, fuzzy

msgid ""

"For common and simple use cases, no other functionality is required. There "

"are, however, some dataclass features that require additional per-field "

"information. To satisfy this need for additional information, you can "

"replace the default field value with a call to the provided :func:`!field` "

"function. For example::"

msgstr ""

"Para casos de uso común, estas funcionalidades son suficientes. Sin embargo, "

"existen otras características de las clases de datos que requieren "

"información adicional en ciertos campos. Para satisfacer esta necesidad, es "

"posible reemplazar cualquier valor por defecto de un campo mediante una "

"llamada a la función :func:`field`. Por ejemplo::"

#: ../Doc/library/dataclasses.rst:249

msgid ""

"@dataclass\n"

"class C:\n"

" mylist: list[int] = field(default_factory=list)\n"

"\n"

"c = C()\n"

"c.mylist += [1, 2, 3]"

msgstr ""

#: ../Doc/library/dataclasses.rst:256

msgid ""

"As shown above, the :const:`MISSING` value is a sentinel object used to "

"detect if some parameters are provided by the user. This sentinel is used "

"because ``None`` is a valid value for some parameters with a distinct "

"meaning. No code should directly use the :const:`MISSING` value."

msgstr ""

"Como se muestra arriba, el valor :const:`MISSING` es un objeto centinela que "

"se usa para detectar si el usuario proporciona algunos parámetros. Este "

"centinela se utiliza porque ``None`` es un valor válido para algunos "

"parámetros con un significado distinto. Ningún código debe utilizar "

"directamente el valor :const:`MISSING`."

#: ../Doc/library/dataclasses.rst:261

#, fuzzy

msgid "The parameters to :func:`!field` are:"

msgstr "Los parámetros de :func:`field` son:"

#: ../Doc/library/dataclasses.rst:263

#, fuzzy

msgid ""

"*default*: If provided, this will be the default value for this field. This "

"is needed because the :func:`!field` call itself replaces the normal "

"position of the default value."

msgstr ""

"``default``: Si es provisto, este será el valor por defecto para este campo. "

"Es necesario que sea definido ya que la propia llamada a :meth:`field` "

"reemplaza la posición normal del valor por defecto."

#: ../Doc/library/dataclasses.rst:267

#, fuzzy

msgid ""

"*default_factory*: If provided, it must be a zero-argument callable that "

"will be called when a default value is needed for this field. Among other "

"purposes, this can be used to specify fields with mutable default values, as "

"discussed below. It is an error to specify both *default* and "

"*default_factory*."

msgstr ""

"``default_factory``: Si es provisto, debe ser un objeto invocable sin "

"argumentos, el cual será llamado cuando el valor por defecto de este campo "

"sea necesario. Además de otros propósitos, puede ser utilizado para "

"especificar campos con valores por defecto mutables, como se explica a "

"continuación. Especificar tanto ``default`` como ``default_factory`` resulta "

"en un error."

#: ../Doc/library/dataclasses.rst:273

#, fuzzy

msgid ""

"*init*: If true (the default), this field is included as a parameter to the "

"generated :meth:`~object.__init__` method."

msgstr ""

"``init``: Si es verdadero (por defecto), este campo es incluido como "

"parámetro del método :meth:`__init__` generado."

#: ../Doc/library/dataclasses.rst:276

#, fuzzy

msgid ""

"*repr*: If true (the default), this field is included in the string returned "

"by the generated :meth:`~object.__repr__` method."

msgstr ""

"``repr``: Si es verdadero (por defecto), este campo es incluido en la cadena "

"de caracteres que retorna el método :meth:`__repr__` generado."

#: ../Doc/library/dataclasses.rst:279

#, fuzzy

msgid ""

"*hash*: This can be a bool or ``None``. If true, this field is included in "

"the generated :meth:`~object.__hash__` method. If ``None`` (the default), "

"use the value of *compare*: this would normally be the expected behavior. A "

"field should be considered in the hash if it's used for comparisons. "

"Setting this value to anything other than ``None`` is discouraged."

msgstr ""

"``hash``: Su valor puede ser de tipo booleano o ``None``. Si es verdadero, "

"este campo es incluido en el método :meth:`__hash__` generado. Si es "

"``None`` (por defecto), utiliza el valor de ``compare``: normalmente éste es "

"el comportamiento esperado. Un campo debería ser considerado para el *hash* "

"si es compatible con operaciones de comparación. Está desaconsejado "

"establecer este valor en algo que no sea ``None``."

#: ../Doc/library/dataclasses.rst:286

msgid ""

"One possible reason to set ``hash=False`` but ``compare=True`` would be if a "

"field is expensive to compute a hash value for, that field is needed for "

"equality testing, and there are other fields that contribute to the type's "

"hash value. Even if a field is excluded from the hash, it will still be "

"used for comparisons."

msgstr ""

"Una posible razón para definir ``hash=False`` y ``compare=True`` podría ser "

"el caso en el que computar el valor *hash* para dicho campo es costoso pero "

"el campo es necesario para los métodos de comparación, siempre que existan "

"otros campos que contribuyen al valor hash del tipo. Incluso si un campo se "

"excluye del hash, se seguirá utilizando a la hora de comparar."

#: ../Doc/library/dataclasses.rst:292

#, fuzzy

msgid ""

"*compare*: If true (the default), this field is included in the generated "

"equality and comparison methods (:meth:`~object.__eq__`, :meth:`~object."

"__gt__`, et al.)."

msgstr ""

"``compare``: Si es verdadero (por defecto), este campo es incluido en los "

"métodos de comparación generados (:meth:`__eq__`, :meth:`__gt__` y otros)."

#: ../Doc/library/dataclasses.rst:296

#, fuzzy

msgid ""

"*metadata*: This can be a mapping or ``None``. ``None`` is treated as an "

"empty dict. This value is wrapped in :func:`~types.MappingProxyType` to "

"make it read-only, and exposed on the :class:`Field` object. It is not used "

"at all by Data Classes, and is provided as a third-party extension "

"mechanism. Multiple third-parties can each have their own key, to use as a "

"namespace in the metadata."

msgstr ""

"``metadata``: Puede ser un mapeo o *None*. *None* es tratado como un "

"diccionario vacío. Este valor es envuelto en :func:`~types.MappingProxyType` "

"para que sea de sólo lectura y visible en el objeto :class:`Field`. No es "

"utilizado por las clases de datos, mas bien es provisto como un mecanismo de "

"extensión de terceros. Varios terceros pueden tener su propia clave para "

"utilizar como espacio de nombres en *metadata*."

#: ../Doc/library/dataclasses.rst:304

#, fuzzy

msgid ""

"*kw_only*: If true, this field will be marked as keyword-only. This is used "

"when the generated :meth:`~object.__init__` method's parameters are computed."

msgstr ""

"``kw_only``: si es verdadero, este campo se marcará como solo palabra clave. "

"Se utiliza cuando se calculan los parámetros del método :meth:`__init__` "

"generado."

#: ../Doc/library/dataclasses.rst:310

#, fuzzy

msgid ""

"If the default value of a field is specified by a call to :func:`!field`, "

"then the class attribute for this field will be replaced by the specified "

"*default* value. If *default* is not provided, then the class attribute "

"will be deleted. The intent is that after the :func:`@dataclass "

"<dataclass>` decorator runs, the class attributes will all contain the "

"default values for the fields, just as if the default value itself were "

"specified. For example, after::"

msgstr ""

"Si el valor por defecto de un campo es especificado por una llamada a :func:"

"`field()`, los atributos de clase para este campo serán reemplazados por los "

"especificados en el valor ``default``. Si el valor de ``default`` no es "

"provisto, el atributo de clase será eliminado. La idea es que, después que "

"la ejecución del decorador :func:`dataclass`, todos los atributos de la "

"clase contengan los valores por defecto de cada campo, como si fueran "

"definidos uno por uno. Por ejemplo, luego de::"

#: ../Doc/library/dataclasses.rst:319

msgid ""

"@dataclass\n"

"class C:\n"

" x: int\n"

" y: int = field(repr=False)\n"

" z: int = field(repr=False, default=10)\n"

" t: int = 20"

msgstr ""

#: ../Doc/library/dataclasses.rst:326

#, fuzzy

msgid ""

"The class attribute :attr:`!C.z` will be ``10``, the class attribute :attr:`!"

"C.t` will be ``20``, and the class attributes :attr:`!C.x` and :attr:`!C.y` "

"will not be set."

msgstr ""

"El atributo de clase ``C.z`` será ``10``, el atributo de clase ``C.t`` será "

"``20`` y los atributos de clase ``C.x`` y ``C.y`` no serán definidos."

#: ../Doc/library/dataclasses.rst:332

#, fuzzy

msgid ""

":class:`!Field` objects describe each defined field. These objects are "

"created internally, and are returned by the :func:`fields` module-level "

"method (see below). Users should never instantiate a :class:`!Field` object "

"directly. Its documented attributes are:"

msgstr ""

"Los objetos :class:`Field` describen cada campo definido. Estos objetos son "

"creados internamente y son retornados por el método :func:`fields` definido "

"en este módulo (explicado más abajo). Los usuarios no deben instanciar un "

"objeto :class:`Field` directamente. Sus atributos documentados son:"

#: ../Doc/library/dataclasses.rst:337

#, fuzzy

msgid ":attr:`!name`: The name of the field."

msgstr "``name``: El nombre del campo."

#: ../Doc/library/dataclasses.rst:338

#, fuzzy

msgid ":attr:`!type`: The type of the field."

msgstr "``type``: El tipo del campo."

#: ../Doc/library/dataclasses.rst:339

#, fuzzy

msgid ""

":attr:`!default`, :attr:`!default_factory`, :attr:`!init`, :attr:`!repr`, :"

"attr:`!hash`, :attr:`!compare`, :attr:`!metadata`, and :attr:`!kw_only` have "

"the identical meaning and values as they do in the :func:`field` function."

msgstr ""

"``default``, ``default_factory``, ``init``, ``repr``, ``hash``, ``compare`` "

"y ``metadata`` tienen los mismos valores y significados respecto a la "

"declaración de :func:`field` (ver arriba)."

#: ../Doc/library/dataclasses.rst:343

msgid ""

"Other attributes may exist, but they are private and must not be inspected "

"or relied on."

msgstr ""

"Pueden existir otros atributos, pero son privados y no deberían ser "

"considerados ni depender de ellos."

#: ../Doc/library/dataclasses.rst:348

msgid ""

"Returns a tuple of :class:`Field` objects that define the fields for this "

"dataclass. Accepts either a dataclass, or an instance of a dataclass. "

"Raises :exc:`TypeError` if not passed a dataclass or instance of one. Does "

"not return pseudo-fields which are ``ClassVar`` or ``InitVar``."

msgstr ""

"Retorna una tupla de objetos :class:`Field` que definen los campos para esta "

"clase de datos. Acepta tanto una clase de datos como una instancia de esta. "

"Lanza una excepción :exc:`TypeError` si se le pasa cualquier otro objeto. No "

"retorna pseudocampos, que son ``ClassVar`` o ``InitVar``."

#: ../Doc/library/dataclasses.rst:355

#, fuzzy

msgid ""

"Converts the dataclass *obj* to a dict (by using the factory function "

"*dict_factory*). Each dataclass is converted to a dict of its fields, as "

"``name: value`` pairs. dataclasses, dicts, lists, and tuples are recursed "

"into. Other objects are copied with :func:`copy.deepcopy`."

msgstr ""

"Convierte la clase de datos ``instance`` en un diccionario (usando la "

"función fábrica ``dict_factory``). Cada clase de datos es convertida a un "

"diccionario con sus campos como parejas ``name: value``. Las clases de "

"datos, diccionarios, listas y tuplas son convertidas recursivamente. Por "

"ejemplo::"

#: ../Doc/library/dataclasses.rst:361

#, fuzzy

msgid "Example of using :func:`!asdict` on nested dataclasses::"

msgstr "Ejemplo de uso de :func:`asdict` en clases de datos anidadas::"

#: ../Doc/library/dataclasses.rst:363

msgid ""

"@dataclass\n"

"class Point:\n"

" x: int\n"

" y: int\n"

"\n"

"@dataclass\n"

"class C:\n"

" mylist: list[Point]\n"

"\n"

"p = Point(10, 20)\n"

"assert asdict(p) == {'x': 10, 'y': 20}\n"

"\n"

"c = C([Point(0, 0), Point(10, 4)])\n"

"assert asdict(c) == {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}"

msgstr ""

# No estoy seguro de la traducción shallow copy como copia superficial.

#: ../Doc/library/dataclasses.rst:378 ../Doc/library/dataclasses.rst:398

#, fuzzy

msgid "To create a shallow copy, the following workaround may be used::"

msgstr ""

"Para crear una copia superficial, se puede utilizar la siguiente solución::"

#: ../Doc/library/dataclasses.rst:380

msgid "{field.name: getattr(obj, field.name) for field in fields(obj)}"

msgstr ""

#: ../Doc/library/dataclasses.rst:382

#, fuzzy

msgid ""

":func:`!asdict` raises :exc:`TypeError` if *obj* is not a dataclass instance."

msgstr ""

"Lanza una excepción :exc:`TypeError` si ``instance`` no es una instancia de "

"una clase de datos."

#: ../Doc/library/dataclasses.rst:387

#, fuzzy

msgid ""

"Converts the dataclass *obj* to a tuple (by using the factory function "

"*tuple_factory*). Each dataclass is converted to a tuple of its field "

"values. dataclasses, dicts, lists, and tuples are recursed into. Other "

"objects are copied with :func:`copy.deepcopy`."

msgstr ""

"Convierte la clase de datos ``instance`` a una tupla (usando la función "

"fábrica ``tuple_factory``). Cada clase de datos es convertida a una tupla "

"con los valores de sus campos. Las clases de datos, diccionarios, listas y "

"tuplas son convertidas recursivamente."

#: ../Doc/library/dataclasses.rst:393

msgid "Continuing from the previous example::"

msgstr "Continuando con el ejemplo anterior::"

#: ../Doc/library/dataclasses.rst:395

msgid ""

"assert astuple(p) == (10, 20)\n"

"assert astuple(c) == ([(0, 0), (10, 4)],)"

msgstr ""

#: ../Doc/library/dataclasses.rst:400

msgid "tuple(getattr(obj, field.name) for field in dataclasses.fields(obj))"

msgstr ""

#: ../Doc/library/dataclasses.rst:402

#, fuzzy

msgid ""

":func:`!astuple` raises :exc:`TypeError` if *obj* is not a dataclass "

"instance."

msgstr ""

"Lanza una excepción :exc:`TypeError` si ``instance`` no es una instancia de "

"una clase de datos."

#: ../Doc/library/dataclasses.rst:407

#, fuzzy

msgid ""

"Creates a new dataclass with name *cls_name*, fields as defined in *fields*, "

"base classes as given in *bases*, and initialized with a namespace as given "

"in *namespace*. *fields* is an iterable whose elements are each either "

"``name``, ``(name, type)``, or ``(name, type, Field)``. If just ``name`` is "

"supplied, :data:`typing.Any` is used for ``type``. The values of *init*, "

"*repr*, *eq*, *order*, *unsafe_hash*, *frozen*, *match_args*, *kw_only*, "

"*slots*, and *weakref_slot* have the same meaning as they do in :func:"

"`@dataclass <dataclass>`."

msgstr ""

"Crea una nueva clase de datos con el nombre ``cls_name``, con los campos "

"definidos en ``fields``, con las clases base dadas en ``bases`` e "

"inicializada con el espacio de nombres dado en ``namespace``. ``fields`` es "

"un iterable que cumple con una de estas formas: ``name``, ``(name, type)`` o "

"``(name, type, Field)``. Si solo ``name`` es proporcionado, ``typing.Any`` "

"es usado para ``type``. Los valores ``init``, ``repr``, ``eq``, ``order``, "

"``unsafe_hash`` y ``frozen`` tienen el mismo significado que en la función :"

"func:`dataclass`."

#: ../Doc/library/dataclasses.rst:417

msgid ""

"If *module* is defined, the :attr:`!__module__` attribute of the dataclass "

"is set to that value. By default, it is set to the module name of the caller."

msgstr ""

#: ../Doc/library/dataclasses.rst:421

#, fuzzy

msgid ""

"This function is not strictly required, because any Python mechanism for "

"creating a new class with :attr:`!__annotations__` can then apply the :func:"

"`@dataclass <dataclass>` function to convert that class to a dataclass. "

"This function is provided as a convenience. For example::"

msgstr ""

"Esta función no es estrictamente necesaria debido a que cualquier mecanismo "

"de Python para crear una nueva clase con ``__annotations__`` puede usar la "

"función :func:`dataclass` para convertir esa clase en una clase de datos. "

"Esta función se proporciona simplemente por comodidad. Por ejemplo::"

#: ../Doc/library/dataclasses.rst:427

msgid ""

"C = make_dataclass('C',\n"

" [('x', int),\n"

" 'y',\n"

" ('z', int, field(default=5))],\n"

" namespace={'add_one': lambda self: self.x + 1})"

msgstr ""

#: ../Doc/library/dataclasses.rst:433

msgid "Is equivalent to::"

msgstr "Es equivalente a::"

#: ../Doc/library/dataclasses.rst:435

msgid ""

"@dataclass\n"

"class C:\n"

" x: int\n"

" y: 'typing.Any'\n"

" z: int = 5\n"

"\n"

" def add_one(self):\n"

" return self.x + 1"

msgstr ""

#: ../Doc/library/dataclasses.rst:446

#, fuzzy

msgid ""

"Creates a new object of the same type as *obj*, replacing fields with values "

"from *changes*. If *obj* is not a Data Class, raises :exc:`TypeError`. If "

"keys in *changes* are not field names of the given dataclass, raises :exc:"

"`TypeError`."

msgstr ""

"Crea un nuevo objeto del mismo tipo que ``instance``, reemplazando los "

"campos correspondientes con los valores de ``changes``. Si ``instance`` no "

"es una clase de datos se lanza una excepción :exc:`TypeError`. Si los "

"valores en ``changes`` no especifican campos, también se lanza una "

"excepción :exc:`TypeError`."

#: ../Doc/library/dataclasses.rst:451

#, fuzzy

msgid ""

"The newly returned object is created by calling the :meth:`~object.__init__` "

"method of the dataclass. This ensures that :meth:`__post_init__`, if "

"present, is also called."

msgstr ""

"El objeto recién retornado es creado llamando al método :meth:`__init__` de "

"la clase de datos. Esto asegura que :meth:`__post_init__`, si existe, "

"también será llamado."

#: ../Doc/library/dataclasses.rst:455

#, fuzzy

msgid ""

"Init-only variables without default values, if any exist, must be specified "

"on the call to :func:`!replace` so that they can be passed to :meth:`!"

"__init__` and :meth:`__post_init__`."

msgstr ""

"Las variables de solo inicialización sin valores predeterminados, si "

"existen, deben especificarse en la llamada a :func:`replace` para que puedan "

"pasarse a :meth:`__init__` y :meth:`__post_init__`."

#: ../Doc/library/dataclasses.rst:459

#, fuzzy

msgid ""

"It is an error for *changes* to contain any fields that are defined as "

"having ``init=False``. A :exc:`ValueError` will be raised in this case."

msgstr ""

"Es un error que ``changes`` contenga cualquier campo que esté definido como "

"``init=False``. Una excepción :exc:`ValueError` se lanzará en este caso."

#: ../Doc/library/dataclasses.rst:463

#, fuzzy

msgid ""

"Be forewarned about how ``init=False`` fields work during a call to :func:`!"

"replace`. They are not copied from the source object, but rather are "

"initialized in :meth:`__post_init__`, if they're initialized at all. It is "

"expected that ``init=False`` fields will be rarely and judiciously used. If "

"they are used, it might be wise to have alternate class constructors, or "

"perhaps a custom :func:`!replace` (or similarly named) method which handles "

"instance copying."

msgstr ""

"Tenga en cuenta cómo funcionan los campos ``init=False`` durante una llamada "

"a :func:`replace`. No se copian del objeto de origen, sino que, de "

"inicializarse, lo hacen en :meth:`__post_init__`. Se espera que los campos "

"``init=False`` se utilicen en contadas ocasiones y con prudencia. Si se "

"utilizan, podría ser conveniente tener constructores de clase alternativos, "

"o quizás un método personalizado ``replace()`` (o con un nombre similar) que "

"maneje la copia de instancias."

#: ../Doc/library/dataclasses.rst:472

msgid ""

"Dataclass instances are also supported by generic function :func:`copy."

"replace`."

msgstr ""

#: ../Doc/library/dataclasses.rst:476

#, fuzzy

msgid ""

"Return ``True`` if its parameter is a dataclass (including subclasses of a "

"dataclass) or an instance of one, otherwise return ``False``."

msgstr ""

"Retorna ``True`` si su parámetro es una clase de datos o una instancia de "

"una, en caso contrario retorna ``False``."

#: ../Doc/library/dataclasses.rst:479

msgid ""

"If you need to know if a class is an instance of a dataclass (and not a "

"dataclass itself), then add a further check for ``not isinstance(obj, "

"type)``::"

msgstr ""

"Si se necesita conocer si una clase es una instancia de *dataclass* (y no "

"una clase de datos en si misma), se debe agregar una verificación adicional "

"para ``not isinstance(obj, type)``::"