# 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: 2026-02-26 18:44-0300\n"

"PO-Revision-Date: 2023-03-17 17:40-0600\n"

"Last-Translator: Rodrigo Tobar <rtobarc@gmail.com>\n"

"Language: 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.18.0\n"

#: ../Doc/howto/descriptor.rst:5

#, fuzzy

msgid "Descriptor Guide"

msgstr "Guía práctica de uso de los descriptores"

#: ../Doc/howto/descriptor.rst

msgid "Author"

msgstr "Autor"

#: ../Doc/howto/descriptor.rst:7

msgid "Raymond Hettinger"

msgstr "Raymond Hettinger"

#: ../Doc/howto/descriptor.rst

msgid "Contact"

msgstr "Contacto"

#: ../Doc/howto/descriptor.rst:8

msgid "<python at rcn dot com>"

msgstr "<python at rcn dot com>"

#: ../Doc/howto/descriptor.rst:11

msgid "Contents"

msgstr "Contenidos"

#: ../Doc/howto/descriptor.rst:13

msgid ""

":term:`Descriptors <descriptor>` let objects customize attribute lookup, "

"storage, and deletion."

msgstr ""

"Los :term:`descriptores <descriptor>` permiten a objetos personalizar la "

"búsqueda, almacenamiento y eliminación de atributos."

#: ../Doc/howto/descriptor.rst:16

msgid "This guide has four major sections:"

msgstr "Esta guía tiene cuatro secciones principales:"

#: ../Doc/howto/descriptor.rst:18

msgid ""

"The \"primer\" gives a basic overview, moving gently from simple examples, "

"adding one feature at a time. Start here if you're new to descriptors."

msgstr ""

"La guía introductoria da una visión general básica, moviéndose gentilmente "

"por ejemplos simples, añadiendo una funcionalidad a la vez. Comienza acá si "

"eres nuevo con los descriptores."

#: ../Doc/howto/descriptor.rst:21

msgid ""

"The second section shows a complete, practical descriptor example. If you "

"already know the basics, start there."

msgstr ""

"La segunda sección muestra un ejemplo completo y práctico de un descriptor. "

"Si ya sabes lo básico comienza acá."

#: ../Doc/howto/descriptor.rst:24

msgid ""

"The third section provides a more technical tutorial that goes into the "

"detailed mechanics of how descriptors work. Most people don't need this "

"level of detail."

msgstr ""

"La tercera sección provee un tutorial más técnico que adentra en la mecánica "

"detallada de cómo funcionan los descriptores. La mayoría de la gente no "

"necesita este nivel de detalle."

#: ../Doc/howto/descriptor.rst:28

msgid ""

"The last section has pure Python equivalents for built-in descriptors that "

"are written in C. Read this if you're curious about how functions turn into "

"bound methods or about the implementation of common tools like :func:"

"`classmethod`, :func:`staticmethod`, :func:`property`, and :term:`__slots__`."

msgstr ""

"La última sección tiene equivalentes en Python puro para descriptores "

"incorporados que están escritos en C. Lee esta sección si tienes curiosidad "

"de cómo las funciones se convierten en métodos vinculados, o sobre la "

"implementación de herramientas comunes como :func:`classmethod`, :func:"

"`staticmethod`, :func:`property`, y :term:`__slots__`."

#: ../Doc/howto/descriptor.rst:36

msgid "Primer"

msgstr "Guía introductoria"

#: ../Doc/howto/descriptor.rst:38

msgid ""

"In this primer, we start with the most basic possible example and then we'll "

"add new capabilities one by one."

msgstr ""

"En esta guía introductoria comenzamos con el ejemplo más básico posible y "

"luego vamos añadiendo nuevas funcionalidades una a una."

#: ../Doc/howto/descriptor.rst:43

msgid "Simple example: A descriptor that returns a constant"

msgstr "Ejemplo simple: un descriptor que retorna una constante"

#: ../Doc/howto/descriptor.rst:45

#, fuzzy

msgid ""

"The :class:`!Ten` class is a descriptor whose :meth:`~object.__get__` method "

"always returns the constant ``10``:"

msgstr ""

"La clase :class:`Ten` es un descriptor cuyo método :meth:`__get__` siempre "

"retorna la constante ``10``:"

#: ../Doc/howto/descriptor.rst:48

msgid ""

"class Ten:\n"

" def __get__(self, obj, objtype=None):\n"

" return 10"

msgstr ""

#: ../Doc/howto/descriptor.rst:54

msgid ""

"To use the descriptor, it must be stored as a class variable in another "

"class:"

msgstr ""

"Para usar el descriptor, éste se debe almacenar como una variable de clase "

"en otra clase:"

#: ../Doc/howto/descriptor.rst:56

msgid ""

"class A:\n"

" x = 5 # Regular class attribute\n"

" y = Ten() # Descriptor instance"

msgstr ""

#: ../Doc/howto/descriptor.rst:62

msgid ""

"An interactive session shows the difference between normal attribute lookup "

"and descriptor lookup:"

msgstr ""

"Una sesión interactiva muestra la diferencia entre un la búsqueda de "

"atributo normal y la búsqueda a través del descriptor:"

#: ../Doc/howto/descriptor.rst:65

msgid ""

">>> a = A() # Make an instance of class A\n"

">>> a.x # Normal attribute lookup\n"

"5\n"

">>> a.y # Descriptor lookup\n"

"10"

msgstr ""

#: ../Doc/howto/descriptor.rst:73

msgid ""

"In the ``a.x`` attribute lookup, the dot operator finds ``'x': 5`` in the "

"class dictionary. In the ``a.y`` lookup, the dot operator finds a "

"descriptor instance, recognized by its ``__get__`` method. Calling that "

"method returns ``10``."

msgstr ""

"En la búsqueda de atributo ``a.x``, el operador punto encuentra ``'x': 5`` "

"en el diccionario de la clase. En la búsqueda ``a.y``, el operador punto "

"encuentra una instancia de un descriptor, reconocible por su método "

"``__get__``. Llamar a ese método retorna ``10``."

#: ../Doc/howto/descriptor.rst:78

msgid ""

"Note that the value ``10`` is not stored in either the class dictionary or "

"the instance dictionary. Instead, the value ``10`` is computed on demand."

msgstr ""

"Nota que el valor ``10`` no es almacenado ni en el diccionario de la clase "

"ni en el diccionario de la instancia. En cambio, el valor ``10`` es "

"calculado bajo demanda."

#: ../Doc/howto/descriptor.rst:81

msgid ""

"This example shows how a simple descriptor works, but it isn't very useful. "

"For retrieving constants, normal attribute lookup would be better."

msgstr ""

"Este ejemplo muestra cómo funciona un descriptor simple, pero no es muy "

"útil. Para recuperar constantes una búsqueda de atributos normal sería mejor."

#: ../Doc/howto/descriptor.rst:84

msgid ""

"In the next section, we'll create something more useful, a dynamic lookup."

msgstr "En la próxima sección crearemos algo más útil, una búsqueda dinámica."

#: ../Doc/howto/descriptor.rst:88

msgid "Dynamic lookups"

msgstr "Búsquedas dinámicas"

#: ../Doc/howto/descriptor.rst:90

msgid ""

"Interesting descriptors typically run computations instead of returning "

"constants:"

msgstr ""

"Descriptores interesantes típicamente ejecutan cálculos en vez de retornar "

"constantes:"

#: ../Doc/howto/descriptor.rst:93

msgid ""

"import os\n"

"\n"

"class DirectorySize:\n"

"\n"

" def __get__(self, obj, objtype=None):\n"

" return len(os.listdir(obj.dirname))\n"

"\n"

"class Directory:\n"

"\n"

" size = DirectorySize() # Descriptor instance\n"

"\n"

" def __init__(self, dirname):\n"

" self.dirname = dirname # Regular instance attribute"

msgstr ""

#: ../Doc/howto/descriptor.rst:109

msgid ""

"An interactive session shows that the lookup is dynamic — it computes "

"different, updated answers each time::"

msgstr ""

"Una sesión interactiva muestra que la búsqueda es dinámica — calcula "

"respuestas diferentes y actualizadas en cada ocasión::"

#: ../Doc/howto/descriptor.rst:112

msgid ""

">>> s = Directory('songs')\n"

">>> g = Directory('games')\n"

">>> s.size # The songs directory has twenty "

"files\n"

"20\n"

">>> g.size # The games directory has three "

"files\n"

"3\n"

">>> os.remove('games/chess') # Delete a game\n"

">>> g.size # File count is automatically "

"updated\n"

"2"

msgstr ""

#: ../Doc/howto/descriptor.rst:122

#, fuzzy

msgid ""

"Besides showing how descriptors can run computations, this example also "

"reveals the purpose of the parameters to :meth:`~object.__get__`. The "

"*self* parameter is *size*, an instance of *DirectorySize*. The *obj* "

"parameter is either *g* or *s*, an instance of *Directory*. It is the *obj* "

"parameter that lets the :meth:`~object.__get__` method learn the target "

"directory. The *objtype* parameter is the class *Directory*."

msgstr ""

"Además de mostrar cómo los descriptores puede ejecutar cálculos, este "

"ejemplo también revela el propósitos de los parámetros de :meth:`__get__`. "

"El parámetro *self* es *size*, una instancia de *DirectorySize*. El "

"parámetro *obj* es *g* o *s*, una instancia de *Directory*. Es el parámetro "

"*obj* el que permite que al método :meth:`__get__` saber el directorio "

"objetivo. El parámetro *objtype* es una clase *Directory*."

#: ../Doc/howto/descriptor.rst:131

msgid "Managed attributes"

msgstr "Atributos gestionados"

#: ../Doc/howto/descriptor.rst:133

#, fuzzy

msgid ""

"A popular use for descriptors is managing access to instance data. The "

"descriptor is assigned to a public attribute in the class dictionary while "

"the actual data is stored as a private attribute in the instance "

"dictionary. The descriptor's :meth:`~object.__get__` and :meth:`~object."

"__set__` methods are triggered when the public attribute is accessed."

msgstr ""

"Un uso popular de descriptores es la gestión de acceso a datos de una "

"instancia. El descriptor se asigna a un atributo público en el diccionario "

"de clase, mientras que los datos reales se guardan en atributos privados en "

"el diccionario de instancia. Los métodos :meth:`__get__` and :meth:`__set__` "

"del descriptor se activan cuando se accede al atributo público."

#: ../Doc/howto/descriptor.rst:139

msgid ""

"In the following example, *age* is the public attribute and *_age* is the "

"private attribute. When the public attribute is accessed, the descriptor "

"logs the lookup or update:"

msgstr ""

"En el siguiente ejemplo, *age* es el atributo público y *_age* es el "

"atributo privado. Cuando el atributo público es accedido, el descriptor "

"registra la búsqueda o actualización:"

#: ../Doc/howto/descriptor.rst:143

#, python-format

msgid ""

"import logging\n"

"\n"

"logging.basicConfig(level=logging.INFO)\n"

"\n"

"class LoggedAgeAccess:\n"

"\n"

" def __get__(self, obj, objtype=None):\n"

" value = obj._age\n"

" logging.info('Accessing %r giving %r', 'age', value)\n"

" return value\n"

"\n"

" def __set__(self, obj, value):\n"

" logging.info('Updating %r to %r', 'age', value)\n"

" obj._age = value\n"

"\n"

"class Person:\n"

"\n"

" age = LoggedAgeAccess() # Descriptor instance\n"

"\n"

" def __init__(self, name, age):\n"

" self.name = name # Regular instance attribute\n"

" self.age = age # Calls __set__()\n"

"\n"

" def birthday(self):\n"

" self.age += 1 # Calls both __get__() and __set__()"

msgstr ""

#: ../Doc/howto/descriptor.rst:172

msgid ""

"An interactive session shows that all access to the managed attribute *age* "

"is logged, but that the regular attribute *name* is not logged:"

msgstr ""

"Una sesión interactiva muestra que todos los accesos al atributo gestionado "

"*age* son registrados, pero que el atributo normal *name* no es registrado:"

#: ../Doc/howto/descriptor.rst:181

#, python-brace-format

msgid ""

">>> mary = Person('Mary M', 30) # The initial age update is logged\n"

"INFO:root:Updating 'age' to 30\n"

">>> dave = Person('David D', 40)\n"

"INFO:root:Updating 'age' to 40\n"

"\n"

">>> vars(mary) # The actual data is in a private "

"attribute\n"

"{'name': 'Mary M', '_age': 30}\n"

">>> vars(dave)\n"

"{'name': 'David D', '_age': 40}\n"

"\n"

">>> mary.age # Access the data and log the "

"lookup\n"

"INFO:root:Accessing 'age' giving 30\n"

"30\n"

">>> mary.birthday() # Updates are logged as well\n"

"INFO:root:Accessing 'age' giving 30\n"

"INFO:root:Updating 'age' to 31\n"

"\n"

">>> dave.name # Regular attribute lookup isn't "

"logged\n"

"'David D'\n"

">>> dave.age # Only the managed attribute is "

"logged\n"

"INFO:root:Accessing 'age' giving 40\n"

"40"

msgstr ""

#: ../Doc/howto/descriptor.rst:206

msgid ""

"One major issue with this example is that the private name *_age* is "

"hardwired in the *LoggedAgeAccess* class. That means that each instance can "

"only have one logged attribute and that its name is unchangeable. In the "

"next example, we'll fix that problem."

msgstr ""

"Un gran problema con este ejemplo es que el nombre privado *_age* está "

"fijado en la clase *LoggedAgeAccess*. Esto significa que cada instancia "

"puede sólo puede registrar un atributo, y que su nombre no se puede cambiar. "

"En el siguiente ejemplo solucionaremos ese problema."

#: ../Doc/howto/descriptor.rst:213

msgid "Customized names"

msgstr "Nombres personalizados"

#: ../Doc/howto/descriptor.rst:215

msgid ""

"When a class uses descriptors, it can inform each descriptor about which "

"variable name was used."

msgstr ""

"Cuando una clase usa descriptores, puede informar a cada descriptor el "

"nombre se usó para la variable."

#: ../Doc/howto/descriptor.rst:218

#, fuzzy

msgid ""

"In this example, the :class:`!Person` class has two descriptor instances, "

"*name* and *age*. When the :class:`!Person` class is defined, it makes a "

"callback to :meth:`~object.__set_name__` in *LoggedAccess* so that the field "

"names can be recorded, giving each descriptor its own *public_name* and "

"*private_name*:"

msgstr ""

"En este ejemplo, la clase :class:`Person` tiene dos instancias de "

"descriptores, *name* y *age*. Cuando la clase :class:`Person` se define, "

"hace una retrollamada a :meth:`__set_name__` en *LoggedAccess* para que se "

"pueda registrar los nombres de los campos, dándole a cada descriptor su "

"propio *public_name* y *private_name*:"

#: ../Doc/howto/descriptor.rst:223

#, python-format

msgid ""

"import logging\n"

"\n"

"logging.basicConfig(level=logging.INFO)\n"

"\n"

"class LoggedAccess:\n"

"\n"

" def __set_name__(self, owner, name):\n"

" self.public_name = name\n"

" self.private_name = '_' + name\n"

"\n"

" def __get__(self, obj, objtype=None):\n"

" value = getattr(obj, self.private_name)\n"

" logging.info('Accessing %r giving %r', self.public_name, value)\n"

" return value\n"

"\n"

" def __set__(self, obj, value):\n"

" logging.info('Updating %r to %r', self.public_name, value)\n"

" setattr(obj, self.private_name, value)\n"

"\n"

"class Person:\n"

"\n"

" name = LoggedAccess() # First descriptor instance\n"

" age = LoggedAccess() # Second descriptor instance\n"

"\n"

" def __init__(self, name, age):\n"

" self.name = name # Calls the first descriptor\n"

" self.age = age # Calls the second descriptor\n"

"\n"

" def birthday(self):\n"

" self.age += 1"

msgstr ""

#: ../Doc/howto/descriptor.rst:256

#, fuzzy

msgid ""

"An interactive session shows that the :class:`!Person` class has called :"

"meth:`~object.__set_name__` so that the field names would be recorded. Here "

"we call :func:`vars` to look up the descriptor without triggering it:"

msgstr ""

"Una sesión interactiva muestra que la clase :class:`Person` ha llamado a :"

"meth:`__set_name__` para que los nombres de los campos sean registrados. "

"Aquí llamamos a :func:`vars` para ver el descriptor sin activarlos:"

#: ../Doc/howto/descriptor.rst:260

#, python-brace-format

msgid ""

">>> vars(vars(Person)['name'])\n"

"{'public_name': 'name', 'private_name': '_name'}\n"

">>> vars(vars(Person)['age'])\n"

"{'public_name': 'age', 'private_name': '_age'}"

msgstr ""

#: ../Doc/howto/descriptor.rst:267

msgid "The new class now logs access to both *name* and *age*:"

msgstr "La nueva clase ahora registrar accesos tanto a *name* como a *age*:"

#: ../Doc/howto/descriptor.rst:275

msgid ""

">>> pete = Person('Peter P', 10)\n"

"INFO:root:Updating 'name' to 'Peter P'\n"

"INFO:root:Updating 'age' to 10\n"

">>> kate = Person('Catherine C', 20)\n"

"INFO:root:Updating 'name' to 'Catherine C'\n"

"INFO:root:Updating 'age' to 20"

msgstr ""

#: ../Doc/howto/descriptor.rst:284

msgid "The two *Person* instances contain only the private names:"

msgstr "Las dos instancias de *Person* contienen sólo los nombres privados::"

#: ../Doc/howto/descriptor.rst:286

#, python-brace-format

msgid ""

">>> vars(pete)\n"

"{'_name': 'Peter P', '_age': 10}\n"

">>> vars(kate)\n"

"{'_name': 'Catherine C', '_age': 20}"

msgstr ""

#: ../Doc/howto/descriptor.rst:295

msgid "Closing thoughts"

msgstr "Pensamientos finales"

#: ../Doc/howto/descriptor.rst:297

#, fuzzy

msgid ""

"A :term:`descriptor` is what we call any object that defines :meth:`~object."

"__get__`, :meth:`~object.__set__`, or :meth:`~object.__delete__`."

msgstr ""

"Llamamos un :term:`descriptor` a cualquier objeto que define :meth:"

"`__get__`, :meth:`__set__` o :meth:`__delete__`."

#: ../Doc/howto/descriptor.rst:300

#, fuzzy

msgid ""

"Optionally, descriptors can have a :meth:`~object.__set_name__` method. "

"This is only used in cases where a descriptor needs to know either the class "

"where it was created or the name of class variable it was assigned to. "

"(This method, if present, is called even if the class is not a descriptor.)"

msgstr ""

"Opcionalmente, los descriptores pueden tener un método :meth:`__set_name__`. "

"Éste sólo se usa en los casos en los que el descriptor necesita saber ya sea "

"la clase donde fue creado, o el nombre de la variable de clase a la que fue "

"asignado. (Este método, si está presente, es llamada incluso si la clase no "

"es un descriptor.)"

#: ../Doc/howto/descriptor.rst:305

msgid ""

"Descriptors get invoked by the dot operator during attribute lookup. If a "

"descriptor is accessed indirectly with ``vars(some_class)"

"[descriptor_name]``, the descriptor instance is returned without invoking it."

msgstr ""

"Los descriptores son invocados por el operador punto durante la búsqueda de "

"atributos. Si un descriptor es accedido indirectamente con ``vars(una_clase)"

"[nombre_del_descriptor]``, la instancia del descriptor es retornada sin ser "

"invocada."

#: ../Doc/howto/descriptor.rst:309

msgid ""

"Descriptors only work when used as class variables. When put in instances, "

"they have no effect."

msgstr ""

"Los descriptores sólo funcionan cuando se usan como variables de clase. "

"Cuando son puestos en una instancia no tienen efecto."

#: ../Doc/howto/descriptor.rst:312

msgid ""

"The main motivation for descriptors is to provide a hook allowing objects "

"stored in class variables to control what happens during attribute lookup."

msgstr ""

"La mayor motivación detrás de los descriptores es el proveer un gancho que "

"permita a los objetos guardados en variables de clase controlar lo que "

"ocurre al buscar un atributo."

#: ../Doc/howto/descriptor.rst:315

msgid ""

"Traditionally, the calling class controls what happens during lookup. "

"Descriptors invert that relationship and allow the data being looked-up to "

"have a say in the matter."

msgstr ""

"Tradicionalmente, la clase que llama controla qué ocurre durante la "

"búsqueda. Los descriptores invierten esta relación y permiten que los datos "

"que están siendo buscados tengan algo qué decir al respecto."

#: ../Doc/howto/descriptor.rst:319

msgid ""

"Descriptors are used throughout the language. It is how functions turn into "

"bound methods. Common tools like :func:`classmethod`, :func:"

"`staticmethod`, :func:`property`, and :func:`functools.cached_property` are "

"all implemented as descriptors."

msgstr ""

"Los descriptores se usan a través de todo el lenguaje. Es cómo funciones se "

"convierten en métodos vinculados. Herramientas comunes como :func:"

"`classmethod`, :func:`staticmethod`, :func:`property`, y :func:`functools."

"cached_property` se implementan todas como descriptores."

#: ../Doc/howto/descriptor.rst:326

msgid "Complete Practical Example"

msgstr "Ejemplo completo práctico"

#: ../Doc/howto/descriptor.rst:328

msgid ""

"In this example, we create a practical and powerful tool for locating "

"notoriously hard to find data corruption bugs."

msgstr ""

"En este ejemplo creamos una herramienta práctica y poderosa para encontrar "

"errores de corrupción de datos que son notoriamente difíciles de encontrar."

#: ../Doc/howto/descriptor.rst:333

msgid "Validator class"

msgstr "Clase validadora"

#: ../Doc/howto/descriptor.rst:335

msgid ""

"A validator is a descriptor for managed attribute access. Prior to storing "

"any data, it verifies that the new value meets various type and range "

"restrictions. If those restrictions aren't met, it raises an exception to "

"prevent data corruption at its source."

msgstr ""

"Un validador es un descriptor que da acceso a un atributo gestionado. Antes "

"de almacenar cualquier dato, verifica que el nuevo valor cumple con varias "

"restricciones de tipo y rango. Si esas restricciones no se cumplen, lanza "

"una excepción para así prevenir corrupción de datos en su origen."

#: ../Doc/howto/descriptor.rst:340

#, fuzzy

msgid ""

"This :class:`!Validator` class is both an :term:`abstract base class` and a "

"managed attribute descriptor:"

msgstr ""

"Esta clase :class:`Validator` es una tanto una :term:`clase base abstracta "

"<abstract base class>` como un descriptor de un atributo gestionado:"

#: ../Doc/howto/descriptor.rst:343

msgid ""

"from abc import ABC, abstractmethod\n"

"\n"

"class Validator(ABC):\n"

"\n"

" def __set_name__(self, owner, name):\n"

" self.private_name = '_' + name\n"

"\n"

" def __get__(self, obj, objtype=None):\n"

" return getattr(obj, self.private_name)\n"

"\n"

" def __set__(self, obj, value):\n"

" self.validate(value)\n"

" setattr(obj, self.private_name, value)\n"

"\n"

" @abstractmethod\n"

" def validate(self, value):\n"

" pass"

msgstr ""

#: ../Doc/howto/descriptor.rst:363

#, fuzzy

msgid ""

"Custom validators need to inherit from :class:`!Validator` and must supply "

"a :meth:`!validate` method to test various restrictions as needed."

msgstr ""

"Validadores personalizados necesitan heredar de :class:`Validator` y deben "

"proveer un método :meth:`validate` method para probar las restricciones que "

"sean necesarias."

#: ../Doc/howto/descriptor.rst:368

msgid "Custom validators"

msgstr "Validadores personalizados"

#: ../Doc/howto/descriptor.rst:370

msgid "Here are three practical data validation utilities:"

msgstr "Acá hay tres utilidades de validación de datos prácticas:"

#: ../Doc/howto/descriptor.rst:372

#, fuzzy

msgid ""

":class:`!OneOf` verifies that a value is one of a restricted set of options."

msgstr ""

":class:`OneOf` verifica que un valor está dentro de un grupo restringido de "

"opciones."

#: ../Doc/howto/descriptor.rst:374

#, fuzzy

msgid ""

":class:`!Number` verifies that a value is either an :class:`int` or :class:"

"`float`. Optionally, it verifies that a value is between a given minimum or "

"maximum."

msgstr ""

":class:`Number` verifica que un valor es :class:`int` o :class:`float`. "

"Opcionalmente verifica que un valor está entre un mínimo y un máximo."

#: ../Doc/howto/descriptor.rst:378

#, fuzzy

msgid ""

":class:`!String` verifies that a value is a :class:`str`. Optionally, it "

"validates a given minimum or maximum length. It can validate a user-defined "

"`predicate <https://en.wikipedia.org/wiki/Predicate_(mathematical_logic)>`_ "

"as well."

msgstr ""

":class:`String` verifica que un valor es un :class:`str`. Opcionalmente "

"valida que tenga un largo mínimo o máximo. Puede también validar un "

"`predicado <https://es.wikipedia.org/wiki/"

"Predicado_(l%C3%B3gica)#L%C3%B3gica_matem%C3%A1tica>`_ definido por el "

"usuario."

#: ../Doc/howto/descriptor.rst:383

#, python-brace-format

msgid ""

"class OneOf(Validator):\n"

"\n"

" def __init__(self, *options):\n"

" self.options = set(options)\n"

"\n"

" def validate(self, value):\n"

" if value not in self.options:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be one of {self.options!r}'\n"

" )\n"

"\n"

"class Number(Validator):\n"

"\n"

" def __init__(self, minvalue=None, maxvalue=None):\n"

" self.minvalue = minvalue\n"

" self.maxvalue = maxvalue\n"

"\n"

" def validate(self, value):\n"

" if not isinstance(value, (int, float)):\n"

" raise TypeError(f'Expected {value!r} to be an int or float')\n"

" if self.minvalue is not None and value < self.minvalue:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be at least {self.minvalue!r}'\n"

" )\n"

" if self.maxvalue is not None and value > self.maxvalue:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be no more than {self.maxvalue!r}'\n"

" )\n"

"\n"

"class String(Validator):\n"

"\n"

" def __init__(self, minsize=None, maxsize=None, predicate=None):\n"

" self.minsize = minsize\n"

" self.maxsize = maxsize\n"

" self.predicate = predicate\n"

"\n"

" def validate(self, value):\n"

" if not isinstance(value, str):\n"

" raise TypeError(f'Expected {value!r} to be a str')\n"

" if self.minsize is not None and len(value) < self.minsize:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be no smaller than {self.minsize!"

"r}'\n"

" )\n"

" if self.maxsize is not None and len(value) > self.maxsize:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be no bigger than {self.maxsize!r}'\n"

" )\n"

" if self.predicate is not None and not self.predicate(value):\n"

" raise ValueError(\n"

" f'Expected {self.predicate} to be true for {value!r}'\n"

" )"

msgstr ""

#: ../Doc/howto/descriptor.rst:439

msgid "Practical application"

msgstr "Aplicación práctica"

#: ../Doc/howto/descriptor.rst:441

msgid "Here's how the data validators can be used in a real class:"

msgstr ""

"Acá se muestra cómo se puede usar los validadores de datos en una clase real:"

#: ../Doc/howto/descriptor.rst:443

msgid ""

"class Component:\n"

"\n"

" name = String(minsize=3, maxsize=10, predicate=str.isupper)\n"

" kind = OneOf('wood', 'metal', 'plastic')\n"

" quantity = Number(minvalue=0)\n"

"\n"

" def __init__(self, name, kind, quantity):\n"

" self.name = name\n"

" self.kind = kind\n"

" self.quantity = quantity"

msgstr ""

#: ../Doc/howto/descriptor.rst:456

msgid "The descriptors prevent invalid instances from being created:"

msgstr "Los descriptores previenen que se creen instancias inválidas:"

#: ../Doc/howto/descriptor.rst:458

#, python-brace-format

msgid ""

">>> Component('Widget', 'metal', 5) # Blocked: 'Widget' is not all "

"uppercase\n"

"Traceback (most recent call last):\n"

" ...\n"

"ValueError: Expected <method 'isupper' of 'str' objects> to be true for "

"'Widget'\n"

"\n"

">>> Component('WIDGET', 'metle', 5) # Blocked: 'metle' is misspelled\n"

"Traceback (most recent call last):\n"

" ...\n"

"ValueError: Expected 'metle' to be one of {'metal', 'plastic', 'wood'}\n"

"\n"

">>> Component('WIDGET', 'metal', -5) # Blocked: -5 is negative\n"

"Traceback (most recent call last):\n"

" ...\n"

"ValueError: Expected -5 to be at least 0\n"

"\n"

">>> Component('WIDGET', 'metal', 'V') # Blocked: 'V' isn't a number\n"

"Traceback (most recent call last):\n"

" ...\n"

"TypeError: Expected 'V' to be an int or float\n"

"\n"

">>> c = Component('WIDGET', 'metal', 5) # Allowed: The inputs are valid"

msgstr ""

#: ../Doc/howto/descriptor.rst:484

msgid "Technical Tutorial"

msgstr "Tutorial técnico"

#: ../Doc/howto/descriptor.rst:486

msgid ""

"What follows is a more technical tutorial for the mechanics and details of "

"how descriptors work."

msgstr ""

"Lo que sigue es un tutorial más práctico sobre las mecánicas y detalles de "

"cómo funcionan los descriptores."

#: ../Doc/howto/descriptor.rst:491

msgid "Abstract"

msgstr "Resumen"

#: ../Doc/howto/descriptor.rst:493

msgid ""

"Defines descriptors, summarizes the protocol, and shows how descriptors are "

"called. Provides an example showing how object relational mappings work."

msgstr ""

"Define los descriptores, resume el protocolo, y muestra cómo los "

"descriptores son llamados. Provee ejemplos mostrando cómo funcionan los "

"mapeos objeto-relacional (*ORM*)."

#: ../Doc/howto/descriptor.rst:496

msgid ""

"Learning about descriptors not only provides access to a larger toolset, it "

"creates a deeper understanding of how Python works."

msgstr ""

"Aprender acerca de los descriptores no sólo brinda acceso a un conjunto de "

"herramientas mayor, sino que genera una comprensión más profunda de cómo "

"funciona Python."

#: ../Doc/howto/descriptor.rst:501

msgid "Definition and introduction"

msgstr "Definición e introducción"

#: ../Doc/howto/descriptor.rst:503

#, fuzzy

msgid ""

"In general, a descriptor is an attribute value that has one of the methods "

"in the descriptor protocol. Those methods are :meth:`~object.__get__`, :"

"meth:`~object.__set__`, and :meth:`~object.__delete__`. If any of those "

"methods are defined for an attribute, it is said to be a :term:`descriptor`."

msgstr ""

"En general, un descriptor es un valor atributo que tiene uno de los métodos "

"del protocolo de descriptores. Estos métodos son :meth:`__get__`, :meth:"

"`__set__`, y :meth:`__delete__`. Si cualquiera de esos métodos se definen en "

"un atributo, se dice que éste es un :term:`descriptor`."

#: ../Doc/howto/descriptor.rst:508

msgid ""

"The default behavior for attribute access is to get, set, or delete the "

"attribute from an object's dictionary. For instance, ``a.x`` has a lookup "

"chain starting with ``a.__dict__['x']``, then ``type(a).__dict__['x']``, and "

"continuing through the method resolution order of ``type(a)``. If the looked-"

"up value is an object defining one of the descriptor methods, then Python "

"may override the default behavior and invoke the descriptor method instead. "

"Where this occurs in the precedence chain depends on which descriptor "

"methods were defined."

msgstr ""

"El comportamiento predeterminado para el acceso a los atributos es obtener, "

"establecer o eliminar el atributo del diccionario de un objeto. Por ejemplo, "

"``a.x`` tiene una cadena de búsqueda que comienza con ``a.__dict__['x']``, "

"luego ``type(a).__dict__['x']`` y continúa a través del orden de resolución "

"de métodos de ``type(a)``. Si el valor buscado es un objeto que define uno "

"de los métodos de descriptores, entonces Python puede anular el "

"comportamiento predeterminado e invocar el método del descriptor en su "

"lugar. El lugar donde esto ocurre en la cadena de precedencia depende de qué "

"métodos de descriptores fueron definidos."

#: ../Doc/howto/descriptor.rst:517

#, fuzzy

msgid ""

"Descriptors are a powerful, general purpose protocol. They are the "

"mechanism behind properties, methods, static methods, class methods, and :"

"func:`super`. They are used throughout Python itself. Descriptors simplify "

"the underlying C code and offer a flexible set of new tools for everyday "

"Python programs."

msgstr ""

"Los descriptores son un protocolo poderoso y de propósito general. Son el "

"mecanismo detrás de propiedades, métodos, métodos estáticos y :func:"

"`super()`. Se usan a través de Python mismo. Los descriptores simplifican el "

"código C subyacente y ofrecen un grupo flexible de nuevas herramientas para "

"programas habituales de Python."

#: ../Doc/howto/descriptor.rst:525

msgid "Descriptor protocol"

msgstr "Protocolo de descriptores"

#: ../Doc/howto/descriptor.rst:527

#, fuzzy

msgid "``descr.__get__(self, obj, type=None)``"

msgstr "``descr.__get__(self, obj, type=None) -> value``"

#: ../Doc/howto/descriptor.rst:529

#, fuzzy

msgid "``descr.__set__(self, obj, value)``"

msgstr "``descr.__set__(self, obj, value) -> None``"

#: ../Doc/howto/descriptor.rst:531

#, fuzzy

msgid "``descr.__delete__(self, obj)``"

msgstr "``descr.__delete__(self, obj) -> None``"

#: ../Doc/howto/descriptor.rst:533

msgid ""

"That is all there is to it. Define any of these methods and an object is "

"considered a descriptor and can override default behavior upon being looked "

"up as an attribute."

msgstr ""

"Eso es todo lo que hay que hacer. Si se define cualquiera de estos métodos, "

"el objeto se considera un descriptor y puede anular el comportamiento "

"predeterminado al ser buscado como un atributo."

#: ../Doc/howto/descriptor.rst:537

#, fuzzy

msgid ""

"If an object defines :meth:`~object.__set__` or :meth:`~object.__delete__`, "

"it is considered a data descriptor. Descriptors that only define :meth:"

"`~object.__get__` are called non-data descriptors (they are often used for "

"methods but other uses are possible)."

msgstr ""

"Si un objeto define :meth:`__set__` o :meth:`__delete__`, se considera un "

"descriptor de datos. Los descriptores que solo definen :meth:`__get__` se "

"denominan descriptores de no-datos (normalmente se utilizan para métodos, "

"pero son posibles otros usos)."

#: ../Doc/howto/descriptor.rst:542

msgid ""

"Data and non-data descriptors differ in how overrides are calculated with "

"respect to entries in an instance's dictionary. If an instance's dictionary "

"has an entry with the same name as a data descriptor, the data descriptor "

"takes precedence. If an instance's dictionary has an entry with the same "

"name as a non-data descriptor, the dictionary entry takes precedence."

msgstr ""

"Los descriptores de datos y de no-datos difieren en cómo se calculan las "

"anulaciones con respecto a las entradas en el diccionario de una instancia. "

"Si el diccionario de una instancia tiene una entrada con el mismo nombre que "

"un descriptor de datos, el descriptor de datos tiene prioridad. Si el "

"diccionario de una instancia tiene una entrada con el mismo nombre que un "

"descriptor de no-datos, la entrada del diccionario tiene prioridad."

#: ../Doc/howto/descriptor.rst:548

#, fuzzy

msgid ""

"To make a read-only data descriptor, define both :meth:`~object.__get__` "

"and :meth:`~object.__set__` with the :meth:`~object.__set__` raising an :exc:"

"`AttributeError` when called. Defining the :meth:`~object.__set__` method "

"with an exception raising placeholder is enough to make it a data descriptor."

msgstr ""

"Para crear un descriptor de datos de sólo lectura, define tanto :meth:"

"`__get__` como :meth:`__set__` donde :meth:`__set__` lanza un :exc:"

"`AttributeError` cuando es llamado. Definir el método :meth:`__set__` de "

"forma que lance una excepción genérica es suficiente para convertirlo en un "

"descriptor de datos."

#: ../Doc/howto/descriptor.rst:555

msgid "Overview of descriptor invocation"

msgstr "Visión general de invocación de descriptores"

#: ../Doc/howto/descriptor.rst:557

msgid ""

"A descriptor can be called directly with ``desc.__get__(obj)`` or ``desc."

"__get__(None, cls)``."

msgstr ""

"Un descriptor puede ser llamado directamente con ``desc.__get__(obj)`` o "

"``desc.__get__(None, cls)``."

#: ../Doc/howto/descriptor.rst:560

msgid ""

"But it is more common for a descriptor to be invoked automatically from "

"attribute access."

msgstr ""

"Pero es más común que un descriptor sea invocado automáticamente por la "

"búsqueda de atributos."

#: ../Doc/howto/descriptor.rst:563

#, fuzzy

msgid ""

"The expression ``obj.x`` looks up the attribute ``x`` in the chain of "

"namespaces for ``obj``. If the search finds a descriptor outside of the "

"instance :attr:`~object.__dict__`, its :meth:`~object.__get__` method is "

"invoked according to the precedence rules listed below."

msgstr ""

"La expresión ``obj.x`` busca el atributo ``x`` en la cadena de nombres de "

"espacio de ``obj``. Si la búsqueda encuentra un descriptor fuera del "

"``__dict__`` de la instancia, su método :meth:`__get__` es invocado de "

"acuerdo a la lista de reglas de precedencia mostradas debajo."

#: ../Doc/howto/descriptor.rst:568

msgid ""

"The details of invocation depend on whether ``obj`` is an object, class, or "

"instance of super."

msgstr ""

"Los detalles de la invocación dependen de si ``obj`` es un objeto una clase, "

"o una instancia de super."

#: ../Doc/howto/descriptor.rst:573

msgid "Invocation from an instance"

msgstr "Invocación desde una instancia"

#: ../Doc/howto/descriptor.rst:575

#, fuzzy

msgid ""

"Instance lookup scans through a chain of namespaces giving data descriptors "

"the highest priority, followed by instance variables, then non-data "

"descriptors, then class variables, and lastly :meth:`~object.__getattr__` if "

"it is provided."

msgstr ""

"La búsqueda en instancias escanea a través de una cadena de nombres de "

"espacio dando la más alta prioridad a descriptores de datos, seguidos por "

"variables de instancia, luego descriptores de no-datos, luego variables de "

"clase, y finalmente a :meth:`__getattr__` si se provee."