# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001-2019, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # # Translators: # oon arfiandwi , 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 , 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 `, 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 " "`, 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 " "` 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 ` 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 `_ 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 " "`_ 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."