# 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: 2021-03-19 11:16+0100\n"

"PO-Revision-Date: 2020-09-12 00:36+0200\n"

"Last-Translator: Francisco Jesús Sevilla García <fjsevilla.dev@gmail.com>\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.8.0\n"

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

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

msgid ""

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

"generated :term:`special method`\\s such as :meth:`__init__` and :meth:"

"`__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:34

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:41

msgid ""

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

"directly specified in the ``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-level decorators, classes, and functions"

msgstr "Decoradores, clases y funciones del módulo"

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

msgid ""

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

"`special method`\\s 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

msgid ""

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

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

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

"func:`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

msgid ""

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

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

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

"decorator returns the same class that 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

msgid ""

"If :func:`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 :func:`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:86

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

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

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

msgid ""

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

msgstr ""

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

"será generado."

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

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:94

msgid ""

"``repr``: If true (the default), a :meth:`__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:101

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:104

msgid ""

"``eq``: If true (the default), an :meth:`__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:109

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:112

msgid ""

"``order``: If true (the default is ``False``), :meth:`__lt__`, :meth:"

"`__le__`, :meth:`__gt__`, and :meth:`__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:119

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:123

msgid ""

"``unsafe_hash``: If ``False`` (the default), a :meth:`__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:126

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 :func:`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:133

msgid ""

"By default, :func:`dataclass` will not implicitly add a :meth:`__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:139

#, fuzzy

msgid ""

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

"then :func:`dataclass` *may* add an implicit :meth:`__hash__` method. "

"Although not recommended, you can force :func:`dataclass` to create a :meth:"

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

"class is logically immutable but can nonetheless be mutated. This is a "

"specialized use case and should be considered carefully."

msgstr ""

"Si :meth:`__hash__` no está definido explícitamente o si es designado como "

"``None``, :func:`dataclass` *puede* añadir implícitamente el método :meth:"

"`__hash__`. Aunque no sea recomendable, es posible forzar que :func:"

"`dataclass` cree un método :meth:`__hash__` mediante ``unsafe_hash=True``; "

"esto es factible si su clase es lógicamente inmutable pero, sin embargo, "

"puede ser modificada. Este es un caso especial de uso que debe ser "

"considerado cuidadosamente."

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

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:151

msgid ""

"If ``eq`` and ``frozen`` are both true, by default :func:`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:159

msgid ""

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

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

"`__setattr__` or :meth:`__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:164

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:172

msgid ""

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

"`__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:177

msgid ""

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

"field with a default value. This is true either when 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:183

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:196

msgid ""

"As shown above, the ``MISSING`` value is a sentinel object used to detect if "

"the ``default`` and ``default_factory`` parameters are provided. This "

"sentinel is used because ``None`` is a valid value for ``default``. No code "

"should directly use the ``MISSING`` value."

msgstr ""

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

"utilizado para detectar si los parámetros ``default`` y ``default_factory`` "

"son provistos. Este objeto centinela es utilizado debido a que ``None`` es "

"un valor válido para ``default``. Ningún procedimiento debe utilizar "

"directamente el valor ``MISSING``."

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

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

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

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

msgid ""

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

"This is needed because the :meth:`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:208

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:214

msgid ""

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

"the generated :meth:`__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:217

msgid ""

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

"returned by the generated :meth:`__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:220

msgid ""

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

"equality and comparison methods (:meth:`__eq__`, :meth:`__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:224

msgid ""

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

"in the generated :meth:`__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:231

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:237

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:245

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 no ``default`` is provided, then the class attribute "

"will be deleted. The intent is that after the :func:`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:261

msgid ""

"The class attribute ``C.z`` will be ``10``, the class attribute ``C.t`` will "

"be ``20``, and the class attributes ``C.x`` and ``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:267

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:272

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

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

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

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

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

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

msgid ""

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

"and ``metadata`` have the identical meaning and values as they do in the :"

"func:`field` declaration."

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:280

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:285

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:292

msgid ""

"Converts the dataclass ``instance`` 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. For example::"

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:312 ../Doc/library/dataclasses.rst:326

msgid "Raises :exc:`TypeError` if ``instance`` 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:316

msgid ""

"Converts the dataclass ``instance`` 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."

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:321

msgid "Continuing from the previous example::"

msgstr "Continuando con el ejemplo anterior::"

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

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, ``typing.Any`` is used for "

"``type``. The values of ``init``, ``repr``, ``eq``, ``order``, "

"``unsafe_hash``, and ``frozen`` have the same meaning as they do in :func:"

"`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:339

msgid ""

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

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

"`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:351

msgid "Is equivalent to::"

msgstr "Es equivalente a::"

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

msgid ""

"Creates a new object of the same type of ``instance``, replacing fields with "

"values from ``changes``. If ``instance`` is not a Data Class, raises :exc:"

"`TypeError`. If values in ``changes`` do not specify fields, 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:369

msgid ""

"The newly returned object is created by calling the :meth:`__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:373

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:377

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:381

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 ``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:392

msgid ""

"Return ``True`` if its parameter is 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:395

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)``::"

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

msgid "Post-init processing"

msgstr "Procesamiento posterior a la inicialización"

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

msgid ""

"The generated :meth:`__init__` code will call a method named :meth:"

"`__post_init__`, if :meth:`__post_init__` is defined on the class. It will "

"normally be called as ``self.__post_init__()``. However, if any ``InitVar`` "

"fields are defined, they will also be passed to :meth:`__post_init__` in the "

"order they were defined in the class. If no :meth:`__init__` method is "

"generated, then :meth:`__post_init__` will not automatically be called."

msgstr ""

"El código del método generado :meth:`__init__` llamará a un método llamado :"

"meth:`__post_init__`, si :meth:`__post_init__` está definido en la clase. "

"Normalmente se llamará como ``self.__post_init__()``. Sin embargo, si se "

"define algún campo ``InitVar``, también se pasarán a :meth:`__post_init__` "

"en el orden en que se definieron en la clase. Si no se genera el método :"

"meth:`__init__`, entonces :meth:`__post_init__` no se llamará "

"automáticamente."

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

msgid ""

"Among other uses, this allows for initializing field values that depend on "

"one or more other fields. For example::"

msgstr ""

"Entre otros usos, esto permite inicializar valores de campo que dependen de "

"uno o más campos. Por ejemplo::"

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

msgid ""

"See the section below on init-only variables for ways to pass parameters to :"

"meth:`__post_init__`. Also see the warning about how :func:`replace` "

"handles ``init=False`` fields."

msgstr ""

"Consulta la sección sobre variables de solo inicialización que hay a "

"continuación para conocer las posibles formas de pasar parámetros a :meth:"

"`__post_init__`. También vea la advertencia sobre cómo :func:`replace` "

"maneja los campos ``init = False``."

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

msgid "Class variables"

msgstr "Variables de clase"

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

msgid ""

"One of two places where :func:`dataclass` actually inspects the type of a "

"field is to determine if a field is a class variable as defined in :pep:"

"`526`. It does this by checking if the type of the field is ``typing."

"ClassVar``. If a field is a ``ClassVar``, it is excluded from consideration "

"as a field and is ignored by the dataclass mechanisms. Such ``ClassVar`` "

"pseudo-fields are not returned by the module-level :func:`fields` function."

msgstr ""

"Uno de los dos casos donde :func:`dataclass` realmente inspecciona el tipo "

"de un campo, es para determinar si dicho campo es una variable de clase como "

"se define en :pep:`526`. Lo hace comprobando si el tipo del campo es "

"``typing.ClassVar``. Si un campo es una ``ClassVar``, se deja de considerar "

"como campo y los mecanismos de las clases de datos lo ignoran. Tales "

"pseudocampos ``ClassVar`` no son retornados por la función del módulo :func:"

"`fields`."

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

msgid "Init-only variables"

msgstr "Variable de solo inicialización"

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

msgid ""

"The other place where :func:`dataclass` inspects a type annotation is to "

"determine if a field is an init-only variable. It does this by seeing if "

"the type of a field is of type ``dataclasses.InitVar``. If a field is an "

"``InitVar``, it is considered a pseudo-field called an init-only field. As "

"it is not a true field, it is not returned by the module-level :func:"

"`fields` function. Init-only fields are added as parameters to the "

"generated :meth:`__init__` method, and are passed to the optional :meth:"

"`__post_init__` method. They are not otherwise used by dataclasses."

msgstr ""

"El otro caso donde :func:`dataclass` inspecciona una anotación de tipo es "

"para determinar si un campo es una variable de solo inicialización. Lo hace "

"comprobando si el tipo de un campo es ``dataclasses.InitVar``. Si un campo "

"es un ``InitVar``, se considera un pseudocampo llamado 'campo de solo "

"inicialización'. Como no es un campo verdadero, no es retornado por la "

"función del módulo :func:`fields`. Los campos de solo inicialización se "

"agregan como parámetros al método generado :meth:`__init__` y se pasan al "

"método opcional :meth:`__post_init__`. No son utilizados de otra manera por "

"las clases de datos."

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

msgid ""

"For example, suppose a field will be initialized from a database, if a value "

"is not provided when creating the class::"

msgstr ""

"Por ejemplo, supongamos que se va a inicializar un campo desde una base de "

"datos, de no proporcionarse un valor al crear la clase::"

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

msgid ""

"In this case, :func:`fields` will return :class:`Field` objects for ``i`` "

"and ``j``, but not for ``database``."

msgstr ""

"En este caso, :func:`fields` retornará objetos :class:`Field` para ``i`` y "

"``j``, pero no para ``database``."

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

msgid "Frozen instances"

msgstr "Instancias congeladas"

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

msgid ""

"It is not possible to create truly immutable Python objects. However, by "

"passing ``frozen=True`` to the :meth:`dataclass` decorator you can emulate "

"immutability. In that case, dataclasses will add :meth:`__setattr__` and :"

"meth:`__delattr__` methods to the class. These methods will raise a :exc:"

"`FrozenInstanceError` when invoked."

msgstr ""

"No es posible crear objetos verdaderamente inmutables en Python. Sin "

"embargo, se puede emular la inmutabilidad pasando ``frozen=True`` al "

"decorador :meth:`dataclass`. En este caso, las clases de datos añadirán los "

"métodos :meth:`__setattr__` y :meth:`__delattr__` a la clase. Estos métodos "

"lanzarán una excepción :exc:`FrozenInstanceError` cuando sean llamados."

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

msgid ""

"There is a tiny performance penalty when using ``frozen=True``: :meth:"

"`__init__` cannot use simple assignment to initialize fields, and must use :"

"meth:`object.__setattr__`."

msgstr ""

"Hay una pequeña penalización de rendimiento cuando se usa ``frozen=True``, "

"esto se debe a que :meth:`__init__` no puede usar una asignación simple para "

"inicializar campos, viéndose obligado a usar :meth:`object.__setattr__`."

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

msgid "Inheritance"

msgstr "Herencia"

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

msgid ""

"When the dataclass is being created by the :meth:`dataclass` decorator, it "

"looks through all of the class's base classes in reverse MRO (that is, "

"starting at :class:`object`) and, for each dataclass that it finds, adds the "

"fields from that base class to an ordered mapping of fields. After all of "

"the base class fields are added, it adds its own fields to the ordered "

"mapping. All of the generated methods will use this combined, calculated "

"ordered mapping of fields. Because the fields are in insertion order, "

"derived classes override base classes. An example::"

msgstr ""

"Cuando la clase de datos está siendo creada por el decorador :meth:"

"`dataclass`, revisa todas las clases base de la clase en el MRO invertido "

"(es decir, comenzando en :class:`object`) y, para cada clase de datos que "

"encuentra, agrega los campos de esa clase base a un mapeo ordenado. Después "

"de agregar todos los campos de la clase base, agrega sus propios campos al "

"mapeo. Todos los métodos generados utilizarán este mapeo ordenado calculado "

"combinando los campos. Como los campos están en orden de inserción, las "

"clases derivadas anulan las clases base. Un ejemplo::"

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

msgid ""

"The final list of fields is, in order, ``x``, ``y``, ``z``. The final type "

"of ``x`` is ``int``, as specified in class ``C``."

msgstr ""

"La lista final de campos es, en orden, ``x``, ``y``, ``z``. El tipo final de "

"``x`` es ``int``, como se especifica en la clase ``C``."

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

msgid "The generated :meth:`__init__` method for ``C`` will look like::"

msgstr "El método :meth:`__init__` generado para ``C`` se verá como::"

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

msgid "Default factory functions"

msgstr "Funciones fábrica por defecto"

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

msgid ""

"If a :func:`field` specifies a ``default_factory``, it is called with zero "

"arguments when a default value for the field is needed. For example, to "

"create a new instance of a list, use::"

msgstr ""

"Si un :func:`field` especifica una ``default_factory``, se llama sin "

"argumentos cuando se necesita un valor predeterminado para el campo. Por "

"ejemplo, para crear una nueva instancia de una lista, debe usarse::"

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

msgid ""

"If a field is excluded from :meth:`__init__` (using ``init=False``) and the "

"field also specifies ``default_factory``, then the default factory function "

"will always be called from the generated :meth:`__init__` function. This "

"happens because there is no other way to give the field an initial value."

msgstr ""

"Si un campo está excluido de :meth:`__init__` (usando ``init = False``) y el "

"campo también especifica ``default_factory``, entonces la función de fábrica "

"predeterminada siempre se llamará desde la función generada :meth:"

"`__init__`. Esto sucede porque no existe otra forma de darle al campo un "

"valor inicial."

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

msgid "Mutable default values"

msgstr "Valores por defecto mutables"

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

msgid ""

"Python stores default member variable values in class attributes. Consider "

"this example, not using dataclasses::"

msgstr ""

"Python almacena los valores miembros por defecto en atributos de clase. "

"Considera este ejemplo, sin usar clases de datos::"

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

msgid ""

"Note that the two instances of class ``C`` share the same class variable "

"``x``, as expected."

msgstr ""

"Tenga en cuenta que, tal como cabe esperar, las dos instancias de la clase "

"``C`` comparten la misma variable de clase ``x``."

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

msgid "Using dataclasses, *if* this code was valid::"

msgstr "Usando clases de datos, *si* este código fuera válido:"

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

msgid "it would generate code similar to::"

msgstr "generaría un código similar a::"

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

msgid ""

"This has the same issue as the original example using class ``C``. That is, "

"two instances of class ``D`` that do not specify a value for ``x`` when "

"creating a class instance will share the same copy of ``x``. Because "

"dataclasses just use normal Python class creation they also share this "

"behavior. There is no general way for Data Classes to detect this "

"condition. Instead, dataclasses will raise a :exc:`TypeError` if it detects "

"a default parameter of type ``list``, ``dict``, or ``set``. This is a "

"partial solution, but it does protect against many common errors."

msgstr ""

"Este tiene el mismo problema que el ejemplo original usando la clase ``C``. "

"Es decir, dos instancias de la clase ``D`` que no especifican un valor para "

"``x``, al crear una instancia de la clase, compartirán la misma copia de "

"``x``. Debido a que las clases de datos usan simplemente el mecanismo normal "

"de creación de clases de Python, también comparten este comportamiento. No "

"existe una forma genérica de que las clases de datos detecten esta "

"condición. En su lugar, las clases de datos generarán una excepción :exc:"

"`TypeError` si detectan un parámetro predeterminado de tipo ``list``, "

"``dict`` o ``set`` (contenedores incorporados mutables). Esta es una "

"solución parcial, pero protege contra muchos de los errores más comunes."

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

msgid ""

"Using default factory functions is a way to create new instances of mutable "

"types as default values for fields::"

msgstr ""

"Usar las funciones fábrica por defecto es una forma de crear nuevas "

"instancias de tipos mutables como valores por defecto para campos::"

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

msgid "Exceptions"

msgstr "Excepciones"

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

msgid ""

"Raised when an implicitly defined :meth:`__setattr__` or :meth:`__delattr__` "

"is called on a dataclass which was defined with ``frozen=True``."

msgstr ""

"Es lanzada cuando un método :meth:`__setattr__` o :meth:`__delattr__` "

"definido implícitamente es llamado en una clase de datos que ha sido "

"definida con ``frozen=True``."