# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
# Translators:
# Leticia Portella , 2017
# Claudio Rogerio Carvalho Filho , 2019
# Adorilson Bezerra , 2019
# Rafael Fontenelle , 2021
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-05-05 06:14+0000\n"
"PO-Revision-Date: 2017-02-16 23:40+0000\n"
"Last-Translator: Rafael Fontenelle , 2021\n"
"Language-Team: Portuguese (Brazil) (https://www.transifex.com/python-doc/teams/5390/pt_BR/)\n"
"Language: pt_BR\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"

#: ../../tutorial/errors.rst:5
msgid "Errors and Exceptions"
msgstr "Erros e excees"

#: ../../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 ""
"At agora mensagens de erro foram apenas mencionadas, mas se voc testou os "
"exemplos, talvez tenha esbarrado em algumas. Existem pelo menos dois tipos "
"distintos de erros: *erros de sintaxe* e *excees*."

#: ../../tutorial/errors.rst:15
msgid "Syntax Errors"
msgstr "Erros de sintaxe"

#: ../../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 ""
"Erros de sintaxe, tambm conhecidos como erros de parse, so provavelmente "
"os mais frequentes entre aqueles que ainda esto aprendendo Python::"

#: ../../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 ""
"O parser repete a linha invlida e apresenta uma pequena 'seta' apontando "
"para o ponto da linha em que o erro foi detectado. O erro  causado (ou ao "
"menos detectado) pelo smbolo que *precede* a seta: no exemplo, o erro foi "
"detectado na funo :func:`print`, uma vez que um dois-pontos (``':'``) est"
" faltando antes dela. O nome de arquivo e nmero de linha so exibidos para "
"que voc possa rastrear o erro no texto do script."

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

#: ../../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 ""
"Mesmo que um comando ou expresso estejam sintaticamente corretos, talvez "
"ocorra um erro na hora de sua execuo. Erros detectados durante a execuo "
"so chamados *excees* e no so necessariamente fatais: logo veremos como "
"trat-las em programas Python. A maioria das excees no so tratadas pelos"
" programas e acabam resultando em mensagens de erro::"

#: ../../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 ""
"A ltima linha da mensagem de erro indica o que aconteceu. Excees surgem "
"com diferentes tipos, e o tipo  exibido como parte da mensagem: os tipos no"
" exemplo so :exc:`ZeroDivisionError`, :exc:`NameError` e :exc:`TypeError`. "
"A string exibida como sendo o tipo da exceo  o nome da exceo embutida "
"que ocorreu. Isso  verdade para todas excees pr-definidas em Python, mas"
" no  necessariamente verdade para excees definidas pelo usurio (embora "
"seja uma conveno til). Os nomes das excees padres so identificadores "
"embutidos (no palavras reservadas)."

#: ../../tutorial/errors.rst:66
msgid ""
"The rest of the line provides detail based on the type of exception and what"
" caused it."
msgstr ""
"O resto da linha  um detalhamento que depende do tipo da exceo ocorrida e"
" sua causa."

#: ../../tutorial/errors.rst:69
msgid ""
"The preceding part of the error message shows the context where the "
"exception occurred, 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 ""
"A parte anterior da mensagem de erro apresenta o contexto onde ocorreu a "
"exceo. Essa informao  denominada *stack traceback* (situao da pilha "
"de execuo). Em geral, contm uma lista de linhas do cdigo-fonte, sem "
"apresentar, no entanto, linhas lidas da entrada padro."

#: ../../tutorial/errors.rst:74
msgid ""
":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ""
":ref:`bltin-exceptions` lista as excees pr-definidas e seus significados."

#: ../../tutorial/errors.rst:80
msgid "Handling Exceptions"
msgstr "Tratamento de excees"

#: ../../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 ""
" possvel escrever programas que tratam excees especficas. Observe o "
"exemplo seguinte, que pede dados ao usurio at que um inteiro vlido seja "
"fornecido, ainda permitindo que o programa seja interrompido (utilizando "
":kbd:`Control-C` ou seja l o que for que o sistema operacional suporte); "
"note que uma interrupo gerada pelo usurio ser sinalizada pela exceo "
":exc:`KeyboardInterrupt`. ::"

#: ../../tutorial/errors.rst:96
msgid "The :keyword:`try` statement works as follows."
msgstr "A instruo :keyword:`try` funciona da seguinte maneira:"

#: ../../tutorial/errors.rst:98
msgid ""
"First, the *try clause* (the statement(s) between the :keyword:`try` and "
":keyword:`except` keywords) is executed."
msgstr ""
"Primeiramente, a *clusula try* (o conjunto de instrues entre as palavras "
"reservadas :keyword:`try` e :keyword:`except` )  executada."

#: ../../tutorial/errors.rst:101
msgid ""
"If no exception occurs, the *except clause* is skipped and execution of the "
":keyword:`try` statement is finished."
msgstr ""
"Se nenhuma exceo ocorrer, a *clusula except*  ignorada e a execuo da "
"instruo :keyword:`try`  finalizada."

#: ../../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 ""
"Se ocorrer uma execuo durante a execuo da clusula try, as instrues "
"remanescentes na clusula so ignoradas. Se o tipo da exceo ocorrida tiver"
" sido previsto em algum :keyword:`except`, ento essa clusula ser "
"executada. Depois disso, a execuo continua aps a instruo "
":keyword:`try`."

#: ../../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 ""
"Se a exceo levantada no foi corresponder a nenhuma exceo listada na "
"clusula de exceo, ento ela  entregue a uma instruo :keyword:`try` "
"mais externa. Se no existir nenhum tratador previsto para tal exceo, "
"trata-se de uma *exceo no tratada* e a execuo do programa termina com "
"uma mensagem de erro."

#: ../../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 ""
"A instruo :keyword:`try` pode ter uma ou mais clusula de exceo, para "
"especificar mltiplos tratadores para diferentes excees. No mximo um "
"nico tratador ser executado. Tratadores s so sensveis s excees "
"levantadas no interior da clusula de tentativa, e no s que tenham "
"ocorrido no interior de outro tratador numa mesma instruo :keyword:`!try`."
" Um tratador pode ser sensvel a mltiplas excees, desde que as "
"especifique em uma tupla::"

#: ../../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 ""
"Uma classe em uma clusula :keyword:`except`  compatvel com uma exceo se"
" ela  da mesma classe ou de uma classe base desta (mas o contrrio no  "
"vlido --- uma clusula de exceo listando uma classe derivada no  "
"compatvel com uma classe base). Por exemplo, o seguinte cdigo ir mostrar "
"B, C, D nesta ordem::"

#: ../../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 ""
"Se a ordem das clusulas fosse invertida (``except B`` no incio), seria "
"exibido B, B, B --- somente a primeira clusula de exceo compatvel  "
"ativada."

#: ../../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 ""
"A ltima clusula de exceo pode omitir o nome da exceo, funcionando como"
" um curinga. Utilize esse recurso com extrema cautela, uma vez que isso pode"
" esconder erros do programador e do usurio! Tambm pode ser utilizado para "
"exibir uma mensagem de erro e ento levantar novamente a exceo (permitindo"
" que o invocador da funo atual tambm possa trat-la)::"

#: ../../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 ""
"A construo :keyword:`try` ... :keyword:`except` possui uma *clusula else*"
" opcional, que quando presente, deve ser colocada depois de todas as outras "
"clusulas.  til para um cdigo que precisa ser executado se nenhuma "
"exceo foi levantada. Por exemplo::"

#: ../../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 ""
" melhor usar a clusula :keyword:`!else` do que adicionar cdigo adicional "
" clusula :keyword:`try` porque ela evita que acidentalmente seja tratada "
"uma exceo que no foi levantada pelo cdigo protegido pela construo com "
"as instrues :keyword:`!try` ... :keyword:`!except`."

#: ../../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 ""
"Quando uma exceo ocorre, ela pode estar associada a um valor chamado "
"*argumento* da exceo. A presena e o tipo do argumento dependem do tipo da"
" exceo."

#: ../../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 ""
"A clusula except pode especificar uma varivel depois do nome (ou da tupla "
"de nomes) da exceo. A varivel  associada  instncia de exceo "
"capturada, com os argumentos armazenados em ``instancia.args``. Por "
"convenincia, a instncia define o mtodo :meth:`__str__` para que os "
"argumentos possam ser exibidos diretamente sem necessidade de acessar "
"``.args``. Pode-se tambm instanciar uma exceo antes de levant-la e "
"adicionar qualquer atributo a ela, conforme desejado. ::"

#: ../../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 ""
"Caso uma exceo tenha argumentos, os mesmos sero impressos como a ltima "
"parte ('detalhe') da mensagem para as excees no tratadas."

#: ../../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 ""
"Alm disso, tratadores de exceo so capazes de capturar excees que "
"tenham sido levantadas no interior de funes invocadas (mesmo que "
"indiretamente) na clusula try. Por exemplo::"

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

#: ../../tutorial/errors.rst:239
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified "
"exception to occur. For example::"
msgstr ""
"A instruo :keyword:`raise` permite ao programador forar a ocorrncia de "
"um determinado tipo de exceo. Por exemplo::"

#: ../../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 ""
"O argumento de :keyword:`raise` indica a exceo a ser levantada. Esse "
"argumento deve ser uma instncia de exceo ou uma classe de exceo (uma "
"classe que deriva de :class:`Exception`). Se uma classe de exceo for "
"passada, ser implicitamente instanciada invocando o seu construtor sem "
"argumentos::"

#: ../../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 ""
"Caso voc precise determinar se uma exceo foi levantada ou no, mas no "
"quer manipular o erro, uma forma simples de instruo :keyword:`raise` "
"permite que voc levante-a novamente::"

#: ../../tutorial/errors.rst:273
msgid "Exception Chaining"
msgstr "Encadeamento de excees"

#: ../../tutorial/errors.rst:275
msgid ""
"The :keyword:`raise` statement allows an optional :keyword:`from` "
"which enables chaining exceptions. For example::"
msgstr ""
"A instruo :keyword:`raise` permite um :keyword:`from ` opcional que"
" torna possvel o encadear excees. Por exemplo::"

#: ../../tutorial/errors.rst:281
msgid "This can be useful when you are transforming exceptions. For example::"
msgstr ""
"Isso pode ser til quando voc est transformando excees. Por exemplo::"

#: ../../tutorial/errors.rst:302
msgid ""
"Exception chaining happens automatically when an exception is raised inside "
"an :keyword:`except` or :keyword:`finally` section. Exception chaining can "
"be disabled by using ``from None`` idiom:"
msgstr ""
"O encadeamento de excees acontece automaticamente quando uma exceo  "
"gerada dentro de uma seo :keyword:`except`  ou :keyword:`finally`. O "
"encadeamento de excees pode ser desativado usando o idioma ``from None``:"

#: ../../tutorial/errors.rst:315
msgid ""
"For more information about chaining mechanics, see :ref:`bltin-exceptions`."
msgstr ""
"Para mais informaes sobre os mecanismos de encadeamento, veja :ref:`bltin-"
"exceptions`."

#: ../../tutorial/errors.rst:321
msgid "User-defined Exceptions"
msgstr "Excees definidas pelo usurio"

#: ../../tutorial/errors.rst:323
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 ""
"Programas podem definir novos tipos de excees, atravs da criao de uma "
"nova classe (veja :ref:`tut-classes` para mais informaes sobre classes "
"Python). Excees devem ser derivadas da classe :exc:`Exception`, direta ou "
"indiretamente."

#: ../../tutorial/errors.rst:327
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 ""
"Classes de excees podem ser definidas para fazer qualquer coisa que "
"qualquer outra classe faz, mas em geral so bem simples, frequentemente "
"oferecendo apenas alguns atributos que fornecem informaes sobre o erro que"
" ocorreu. Ao criar um mdulo que pode gerar diversos erros, uma prtica "
"comum  criar uma classe base para as excees definidas por aquele mdulo, "
"e as classes especficas para cada condio de erro como subclasses dela::"

#: ../../tutorial/errors.rst:365
msgid ""
"Most exceptions are defined with names that end in \"Error\", similar to the"
" naming of the standard exceptions."
msgstr ""
" comum que novas excees sejam definidas com nomes terminando em "
"\"Error\", semelhante a muitas excees embutidas."

#: ../../tutorial/errors.rst:368
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 ""
"Muitos mdulos padro definem novas excees para reportar erros que ocorrem"
" no interior das funes que definem. Mais informaes sobre classes "
"aparecem no captulo :ref:`tut-classes`."

#: ../../tutorial/errors.rst:376
msgid "Defining Clean-up Actions"
msgstr "Definindo aes de limpeza"

#: ../../tutorial/errors.rst:378
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 ""
"A instruo :keyword:`try` possui outra clusula opcional, cuja finalidade "
" permitir a implementao de aes de limpeza, que sempre devem ser "
"executadas independentemente da ocorrncia de excees. Como no exemplo::"

#: ../../tutorial/errors.rst:392
msgid ""
"If a :keyword:`finally` clause is present, the :keyword:`!finally` clause "
"will execute as the last task before the :keyword:`try` statement completes."
" The :keyword:`!finally` clause runs whether or not the :keyword:`!try` "
"statement produces an exception. The following points discuss more complex "
"cases when an exception occurs:"
msgstr ""
"Se uma clusula :keyword:`finally` estiver presente, a clusula "
":keyword:`!finally` ser executada como a ltima tarefa antes da concluso "
"da instruo :keyword:`try`. A clusula :keyword:`!finally` executa se a "
"instruo :keyword:`!try` produz uma exceo. Os pontos a seguir discutem "
"casos mais complexos quando ocorre uma exceo:"

#: ../../tutorial/errors.rst:398
msgid ""
"If an exception occurs during execution of the :keyword:`!try` clause, the "
"exception may be handled by an :keyword:`except` clause. If the exception is"
" not handled by an :keyword:`!except` clause, the exception is re-raised "
"after the :keyword:`!finally` clause has been executed."
msgstr ""
"Se ocorrer uma exceo durante a execuo da clusula :keyword:`!try`, a "
"exceo poder ser tratada por uma clusula :keyword:`except`. Se a exceo "
"no for tratada por uma clusula :keyword:`!except`, a exceo ser gerada "
"novamente aps a execuo da clusula: keyword:`!finally`."

#: ../../tutorial/errors.rst:404
msgid ""
"An exception could occur during execution of an :keyword:`!except` or "
":keyword:`!else` clause. Again, the exception is re-raised after the "
":keyword:`!finally` clause has been executed."
msgstr ""
"Uma exceo pode ocorrer durante a execuo de uma clusula "
":keyword:`!except` ou :keyword:`!else`. Novamente, a exceo  re-levantada "
"depois que :keyword:`!finally`  executada."

#: ../../tutorial/errors.rst:408
msgid ""
"If the :keyword:`!finally` clause executes a :keyword:`break`, "
":keyword:`continue` or :keyword:`return` statement, exceptions are not re-"
"raised."
msgstr ""
"Se a clusula :keyword:`!finally` executa uma instruo :keyword:`break`, "
":keyword:`continue` ou :keyword:`return`, as excees no so levantadas "
"novamente."

#: ../../tutorial/errors.rst:412
msgid ""
"If the :keyword:`!try` statement reaches a :keyword:`break`, "
":keyword:`continue` or :keyword:`return` statement, the :keyword:`!finally` "
"clause will execute just prior to the :keyword:`!break`, "
":keyword:`!continue` or :keyword:`!return` statement's execution."
msgstr ""
"Se a instruo :keyword:`!try` atingir uma instruo :keyword:`break`, "
":keyword:`continue` ou :keyword:`return`, a clusula :keyword:`!finally` "
"ser executada imediatamente antes da execuo da instruo "
":keyword:`!break`, :keyword:`!continue` ou :keyword:`!return`."

#: ../../tutorial/errors.rst:418
msgid ""
"If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the"
" returned value will be the one from the :keyword:`!finally` clause's "
":keyword:`!return` statement, not the value from the :keyword:`!try` "
"clause's :keyword:`!return` statement."
msgstr ""
"Se uma clusula :keyword:`!finally` incluir uma instruo "
":keyword:`!return`, o valor retornado ser aquele da instruo "
":keyword:`!return` da clusula :keyword:`!finally`, no o valor da instruo"
" :keyword:`!return` da clusula :keyword:`!try`."

#: ../../tutorial/errors.rst:424
msgid "For example::"
msgstr "Por exemplo::"

#: ../../tutorial/errors.rst:435
msgid "A more complicated example::"
msgstr "Um exemplo mais complicado::"

#: ../../tutorial/errors.rst:460
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 voc pode ver, a clusula :keyword:`finally`  executada em todos os "
"casos. A exceo :exc:`TypeError` levantada pela diviso de duas strings no"
"  tratada pela clusula :keyword:`except` e portanto  re-levantada depois "
"que a clusula :keyword:`!finally`  executada."

#: ../../tutorial/errors.rst:465
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 ""
"Em aplicao do mundo real, a clusula :keyword:`finally`  til para "
"liberar recursos externos (como arquivos ou conexes de rede), "
"independentemente do uso do recurso ter sido bem sucedido ou no."

#: ../../tutorial/errors.rst:473
msgid "Predefined Clean-up Actions"
msgstr "Aes de limpeza predefinidas"

#: ../../tutorial/errors.rst:475
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 ""
"Alguns objetos definem aes de limpeza padres para serem executadas quando"
" o objeto no  mais necessrio, independentemente da operao que estava "
"usando o objeto ter sido ou no bem sucedida. Veja o exemplo a seguir, que "
"tenta abrir um arquivo e exibir seu contedo na tela. ::"

#: ../../tutorial/errors.rst:483
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 ""
"O problema com esse cdigo  que ele deixa o arquivo aberto um perodo "
"indeterminado depois que o cdigo  executado. Isso no chega a ser problema"
" em scripts simples, mas pode ser um problema para grandes aplicaes. A "
"palavra reservada :keyword:`with` permite que objetos como arquivos sejam "
"utilizados com a certeza de que sempre sero prontamente e corretamente "
"finalizados. ::"

#: ../../tutorial/errors.rst:493
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 ""
"Depois que a instruo  executada, o arquivo *f*  sempre fechado, mesmo se"
" ocorrer um problema durante o processamento das linhas. Outros objetos que,"
" como arquivos, fornecem aes de limpeza predefinidas as indicaro em suas "
"documentaes."