introduction.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.
# 
# 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-01 14:24+0000\n"
"PO-Revision-Date: 2017-02-16 23:41+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/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr "Pengantar Informal Tentang Python"

#: ../../tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears;"
" lines that do not begin with a prompt are output from the interpreter. Note"
" that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
"Dalam contoh berikut, masukan dan keluaran dibedakan dengan ada atau "
"tidaknya prompt (:term:`>>>` dan :term:`...`): untuk mengulangi contoh, Anda"
" harus mengetikkan semuanya setelah prompt, saat prompt muncul; baris yang "
"tidak dimulai dengan prompt adalah output dari interpreter. Perhatikan bahwa"
" baris yang hanya berisi prompt sekunder dalam contoh berarti Anda harus "
"mengetikkan baris kosong; ini digunakan untuk mengakhiri perintah multi-"
"baris."

#: ../../tutorial/introduction.rst:16
msgid ""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments.  Comments in Python start with the hash character,"
" ``#``, and extend to the end of the physical line.  A comment may appear at"
" the start of a line or following whitespace or code, but not within a "
"string literal.  A hash character within a string literal is just a hash "
"character. Since comments are to clarify code and are not interpreted by "
"Python, they may be omitted when typing in examples."
msgstr ""
"Banyak contoh dalam manual ini, bahkan yang dimasukkan pada prompt "
"interaktif, termasuk komentar. Komentar dalam Python dimulai dengan karakter"
" hash, ``#``, dan diperluas hingga akhir garis fisik. Sebuah komentar dapat "
"muncul di awal baris atau mengikuti spasi atau kode, tetapi tidak dalam "
"string literal. Karakter hash dalam string literal hanyalah karakter hash. "
"Karena komentar adalah untuk mengklarifikasi kode dan tidak ditafsirkan oleh"
" Python, mereka dapat dihilangkan saat mengetikkan contoh."

#: ../../tutorial/introduction.rst:24
msgid "Some examples::"
msgstr "Beberapa contoh::"

#: ../../tutorial/introduction.rst:35
msgid "Using Python as a Calculator"
msgstr "Menggunakan Python sebagai Kalkulator"

#: ../../tutorial/introduction.rst:37
msgid ""
"Let's try some simple Python commands.  Start the interpreter and wait for "
"the primary prompt, ``>>>``.  (It shouldn't take long.)"
msgstr ""
"Mari kita coba beberapa perintah Python sederhana. Mulai interpreter dan "
"tunggu prompt utama, ``>>>``. (Seharusnya tidak butuh waktu lama.)"

#: ../../tutorial/introduction.rst:44
msgid "Numbers"
msgstr "Angka"

#: ../../tutorial/introduction.rst:46
msgid ""
"The interpreter acts as a simple calculator: you can type an expression at "
"it and it will write the value.  Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` work just like in most other "
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
"grouping. For example::"
msgstr ""
"Interpreter bertindak sebagai kalkulator sederhana: Anda dapat mengetikkan "
"ekspresi padanya dan itu akan menulis nilainya. Sintaksis ekspresi mudah: "
"operator ``+``, ``-``, ``*`` dan ``/`` berfungsi seperti di sebagian besar "
"bahasa lain (misalnya, Pascal atau C); tanda kurung (``()``) dapat digunakan"
" untuk pengelompokan. Sebagai contoh::"

#: ../../tutorial/introduction.rst:61
msgid ""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type "
":class:`float`.  We will see more about numeric types later in the tutorial."
msgstr ""
"Bilangan bulat (mis. ``2``, ``4``, ``20``) memiliki tipe :class:`int`, yang "
"memiliki bagian pecahan (mis.``5.0``,``1.6``) memiliki tipe :class:`float`. "
"Kita akan melihat lebih banyak tentang tipe bilangan nanti dalam tutorial."

#: ../../tutorial/introduction.rst:65
msgid ""
"Division (``/``) always returns a float.  To do :term:`floor division` and "
"get an integer result (discarding any fractional result) you can use the "
"``//`` operator; to calculate the remainder you can use ``%``::"
msgstr ""
"Division (``/``) selalu mengembalikan float atau bilangan pecahan. Untuk "
"melakukan :term:`floor division` dan mendapatkan hasil integer atau bilangan"
" bulat (menghilangkan hasil pecahannya) Anda dapat menggunakan operator "
"``//``; untuk menghitung sisanya Anda dapat menggunakan ``%``::"

#: ../../tutorial/introduction.rst:79
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr ""
"Dengan Python, dimungkinkan untuk menggunakan operator ``**`` untuk "
"menghitung pemangkatan [#]_::"

#: ../../tutorial/introduction.rst:86
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr ""
"Tanda sama dengan (``=``) digunakan untuk memberikan nilai ke variabel. "
"Setelah itu, tidak ada hasil yang ditampilkan sebelum prompt interaktif "
"berikutnya::"

#: ../../tutorial/introduction.rst:94
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
"Jika variabel tidak \"didefinisikan\" (diberi nilai), mencoba menggunakannya"
" akan menghasilkan kesalahan::"

#: ../../tutorial/introduction.rst:102
msgid ""
"There is full support for floating point; operators with mixed type operands"
" convert the integer operand to floating point::"
msgstr ""
"Ada dukungan penuh untuk floating point; operator dengan operan tipe "
"campuran akan mengubah operan integer ke floating point::"

#: ../../tutorial/introduction.rst:108
msgid ""
"In interactive mode, the last printed expression is assigned to the variable"
" ``_``.  This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr ""
"Dalam mode interaktif, ekspresi cetak terakhir diberikan ke variabel ``_``. "
"Ini berarti bahwa ketika Anda menggunakan Python sebagai kalkulator meja, "
"agak lebih mudah untuk melanjutkan perhitungan, misalnya::"

#: ../../tutorial/introduction.rst:121
msgid ""
"This variable should be treated as read-only by the user.  Don't explicitly "
"assign a value to it --- you would create an independent local variable with"
" the same name masking the built-in variable with its magic behavior."
msgstr ""
"Variabel ini harus diperlakukan sebagai baca-saja oleh pengguna. Jangan "
"secara eksplisit memberikan nilai padanya --- Anda akan membuat variabel "
"lokal independen dengan nama yang sama menutupi variabel bawaan dengan "
"perilaku saktinya."

#: ../../tutorial/introduction.rst:125
msgid ""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` and "
":class:`~fractions.Fraction`. Python also has built-in support for "
":ref:`complex numbers <typesnumeric>`, and uses the ``j`` or ``J`` suffix to"
" indicate the imaginary part (e.g. ``3+5j``)."
msgstr ""
"Selain :class:`int` dan :class:` float`, Python mendukung tipe angka "
"lainnya, seperti :class:`~decimal.Decimal` dan :class:`~fractions.Fraction`."
" Python juga memiliki dukungan bawaan untuk :ref:`complex numbers "
"<typesnumeric>`, dan menggunakan akhiran ``j`` atau ``J`` untuk menunjukkan "
"bagian imajiner (mis. ``3+5j``)."

#: ../../tutorial/introduction.rst:135
msgid "Strings"
msgstr "String"

#: ../../tutorial/introduction.rst:137
msgid ""
"Besides numbers, Python can also manipulate strings, which can be expressed "
"in several ways.  They can be enclosed in single quotes (``'...'``) or "
"double quotes (``\"...\"``) with the same result [#]_.  ``\\`` can be used "
"to escape quotes::"
msgstr ""
"Selain angka, Python juga dapat memanipulasi string atau teks, yang dapat "
"diekspresikan dalam beberapa cara. Mereka dapat disertakan dalam tanda kutip"
" tunggal (``'...'``) atau tanda kutip ganda (``\"...\"``) dengan hasil yang "
"sama [#]_. ``\\`` dapat digunakan untuk keluar dari kutipan::"

#: ../../tutorial/introduction.rst:155
msgid ""
"In the interactive interpreter, the output string is enclosed in quotes and "
"special characters are escaped with backslashes.  While this might sometimes"
" look different from the input (the enclosing quotes could change), the two "
"strings are equivalent.  The string is enclosed in double quotes if the "
"string contains a single quote and no double quotes, otherwise it is "
"enclosed in single quotes.  The :func:`print` function produces a more "
"readable output, by omitting the enclosing quotes and by printing escaped "
"and special characters::"
msgstr ""
"Dalam interpreter interaktif, string keluaran diapit dengan tanda kutip dan "
"karakter khusus dipisahkan dengan garis miring terbalik. Meskipun ini "
"kadang-kadang terlihat berbeda dari input (tanda kutip terlampir dapat "
"berubah), kedua string tersebut setara. String disertakan dalam tanda kutip "
"ganda jika string berisi kutipan tunggal dan tidak ada tanda kutip ganda, "
"jika tidak maka akan dilampirkan dalam tanda kutip tunggal. Fungsi "
":func:`print` menghasilkan keluaran yang lebih mudah dibaca, dengan "
"menghilangkan tanda kutip terlampir dan dengan mencetak karakter yang "
"dipisahkan dan spesial::"

#: ../../tutorial/introduction.rst:175
msgid ""
"If you don't want characters prefaced by ``\\`` to be interpreted as special"
" characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr ""
"Jika Anda tidak ingin karakter yang diawali dengan ``\\`` ditafsirkan "
"sebagai karakter khusus, Anda dapat menggunakan *raw strings* dengan "
"menambahkan ``r`` sebelum kutipan pertama::"

#: ../../tutorial/introduction.rst:185
msgid ""
"String literals can span multiple lines.  One way is using triple-quotes: "
"``\"\"\"...\"\"\"`` or ``'''...'''``.  End of lines are automatically "
"included in the string, but it's possible to prevent this by adding a ``\\``"
" at the end of the line.  The following example::"
msgstr ""
"String literal dapat melebar hingga beberapa baris. Salah satu caranya "
"adalah dengan menggunakan tanda kutip tiga: ``\"\"\"...\"\"\"`` atau "
"``'''...'''``. Akhir baris secara otomatis termasuk dalam string, tetapi "
"dimungkinkan untuk mencegahnya dengan menambahkan ``\\`` di akhir baris. "
"Contoh berikut::"

#: ../../tutorial/introduction.rst:196
msgid ""
"produces the following output (note that the initial newline is not "
"included):"
msgstr ""
"menghasilkan keluaran berikut (perhatikan bahwa awal baris baru tidak "
"termasuk):"

#: ../../tutorial/introduction.rst:204
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr ""
"String dapat digabungkan (direkatkan) dengan operator ``+``, dan diulangi "
"dengan ``*``::"

#: ../../tutorial/introduction.rst:211
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr ""
"Dua atau lebih *string literals* (yaitu yang terlampir di antara tanda "
"kutip) di sebelah satu sama lain secara otomatis digabungkan. ::"

#: ../../tutorial/introduction.rst:217
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr "Fitur ini sangat berguna ketika Anda ingin memecah string panjang::"

#: ../../tutorial/introduction.rst:224
msgid ""
"This only works with two literals though, not with variables or "
"expressions::"
msgstr ""
"Ini hanya bekerja dengan dua literal, tidak dengan variabel atau ekspresi::"

#: ../../tutorial/introduction.rst:238
msgid ""
"If you want to concatenate variables or a variable and a literal, use "
"``+``::"
msgstr ""
"Jika Anda ingin menggabungkan variabel atau variabel dan literal, gunakan "
"``+``::"

#: ../../tutorial/introduction.rst:243
msgid ""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string"
" of size one::"
msgstr ""
"String dapat diindeks atau *indexed* (disandikan), dengan karakter pertama "
"memiliki indeks 0. Tidak ada tipe karakter yang terpisah; sebuah karakter "
"hanyalah sebuah string berukuran satu::"

#: ../../tutorial/introduction.rst:253
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr ""
"Indeks juga bisa berupa angka negatif, untuk mulai menghitung dari kanan::"

#: ../../tutorial/introduction.rst:262
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr ""
"Perhatikan bahwa karena -0 sama dengan 0, indeks negatif mulai dari -1."

#: ../../tutorial/introduction.rst:264
msgid ""
"In addition to indexing, *slicing* is also supported.  While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr ""
"Selain pengindeksan, *slicing* atau mengiris juga didukung. Sementara "
"pengindeksan digunakan untuk mendapatkan karakter individual, *slicing* "
"memungkinkan Anda untuk mendapatkan substring::"

#: ../../tutorial/introduction.rst:272
msgid ""
"Note how the start is always included, and the end always excluded.  This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr ""
"Perhatikan bagaimana awal selalu disertakan, dan akhirnya selalu "
"dikecualikan. Ini memastikan bahwa ``s[:i] + s[i:]`` selalu sama dengan "
"``s``::"

#: ../../tutorial/introduction.rst:280
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero,"
" an omitted second index defaults to the size of the string being sliced. ::"
msgstr ""
"Indeks irisan memiliki nilai bawaan yang berguna; indeks pertama yang hilang"
" akan digantikan ke nilai nol, indeks kedua yang hilang akan digantikan ke "
"nilai ukuran atau panjang string yang diiris. ::"

#: ../../tutorial/introduction.rst:290
msgid ""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr ""
"Salah satu cara untuk mengingat bagaimana irisan bekerja adalah dengan "
"menganggap indeks sebagai menunjuk *between* karakter, dengan tepi kiri "
"karakter pertama bernomor 0. Kemudian tepi kanan karakter terakhir dari "
"string *n* karakter memiliki indeks *n*, misalnya::"

#: ../../tutorial/introduction.rst:301
msgid ""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and"
" *j*, respectively."
msgstr ""
"Baris pertama angka memberikan posisi indeks 0...6 dalam string; baris kedua"
" memberikan indeks negatif yang sesuai. Irisan dari *i* ke *j* terdiri dari "
"semua karakter di antara kedua sisi yang berlabel *i* dan *j*."

#: ../../tutorial/introduction.rst:306
msgid ""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds.  For example, the length of "
"``word[1:3]`` is 2."
msgstr ""
"Untuk indeks non-negatif, panjang irisan adalah selisih indeks, jika "
"keduanya berada dalam batas. Misalnya, panjang ``word[1:3]`` adalah 2."

#: ../../tutorial/introduction.rst:310
msgid "Attempting to use an index that is too large will result in an error::"
msgstr ""
"Mencoba menggunakan indeks yang terlalu besar akan menghasilkan kesalahan::"

#: ../../tutorial/introduction.rst:317
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
"Namun, indeks irisan di luar jangkauan ditangani dengan anggun ketika "
"digunakan untuk mengiris::"

#: ../../tutorial/introduction.rst:325
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr ""
"String python tidak dapat diubah --- mereka adalah :term:`immutable`. Oleh "
"karena itu, menetapkan ke suatu indeks posisi dalam string menghasilkan "
"kesalahan::"

#: ../../tutorial/introduction.rst:337
msgid "If you need a different string, you should create a new one::"
msgstr ""
"Jika Anda membutuhkan string yang berbeda, Anda harus membuat yang baru::"

#: ../../tutorial/introduction.rst:344
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "Fungsi bawaan :func:`len` mengembalikan panjang string::"

#: ../../tutorial/introduction.rst:355
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"

#: ../../tutorial/introduction.rst:354
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
"String adalah contoh *sequence types* atau jenis urutan, dan mendukung "
"operasi umum yang didukung oleh jenis tersebut."

#: ../../tutorial/introduction.rst:359
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"

#: ../../tutorial/introduction.rst:358
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr ""
"String mendukung sejumlah besar metode untuk transformasi dasar dan "
"pencarian."

#: ../../tutorial/introduction.rst:362
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"

#: ../../tutorial/introduction.rst:362
msgid "String literals that have embedded expressions."
msgstr "String literal yang memiliki ekspresi yang tersemat."

#: ../../tutorial/introduction.rst:365
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"

#: ../../tutorial/introduction.rst:365
msgid "Information about string formatting with :meth:`str.format`."
msgstr "Informasi tentang pemformatan string dengan :meth:`str.format`."

#: ../../tutorial/introduction.rst:368
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"

#: ../../tutorial/introduction.rst:368
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr ""
"Operasi pemformatan lama dipanggil ketika string adalah operan kiri dari "
"operator ``%`` dijelaskan secara lebih rinci di sini."

#: ../../tutorial/introduction.rst:375
msgid "Lists"
msgstr "List"

#: ../../tutorial/introduction.rst:377
msgid ""
"Python knows a number of *compound* data types, used to group together other"
" values.  The most versatile is the *list*, which can be written as a list "
"of comma-separated values (items) between square brackets.  Lists might "
"contain items of different types, but usually the items all have the same "
"type. ::"
msgstr ""
"Python mengetahui sejumlah tipe data *compound* atau gabungan, yang "
"digunakan untuk mengelompokkan nilai-nilai lainnya. Yang paling serbaguna "
"adalah *list*, yang dapat ditulis sebagai daftar nilai yang dipisahkan koma "
"(item) antara tanda kurung siku. List atau daftar mungkin berisi item dari "
"tipe yang berbeda, tetapi biasanya semua item memiliki tipe yang sama. ::"

#: ../../tutorial/introduction.rst:386
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr ""
"Seperti string (dan semua bawaan lainnya tipe :term:`sequence`), list atau "
"daftar tersebut dapat diindeks dan diiris::"

#: ../../tutorial/introduction.rst:396
msgid ""
"All slice operations return a new list containing the requested elements.  "
"This means that the following slice returns a :ref:`shallow copy "
"<shallow_vs_deep_copy>` of the list::"
msgstr ""
"Semua operasi iris mengembalikan list atau daftar baru yang berisi elemen "
"yang diminta. Ini berarti bahwa irisan berikut mengembalikan :ref:`shallow "
"copy <shallow_vs_deep_copy>` dari list::"

#: ../../tutorial/introduction.rst:403
msgid "Lists also support operations like concatenation::"
msgstr "List atau daftar juga mendukung operasi seperti perangkaian::"

#: ../../tutorial/introduction.rst:408
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr ""
"Tidak seperti string, yang :term:`immutable`, list adalah :term:`mutable`, "
"mis. dimungkinkan untuk mengubah kontennya::"

#: ../../tutorial/introduction.rst:418
msgid ""
"You can also add new items at the end of the list, by using the "
":meth:`~list.append` *method* (we will see more about methods later)::"
msgstr ""
"Anda juga dapat menambahkan item baru di akhir list, dengan menggunakan "
"*method* :meth:`~list.append` (kita akan melihat lebih banyak tentang metode"
" nanti)::"

#: ../../tutorial/introduction.rst:426
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
"Pemberian nilai untuk irisan juga dimungkinkan, dan ini bahkan dapat "
"mengubah ukuran list atau menghapus seluruhnya::"

#: ../../tutorial/introduction.rst:445
msgid "The built-in function :func:`len` also applies to lists::"
msgstr "Fungsi bawaan :func:`len` juga berlaku untuk list::"

#: ../../tutorial/introduction.rst:451
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr ""
"Dimungkinkan untuk membuat list atau daftar bersarang (membuat daftar yang "
"berisi daftar lain), misalnya::"

#: ../../tutorial/introduction.rst:467
msgid "First Steps Towards Programming"
msgstr "Langkah Awal Menuju Pemrograman"

#: ../../tutorial/introduction.rst:469
msgid ""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together.  For instance, we can write an initial sub-sequence of the "
"`Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_number>`_ as "
"follows::"
msgstr ""
"Tentu saja, kita bisa menggunakan Python untuk tugas yang lebih rumit "
"daripada menambahkan dua dan dua bersamaan. Sebagai contoh, kita dapat "
"menulis awal dari sub-urutan `Fibonacci series "
"<https://en.wikipedia.org/wiki/Fibonacci_number>`_ sebagai berikut::"

#: ../../tutorial/introduction.rst:489
msgid "This example introduces several new features."
msgstr "Contoh ini memperkenalkan beberapa fitur baru."

#: ../../tutorial/introduction.rst:491
msgid ""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1.  On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place.  The right-"
"hand side expressions are evaluated  from the left to the right."
msgstr ""
"Baris pertama berisi *multiple assignment*: variabel ``a`` dan ``b`` secara "
"bersamaan mendapatkan nilai-nilai baru 0 dan 1. Pada baris terakhir ini "
"digunakan lagi, menunjukkan bahwa ekspresi di sisi sebelah kanan, semua "
"dievaluasi terlebih dahulu sebelum salah satu pemberian nilai berlangsung. "
"Ekspresi sisi kanan dievaluasi dari kiri ke kanan."

#: ../../tutorial/introduction.rst:497
msgid ""
"The :keyword:`while` loop executes as long as the condition (here: ``a < "
"10``) remains true.  In Python, like in C, any non-zero integer value is "
"true; zero is false.  The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false.  The test used in the example is a simple comparison.  The "
"standard comparison operators are written the same as in C: ``<`` (less "
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
"Perulangan :keyword:`while` dieksekusi selama kondisi (di sini: ``a < 10``) "
"masih benar. Dalam Python, seperti dalam C, nilai integer bukan nol bernilai"
" benar; nol itu bernilai salah. Kondisi ini juga bisa berupa nilai string "
"atau daftar, sebenarnya urutan apa pun; apapun dengan panjang yang tidak nol"
" bernilai benar, urutan kosong bernilai salah. Tes yang digunakan dalam "
"contoh adalah perbandingan sederhana. Operator perbandingan standar ditulis "
"sama seperti dalam C: ``<`` (kurang dari), ``>`` (lebih besar dari), ``==`` "
"(sama dengan), ``<=`` ( kurang dari atau sama dengan), ``>=`` (lebih besar "
"atau sama dengan) dan ``!=`` (tidak sama dengan)."

#: ../../tutorial/introduction.rst:506
msgid ""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements.  At the interactive prompt, you have to type a tab or "
"space(s) for each indented line.  In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility.  When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line).  Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
"*body* dari pengulangan adalah *indentasi*: indentasi adalah cara Python "
"untuk pengelompokan pernyataan. Pada prompt interaktif, Anda harus "
"mengetikkan tab atau spasi(-spasi) untuk setiap baris yang diberikan "
"indentasi. Dalam praktiknya Anda akan menyiapkan masukan yang lebih rumit "
"untuk Python dengan editor teks; semua editor teks yang baik memiliki "
"fasilitas indentasi otomatis. Ketika pernyataan majemuk dimasukkan secara "
"interaktif, harus diikuti oleh baris kosong untuk menunjukkan penyelesaian "
"(karena pengurai tidak dapat menebak kapan Anda mengetik baris terakhir). "
"Perhatikan bahwa setiap baris dalam blok dasar harus diindentasi dengan "
"jumlah yang sama."

#: ../../tutorial/introduction.rst:515
msgid ""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating point quantities, and strings.  Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
"Fungsi :func:`print` menulis nilai argumen(-argumen) yang diberikan. Ini "
"berbeda dari hanya menulis ekspresi yang ingin Anda tulis (seperti yang kami"
" lakukan sebelumnya dalam contoh kalkulator) dalam cara menangani beberapa "
"argumen, jumlah floating point, dan string. String dicetak tanpa tanda "
"kutip, dan spasi dimasukkan di antara item, sehingga Anda dapat memformat "
"sesuatu dengan baik, seperti ini::"

#: ../../tutorial/introduction.rst:526
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr ""
"Argumen kata kunci *end* dapat digunakan untuk menghindari baris baru "
"setelah keluaran, atau mengakhiri keluaran dengan string yang berbeda::"

#: ../../tutorial/introduction.rst:538
msgid "Footnotes"
msgstr "Catatan kaki"

#: ../../tutorial/introduction.rst:539
msgid ""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted"
" as ``-(3**2)`` and thus result in ``-9``.  To avoid this and get ``9``, you"
" can use ``(-3)**2``."
msgstr ""
"Karena ``**`` memiliki prioritas lebih tinggi dari ``-``, ``-3**2`` akan "
"ditafsirkan sebagai ``-(3**2)`` dan karenanya menghasilkan ``-9``. Untuk "
"menghindari ini dan mendapatkan ``9``, Anda dapat menggunakan ``(-3)**2``."

#: ../../tutorial/introduction.rst:543
msgid ""
"Unlike other languages, special characters such as ``\\n`` have the same "
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
"Tidak seperti bahasa lain, karakter khusus seperti ``\\n`` memiliki arti "
"yang sama dengan kedua tanda kutip tunggal (``'...'``) dan ganda "
"(``\"...\"``). Satu-satunya perbedaan antara keduanya adalah bahwa dalam "
"tanda kutip tunggal Anda tidak perlu memisahkan ``\"`` (tetapi Anda harus "
"memisahkan ``\\'``) dan sebaliknya."