From 8b5a515f57843db072aa44618bd2acf970b2033b Mon Sep 17 00:00:00 2001 From: Marco Richetta Date: Sun, 3 May 2020 21:44:59 -0300 Subject: [PATCH 1/3] Traduciendo classes --- TRANSLATORS | 1 + tutorial/classes.po | 743 +++++++++++++++++++++++--------------------- 2 files changed, 389 insertions(+), 355 deletions(-) diff --git a/TRANSLATORS b/TRANSLATORS index c7b0ff332d..53e56f51a4 100644 --- a/TRANSLATORS +++ b/TRANSLATORS @@ -1,2 +1,3 @@ Nicolás Demarchi (@gilgamezh) Manuel Kaufmann (@humitos) +Marco Richetta (@marcorichetta) diff --git a/tutorial/classes.po b/tutorial/classes.po index bdc8b879f3..81e82d6d0f 100644 --- a/tutorial/classes.po +++ b/tutorial/classes.po @@ -3,18 +3,21 @@ # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # -#, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.7\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2019-05-06 11:59-0400\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" -"Language-Team: LANGUAGE \n" +"PO-Revision-Date: 2020-05-03 21:38-0300\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Last-Translator: Marco Richetta \n" +"Language-Team: python-doc-es (https://mail.python.org/mailman3/lists/docs-" +"es.python.org)\n" +"Language: es\n" +"X-Generator: Poedit 2.3\n" #: ../Doc/tutorial/classes.rst:5 msgid "Classes" @@ -54,16 +57,16 @@ msgstr "" "Programación Orientada a Objetos: el mecanismo de la herencia de clases " "permite múltiples clases base, una clase derivada puede sobre escribir " "cualquier método de su(s) clase(s) base, y un método puede llamar al método " -"de la clase base con el mismo nombre. Los objetos pueden tener una cantidad" -" arbitraria de datos de cualquier tipo. Igual que con los módulos, las " -"clases participan de la naturaleza dinámica de Python: se crean en tiempo de" -" ejecución, y pueden modificarse luego de la creación." +"de la clase base con el mismo nombre. Los objetos pueden tener una " +"cantidad arbitraria de datos de cualquier tipo. Igual que con los módulos, " +"las clases participan de la naturaleza dinámica de Python: se crean en " +"tiempo de ejecución, y pueden modificarse luego de la creación." #: ../Doc/tutorial/classes.rst:23 msgid "" "In C++ terminology, normally class members (including the data members) are " -"*public* (except see below :ref:`tut-private`), and all member functions are" -" *virtual*. As in Modula-3, there are no shorthands for referencing the " +"*public* (except see below :ref:`tut-private`), and all member functions " +"are *virtual*. As in Modula-3, there are no shorthands for referencing the " "object's members from its methods: the method function is declared with an " "explicit first argument representing the object, which is provided " "implicitly by the call. As in Smalltalk, classes themselves are objects. " @@ -75,28 +78,29 @@ msgid "" msgstr "" "En terminología de C++, normalmente los miembros de las clases (incluyendo " "los miembros de datos), son *públicos* (excepto ver abajo :ref:`tut-" -"private`), y todas las funciones miembro son *virtuales*. Como en Modula-3," -" no hay atajos para hacer referencia a los miembros del objeto desde sus " -"métodos: la función método se declara con un primer argumento explícito que " -"representa al objeto, el cual se provee implícitamente por la llamada. Como" -" en Smalltalk, las clases mismas son objetos. Esto provee una semántica " -"para importar y renombrar. A diferencia de C++ y Modula-3, los tipos de " -"datos integrados pueden usarse como clases base para que el usuario los " -"extienda. También, como en C++ pero a diferencia de Modula-3, la mayoría de" -" los operadores integrados con sintaxis especial (operadores aritméticos, de" -" subíndice, etc.) pueden ser redefinidos por instancias de la clase." +"private`), y todas las funciones miembro son *virtuales*. Como en " +"Modula-3, no hay atajos para hacer referencia a los miembros del objeto " +"desde sus métodos: la función método se declara con un primer argumento " +"explícito que representa al objeto, el cual se provee implícitamente por la " +"llamada. Como en Smalltalk, las clases mismas son objetos. Esto provee " +"una semántica para importar y renombrar. A diferencia de C++ y Modula-3, " +"los tipos de datos integrados pueden usarse como clases base para que el " +"usuario los extienda. También, como en C++ pero a diferencia de Modula-3, " +"la mayoría de los operadores integrados con sintaxis especial (operadores " +"aritméticos, de subíndice, etc.) pueden ser redefinidos por instancias de " +"la clase." #: ../Doc/tutorial/classes.rst:34 msgid "" -"(Lacking universally accepted terminology to talk about classes, I will make" -" occasional use of Smalltalk and C++ terms. I would use Modula-3 terms, " -"since its object-oriented semantics are closer to those of Python than C++, " -"but I expect that few readers have heard of it.)" +"(Lacking universally accepted terminology to talk about classes, I will " +"make occasional use of Smalltalk and C++ terms. I would use Modula-3 " +"terms, since its object-oriented semantics are closer to those of Python " +"than C++, but I expect that few readers have heard of it.)" msgstr "" "(Sin haber una terminología universalmente aceptada sobre clases, haré uso " "ocasional de términos de Smalltalk y C++. Usaría términos de Modula-3, ya " "que su semántica orientada a objetos es más cercana a Python que C++, pero " -"no espero que muchos lectores hayan escuchado hablar de él)." +"no espero que muchos lectores hayan escuchado hablar de él.)" #: ../Doc/tutorial/classes.rst:43 msgid "A Word About Names and Objects" @@ -127,9 +131,9 @@ msgstr "" "otros tipos. Esto se usa normalmente para beneficio del programa, ya que " "los renombres funcionan como punteros en algunos aspectos. Por ejemplo, " "pasar un objeto es barato ya que la implementación solamente pasa el " -"puntero; y si una función modifica el objeto que fue pasado, el que la llama" -" verá el cambio; esto elimina la necesidad de tener dos formas diferentes de" -" pasar argumentos, como en Pascal." +"puntero; y si una función modifica el objeto que fue pasado, el que la " +"llama verá el cambio; esto elimina la necesidad de tener dos formas " +"diferentes de pasar argumentos, como en Pascal." #: ../Doc/tutorial/classes.rst:61 msgid "Python Scopes and Namespaces" @@ -161,20 +165,20 @@ msgid "" "noticeable in any way (except for performance), and it may change in the " "future. Examples of namespaces are: the set of built-in names (containing " "functions such as :func:`abs`, and built-in exception names); the global " -"names in a module; and the local names in a function invocation. In a sense" -" the set of attributes of an object also form a namespace. The important " -"thing to know about namespaces is that there is absolutely no relation " -"between names in different namespaces; for instance, two different modules " -"may both define a function ``maximize`` without confusion --- users of the " -"modules must prefix it with the module name." +"names in a module; and the local names in a function invocation. In a " +"sense the set of attributes of an object also form a namespace. The " +"important thing to know about namespaces is that there is absolutely no " +"relation between names in different namespaces; for instance, two different " +"modules may both define a function ``maximize`` without confusion --- users " +"of the modules must prefix it with the module name." msgstr "" "Un *espacio de nombres* es una relación de nombres a objetos. Muchos " -"espacios de nombres están implementados en este momento como diccionarios de" -" Python, pero eso no se nota para nada (excepto por el desempeño), y puede " -"cambiar en el futuro. Como ejemplos de espacios de nombres tenés: el " -"conjunto de nombres incluidos (conteniendo funciones como :func:`abs`, y los" -" nombres de excepciones integradas); los nombres globales en un módulo; y " -"los nombres locales en la invocación a una función. Lo que es importante " +"espacios de nombres están implementados en este momento como diccionarios " +"de Python, pero eso no se nota para nada (excepto por el desempeño), y " +"puede cambiar en el futuro. Como ejemplos de espacios de nombres tenés: el " +"conjunto de nombres incluidos (conteniendo funciones como :func:`abs`, y " +"los nombres de excepciones integradas); los nombres globales en un módulo; " +"y los nombres locales en la invocación a una función. Lo que es importante " "saber de los espacios de nombres es que no hay relación en absoluto entre " "los nombres de espacios de nombres distintos; por ejemplo, dos módulos " "diferentes pueden tener definidos los dos una función ``maximizar`` sin " @@ -186,11 +190,11 @@ msgid "" "By the way, I use the word *attribute* for any name following a dot --- for " "example, in the expression ``z.real``, ``real`` is an attribute of the " "object ``z``. Strictly speaking, references to names in modules are " -"attribute references: in the expression ``modname.funcname``, ``modname`` is" -" a module object and ``funcname`` is an attribute of it. In this case there" -" happens to be a straightforward mapping between the module's attributes and" -" the global names defined in the module: they share the same namespace! " -"[#]_" +"attribute references: in the expression ``modname.funcname``, ``modname`` " +"is a module object and ``funcname`` is an attribute of it. In this case " +"there happens to be a straightforward mapping between the module's " +"attributes and the global names defined in the module: they share the same " +"namespace! [#]_" msgstr "" "Por cierto, yo uso la palabra *atributo* para cualquier cosa después de un " "punto; por ejemplo, en la expresión ``z.real``, ``real`` es un atributo del " @@ -210,12 +214,12 @@ msgid "" "remove the attribute :attr:`the_answer` from the object named by " "``modname``." msgstr "" -"Los atributos pueden ser de sólo lectura, o de escritura. En el último caso" -" es posible la asignación a atributos. Los atributos de módulo pueden " +"Los atributos pueden ser de sólo lectura, o de escritura. En el último " +"caso es posible la asignación a atributos. Los atributos de módulo pueden " "escribirse: ``modulo.la_respuesta = 42``. Los atributos de escritura se " -"pueden borrar también con la declaración :keyword:`del`. Por ejemplo, ``del" -" modulo.la_respuesta`` va a eliminar el atributo :attr:`la_respuesta` del " -"objeto con nombre ``modulo``." +"pueden borrar también con la declaración :keyword:`del`. Por ejemplo, " +"``del modulo.la_respuesta`` va a eliminar el atributo :attr:`la_respuesta` " +"del objeto con nombre ``modulo``." #: ../Doc/tutorial/classes.rst:96 msgid "" @@ -225,9 +229,9 @@ msgid "" "module is created when the module definition is read in; normally, module " "namespaces also last until the interpreter quits. The statements executed " "by the top-level invocation of the interpreter, either read from a script " -"file or interactively, are considered part of a module called " -":mod:`__main__`, so they have their own global namespace. (The built-in " -"names actually also live in a module; this is called :mod:`builtins`.)" +"file or interactively, are considered part of a module called :mod:" +"`__main__`, so they have their own global namespace. (The built-in names " +"actually also live in a module; this is called :mod:`builtins`.)" msgstr "" "Los espacios de nombres se crean en diferentes momentos y con diferentes " "tiempos de vida. El espacio de nombres que contiene los nombres incluidos " @@ -235,30 +239,31 @@ msgstr "" "nombres global de un módulo se crea cuando se lee la definición de un " "módulo; normalmente, los espacios de nombres de módulos también duran hasta " "que el intérprete finaliza. Las instrucciones ejecutadas en el nivel de " -"llamadas superior del intérprete, ya sea desde un script o interactivamente," -" se consideran parte del módulo llamado :mod:`__main__`, por lo tanto tienen" -" su propio espacio de nombres global. (Los nombres incluidos en realidad " -"también viven en un módulo; este se llama :mod:`builtins`.)" +"llamadas superior del intérprete, ya sea desde un script o " +"interactivamente, se consideran parte del módulo llamado :mod:`__main__`, " +"por lo tanto tienen su propio espacio de nombres global. (Los nombres " +"incluidos en realidad también viven en un módulo; este se llama :mod:" +"`builtins`.)" #: ../Doc/tutorial/classes.rst:106 msgid "" "The local namespace for a function is created when the function is called, " "and deleted when the function returns or raises an exception that is not " -"handled within the function. (Actually, forgetting would be a better way to" -" describe what actually happens.) Of course, recursive invocations each " +"handled within the function. (Actually, forgetting would be a better way " +"to describe what actually happens.) Of course, recursive invocations each " "have their own local namespace." msgstr "" "El espacio de nombres local a una función se crea cuando la función es " -"llamada, y se elimina cuando la función retorna o lanza una excepción que no" -" se maneje dentro de la función. (Podríamos decir que lo que pasa en " +"llamada, y se elimina cuando la función retorna o lanza una excepción que " +"no se maneje dentro de la función. (Podríamos decir que lo que pasa en " "realidad es que ese espacio de nombres se \"olvida\".) Por supuesto, las " "llamadas recursivas tienen cada una su propio espacio de nombres local." #: ../Doc/tutorial/classes.rst:112 msgid "" "A *scope* is a textual region of a Python program where a namespace is " -"directly accessible. \"Directly accessible\" here means that an unqualified" -" reference to a name attempts to find the name in the namespace." +"directly accessible. \"Directly accessible\" here means that an " +"unqualified reference to a name attempts to find the name in the namespace." msgstr "" "Un *ámbito* es una región textual de un programa en Python donde un espacio " "de nombres es accesible directamente. \"Accesible directamente\" significa " @@ -267,8 +272,8 @@ msgstr "" #: ../Doc/tutorial/classes.rst:116 msgid "" -"Although scopes are determined statically, they are used dynamically. At any" -" time during execution, there are at least three nested scopes whose " +"Although scopes are determined statically, they are used dynamically. At " +"any time during execution, there are at least three nested scopes whose " "namespaces are directly accessible:" msgstr "" "Aunque los alcances se determinan estáticamente, se usan dinámicamente. En " @@ -299,11 +304,11 @@ msgstr "" msgid "" "If a name is declared global, then all references and assignments go " "directly to the middle scope containing the module's global names. To " -"rebind variables found outside of the innermost scope, the " -":keyword:`nonlocal` statement can be used; if not declared nonlocal, those " -"variables are read-only (an attempt to write to such a variable will simply " -"create a *new* local variable in the innermost scope, leaving the " -"identically named outer variable unchanged)." +"rebind variables found outside of the innermost scope, the :keyword:" +"`nonlocal` statement can be used; if not declared nonlocal, those variables " +"are read-only (an attempt to write to such a variable will simply create a " +"*new* local variable in the innermost scope, leaving the identically named " +"outer variable unchanged)." msgstr "" "Si un nombre se declara como global, entonces todas las referencias y " "asignaciones al mismo van directo al ámbito intermedio que contiene los " @@ -331,9 +336,9 @@ msgid "" "scope of a function defined in a module is that module's namespace, no " "matter from where or by what alias the function is called. On the other " "hand, the actual search for names is done dynamically, at run time --- " -"however, the language definition is evolving towards static name resolution," -" at \"compile\" time, so don't rely on dynamic name resolution! (In fact, " -"local variables are already determined statically.)" +"however, the language definition is evolving towards static name " +"resolution, at \"compile\" time, so don't rely on dynamic name resolution! " +"(In fact, local variables are already determined statically.)" msgstr "" "Es importante notar que los alcances se determinan textualmente: el ámbito " "global de una función definida en un módulo es el espacio de nombres de ese " @@ -346,17 +351,17 @@ msgstr "" #: ../Doc/tutorial/classes.rst:146 msgid "" -"A special quirk of Python is that -- if no :keyword:`global` statement is in" -" effect -- assignments to names always go into the innermost scope. " +"A special quirk of Python is that -- if no :keyword:`global` statement is " +"in effect -- assignments to names always go into the innermost scope. " "Assignments do not copy data --- they just bind names to objects. The same " "is true for deletions: the statement ``del x`` removes the binding of ``x`` " "from the namespace referenced by the local scope. In fact, all operations " -"that introduce new names use the local scope: in particular, " -":keyword:`import` statements and function definitions bind the module or " -"function name in the local scope." +"that introduce new names use the local scope: in particular, :keyword:" +"`import` statements and function definitions bind the module or function " +"name in the local scope." msgstr "" -"Una peculiaridad especial de Python es que, si no hay una declaración " -":keyword:`global` o :keyword:`nonlocal` en efecto, las asignaciones a " +"Una peculiaridad especial de Python es que, si no hay una declaración :" +"keyword:`global` o :keyword:`nonlocal` en efecto, las asignaciones a " "nombres siempre van al ámbito interno. Las asignaciones no copian datos, " "solamente asocian nombres a objetos. Lo mismo cuando se borra: la " "declaración ``del x`` quita la asociación de ``x`` del espacio de nombres " @@ -368,9 +373,9 @@ msgstr "" #: ../Doc/tutorial/classes.rst:154 msgid "" "The :keyword:`global` statement can be used to indicate that particular " -"variables live in the global scope and should be rebound there; the " -":keyword:`nonlocal` statement indicates that particular variables live in an" -" enclosing scope and should be rebound there." +"variables live in the global scope and should be rebound there; the :" +"keyword:`nonlocal` statement indicates that particular variables live in an " +"enclosing scope and should be rebound there." msgstr "" "La declaración :keyword:`global` puede usarse para indicar que ciertas " "variables viven en el ámbito global y deberían reasignarse allí; la " @@ -388,8 +393,8 @@ msgid "" "variable binding::" msgstr "" "Este es un ejemplo que muestra como hacer referencia a distintos ámbitos y " -"espacios de nombres, y cómo las declaraciones :keyword:`global` y " -":keyword:`nonlocal` afectan la asignación de variables::" +"espacios de nombres, y cómo las declaraciones :keyword:`global` y :keyword:" +"`nonlocal` afectan la asignación de variables::" #: ../Doc/tutorial/classes.rst:191 msgid "The output of the example code is:" @@ -403,14 +408,14 @@ msgid "" "assignment changed the module-level binding." msgstr "" "Notá como la asignación *local* (que es el comportamiento normal) no cambió " -"la vinculación de *algo* de *prueba_ambitos*. La asignación " -":keyword:`nonlocal` cambió la vinculación de *algo* de *prueba_ambitos*, y " -"la asignación :keyword:`global` cambió la vinculación a nivel de módulo." +"la vinculación de *algo* de *prueba_ambitos*. La asignación :keyword:" +"`nonlocal` cambió la vinculación de *algo* de *prueba_ambitos*, y la " +"asignación :keyword:`global` cambió la vinculación a nivel de módulo." #: ../Doc/tutorial/classes.rst:205 msgid "" -"You can also see that there was no previous binding for *spam* before the " -":keyword:`global` assignment." +"You can also see that there was no previous binding for *spam* before the :" +"keyword:`global` assignment." msgstr "" "También podés ver que no había vinculación para *algo* antes de la " "asignación :keyword:`global`." @@ -450,10 +455,10 @@ msgstr "" #: ../Doc/tutorial/classes.rst:236 msgid "" "In practice, the statements inside a class definition will usually be " -"function definitions, but other statements are allowed, and sometimes useful" -" --- we'll come back to this later. The function definitions inside a class" -" normally have a peculiar form of argument list, dictated by the calling " -"conventions for methods --- again, this is explained later." +"function definitions, but other statements are allowed, and sometimes " +"useful --- we'll come back to this later. The function definitions inside " +"a class normally have a peculiar form of argument list, dictated by the " +"calling conventions for methods --- again, this is explained later." msgstr "" "En la práctica, las declaraciones dentro de una clase son definiciones de " "funciones, pero otras declaraciones son permitidas, y a veces resultan " @@ -466,32 +471,32 @@ msgstr "" msgid "" "When a class definition is entered, a new namespace is created, and used as " "the local scope --- thus, all assignments to local variables go into this " -"new namespace. In particular, function definitions bind the name of the new" -" function here." +"new namespace. In particular, function definitions bind the name of the " +"new function here." msgstr "" "Cuando se ingresa una definición de clase, se crea un nuevo espacio de " "nombres, el cual se usa como ámbito local; por lo tanto, todas las " "asignaciones a variables locales van a este nuevo espacio de nombres. En " -"particular, las definiciones de funciones asocian el nombre de las funciones" -" nuevas allí." +"particular, las definiciones de funciones asocian el nombre de las " +"funciones nuevas allí." #: ../Doc/tutorial/classes.rst:247 msgid "" "When a class definition is left normally (via the end), a *class object* is " "created. This is basically a wrapper around the contents of the namespace " -"created by the class definition; we'll learn more about class objects in the" -" next section. The original local scope (the one in effect just before the " -"class definition was entered) is reinstated, and the class object is bound " -"here to the class name given in the class definition header " -"(:class:`ClassName` in the example)." +"created by the class definition; we'll learn more about class objects in " +"the next section. The original local scope (the one in effect just before " +"the class definition was entered) is reinstated, and the class object is " +"bound here to the class name given in the class definition header (:class:" +"`ClassName` in the example)." msgstr "" "Cuando una definición de clase se finaliza normalmente se crea un *objeto " "clase*. Básicamente, este objeto envuelve los contenidos del espacio de " -"nombres creado por la definición de la clase; aprenderemos más acerca de los" -" objetos clase en la sección siguiente. El ámbito local original (el que " -"tenía efecto justo antes de que ingrese la definición de la clase) es " -"restablecido, y el objeto clase se asocia allí al nombre que se le puso a la" -" clase en el encabezado de su definición (:class:`Clase` en el ejemplo)." +"nombres creado por la definición de la clase; aprenderemos más acerca de " +"los objetos clase en la sección siguiente. El ámbito local original (el " +"que tenía efecto justo antes de que ingrese la definición de la clase) es " +"restablecido, y el objeto clase se asocia allí al nombre que se le puso a " +"la clase en el encabezado de su definición (:class:`Clase` en el ejemplo)." #: ../Doc/tutorial/classes.rst:259 msgid "Class Objects" @@ -508,15 +513,15 @@ msgstr "" #: ../Doc/tutorial/classes.rst:264 msgid "" "*Attribute references* use the standard syntax used for all attribute " -"references in Python: ``obj.name``. Valid attribute names are all the names" -" that were in the class's namespace when the class object was created. So, " -"if the class definition looked like this::" +"references in Python: ``obj.name``. Valid attribute names are all the " +"names that were in the class's namespace when the class object was " +"created. So, if the class definition looked like this::" msgstr "" -"Para *hacer referencia a atributos* se usa la sintaxis estándar de todas las" -" referencias a atributos en Python: ``objeto.nombre``. Los nombres de " +"Para *hacer referencia a atributos* se usa la sintaxis estándar de todas " +"las referencias a atributos en Python: ``objeto.nombre``. Los nombres de " "atributo válidos son todos los nombres que estaban en el espacio de nombres " -"de la clase cuando ésta se creó. Por lo tanto, si la definición de la clase" -" es así::" +"de la clase cuando ésta se creó. Por lo tanto, si la definición de la " +"clase es así::" #: ../Doc/tutorial/classes.rst:276 msgid "" @@ -530,14 +535,14 @@ msgstr "" "válidas, que devuelven un entero y un objeto función respectivamente. Los " "atributos de clase también pueden ser asignados, o sea que podés cambiar el " "valor de ``MiClase.i`` mediante asignación. :attr:`__doc__` también es un " -"atributo válido, que devuelve la documentación asociada a la clase: " -"``\"Simple clase de ejemplo\"``." +"atributo válido, que devuelve la documentación asociada a la clase: ``" +"\"Simple clase de ejemplo\"``." #: ../Doc/tutorial/classes.rst:282 msgid "" "Class *instantiation* uses function notation. Just pretend that the class " -"object is a parameterless function that returns a new instance of the class." -" For example (assuming the above class)::" +"object is a parameterless function that returns a new instance of the " +"class. For example (assuming the above class)::" msgstr "" "La *instanciación* de clases usa la notación de funciones. Hacé de cuenta " "que el objeto de clase es una función sin parámetros que devuelve una nueva " @@ -548,26 +553,27 @@ msgid "" "creates a new *instance* of the class and assigns this object to the local " "variable ``x``." msgstr "" -"...crea una nueva *instancia* de la clase y asigna este objeto a la variable" -" local ``x``." +"...crea una nueva *instancia* de la clase y asigna este objeto a la " +"variable local ``x``." #: ../Doc/tutorial/classes.rst:291 msgid "" "The instantiation operation (\"calling\" a class object) creates an empty " "object. Many classes like to create objects with instances customized to a " -"specific initial state. Therefore a class may define a special method named " -":meth:`__init__`, like this::" +"specific initial state. Therefore a class may define a special method " +"named :meth:`__init__`, like this::" msgstr "" "La operación de instanciación (\"llamar\" a un objeto clase) crea un objeto " "vacío. Muchas clases necesitan crear objetos con instancias en un estado " -"inicial particular. Por lo tanto una clase puede definir un método especial" -" llamado :meth:`__init__`, de esta forma::" +"inicial particular. Por lo tanto una clase puede definir un método " +"especial llamado :meth:`__init__`, de esta forma::" #: ../Doc/tutorial/classes.rst:299 msgid "" "When a class defines an :meth:`__init__` method, class instantiation " -"automatically invokes :meth:`__init__` for the newly-created class instance." -" So in this example, a new, initialized instance can be obtained by::" +"automatically invokes :meth:`__init__` for the newly-created class " +"instance. So in this example, a new, initialized instance can be obtained " +"by::" msgstr "" "Cuando una clase define un método :meth:`__init__`, la instanciación de la " "clase automáticamente invoca a :meth:`__init__` para la instancia recién " @@ -591,13 +597,13 @@ msgstr "Objetos instancia" #: ../Doc/tutorial/classes.rst:324 msgid "" -"Now what can we do with instance objects? The only operations understood by" -" instance objects are attribute references. There are two kinds of valid " +"Now what can we do with instance objects? The only operations understood " +"by instance objects are attribute references. There are two kinds of valid " "attribute names, data attributes and methods." msgstr "" -"Ahora, ¿Qué podemos hacer con los objetos instancia? La única operación que" -" es entendida por los objetos instancia es la referencia de atributos. Hay " -"dos tipos de nombres de atributos válidos, atributos de datos y métodos." +"Ahora, ¿Qué podemos hacer con los objetos instancia? La única operación " +"que es entendida por los objetos instancia es la referencia de atributos. " +"Hay dos tipos de nombres de atributos válidos, atributos de datos y métodos." #: ../Doc/tutorial/classes.rst:328 msgid "" @@ -619,17 +625,17 @@ msgstr "" msgid "" "The other kind of instance attribute reference is a *method*. A method is a " "function that \"belongs to\" an object. (In Python, the term method is not " -"unique to class instances: other object types can have methods as well. For" -" example, list objects have methods called append, insert, remove, sort, and" -" so on. However, in the following discussion, we'll use the term method " +"unique to class instances: other object types can have methods as well. " +"For example, list objects have methods called append, insert, remove, sort, " +"and so on. However, in the following discussion, we'll use the term method " "exclusively to mean methods of class instance objects, unless explicitly " "stated otherwise.)" msgstr "" "El otro tipo de atributo de instancia es el *método*. Un método es una " -"función que \"pertenece a\" un objeto. En Python, el término método no está" -" limitado a instancias de clase: otros tipos de objetos pueden tener métodos" -" también. Por ejemplo, los objetos lista tienen métodos llamados append, " -"insert, remove, sort, y así sucesivamente. Pero, en la siguiente " +"función que \"pertenece a\" un objeto. En Python, el término método no " +"está limitado a instancias de clase: otros tipos de objetos pueden tener " +"métodos también. Por ejemplo, los objetos lista tienen métodos llamados " +"append, insert, remove, sort, y así sucesivamente. Pero, en la siguiente " "explicación, usaremos el término método para referirnos exclusivamente a " "métodos de objetos instancia de clase, a menos que se especifique " "explícitamente lo contrario." @@ -646,10 +652,10 @@ msgstr "" "Los nombres válidos de métodos de un objeto instancia dependen de su clase. " "Por definición, todos los atributos de clase que son objetos funciones " "definen métodos correspondientes de sus instancias. Entonces, en nuestro " -"ejemplo, ``x.f`` es una referencia a un método válido, dado que " -"``MiClase.f`` es una función, pero ``x.i`` no lo es, dado que ``MiClase.i`` " -"no lo es. Pero ``x.f`` no es la misma cosa que ``MiClase.f``; es un *objeto" -" método*, no un objeto función." +"ejemplo, ``x.f`` es una referencia a un método válido, dado que ``MiClase." +"f`` es una función, pero ``x.i`` no lo es, dado que ``MiClase.i`` no lo " +"es. Pero ``x.f`` no es la misma cosa que ``MiClase.f``; es un *objeto " +"método*, no un objeto función." #: ../Doc/tutorial/classes.rst:360 msgid "Method Objects" @@ -679,46 +685,46 @@ msgid "" "What exactly happens when a method is called? You may have noticed that " "``x.f()`` was called without an argument above, even though the function " "definition for :meth:`f` specified an argument. What happened to the " -"argument? Surely Python raises an exception when a function that requires an" -" argument is called without any --- even if the argument isn't actually " +"argument? Surely Python raises an exception when a function that requires " +"an argument is called without any --- even if the argument isn't actually " "used..." msgstr "" -"¿Qué sucede exactamente cuando un método es llamado? Debés haber notado que" -" ``x.f()`` fue llamado más arriba sin ningún argumento, a pesar de que la " -"definición de función de :meth:`f` especificaba un argumento. ¿Qué pasó con" -" ese argumento? Seguramente Python levanta una excepción cuando una función" -" que requiere un argumento es llamada sin ninguno, aún si el argumento no es" -" utilizado..." +"¿Qué sucede exactamente cuando un método es llamado? Debés haber notado " +"que ``x.f()`` fue llamado más arriba sin ningún argumento, a pesar de que " +"la definición de función de :meth:`f` especificaba un argumento. ¿Qué pasó " +"con ese argumento? Seguramente Python levanta una excepción cuando una " +"función que requiere un argumento es llamada sin ninguno, aún si el " +"argumento no es utilizado..." #: ../Doc/tutorial/classes.rst:382 msgid "" "Actually, you may have guessed the answer: the special thing about methods " -"is that the instance object is passed as the first argument of the function." -" In our example, the call ``x.f()`` is exactly equivalent to " -"``MyClass.f(x)``. In general, calling a method with a list of *n* arguments" -" is equivalent to calling the corresponding function with an argument list " -"that is created by inserting the method's instance object before the first " -"argument." +"is that the instance object is passed as the first argument of the " +"function. In our example, the call ``x.f()`` is exactly equivalent to " +"``MyClass.f(x)``. In general, calling a method with a list of *n* " +"arguments is equivalent to calling the corresponding function with an " +"argument list that is created by inserting the method's instance object " +"before the first argument." msgstr "" "De hecho, tal vez hayas adivinado la respuesta: lo que tienen de especial " "los métodos es que el objeto es pasado como el primer argumento de la " -"función. En nuestro ejemplo, la llamada ``x.f()`` es exactamente equivalente" -" a ``MiClase.f(x)``. En general, llamar a un método con una lista de *n* " -"argumentos es equivalente a llamar a la función correspondiente con una " -"lista de argumentos que es creada insertando el objeto del método antes del " -"primer argumento." +"función. En nuestro ejemplo, la llamada ``x.f()`` es exactamente " +"equivalente a ``MiClase.f(x)``. En general, llamar a un método con una " +"lista de *n* argumentos es equivalente a llamar a la función " +"correspondiente con una lista de argumentos que es creada insertando el " +"objeto del método antes del primer argumento." #: ../Doc/tutorial/classes.rst:389 msgid "" -"If you still don't understand how methods work, a look at the implementation" -" can perhaps clarify matters. When a non-data attribute of an instance is " -"referenced, the instance's class is searched. If the name denotes a valid " -"class attribute that is a function object, a method object is created by " -"packing (pointers to) the instance object and the function object just found" -" together in an abstract object: this is the method object. When the method" -" object is called with an argument list, a new argument list is constructed " -"from the instance object and the argument list, and the function object is " -"called with this new argument list." +"If you still don't understand how methods work, a look at the " +"implementation can perhaps clarify matters. When a non-data attribute of " +"an instance is referenced, the instance's class is searched. If the name " +"denotes a valid class attribute that is a function object, a method object " +"is created by packing (pointers to) the instance object and the function " +"object just found together in an abstract object: this is the method " +"object. When the method object is called with an argument list, a new " +"argument list is constructed from the instance object and the argument " +"list, and the function object is called with this new argument list." msgstr "" #: ../Doc/tutorial/classes.rst:403 @@ -743,9 +749,9 @@ msgid "" "not be used as a class variable because just a single list would be shared " "by all *Dog* instances::" msgstr "" -"Como se vió en :ref:`tut-object`, los datos compartidos pueden tener efectos" -" inesperados que involucren objetos :term:`mutables` como ser listas y " -"diccionarios. Por ejemplo, la lista *trucos* en el siguiente código no " +"Como se vió en :ref:`tut-object`, los datos compartidos pueden tener " +"efectos inesperados que involucren objetos :term:`mutables` como ser listas " +"y diccionarios. Por ejemplo, la lista *trucos* en el siguiente código no " "debería ser usada como variable de clase porque una sola lista sería " "compartida por todos las instancias de *Perro*::" @@ -772,10 +778,10 @@ msgstr "" "nombre; para evitar conflictos de nombre accidentales, que pueden causar " "errores difíciles de encontrar en programas grandes, es prudente usar algún " "tipo de convención que minimice las posibilidades de dichos conflictos. " -"Algunas convenciones pueden ser poner los nombres de métodos con mayúsculas," -" prefijar los nombres de atributos de datos con una pequeña cadena única (a " -"lo mejor sólo un guión bajo), o usar verbos para los métodos y sustantivos " -"para los atributos." +"Algunas convenciones pueden ser poner los nombres de métodos con " +"mayúsculas, prefijar los nombres de atributos de datos con una pequeña " +"cadena única (a lo mejor sólo un guión bajo), o usar verbos para los " +"métodos y sustantivos para los atributos." #: ../Doc/tutorial/classes.rst:485 msgid "" @@ -783,86 +789,89 @@ msgid "" "(\"clients\") of an object. In other words, classes are not usable to " "implement pure abstract data types. In fact, nothing in Python makes it " "possible to enforce data hiding --- it is all based upon convention. (On " -"the other hand, the Python implementation, written in C, can completely hide" -" implementation details and control access to an object if necessary; this " -"can be used by extensions to Python written in C.)" +"the other hand, the Python implementation, written in C, can completely " +"hide implementation details and control access to an object if necessary; " +"this can be used by extensions to Python written in C.)" msgstr "" "A los atributos de datos los pueden hacer referencia tanto los métodos como " -"los usuarios (\"clientes\") ordinarios de un objeto. En otras palabras, las" -" clases no se usan para implementar tipos de datos abstractos puros. De " -"hecho, en Python no hay nada que haga cumplir el ocultar datos; todo se basa" -" en convención. (Por otro lado, la implementación de Python, escrita en C, " -"puede ocultar por completo detalles de implementación y el control de acceso" -" a un objeto si es necesario; esto se puede usar en extensiones a Python " -"escritas en C.)" +"los usuarios (\"clientes\") ordinarios de un objeto. En otras palabras, " +"las clases no se usan para implementar tipos de datos abstractos puros. De " +"hecho, en Python no hay nada que haga cumplir el ocultar datos; todo se " +"basa en convención. (Por otro lado, la implementación de Python, escrita " +"en C, puede ocultar por completo detalles de implementación y el control de " +"acceso a un objeto si es necesario; esto se puede usar en extensiones a " +"Python escritas en C.)" #: ../Doc/tutorial/classes.rst:493 msgid "" "Clients should use data attributes with care --- clients may mess up " "invariants maintained by the methods by stamping on their data attributes. " -"Note that clients may add data attributes of their own to an instance object" -" without affecting the validity of the methods, as long as name conflicts " -"are avoided --- again, a naming convention can save a lot of headaches here." +"Note that clients may add data attributes of their own to an instance " +"object without affecting the validity of the methods, as long as name " +"conflicts are avoided --- again, a naming convention can save a lot of " +"headaches here." msgstr "" "Los clientes deben usar los atributos de datos con cuidado; éstos pueden " "romper invariantes que mantienen los métodos si pisan los atributos de " -"datos. Observá que los clientes pueden añadir sus propios atributos de datos" -" a una instancia sin afectar la validez de sus métodos, siempre y cuando se " -"eviten conflictos de nombres; de nuevo, una convención de nombres puede " -"ahorrar un montón de dolores de cabeza." +"datos. Observá que los clientes pueden añadir sus propios atributos de " +"datos a una instancia sin afectar la validez de sus métodos, siempre y " +"cuando se eviten conflictos de nombres; de nuevo, una convención de nombres " +"puede ahorrar un montón de dolores de cabeza." #: ../Doc/tutorial/classes.rst:499 msgid "" "There is no shorthand for referencing data attributes (or other methods!) " -"from within methods. I find that this actually increases the readability of" -" methods: there is no chance of confusing local variables and instance " +"from within methods. I find that this actually increases the readability " +"of methods: there is no chance of confusing local variables and instance " "variables when glancing through a method." msgstr "" "No hay un atajo para hacer referencia a atributos de datos (¡u otros " -"métodos!) desde dentro de un método. A mi parecer, esto en realidad aumenta" -" la legibilidad de los métodos: no existe posibilidad alguna de confundir " -"variables locales con variables de instancia cuando repasamos un método." +"métodos!) desde dentro de un método. A mi parecer, esto en realidad " +"aumenta la legibilidad de los métodos: no existe posibilidad alguna de " +"confundir variables locales con variables de instancia cuando repasamos un " +"método." #: ../Doc/tutorial/classes.rst:504 msgid "" "Often, the first argument of a method is called ``self``. This is nothing " "more than a convention: the name ``self`` has absolutely no special meaning " "to Python. Note, however, that by not following the convention your code " -"may be less readable to other Python programmers, and it is also conceivable" -" that a *class browser* program might be written that relies upon such a " -"convention." +"may be less readable to other Python programmers, and it is also " +"conceivable that a *class browser* program might be written that relies " +"upon such a convention." msgstr "" "A menudo, el primer argumento de un método se llama ``self`` (uno mismo). " -"Esto no es nada más que una convención: el nombre ``self`` no significa nada" -" en especial para Python. Observá que, sin embargo, si no seguís la " +"Esto no es nada más que una convención: el nombre ``self`` no significa " +"nada en especial para Python. Observá que, sin embargo, si no seguís la " "convención tu código puede resultar menos legible a otros programadores de " "Python, y puede llegar a pasar que un programa *navegador de clases* pueda " "escribirse de una manera que dependa de dicha convención." #: ../Doc/tutorial/classes.rst:510 msgid "" -"Any function object that is a class attribute defines a method for instances" -" of that class. It is not necessary that the function definition is " -"textually enclosed in the class definition: assigning a function object to a" -" local variable in the class is also ok. For example::" +"Any function object that is a class attribute defines a method for " +"instances of that class. It is not necessary that the function definition " +"is textually enclosed in the class definition: assigning a function object " +"to a local variable in the class is also ok. For example::" msgstr "" "Cualquier objeto función que es un atributo de clase define un método para " -"instancias de esa clase. No es necesario que el la definición de la función" -" esté textualmente dentro de la definición de la clase: asignando un objeto " -"función a una variable local en la clase también está bien. Por ejemplo::" +"instancias de esa clase. No es necesario que el la definición de la " +"función esté textualmente dentro de la definición de la clase: asignando un " +"objeto función a una variable local en la clase también está bien. Por " +"ejemplo::" #: ../Doc/tutorial/classes.rst:527 msgid "" -"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer" -" to function objects, and consequently they are all methods of instances of " -":class:`C` --- ``h`` being exactly equivalent to ``g``. Note that this " -"practice usually only serves to confuse the reader of a program." +"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that " +"refer to function objects, and consequently they are all methods of " +"instances of :class:`C` --- ``h`` being exactly equivalent to ``g``. Note " +"that this practice usually only serves to confuse the reader of a program." msgstr "" "Ahora ``f``, ``g`` y ``h`` son todos atributos de la clase :class:`C` que " "hacen referencia a objetos función, y consecuentemente son todos métodos de " "las instancias de :class:`C`; ``h`` siendo exactamente equivalente a ``g``. " -"Fijate que esta práctica normalmente sólo sirve para confundir al que lea un" -" programa." +"Fijate que esta práctica normalmente sólo sirve para confundir al que lea " +"un programa." #: ../Doc/tutorial/classes.rst:532 msgid "" @@ -881,8 +890,8 @@ msgid "" "legitimate uses of the global scope: for one thing, functions and modules " "imported into the global scope can be used by methods, as well as functions " "and classes defined in it. Usually, the class containing the method is " -"itself defined in this global scope, and in the next section we'll find some" -" good reasons why a method would want to reference its own class." +"itself defined in this global scope, and in the next section we'll find " +"some good reasons why a method would want to reference its own class." msgstr "" "Los métodos pueden hacer referencia a nombres globales de la misma manera " "que lo hacen las funciones comunes. El ámbito global asociado a un método " @@ -892,8 +901,8 @@ msgstr "" "menos, las funciones y módulos importados en el ámbito global pueden usarse " "por los métodos, al igual que las funciones y clases definidas en él. " "Habitualmente, la clase que contiene el método está definida en este ámbito " -"global, y en la siguiente sección veremos algunas buenas razones por las que" -" un método querría hacer referencia a su propia clase." +"global, y en la siguiente sección veremos algunas buenas razones por las " +"que un método querría hacer referencia a su propia clase." #: ../Doc/tutorial/classes.rst:556 msgid "" @@ -924,8 +933,8 @@ msgid "" "expressions are also allowed. This can be useful, for example, when the " "base class is defined in another module::" msgstr "" -"El nombre :class:`ClaseBase` debe estar definido en un ámbito que contenga a" -" la definición de la clase derivada. En el lugar del nombre de la clase " +"El nombre :class:`ClaseBase` debe estar definido en un ámbito que contenga " +"a la definición de la clase derivada. En el lugar del nombre de la clase " "base se permiten otras expresiones arbitrarias. Esto puede ser útil, por " "ejemplo, cuando la clase base está definida en otro módulo::" @@ -933,17 +942,17 @@ msgstr "" msgid "" "Execution of a derived class definition proceeds the same as for a base " "class. When the class object is constructed, the base class is remembered. " -"This is used for resolving attribute references: if a requested attribute is" -" not found in the class, the search proceeds to look in the base class. " +"This is used for resolving attribute references: if a requested attribute " +"is not found in the class, the search proceeds to look in the base class. " "This rule is applied recursively if the base class itself is derived from " "some other class." msgstr "" "La ejecución de una definición de clase derivada procede de la misma forma " -"que una clase base. Cuando el objeto clase se construye, se tiene en cuenta" -" a la clase base. Esto se usa para resolver referencias a atributos: si un " -"atributo solicitado no se encuentra en la clase, la búsqueda continúa por la" -" clase base. Esta regla se aplica recursivamente si la clase base misma " -"deriva de alguna otra clase." +"que una clase base. Cuando el objeto clase se construye, se tiene en " +"cuenta a la clase base. Esto se usa para resolver referencias a atributos: " +"si un atributo solicitado no se encuentra en la clase, la búsqueda continúa " +"por la clase base. Esta regla se aplica recursivamente si la clase base " +"misma deriva de alguna otra clase." #: ../Doc/tutorial/classes.rst:589 msgid "" @@ -954,23 +963,25 @@ msgid "" "method reference is valid if this yields a function object." msgstr "" "No hay nada en especial en la instanciación de clases derivadas: " -"``ClaseDerivada()`` crea una nueva instancia de la clase. Las referencias a" -" métodos se resuelven de la siguiente manera: se busca el atributo de clase " -"correspondiente, descendiendo por la cadena de clases base si es necesario, " -"y la referencia al método es válida si se entrega un objeto función." +"``ClaseDerivada()`` crea una nueva instancia de la clase. Las referencias " +"a métodos se resuelven de la siguiente manera: se busca el atributo de " +"clase correspondiente, descendiendo por la cadena de clases base si es " +"necesario, y la referencia al método es válida si se entrega un objeto " +"función." #: ../Doc/tutorial/classes.rst:595 msgid "" -"Derived classes may override methods of their base classes. Because methods" -" have no special privileges when calling other methods of the same object, a" -" method of a base class that calls another method defined in the same base " -"class may end up calling a method of a derived class that overrides it. " -"(For C++ programmers: all methods in Python are effectively ``virtual``.)" +"Derived classes may override methods of their base classes. Because " +"methods have no special privileges when calling other methods of the same " +"object, a method of a base class that calls another method defined in the " +"same base class may end up calling a method of a derived class that " +"overrides it. (For C++ programmers: all methods in Python are effectively " +"``virtual``.)" msgstr "" "Las clases derivadas pueden redefinir métodos de su clase base. Como los " "métodos no tienen privilegios especiales cuando llaman a otros métodos del " -"mismo objeto, un método de la clase base que llame a otro método definido en" -" la misma clase base puede terminar llamando a un método de la clase " +"mismo objeto, un método de la clase base que llame a otro método definido " +"en la misma clase base puede terminar llamando a un método de la clase " "derivada que lo haya redefinido. (Para los programadores de C++: en Python " "todos los métodos son en efecto ``virtuales``.)" @@ -983,12 +994,12 @@ msgid "" "to clients as well. (Note that this only works if the base class is " "accessible as ``BaseClassName`` in the global scope.)" msgstr "" -"Un método redefinido en una clase derivada puede de hecho querer extender en" -" vez de simplemente reemplazar al método de la clase base con el mismo " +"Un método redefinido en una clase derivada puede de hecho querer extender " +"en vez de simplemente reemplazar al método de la clase base con el mismo " "nombre. Hay una manera simple de llamar al método de la clase base " "directamente: simplemente llamás a ``ClaseBase.metodo(self, argumentos)``. " -"En ocasiones esto es útil para los clientes también. (Observá que esto sólo" -" funciona si la clase base es accesible como ``ClaseBase`` en el ámbito " +"En ocasiones esto es útil para los clientes también. (Observá que esto " +"sólo funciona si la clase base es accesible como ``ClaseBase`` en el ámbito " "global.)" #: ../Doc/tutorial/classes.rst:608 @@ -997,18 +1008,25 @@ msgstr "Python tiene dos funciones integradas que funcionan con herencia:" #: ../Doc/tutorial/classes.rst:610 msgid "" -"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)``" -" will be ``True`` only if ``obj.__class__`` is :class:`int` or some class " -"derived from :class:`int`." +"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, " +"int)`` will be ``True`` only if ``obj.__class__`` is :class:`int` or some " +"class derived from :class:`int`." msgstr "" +"Usar :func:`isinstance` para verificar el tipo de una instancia: " +"``isinstance(obj, int)`` será ``True`` sólo si ``obj.__class__`` es :class:" +"`int` o alguna clase derivada de :class:`int`." #: ../Doc/tutorial/classes.rst:614 msgid "" -"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)``" -" is ``True`` since :class:`bool` is a subclass of :class:`int`. However, " -"``issubclass(float, int)`` is ``False`` since :class:`float` is not a " -"subclass of :class:`int`." +"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, " +"int)`` is ``True`` since :class:`bool` is a subclass of :class:`int`. " +"However, ``issubclass(float, int)`` is ``False`` since :class:`float` is " +"not a subclass of :class:`int`." msgstr "" +"Usar :func:`issubclass` para verificar la herencia de clases: " +"``issubclass(bool, int)`` es ``True`` ya que :class:`bool` es una subclase " +"de :class:`int`. Sin embargo, ``issubclass(float, int)`` es ``False`` ya " +"que :class:`float` no es una subclase de :class:`int`." #: ../Doc/tutorial/classes.rst:624 msgid "Multiple Inheritance" @@ -1028,17 +1046,17 @@ msgid "" "attributes inherited from a parent class as depth-first, left-to-right, not " "searching twice in the same class where there is an overlap in the " "hierarchy. Thus, if an attribute is not found in :class:`DerivedClassName`, " -"it is searched for in :class:`Base1`, then (recursively) in the base classes" -" of :class:`Base1`, and if it was not found there, it was searched for in " -":class:`Base2`, and so on." +"it is searched for in :class:`Base1`, then (recursively) in the base " +"classes of :class:`Base1`, and if it was not found there, it was searched " +"for in :class:`Base2`, and so on." msgstr "" -"Para la mayoría de los propósitos, en los casos más simples, podés pensar en" -" la búsqueda de los atributos heredados de clases padres como primero en " +"Para la mayoría de los propósitos, en los casos más simples, podés pensar " +"en la búsqueda de los atributos heredados de clases padres como primero en " "profundidad, de izquierda a derecha, sin repetir la misma clase cuando está " -"dos veces en la jerarquía. Por lo tanto, si un atributo no se encuentra en " -":class:`ClaseDerivada`, se busca en :class:`Base1`, luego (recursivamente) " -"en las clases base de :class:`Base1`, y sólo si no se encuentra allí se lo " -"busca en :class:`Base2`, y así sucesivamente." +"dos veces en la jerarquía. Por lo tanto, si un atributo no se encuentra " +"en :class:`ClaseDerivada`, se busca en :class:`Base1`, luego " +"(recursivamente) en las clases base de :class:`Base1`, y sólo si no se " +"encuentra allí se lo busca en :class:`Base2`, y así sucesivamente." #: ../Doc/tutorial/classes.rst:643 msgid "" @@ -1049,8 +1067,8 @@ msgid "" "languages." msgstr "" "En realidad es un poco más complejo que eso; el orden de resolución de " -"métodos cambia dinámicamente para soportar las llamadas cooperativas a " -":func:`super`. Este enfoque es conocido en otros lenguajes con herencia " +"métodos cambia dinámicamente para soportar las llamadas cooperativas a :" +"func:`super`. Este enfoque es conocido en otros lenguajes con herencia " "múltiple como \"llámese al siguiente método\" y es más poderoso que la " "llamada al superior que se encuentra en lenguajes con sólo herencia simple." @@ -1067,22 +1085,23 @@ msgid "" "and that is monotonic (meaning that a class can be subclassed without " "affecting the precedence order of its parents). Taken together, these " "properties make it possible to design reliable and extensible classes with " -"multiple inheritance. For more detail, see " -"https://www.python.org/download/releases/2.3/mro/." +"multiple inheritance. For more detail, see https://www.python.org/download/" +"releases/2.3/mro/." msgstr "" "El ordenamiento dinámico es necesario porque todos los casos de herencia " -"múltiple exhiben una o más relaciones en diamante (cuando se puede llegar al" -" menos a una de las clases base por distintos caminos desde la clase de más " -"abajo). Por ejemplo, todas las clases heredan de :class:`object`, por lo " -"tanto cualquier caso de herencia múltiple provee más de un camino para " -"llegar a :class:`object`. Para que las clases base no sean accedidas más de" -" una vez, el algoritmo dinámico hace lineal el orden de búsqueda de manera " -"que se preserve el orden de izquierda a derecha especificado en cada clase, " -"que se llame a cada clase base sólo una vez, y que sea monótona (lo cual " -"significa que una clase puede tener clases derivadas sin afectar el orden de" -" precedencia de sus clases bases). En conjunto, estas propiedades hacen " -"posible diseñar clases confiables y extensibles con herencia múltiple. Para " -"más detalles mirá https://www.python.org/download/releases/2.3/mro/." +"múltiple exhiben una o más relaciones en diamante (cuando se puede llegar " +"al menos a una de las clases base por distintos caminos desde la clase de " +"más abajo). Por ejemplo, todas las clases heredan de :class:`object`, por " +"lo tanto cualquier caso de herencia múltiple provee más de un camino para " +"llegar a :class:`object`. Para que las clases base no sean accedidas más " +"de una vez, el algoritmo dinámico hace lineal el orden de búsqueda de " +"manera que se preserve el orden de izquierda a derecha especificado en cada " +"clase, que se llame a cada clase base sólo una vez, y que sea monótona (lo " +"cual significa que una clase puede tener clases derivadas sin afectar el " +"orden de precedencia de sus clases bases). En conjunto, estas propiedades " +"hacen posible diseñar clases confiables y extensibles con herencia " +"múltiple. Para más detalles mirá https://www.python.org/download/" +"releases/2.3/mro/." #: ../Doc/tutorial/classes.rst:666 msgid "Private Variables" @@ -1090,8 +1109,8 @@ msgstr "Variables privadas" #: ../Doc/tutorial/classes.rst:668 msgid "" -"\"Private\" instance variables that cannot be accessed except from inside an" -" object don't exist in Python. However, there is a convention that is " +"\"Private\" instance variables that cannot be accessed except from inside " +"an object don't exist in Python. However, there is a convention that is " "followed by most Python code: a name prefixed with an underscore (e.g. " "``_spam``) should be treated as a non-public part of the API (whether it is " "a function, a method or a data member). It should be considered an " @@ -1099,11 +1118,11 @@ msgid "" msgstr "" "Las variables \"privadas\" de instancia, que no pueden accederse excepto " "desde dentro de un objeto, no existen en Python. Sin embargo, hay una " -"convención que se sigue en la mayoría del código Python: un nombre prefijado" -" con un guión bajo (por ejemplo, ``_spam``) debería tratarse como una parte " -"no pública de la API (más allá de que sea una función, un método, o un " -"dato). Debería considerarse un detalle de implementación y que está sujeto " -"a cambios sin aviso." +"convención que se sigue en la mayoría del código Python: un nombre " +"prefijado con un guión bajo (por ejemplo, ``_spam``) debería tratarse como " +"una parte no pública de la API (más allá de que sea una función, un método, " +"o un dato). Debería considerarse un detalle de implementación y que está " +"sujeto a cambios sin aviso." #: ../Doc/tutorial/classes.rst:678 msgid "" @@ -1112,9 +1131,9 @@ msgid "" "support for such a mechanism, called :dfn:`name mangling`. Any identifier " "of the form ``__spam`` (at least two leading underscores, at most one " "trailing underscore) is textually replaced with ``_classname__spam``, where " -"``classname`` is the current class name with leading underscore(s) stripped." -" This mangling is done without regard to the syntactic position of the " -"identifier, as long as it occurs within the definition of a class." +"``classname`` is the current class name with leading underscore(s) " +"stripped. This mangling is done without regard to the syntactic position " +"of the identifier, as long as it occurs within the definition of a class." msgstr "" "Ya que hay un caso de uso válido para los identificadores privados de clase " "(a saber: colisión de nombres con nombres definidos en las subclases), hay " @@ -1137,22 +1156,27 @@ msgstr "" #: ../Doc/tutorial/classes.rst:709 msgid "" -"The above example would work even if ``MappingSubclass`` were to introduce a" -" ``__update`` identifier since it is replaced with ``_Mapping__update`` in " +"The above example would work even if ``MappingSubclass`` were to introduce " +"a ``__update`` identifier since it is replaced with ``_Mapping__update`` in " "the ``Mapping`` class and ``_MappingSubclass__update`` in the " "``MappingSubclass`` class respectively." msgstr "" +"El ejemplo de arriba funcionaría incluso si ``MappingSubclass`` introdujera " +"un identificador ``__update`` ya que se reemplaza con ``_Mapping__update`` " +"en la clase ``Mapping`` y ``_MappingSubclass__update`` en la clase " +"``MappingSubclass`` respectivamente." #: ../Doc/tutorial/classes.rst:714 msgid "" "Note that the mangling rules are designed mostly to avoid accidents; it " -"still is possible to access or modify a variable that is considered private." -" This can even be useful in special circumstances, such as in the debugger." +"still is possible to access or modify a variable that is considered " +"private. This can even be useful in special circumstances, such as in the " +"debugger." msgstr "" "Hay que aclarar que las reglas de modificación de nombres están diseñadas " "principalmente para evitar accidentes; es posible acceder o modificar una " -"variable que es considerada como privada. Esto hasta puede resultar útil en" -" circunstancias especiales, tales como en el depurador." +"variable que es considerada como privada. Esto hasta puede resultar útil " +"en circunstancias especiales, tales como en el depurador." #: ../Doc/tutorial/classes.rst:718 msgid "" @@ -1187,24 +1211,24 @@ msgstr "" #: ../Doc/tutorial/classes.rst:745 msgid "" "A piece of Python code that expects a particular abstract data type can " -"often be passed a class that emulates the methods of that data type instead." -" For instance, if you have a function that formats some data from a file " -"object, you can define a class with methods :meth:`read` and " -":meth:`!readline` that get the data from a string buffer instead, and pass " -"it as an argument." +"often be passed a class that emulates the methods of that data type " +"instead. For instance, if you have a function that formats some data from " +"a file object, you can define a class with methods :meth:`read` and :meth:`!" +"readline` that get the data from a string buffer instead, and pass it as an " +"argument." msgstr "" "Algún código Python que espera un tipo abstracto de datos en particular " "puede frecuentemente recibir en cambio una clase que emula los métodos de " -"aquel tipo de datos. Por ejemplo, si tenés una función que formatea algunos" -" datos a partir de un objeto archivo, podés definir una clase con métodos " -":meth:`read` y :meth:`!readline` que obtengan los datos de alguna cadena en " -"memoria intermedia, y pasarlo como argumento." +"aquel tipo de datos. Por ejemplo, si tenés una función que formatea " +"algunos datos a partir de un objeto archivo, podés definir una clase con " +"métodos :meth:`read` y :meth:`!readline` que obtengan los datos de alguna " +"cadena en memoria intermedia, y pasarlo como argumento." #: ../Doc/tutorial/classes.rst:756 msgid "" -"Instance method objects have attributes, too: ``m.__self__`` is the instance" -" object with the method :meth:`m`, and ``m.__func__`` is the function object" -" corresponding to the method." +"Instance method objects have attributes, too: ``m.__self__`` is the " +"instance object with the method :meth:`m`, and ``m.__func__`` is the " +"function object corresponding to the method." msgstr "" "Los objetos método de instancia tienen atributos también: ``m.__self__`` es " "el objeto instancia con el método :meth:`m`, y ``m.__func__`` es el objeto " @@ -1225,24 +1249,25 @@ msgstr "" #: ../Doc/tutorial/classes.rst:780 msgid "" "This style of access is clear, concise, and convenient. The use of " -"iterators pervades and unifies Python. Behind the scenes, the " -":keyword:`for` statement calls :func:`iter` on the container object. The " -"function returns an iterator object that defines the method " -":meth:`~iterator.__next__` which accesses elements in the container one at a" -" time. When there are no more elements, :meth:`~iterator.__next__` raises a" -" :exc:`StopIteration` exception which tells the :keyword:`!for` loop to " -"terminate. You can call the :meth:`~iterator.__next__` method using the " -":func:`next` built-in function; this example shows how it all works::" +"iterators pervades and unifies Python. Behind the scenes, the :keyword:" +"`for` statement calls :func:`iter` on the container object. The function " +"returns an iterator object that defines the method :meth:`~iterator." +"__next__` which accesses elements in the container one at a time. When " +"there are no more elements, :meth:`~iterator.__next__` raises a :exc:" +"`StopIteration` exception which tells the :keyword:`!for` loop to " +"terminate. You can call the :meth:`~iterator.__next__` method using the :" +"func:`next` built-in function; this example shows how it all works::" msgstr "" "Este estilo de acceso es limpio, conciso y conveniente. El uso de " -"iteradores está impregnado y unifica a Python. En bambalinas, la sentencia " -":keyword:`for` llama a :func:`iter` en el objeto contenedor. La función " -"devuelve un objeto iterador que define el método :meth:`__next__` que accede" -" elementos en el contenedor de a uno por vez. Cuando no hay más elementos, " -":meth:`~iterator.__next__` levanta una excepción :exc:`StopIteration` que le" -" avisa al bucle del :keyword:`for` que hay que terminar. Podés llamar al " -"método :meth:`~iterator.__next__` usando la función integrada " -":func:`~iterator.__next__`; este ejemplo muestra como funciona todo esto::" +"iteradores está impregnado y unifica a Python. En bambalinas, la " +"sentencia :keyword:`for` llama a :func:`iter` en el objeto contenedor. La " +"función devuelve un objeto iterador que define el método :meth:`__next__` " +"que accede elementos en el contenedor de a uno por vez. Cuando no hay más " +"elementos, :meth:`~iterator.__next__` levanta una excepción :exc:" +"`StopIteration` que le avisa al bucle del :keyword:`for` que hay que " +"terminar. Podés llamar al método :meth:`~iterator.__next__` usando la " +"función integrada :func:`~iterator.__next__`; este ejemplo muestra como " +"funciona todo esto::" #: ../Doc/tutorial/classes.rst:805 msgid "" @@ -1253,8 +1278,8 @@ msgid "" msgstr "" "Habiendo visto la mecánica del protocolo de iteración, es fácil agregar " "comportamiento de iterador a tus clases. Definí un método :meth:`__iter__` " -"que devuelva un objeto con un método :meth:`__next__`. Si la clase define " -":meth:`__next__`, entonces alcanza con que :meth:`__iter__` devuelva " +"que devuelva un objeto con un método :meth:`__next__`. Si la clase define :" +"meth:`__next__`, entonces alcanza con que :meth:`__iter__` devuelva " "``self``::" #: ../Doc/tutorial/classes.rst:842 @@ -1263,43 +1288,43 @@ msgstr "Generadores" #: ../Doc/tutorial/classes.rst:844 msgid "" -":term:`Generator`\\s are a simple and powerful tool for creating iterators." -" They are written like regular functions but use the :keyword:`yield` " -"statement whenever they want to return data. Each time :func:`next` is " -"called on it, the generator resumes where it left off (it remembers all the " -"data values and which statement was last executed). An example shows that " -"generators can be trivially easy to create::" +":term:`Generator`\\s are a simple and powerful tool for creating " +"iterators. They are written like regular functions but use the :keyword:" +"`yield` statement whenever they want to return data. Each time :func:" +"`next` is called on it, the generator resumes where it left off (it " +"remembers all the data values and which statement was last executed). An " +"example shows that generators can be trivially easy to create::" msgstr "" "Los `generadores` son una simple y poderosa herramienta para crear " -"iteradores. Se escriben como funciones regulares pero usan la sentencia " -":keyword:`yield` cuando quieren devolver datos. Cada vez que se llama " -":func:`next` sobre él, el generador continúa desde donde dejó (y recuerda " -"todos los valores de datos y cual sentencia fue ejecutada última). Un " -"ejemplo muestra que los generadores pueden ser muy fáciles de crear::" +"iteradores. Se escriben como funciones regulares pero usan la sentencia :" +"keyword:`yield` cuando quieren devolver datos. Cada vez que se llama :func:" +"`next` sobre él, el generador continúa desde donde dejó (y recuerda todos " +"los valores de datos y cual sentencia fue ejecutada última). Un ejemplo " +"muestra que los generadores pueden ser muy fáciles de crear::" #: ../Doc/tutorial/classes.rst:865 msgid "" "Anything that can be done with generators can also be done with class-based " "iterators as described in the previous section. What makes generators so " -"compact is that the :meth:`__iter__` and :meth:`~generator.__next__` methods" -" are created automatically." +"compact is that the :meth:`__iter__` and :meth:`~generator.__next__` " +"methods are created automatically." msgstr "" "Todo lo que puede ser hecho con generadores también puede ser hecho con " "iteradores basados en clases, como se describe en la sección anterior. Lo " -"que hace que los generadores sean tan compactos es que los métodos " -":meth:`__iter__` y :meth:`__next__` son creados automáticamente." +"que hace que los generadores sean tan compactos es que los métodos :meth:" +"`__iter__` y :meth:`__next__` son creados automáticamente." #: ../Doc/tutorial/classes.rst:870 msgid "" "Another key feature is that the local variables and execution state are " "automatically saved between calls. This made the function easier to write " -"and much more clear than an approach using instance variables like " -"``self.index`` and ``self.data``." +"and much more clear than an approach using instance variables like ``self." +"index`` and ``self.data``." msgstr "" "Otra característica clave es que las variables locales y el estado de la " "ejecución son guardados automáticamente entre llamadas. Esto hace que la " -"función sea más fácil de escribir y quede mucho más claro que hacerlo usando" -" variables de instancia tales como ``self.indice`` y ``self.datos``." +"función sea más fácil de escribir y quede mucho más claro que hacerlo " +"usando variables de instancia tales como ``self.indice`` y ``self.datos``." #: ../Doc/tutorial/classes.rst:875 msgid "" @@ -1309,10 +1334,10 @@ msgid "" "effort than writing a regular function." msgstr "" "Además de la creación automática de métodos y el guardar el estado del " -"programa, cuando los generadores terminan automáticamente levantan " -":exc:`StopIteration`. Combinadas, estas características facilitan la " -"creación de iteradores, y hacen que no sea más esfuerzo que escribir una " -"función regular." +"programa, cuando los generadores terminan automáticamente levantan :exc:" +"`StopIteration`. Combinadas, estas características facilitan la creación " +"de iteradores, y hacen que no sea más esfuerzo que escribir una función " +"regular." #: ../Doc/tutorial/classes.rst:884 msgid "Generator Expressions" @@ -1320,13 +1345,21 @@ msgstr "Expresiones generadoras" #: ../Doc/tutorial/classes.rst:886 msgid "" -"Some simple generators can be coded succinctly as expressions using a syntax" -" similar to list comprehensions but with parentheses instead of square " -"brackets. These expressions are designed for situations where the generator " -"is used right away by an enclosing function. Generator expressions are more" -" compact but less versatile than full generator definitions and tend to be " -"more memory friendly than equivalent list comprehensions." -msgstr "" +"Some simple generators can be coded succinctly as expressions using a " +"syntax similar to list comprehensions but with parentheses instead of " +"square brackets. These expressions are designed for situations where the " +"generator is used right away by an enclosing function. Generator " +"expressions are more compact but less versatile than full generator " +"definitions and tend to be more memory friendly than equivalent list " +"comprehensions." +msgstr "" +"Algunos generadores simples pueden ser escritos de manera concisa como " +"expresiones usando una sintaxis similar a las comprensiones de listas pero " +"con paréntesis en lugar de corchetes. Estas expresiones están hechas para " +"situaciones donde el generador es utilizado de inmediato por la función que " +"lo encierra. Las expresiones generadoras son más compactas pero menos " +"versátiles que las definiciones completas de generadores y tienden a ser " +"más amigables con la memoria que sus comprensiones de listas equivalentes." #: ../Doc/tutorial/classes.rst:893 msgid "Examples::" @@ -1334,7 +1367,7 @@ msgstr "Ejemplos::" #: ../Doc/tutorial/classes.rst:917 msgid "Footnotes" -msgstr "" +msgstr "Notas al pie" #: ../Doc/tutorial/classes.rst:918 msgid "" From a4db9b0b58b9a079dcb09e951cf79438d6289c5a Mon Sep 17 00:00:00 2001 From: Marco Richetta Date: Mon, 4 May 2020 11:09:19 -0300 Subject: [PATCH 2/3] =?UTF-8?q?Correcci=C3=B3n=20con=20powrap?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tutorial/classes.po | 660 ++++++++++++++++++++++---------------------- 1 file changed, 323 insertions(+), 337 deletions(-) diff --git a/tutorial/classes.po b/tutorial/classes.po index 81e82d6d0f..44bd7beb48 100644 --- a/tutorial/classes.po +++ b/tutorial/classes.po @@ -14,8 +14,8 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "Last-Translator: Marco Richetta \n" -"Language-Team: python-doc-es (https://mail.python.org/mailman3/lists/docs-" -"es.python.org)\n" +"Language-Team: python-doc-es (https://mail.python.org/mailman3/lists/docs-es." +"python.org)\n" "Language: es\n" "X-Generator: Poedit 2.3\n" @@ -57,16 +57,16 @@ msgstr "" "Programación Orientada a Objetos: el mecanismo de la herencia de clases " "permite múltiples clases base, una clase derivada puede sobre escribir " "cualquier método de su(s) clase(s) base, y un método puede llamar al método " -"de la clase base con el mismo nombre. Los objetos pueden tener una " -"cantidad arbitraria de datos de cualquier tipo. Igual que con los módulos, " -"las clases participan de la naturaleza dinámica de Python: se crean en " -"tiempo de ejecución, y pueden modificarse luego de la creación." +"de la clase base con el mismo nombre. Los objetos pueden tener una cantidad " +"arbitraria de datos de cualquier tipo. Igual que con los módulos, las " +"clases participan de la naturaleza dinámica de Python: se crean en tiempo de " +"ejecución, y pueden modificarse luego de la creación." #: ../Doc/tutorial/classes.rst:23 msgid "" "In C++ terminology, normally class members (including the data members) are " -"*public* (except see below :ref:`tut-private`), and all member functions " -"are *virtual*. As in Modula-3, there are no shorthands for referencing the " +"*public* (except see below :ref:`tut-private`), and all member functions are " +"*virtual*. As in Modula-3, there are no shorthands for referencing the " "object's members from its methods: the method function is declared with an " "explicit first argument representing the object, which is provided " "implicitly by the call. As in Smalltalk, classes themselves are objects. " @@ -78,24 +78,23 @@ msgid "" msgstr "" "En terminología de C++, normalmente los miembros de las clases (incluyendo " "los miembros de datos), son *públicos* (excepto ver abajo :ref:`tut-" -"private`), y todas las funciones miembro son *virtuales*. Como en " -"Modula-3, no hay atajos para hacer referencia a los miembros del objeto " -"desde sus métodos: la función método se declara con un primer argumento " -"explícito que representa al objeto, el cual se provee implícitamente por la " -"llamada. Como en Smalltalk, las clases mismas son objetos. Esto provee " -"una semántica para importar y renombrar. A diferencia de C++ y Modula-3, " -"los tipos de datos integrados pueden usarse como clases base para que el " -"usuario los extienda. También, como en C++ pero a diferencia de Modula-3, " -"la mayoría de los operadores integrados con sintaxis especial (operadores " -"aritméticos, de subíndice, etc.) pueden ser redefinidos por instancias de " -"la clase." +"private`), y todas las funciones miembro son *virtuales*. Como en Modula-3, " +"no hay atajos para hacer referencia a los miembros del objeto desde sus " +"métodos: la función método se declara con un primer argumento explícito que " +"representa al objeto, el cual se provee implícitamente por la llamada. Como " +"en Smalltalk, las clases mismas son objetos. Esto provee una semántica para " +"importar y renombrar. A diferencia de C++ y Modula-3, los tipos de datos " +"integrados pueden usarse como clases base para que el usuario los extienda. " +"También, como en C++ pero a diferencia de Modula-3, la mayoría de los " +"operadores integrados con sintaxis especial (operadores aritméticos, de " +"subíndice, etc.) pueden ser redefinidos por instancias de la clase." #: ../Doc/tutorial/classes.rst:34 msgid "" -"(Lacking universally accepted terminology to talk about classes, I will " -"make occasional use of Smalltalk and C++ terms. I would use Modula-3 " -"terms, since its object-oriented semantics are closer to those of Python " -"than C++, but I expect that few readers have heard of it.)" +"(Lacking universally accepted terminology to talk about classes, I will make " +"occasional use of Smalltalk and C++ terms. I would use Modula-3 terms, " +"since its object-oriented semantics are closer to those of Python than C++, " +"but I expect that few readers have heard of it.)" msgstr "" "(Sin haber una terminología universalmente aceptada sobre clases, haré uso " "ocasional de términos de Smalltalk y C++. Usaría términos de Modula-3, ya " @@ -131,9 +130,9 @@ msgstr "" "otros tipos. Esto se usa normalmente para beneficio del programa, ya que " "los renombres funcionan como punteros en algunos aspectos. Por ejemplo, " "pasar un objeto es barato ya que la implementación solamente pasa el " -"puntero; y si una función modifica el objeto que fue pasado, el que la " -"llama verá el cambio; esto elimina la necesidad de tener dos formas " -"diferentes de pasar argumentos, como en Pascal." +"puntero; y si una función modifica el objeto que fue pasado, el que la llama " +"verá el cambio; esto elimina la necesidad de tener dos formas diferentes de " +"pasar argumentos, como en Pascal." #: ../Doc/tutorial/classes.rst:61 msgid "Python Scopes and Namespaces" @@ -165,22 +164,22 @@ msgid "" "noticeable in any way (except for performance), and it may change in the " "future. Examples of namespaces are: the set of built-in names (containing " "functions such as :func:`abs`, and built-in exception names); the global " -"names in a module; and the local names in a function invocation. In a " -"sense the set of attributes of an object also form a namespace. The " -"important thing to know about namespaces is that there is absolutely no " -"relation between names in different namespaces; for instance, two different " -"modules may both define a function ``maximize`` without confusion --- users " -"of the modules must prefix it with the module name." +"names in a module; and the local names in a function invocation. In a sense " +"the set of attributes of an object also form a namespace. The important " +"thing to know about namespaces is that there is absolutely no relation " +"between names in different namespaces; for instance, two different modules " +"may both define a function ``maximize`` without confusion --- users of the " +"modules must prefix it with the module name." msgstr "" "Un *espacio de nombres* es una relación de nombres a objetos. Muchos " -"espacios de nombres están implementados en este momento como diccionarios " -"de Python, pero eso no se nota para nada (excepto por el desempeño), y " -"puede cambiar en el futuro. Como ejemplos de espacios de nombres tenés: el " -"conjunto de nombres incluidos (conteniendo funciones como :func:`abs`, y " -"los nombres de excepciones integradas); los nombres globales en un módulo; " -"y los nombres locales en la invocación a una función. Lo que es importante " -"saber de los espacios de nombres es que no hay relación en absoluto entre " -"los nombres de espacios de nombres distintos; por ejemplo, dos módulos " +"espacios de nombres están implementados en este momento como diccionarios de " +"Python, pero eso no se nota para nada (excepto por el desempeño), y puede " +"cambiar en el futuro. Como ejemplos de espacios de nombres tenés: el " +"conjunto de nombres incluidos (conteniendo funciones como :func:`abs`, y los " +"nombres de excepciones integradas); los nombres globales en un módulo; y los " +"nombres locales en la invocación a una función. Lo que es importante saber " +"de los espacios de nombres es que no hay relación en absoluto entre los " +"nombres de espacios de nombres distintos; por ejemplo, dos módulos " "diferentes pueden tener definidos los dos una función ``maximizar`` sin " "confusión; los usuarios de los módulos deben usar el nombre del módulo como " "prefijo." @@ -190,11 +189,10 @@ msgid "" "By the way, I use the word *attribute* for any name following a dot --- for " "example, in the expression ``z.real``, ``real`` is an attribute of the " "object ``z``. Strictly speaking, references to names in modules are " -"attribute references: in the expression ``modname.funcname``, ``modname`` " -"is a module object and ``funcname`` is an attribute of it. In this case " -"there happens to be a straightforward mapping between the module's " -"attributes and the global names defined in the module: they share the same " -"namespace! [#]_" +"attribute references: in the expression ``modname.funcname``, ``modname`` is " +"a module object and ``funcname`` is an attribute of it. In this case there " +"happens to be a straightforward mapping between the module's attributes and " +"the global names defined in the module: they share the same namespace! [#]_" msgstr "" "Por cierto, yo uso la palabra *atributo* para cualquier cosa después de un " "punto; por ejemplo, en la expresión ``z.real``, ``real`` es un atributo del " @@ -202,8 +200,7 @@ msgstr "" "son referencias a atributos: en la expresión ``modulo.funcion``, ``modulo`` " "es un objeto módulo y ``funcion`` es un atributo de éste. En este caso hay " "una relación directa entre los atributos del módulo y los nombres globales " -"definidos en el módulo: ¡están compartiendo el mismo espacio de nombres! " -"[#]_" +"definidos en el módulo: ¡están compartiendo el mismo espacio de nombres! [#]_" #: ../Doc/tutorial/classes.rst:90 msgid "" @@ -211,15 +208,14 @@ msgid "" "attributes is possible. Module attributes are writable: you can write " "``modname.the_answer = 42``. Writable attributes may also be deleted with " "the :keyword:`del` statement. For example, ``del modname.the_answer`` will " -"remove the attribute :attr:`the_answer` from the object named by " -"``modname``." +"remove the attribute :attr:`the_answer` from the object named by ``modname``." msgstr "" -"Los atributos pueden ser de sólo lectura, o de escritura. En el último " -"caso es posible la asignación a atributos. Los atributos de módulo pueden " +"Los atributos pueden ser de sólo lectura, o de escritura. En el último caso " +"es posible la asignación a atributos. Los atributos de módulo pueden " "escribirse: ``modulo.la_respuesta = 42``. Los atributos de escritura se " -"pueden borrar también con la declaración :keyword:`del`. Por ejemplo, " -"``del modulo.la_respuesta`` va a eliminar el atributo :attr:`la_respuesta` " -"del objeto con nombre ``modulo``." +"pueden borrar también con la declaración :keyword:`del`. Por ejemplo, ``del " +"modulo.la_respuesta`` va a eliminar el atributo :attr:`la_respuesta` del " +"objeto con nombre ``modulo``." #: ../Doc/tutorial/classes.rst:96 msgid "" @@ -239,31 +235,30 @@ msgstr "" "nombres global de un módulo se crea cuando se lee la definición de un " "módulo; normalmente, los espacios de nombres de módulos también duran hasta " "que el intérprete finaliza. Las instrucciones ejecutadas en el nivel de " -"llamadas superior del intérprete, ya sea desde un script o " -"interactivamente, se consideran parte del módulo llamado :mod:`__main__`, " -"por lo tanto tienen su propio espacio de nombres global. (Los nombres " -"incluidos en realidad también viven en un módulo; este se llama :mod:" -"`builtins`.)" +"llamadas superior del intérprete, ya sea desde un script o interactivamente, " +"se consideran parte del módulo llamado :mod:`__main__`, por lo tanto tienen " +"su propio espacio de nombres global. (Los nombres incluidos en realidad " +"también viven en un módulo; este se llama :mod:`builtins`.)" #: ../Doc/tutorial/classes.rst:106 msgid "" "The local namespace for a function is created when the function is called, " "and deleted when the function returns or raises an exception that is not " -"handled within the function. (Actually, forgetting would be a better way " -"to describe what actually happens.) Of course, recursive invocations each " -"have their own local namespace." +"handled within the function. (Actually, forgetting would be a better way to " +"describe what actually happens.) Of course, recursive invocations each have " +"their own local namespace." msgstr "" "El espacio de nombres local a una función se crea cuando la función es " -"llamada, y se elimina cuando la función retorna o lanza una excepción que " -"no se maneje dentro de la función. (Podríamos decir que lo que pasa en " +"llamada, y se elimina cuando la función retorna o lanza una excepción que no " +"se maneje dentro de la función. (Podríamos decir que lo que pasa en " "realidad es que ese espacio de nombres se \"olvida\".) Por supuesto, las " "llamadas recursivas tienen cada una su propio espacio de nombres local." #: ../Doc/tutorial/classes.rst:112 msgid "" "A *scope* is a textual region of a Python program where a namespace is " -"directly accessible. \"Directly accessible\" here means that an " -"unqualified reference to a name attempts to find the name in the namespace." +"directly accessible. \"Directly accessible\" here means that an unqualified " +"reference to a name attempts to find the name in the namespace." msgstr "" "Un *ámbito* es una región textual de un programa en Python donde un espacio " "de nombres es accesible directamente. \"Accesible directamente\" significa " @@ -272,8 +267,8 @@ msgstr "" #: ../Doc/tutorial/classes.rst:116 msgid "" -"Although scopes are determined statically, they are used dynamically. At " -"any time during execution, there are at least three nested scopes whose " +"Although scopes are determined statically, they are used dynamically. At any " +"time during execution, there are at least three nested scopes whose " "namespaces are directly accessible:" msgstr "" "Aunque los alcances se determinan estáticamente, se usan dinámicamente. En " @@ -336,9 +331,9 @@ msgid "" "scope of a function defined in a module is that module's namespace, no " "matter from where or by what alias the function is called. On the other " "hand, the actual search for names is done dynamically, at run time --- " -"however, the language definition is evolving towards static name " -"resolution, at \"compile\" time, so don't rely on dynamic name resolution! " -"(In fact, local variables are already determined statically.)" +"however, the language definition is evolving towards static name resolution, " +"at \"compile\" time, so don't rely on dynamic name resolution! (In fact, " +"local variables are already determined statically.)" msgstr "" "Es importante notar que los alcances se determinan textualmente: el ámbito " "global de una función definida en un módulo es el espacio de nombres de ese " @@ -351,8 +346,8 @@ msgstr "" #: ../Doc/tutorial/classes.rst:146 msgid "" -"A special quirk of Python is that -- if no :keyword:`global` statement is " -"in effect -- assignments to names always go into the innermost scope. " +"A special quirk of Python is that -- if no :keyword:`global` statement is in " +"effect -- assignments to names always go into the innermost scope. " "Assignments do not copy data --- they just bind names to objects. The same " "is true for deletions: the statement ``del x`` removes the binding of ``x`` " "from the namespace referenced by the local scope. In fact, all operations " @@ -361,20 +356,20 @@ msgid "" "name in the local scope." msgstr "" "Una peculiaridad especial de Python es que, si no hay una declaración :" -"keyword:`global` o :keyword:`nonlocal` en efecto, las asignaciones a " -"nombres siempre van al ámbito interno. Las asignaciones no copian datos, " -"solamente asocian nombres a objetos. Lo mismo cuando se borra: la " -"declaración ``del x`` quita la asociación de ``x`` del espacio de nombres " -"referenciado por el ámbito local. De hecho, todas las operaciones que " -"introducen nuevos nombres usan el ámbito local: en particular, las " -"instrucciones :keyword:`import` y las definiciones de funciones asocian el " -"módulo o nombre de la función al espacio de nombres en el ámbito local." +"keyword:`global` o :keyword:`nonlocal` en efecto, las asignaciones a nombres " +"siempre van al ámbito interno. Las asignaciones no copian datos, solamente " +"asocian nombres a objetos. Lo mismo cuando se borra: la declaración ``del " +"x`` quita la asociación de ``x`` del espacio de nombres referenciado por el " +"ámbito local. De hecho, todas las operaciones que introducen nuevos nombres " +"usan el ámbito local: en particular, las instrucciones :keyword:`import` y " +"las definiciones de funciones asocian el módulo o nombre de la función al " +"espacio de nombres en el ámbito local." #: ../Doc/tutorial/classes.rst:154 msgid "" "The :keyword:`global` statement can be used to indicate that particular " -"variables live in the global scope and should be rebound there; the :" -"keyword:`nonlocal` statement indicates that particular variables live in an " +"variables live in the global scope and should be rebound there; the :keyword:" +"`nonlocal` statement indicates that particular variables live in an " "enclosing scope and should be rebound there." msgstr "" "La declaración :keyword:`global` puede usarse para indicar que ciertas " @@ -402,10 +397,10 @@ msgstr "El resultado del código ejemplo es:" #: ../Doc/tutorial/classes.rst:200 msgid "" -"Note how the *local* assignment (which is default) didn't change " -"*scope_test*\\'s binding of *spam*. The :keyword:`nonlocal` assignment " -"changed *scope_test*\\'s binding of *spam*, and the :keyword:`global` " -"assignment changed the module-level binding." +"Note how the *local* assignment (which is default) didn't change *scope_test*" +"\\'s binding of *spam*. The :keyword:`nonlocal` assignment changed " +"*scope_test*\\'s binding of *spam*, and the :keyword:`global` assignment " +"changed the module-level binding." msgstr "" "Notá como la asignación *local* (que es el comportamiento normal) no cambió " "la vinculación de *algo* de *prueba_ambitos*. La asignación :keyword:" @@ -455,10 +450,10 @@ msgstr "" #: ../Doc/tutorial/classes.rst:236 msgid "" "In practice, the statements inside a class definition will usually be " -"function definitions, but other statements are allowed, and sometimes " -"useful --- we'll come back to this later. The function definitions inside " -"a class normally have a peculiar form of argument list, dictated by the " -"calling conventions for methods --- again, this is explained later." +"function definitions, but other statements are allowed, and sometimes useful " +"--- we'll come back to this later. The function definitions inside a class " +"normally have a peculiar form of argument list, dictated by the calling " +"conventions for methods --- again, this is explained later." msgstr "" "En la práctica, las declaraciones dentro de una clase son definiciones de " "funciones, pero otras declaraciones son permitidas, y a veces resultan " @@ -471,32 +466,32 @@ msgstr "" msgid "" "When a class definition is entered, a new namespace is created, and used as " "the local scope --- thus, all assignments to local variables go into this " -"new namespace. In particular, function definitions bind the name of the " -"new function here." +"new namespace. In particular, function definitions bind the name of the new " +"function here." msgstr "" "Cuando se ingresa una definición de clase, se crea un nuevo espacio de " "nombres, el cual se usa como ámbito local; por lo tanto, todas las " "asignaciones a variables locales van a este nuevo espacio de nombres. En " -"particular, las definiciones de funciones asocian el nombre de las " -"funciones nuevas allí." +"particular, las definiciones de funciones asocian el nombre de las funciones " +"nuevas allí." #: ../Doc/tutorial/classes.rst:247 msgid "" "When a class definition is left normally (via the end), a *class object* is " "created. This is basically a wrapper around the contents of the namespace " -"created by the class definition; we'll learn more about class objects in " -"the next section. The original local scope (the one in effect just before " -"the class definition was entered) is reinstated, and the class object is " -"bound here to the class name given in the class definition header (:class:" +"created by the class definition; we'll learn more about class objects in the " +"next section. The original local scope (the one in effect just before the " +"class definition was entered) is reinstated, and the class object is bound " +"here to the class name given in the class definition header (:class:" "`ClassName` in the example)." msgstr "" "Cuando una definición de clase se finaliza normalmente se crea un *objeto " "clase*. Básicamente, este objeto envuelve los contenidos del espacio de " -"nombres creado por la definición de la clase; aprenderemos más acerca de " -"los objetos clase en la sección siguiente. El ámbito local original (el " -"que tenía efecto justo antes de que ingrese la definición de la clase) es " -"restablecido, y el objeto clase se asocia allí al nombre que se le puso a " -"la clase en el encabezado de su definición (:class:`Clase` en el ejemplo)." +"nombres creado por la definición de la clase; aprenderemos más acerca de los " +"objetos clase en la sección siguiente. El ámbito local original (el que " +"tenía efecto justo antes de que ingrese la definición de la clase) es " +"restablecido, y el objeto clase se asocia allí al nombre que se le puso a la " +"clase en el encabezado de su definición (:class:`Clase` en el ejemplo)." #: ../Doc/tutorial/classes.rst:259 msgid "Class Objects" @@ -513,15 +508,15 @@ msgstr "" #: ../Doc/tutorial/classes.rst:264 msgid "" "*Attribute references* use the standard syntax used for all attribute " -"references in Python: ``obj.name``. Valid attribute names are all the " -"names that were in the class's namespace when the class object was " -"created. So, if the class definition looked like this::" +"references in Python: ``obj.name``. Valid attribute names are all the names " +"that were in the class's namespace when the class object was created. So, " +"if the class definition looked like this::" msgstr "" -"Para *hacer referencia a atributos* se usa la sintaxis estándar de todas " -"las referencias a atributos en Python: ``objeto.nombre``. Los nombres de " +"Para *hacer referencia a atributos* se usa la sintaxis estándar de todas las " +"referencias a atributos en Python: ``objeto.nombre``. Los nombres de " "atributo válidos son todos los nombres que estaban en el espacio de nombres " -"de la clase cuando ésta se creó. Por lo tanto, si la definición de la " -"clase es así::" +"de la clase cuando ésta se creó. Por lo tanto, si la definición de la clase " +"es así::" #: ../Doc/tutorial/classes.rst:276 msgid "" @@ -541,8 +536,8 @@ msgstr "" #: ../Doc/tutorial/classes.rst:282 msgid "" "Class *instantiation* uses function notation. Just pretend that the class " -"object is a parameterless function that returns a new instance of the " -"class. For example (assuming the above class)::" +"object is a parameterless function that returns a new instance of the class. " +"For example (assuming the above class)::" msgstr "" "La *instanciación* de clases usa la notación de funciones. Hacé de cuenta " "que el objeto de clase es una función sin parámetros que devuelve una nueva " @@ -553,20 +548,20 @@ msgid "" "creates a new *instance* of the class and assigns this object to the local " "variable ``x``." msgstr "" -"...crea una nueva *instancia* de la clase y asigna este objeto a la " -"variable local ``x``." +"...crea una nueva *instancia* de la clase y asigna este objeto a la variable " +"local ``x``." #: ../Doc/tutorial/classes.rst:291 msgid "" "The instantiation operation (\"calling\" a class object) creates an empty " "object. Many classes like to create objects with instances customized to a " -"specific initial state. Therefore a class may define a special method " -"named :meth:`__init__`, like this::" +"specific initial state. Therefore a class may define a special method named :" +"meth:`__init__`, like this::" msgstr "" "La operación de instanciación (\"llamar\" a un objeto clase) crea un objeto " "vacío. Muchas clases necesitan crear objetos con instancias en un estado " -"inicial particular. Por lo tanto una clase puede definir un método " -"especial llamado :meth:`__init__`, de esta forma::" +"inicial particular. Por lo tanto una clase puede definir un método especial " +"llamado :meth:`__init__`, de esta forma::" #: ../Doc/tutorial/classes.rst:299 msgid "" @@ -597,13 +592,13 @@ msgstr "Objetos instancia" #: ../Doc/tutorial/classes.rst:324 msgid "" -"Now what can we do with instance objects? The only operations understood " -"by instance objects are attribute references. There are two kinds of valid " +"Now what can we do with instance objects? The only operations understood by " +"instance objects are attribute references. There are two kinds of valid " "attribute names, data attributes and methods." msgstr "" -"Ahora, ¿Qué podemos hacer con los objetos instancia? La única operación " -"que es entendida por los objetos instancia es la referencia de atributos. " -"Hay dos tipos de nombres de atributos válidos, atributos de datos y métodos." +"Ahora, ¿Qué podemos hacer con los objetos instancia? La única operación que " +"es entendida por los objetos instancia es la referencia de atributos. Hay " +"dos tipos de nombres de atributos válidos, atributos de datos y métodos." #: ../Doc/tutorial/classes.rst:328 msgid "" @@ -625,17 +620,17 @@ msgstr "" msgid "" "The other kind of instance attribute reference is a *method*. A method is a " "function that \"belongs to\" an object. (In Python, the term method is not " -"unique to class instances: other object types can have methods as well. " -"For example, list objects have methods called append, insert, remove, sort, " -"and so on. However, in the following discussion, we'll use the term method " +"unique to class instances: other object types can have methods as well. For " +"example, list objects have methods called append, insert, remove, sort, and " +"so on. However, in the following discussion, we'll use the term method " "exclusively to mean methods of class instance objects, unless explicitly " "stated otherwise.)" msgstr "" "El otro tipo de atributo de instancia es el *método*. Un método es una " -"función que \"pertenece a\" un objeto. En Python, el término método no " -"está limitado a instancias de clase: otros tipos de objetos pueden tener " -"métodos también. Por ejemplo, los objetos lista tienen métodos llamados " -"append, insert, remove, sort, y así sucesivamente. Pero, en la siguiente " +"función que \"pertenece a\" un objeto. En Python, el término método no está " +"limitado a instancias de clase: otros tipos de objetos pueden tener métodos " +"también. Por ejemplo, los objetos lista tienen métodos llamados append, " +"insert, remove, sort, y así sucesivamente. Pero, en la siguiente " "explicación, usaremos el término método para referirnos exclusivamente a " "métodos de objetos instancia de clase, a menos que se especifique " "explícitamente lo contrario." @@ -653,9 +648,9 @@ msgstr "" "Por definición, todos los atributos de clase que son objetos funciones " "definen métodos correspondientes de sus instancias. Entonces, en nuestro " "ejemplo, ``x.f`` es una referencia a un método válido, dado que ``MiClase." -"f`` es una función, pero ``x.i`` no lo es, dado que ``MiClase.i`` no lo " -"es. Pero ``x.f`` no es la misma cosa que ``MiClase.f``; es un *objeto " -"método*, no un objeto función." +"f`` es una función, pero ``x.i`` no lo es, dado que ``MiClase.i`` no lo es. " +"Pero ``x.f`` no es la misma cosa que ``MiClase.f``; es un *objeto método*, " +"no un objeto función." #: ../Doc/tutorial/classes.rst:360 msgid "Method Objects" @@ -682,49 +677,49 @@ msgstr "...continuará imprimiendo ``hola mundo`` hasta el fin de los días." #: ../Doc/tutorial/classes.rst:376 msgid "" -"What exactly happens when a method is called? You may have noticed that " -"``x.f()`` was called without an argument above, even though the function " +"What exactly happens when a method is called? You may have noticed that ``x." +"f()`` was called without an argument above, even though the function " "definition for :meth:`f` specified an argument. What happened to the " -"argument? Surely Python raises an exception when a function that requires " -"an argument is called without any --- even if the argument isn't actually " +"argument? Surely Python raises an exception when a function that requires an " +"argument is called without any --- even if the argument isn't actually " "used..." msgstr "" -"¿Qué sucede exactamente cuando un método es llamado? Debés haber notado " -"que ``x.f()`` fue llamado más arriba sin ningún argumento, a pesar de que " -"la definición de función de :meth:`f` especificaba un argumento. ¿Qué pasó " -"con ese argumento? Seguramente Python levanta una excepción cuando una " -"función que requiere un argumento es llamada sin ninguno, aún si el " -"argumento no es utilizado..." +"¿Qué sucede exactamente cuando un método es llamado? Debés haber notado que " +"``x.f()`` fue llamado más arriba sin ningún argumento, a pesar de que la " +"definición de función de :meth:`f` especificaba un argumento. ¿Qué pasó con " +"ese argumento? Seguramente Python levanta una excepción cuando una función " +"que requiere un argumento es llamada sin ninguno, aún si el argumento no es " +"utilizado..." #: ../Doc/tutorial/classes.rst:382 msgid "" "Actually, you may have guessed the answer: the special thing about methods " "is that the instance object is passed as the first argument of the " "function. In our example, the call ``x.f()`` is exactly equivalent to " -"``MyClass.f(x)``. In general, calling a method with a list of *n* " -"arguments is equivalent to calling the corresponding function with an " -"argument list that is created by inserting the method's instance object " -"before the first argument." +"``MyClass.f(x)``. In general, calling a method with a list of *n* arguments " +"is equivalent to calling the corresponding function with an argument list " +"that is created by inserting the method's instance object before the first " +"argument." msgstr "" "De hecho, tal vez hayas adivinado la respuesta: lo que tienen de especial " "los métodos es que el objeto es pasado como el primer argumento de la " -"función. En nuestro ejemplo, la llamada ``x.f()`` es exactamente " -"equivalente a ``MiClase.f(x)``. En general, llamar a un método con una " -"lista de *n* argumentos es equivalente a llamar a la función " -"correspondiente con una lista de argumentos que es creada insertando el " -"objeto del método antes del primer argumento." +"función. En nuestro ejemplo, la llamada ``x.f()`` es exactamente equivalente " +"a ``MiClase.f(x)``. En general, llamar a un método con una lista de *n* " +"argumentos es equivalente a llamar a la función correspondiente con una " +"lista de argumentos que es creada insertando el objeto del método antes del " +"primer argumento." #: ../Doc/tutorial/classes.rst:389 msgid "" -"If you still don't understand how methods work, a look at the " -"implementation can perhaps clarify matters. When a non-data attribute of " -"an instance is referenced, the instance's class is searched. If the name " -"denotes a valid class attribute that is a function object, a method object " -"is created by packing (pointers to) the instance object and the function " -"object just found together in an abstract object: this is the method " -"object. When the method object is called with an argument list, a new " -"argument list is constructed from the instance object and the argument " -"list, and the function object is called with this new argument list." +"If you still don't understand how methods work, a look at the implementation " +"can perhaps clarify matters. When a non-data attribute of an instance is " +"referenced, the instance's class is searched. If the name denotes a valid " +"class attribute that is a function object, a method object is created by " +"packing (pointers to) the instance object and the function object just found " +"together in an abstract object: this is the method object. When the method " +"object is called with an argument list, a new argument list is constructed " +"from the instance object and the argument list, and the function object is " +"called with this new argument list." msgstr "" #: ../Doc/tutorial/classes.rst:403 @@ -749,9 +744,9 @@ msgid "" "not be used as a class variable because just a single list would be shared " "by all *Dog* instances::" msgstr "" -"Como se vió en :ref:`tut-object`, los datos compartidos pueden tener " -"efectos inesperados que involucren objetos :term:`mutables` como ser listas " -"y diccionarios. Por ejemplo, la lista *trucos* en el siguiente código no " +"Como se vió en :ref:`tut-object`, los datos compartidos pueden tener efectos " +"inesperados que involucren objetos :term:`mutables` como ser listas y " +"diccionarios. Por ejemplo, la lista *trucos* en el siguiente código no " "debería ser usada como variable de clase porque una sola lista sería " "compartida por todos las instancias de *Perro*::" @@ -778,10 +773,10 @@ msgstr "" "nombre; para evitar conflictos de nombre accidentales, que pueden causar " "errores difíciles de encontrar en programas grandes, es prudente usar algún " "tipo de convención que minimice las posibilidades de dichos conflictos. " -"Algunas convenciones pueden ser poner los nombres de métodos con " -"mayúsculas, prefijar los nombres de atributos de datos con una pequeña " -"cadena única (a lo mejor sólo un guión bajo), o usar verbos para los " -"métodos y sustantivos para los atributos." +"Algunas convenciones pueden ser poner los nombres de métodos con mayúsculas, " +"prefijar los nombres de atributos de datos con una pequeña cadena única (a " +"lo mejor sólo un guión bajo), o usar verbos para los métodos y sustantivos " +"para los atributos." #: ../Doc/tutorial/classes.rst:485 msgid "" @@ -789,89 +784,86 @@ msgid "" "(\"clients\") of an object. In other words, classes are not usable to " "implement pure abstract data types. In fact, nothing in Python makes it " "possible to enforce data hiding --- it is all based upon convention. (On " -"the other hand, the Python implementation, written in C, can completely " -"hide implementation details and control access to an object if necessary; " -"this can be used by extensions to Python written in C.)" +"the other hand, the Python implementation, written in C, can completely hide " +"implementation details and control access to an object if necessary; this " +"can be used by extensions to Python written in C.)" msgstr "" "A los atributos de datos los pueden hacer referencia tanto los métodos como " -"los usuarios (\"clientes\") ordinarios de un objeto. En otras palabras, " -"las clases no se usan para implementar tipos de datos abstractos puros. De " -"hecho, en Python no hay nada que haga cumplir el ocultar datos; todo se " -"basa en convención. (Por otro lado, la implementación de Python, escrita " -"en C, puede ocultar por completo detalles de implementación y el control de " -"acceso a un objeto si es necesario; esto se puede usar en extensiones a " -"Python escritas en C.)" +"los usuarios (\"clientes\") ordinarios de un objeto. En otras palabras, las " +"clases no se usan para implementar tipos de datos abstractos puros. De " +"hecho, en Python no hay nada que haga cumplir el ocultar datos; todo se basa " +"en convención. (Por otro lado, la implementación de Python, escrita en C, " +"puede ocultar por completo detalles de implementación y el control de acceso " +"a un objeto si es necesario; esto se puede usar en extensiones a Python " +"escritas en C.)" #: ../Doc/tutorial/classes.rst:493 msgid "" "Clients should use data attributes with care --- clients may mess up " "invariants maintained by the methods by stamping on their data attributes. " -"Note that clients may add data attributes of their own to an instance " -"object without affecting the validity of the methods, as long as name " -"conflicts are avoided --- again, a naming convention can save a lot of " -"headaches here." +"Note that clients may add data attributes of their own to an instance object " +"without affecting the validity of the methods, as long as name conflicts are " +"avoided --- again, a naming convention can save a lot of headaches here." msgstr "" "Los clientes deben usar los atributos de datos con cuidado; éstos pueden " "romper invariantes que mantienen los métodos si pisan los atributos de " -"datos. Observá que los clientes pueden añadir sus propios atributos de " -"datos a una instancia sin afectar la validez de sus métodos, siempre y " -"cuando se eviten conflictos de nombres; de nuevo, una convención de nombres " -"puede ahorrar un montón de dolores de cabeza." +"datos. Observá que los clientes pueden añadir sus propios atributos de datos " +"a una instancia sin afectar la validez de sus métodos, siempre y cuando se " +"eviten conflictos de nombres; de nuevo, una convención de nombres puede " +"ahorrar un montón de dolores de cabeza." #: ../Doc/tutorial/classes.rst:499 msgid "" "There is no shorthand for referencing data attributes (or other methods!) " -"from within methods. I find that this actually increases the readability " -"of methods: there is no chance of confusing local variables and instance " +"from within methods. I find that this actually increases the readability of " +"methods: there is no chance of confusing local variables and instance " "variables when glancing through a method." msgstr "" "No hay un atajo para hacer referencia a atributos de datos (¡u otros " -"métodos!) desde dentro de un método. A mi parecer, esto en realidad " -"aumenta la legibilidad de los métodos: no existe posibilidad alguna de " -"confundir variables locales con variables de instancia cuando repasamos un " -"método." +"métodos!) desde dentro de un método. A mi parecer, esto en realidad aumenta " +"la legibilidad de los métodos: no existe posibilidad alguna de confundir " +"variables locales con variables de instancia cuando repasamos un método." #: ../Doc/tutorial/classes.rst:504 msgid "" "Often, the first argument of a method is called ``self``. This is nothing " "more than a convention: the name ``self`` has absolutely no special meaning " "to Python. Note, however, that by not following the convention your code " -"may be less readable to other Python programmers, and it is also " -"conceivable that a *class browser* program might be written that relies " -"upon such a convention." +"may be less readable to other Python programmers, and it is also conceivable " +"that a *class browser* program might be written that relies upon such a " +"convention." msgstr "" "A menudo, el primer argumento de un método se llama ``self`` (uno mismo). " -"Esto no es nada más que una convención: el nombre ``self`` no significa " -"nada en especial para Python. Observá que, sin embargo, si no seguís la " +"Esto no es nada más que una convención: el nombre ``self`` no significa nada " +"en especial para Python. Observá que, sin embargo, si no seguís la " "convención tu código puede resultar menos legible a otros programadores de " "Python, y puede llegar a pasar que un programa *navegador de clases* pueda " "escribirse de una manera que dependa de dicha convención." #: ../Doc/tutorial/classes.rst:510 msgid "" -"Any function object that is a class attribute defines a method for " -"instances of that class. It is not necessary that the function definition " -"is textually enclosed in the class definition: assigning a function object " -"to a local variable in the class is also ok. For example::" +"Any function object that is a class attribute defines a method for instances " +"of that class. It is not necessary that the function definition is " +"textually enclosed in the class definition: assigning a function object to a " +"local variable in the class is also ok. For example::" msgstr "" "Cualquier objeto función que es un atributo de clase define un método para " -"instancias de esa clase. No es necesario que el la definición de la " -"función esté textualmente dentro de la definición de la clase: asignando un " -"objeto función a una variable local en la clase también está bien. Por " -"ejemplo::" +"instancias de esa clase. No es necesario que el la definición de la función " +"esté textualmente dentro de la definición de la clase: asignando un objeto " +"función a una variable local en la clase también está bien. Por ejemplo::" #: ../Doc/tutorial/classes.rst:527 msgid "" -"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that " -"refer to function objects, and consequently they are all methods of " -"instances of :class:`C` --- ``h`` being exactly equivalent to ``g``. Note " -"that this practice usually only serves to confuse the reader of a program." +"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer " +"to function objects, and consequently they are all methods of instances of :" +"class:`C` --- ``h`` being exactly equivalent to ``g``. Note that this " +"practice usually only serves to confuse the reader of a program." msgstr "" "Ahora ``f``, ``g`` y ``h`` son todos atributos de la clase :class:`C` que " "hacen referencia a objetos función, y consecuentemente son todos métodos de " "las instancias de :class:`C`; ``h`` siendo exactamente equivalente a ``g``. " -"Fijate que esta práctica normalmente sólo sirve para confundir al que lea " -"un programa." +"Fijate que esta práctica normalmente sólo sirve para confundir al que lea un " +"programa." #: ../Doc/tutorial/classes.rst:532 msgid "" @@ -890,8 +882,8 @@ msgid "" "legitimate uses of the global scope: for one thing, functions and modules " "imported into the global scope can be used by methods, as well as functions " "and classes defined in it. Usually, the class containing the method is " -"itself defined in this global scope, and in the next section we'll find " -"some good reasons why a method would want to reference its own class." +"itself defined in this global scope, and in the next section we'll find some " +"good reasons why a method would want to reference its own class." msgstr "" "Los métodos pueden hacer referencia a nombres globales de la misma manera " "que lo hacen las funciones comunes. El ámbito global asociado a un método " @@ -901,8 +893,8 @@ msgstr "" "menos, las funciones y módulos importados en el ámbito global pueden usarse " "por los métodos, al igual que las funciones y clases definidas en él. " "Habitualmente, la clase que contiene el método está definida en este ámbito " -"global, y en la siguiente sección veremos algunas buenas razones por las " -"que un método querría hacer referencia a su propia clase." +"global, y en la siguiente sección veremos algunas buenas razones por las que " +"un método querría hacer referencia a su propia clase." #: ../Doc/tutorial/classes.rst:556 msgid "" @@ -933,26 +925,26 @@ msgid "" "expressions are also allowed. This can be useful, for example, when the " "base class is defined in another module::" msgstr "" -"El nombre :class:`ClaseBase` debe estar definido en un ámbito que contenga " -"a la definición de la clase derivada. En el lugar del nombre de la clase " -"base se permiten otras expresiones arbitrarias. Esto puede ser útil, por " +"El nombre :class:`ClaseBase` debe estar definido en un ámbito que contenga a " +"la definición de la clase derivada. En el lugar del nombre de la clase base " +"se permiten otras expresiones arbitrarias. Esto puede ser útil, por " "ejemplo, cuando la clase base está definida en otro módulo::" #: ../Doc/tutorial/classes.rst:583 msgid "" "Execution of a derived class definition proceeds the same as for a base " "class. When the class object is constructed, the base class is remembered. " -"This is used for resolving attribute references: if a requested attribute " -"is not found in the class, the search proceeds to look in the base class. " -"This rule is applied recursively if the base class itself is derived from " -"some other class." +"This is used for resolving attribute references: if a requested attribute is " +"not found in the class, the search proceeds to look in the base class. This " +"rule is applied recursively if the base class itself is derived from some " +"other class." msgstr "" "La ejecución de una definición de clase derivada procede de la misma forma " -"que una clase base. Cuando el objeto clase se construye, se tiene en " -"cuenta a la clase base. Esto se usa para resolver referencias a atributos: " -"si un atributo solicitado no se encuentra en la clase, la búsqueda continúa " -"por la clase base. Esta regla se aplica recursivamente si la clase base " -"misma deriva de alguna otra clase." +"que una clase base. Cuando el objeto clase se construye, se tiene en cuenta " +"a la clase base. Esto se usa para resolver referencias a atributos: si un " +"atributo solicitado no se encuentra en la clase, la búsqueda continúa por la " +"clase base. Esta regla se aplica recursivamente si la clase base misma " +"deriva de alguna otra clase." #: ../Doc/tutorial/classes.rst:589 msgid "" @@ -963,43 +955,41 @@ msgid "" "method reference is valid if this yields a function object." msgstr "" "No hay nada en especial en la instanciación de clases derivadas: " -"``ClaseDerivada()`` crea una nueva instancia de la clase. Las referencias " -"a métodos se resuelven de la siguiente manera: se busca el atributo de " -"clase correspondiente, descendiendo por la cadena de clases base si es " -"necesario, y la referencia al método es válida si se entrega un objeto " -"función." +"``ClaseDerivada()`` crea una nueva instancia de la clase. Las referencias a " +"métodos se resuelven de la siguiente manera: se busca el atributo de clase " +"correspondiente, descendiendo por la cadena de clases base si es necesario, " +"y la referencia al método es válida si se entrega un objeto función." #: ../Doc/tutorial/classes.rst:595 msgid "" -"Derived classes may override methods of their base classes. Because " -"methods have no special privileges when calling other methods of the same " -"object, a method of a base class that calls another method defined in the " -"same base class may end up calling a method of a derived class that " -"overrides it. (For C++ programmers: all methods in Python are effectively " -"``virtual``.)" +"Derived classes may override methods of their base classes. Because methods " +"have no special privileges when calling other methods of the same object, a " +"method of a base class that calls another method defined in the same base " +"class may end up calling a method of a derived class that overrides it. " +"(For C++ programmers: all methods in Python are effectively ``virtual``.)" msgstr "" "Las clases derivadas pueden redefinir métodos de su clase base. Como los " "métodos no tienen privilegios especiales cuando llaman a otros métodos del " -"mismo objeto, un método de la clase base que llame a otro método definido " -"en la misma clase base puede terminar llamando a un método de la clase " -"derivada que lo haya redefinido. (Para los programadores de C++: en Python " -"todos los métodos son en efecto ``virtuales``.)" +"mismo objeto, un método de la clase base que llame a otro método definido en " +"la misma clase base puede terminar llamando a un método de la clase derivada " +"que lo haya redefinido. (Para los programadores de C++: en Python todos los " +"métodos son en efecto ``virtuales``.)" #: ../Doc/tutorial/classes.rst:601 msgid "" "An overriding method in a derived class may in fact want to extend rather " "than simply replace the base class method of the same name. There is a " -"simple way to call the base class method directly: just call " -"``BaseClassName.methodname(self, arguments)``. This is occasionally useful " -"to clients as well. (Note that this only works if the base class is " -"accessible as ``BaseClassName`` in the global scope.)" +"simple way to call the base class method directly: just call ``BaseClassName." +"methodname(self, arguments)``. This is occasionally useful to clients as " +"well. (Note that this only works if the base class is accessible as " +"``BaseClassName`` in the global scope.)" msgstr "" -"Un método redefinido en una clase derivada puede de hecho querer extender " -"en vez de simplemente reemplazar al método de la clase base con el mismo " +"Un método redefinido en una clase derivada puede de hecho querer extender en " +"vez de simplemente reemplazar al método de la clase base con el mismo " "nombre. Hay una manera simple de llamar al método de la clase base " "directamente: simplemente llamás a ``ClaseBase.metodo(self, argumentos)``. " -"En ocasiones esto es útil para los clientes también. (Observá que esto " -"sólo funciona si la clase base es accesible como ``ClaseBase`` en el ámbito " +"En ocasiones esto es útil para los clientes también. (Observá que esto sólo " +"funciona si la clase base es accesible como ``ClaseBase`` en el ámbito " "global.)" #: ../Doc/tutorial/classes.rst:608 @@ -1008,9 +998,9 @@ msgstr "Python tiene dos funciones integradas que funcionan con herencia:" #: ../Doc/tutorial/classes.rst:610 msgid "" -"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, " -"int)`` will be ``True`` only if ``obj.__class__`` is :class:`int` or some " -"class derived from :class:`int`." +"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` " +"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class " +"derived from :class:`int`." msgstr "" "Usar :func:`isinstance` para verificar el tipo de una instancia: " "``isinstance(obj, int)`` será ``True`` sólo si ``obj.__class__`` es :class:" @@ -1018,10 +1008,10 @@ msgstr "" #: ../Doc/tutorial/classes.rst:614 msgid "" -"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, " -"int)`` is ``True`` since :class:`bool` is a subclass of :class:`int`. " -"However, ``issubclass(float, int)`` is ``False`` since :class:`float` is " -"not a subclass of :class:`int`." +"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` " +"is ``True`` since :class:`bool` is a subclass of :class:`int`. However, " +"``issubclass(float, int)`` is ``False`` since :class:`float` is not a " +"subclass of :class:`int`." msgstr "" "Usar :func:`issubclass` para verificar la herencia de clases: " "``issubclass(bool, int)`` es ``True`` ya que :class:`bool` es una subclase " @@ -1046,17 +1036,17 @@ msgid "" "attributes inherited from a parent class as depth-first, left-to-right, not " "searching twice in the same class where there is an overlap in the " "hierarchy. Thus, if an attribute is not found in :class:`DerivedClassName`, " -"it is searched for in :class:`Base1`, then (recursively) in the base " -"classes of :class:`Base1`, and if it was not found there, it was searched " -"for in :class:`Base2`, and so on." +"it is searched for in :class:`Base1`, then (recursively) in the base classes " +"of :class:`Base1`, and if it was not found there, it was searched for in :" +"class:`Base2`, and so on." msgstr "" -"Para la mayoría de los propósitos, en los casos más simples, podés pensar " -"en la búsqueda de los atributos heredados de clases padres como primero en " +"Para la mayoría de los propósitos, en los casos más simples, podés pensar en " +"la búsqueda de los atributos heredados de clases padres como primero en " "profundidad, de izquierda a derecha, sin repetir la misma clase cuando está " -"dos veces en la jerarquía. Por lo tanto, si un atributo no se encuentra " -"en :class:`ClaseDerivada`, se busca en :class:`Base1`, luego " -"(recursivamente) en las clases base de :class:`Base1`, y sólo si no se " -"encuentra allí se lo busca en :class:`Base2`, y así sucesivamente." +"dos veces en la jerarquía. Por lo tanto, si un atributo no se encuentra en :" +"class:`ClaseDerivada`, se busca en :class:`Base1`, luego (recursivamente) en " +"las clases base de :class:`Base1`, y sólo si no se encuentra allí se lo " +"busca en :class:`Base2`, y así sucesivamente." #: ../Doc/tutorial/classes.rst:643 msgid "" @@ -1067,10 +1057,10 @@ msgid "" "languages." msgstr "" "En realidad es un poco más complejo que eso; el orden de resolución de " -"métodos cambia dinámicamente para soportar las llamadas cooperativas a :" -"func:`super`. Este enfoque es conocido en otros lenguajes con herencia " -"múltiple como \"llámese al siguiente método\" y es más poderoso que la " -"llamada al superior que se encuentra en lenguajes con sólo herencia simple." +"métodos cambia dinámicamente para soportar las llamadas cooperativas a :func:" +"`super`. Este enfoque es conocido en otros lenguajes con herencia múltiple " +"como \"llámese al siguiente método\" y es más poderoso que la llamada al " +"superior que se encuentra en lenguajes con sólo herencia simple." #: ../Doc/tutorial/classes.rst:649 msgid "" @@ -1089,19 +1079,18 @@ msgid "" "releases/2.3/mro/." msgstr "" "El ordenamiento dinámico es necesario porque todos los casos de herencia " -"múltiple exhiben una o más relaciones en diamante (cuando se puede llegar " -"al menos a una de las clases base por distintos caminos desde la clase de " -"más abajo). Por ejemplo, todas las clases heredan de :class:`object`, por " -"lo tanto cualquier caso de herencia múltiple provee más de un camino para " -"llegar a :class:`object`. Para que las clases base no sean accedidas más " -"de una vez, el algoritmo dinámico hace lineal el orden de búsqueda de " -"manera que se preserve el orden de izquierda a derecha especificado en cada " -"clase, que se llame a cada clase base sólo una vez, y que sea monótona (lo " -"cual significa que una clase puede tener clases derivadas sin afectar el " -"orden de precedencia de sus clases bases). En conjunto, estas propiedades " -"hacen posible diseñar clases confiables y extensibles con herencia " -"múltiple. Para más detalles mirá https://www.python.org/download/" -"releases/2.3/mro/." +"múltiple exhiben una o más relaciones en diamante (cuando se puede llegar al " +"menos a una de las clases base por distintos caminos desde la clase de más " +"abajo). Por ejemplo, todas las clases heredan de :class:`object`, por lo " +"tanto cualquier caso de herencia múltiple provee más de un camino para " +"llegar a :class:`object`. Para que las clases base no sean accedidas más de " +"una vez, el algoritmo dinámico hace lineal el orden de búsqueda de manera " +"que se preserve el orden de izquierda a derecha especificado en cada clase, " +"que se llame a cada clase base sólo una vez, y que sea monótona (lo cual " +"significa que una clase puede tener clases derivadas sin afectar el orden de " +"precedencia de sus clases bases). En conjunto, estas propiedades hacen " +"posible diseñar clases confiables y extensibles con herencia múltiple. Para " +"más detalles mirá https://www.python.org/download/releases/2.3/mro/." #: ../Doc/tutorial/classes.rst:666 msgid "Private Variables" @@ -1109,8 +1098,8 @@ msgstr "Variables privadas" #: ../Doc/tutorial/classes.rst:668 msgid "" -"\"Private\" instance variables that cannot be accessed except from inside " -"an object don't exist in Python. However, there is a convention that is " +"\"Private\" instance variables that cannot be accessed except from inside an " +"object don't exist in Python. However, there is a convention that is " "followed by most Python code: a name prefixed with an underscore (e.g. " "``_spam``) should be treated as a non-public part of the API (whether it is " "a function, a method or a data member). It should be considered an " @@ -1118,11 +1107,11 @@ msgid "" msgstr "" "Las variables \"privadas\" de instancia, que no pueden accederse excepto " "desde dentro de un objeto, no existen en Python. Sin embargo, hay una " -"convención que se sigue en la mayoría del código Python: un nombre " -"prefijado con un guión bajo (por ejemplo, ``_spam``) debería tratarse como " -"una parte no pública de la API (más allá de que sea una función, un método, " -"o un dato). Debería considerarse un detalle de implementación y que está " -"sujeto a cambios sin aviso." +"convención que se sigue en la mayoría del código Python: un nombre prefijado " +"con un guión bajo (por ejemplo, ``_spam``) debería tratarse como una parte " +"no pública de la API (más allá de que sea una función, un método, o un " +"dato). Debería considerarse un detalle de implementación y que está sujeto " +"a cambios sin aviso." #: ../Doc/tutorial/classes.rst:678 msgid "" @@ -1132,8 +1121,8 @@ msgid "" "of the form ``__spam`` (at least two leading underscores, at most one " "trailing underscore) is textually replaced with ``_classname__spam``, where " "``classname`` is the current class name with leading underscore(s) " -"stripped. This mangling is done without regard to the syntactic position " -"of the identifier, as long as it occurs within the definition of a class." +"stripped. This mangling is done without regard to the syntactic position of " +"the identifier, as long as it occurs within the definition of a class." msgstr "" "Ya que hay un caso de uso válido para los identificadores privados de clase " "(a saber: colisión de nombres con nombres definidos en las subclases), hay " @@ -1156,8 +1145,8 @@ msgstr "" #: ../Doc/tutorial/classes.rst:709 msgid "" -"The above example would work even if ``MappingSubclass`` were to introduce " -"a ``__update`` identifier since it is replaced with ``_Mapping__update`` in " +"The above example would work even if ``MappingSubclass`` were to introduce a " +"``__update`` identifier since it is replaced with ``_Mapping__update`` in " "the ``Mapping`` class and ``_MappingSubclass__update`` in the " "``MappingSubclass`` class respectively." msgstr "" @@ -1175,8 +1164,8 @@ msgid "" msgstr "" "Hay que aclarar que las reglas de modificación de nombres están diseñadas " "principalmente para evitar accidentes; es posible acceder o modificar una " -"variable que es considerada como privada. Esto hasta puede resultar útil " -"en circunstancias especiales, tales como en el depurador." +"variable que es considerada como privada. Esto hasta puede resultar útil en " +"circunstancias especiales, tales como en el depurador." #: ../Doc/tutorial/classes.rst:718 msgid "" @@ -1212,23 +1201,23 @@ msgstr "" msgid "" "A piece of Python code that expects a particular abstract data type can " "often be passed a class that emulates the methods of that data type " -"instead. For instance, if you have a function that formats some data from " -"a file object, you can define a class with methods :meth:`read` and :meth:`!" +"instead. For instance, if you have a function that formats some data from a " +"file object, you can define a class with methods :meth:`read` and :meth:`!" "readline` that get the data from a string buffer instead, and pass it as an " "argument." msgstr "" "Algún código Python que espera un tipo abstracto de datos en particular " "puede frecuentemente recibir en cambio una clase que emula los métodos de " -"aquel tipo de datos. Por ejemplo, si tenés una función que formatea " -"algunos datos a partir de un objeto archivo, podés definir una clase con " -"métodos :meth:`read` y :meth:`!readline` que obtengan los datos de alguna " -"cadena en memoria intermedia, y pasarlo como argumento." +"aquel tipo de datos. Por ejemplo, si tenés una función que formatea algunos " +"datos a partir de un objeto archivo, podés definir una clase con métodos :" +"meth:`read` y :meth:`!readline` que obtengan los datos de alguna cadena en " +"memoria intermedia, y pasarlo como argumento." #: ../Doc/tutorial/classes.rst:756 msgid "" -"Instance method objects have attributes, too: ``m.__self__`` is the " -"instance object with the method :meth:`m`, and ``m.__func__`` is the " -"function object corresponding to the method." +"Instance method objects have attributes, too: ``m.__self__`` is the instance " +"object with the method :meth:`m`, and ``m.__func__`` is the function object " +"corresponding to the method." msgstr "" "Los objetos método de instancia tienen atributos también: ``m.__self__`` es " "el objeto instancia con el método :meth:`m`, y ``m.__func__`` es el objeto " @@ -1259,15 +1248,14 @@ msgid "" "func:`next` built-in function; this example shows how it all works::" msgstr "" "Este estilo de acceso es limpio, conciso y conveniente. El uso de " -"iteradores está impregnado y unifica a Python. En bambalinas, la " -"sentencia :keyword:`for` llama a :func:`iter` en el objeto contenedor. La " -"función devuelve un objeto iterador que define el método :meth:`__next__` " -"que accede elementos en el contenedor de a uno por vez. Cuando no hay más " -"elementos, :meth:`~iterator.__next__` levanta una excepción :exc:" -"`StopIteration` que le avisa al bucle del :keyword:`for` que hay que " -"terminar. Podés llamar al método :meth:`~iterator.__next__` usando la " -"función integrada :func:`~iterator.__next__`; este ejemplo muestra como " -"funciona todo esto::" +"iteradores está impregnado y unifica a Python. En bambalinas, la sentencia :" +"keyword:`for` llama a :func:`iter` en el objeto contenedor. La función " +"devuelve un objeto iterador que define el método :meth:`__next__` que accede " +"elementos en el contenedor de a uno por vez. Cuando no hay más elementos, :" +"meth:`~iterator.__next__` levanta una excepción :exc:`StopIteration` que le " +"avisa al bucle del :keyword:`for` que hay que terminar. Podés llamar al " +"método :meth:`~iterator.__next__` usando la función integrada :func:" +"`~iterator.__next__`; este ejemplo muestra como funciona todo esto::" #: ../Doc/tutorial/classes.rst:805 msgid "" @@ -1288,12 +1276,12 @@ msgstr "Generadores" #: ../Doc/tutorial/classes.rst:844 msgid "" -":term:`Generator`\\s are a simple and powerful tool for creating " -"iterators. They are written like regular functions but use the :keyword:" -"`yield` statement whenever they want to return data. Each time :func:" -"`next` is called on it, the generator resumes where it left off (it " -"remembers all the data values and which statement was last executed). An " -"example shows that generators can be trivially easy to create::" +":term:`Generator`\\s are a simple and powerful tool for creating iterators. " +"They are written like regular functions but use the :keyword:`yield` " +"statement whenever they want to return data. Each time :func:`next` is " +"called on it, the generator resumes where it left off (it remembers all the " +"data values and which statement was last executed). An example shows that " +"generators can be trivially easy to create::" msgstr "" "Los `generadores` son una simple y poderosa herramienta para crear " "iteradores. Se escriben como funciones regulares pero usan la sentencia :" @@ -1306,8 +1294,8 @@ msgstr "" msgid "" "Anything that can be done with generators can also be done with class-based " "iterators as described in the previous section. What makes generators so " -"compact is that the :meth:`__iter__` and :meth:`~generator.__next__` " -"methods are created automatically." +"compact is that the :meth:`__iter__` and :meth:`~generator.__next__` methods " +"are created automatically." msgstr "" "Todo lo que puede ser hecho con generadores también puede ser hecho con " "iteradores basados en clases, como se describe en la sección anterior. Lo " @@ -1323,8 +1311,8 @@ msgid "" msgstr "" "Otra característica clave es que las variables locales y el estado de la " "ejecución son guardados automáticamente entre llamadas. Esto hace que la " -"función sea más fácil de escribir y quede mucho más claro que hacerlo " -"usando variables de instancia tales como ``self.indice`` y ``self.datos``." +"función sea más fácil de escribir y quede mucho más claro que hacerlo usando " +"variables de instancia tales como ``self.indice`` y ``self.datos``." #: ../Doc/tutorial/classes.rst:875 msgid "" @@ -1335,9 +1323,8 @@ msgid "" msgstr "" "Además de la creación automática de métodos y el guardar el estado del " "programa, cuando los generadores terminan automáticamente levantan :exc:" -"`StopIteration`. Combinadas, estas características facilitan la creación " -"de iteradores, y hacen que no sea más esfuerzo que escribir una función " -"regular." +"`StopIteration`. Combinadas, estas características facilitan la creación de " +"iteradores, y hacen que no sea más esfuerzo que escribir una función regular." #: ../Doc/tutorial/classes.rst:884 msgid "Generator Expressions" @@ -1345,21 +1332,20 @@ msgstr "Expresiones generadoras" #: ../Doc/tutorial/classes.rst:886 msgid "" -"Some simple generators can be coded succinctly as expressions using a " -"syntax similar to list comprehensions but with parentheses instead of " -"square brackets. These expressions are designed for situations where the " -"generator is used right away by an enclosing function. Generator " -"expressions are more compact but less versatile than full generator " -"definitions and tend to be more memory friendly than equivalent list " -"comprehensions." +"Some simple generators can be coded succinctly as expressions using a syntax " +"similar to list comprehensions but with parentheses instead of square " +"brackets. These expressions are designed for situations where the generator " +"is used right away by an enclosing function. Generator expressions are more " +"compact but less versatile than full generator definitions and tend to be " +"more memory friendly than equivalent list comprehensions." msgstr "" "Algunos generadores simples pueden ser escritos de manera concisa como " "expresiones usando una sintaxis similar a las comprensiones de listas pero " "con paréntesis en lugar de corchetes. Estas expresiones están hechas para " "situaciones donde el generador es utilizado de inmediato por la función que " "lo encierra. Las expresiones generadoras son más compactas pero menos " -"versátiles que las definiciones completas de generadores y tienden a ser " -"más amigables con la memoria que sus comprensiones de listas equivalentes." +"versátiles que las definiciones completas de generadores y tienden a ser más " +"amigables con la memoria que sus comprensiones de listas equivalentes." #: ../Doc/tutorial/classes.rst:893 msgid "Examples::" From eb56019b136c85b5155c9b36fc6aee72f944a853 Mon Sep 17 00:00:00 2001 From: Marco Richetta Date: Mon, 4 May 2020 13:37:06 -0300 Subject: [PATCH 3/3] =?UTF-8?q?Traducci=C3=B3n=20100%?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tutorial/classes.po | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/tutorial/classes.po b/tutorial/classes.po index 44bd7beb48..08d9638d40 100644 --- a/tutorial/classes.po +++ b/tutorial/classes.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: Python 3.7\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2019-05-06 11:59-0400\n" -"PO-Revision-Date: 2020-05-03 21:38-0300\n" +"PO-Revision-Date: 2020-05-04 13:28-0300\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" @@ -278,22 +278,29 @@ msgstr "" #: ../Doc/tutorial/classes.rst:120 msgid "the innermost scope, which is searched first, contains the local names" msgstr "" +"el alcance más interno, que es inspeccionado primero, contiene los nombres " +"locales" #: ../Doc/tutorial/classes.rst:121 msgid "" "the scopes of any enclosing functions, which are searched starting with the " "nearest enclosing scope, contains non-local, but also non-global names" msgstr "" +"los alcances de las funciones que encierran a la función actual, que son " +"inspeccionados a partir del alcance más cercano, contienen nombres no " +"locales, pero también no globales" #: ../Doc/tutorial/classes.rst:123 msgid "the next-to-last scope contains the current module's global names" -msgstr "" +msgstr "el penúltimo alcance contiene nombres globales del módulo actual" #: ../Doc/tutorial/classes.rst:124 msgid "" "the outermost scope (searched last) is the namespace containing built-in " "names" msgstr "" +"el alcance más externo (el último inspeccionado) es el espacio de nombres " +"que contiene los nombres integrados" #: ../Doc/tutorial/classes.rst:126 msgid "" @@ -721,6 +728,15 @@ msgid "" "from the instance object and the argument list, and the function object is " "called with this new argument list." msgstr "" +"Si todavía no entiendes como funcionan los métodos, una mirada a su " +"implementación quizás pueda aclarar dudas. Cuando un atributo sin datos de " +"una instancia es referenciado, la clase de la instancia es accedida. Si el " +"nombre indica un atributo de clase válido que sea un objeto función, se crea " +"un objeto método empaquetando (apunta a) la instancia y al objeto función, " +"juntados en un objeto abstracto: este es el objeto método. Cuando el objeto " +"método es llamado con una lista de argumentos, se crea una nueva lista de " +"argumentos a partir del objeto instancia y la lista de argumentos. " +"Finalmente el objeto función es llamado con esta nueva lista de argumentos." #: ../Doc/tutorial/classes.rst:403 msgid "Class and Instance Variables" @@ -1364,3 +1380,9 @@ msgid "" "abstraction of namespace implementation, and should be restricted to things " "like post-mortem debuggers." msgstr "" +"Excepto por una cosa. Los objetos módulo tienen un atributo de sólo lectura " +"secreto llamado :attr:`~object.__dict__` que devuelve el diccionario usado " +"para implementar el espacio de nombres del módulo; el nombre :attr:~object." +"__dict__` es un atributo pero no un nombre global. Obviamente, usar esto " +"viola la abstracción de la implementación del espacio de nombres, y debería " +"ser restringido a cosas como depuradores post-mortem."