# 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 exceções" #: ../../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 *exceções*." #: ../../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, também conhecidos como erros de parse, são provavelmente " "os mais frequentes entre aqueles que ainda estão 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 inválida 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 símbolo que *precede* a seta: no exemplo, o erro foi " "detectado na função :func:`print`, uma vez que um dois-pontos (``':'``) está" " faltando antes dela. O nome de arquivo e número de linha são exibidos para " "que você possa rastrear o erro no texto do script." #: ../../tutorial/errors.rst:37 msgid "Exceptions" msgstr "Exceções" #: ../../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 expressão estejam sintaticamente corretos, talvez " "ocorra um erro na hora de sua execução. Erros detectados durante a execução " "são chamados *exceções* e não são necessariamente fatais: logo veremos como " "tratá-las em programas Python. A maioria das exceções não são 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. Exceções surgem " "com diferentes tipos, e o tipo é exibido como parte da mensagem: os tipos no" " exemplo são :exc:`ZeroDivisionError`, :exc:`NameError` e :exc:`TypeError`. " "A string exibida como sendo o tipo da exceção é o nome da exceção embutida " "que ocorreu. Isso é verdade para todas exceções pré-definidas em Python, mas" " não é necessariamente verdade para exceções definidas pelo usuário (embora " "seja uma convenção útil). Os nomes das exceções padrões são identificadores " "embutidos (não 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 exceção 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 " "exceção. Essa informação é denominada *stack traceback* (situação da pilha " "de execução). Em geral, contém uma lista de linhas do código-fonte, sem " "apresentar, no entanto, linhas lidas da entrada padrão." #: ../../tutorial/errors.rst:74 msgid "" ":ref:`bltin-exceptions` lists the built-in exceptions and their meanings." msgstr "" ":ref:`bltin-exceptions` lista as exceções pré-definidas e seus significados." #: ../../tutorial/errors.rst:80 msgid "Handling Exceptions" msgstr "Tratamento de exceções" #: ../../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 "" "É possível escrever programas que tratam exceções específicas. Observe o " "exemplo seguinte, que pede dados ao usuário até que um inteiro válido 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 interrupção gerada pelo usuário será sinalizada pela exceção " ":exc:`KeyboardInterrupt`. ::" #: ../../tutorial/errors.rst:96 msgid "The :keyword:`try` statement works as follows." msgstr "A instrução :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 *cláusula try* (o conjunto de instruções 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 exceção ocorrer, a *cláusula except* é ignorada e a execução da " "instrução :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 execução durante a execução da cláusula try, as instruções " "remanescentes na cláusula são ignoradas. Se o tipo da exceção ocorrida tiver" " sido previsto em algum :keyword:`except`, então essa cláusula será " "executada. Depois disso, a execução continua após a instrução " ":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 exceção levantada não foi corresponder a nenhuma exceção listada na " "cláusula de exceção, então ela é entregue a uma instrução :keyword:`try` " "mais externa. Se não existir nenhum tratador previsto para tal exceção, " "trata-se de uma *exceção não tratada* e a execução 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 instrução :keyword:`try` pode ter uma ou mais cláusula de exceção, para " "especificar múltiplos tratadores para diferentes exceções. No máximo um " "único tratador será executado. Tratadores só são sensíveis às exceções " "levantadas no interior da cláusula de tentativa, e não às que tenham " "ocorrido no interior de outro tratador numa mesma instrução :keyword:`!try`." " Um tratador pode ser sensível a múltiplas exceções, 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 cláusula :keyword:`except` é compatível com uma exceção se" " ela é da mesma classe ou de uma classe base desta (mas o contrário não é " "válido --- uma cláusula de exceção listando uma classe derivada não é " "compatível com uma classe base). Por exemplo, o seguinte código 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 cláusulas fosse invertida (``except B`` no início), seria " "exibido B, B, B --- somente a primeira cláusula de exceção compatível é " "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 cláusula de exceção pode omitir o nome da exceção, funcionando como" " um curinga. Utilize esse recurso com extrema cautela, uma vez que isso pode" " esconder erros do programador e do usuário! Também pode ser utilizado para " "exibir uma mensagem de erro e então levantar novamente a exceção (permitindo" " que o invocador da função atual também 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 construção :keyword:`try` ... :keyword:`except` possui uma *cláusula else*" " opcional, que quando presente, deve ser colocada depois de todas as outras " "cláusulas. É útil para um código que precisa ser executado se nenhuma " "exceção 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 cláusula :keyword:`!else` do que adicionar código adicional " "à cláusula :keyword:`try` porque ela evita que acidentalmente seja tratada " "uma exceção que não foi levantada pelo código protegido pela construção com " "as instruções :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 exceção ocorre, ela pode estar associada a um valor chamado " "*argumento* da exceção. A presença e o tipo do argumento dependem do tipo da" " exceção." #: ../../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 cláusula except pode especificar uma variável depois do nome (ou da tupla " "de nomes) da exceção. A variável é associada à instância de exceção " "capturada, com os argumentos armazenados em ``instancia.args``. Por " "conveniência, a instância define o método :meth:`__str__` para que os " "argumentos possam ser exibidos diretamente sem necessidade de acessar " "``.args``. Pode-se também instanciar uma exceção 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 exceção tenha argumentos, os mesmos serão impressos como a última " "parte ('detalhe') da mensagem para as exceções não 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 "" "Além disso, tratadores de exceção são capazes de capturar exceções que " "tenham sido levantadas no interior de funções invocadas (mesmo que " "indiretamente) na cláusula try. Por exemplo::" #: ../../tutorial/errors.rst:237 msgid "Raising Exceptions" msgstr "Levantando exceções" #: ../../tutorial/errors.rst:239 msgid "" "The :keyword:`raise` statement allows the programmer to force a specified " "exception to occur. For example::" msgstr "" "A instrução :keyword:`raise` permite ao programador forçar a ocorrência de " "um determinado tipo de exceção. 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 exceção a ser levantada. Esse " "argumento deve ser uma instância de exceção ou uma classe de exceção (uma " "classe que deriva de :class:`Exception`). Se uma classe de exceção 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 exceção foi levantada ou não, mas não " "quer manipular o erro, uma forma simples de instrução :keyword:`raise` " "permite que você levante-a novamente::" #: ../../tutorial/errors.rst:273 msgid "Exception Chaining" msgstr "Encadeamento de exceções" #: ../../tutorial/errors.rst:275 msgid "" "The :keyword:`raise` statement allows an optional :keyword:`from` " "which enables chaining exceptions. For example::" msgstr "" "A instrução :keyword:`raise` permite um :keyword:`from ` opcional que" " torna possível o encadear exceções. 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 exceções. 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 exceções acontece automaticamente quando uma exceção é " "gerada dentro de uma seção :keyword:`except` ou :keyword:`finally`. O " "encadeamento de exceções 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 informações sobre os mecanismos de encadeamento, veja :ref:`bltin-" "exceptions`." #: ../../tutorial/errors.rst:321 msgid "User-defined Exceptions" msgstr "Exceções definidas pelo usuário" #: ../../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 exceções, através da criação de uma " "nova classe (veja :ref:`tut-classes` para mais informações sobre classes " "Python). Exceções 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 exceções podem ser definidas para fazer qualquer coisa que " "qualquer outra classe faz, mas em geral são bem simples, frequentemente " "oferecendo apenas alguns atributos que fornecem informações sobre o erro que" " ocorreu. Ao criar um módulo que pode gerar diversos erros, uma prática " "comum é criar uma classe base para as exceções definidas por aquele módulo, " "e as classes específicas para cada condição 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 exceções sejam definidas com nomes terminando em " "\"Error\", semelhante a muitas exceções 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 módulos padrão definem novas exceções para reportar erros que ocorrem" " no interior das funções que definem. Mais informações sobre classes " "aparecem no capítulo :ref:`tut-classes`." #: ../../tutorial/errors.rst:376 msgid "Defining Clean-up Actions" msgstr "Definindo ações 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 instrução :keyword:`try` possui outra cláusula opcional, cuja finalidade é" " permitir a implementação de ações de limpeza, que sempre devem ser " "executadas independentemente da ocorrência de exceções. 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 cláusula :keyword:`finally` estiver presente, a cláusula " ":keyword:`!finally` será executada como a última tarefa antes da conclusão " "da instrução :keyword:`try`. A cláusula :keyword:`!finally` executa se a " "instrução :keyword:`!try` produz uma exceção. Os pontos a seguir discutem " "casos mais complexos quando ocorre uma exceção:" #: ../../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 exceção durante a execução da cláusula :keyword:`!try`, a " "exceção poderá ser tratada por uma cláusula :keyword:`except`. Se a exceção " "não for tratada por uma cláusula :keyword:`!except`, a exceção será gerada " "novamente após a execução da cláusula: 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 exceção pode ocorrer durante a execução de uma cláusula " ":keyword:`!except` ou :keyword:`!else`. Novamente, a exceção é 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 cláusula :keyword:`!finally` executa uma instrução :keyword:`break`, " ":keyword:`continue` ou :keyword:`return`, as exceções não são 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 instrução :keyword:`!try` atingir uma instrução :keyword:`break`, " ":keyword:`continue` ou :keyword:`return`, a cláusula :keyword:`!finally` " "será executada imediatamente antes da execução da instrução " ":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 cláusula :keyword:`!finally` incluir uma instrução " ":keyword:`!return`, o valor retornado será aquele da instrução " ":keyword:`!return` da cláusula :keyword:`!finally`, não o valor da instrução" " :keyword:`!return` da cláusula :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 cláusula :keyword:`finally` é executada em todos os " "casos. A exceção :exc:`TypeError` levantada pela divisão de duas strings não" " é tratada pela cláusula :keyword:`except` e portanto é re-levantada depois " "que a cláusula :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 aplicação do mundo real, a cláusula :keyword:`finally` é útil para " "liberar recursos externos (como arquivos ou conexões de rede), " "independentemente do uso do recurso ter sido bem sucedido ou não." #: ../../tutorial/errors.rst:473 msgid "Predefined Clean-up Actions" msgstr "Ações 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 ações de limpeza padrões para serem executadas quando" " o objeto não é mais necessário, independentemente da operação que estava " "usando o objeto ter sido ou não bem sucedida. Veja o exemplo a seguir, que " "tenta abrir um arquivo e exibir seu conteúdo 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 código é que ele deixa o arquivo aberto um período " "indeterminado depois que o código é executado. Isso não chega a ser problema" " em scripts simples, mas pode ser um problema para grandes aplicações. A " "palavra reservada :keyword:`with` permite que objetos como arquivos sejam " "utilizados com a certeza de que sempre serão 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 instrução é executada, o arquivo *f* é sempre fechado, mesmo se" " ocorrer um problema durante o processamento das linhas. Outros objetos que," " como arquivos, fornecem ações de limpeza predefinidas as indicarão em suas " "documentações."