dataclasses.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Hildeberto Abreu Magalh&atilde;es <hildeberto@gmail.com>, 2021
# Marco Rougeth <marco@rougeth.com>, 2021
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2021
# Vin&iacute;cius Muniz de Melo <viniciusdesk@icloud.com>, 2021
# i17obot <i17obot@rougeth.com>, 2021
# Rafael Fontenelle <rffontenelle@gmail.com>, 2024
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-04-18 14:18+0000\n"
"PO-Revision-Date: 2021-06-28 01:03+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2024\n"
"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
"teams/5390/pt_BR/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pt_BR\n"
"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "
"1000000 == 0 ? 1 : 2;\n"

#: ../../library/dataclasses.rst:2
msgid ":mod:`!dataclasses` --- Data Classes"
msgstr ":mod:`!dataclasses` --- Data Classes"

#: ../../library/dataclasses.rst:10
msgid "**Source code:** :source:`Lib/dataclasses.py`"
msgstr "**C&oacute;digo-fonte:** :source:`Lib/dataclasses.py`"

#: ../../library/dataclasses.rst:14
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&oacute;dulo fornece um decorador e fun&ccedil;&otilde;es para adicionar automaticamente :"
"term:`m&eacute;todos especiais <m&eacute;todo especial>` tais como :meth:`~object."
"__init__` e :meth:`~object.__repr__` a classes definidas pelo usu&aacute;rio. Foi "
"originalmente descrita em :pep:`557`."

#: ../../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 ""
"Vari&aacute;veis-membro a serem usadas nesses m&eacute;todos gerados s&atilde;o definidas usando "
"as anota&ccedil;&otilde;es de tipo da :pep:`526`. Por exemplo, esse c&oacute;digo::"

#: ../../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 ""

#: ../../library/dataclasses.rst:34
msgid "will add, among other things, a :meth:`!__init__` that looks like::"
msgstr "adicionar&aacute;, entre outras coisas, um :meth:`!__init__` como esse::"

#: ../../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 ""

#: ../../library/dataclasses.rst:41
msgid ""
"Note that this method is automatically added to the class: it is not "
"directly specified in the :class:`!InventoryItem` definition shown above."
msgstr ""
"Observe que este m&eacute;todo &eacute; adicionado automaticamente &agrave; classe: ele n&atilde;o &eacute; "
"especificado diretamente na defini&ccedil;&atilde;o :class:`!InventoryItem` mostrada acima."

#: ../../library/dataclasses.rst:47
msgid "Module contents"
msgstr "Conte&uacute;do do m&oacute;dulo"

#: ../../library/dataclasses.rst:51
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 fun&ccedil;&atilde;o &eacute; um :term:`decorador` que &eacute; usado para adicionar :term:`m&eacute;todos "
"especiais <m&eacute;todo especial>` para classes, conforme descrito abaixo."

#: ../../library/dataclasses.rst:54
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 ""
"O decorador ``@dataclass`` examina a classe para encontrar campos "
"(``field``.  Um ``field`` &eacute; definido como uma vari&aacute;vel de classe que tem "
"uma :term:`anota&ccedil;&atilde;o de tipo <variable annotation>`.  Com duas exce&ccedil;&otilde;es, "
"descritas mais adiante, ``@dataclass`` n&atilde;o examina o tipo especificado na "
"anota&ccedil;&atilde;o de vari&aacute;vel."

#: ../../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 ""
"A ordem dos campos em todos os m&eacute;todos gerados &eacute; a ordem em que eles "
"aparecem na defini&ccedil;&atilde;o de classe."

#: ../../library/dataclasses.rst:63
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 ""
"O decorador ``@dataclass`` adicionar&aacute; v&aacute;rios m&eacute;todos \"dunder\" &agrave; classe, "
"descritos abaixo. Se algum dos m&eacute;todos adicionados j&aacute; existir na classe, o "
"comportamento depender&aacute; do par&acirc;metro, conforme documentado abaixo. O "
"decorador retorna a mesma classe decorada; nenhuma nova classe &eacute; criada."

#: ../../library/dataclasses.rst:69
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 ""
"Se ``@dataclass`` for usado apenas como um simples decorador, sem "
"par&acirc;metros, ele age como se tivesse os valores padr&atilde;o documentados nessa "
"assinatura. Ou seja, esses tr&ecirc;s usos de ``@dataclass`` s&atilde;o equivalentes::"

#: ../../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 ""

#: ../../library/dataclasses.rst:87
msgid "The parameters to ``@dataclass`` are:"
msgstr "Os par&acirc;metros do ``@dataclass`` s&atilde;o:"

#: ../../library/dataclasses.rst:89
msgid ""
"*init*: If true (the default), a :meth:`~object.__init__` method will be "
"generated."
msgstr ""
"*init*: Se verdadeiro (o padr&atilde;o), o m&eacute;todo :meth:`~object.__init__` ser&aacute; "
"gerado."

#: ../../library/dataclasses.rst:92
msgid ""
"If the class already defines :meth:`!__init__`, this parameter is ignored."
msgstr ""
"Se a classe do usu&aacute;rio definir :meth:`!__init__` esse par&acirc;metro &eacute; ignorado."

#: ../../library/dataclasses.rst:95
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*: Se verdadeiro (o padr&atilde;o), um m&eacute;todo :meth:`~object.__repr__` ser&aacute; "
"gerado. A sequ&ecirc;ncia de string de representa&ccedil;&atilde;o gerada ter&aacute; o nome da classe "
"e o nome e representa&ccedil;&atilde;o de cada campo, na ordem em que s&atilde;o definidos na "
"classe. Os campos marcados como exclu&iacute;dos da representa&ccedil;&atilde;o n&atilde;o s&atilde;o "
"inclu&iacute;dos. Por exemplo: ``InventoryItem(name='widget', unit_price=3.0, "
"quantity_on_hand=10)``."

#: ../../library/dataclasses.rst:102
msgid ""
"If the class already defines :meth:`!__repr__`, this parameter is ignored."
msgstr ""
"Se a classe do usu&aacute;rio j&aacute; define :meth:`!__repr__` esse par&acirc;metro &eacute; ignorado."

#: ../../library/dataclasses.rst:105
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*: Se verdadeiro (o padr&atilde;o), um m&eacute;todo :meth:`~object.__eq__` ser&aacute; "
"gerado. Este m&eacute;todo compara a classe como se fosse uma tupla de campos, em "
"ordem. Ambas as inst&acirc;ncias na compara&ccedil;&atilde;o devem ser de tipo id&ecirc;ntico."

#: ../../library/dataclasses.rst:110
msgid ""
"If the class already defines :meth:`!__eq__`, this parameter is ignored."
msgstr ""
"Se a classe do usu&aacute;rio j&aacute; define :meth:`!__eq__` esse par&acirc;metro &eacute; ignorado."

#: ../../library/dataclasses.rst:113
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*: Se verdadeiro (o padr&atilde;o &eacute; ``False``), os m&eacute;todos :meth:`~object."
"__lt__`, :meth:`~object.__le__`, :meth:`~object.__gt__` e :meth:`~object."
"__ge__` ser&atilde;o gerados.  Comparam a classe como se fosse uma tupla de campos, "
"em ordem.  Ambas inst&acirc;ncias na compara&ccedil;&atilde;o devem ser de tipo id&ecirc;ntico.  Se "
"*order* &eacute; verdadeiro e *eq* &eacute; falso, a exce&ccedil;&atilde;o :exc:`ValueError` &eacute; levantada."

#: ../../library/dataclasses.rst:120
msgid ""
"If the class already defines any of :meth:`!__lt__`, :meth:`!__le__`, :meth:"
"`!__gt__`, or :meth:`!__ge__`, then :exc:`TypeError` is raised."
msgstr ""
"Se a classe do usu&aacute;rio j&aacute; define algum dentre :meth:`!__lt__`, :meth:`!"
"__le__`, :meth:`!__gt__` ou :meth:`!__ge__`, ent&atilde;o :exc:`TypeError` &eacute; "
"levantada."

#: ../../library/dataclasses.rst:124
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*: Se ``False`` (o padr&atilde;o), um m&eacute;todo :meth:`~object.__hash__` &eacute; "
"gerado, conforme a forma como *eq* e *frozen* est&atilde;o configurados."

#: ../../library/dataclasses.rst:127
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 ""

#: ../../library/dataclasses.rst:134
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 padr&atilde;o, ``@dataclass`` n&atilde;o vai adicionar implicitamente um m&eacute;todo :meth:"
"`~object.__hash__`, a menos que seja seguro faz&ecirc;-lo.  Nem ir&aacute; adicionar ou "
"modificar um m&eacute;todo :meth:`!__hash__` existente, definido explicitamente. "
"Configurar o atributo de classe ``__hash__ = None`` tem um significado "
"espec&iacute;fico para o Python, conforme descrito na documenta&ccedil;&atilde;o de :meth:`!"
"__hash__`."

#: ../../library/dataclasses.rst:140
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 ""
"Se :meth:`!__hash__` n&atilde;o &eacute; definido explicitamente, ou se &eacute; configurado como "
"``None``, ent&atilde;o ``@dataclass`` *pode* adicionar um m&eacute;todo :meth:`!__hash__` "
"impl&iacute;cito. Mesmo que n&atilde;o seja recomendado, pode-se for&ccedil;ar ``@dataclass`` a "
"criar um m&eacute;todo :meth:`!__hash__` com  ``unsafe_hash=True``. Este pode ser o "
"caso se sua classe &eacute; logicamente imut&aacute;vel, mas na pr&aacute;tica pode ser mudada. "
"Esse &eacute; um caso de uso espec&iacute;fico e deve ser considerado com muito cuidado."

#: ../../library/dataclasses.rst:147
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 ""
"Essas s&atilde;o as regras governando a cria&ccedil;&atilde;o impl&iacute;cita de um m&eacute;todo  :meth:`!"
"__hash__`.  Observe que n&atilde;o pode ter um m&eacute;todo :meth:`!__hash__` expl&iacute;cito "
"na dataclass e configurar ``unsafe_hash=True``; isso resultar&aacute; em um :exc:"
"`TypeError`."

#: ../../library/dataclasses.rst:152
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 ""
"Se *eq* e *frozen* s&atilde;o ambos verdadeiros, por padr&atilde;o ``@dataclass`` vai "
"gerar um m&eacute;todo :meth:`!__hash__`. Se *eq* &eacute; verdadeiro e *frozen* &eacute; falso, :"
"meth:`!__hash__` ser&aacute; configurado para ``None``, marcando a classe como n&atilde;o-"
"hashe&aacute;vel (j&aacute; que &eacute; mut&aacute;vel). Se *eq* &eacute; falso, :meth:`!__hash__` ser&aacute; "
"deixado intocado, o que significa que o m&eacute;todo :meth:`!__hash__` da "
"superclasse ser&aacute; usado (se a superclasse &eacute; :class:`object`, significa que "
"voltar&aacute; para o hash baseado em id)."

#: ../../library/dataclasses.rst:160
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*: Se verdadeiro (o padr&atilde;o &eacute; ``False``), atribui&ccedil;&otilde;es para os campos "
"v&atilde;o gerar uma exce&ccedil;&atilde;o. Imita inst&acirc;ncias congeladas, somente leitura. Se :"
"meth:`~object.__setattr__` ou :meth:`~object.__delattr__` &eacute; definido na "
"classe, a exce&ccedil;&atilde;o :exc:`TypeError` &eacute; levantada. Veja a discuss&atilde;o abaixo."

#: ../../library/dataclasses.rst:165
msgid ""
"*match_args*: If true (the default is ``True``), the :attr:`~object."
"__match_args__` tuple will be created from the list of non keyword-only "
"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 ""

#: ../../library/dataclasses.rst:174
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. See the :term:`parameter` glossary entry for details.  Also see "
"the :const:`KW_ONLY` section."
msgstr ""

#: ../../library/dataclasses.rst:182
msgid "Keyword-only fields are not included in :attr:`!__match_args__`."
msgstr ""

#: ../../library/dataclasses.rst:186
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 ""

#: ../../library/dataclasses.rst:192
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 ""

#: ../../library/dataclasses.rst:199
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 ""

#: ../../library/dataclasses.rst:207
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 ""

#: ../../library/dataclasses.rst:217
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 ""

#: ../../library/dataclasses.rst:225
msgid ""
"``field``\\s may optionally specify a default value, using normal Python "
"syntax::"
msgstr ""
"``field``\\s pode opcionalmente especificar um valor padr&atilde;o, usando sintaxe "
"Python normal::"

#: ../../library/dataclasses.rst:228
msgid ""
"@dataclass\n"
"class C:\n"
"    a: int       # 'a' has no default value\n"
"    b: int = 0   # assign a default value for 'b'"
msgstr ""

#: ../../library/dataclasses.rst:233
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 ""

#: ../../library/dataclasses.rst:236
msgid "def __init__(self, a: int, b: int = 0):"
msgstr ""

#: ../../library/dataclasses.rst:238
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 ""
":exc:`TypeError` ser&aacute; levantada se um campo sem valor padr&atilde;o for definido "
"ap&oacute;s um campo com valor padr&atilde;o.  Isso &eacute; verdadeiro se ocorrer numa classe "
"simples, ou como resultado de uma heran&ccedil;a de classe."

#: ../../library/dataclasses.rst:244
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 ""

#: ../../library/dataclasses.rst:250
msgid ""
"@dataclass\n"
"class C:\n"
"    mylist: list[int] = field(default_factory=list)\n"
"\n"
"c = C()\n"
"c.mylist += [1, 2, 3]"
msgstr ""

#: ../../library/dataclasses.rst:257
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 mostrado acima, o valor :const:`MISSING` &eacute; um objeto sentinela usado "
"para detectar se alguns par&acirc;metros s&atilde;o fornecidos pelo usu&aacute;rio. Este "
"sentinela &eacute; usado porque ``None`` &eacute; um valor v&aacute;lido para alguns par&acirc;metros "
"com um significado distinto.  Nenhum c&oacute;digo deve usar diretamente o valor :"
"const:`MISSING`."

#: ../../library/dataclasses.rst:262
msgid "The parameters to :func:`!field` are:"
msgstr ""

#: ../../library/dataclasses.rst:264
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 ""

#: ../../library/dataclasses.rst:268
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 ""

#: ../../library/dataclasses.rst:274
msgid ""
"*init*: If true (the default), this field is included as a parameter to the "
"generated :meth:`~object.__init__` method."
msgstr ""

#: ../../library/dataclasses.rst:277
msgid ""
"*repr*: If true (the default), this field is included in the string returned "
"by the generated :meth:`~object.__repr__` method."
msgstr ""

#: ../../library/dataclasses.rst:280
msgid ""
"*hash*: This can be a bool or ``None``.  If true, this field is included in "
"the generated :meth:`~object.__hash__` method.  If false, this field is "
"excluded from the generated :meth:`~object.__hash__`. If ``None`` (the "
"default), use the value of *compare*: this would normally be the expected "
"behavior, since a field should be included in the hash if it's used for "
"comparisons.  Setting this value to anything other than ``None`` is "
"discouraged."
msgstr ""

#: ../../library/dataclasses.rst:288
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 ""
"Uma poss&iacute;vel raz&atilde;o para definir ``hash=False`` mas ``compare=True`` seria se "
"um campo for caro para calcular um valor de hash, esse campo for necess&aacute;rio "
"para teste de igualdade e houver outros campos que contribuem para o valor "
"de hash do tipo. Mesmo que um campo seja exclu&iacute;do do hash, ele ainda ser&aacute; "
"usado para compara&ccedil;&otilde;es."

#: ../../library/dataclasses.rst:294
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 ""

#: ../../library/dataclasses.rst:298
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 ""

#: ../../library/dataclasses.rst:306
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 ""

#: ../../library/dataclasses.rst:310
msgid "Keyword-only fields are also not included in :attr:`!__match_args__`."
msgstr ""

#: ../../library/dataclasses.rst:314
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 ""

#: ../../library/dataclasses.rst:323
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 ""

#: ../../library/dataclasses.rst:330
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 ""

#: ../../library/dataclasses.rst:336
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 ""

#: ../../library/dataclasses.rst:341
msgid ":attr:`!name`: The name of the field."
msgstr ""

#: ../../library/dataclasses.rst:342
msgid ":attr:`!type`: The type of the field."
msgstr ""

#: ../../library/dataclasses.rst:343
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 ""

#: ../../library/dataclasses.rst:347
msgid ""
"Other attributes may exist, but they are private and must not be inspected "
"or relied on."
msgstr ""
"Outros atributos podem existir, mas s&atilde;o privados e n&atilde;o devem ser "
"inspecionados ou confi&aacute;veis."

#: ../../library/dataclasses.rst:352
msgid ""
"``InitVar[T]`` type annotations describe variables that are :ref:`init-only "
"<dataclasses-init-only-variables>`. Fields annotated with :class:`!InitVar` "
"are considered pseudo-fields, and thus are neither returned by the :func:"
"`fields` function nor used in any way except adding them as parameters to :"
"meth:`~object.__init__` and an optional :meth:`__post_init__`."
msgstr ""

#: ../../library/dataclasses.rst:361
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 uma tupla de objetos :class:`Field` que definem os campos para esta "
"classe de dados. Aceita uma classe de dados ou uma inst&acirc;ncia de uma classe "
"de dados. Levanta :exc:`TypeError` se n&atilde;o for passada uma classe de dados ou "
"inst&acirc;ncia de uma. N&atilde;o retorna pseudocampos que s&atilde;o ``ClassVar`` ou "
"``InitVar``."

#: ../../library/dataclasses.rst:368
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 ""

#: ../../library/dataclasses.rst:374
msgid "Example of using :func:`!asdict` on nested dataclasses::"
msgstr ""

#: ../../library/dataclasses.rst:376
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 ""

#: ../../library/dataclasses.rst:391 ../../library/dataclasses.rst:411
msgid "To create a shallow copy, the following workaround may be used::"
msgstr ""
"Para criar uma c&oacute;pia rasa, a seguinte solu&ccedil;&atilde;o alternativa pode ser usada::"

#: ../../library/dataclasses.rst:393
msgid "{field.name: getattr(obj, field.name) for field in fields(obj)}"
msgstr ""

#: ../../library/dataclasses.rst:395
msgid ""
":func:`!asdict` raises :exc:`TypeError` if *obj* is not a dataclass instance."
msgstr ""

#: ../../library/dataclasses.rst:400
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 ""

#: ../../library/dataclasses.rst:406
msgid "Continuing from the previous example::"
msgstr "Continuando a partir do exemplo anterior::"

#: ../../library/dataclasses.rst:408
msgid ""
"assert astuple(p) == (10, 20)\n"
"assert astuple(c) == ([(0, 0), (10, 4)],)"
msgstr ""

#: ../../library/dataclasses.rst:413
msgid "tuple(getattr(obj, field.name) for field in dataclasses.fields(obj))"
msgstr ""

#: ../../library/dataclasses.rst:415
msgid ""
":func:`!astuple` raises :exc:`TypeError` if *obj* is not a dataclass "
"instance."
msgstr ""

#: ../../library/dataclasses.rst:420
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 ""

#: ../../library/dataclasses.rst:430
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 ""

#: ../../library/dataclasses.rst:434
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 ""

#: ../../library/dataclasses.rst:440
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 ""

#: ../../library/dataclasses.rst:446
msgid "Is equivalent to::"
msgstr "&Eacute; equivalente a::"

#: ../../library/dataclasses.rst:448
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 ""

#: ../../library/dataclasses.rst:459
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 ""

#: ../../library/dataclasses.rst:464
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 ""

#: ../../library/dataclasses.rst:468
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 ""

#: ../../library/dataclasses.rst:472
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 ""

#: ../../library/dataclasses.rst:476
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 ""

#: ../../library/dataclasses.rst:485
msgid ""
"Dataclass instances are also supported by generic function :func:`copy."
"replace`."
msgstr ""

#: ../../library/dataclasses.rst:489
msgid ""
"Return ``True`` if its parameter is a dataclass (including subclasses of a "
"dataclass) or an instance of one, otherwise return ``False``."
msgstr ""

#: ../../library/dataclasses.rst:492
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 ""
"Se voc&ecirc; precisa saber se a classe &eacute; uma inst&acirc;ncia de dataclass (e n&atilde;o a "
"dataclass de fato), ent&atilde;o adicione uma verifica&ccedil;&atilde;o para ``not "
"isinstance(obj, type)``::"

#: ../../library/dataclasses.rst:496
msgid ""
"def is_dataclass_instance(obj):\n"
"    return is_dataclass(obj) and not isinstance(obj, type)"
msgstr ""

#: ../../library/dataclasses.rst:501
msgid "A sentinel value signifying a missing default or default_factory."
msgstr ""

#: ../../library/dataclasses.rst:505
msgid ""
"A sentinel value used as a type annotation.  Any fields after a pseudo-field "
"with the type of :const:`!KW_ONLY` are marked as keyword-only fields.  Note "
"that a pseudo-field of type :const:`!KW_ONLY` is otherwise completely "
"ignored.  This includes the name of such a field.  By convention, a name of "
"``_`` is used for a :const:`!KW_ONLY` field.  Keyword-only fields signify :"
"meth:`~object.__init__` parameters that must be specified as keywords when "
"the class is instantiated."
msgstr ""

#: ../../library/dataclasses.rst:514
msgid ""
"In this example, the fields ``y`` and ``z`` will be marked as keyword-only "
"fields::"
msgstr ""

#: ../../library/dataclasses.rst:516
msgid ""
"@dataclass\n"
"class Point:\n"
"    x: float\n"
"    _: KW_ONLY\n"
"    y: float\n"
"    z: float\n"
"\n"
"p = Point(0, y=1.5, z=2.0)"
msgstr ""

#: ../../library/dataclasses.rst:525
msgid ""
"In a single dataclass, it is an error to specify more than one field whose "
"type is :const:`!KW_ONLY`."
msgstr ""

#: ../../library/dataclasses.rst:532
msgid ""
"Raised when an implicitly defined :meth:`~object.__setattr__` or :meth:"
"`~object.__delattr__` is called on a dataclass which was defined with "
"``frozen=True``. It is a subclass of :exc:`AttributeError`."
msgstr ""

#: ../../library/dataclasses.rst:539
msgid "Post-init processing"
msgstr "Processamento p&oacute;s-inicializa&ccedil;&atilde;o"

#: ../../library/dataclasses.rst:543
msgid ""
"When defined on the class, it will be called by the generated :meth:`~object."
"__init__`, normally as :meth:`!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 ""

#: ../../library/dataclasses.rst:550
msgid ""
"Among other uses, this allows for initializing field values that depend on "
"one or more other fields.  For example::"
msgstr ""

#: ../../library/dataclasses.rst:553
msgid ""
"@dataclass\n"
"class C:\n"
"    a: float\n"
"    b: float\n"
"    c: float = field(init=False)\n"
"\n"
"    def __post_init__(self):\n"
"        self.c = self.a + self.b"
msgstr ""

#: ../../library/dataclasses.rst:562
msgid ""
"The :meth:`~object.__init__` method generated by :func:`@dataclass "
"<dataclass>` does not call base class :meth:`!__init__` methods. If the base "
"class has an :meth:`!__init__` method that has to be called, it is common to "
"call this method in a :meth:`__post_init__` method::"
msgstr ""

#: ../../library/dataclasses.rst:567
msgid ""
"class Rectangle:\n"
"    def __init__(self, height, width):\n"
"        self.height = height\n"
"        self.width = width\n"
"\n"
"@dataclass\n"
"class Square(Rectangle):\n"
"    side: float\n"
"\n"
"    def __post_init__(self):\n"
"        super().__init__(self.side, self.side)"
msgstr ""

#: ../../library/dataclasses.rst:579
msgid ""
"Note, however, that in general the dataclass-generated :meth:`!__init__` "
"methods don't need to be called, since the derived dataclass will take care "
"of initializing all fields of any base class that is a dataclass itself."
msgstr ""

#: ../../library/dataclasses.rst:583
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 ""

#: ../../library/dataclasses.rst:590
msgid "Class variables"
msgstr "Vari&aacute;veis de classe"

#: ../../library/dataclasses.rst:592
msgid ""
"One of the few places where :func:`@dataclass <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 :data:`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 ""

#: ../../library/dataclasses.rst:603
msgid "Init-only variables"
msgstr "Vari&aacute;veis de inicializa&ccedil;&atilde;o apenas"

#: ../../library/dataclasses.rst:605
msgid ""
"Another place where :func:`@dataclass <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 :class:`InitVar`.  If a "
"field is an :class:`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:`~object.__init__` method, and are passed to the "
"optional :meth:`__post_init__` method.  They are not otherwise used by "
"dataclasses."
msgstr ""

#: ../../library/dataclasses.rst:615
msgid ""
"For example, suppose a field will be initialized from a database, if a value "
"is not provided when creating the class::"
msgstr ""

#: ../../library/dataclasses.rst:618
msgid ""
"@dataclass\n"
"class C:\n"
"    i: int\n"
"    j: int | None = None\n"
"    database: InitVar[DatabaseType | None] = None\n"
"\n"
"    def __post_init__(self, database):\n"
"        if self.j is None and database is not None:\n"
"            self.j = database.lookup('j')\n"
"\n"
"c = C(10, database=my_database)"
msgstr ""

#: ../../library/dataclasses.rst:630
msgid ""
"In this case, :func:`fields` will return :class:`Field` objects for :attr:`!"
"i` and :attr:`!j`, but not for :attr:`!database`."
msgstr ""

#: ../../library/dataclasses.rst:636
msgid "Frozen instances"
msgstr ""

#: ../../library/dataclasses.rst:638
msgid ""
"It is not possible to create truly immutable Python objects.  However, by "
"passing ``frozen=True`` to the :func:`@dataclass <dataclass>` decorator you "
"can emulate immutability.  In that case, dataclasses will add :meth:`~object."
"__setattr__` and :meth:`~object.__delattr__` methods to the class.  These "
"methods will raise a :exc:`FrozenInstanceError` when invoked."
msgstr ""

#: ../../library/dataclasses.rst:644
msgid ""
"There is a tiny performance penalty when using ``frozen=True``: :meth:"
"`~object.__init__` cannot use simple assignment to initialize fields, and "
"must use :meth:`!object.__setattr__`."
msgstr ""

#: ../../library/dataclasses.rst:653
msgid "Inheritance"
msgstr "Heran&ccedil;a"

#: ../../library/dataclasses.rst:655
msgid ""
"When the dataclass is being created by the :func:`@dataclass <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 ""

#: ../../library/dataclasses.rst:665
msgid ""
"@dataclass\n"
"class Base:\n"
"    x: Any = 15.0\n"
"    y: int = 0\n"
"\n"
"@dataclass\n"
"class C(Base):\n"
"    z: int = 10\n"
"    x: int = 15"
msgstr ""

#: ../../library/dataclasses.rst:675
msgid ""
"The final list of fields is, in order, :attr:`!x`, :attr:`!y`, :attr:`!z`.  "
"The final type of :attr:`!x` is :class:`int`, as specified in class :class:`!"
"C`."
msgstr ""

#: ../../library/dataclasses.rst:678
msgid ""
"The generated :meth:`~object.__init__` method for :class:`!C` will look "
"like::"
msgstr ""

#: ../../library/dataclasses.rst:680
msgid "def __init__(self, x: int = 15, y: int = 0, z: int = 10):"
msgstr ""

#: ../../library/dataclasses.rst:683
msgid "Re-ordering of keyword-only parameters in :meth:`!__init__`"
msgstr ""

#: ../../library/dataclasses.rst:685
msgid ""
"After the parameters needed for :meth:`~object.__init__` are computed, any "
"keyword-only parameters are moved to come after all regular (non-keyword-"
"only) parameters.  This is a requirement of how keyword-only parameters are "
"implemented in Python: they must come after non-keyword-only parameters."
msgstr ""

#: ../../library/dataclasses.rst:691
msgid ""
"In this example, :attr:`!Base.y`, :attr:`!Base.w`, and :attr:`!D.t` are "
"keyword-only fields, and :attr:`!Base.x` and :attr:`!D.z` are regular "
"fields::"
msgstr ""

#: ../../library/dataclasses.rst:694
msgid ""
"@dataclass\n"
"class Base:\n"
"    x: Any = 15.0\n"
"    _: KW_ONLY\n"
"    y: int = 0\n"
"    w: int = 1\n"
"\n"
"@dataclass\n"
"class D(Base):\n"
"    z: int = 10\n"
"    t: int = field(kw_only=True, default=0)"
msgstr ""

#: ../../library/dataclasses.rst:706
msgid "The generated :meth:`!__init__` method for :class:`!D` will look like::"
msgstr ""

#: ../../library/dataclasses.rst:708
msgid ""
"def __init__(self, x: Any = 15.0, z: int = 10, *, y: int = 0, w: int = 1, t: "
"int = 0):"
msgstr ""

#: ../../library/dataclasses.rst:710
msgid ""
"Note that the parameters have been re-ordered from how they appear in the "
"list of fields: parameters derived from regular fields are followed by "
"parameters derived from keyword-only fields."
msgstr ""

#: ../../library/dataclasses.rst:714
msgid ""
"The relative ordering of keyword-only parameters is maintained in the re-"
"ordered :meth:`!__init__` parameter list."
msgstr ""

#: ../../library/dataclasses.rst:719
msgid "Default factory functions"
msgstr "Fun&ccedil;&otilde;es padr&atilde;o de f&aacute;brica"

#: ../../library/dataclasses.rst:721
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 ""

#: ../../library/dataclasses.rst:725
msgid "mylist: list = field(default_factory=list)"
msgstr ""

#: ../../library/dataclasses.rst:727
msgid ""
"If a field is excluded from :meth:`~object.__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 ""

#: ../../library/dataclasses.rst:734
msgid "Mutable default values"
msgstr "Valores padr&atilde;o mut&aacute;veis"

#: ../../library/dataclasses.rst:736
msgid ""
"Python stores default member variable values in class attributes. Consider "
"this example, not using dataclasses::"
msgstr ""

#: ../../library/dataclasses.rst:739
msgid ""
"class C:\n"
"    x = []\n"
"    def add(self, element):\n"
"        self.x.append(element)\n"
"\n"
"o1 = C()\n"
"o2 = C()\n"
"o1.add(1)\n"
"o2.add(2)\n"
"assert o1.x == [1, 2]\n"
"assert o1.x is o2.x"
msgstr ""

#: ../../library/dataclasses.rst:751
msgid ""
"Note that the two instances of class :class:`!C` share the same class "
"variable :attr:`!x`, as expected."
msgstr ""

#: ../../library/dataclasses.rst:754
msgid "Using dataclasses, *if* this code was valid::"
msgstr "Usando dataclasses, *se* este c&oacute;digo fosse v&aacute;lido::"

#: ../../library/dataclasses.rst:756
msgid ""
"@dataclass\n"
"class D:\n"
"    x: list = []      # This code raises ValueError\n"
"    def add(self, element):\n"
"        self.x.append(element)"
msgstr ""

#: ../../library/dataclasses.rst:762
msgid "it would generate code similar to::"
msgstr "Geraria c&oacute;digo similar a::"

#: ../../library/dataclasses.rst:764
msgid ""
"class D:\n"
"    x = []\n"
"    def __init__(self, x=x):\n"
"        self.x = x\n"
"    def add(self, element):\n"
"        self.x.append(element)\n"
"\n"
"assert D().x is D().x"
msgstr ""

#: ../../library/dataclasses.rst:773
msgid ""
"This has the same issue as the original example using class :class:`!C`. "
"That is, two instances of class :class:`!D` that do not specify a value for :"
"attr:`!x` when creating a class instance will share the same copy of :attr:`!"
"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, the :func:`@dataclass <dataclass>` decorator will "
"raise a :exc:`ValueError` if it detects an unhashable default parameter.  "
"The assumption is that if a value is unhashable, it is mutable.  This is a "
"partial solution, but it does protect against many common errors."
msgstr ""

#: ../../library/dataclasses.rst:784
msgid ""
"Using default factory functions is a way to create new instances of mutable "
"types as default values for fields::"
msgstr ""

#: ../../library/dataclasses.rst:787
msgid ""
"@dataclass\n"
"class D:\n"
"    x: list = field(default_factory=list)\n"
"\n"
"assert D().x is not D().x"
msgstr ""

#: ../../library/dataclasses.rst:793
msgid ""
"Instead of looking for and disallowing objects of type :class:`list`, :class:"
"`dict`, or :class:`set`, unhashable objects are now not allowed as default "
"values.  Unhashability is used to approximate mutability."
msgstr ""

#: ../../library/dataclasses.rst:800
msgid "Descriptor-typed fields"
msgstr ""

#: ../../library/dataclasses.rst:802
msgid ""
"Fields that are assigned :ref:`descriptor objects <descriptors>` as their "
"default value have the following special behaviors:"
msgstr ""

#: ../../library/dataclasses.rst:805
msgid ""
"The value for the field passed to the dataclass's :meth:`~object.__init__` "
"method is passed to the descriptor's :meth:`~object.__set__` method rather "
"than overwriting the descriptor object."
msgstr ""

#: ../../library/dataclasses.rst:809
msgid ""
"Similarly, when getting or setting the field, the descriptor's :meth:"
"`~object.__get__` or :meth:`!__set__` method is called rather than returning "
"or overwriting the descriptor object."
msgstr ""

#: ../../library/dataclasses.rst:813
msgid ""
"To determine whether a field contains a default value, :func:`@dataclass "
"<dataclass>` will call the descriptor's :meth:`!__get__` method using its "
"class access form: ``descriptor.__get__(obj=None, type=cls)``.  If the "
"descriptor returns a value in this case, it will be used as the field's "
"default. On the other hand, if the descriptor raises :exc:`AttributeError` "
"in this situation, no default value will be provided for the field."
msgstr ""

#: ../../library/dataclasses.rst:823
msgid ""
"class IntConversionDescriptor:\n"
"    def __init__(self, *, default):\n"
"        self._default = default\n"
"\n"
"    def __set_name__(self, owner, name):\n"
"        self._name = \"_\" + name\n"
"\n"
"    def __get__(self, obj, type):\n"
"        if obj is None:\n"
"            return self._default\n"
"\n"
"        return getattr(obj, self._name, self._default)\n"
"\n"
"    def __set__(self, obj, value):\n"
"        setattr(obj, self._name, int(value))\n"
"\n"
"@dataclass\n"
"class InventoryItem:\n"
"    quantity_on_hand: IntConversionDescriptor = "
"IntConversionDescriptor(default=100)\n"
"\n"
"i = InventoryItem()\n"
"print(i.quantity_on_hand)   # 100\n"
"i.quantity_on_hand = 2.5    # calls __set__ with 2.5\n"
"print(i.quantity_on_hand)   # 2"
msgstr ""

#: ../../library/dataclasses.rst:848
msgid ""
"Note that if a field is annotated with a descriptor type, but is not "
"assigned a descriptor object as its default value, the field will act like a "
"normal field."
msgstr ""