errors.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2019, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 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 <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../Doc/tutorial/errors.rst:5
msgid "Errors and Exceptions"
msgstr "Errores y excepciones"

#: ../Doc/tutorial/errors.rst:7
msgid ""
"Until now error messages haven't been more than mentioned, but if you have "
"tried out the examples you have probably seen some.  There are (at least) "
"two distinguishable kinds of errors: *syntax errors* and *exceptions*."
msgstr ""
"Hasta ahora los mensajes de error no habían sido más que mencionados, pero "
"si probaste los ejemplos probablemente hayas visto algunos.  Hay (al menos) "
"dos tipos diferentes de errores: *errores de sintaxis* y *excepciones*."

#: ../Doc/tutorial/errors.rst:15
msgid "Syntax Errors"
msgstr "Errores de sintaxis"

#: ../Doc/tutorial/errors.rst:17
msgid ""
"Syntax errors, also known as parsing errors, are perhaps the most common "
"kind of complaint you get while you are still learning Python::"
msgstr ""
"Los errores de sintaxis, también conocidos como errores de interpretación, "
"son quizás el tipo de queja más común que tenés cuando todavía estás "
"aprendiendo Python::"

#: ../Doc/tutorial/errors.rst:26
msgid ""
"The parser repeats the offending line and displays a little 'arrow' pointing"
" at the earliest point in the line where the error was detected.  The error "
"is caused by (or at least detected at) the token *preceding* the arrow: in "
"the example, the error is detected at the function :func:`print`, since a "
"colon (``':'``) is missing before it.  File name and line number are printed"
" so you know where to look in case the input came from a script."
msgstr ""
"El intérprete repite la línea culpable y muestra una pequeña 'flecha' que "
"apunta al primer lugar donde se detectó el error.  Este es causado por (o al"
" menos detectado en) el símbolo que *precede* a la flecha: en el ejemplo, el"
" error se detecta en la función :func:`print`, ya que faltan dos puntos "
"(``':'``) antes del mismo.  Se muestran el nombre del archivo y el número de"
" línea para que sepas dónde mirar en caso de que la entrada venga de un "
"programa."

#: ../Doc/tutorial/errors.rst:37
msgid "Exceptions"
msgstr "Excepciones"

#: ../Doc/tutorial/errors.rst:39
msgid ""
"Even if a statement or expression is syntactically correct, it may cause an "
"error when an attempt is made to execute it. Errors detected during "
"execution are called *exceptions* and are not unconditionally fatal: you "
"will soon learn how to handle them in Python programs.  Most exceptions are "
"not handled by programs, however, and result in error messages as shown "
"here::"
msgstr ""
"Incluso si la declaración o expresión es sintácticamente correcta, puede "
"generar un error cuando se intenta ejecutarla.  Los errores detectados "
"durante la ejecución se llaman *excepciones*, y no son incondicionalmente "
"fatales: pronto aprenderás cómo manejarlos en los programas en Python.  Sin "
"embargo, la mayoría de las excepciones no son manejadas por los programas, y"
" resultan en mensajes de error como los mostrados aquí::"

#: ../Doc/tutorial/errors.rst:58
msgid ""
"The last line of the error message indicates what happened. Exceptions come "
"in different types, and the type is printed as part of the message: the "
"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and "
":exc:`TypeError`. The string printed as the exception type is the name of "
"the built-in exception that occurred.  This is true for all built-in "
"exceptions, but need not be true for user-defined exceptions (although it is"
" a useful convention). Standard exception names are built-in identifiers "
"(not reserved keywords)."
msgstr ""
"La última línea de los mensajes de error indica qué sucedió.  Las "
"excepciones vienen de distintos tipos, y el tipo se imprime como parte del "
"mensaje: los tipos en el ejemplo son: :exc:`ZeroDivisionError`, "
":exc:`NameError` y :exc:`TypeError`.  La cadena mostrada como tipo de la "
"excepción es el nombre de la excepción predefinida que ocurrió.  Esto es "
"verdad para todas las excepciones predefinidas del intérprete, pero no "
"necesita ser verdad para excepciones definidas por el usuario (aunque es una"
" convención útil).  Los nombres de las excepciones estándar son "
"identificadores incorporados al intérprete (no son palabras clave "
"reservadas)."

#: ../Doc/tutorial/errors.rst:66
msgid ""
"The rest of the line provides detail based on the type of exception and what"
" caused it."
msgstr ""
"El resto de la línea provee un detalle basado en el tipo de la excepción y "
"qué la causó."

#: ../Doc/tutorial/errors.rst:69
msgid ""
"The preceding part of the error message shows the context where the "
"exception happened, in the form of a stack traceback. In general it contains"
" a stack traceback listing source lines; however, it will not display lines "
"read from standard input."
msgstr ""
"La parte anterior del mensaje de error muestra el contexto donde la "
"excepción sucedió, en la forma de un *trazado del error* listando líneas "
"fuente; sin embargo, no mostrará líneas leídas desde la entrada estándar."

#: ../Doc/tutorial/errors.rst:74
msgid ""
":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ""
":ref:`bltin-exceptions` lista las excepciones predefinidas y sus "
"significados."

#: ../Doc/tutorial/errors.rst:80
msgid "Handling Exceptions"
msgstr "Manejando excepciones"

#: ../Doc/tutorial/errors.rst:82
msgid ""
"It is possible to write programs that handle selected exceptions. Look at "
"the following example, which asks the user for input until a valid integer "
"has been entered, but allows the user to interrupt the program (using "
":kbd:`Control-C` or whatever the operating system supports); note that a "
"user-generated interruption is signalled by raising the "
":exc:`KeyboardInterrupt` exception. ::"
msgstr ""
"Es posible escribir programas que manejen determinadas excepciones.  Mirá el"
" siguiente ejemplo, que le pide al usuario una entrada hasta que ingrese un "
"entero válido, pero permite al usuario interrumpir el programa (usando "
":kbd:`Control-C` o lo que sea que el sistema operativo soporte); notá que "
"una interrupción generada por el usuario se señaliza generando la excepción "
":exc:`KeyboardInterrupt`. ::"

#: ../Doc/tutorial/errors.rst:96
msgid "The :keyword:`try` statement works as follows."
msgstr "La declaración :keyword:`try` funciona de la siguiente manera:"

#: ../Doc/tutorial/errors.rst:98
msgid ""
"First, the *try clause* (the statement(s) between the :keyword:`try` and "
":keyword:`except` keywords) is executed."
msgstr ""

#: ../Doc/tutorial/errors.rst:101
msgid ""
"If no exception occurs, the *except clause* is skipped and execution of the "
":keyword:`try` statement is finished."
msgstr ""

#: ../Doc/tutorial/errors.rst:104
msgid ""
"If an exception occurs during execution of the try clause, the rest of the "
"clause is skipped.  Then if its type matches the exception named after the "
":keyword:`except` keyword, the except clause is executed, and then execution"
" continues after the :keyword:`try` statement."
msgstr ""

#: ../Doc/tutorial/errors.rst:109
msgid ""
"If an exception occurs which does not match the exception named in the "
"except clause, it is passed on to outer :keyword:`try` statements; if no "
"handler is found, it is an *unhandled exception* and execution stops with a "
"message as shown above."
msgstr ""

#: ../Doc/tutorial/errors.rst:114
msgid ""
"A :keyword:`try` statement may have more than one except clause, to specify "
"handlers for different exceptions.  At most one handler will be executed. "
"Handlers only handle exceptions that occur in the corresponding try clause, "
"not in other handlers of the same :keyword:`!try` statement.  An except "
"clause may name multiple exceptions as a parenthesized tuple, for example::"
msgstr ""
"Una declaración :keyword:`try` puede tener más de un :keyword:`except`, para"
" especificar manejadores para distintas excepciones.  A lo sumo un manejador"
" será ejecutado.  Sólo se manejan excepciones que ocurren en el "
"correspondiente :keyword:`try`, no en otros manejadores del mismo "
":keyword:`try`.  Un :keyword:`except` puede nombrar múltiples excepciones "
"usando paréntesis, por ejemplo::"

#: ../Doc/tutorial/errors.rst:123
msgid ""
"A class in an :keyword:`except` clause is compatible with an exception if it"
" is the same class or a base class thereof (but not the other way around ---"
" an except clause listing a derived class is not compatible with a base "
"class).  For example, the following code will print B, C, D in that order::"
msgstr ""
"Una clase en una clausula :keyword:`except` es compatible con una excepción "
"si la misma esta en la misma clase o una clase base de la misma (pero no de "
"la otra manera --- una clausula except listando una clase derivada no es "
"compatible con una clase base). Por ejemplo, el siguiente código imprimirá "
"B, C, D, en ese orden::"

#: ../Doc/tutorial/errors.rst:147
msgid ""
"Note that if the except clauses were reversed (with ``except B`` first), it "
"would have printed B, B, B --- the first matching except clause is "
"triggered."
msgstr ""
"Notese que si las clausulas de except estuvieran invertidas (con ``except "
"B`` primero), habría impreso B, B, B --- la primera clausula de except "
"coincidente es usada."

#: ../Doc/tutorial/errors.rst:150
msgid ""
"The last except clause may omit the exception name(s), to serve as a "
"wildcard. Use this with extreme caution, since it is easy to mask a real "
"programming error in this way!  It can also be used to print an error "
"message and then re-raise the exception (allowing a caller to handle the "
"exception as well)::"
msgstr ""
"El último :keyword:`except` puede omitir nombrar qué excepción captura, para"
" servir como comodín.  Usá esto con extremo cuidado, ya que de esta manera "
"es fácil ocultar un error real de programación.  También puede usarse para "
"mostrar un mensaje de error y luego re-generar la excepción (permitiéndole "
"al que llama, manejar también la excepción)::"

#: ../Doc/tutorial/errors.rst:169
msgid ""
"The :keyword:`try` ... :keyword:`except` statement has an optional *else "
"clause*, which, when present, must follow all except clauses.  It is useful "
"for code that must be executed if the try clause does not raise an "
"exception.  For example::"
msgstr ""
"Las declaraciones :keyword:`try` ... :keyword:`except` tienen un *bloque "
"else* opcional, el cual, cuando está presente, debe seguir a los except.  Es"
" útil para aquel código que debe ejecutarse si el *bloque try* no genera una"
" excepción.  Por ejemplo::"

#: ../Doc/tutorial/errors.rst:183
msgid ""
"The use of the :keyword:`!else` clause is better than adding additional code"
" to the :keyword:`try` clause because it avoids accidentally catching an "
"exception that wasn't raised by the code being protected by the "
":keyword:`!try` ... :keyword:`!except` statement."
msgstr ""
"El uso de :keyword:`else` es mejor que agregar código adicional en el "
":keyword:`try` porque evita capturar accidentalmente una excepción que no "
"fue generada por el código que está protegido por la declaración "
":keyword:`try` ... :keyword:`except`."

#: ../Doc/tutorial/errors.rst:188
msgid ""
"When an exception occurs, it may have an associated value, also known as the"
" exception's *argument*. The presence and type of the argument depend on the"
" exception type."
msgstr ""
"Cuando ocurre una excepción, puede tener un valor asociado, también conocido"
" como el *argumento* de la excepción.  La presencia y el tipo de argumento "
"depende del tipo de excepción."

#: ../Doc/tutorial/errors.rst:192
msgid ""
"The except clause may specify a variable after the exception name.  The "
"variable is bound to an exception instance with the arguments stored in "
"``instance.args``.  For convenience, the exception instance defines "
":meth:`__str__` so the arguments can be printed directly without having to "
"reference ``.args``.  One may also instantiate an exception first before "
"raising it and add any attributes to it as desired. ::"
msgstr ""
"El :keyword:`except` puede especificar una variable luego del nombre de "
"excepción.  La variable se vincula a una instancia de excepción con los "
"argumentos almacenados en ``instance.args``.  Por conveniencia, la instancia"
" de excepción define :meth:`__str__` para que se pueda mostrar los "
"argumentos directamente, sin necesidad de hacer referencia a ``.args``.  "
"También se puede instanciar la excepción primero, antes de generarla, y "
"agregarle los atributos que se desee::"

#: ../Doc/tutorial/errors.rst:216
msgid ""
"If an exception has arguments, they are printed as the last part ('detail') "
"of the message for unhandled exceptions."
msgstr ""
"Si una excepción tiene argumentos, estos se imprimen como la última parte "
"(el 'detalle') del mensaje para las excepciones que no están manejadas."

#: ../Doc/tutorial/errors.rst:219
msgid ""
"Exception handlers don't just handle exceptions if they occur immediately in"
" the try clause, but also if they occur inside functions that are called "
"(even indirectly) in the try clause. For example::"
msgstr ""
"Los manejadores de excepciones no manejan solamente las excepciones que "
"ocurren en el *bloque try*, también manejan las excepciones que ocurren "
"dentro de las funciones que se llaman (inclusive indirectamente) dentro del "
"*bloque try*.  Por ejemplo::"

#: ../Doc/tutorial/errors.rst:237
msgid "Raising Exceptions"
msgstr "Levantando excepciones"

#: ../Doc/tutorial/errors.rst:239
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified "
"exception to occur. For example::"
msgstr ""
"La declaración :keyword:`raise` permite al programador forzar a que ocurra "
"una excepción específica.  Por ejemplo::"

#: ../Doc/tutorial/errors.rst:247
msgid ""
"The sole argument to :keyword:`raise` indicates the exception to be raised. "
"This must be either an exception instance or an exception class (a class "
"that derives from :class:`Exception`).  If an exception class is passed, it "
"will be implicitly instantiated by calling its constructor with no "
"arguments::"
msgstr ""
"El único argumento a :keyword:`raise` indica la excepción a generarse. Tiene"
" que ser o una instancia de excepción, o una clase de excepción (una clase "
"que hereda de :class:`Exception`). Si se pasa una clase de excepción, la "
"misma sera instanciada implicitamente llamandoa su constructor sin "
"argumentos::"

#: ../Doc/tutorial/errors.rst:254
msgid ""
"If you need to determine whether an exception was raised but don't intend to"
" handle it, a simpler form of the :keyword:`raise` statement allows you to "
"re-raise the exception::"
msgstr ""
"Si necesitás determinar cuando una excepción fue lanzada pero no querés "
"manejarla, una forma simplificada de la instrucción :keyword:`raise` te "
"permite relanzarla::"

#: ../Doc/tutorial/errors.rst:273
msgid "User-defined Exceptions"
msgstr "Excepciones definidas por el usuario"

#: ../Doc/tutorial/errors.rst:275
msgid ""
"Programs may name their own exceptions by creating a new exception class "
"(see :ref:`tut-classes` for more about Python classes).  Exceptions should "
"typically be derived from the :exc:`Exception` class, either directly or "
"indirectly."
msgstr ""
"Los programas pueden nombrar sus propias excepciones creando una nueva clase"
" excepción (mirá :ref:`tut-classes` para más información sobre las clases de"
" Python).  Las excepciones, típicamente, deberán derivar de la clase "
":exc:`Exception`, directa o indirectamente."

#: ../Doc/tutorial/errors.rst:279
msgid ""
"Exception classes can be defined which do anything any other class can do, "
"but are usually kept simple, often only offering a number of attributes that"
" allow information about the error to be extracted by handlers for the "
"exception.  When creating a module that can raise several distinct errors, a"
" common practice is to create a base class for exceptions defined by that "
"module, and subclass that to create specific exception classes for different"
" error conditions::"
msgstr ""
"Las clases de Excepciones pueden ser definidas de la misma forma que "
"cualquier otra clase, pero usualmente se mantienen simples, a menudo solo "
"ofreciendo un número de atributos con información sobre el error que leerán "
"los manejadores de la excepción.  Al crear un módulo que puede lanzar varios"
" errores distintos, una práctica común es crear una clase base para "
"excepciones definidas en ese módulo y extenderla para crear clases "
"excepciones específicas para distintas condiciones de error::"

#: ../Doc/tutorial/errors.rst:317
msgid ""
"Most exceptions are defined with names that end in \"Error\", similar to the"
" naming of the standard exceptions."
msgstr ""

#: ../Doc/tutorial/errors.rst:320
msgid ""
"Many standard modules define their own exceptions to report errors that may "
"occur in functions they define.  More information on classes is presented in"
" chapter :ref:`tut-classes`."
msgstr ""
"Muchos módulos estándar definen sus propias excepciones para reportar "
"errores que pueden ocurrir en funciones propias. Se puede encontrar más "
"información sobre clases en el capítulo :ref:`tut-classes`."

#: ../Doc/tutorial/errors.rst:328
msgid "Defining Clean-up Actions"
msgstr "Definiendo acciones de limpieza"

#: ../Doc/tutorial/errors.rst:330
msgid ""
"The :keyword:`try` statement has another optional clause which is intended "
"to define clean-up actions that must be executed under all circumstances.  "
"For example::"
msgstr ""
"La declaración :keyword:`try` tiene otra cláusula opcional que intenta "
"definir acciones de limpieza que deben ser ejecutadas bajo ciertas "
"circunstancias. Por ejemplo::"

#: ../Doc/tutorial/errors.rst:344
msgid ""
"A *finally clause* is always executed before leaving the :keyword:`try` "
"statement, whether an exception has occurred or not. When an exception has "
"occurred in the :keyword:`!try` clause and has not been handled by an "
":keyword:`except` clause (or it has occurred in an :keyword:`!except` or "
":keyword:`!else` clause), it is re-raised after the :keyword:`finally` "
"clause has been executed.  The :keyword:`!finally` clause is also executed "
"\"on the way out\" when any other clause of the :keyword:`!try` statement is"
" left via a :keyword:`break`, :keyword:`continue` or :keyword:`return` "
"statement.  A more complicated example::"
msgstr ""
"Una *cláusula finally* siempre es ejecutada antes de salir de la declaración"
" :keyword:`try`, ya sea que una excepción haya ocurrido o no.  Cuando ocurre"
" una excepción en la cláusula :keyword:`try` y no fue manejada por una "
"cláusula :keyword:`except` (o ocurrió en una cláusula :keyword:`except` o "
":keyword:`else`), es relanzada luego de que se ejecuta la cláusula "
":keyword:`finally`. El :keyword:`finally` es también ejecutado \"a la "
"salida\" cuando cualquier otra cláusula de la declaración :keyword:`try` es "
"dejada via :keyword:`break`, :keyword:`continue` or :keyword:`return`.  Un "
"ejemplo más complicado::"

#: ../Doc/tutorial/errors.rst:377
msgid ""
"As you can see, the :keyword:`finally` clause is executed in any event.  The"
" :exc:`TypeError` raised by dividing two strings is not handled by the "
":keyword:`except` clause and therefore re-raised after the "
":keyword:`!finally` clause has been executed."
msgstr ""
"Como podés ver, la cláusula :keyword:`finally` es ejecutada siempre.  La "
"excepción :exc:`TypeError` lanzada al dividir dos cadenas de texto no es "
"manejado por la cláusula :keyword:`except` y por lo tanto es relanzada luego"
" de que se ejecuta la cláusula :keyword:`finally`."

#: ../Doc/tutorial/errors.rst:382
msgid ""
"In real world applications, the :keyword:`finally` clause is useful for "
"releasing external resources (such as files or network connections), "
"regardless of whether the use of the resource was successful."
msgstr ""
"En aplicaciones reales, la cláusula :keyword:`finally` es útil para liberar "
"recursos externos (como archivos o conexiones de red), sin importar si el "
"uso del recurso fue exitoso."

#: ../Doc/tutorial/errors.rst:390
msgid "Predefined Clean-up Actions"
msgstr "Acciones predefinidas de limpieza"

#: ../Doc/tutorial/errors.rst:392
msgid ""
"Some objects define standard clean-up actions to be undertaken when the "
"object is no longer needed, regardless of whether or not the operation using"
" the object succeeded or failed. Look at the following example, which tries "
"to open a file and print its contents to the screen. ::"
msgstr ""
"Algunos objetos definen acciones de limpieza estándar que llevar a cabo "
"cuando el objeto no es más necesitado, independientemente de que las "
"operaciones sobre el objeto hayan sido exitosas o no.  Mirá el siguiente "
"ejemplo, que intenta abrir un archivo e imprimir su contenido en la "
"pantalla.::"

#: ../Doc/tutorial/errors.rst:400
msgid ""
"The problem with this code is that it leaves the file open for an "
"indeterminate amount of time after this part of the code has finished "
"executing. This is not an issue in simple scripts, but can be a problem for "
"larger applications. The :keyword:`with` statement allows objects like files"
" to be used in a way that ensures they are always cleaned up promptly and "
"correctly. ::"
msgstr ""
"El problema con este código es que deja el archivo abierto por un periodo de"
" tiempo indeterminado luego de que esta parte termine de ejecutarse.  Esto "
"no es un problema en scripts simples, pero puede ser un problema en "
"aplicaciones más grandes.  La declaración :keyword:`with` permite que "
"objetos como archivos sean usados de una forma que asegure que siempre se "
"los libera rápido y en forma correcta.::"

#: ../Doc/tutorial/errors.rst:410
msgid ""
"After the statement is executed, the file *f* is always closed, even if a "
"problem was encountered while processing the lines. Objects which, like "
"files, provide predefined clean-up actions will indicate this in their "
"documentation."
msgstr ""