# 3. Pengantar Informal Tentang Python

Dalam contoh berikut, masukan dan keluaran dibedakan dengan ada atau tidaknya prompt (>>> dan ...): 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.

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.

Beberapa contoh:

    # this is the first comment
    spam = 1  # and this is the second comment
              # ... and now a third!
    text = "# This is not a comment because it's inside quotes."

## 3.1. Menggunakan Python sebagai Kalkulator

Mari kita coba beberapa perintah Python sederhana. Mulai interpreter dan tunggu prompt utama, `>>>`. (Seharusnya tidak butuh waktu lama.)

### 3.1.1. Angka

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:

    >>> 2 + 2
    4
    >>> 50 - 5*6
    20
    >>> (50 - 5*6) / 4
    5.0
    >>> 8 / 5  # division always returns a floating point number
    1.6

Bilangan bulat (mis. `2`, `4`, `20`) memiliki tipe `int`, yang memiliki bagian pecahan (mis.``5.0``,``1.6``) memiliki tipe `float`. Kita akan melihat lebih banyak tentang tipe bilangan nanti dalam tutorial.

Division (`/`) selalu mengembalikan float atau bilangan pecahan. Untuk melakukan floor division dan mendapatkan hasil integer atau bilangan bulat (menghilangkan hasil pecahannya) Anda dapat menggunakan operator `//`; untuk menghitung sisanya Anda dapat menggunakan `%`:

    >>> 17 / 3  # classic division returns a float
    5.666666666666667
    >>>
    >>> 17 // 3  # floor division discards the fractional part
    5
    >>> 17 % 3  # the % operator returns the remainder of the division
    2
    >>> 5 * 3 + 2  # result * divisor + remainder
    17

Dengan Python, dimungkinkan untuk menggunakan operator `**` untuk menghitung pemangkatan 1:

    >>> 5 ** 2  # 5 squared
    25
    >>> 2 ** 7  # 2 to the power of 7
    128

Tanda sama dengan (`=`) digunakan untuk memberikan nilai ke variabel. Setelah itu, tidak ada hasil yang ditampilkan sebelum prompt interaktif berikutnya:

    >>> width = 20
    >>> height = 5 * 9
    >>> width * height
    900

Jika variabel tidak "didefinisikan" (diberi nilai), mencoba menggunakannya akan menghasilkan kesalahan:

    >>> n  # try to access an undefined variable
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'n' is not defined

Ada dukungan penuh untuk floating point; operator dengan operan tipe campuran akan mengubah operan integer ke floating point:

    >>> 4 * 3.75 - 1
    14.0

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:

    >>> tax = 12.5 / 100
    >>> price = 100.50
    >>> price * tax
    12.5625
    >>> price + _
    113.0625
    >>> round(_, 2)
    113.06

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.

Selain `int` dan :class:` float`, Python mendukung tipe angka lainnya, seperti `Decimal` dan `Fraction`. Python juga memiliki dukungan bawaan untuk complex numbers, dan menggunakan akhiran `j` atau `J` untuk menunjukkan bagian imajiner (mis. `3+5j`).

### 3.1.2. String

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 2. `\` dapat digunakan untuk keluar dari kutipan:

    >>> 'spam eggs'  # single quotes
    'spam eggs'
    >>> 'doesn\'t'  # use \' to escape the single quote...
    "doesn't"
    >>> "doesn't"  # ...or use double quotes instead
    "doesn't"
    >>> '"Yes," they said.'
    '"Yes," they said.'
    >>> "\"Yes,\" they said."
    '"Yes," they said.'
    >>> '"Isn\'t," they said.'
    '"Isn\'t," they said.'

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 `print()` menghasilkan keluaran yang lebih mudah dibaca, dengan menghilangkan tanda kutip terlampir dan dengan mencetak karakter yang dipisahkan dan spesial:

    >>> '"Isn\'t," they said.'
    '"Isn\'t," they said.'
    >>> print('"Isn\'t," they said.')
    "Isn't," they said.
    >>> s = 'First line.\nSecond line.'  # \n means newline
    >>> s  # without print(), \n is included in the output
    'First line.\nSecond line.'
    >>> print(s)  # with print(), \n produces a new line
    First line.
    Second line.

Jika Anda tidak ingin karakter yang diawali dengan `\` ditafsirkan sebagai karakter khusus, Anda dapat menggunakan raw strings dengan menambahkan `r` sebelum kutipan pertama:

    >>> print('C:\some\name')  # here \n means newline!
    C:\some
    ame
    >>> print(r'C:\some\name')  # note the r before the quote
    C:\some\name

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:

    print("""\
    Usage: thingy [OPTIONS]
         -h                        Display this usage message
         -H hostname               Hostname to connect to
    """)

menghasilkan keluaran berikut (perhatikan bahwa awal baris baru tidak termasuk):

    Usage: thingy [OPTIONS]
         -h                        Display this usage message
         -H hostname               Hostname to connect to

String dapat digabungkan (direkatkan) dengan operator `+`, dan diulangi dengan `*`:

    >>> # 3 times 'un', followed by 'ium'
    >>> 3 * 'un' + 'ium'
    'unununium'

Dua atau lebih string literals (yaitu yang terlampir di antara tanda kutip) di sebelah satu sama lain secara otomatis digabungkan.

    >>> 'Py' 'thon'
    'Python'

Fitur ini sangat berguna ketika Anda ingin memecah string panjang:

    >>> text = ('Put several strings within parentheses '
    ...         'to have them joined together.')
    >>> text
    'Put several strings within parentheses to have them joined together.'

Ini hanya bekerja dengan dua literal, tidak dengan variabel atau ekspresi:

    >>> prefix = 'Py'
    >>> prefix 'thon'  # can't concatenate a variable and a string literal
      ...
    SyntaxError: invalid syntax
    >>> ('un' * 3) 'ium'
      ...
    SyntaxError: invalid syntax

Jika Anda ingin menggabungkan variabel atau variabel dan literal, gunakan `+`:

    >>> prefix + 'thon'
    'Python'

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:

    >>> word = 'Python'
    >>> word[0]  # character in position 0
    'P'
    >>> word[5]  # character in position 5
    'n'

Indeks juga bisa berupa angka negatif, untuk mulai menghitung dari kanan:

    >>> word[-1]  # last character
    'n'
    >>> word[-2]  # second-last character
    'o'
    >>> word[-6]
    'P'

Perhatikan bahwa karena -0 sama dengan 0, indeks negatif mulai dari -1.

Selain pengindeksan, slicing atau mengiris juga didukung. Sementara pengindeksan digunakan untuk mendapatkan karakter individual, slicing memungkinkan Anda untuk mendapatkan substring:

    >>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
    'Py'
    >>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
    'tho'

Perhatikan bagaimana awal selalu disertakan, dan akhirnya selalu dikecualikan. Ini memastikan bahwa `s[:i] + s[i:]` selalu sama dengan `s`:

    >>> word[:2] + word[2:]
    'Python'
    >>> word[:4] + word[4:]
    'Python'

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.

    >>> word[:2]   # character from the beginning to position 2 (excluded)
    'Py'
    >>> word[4:]   # characters from position 4 (included) to the end
    'on'
    >>> word[-2:]  # characters from the second-last (included) to the end
    'on'

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:

     +---+---+---+---+---+---+
     | P | y | t | h | o | n |
     +---+---+---+---+---+---+
     0   1   2   3   4   5   6
    -6  -5  -4  -3  -2  -1

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.

Untuk indeks non-negatif, panjang irisan adalah selisih indeks, jika keduanya berada dalam batas. Misalnya, panjang `word[1:3]` adalah 2.

Mencoba menggunakan indeks yang terlalu besar akan menghasilkan kesalahan:

    >>> word[42]  # the word only has 6 characters
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    IndexError: string index out of range

Namun, indeks irisan di luar jangkauan ditangani dengan anggun ketika digunakan untuk mengiris:

    >>> word[4:42]
    'on'
    >>> word[42:]
    ''

String python tidak dapat diubah --- mereka adalah immutable. Oleh karena itu, menetapkan ke suatu indeks posisi dalam string menghasilkan kesalahan:

    >>> word[0] = 'J'
      ...
    TypeError: 'str' object does not support item assignment
    >>> word[2:] = 'py'
      ...
    TypeError: 'str' object does not support item assignment

Jika Anda membutuhkan string yang berbeda, Anda harus membuat yang baru:

    >>> 'J' + word[1:]
    'Jython'
    >>> word[:2] + 'py'
    'Pypy'

Fungsi bawaan `len()` mengembalikan panjang string:

    >>> s = 'supercalifragilisticexpialidocious'
    >>> len(s)
    34

Lihat juga

Text Sequence Type --- str

  String adalah contoh sequence types atau jenis urutan, dan mendukung operasi umum yang didukung oleh jenis tersebut.

String Methods

  String mendukung sejumlah besar metode untuk transformasi dasar dan pencarian.

Formatted string literals

  String literal yang memiliki ekspresi yang tersemat.

Format String Syntax

  Informasi tentang pemformatan string dengan `str.format()`.

printf-style String Formatting

  Operasi pemformatan lama dipanggil ketika string adalah operan kiri dari operator `%` dijelaskan secara lebih rinci di sini.

### 3.1.3. List

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 (items) antara tanda kurung siku. List atau daftar mungkin berisi items dari tipe yang berbeda, tetapi biasanya semua items memiliki tipe yang sama.

    >>> squares = [1, 4, 9, 16, 25]
    >>> squares
    [1, 4, 9, 16, 25]

Like strings (and all other built-in sequence type), lists can be indexed and sliced:

    >>> squares[0]  # indexing returns the item
    1
    >>> squares[-1]
    25
    >>> squares[-3:]  # slicing returns a new list
    [9, 16, 25]

All slice operations return a new list containing the requested elements. This means that the following slice returns a new (shallow) copy of the list:

    >>> squares[:]
    [1, 4, 9, 16, 25]

List atau daftar juga mendukung operasi seperti perangkaian:

    >>> squares + [36, 49, 64, 81, 100]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Tidak seperti string, yang immutable, list adalah mutable, mis. dimungkinkan untuk mengubah kontennya:

    >>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
    >>> 4 ** 3  # the cube of 4 is 64, not 65!
    64
    >>> cubes[3] = 64  # replace the wrong value
    >>> cubes
    [1, 8, 27, 64, 125]

Anda juga dapat menambahkan items baru di akhir list, dengan menggunakan method `append()` (kita akan melihat lebih banyak tentang metode nanti):

    >>> cubes.append(216)  # add the cube of 6
    >>> cubes.append(7 ** 3)  # and the cube of 7
    >>> cubes
    [1, 8, 27, 64, 125, 216, 343]

Pemberian nilai untuk irisan juga dimungkinkan, dan ini bahkan dapat mengubah ukuran list atau menghapus seluruhnya:

    >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> letters
    ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> # replace some values
    >>> letters[2:5] = ['C', 'D', 'E']
    >>> letters
    ['a', 'b', 'C', 'D', 'E', 'f', 'g']
    >>> # now remove them
    >>> letters[2:5] = []
    >>> letters
    ['a', 'b', 'f', 'g']
    >>> # clear the list by replacing all the elements with an empty list
    >>> letters[:] = []
    >>> letters
    []

Fungsi bawaan `len()` juga berlaku untuk list:

    >>> letters = ['a', 'b', 'c', 'd']
    >>> len(letters)
    4

Dimungkinkan untuk membuat list atau daftar bersarang (membuat daftar yang berisi daftar lain), misalnya:

    >>> a = ['a', 'b', 'c']
    >>> n = [1, 2, 3]
    >>> x = [a, n]
    >>> x
    [['a', 'b', 'c'], [1, 2, 3]]
    >>> x[0]
    ['a', 'b', 'c']
    >>> x[0][1]
    'b'

## 3.2. Langkah Awal Menuju Pemrograman

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:

    >>> # Fibonacci series:
    ... # the sum of two elements defines the next
    ... a, b = 0, 1
    >>> while b < 10:
    ...     print(b)
    ...     a, b = b, a+b
    ...
    1
    1
    2
    3
    5
    8

Contoh ini memperkenalkan beberapa fitur baru.

- 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.

- The `while` loop executes as long as the condition (here: `b < 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).

- 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.

- Fungsi `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 items, sehingga Anda dapat memformat sesuatu dengan baik, seperti ini:

      >>> i = 256*256
      >>> print('The value of i is', i)
      The value of i is 65536

  Argumen kata kunci end dapat digunakan untuk menghindari baris baru setelah keluaran, atau mengakhiri keluaran dengan string yang berbeda:

      >>> a, b = 0, 1
      >>> while b < 1000:
      ...     print(b, end=',')
      ...     a, b = b, a+b
      ...
      1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Catatan kaki

1

  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`.

2

  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.