# 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.
# 
# Translators:
# oon arfiandwi <oon.arfiandwi@gmail.com>, 2019
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-09-26 11:33+0000\n"
"PO-Revision-Date: 2017-02-16 23:40+0000\n"
"Last-Translator: oon arfiandwi <oon.arfiandwi@gmail.com>, 2019\n"
"Language-Team: Indonesian (https://www.transifex.com/python-doc/teams/5390/id/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: id\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../tutorial/errors.rst:5
msgid "Errors and Exceptions"
msgstr "Kesalahan *errors* dan Pengecualian *exceptions*"

#: ../../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 ""
"Sampai sekarang pesan kesalahan belum lebih dari yang disebutkan, tetapi "
"jika Anda telah mencoba contohnya, Anda mungkin telah melihat beberapa. Ada "
"(setidaknya) dua jenis kesalahan yang dapat dibedakan: *syntax errors* dan "
"*exceptions*."

#: ../../tutorial/errors.rst:15
msgid "Syntax Errors"
msgstr "Kesalahan Sintaksis"

#: ../../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 ""
"Kesalahan sintaksis, juga dikenal sebagai kesalahan penguraian *parsing*, "
"mungkin merupakan jenis keluhan paling umum yang Anda dapatkan saat Anda "
"masih belajar 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 ""
"Pengurai *parser* mengulangi baris yang menyinggung dan menampilkan sedikit "
"'arrow' yang menunjuk pada titik paling awal di baris di mana kesalahan "
"terdeteksi. Kesalahan disebabkan oleh (atau setidaknya terdeteksi pada) "
"token *preceding* panah: dalam contoh, kesalahan terdeteksi pada fungsi "
":func:`print`, karena titik dua (``':'``)) hilang sebelum itu. Nama file dan"
" nomor baris dicetak sehingga Anda tahu ke mana harus mencari kalau-kalau "
"masukan berasal dari skrip."

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

#: ../../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 ""
"Bahkan jika suatu pernyataan atau ungkapan secara sintaksis benar, itu dapat"
" menyebabkan kesalahan ketika suatu usaha dilakukan untuk mengeksekusinya. "
"Kesalahan yang terdeteksi selama eksekusi disebut *exceptions* dan tidak "
"fatal tanpa syarat: Anda akan segera belajar cara menanganinya dalam program"
" Python. Namun, sebagian besar pengecualian tidak ditangani oleh program, "
"dan menghasilkan pesan kesalahan seperti yang ditunjukkan di sini::"

#: ../../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 ""
"Baris terakhir dari pesan kesalahan menunjukkan apa yang terjadi. "
"Pengecualian ada berbagai jenis yang berbeda, dan tipe dicetak sebagai "
"bagian dari pesan: tipe dalam contoh adalah :exc:`ZeroDivisionError`, "
":exc:`NameError` dan :exc:`TypeError`. String yang dicetak sebagai jenis "
"pengecualian adalah nama pengecualian bawaan yang terjadi. Ini berlaku untuk"
" semua pengecualian bawaan, tetapi tidak harus sama untuk pengecualian yang "
"dibuat pengguna (meskipun ini adalah konvensi yang bermanfaat). Nama "
"pengecualian standar adalah pengidentifikasi bawaan (bukan kata kunci yang "
"dipesan *reserved keyword*)."

#: ../../tutorial/errors.rst:66
msgid ""
"The rest of the line provides detail based on the type of exception and what"
" caused it."
msgstr ""
"Sisa baris menyediakan detail berdasarkan jenis pengecualian dan apa yang "
"menyebabkannya."

#: ../../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 ""
"Bagian sebelumnya dari pesan kesalahan menunjukkan konteks di mana "
"pengecualian terjadi, dalam bentuk *stack traceback*. Secara umum berisi "
"daftar baris sumber *stack traceback*; namun, ini tidak akan menampilkan "
"baris yang dibaca dari masukan standar."

#: ../../tutorial/errors.rst:74
msgid ""
":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ""
":ref:`bltin-exceptions` memberikan daftar pengecualian bawaan dan artinya."

#: ../../tutorial/errors.rst:80
msgid "Handling Exceptions"
msgstr "Menangani Pengecualian"

#: ../../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 ""
"Dimungkinkan untuk menulis program yang menangani pengecualian yang dipilih."
" Lihatlah contoh berikut, yang meminta masukan dari pengguna sampai integer "
"yang valid telah dimasukkan, tetapi memungkinkan pengguna untuk menghentikan"
" program (menggunakan :kbd:`Control-C` atau apa pun yang didukung sistem "
"operasi); perhatikan bahwa gangguan yang dibuat pengguna ditandai dengan "
"munculnya pengecualian :exc:`KeyboardInterrupt`. ::"

#: ../../tutorial/errors.rst:96
msgid "The :keyword:`try` statement works as follows."
msgstr "Pernyataan :keyword:`try` berfungsi sebagai berikut."

#: ../../tutorial/errors.rst:98
msgid ""
"First, the *try clause* (the statement(s) between the :keyword:`try` and "
":keyword:`except` keywords) is executed."
msgstr ""
"Pertama, *try clause* (pernyataan(-pernyataan) di antara kata kunci "
":keyword:`try` dan :keyword:`except`) dieksekusi."

#: ../../tutorial/errors.rst:101
msgid ""
"If no exception occurs, the *except clause* is skipped and execution of the "
":keyword:`try` statement is finished."
msgstr ""
"Jika tidak ada pengecualian terjadi, *except clause* dilewati dan eksekusi "
"pernyataan :keyword: `try` selesai."

#: ../../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 ""
"Jika pengecualian terjadi selama eksekusi klausa *try*, sisa klausa "
"dilewati. Kemudian jika jenisnya cocok dengan pengecualian yang dinamai "
"dengan kata kunci :keyword:`exception`, klausa *except* dioperasikan, dan "
"kemudian eksekusi berlanjut setelah pernyataan :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 ""
"Jika terjadi pengecualian yang tidak cocok dengan pengecualian yang "
"disebutkan dalam klausa kecuali, itu diteruskan ke luar pernyataan "
":keyword:`try`; jika tidak ada penangan yang ditemukan, ini adalah "
"*unhandled exception* dan eksekusi berhenti dengan pesan seperti yang "
"ditunjukkan di atas."

#: ../../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 ""
"Pernyataan :keyword:`try` mungkin memiliki lebih dari satu klausa *except*, "
"untuk menentukan penangan dari berbagai pengecualian. Paling banyak satu "
"penangan akan dieksekusi. Penangan hanya menangani pengecualian yang terjadi"
" pada klausa *try* yang sesuai, bukan pada penangan lain yang sama "
"pernyataan :keyword:`!try`. Klausa *except* dapat menyebutkan beberapa "
"pengecualian sebagai tanda kurung *tuple*, misalnya::"

#: ../../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 ""
"Kelas dalam klausa :keyword:`except` kompatibel dengan pengecualian jika itu"
" adalah kelas yang sama atau kelas basisnya (tapi bukan sebaliknya --- "
"sebuah klausa *except* dari daftar kelas turunan tidak kompatibel dengan "
"kelas). Misalnya, kode berikut akan mencetak B, C, D dalam urutan itu::"

#: ../../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 ""
"Perhatikan bahwa jika klausa *except* dibalik (dengan ``except B`` dahulu), "
"itu akan dicetak B, B, B --- pencocokan pertama klausa *except* dipicu."

#: ../../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 ""
"Klausa *except* terakhir dapat menghilangkan nama-(nama) pengecualian, untuk"
" berfungsi sebagai *wildcard*. Gunakan ini dengan sangat hati-hati, karena "
"mudah untuk menutupi kesalahan nyata pemrograman dengan cara ini! Ini juga "
"dapat digunakan untuk mencetak pesan kesalahan dan kemudian menimbulkan "
"kembali pengecualian (memungkinkan pemanggil untuk menangani pengecualian "
"juga) ::"

#: ../../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 ""
"Pernyataan :keyword:`try` ... :keywird:`except` memiliki opsi *else clause*,"
" yang, jika ada, harus mengikuti semua klausa *except*. Ini berguna untuk "
"kode yang harus dijalankan jika klausa *try* tidak menimbulkan pengecualian."
" Sebagai contoh::"

#: ../../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 ""
"Penggunaan klausa :keyword:`!else` lebih baik daripada menambahkan kode "
"tambahan ke klausa :keyword:`try` karena menghindari secara tidak sengaja "
"menangkap pengecualian yang tidak dimunculkan oleh kode yang dilindungi oleh"
" pernyataan :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 ""
"Ketika pengecualian terjadi, itu mungkin memiliki nilai terkait, juga "
"dikenal sebagai *argument* pengecualian. Kehadiran dan jenis argumen "
"tergantung pada jenis pengecualian."

#: ../../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 ""
"Klausa except dapat menentukan variabel setelah nama pengecualian. Variabel "
"terikat pada *instance* pengecualian dengan argumen yang disimpan dalam "
"``instance.args``. Untuk kenyamanan, *instance* pengecualian mendefinisikan "
":meth:`__str__` sehingga argumen dapat dicetak langsung tanpa harus merujuk "
"``.args``. Seseorang juga dapat membuat instansiasi pengecualian terlebih "
"dahulu sebelum menimbulkannya dan menambahkan atribut apa pun yang "
"diinginkan. ::"

#: ../../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 ""
"Jika pengecualian memiliki argumen, mereka dicetak sebagai bagian terakhir "
"('detail') dari pesan untuk pengecualian yang tidak ditangani."

#: ../../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 ""
"Penangan pengecualian tidak hanya menangani pengecualian jika mereka muncul "
"segera di klausa *try*, tetapi juga jika mereka terjadi di dalam fungsi yang"
" disebut (bahkan secara tidak langsung) di klausa *try*. Sebagai contoh::"

#: ../../tutorial/errors.rst:237
msgid "Raising Exceptions"
msgstr "Memunculkan Pengecualian"

#: ../../tutorial/errors.rst:239
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified "
"exception to occur. For example::"
msgstr ""
"Pernyataan :keyword:`raise` memungkinkan programmer untuk memaksa "
"pengecualian yang ditentukan terjadi. Sebagai contoh::"

#: ../../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 ""
"Satu-satunya argumen untuk :keyword:`raise` menunjukkan pengecualian yang "
"dimunculkan. Ini harus berupa *instance* pengecualian atau kelas "
"pengecualian (kelas yang berasal dari :class:`Exception`). Jika kelas "
"pengecualian dikirimkan, itu akan secara implisit diinstansiasi dengan "
"memanggil pembangunnya *constructor* tanpa argumen::"

#: ../../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 ""
"Jika Anda perlu menentukan apakah pengecualian muncul tetapi tidak bermaksud"
" menanganinya, bentuk yang lebih sederhana dari pernyataan :keyword:`raise` "
"memungkinkan Anda untuk memunculkan kembali pengecualian::"

#: ../../tutorial/errors.rst:273
msgid "User-defined Exceptions"
msgstr "Pengecualian yang Ditentukan Pengguna"

#: ../../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 ""
"Program dapat memberi nama pengecualian mereka sendiri dengan membuat kelas "
"pengecualian baru (lihat :ref:`tut-class` untuk informasi lebih lanjut "
"tentang kelas Python). Pengecualian biasanya berasal dari kelas "
":exc:`Exception`, baik secara langsung atau tidak langsung."

#: ../../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 ""
"Kelas pengecualian dapat didefinisikan yang melakukan apa saja yang dapat "
"dilakukan oleh kelas lain, tetapi biasanya tetap sederhana, seringkali hanya"
" menawarkan sejumlah atribut yang memungkinkan informasi tentang kesalahan "
"diekstraksi oleh penangan sebagai pengecualian. Saat membuat modul yang "
"dapat menimbulkan beberapa kesalahan berbeda, praktik yang umum adalah "
"membuat kelas dasar untuk pengecualian yang ditentukan oleh modul itu, dan "
"mensubkelaskan kelas itu untuk membuat kelas pengecualian khusus untuk "
"kondisi kesalahan yang berbeda::"

#: ../../tutorial/errors.rst:317
msgid ""
"Most exceptions are defined with names that end in \"Error\", similar to the"
" naming of the standard exceptions."
msgstr ""
"Sebagian besar pengecualian didefinisikan dengan nama yang diakhiri dengan "
"\"Error\", mirip dengan penamaan pengecualian standar."

#: ../../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 ""
"Banyak modul standar menentukan pengecualian mereka sendiri untuk melaporkan"
" kesalahan yang mungkin terjadi pada fungsi yang mereka tetapkan. Informasi "
"lebih lanjut tentang kelas disajikan dalam bab :ref:`tut-class`."

#: ../../tutorial/errors.rst:328
msgid "Defining Clean-up Actions"
msgstr "Mendefinisikan Tindakan Pembersihan"

#: ../../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 ""
"Pernyataan :keyword:`try` memiliki klausa opsional lain yang dimaksudkan "
"untuk menentukan tindakan pembersihan yang harus dijalankan dalam semua "
"keadaan. Sebagai contoh::"

#: ../../tutorial/errors.rst:344
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 ""
"Jika ada klausa :keyword:`finally`, klausa :keyword:`finally` akan "
"dieksekusi sebagai tugas terakhir sebelum pernyataan :keyword:`try` selesai."
" Klausa :keyword:`finally` dioperasikan meski pernyataan :keyword:`try` "
"menghasilkan pengecualian atau tidak. Poin-poin berikut membahas kasus yang "
"lebih kompleks ketika pengecualian terjadi:"

#: ../../tutorial/errors.rst:346
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 ""
"Jika pengecualian terjadi selama pelaksanaan klausa :keyword:`!try`, "
"pengecualian dapat ditangani oleh klausa :keyword:`except`. Jika "
"pengecualian tidak ditangani oleh klausa :keyword:`except`, pengecualian "
"akan muncul kembali setelah klausa :keyword:`!finally` telah dieksekusi."

#: ../../tutorial/errors.rst:348
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 ""
"Pengecualian dapat terjadi selama pelaksanaan klausa :keyword:`!except` atau"
" :keyword:`!else`. Sekali lagi, pengecualian akan muncul kembali setelah "
"klausa :keyword:`!finally` telah dieksekusi."

#: ../../tutorial/errors.rst:350
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 ""
"Jika pernyataan :keyword:`!try` mencapai pernyataan :keyword:`break`, "
":keyword:`continue` atau :keyword:`return`, kalimat :keyword:`finally` akan "
"dieksekusi tepat sebelum eksekusi pernyataan :keyword:`break`, "
":keyword:`continue` atau :keyword:`return`."

#: ../../tutorial/errors.rst:352
msgid ""
"If a :keyword:`finally` clause includes a :keyword:`return` statement, the "
":keyword:`finally` clause's :keyword:`return` statement will execute before,"
" and instead of, the :keyword:`return` statement in a :keyword:`try` clause."
msgstr ""
"Jika sebuah klausa :keyword:`finally` mencakup pernyataan :keyword:`return`,"
" pernyataan :keyword:`return` dari klausa :keyword:`finally` akan dieksekusi"
" sebelumnya, dan alih-alih, pernyataan :keyword:`return` dalam klausa "
":keyword:`try`."

#: ../../tutorial/errors.rst:354
msgid "For example::"
msgstr "Sebagai contoh::"

#: ../../tutorial/errors.rst:365
msgid "A more complicated example::"
msgstr "Contoh yang lebih rumit::"

#: ../../tutorial/errors.rst:390
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 ""
"Seperti yang Anda lihat, klausa :keyword:`finally` dieksekusi dalam "
"peristiwa apa pun. :exc:`TypeError` yang ditimbulkan dengan membagi dua "
"string tidak ditangani oleh klausa :keyword:`except` dan karenanya kembali "
"muncul setelah klausa :keyword:`!finally` telah dieksekusi."

#: ../../tutorial/errors.rst:395
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 ""
"Dalam aplikasi dunia nyata, klausa :keyword:`finally` berguna untuk "
"melepaskan sumber daya eksternal (seperti berkas atau koneksi jaringan), "
"terlepas dari apakah penggunaan sumber daya tersebut berhasil."

#: ../../tutorial/errors.rst:403
msgid "Predefined Clean-up Actions"
msgstr "Tindakan Pembersihan yang Sudah Ditentukan"

#: ../../tutorial/errors.rst:405
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 ""
"Beberapa objek mendefinisikan tindakan pembersihan standar yang harus "
"dilakukan ketika objek tidak lagi diperlukan, terlepas dari apakah operasi "
"menggunakan objek berhasil atau gagal. Lihatlah contoh berikut, yang mencoba"
" membuka berkas dan mencetak isinya ke layar. ::"

#: ../../tutorial/errors.rst:413
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 ""
"Masalah dengan kode ini adalah bahwa ia membiarkan berkas terbuka untuk "
"jumlah waktu yang tidak ditentukan setelah bagian kode ini selesai "
"dieksekusi. Ini bukan masalah dalam skrip sederhana, tetapi bisa menjadi "
"masalah untuk aplikasi yang lebih besar. Pernyataan :keyword:`with` "
"memungkinkan objek seperti berkas digunakan dengan cara yang memastikan "
"mereka selalu dibersihkan secepatnya dan dengan benar. ::"

#: ../../tutorial/errors.rst:423
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 ""
"Setelah pernyataan dieksekusi, file *f* selalu ditutup, bahkan jika ada "
"masalah saat pemrosesan baris-baris. Objek yang, seperti berkas-berkas, "
"memberikan tindakan pembersihan yang telah ditentukan, akan menunjukkan ini "
"dalam dokumentasinya."