Lompat ke konten
Materi
  • 1 Memulai
    1.1

    Program pertama Anda

    Python menjalankan kode Anda satu baris sekaligus. Setiap baris adalah pernyataan. Program hanyalah daftar pernyataan yang berjalan dari atas ke bawah.

    Fungsi print() menampilkan teks di layar. Ini disebut output. Teks di dalam tanda kutip adalah string.

    print("Hello, world!")
    print("I am learning Python")
    
    • Setiap print() memulai baris baru.
    • Tanda kutip bisa "double" atau 'single' — keduanya menghasilkan string.
    • Program tidak melakukan apa pun sampai Anda menjalankannya.
    Kode sumber berjalan melalui interpreter untuk menghasilkan output
    Kode sumber berjalan melalui interpreter untuk menghasilkan output
    1.2

    Komentar & gaya kode

    Komentar dimulai dengan #. Python mengabaikan segalanya setelah # pada baris itu. Komentar menjelaskan kode Anda kepada orang lain; mereka tidak mengubah apa yang dilakukan kode.

    # This line is a note for humans
    print("Hi")        # you can also comment at the end of a line
    

    Gaya yang baik membuat kode mudah dibaca:

    • Gunakan nama yang jelas untuk menunjukkan arti suatu nilai.
    • Letakkan satu pernyataan dalam setiap baris.
    • Jangan tambahkan spasi di awal baris biasa. Di Python, spasi di awal (indentasi) memiliki makna khusus, sehingga spasi yang salah akan menyebabkan error.
    1.3

    Input, proses, output

    Banyak program mengikuti rencana sederhana: input → proses → output. Anda mendapatkan data, memprosesnya, lalu menampilkan hasilnya.

    Fungsi input() membaca teks yang diketik pengguna. Fungsi ini selalu mengembalikan string.

    name = input("What is your name? ")
    print("Hello, " + name)
    
    • input() menunggu pengguna mengetik dan menekan Enter.
    • Simpan teks yang diketik ke dalam variabel agar dapat digunakan nanti.
    • Karena input() mengembalikan string, ubah terlebih dahulu dengan int(...) jika Anda memerlukan angka.

    Kesalahan umum

    • Lupa tanda kutip: print(Hello) mencari variabel bernama Hello dan memicu NameError. Teks perlu tanda kutip: print("Hello").
    • Spasi tak terduga di awal baris: Python membaca indentasi sebagai struktur, sehingga memicu IndentationError.
    • Menganggap input() mengembalikan angka. Fungsi ini selalu mengembalikan string, jadi bungkus dengan int(...) sebelum melakukan matematika.
  • 2 Variabel, tipe & operator
    2.1

    Variabel & penugasan

    Variabel adalah nama untuk sebuah nilai. Anda membuatnya dengan =, yang disebut penugasan. Nama diletakkan di kiri; nilai diletakkan di kanan.

    age = 17
    name = "Mei"
    price = 9.99
    print(age, name, price)
    

    Sekarang age menyimpan 17. Gunakan nama tersebut di mana saja Anda membutuhkan nilai, dan ubah kemudian:

    age = 17
    age = age + 1   # age is now 18
    print(age)
    
    Sebuah variabel adalah nama yang melekat pada nilai yang disimpan
    Setiap nama variabel menunjuk ke nilai dalam memori
    • Tanda = tidak berarti "sama dengan". Artinya "simpan sisi kanan di bawah nama sisi kiri".
    • Untuk menguji apakah dua nilai sama, gunakan == (lihat di bawah).
    2.2

    Angka: int & float

    Python memiliki dua jenis angka utama. Integer (int) adalah bilangan bulat seperti 17. Float (float) memiliki titik desimal seperti 9.99.

    Operator-operator ini bekerja pada angka:

    Operator Makna Contoh Hasil
    + tambah 3 + 2 5
    - kurang 3 - 2 1
    * kali 3 * 2 6
    / bagi (selalu float) 7 / 2 3.5
    // bagi bulat 7 // 2 3
    % sisa (modulo) 7 % 2 1
    ** pangkat 2 ** 3 8
    • / selalu menghasilkan float, sehingga 4 / 2 adalah 2.0.
    • // dan % berjalan beriringan: 17 // 5 adalah 3, dan 17 % 5 adalah 2.
    2.3

    Ekspresi & konversi tipe

    Ekspresi adalah segala sesuatu yang memiliki nilai, seperti 3 + 4 * 2. Python menggunakan urutan matematika standar (* dan / sebelum + dan -); gunakan kurung untuk memperjelas urutan.

    input() menghasilkan string, jadi konversikan sebelum melakukan matematika. Mengubah nilai dari satu tipe ke tipe lain disebut konversi tipe:

    age = int("17")        # text "17" -> number 17
    price = float("9.99")  # text -> 9.99
    label = str(17)        # number -> text "17"
    print(age, price, label)
    
    • int("abc") gagal, jadi hanya konversikan teks yang terlihat seperti angka.
    • Mencampur tipe juga gagal: "age: " + 17 adalah error; tulis "age: " + str(17).
    2.4

    Boolean & perbandingan

    Boolean adalah salah satu dari hanya dua nilai: True atau False. Perbandingan mengembalikan nilai Boolean.

    Operator Makna
    == sama dengan
    != tidak sama dengan
    < > kurang dari / lebih dari
    <= >= kurang/lebih dari atau sama dengan
    print(7 > 2)        # True
    print(3 == 3.0)     # True
    age = 20
    print(age >= 18)    # True
    

    Gabungkan perbandingan dengan and, or, not:

    age = 20
    print(age >= 13 and age <= 19)   # True only for a teenager
    

    Kesalahan umum

    • / selalu menghasilkan float, bahkan jika 4 / 2 adalah 2.0. Gunakan // ketika Anda menginginkan bilangan bulat.
    • Menggunakan = padahal maksudnya ==: = menetapkan nilai, == menguji apakah dua nilai sama.
    • Menggabungkan string dan angka: "age: " + 5 memicu TypeError. Konversikan terlebih dahulu dengan str(5).
    • Float tidak presisi, sehingga 0.1 + 0.2 tidak persis 0.3 — hindari == pada hasil float.
  • 3 String
    3.1

    Indeks

    String adalah teks di dalam tanda kutip. Setiap karakter memiliki posisi, disebut indeksnya. Indeks pertama adalah 0, bukan 1.

    Baca satu karakter dengan kurung siku:

    word = "Python"
    print(word[0])    # P  (the first character)
    print(word[2])    # t
    print(len(word))  # 6  (how many characters)
    
    • Penghitungan dimulai dari 0, sehingga indeks terakhir adalah len(word) - 1.
    • Indeks negatif menghitung mundur dari akhir: word[-1] adalah karakter terakhir.
    word = "Python"
    print(word[-1])   # n
    print(word[-2])   # o
    
    • Indeks yang terlalu besar akan menyebabkan error (an IndexError).
    s[start:stop] adalah jendela setengah terbuka dari karakter
    s[start:stop] adalah jendela setengah terbuka dari karakter
    3.2

    Pemotongan (Slicing)

    Pemotongan mengambil sebagian dari string. Tulis word[start:end]. Pemotongan mempertahankan start tetapi berhenti sebelum end.

    word = "Python"
    print(word[0:3])   # Pyt   (positions 0, 1, 2)
    print(word[2:5])   # tho
    
    • Biarkan start kosong untuk memulai dari 0; biarkan end kosong untuk sampai ke akhir.
    word = "Python"
    print(word[:3])    # Pyt
    print(word[3:])    # hon
    
    • Angka ketiga adalah langkah. word[::-1] membalikkan string.
    print("Python"[::-1])   # nohtyP
    
    3.3

    Metode string & panjang

    Metode adalah fungsi yang dimiliki oleh sebuah nilai. Panggil dengan titik:

    name = "mei chen"
    print(name.upper())     # MEI CHEN
    print(name.title())     # Mei Chen
    print(len(name))        # 8
    

    String bersifat immutable: metode mengembalikan string baru dan tidak pernah mengubah aslinya.

    name = "mei"
    print(name.upper())     # MEI  (the returned value)
    print(name)             # mei  (the original is unchanged)
    

    Metode umum (masing-masing mengembalikan nilai baru):

    Metode Makna Contoh Hasil
    .upper() / .lower() ubah kasus "Hi".lower() hi
    .strip() hapus spasi tepi " hi ".strip() hi
    .replace(a, b) tukar teks "cat".replace("c", "b") bat
    .split(sep) pecah menjadi list "a,b".split(",") ['a', 'b']

    Gabungkan string dengan +. Ini disebut penggabungan (concatenation):

    first = "Mei"
    last = "Chen"
    print(first + " " + last)   # Mei Chen
    
    3.4

    f-string

    f-string membangun teks dari nilai. Tulis f sebelum tanda kutip, lalu tulis {...} di sekitar nilai.

    name = "Mei"
    age = 17
    print(f"{name} is {age} years old")   # Mei is 17 years old
    
    • Ekspresi apa pun bisa masuk di dalam kurung kurawal.
    • {value:.2f} membulatkan ke 2 tempat desimal.
    price = 9.5
    print(f"Two cost {price * 2}")        # Two cost 19.0
    print(f"Pi is about {3.14159:.2f}")   # Pi is about 3.14
    

    Kesalahan umum

    • String tidak bisa diubah in-place: s[0] = "x" memicu error. Bangun string baru sebagai gantinya.
    • Indeks dimulai dari 0; karakter terakhir adalah s[-1], dan s[len(s)] berada di luar jangkauan.
    • Potongan s[a:b] mencakup a tetapi berhenti sebelum b.
    • Metode string mengembalikan STRING BARU: s.upper() tidak melakukan apa-apa kecuali Anda menyimpan hasilnya.
  • 4 Seleksi
    4.1

    if / elif / else

    Program memilih apa yang harus dilakukan dengan if. Program menjalankan blok yang terindentasi hanya ketika kondisi bernilai benar. Baris if diakhiri dengan titik dua.

    score = 72
    if score >= 60:
        print("pass")
    # pass
    

    Tambahkan elif (else-if) untuk lebih banyak kasus dan else untuk "segala sesuatu lainnya". Python hanya menjalankan cabang pertama yang bernilai benar, lalu melewatkan sisanya.

    score = 72
    if score >= 80:
        print("A")
    elif score >= 60:
        print("B")
    else:
        print("fail")
    # B
    
    • Bandingkan nilai dengan == (sama dengan), != (tidak sama dengan), <, >, <=, >=.
    • Perbandingan menghasilkan nilai Boolean — yaitu True atau False.
    if / elif / else: hanya satu cabang yang berjalan
    if / elif / else: hanya satu cabang yang berjalan
    4.2

    Menggabungkan kondisi

    Gabungkan kondisi menggunakan and, or, not. and memerlukan kedua sisi bernilai benar; or memerlukan salah satu sisi bernilai benar; not membalik nilai Boolean.

    age = 16
    has_ticket = True
    if age >= 18 and has_ticket:
        print("entry allowed")
    else:
        print("entry refused")
    # entry refused
    
    • Gunakan tanda kurung untuk memperjelas urutan: (a or b) and c.
    temp = 30
    if temp > 25 and not temp > 35:
        print("warm but ok")
    # warm but ok
    

    Kesalahan umum

    • Tulis elif, bukan else if.
    • Setiap baris if / elif / else diakhiri dengan titik dua :, dan isinya harus diindentasi.
    • if x = 5: adalah kesalahan — gunakan == untuk membandingkan.
    • else tidak menerima kondisi; hanya if dan elif yang melakukannya.
  • 5 Iterasi
    5.1

    Loop for dan range

    Loop mengulang kode. Loop for mengulang sekali untuk setiap item dalam sekuens. range(n) memberikan angka dari 0 hingga n - 1.

    for i in range(5):
        print(i)
    # 0, then 1, 2, 3, 4 (each on its own line)
    
    • range(a, b) berjalan dari a hingga (tetapi tidak termasuk) b.
    • range(a, b, step) menambahkan langkah setiap kali.
    for n in range(2, 11, 2):
        print(n)        # 2 4 6 8 10
    
    for i in range(n): body berjalan dengan i = 0 … n-1
    for i in range(n): body berjalan dengan i = 0 … n-1
    5.2

    Pola akumulator

    Untuk membangun hasil di sepanjang loop, mulai variabel sebelum loop, lalu perbarui setiap putaran. Ini adalah pola akumulator.

    total = 0
    for n in range(1, 6):
        total = total + n
    print(total)        # 15
    
    • Ide yang sama menghitung berapa banyak item yang sesuai dengan tes.
    count = 0
    for letter in "banana":
        if letter == "a":
            count = count + 1
    print(count)        # 3
    
    5.3

    loop while

    Loop while mengulang selama kondisi tetap benar. Ubah sesuatu di dalamnya, atau ia tidak akan pernah berhenti — loop tak terbatas.

    n = 1
    while n <= 3:
        print(n)
        n = n + 1
    # 1 2 3
    
    • break keluar dari loop segera.
    total = 0
    while True:
        total = total + 10
        if total >= 30:
            break
    print(total)        # 30
    
    5.4

    Perulangan bersarang

    Loop di dalam loop lain adalah loop bersarang. Loop dalam berjalan sepenuhnya untuk setiap putaran loop luar.

    for row in range(3):
        line = ""
        for col in range(3):
            line = line + "*"
        print(line)
    # ***
    # ***
    # ***
    

    Kesalahan umum

    • range(n) berjalan dari 0 ke n - 1, bukan 1 ke n — kesalahan off-by-one klasik.
    • Mengubah list saat looping melewatkan item; loop pada salinannya jika Anda harus menghapus sesuatu.
    • Lupa mengubah variabel loop dalam while membuatnya berjalan selamanya.
    • Indentasi menentukan apa yang ada di dalam loop; baris yang salah indentasi hanya berjalan sekali, setelah loop.
  • 6 List & list 2-D
    6.1

    Daftar

    List menyimpan banyak nilai secara berurutan, di dalam []. Setiap item memiliki indeks (dari 0).

    scores = [88, 71, 95]
    print(scores[0])      # 88
    print(len(scores))    # 3
    scores.append(60)     # add to the end
    print(scores)         # [88, 71, 95, 60]
    
    • Ubah item berdasarkan indeksnya: scores[1] = 100.
    • List dapat bertambah dan berkurang; string tidak bisa.

    Alat list sehari-hari:

    Alat Melakukan
    a.append(x) menambah x di akhir
    a.insert(i, x) menyisipkan x di posisi i
    a.remove(x) menghapus x pertama
    a.pop() / a.pop(i) menghapus dan mengembalikan item terakhir / item i
    a.sort() mengurutkan list secara in-place
    sorted(a) mengembalikan list terurut BARU
    x in a apakah x ada di list?
    len(a), sum(a), max(a), min(a) ukuran dan matematika cepat
    Indeks list dimulai dari 0
    Indeks list dimulai dari 0
    6.2

    Menelusuri list

    Menelusuri list berarti mengunjungi setiap item. Loop for melakukan ini tanpa perlu indeks.

    scores = [88, 71, 95]
    total = 0
    for s in scores:
        total = total + s
    print(total)          # 254
    
    • Gunakan enumerate jika Anda juga membutuhkan indeks.
    for i, name in enumerate(["a", "b"]):
        print(i, name)    # 0 a  /  1 b
    
    6.3

    List 2-D (grid)

    List 2-D adalah daftar dari list — grid baris dan kolom. Gunakan dua indeks: grid[row][col].

    grid = [[1, 2, 3],
            [4, 5, 6]]
    print(grid[0][2])     # 3
    print(grid[1][0])     # 4
    
    • Loop bersarang mengunjungi setiap sel.
    grid = [[1, 2], [3, 4]]
    for row in grid:
        for value in row:
            print(value, end=" ")
    print()               # 1 2 3 4
    
    6.4

    List comprehension

    List comprehension membangun list baru dalam satu baris: [expression for item in sequence].

    squares = [x * x for x in range(5)]
    print(squares)        # [0, 1, 4, 9, 16]
    
    • Tambahkan if untuk mempertahankan hanya beberapa item.
    evens = [n for n in range(10) if n % 2 == 0]
    print(evens)          # [0, 2, 4, 6, 8]
    
    6.5

    Tuple & set

    Tuple adalah sekuens tetap dalam tanda kurung bulat. Tidak dapat diubah setelah dibuat — gunakan untuk nilai yang terkait bersama, dan buka menjadi nama-nama.

    point = (3, 4)
    x, y = point            # unpacking
    print(x, y)             # 3 4
    

    Fungsi yang perlu mengembalikan dua hasil mengembalikan tuple:

    def min_max(nums):
        return min(nums), max(nums)
    
    lo, hi = min_max([5, 2, 9])
    print(lo, hi)           # 2 9
    

    Set menyimpan setiap nilai sekali, tanpa urutan. Sangat cocok untuk menghapus duplikat dan untuk pengujian keanggotaan yang cepat.

    votes = ["red", "blue", "red", "green", "red"]
    colours = set(votes)
    print(len(colours))         # 3  (duplicates removed)
    print("blue" in colours)    # True
    

    Kesalahan umum

    • b = a berbagi satu daftar. a.copy() atau a[:] membuat daftar luar baru, tetapi item yang dapat diubah di dalamnya tetap berbagi (salinan dangkal).
    • Item terakhir adalah a[-1]; a[len(a)] berada di luar jangkauan.
    • append menambah SATU item; gunakan extend atau + untuk menggabungkan list lain.
    • Membangun grid dengan [[0]*3]*3 membuat tiga salinan dari baris yang sama. Bangun barisnya dalam loop sebagai gantinya.
    • Tuple dengan satu item butuh koma: (5,), bukan (5).
    • Set tidak memiliki urutan dan tidak memiliki duplikat, sehingga Anda tidak dapat mengindeksnya dengan s[0].
  • 7 Dictionaries
    7.1

    Dictionaries

    Dictionary (dict) menyimpan pasangan kunci → nilai. Anda mencari nilai berdasarkan kuncinya, bukan berdasarkan indeks angka.

    student = {"name": "Mei", "score": 88}
    print(student["name"])     # Mei
    print(student["score"])    # 88
    

    Menambah dan memperbarui

    Tetapkan ke kunci untuk menambahkannya, atau mengubah yang sudah ada.

    student = {"name": "Mei"}
    student["score"] = 88      # add a new key
    student["score"] = 90      # update the value
    print(student)             # {'name': 'Mei', 'score': 90}
    

    Memeriksa dan looping

    Gunakan in untuk menguji kunci. Loop atas kuncinya, atau loop atas .items() untuk mendapatkan kunci dan nilainya.

    student = {"name": "Mei", "score": 90}
    print("score" in student)  # True
    for key, value in student.items():
        print(key, "=", value)
    # name = Mei
    # score = 90
    
    • .get(key, default) mengembalikan default ketika kunci hilang — tanpa error.
    student = {"name": "Mei"}
    print(student.get("age", 0))   # 0
    

    Pola ujian klasik — hitung seberapa sering setiap nilai muncul:

    word = "banana"
    counts = {}
    for letter in word:
        counts[letter] = counts.get(letter, 0) + 1
    print(counts)   # {'b': 1, 'a': 3, 'n': 2}
    
    • .get(letter, 0) menyediakan 0 pertama kali kunci terlihat, sehingga tidak ada KeyError.

    Kesalahan umum

    • Membaca kunci yang hilang dengan d[key] memicu KeyError; gunakan d.get(key) atau uji if key in d terlebih dahulu.
    • Menetapkan d[key] lagi menimpa nilai lama — kunci bersifat unik.
    • Kunci harus tidak dapat diubah, seperti string atau angka — list tidak bisa menjadi kunci.
    Dictionary memetakan setiap kunci ke satu nilai
    Dictionary memetakan setiap kunci ke satu nilai
  • 8 Fungsi & abstraksi
    8.1

    Mendefinisikan & memanggil fungsi

    Fungsi adalah blok kode bernama yang dapat Anda gunakan kembali. Definisikan dengan def, lalu panggil dengan namanya.

    def greet():
        print("Hello!")
    
    greet()        # Hello!
    greet()        # Hello!
    
    • Kode di dalamnya hanya berjalan ketika Anda memanggil fungsi.
    def mendefinisikan; call menjalankan; return mengirim nilai kembali
    def mendefinisikan; call menjalankan; return mengirim nilai kembali
    8.2

    Nilai pengembalian

    Fungsi dapat mengembalikan nilai dengan return. Pemanggilan kemudian merepresentasikan nilai tersebut.

    def square(n):
        return n * n
    
    print(square(5))          # 25
    print(square(3) + 1)      # 10
    
    • return mengakhiri fungsi segera. Fungsi tanpa return memberikan None.
    8.3

    Parameter, argumen & jangkauan

    Parameter adalah nama dalam def. Argumen adalah nilai yang Anda masukkan.

    def power(base, exp):         # base, exp are parameters
        return base ** exp
    
    print(power(2, 3))            # 8  (2 and 3 are arguments)
    

    Variabel yang dibuat di dalam fungsi bersifat lokal — ia hanya ada di sana. Wilayah itu adalah jangkauannya.

    def f():
        x = 10            # local to f
        return x
    
    print(f())            # 10
    # print(x) here would be an error: x is not defined outside f
    

    Parameter dapat memiliki nilai default, digunakan ketika pemanggil melewatkannya:

    def greet(name, greeting="Hello"):
        return greeting + ", " + name
    
    print(greet("Mei"))              # Hello, Mei
    print(greet("Sam", "Welcome"))   # Welcome, Sam
    
    8.4

    Abstraksi prosedural

    Abstraksi prosedural berarti menyembunyikan detail di balik sebuah nama. Anda menggunakan fungsi berdasarkan namanya dan apa yang dilakukannya, bukan bagaimana cara kerjanya.

    def area_of_rectangle(w, h):
        return w * h
    
    print(area_of_rectangle(4, 5))   # 20
    
    • Fungsi yang baik melakukan satu tugas, memiliki nama yang jelas, dan menghindari pengulangan kode.
    8.5

    Modul & impor

    Modul adalah file berisi fungsi siap pakai. Masukkan dengan import.

    import random
    random.seed(0)               # makes the result repeatable
    print(random.randint(1, 6))  # a dice roll
    
    import math
    print(math.sqrt(16))         # 4.0
    

    Kesalahan umum

    • Fungsi mengembalikan None kecuali Anda menulis return. Mencetak (printing) tidak sama dengan mengembalikan (returning).
    • Jangan gunakan default yang dapat diubah seperti def f(x=[]) — daftar yang sama akan dibagi antara semua pemanggilan.
    • Variabel yang dibuat di dalam fungsi bersifat lokal dan tidak dapat dilihat di luarnya.
    • Jalankan fungsi dengan f(); menulis f sendiri hanya memberinya nama.
  • 9 Kesalahan, pengecualian & pengujian
    9.1

    Kesalahan & penelusuran

    Kode dapat gagal dalam tiga cara. Kesalahan sintaks melanggar aturan Python, sehingga tidak pernah berjalan. Kesalahan runtime terjadi saat berjalan, seperti membagi dengan nol. Kesalahan logika berjalan tetapi memberikan jawaban yang salah.

    Kesalahan Python umum: Syntax, Name, Type, Index
    Kesalahan Python umum: Syntax, Name, Type, Index
    # A runtime error, caught so this block still finishes:
    try:
        print(10 / 0)
    except ZeroDivisionError:
        print("cannot divide by zero")
    # cannot divide by zero
    
    • Python mencetak jejak traceback yang menunjukkan lokasi kegagalan. Bacalah dari bawah ke atas.
    9.2

    try / except / raise

    Masukkan kode berisiko dalam try; jika gagal, except menangkap pengecualian alih-alih menyebabkan crash.

    def to_int(text):
        try:
            return int(text)
        except ValueError:
            return 0
    print(to_int("abc"))   # 0
    
    • Tangkap tipe spesifik (ValueError, ZeroDivisionError, …).
    • raise membuat kesalahan Anda sendiri dengan sengaja.
    def set_age(age):
        if age < 0:
            raise ValueError("age cannot be negative")
        return age
    
    try:
        set_age(-1)
    except ValueError as err:
        print("error:", err)
    # error: age cannot be negative
    
    9.3

    Pengujian & ketahanan

    Pengujian memeriksa bahwa kode memberikan jawaban yang benar. Cobalah kasus normal dan kasus batas — input kosong, nol, nilai sangat besar.

    def average(nums):
        if len(nums) == 0:        # edge case: empty list
            return 0
        return sum(nums) / len(nums)
    
    print(average([2, 4, 6]))     # 4.0
    print(average([]))            # 0
    
    • Kode tangguh menangani input aneh secara halus alih-alih menyebabkan crash.

    Kesalahan umum

    • Jangan gunakan except: telanjang — tangkap kesalahan spesifik, mis. except ValueError:.
    • Kesalahan sintaks menghentikan seluruh program sebelum berjalan, jadi perbaiki itu terlebih dahulu.
    • Uji kasus batas (input kosong, nol, nilai terbesar), bukan hanya yang mudah.
  • 10 File
    10.1

    Membaca & menulis file teks

    File teks menyimpan teks di disk. Buka dengan open(name, mode) di mana mode menyatakan read atau write. Selalu gunakan with, yang menutup file untuk Anda.

    Menulis

    Mode "w" menulis file baru dan menghapus yang lama.

    with open("notes.txt", "w") as f:
        f.write("first line\n")
        f.write("second line\n")
    print("saved")            # saved
    

    Membaca

    Mode "r" (default) membaca. .read() mengembalikan seluruh file sebagai satu string.

    with open("notes.txt", "w") as f:
        f.write("hello\nworld\n")
    with open("notes.txt") as f:
        print(f.read().strip())   # hello / world
    

    Baris demi baris

    Loop melalui file untuk mendapatkan satu baris sekaligus. .strip() menghapus newline di akhir.

    with open("data.txt", "w") as f:
        f.write("Mei,88\nSam,71\n")
    with open("data.txt") as f:
        for line in f:
            name, score = line.strip().split(",")
            print(name, "scored", score)
    # Mei scored 88
    # Sam scored 71
    

    Melampirkan

    Mode "a" melampirkan — menambahkan ke akhir tanpa menghapus.

    with open("log.txt", "w") as f:
        f.write("line 1\n")
    with open("log.txt", "a") as f:
        f.write("line 2\n")
    with open("log.txt") as f:
        print(f.read().strip())   # line 1 / line 2
    
    Mode Makna
    "r" baca (default)
    "w" tulis (hapus dulu)
    "a" lampirkan (tambah ke akhir)

    Kesalahan umum

    • Selalu tutup file, atau gunakan with open(...) as f: yang menutupnya untuk Anda.
    • read() memberikan seluruh file sebagai satu string, dan setiap baris masih berakhir dengan \n.
    • Membuka dengan "w" menghapus file terlebih dahulu; gunakan "a" untuk menambah ke akhir.
    open → read/write → close (dengan auto-closes)
    open → read/write → close (dengan auto-closes)
  • 11 Desain algoritma
    11.1

    Algoritma & dekomposisi

    Algoritma adalah daftar langkah yang jelas yang memecahkan masalah. Dekomposisi berarti memecah masalah besar menjadi bagian-bagian kecil yang dapat Anda selesaikan satu per satu.

    # Algorithm: find the largest number in a list
    def largest(nums):
        best = nums[0]
        for n in nums:
            if n > best:
                best = n
        return best
    
    print(largest([3, 9, 2, 7]))   # 9
    
    • Abstraksi berarti mengabaikan detail: Anda menggunakan largest(...) tanpa membaca ulang cara kerjanya.
    11.2

    Pseudocode & flowchart

    Pseudocode adalah bahasa Inggris terstruktur sederhana untuk algoritma, ditulis sebelum kode nyata. Ini tidak dijalankan.

    SET best TO first number
    FOR Each number n
        IF n > best
          THEN
            SET best TO n
    OUTPUT best
    

    Flowchart menggambar rencana yang sama: kotak untuk setiap langkah, belah ketupat untuk setiap keputusan, dan panah untuk urutan.

    11.3

    Rekursi & tumpukan pemanggilan

    Rekursi adalah ketika fungsi memanggil dirinya sendiri. Ia membutuhkan kasus dasar (input sederhana yang langsung mengembalikan) dan kasus rekursif (memanggil dirinya sendiri pada input yang lebih kecil).

    Stack pemanggilan untuk factorial(3): setiap pemanggilan menunggu, lalu mengembalikan dalam urutan terbalik
    Stack pemanggilan untuk factorial(3): setiap pemanggilan menunggu, lalu mengembalikan dalam urutan terbalik
    def fact(n):
        return 1 if n <= 1 else n * fact(n - 1)
    
    print(fact(5))     # 120
    
    • Setiap pemanggilan yang tertahan berada di tumpukan pemanggilan hingga pemanggilan di atasnya mengembalikan.

    Kesalahan umum

    • Rekursi memerlukan kasus dasar, atau ia akan memanggil dirinya sendiri selamanya dan membuat tumpukan pemanggilan crash.
    • Pseudocode untuk perencanaan — tidak perlu berjalan, tetapi setiap langkah harus tak ambigu.
    • Pecah masalah besar menjadi langkah-nama kecil sebelum menulis kode apa pun.
  • 12 Struktur data
    12.1

    Tipe Data Abstrak (ADT)

    Tipe data abstrak (ADT) menggambarkan beberapa data beserta operasi di atasnya, terpisah dari bagaimana ia dibangun. Anda menggunakannya melalui operasinya, bukan melalui penyimpanan dalamnya.

    # A stack ADT, built on a list
    s = []
    s.append(1)        # add
    s.append(2)
    print(s.pop())     # 2  (remove the most recent)
    
    12.2

    Tumpukan (Stacks)

    Tumpukan adalah terakhir masuk, pertama keluar (LIFO). Anda push ke atas dan pop dari atas.

    Tumpukan menghapus dari atas (LIFO); antrean menghapus dari depan (FIFO)
    Tumpukan menghapus dari atas (LIFO); antrean menghapus dari depan (FIFO)
    stack = []
    stack.append("a")
    stack.append("b")
    print(stack.pop())   # b
    print(stack.pop())   # a
    
    12.3

    antrean (Queues)

    Antrean adalah pertama masuk, pertama keluar (FIFO). Anda enqueue di belakang dan dequeue dari depan.

    queue = []
    queue.append("a")     # enqueue
    queue.append("b")
    print(queue.pop(0))   # a  (dequeue the front)
    print(queue.pop(0))   # b
    
    12.4

    Daftar terikat

    Daftar linked adalah rantai node. Setiap node memegang data dan pointer ke node berikutnya; yang terakhir menunjuk ke None.

    Daftar terhubung: setiap simpul menyimpan data dan penunjuk ke simpul berikutnya, berakhir pada None
    Daftar terhubung: setiap simpul menyimpan data dan penunjuk ke simpul berikutnya, berakhir pada None
    n3 = {"data": 3, "next": None}
    n2 = {"data": 2, "next": n3}
    n1 = {"data": 1, "next": n2}
    node = n1
    while node is not None:      # traverse to the end
        print(node["data"])
        node = node["next"]
    # 1 2 3
    
    12.5

    Tabel hash

    Tabel hash memetakan kunci ke slot dengan fungsi hash. Dua kunci dapat mendarat di slot yang sama — tabrakan. dict Python adalah tabel hash, sehingga pencarian cepat.

    Fungsi hash memetakan setiap kunci ke slot; dua kunci dapat bertabrakan di satu slot
    Fungsi hash memetakan setiap kunci ke sebuah slot; dua kunci dapat bertabrakan di satu slot
    table = {}
    table["Mei"] = 88
    table["Sam"] = 71
    print(table["Mei"])   # 88  (fast lookup by key)
    
    12.6

    Pohon Pencarian Biner

    Pohon pencarian biner (BST) menjaga urutan: setiap anak kiri lebih kecil dari nodenya, setiap anak kanan lebih besar. Pencarian tetap cepat.

    Pohon pencarian biner: nilai lebih kecil ke kiri, nilai lebih besar ke kanan
    Pohon pencarian biner: nilai lebih kecil ke kiri, nilai lebih besar ke kanan
    def insert(root, val):
        if root is None:
            return {"val": val, "left": None, "right": None}
        if val < root["val"]:
            root["left"] = insert(root["left"], val)
        else:
            root["right"] = insert(root["right"], val)
        return root
    
    def inorder(root):
        if root is None:
            return []
        return inorder(root["left"]) + [root["val"]] + inorder(root["right"])
    
    tree = None
    for v in [5, 3, 8, 1, 4]:
        tree = insert(tree, v)
    print(inorder(tree))   # [1, 3, 4, 5, 8]
    
    12.7

    Graf

    Graf adalah himpunan simpul yang terhubung oleh sisi. Daftar ketetanggaan — sebuah dict berisi daftar tetangga — adalah cara umum untuk menyimpannya.

    Graf simpul dan sisi, dengan bentuk daftar ketetanggaannya
    Graf simpul dan sisi, dengan bentuk daftar ketetanggaannya
    graph = {"A": ["B", "D"], "B": ["A", "C"], "C": ["B", "D"], "D": ["A", "C"]}
    for vertex in graph:
        print(vertex, "->", graph[vertex])
    # A -> ['B', 'D']  (and so on for B, C, D)
    

    Kesalahan umum

    • Tumpukan bersifat terakhir masuk pertama keluar; antrian bersifat pertama masuk pertama keluar. Jangan sampai tertukar.
    • Periksa apakah struktur kosong sebelum Anda pop atau dequeue darinya.
    • Dalam daftar linked, kehilangan pointer head berarti kehilangan seluruh daftar.
  • 13 Pencarian, pengurutan & efisiensi
    13.1

    Pencarian linear & biner

    Pencarian menemukan di mana suatu nilai berada. Pencarian linear memeriksa setiap item secara berurutan, sehingga bekerja pada daftar apa pun.

    def linear_search(items, target):
        for i in range(len(items)):
            if items[i] == target:
                return i
        return -1     # not found
    
    print(linear_search([4, 8, 2, 9], 2))   # 2
    

    Pencarian biner jauh lebih cepat tetapi membutuhkan daftar terurut. Ia membagi dua jangkauan setiap langkah.

    def binary_search(items, target):
        lo, hi = 0, len(items) - 1
        while lo <= hi:
            mid = (lo + hi) // 2
            if items[mid] == target:
                return mid
            elif items[mid] < target:
                lo = mid + 1
            else:
                hi = mid - 1
        return -1
    
    print(binary_search([1, 3, 5, 7, 9], 7))   # 3
    
    Pencarian biner membagi dua jangkauan setiap langkah — O(log n) pada daftar terurut
    Pencarian biner membagi dua jangkauan setiap langkah — O(log n) pada daftar terurut
    13.2

    Pengurutan (bubble & insertion)

    Mengurutkan berarti menyusun item dalam urutan. Bubble sort berulang kali menukar tetangga yang urutannya salah.

    def bubble_sort(a):
        a = a[:]                          # work on a copy
        for i in range(len(a)):
            for j in range(len(a) - 1 - i):
                if a[j] > a[j + 1]:
                    a[j], a[j + 1] = a[j + 1], a[j]
        return a
    
    print(bubble_sort([5, 2, 4, 1]))      # [1, 2, 4, 5]
    

    Insertion sort membangun bagian terurut satu item sekaligus, menggeser setiap item baru kembali ke tempatnya:

    def insertion_sort(a):
        a = a[:]                           # work on a copy
        for i in range(1, len(a)):
            key = a[i]
            j = i - 1
            while j >= 0 and a[j] > key:   # shift bigger values right
                a[j + 1] = a[j]
                j -= 1
            a[j + 1] = key                 # drop key into the gap
        return a
    
    print(insertion_sort([5, 2, 4, 1]))   # [1, 2, 4, 5]
    
    • Dalam kode nyata, gunakan built-in Python sorted():
    print(sorted([5, 2, 4, 1]))           # [1, 2, 4, 5]
    
    13.3

    Efisiensi algoritmik

    Efisiensi menanyakan bagaimana beban kerja bertambah seiring input bertambah. Kita mendeskripsikannya dengan Big-OO.

    Bagaimana jumlah langkah bertambah seiring ukuran input untuk kompleksitas umum
    Bagaimana jumlah langkah bertambah seiring ukuran input untuk kompleksitas umum
    Big-O Nama Contoh
    $O(1)$ konstan melihat kunci dict
    $O(\log n)$ logaritmik pencarian biner
    $O(n)$ linear pencarian linear
    $O(n^2)$ kuadratik bubble sort
    def steps(n):           # how many steps a linear scan takes
        count = 0
        for i in range(n):
            count = count + 1
        return count
    
    print(steps(100))       # 100  -> O(n)
    
    13.4

    Keacakan & simulasi

    Modul random menghasilkan angka acak. Gunakan seed agar hasil dapat direproduksi. Simulasi menjalankan banyak percobaan acak untuk memperkirakan jawaban.

    import random
    random.seed(0)
    rolls = [random.randint(1, 6) for _ in range(1000)]
    print(rolls.count(6))   # about 1/6 of 1000
    

    Kesalahan umum

    • Pencarian biner hanya bekerja pada daftar terurut.
    • Big-O memberi tahu Anda bagaimana waktu BERKEMBANG, bukan waktu eksak; metode O(n²) mengalahkan O(n) hanya untuk input sangat kecil.
    • Bubble sort adalah O(n²) — cukup untuk belajar, tetapi lambat pada daftar besar.
  • 14 OOP & paradigma
    14.1

    Kelas & objek

    Kelas adalah cetak biru. Objek adalah satu hal yang dibangun darinya (instans). __init__ adalah konstruktor yang menyiapkan setiap objek; self adalah objek itu sendiri.

    class Dog:
        def __init__(self, name):
            self.name = name            # an attribute
        def speak(self):
            return self.name + " says woof"
    
    d = Dog("Rex")
    print(d.speak())     # Rex says woof
    
    • name adalah atribut (data pada objek); speak adalah method (tindakan).

    Tambahkan __str__ untuk mengontrol apa yang print(obj) tampilkan:

    class Dog:
        def __init__(self, name):
            self.name = name
        def __str__(self):
            return f"Dog named {self.name}"
    
    print(Dog("Rex"))    # Dog named Rex
    
    Kelas adalah cetak biru; memanggilnya membuat objek
    Kelas adalah cetak biru; memanggilnya membuat objek
    14.2

    Warisan, enkapsulasi & polimorfisme

    Warisan memungkinkan subclass menggunakan ulang superclass. Gunakan super() untuk memanggil induk; atur ulang method untuk mengubahnya.

    class Animal:
        def speak(self):
            return "some sound"
    
    class Cat(Animal):
        def speak(self):                # override
            return "meow"
    
    print(Cat().speak())   # meow
    

    Enkapsulasi mengelompokkan data dengan metode dan mengekspos antarmuka yang dimaksud. Dalam Python, garis bawah di awal menandai nama yang tidak seharusnya publik (sering disebut pribadi) berdasarkan konvensi; hal ini tidak mencegah akses oleh kode eksternal. Pemangkasan nama dengan dua garis bawah membantu menghindari benturan nama subclass tak sengaja, bukan untuk memaksakan keamanan.

    class Account:
        def __init__(self):
            self._balance = 0           # non-public by convention
        def deposit(self, n):
            self._balance += n
        def balance(self):
            return self._balance
    
    a = Account()
    a.deposit(50)
    print(a.balance())     # 50
    

    Polimorfisme berarti satu nama, banyak perilaku — speak yang tepat berjalan untuk setiap objek.

    class Cat:
        def speak(self):
            return "meow"
    
    class Cow:
        def speak(self):
            return "moo"
    
    for animal in [Cat(), Cow()]:
        print(animal.speak())   # meow, then moo
    
    14.3

    Paradigma pemrograman

    Paradigma adalah gaya menulis program. Kode prosedural adalah urutan langkah dan fungsi. Kode berorientasi objek mengelompokkan data dan method menjadi objek. Kode deklaratif menyatakan apa yang Anda inginkan, bukan bagaimana (list comprehension atau SQL).

    def total(nums):           # procedural
        t = 0
        for n in nums:
            t += n
        return t
    print(total([1, 2, 3]))    # 6
    
    print(sum([1, 2, 3]))      # 6  (declarative: same result)
    

    Kesalahan umum

    • Setiap method memerlukan self sebagai parameter pertamanya.
    • __init__ mengatur objek baru dan berjalan otomatis saat Anda membuat satu.
    • Dua objek dari kelas yang sama memiliki atribut terpisah; mengubah satu tidak mengubah yang lain.
  • 15 Representasi data
    15.1

    Bit & biner

    Bit adalah satu 0 atau 1 tunggal. Biner adalah sistem bilian basis-2: setiap posisi bernilai dua kali lipat dari posisi di sebelah kanannya (1, 2, 4, 8, …). Desimal (basis-10) adalah angka kita sehari-hari.

    Nilai tempat biner: 1101 berarti 8 + 4 + 1 = 13
    Nilai tempat biner: 1101 berarti 8 + 4 + 1 = 13
    print(bin(13))         # 0b1101
    print(int("1101", 2))  # 13
    
    • 8 bit membentuk byte. Lebar tetap dapat overflow (melipat) ketika nilainya terlalu besar.
    x = 250
    x = (x + 10) % 256     # one byte wraps at 256
    print(x)               # 4
    

    Heksadesimal (basis 16) adalah cara ringkas membaca biner: satu digit heksadecimal mewakili tepat empat bit. Python menulis heksa dengan 0x:

    print(hex(255))        # 0xff
    print(0xFF)            # 255
    print(int("ff", 16))   # 255
    
    15.2

    Kompresi

    Kompresi membuat data lebih kecil. Kompresi lossless menjaga setiap bit, sehingga Anda dapat merekonstruksi aslinya persis. Kompresi lossy membuang detail — lebih kecil tapi tidak persis — dan digunakan untuk foto dan musik.

    Pengkodean run-length adalah metode lossless sederhana: simpan rentang (pengulangan) sebagai count ditambah nilainya.

    def rle(text):
        out = ""
        i = 0
        while i < len(text):
            run = 1
            while i + run < len(text) and text[i + run] == text[i]:
                run += 1
            out += str(run) + text[i]
            i += run
        return out
    
    print(rle("AAAABBBCCD"))   # 4A3B2C1D
    

    Kesalahan umum

    • n bits menyimpan 2**n nilai berbeda, dari 0 hingga 2**n - 1.
    • Kompresi lossy membuang detail dan tidak dapat dibalik; lossless dapat dikembalikan persis.
  • 16 Konsep komputasi
    16.1

    Apa itu komputasi & siklus desain

    Komputasi berarti menyelesaikan masalah dengan komputer: input, proses, output. Perangkat lunak baik dibangun dalam siklus desain — rencanakan, tulis, uji, perbaiki — diulang berkali-kali.

    • Pecah masalah, bangun sebagian kecil, uji, lalu tambahkan lagi.
    • Programmer bekerja dalam tim dan menggunakan ulang kode orang lain.
    16.2

    Internet

    Internet adalah jaringan dari jaringan. Data dibagi menjadi paket yang berjalan terpisah dan disusun kembali di ujung lain. Aturan bersama yang disebut protokol (seperti TCP/IP) membuat ini berfungsi. Jika satu jalur rusak, paket mengambil rute lain — ini adalah redundansi, yang memberikan toleransi kesalahan.

    Peta Internet: setiap garis adalah jalur antara dua jaringan
    Peta Internet: setiap garis adalah jalur antara dua jaringan
    Lapisan Tugas
    HTTP permintaan dan kirim halaman web
    TCP pengiriman andal, berurutan
    IP pengalamatan dan perutean
    16.3

    Komputasi paralel & terdistribusi

    Kode sekuensial melakukan satu langkah pada satu waktu. Komputasi paralel melakukan beberapa langkah sekaligus di banyak inti prosesor, yang dapat memberikan percepatan. Komputasi terdistribusi menyebarkan tugas ke banyak komputer, seperti di cloud.

    • Tidak semua hal dapat berjalan secara paralel: beberapa langkah harus menunggu hasil sebelumnya.
    16.4

    Dampak komputasi

    Komputasi membawa manfaat dan kerugian. Kesenjangan digital berarti tidak semua orang memiliki akses yang setara. Perangkat lunak dapat membawa bias dari data yang dipelajari. Hormati hak kekayaan intelektual (lisensi), dan lindungi data pribadi serta privasi orang.

    Kesalahan umum

    • Internet dan World Wide Web bukan hal yang sama: Web adalah satu layanan yang berjalan di atas Internet.
    • Inti prosesor lebih banyak hanya membantu jika pekerjaan dapat dibagi menjadi bagian yang dijalankan bersamaan.
  • 17 Menggabungkannya
    17.1

    Proyek mini end-to-end

    Proyek mini menggabungkan ide-ide sebelumnya: data dalam daftar, fungsi dengan seleksi di dalam perulangan, dan output tercetak. Ini juga merupakan bentuk dari Tugas Kinerja AP Create.

    Proyek: nilai rata-rata

    def average(marks):
        if len(marks) == 0:
            return 0
        return round(sum(marks) / len(marks), 1)
    
    print(average([88, 71, 95, 60]))   # 78.5
    

    Proyek: hitung kelulusan

    def count_passes(marks, pass_mark=60):
        passes = 0
        for m in marks:                 # iteration
            if m >= pass_mark:          # selection
                passes += 1
        return passes
    
    print(count_passes([88, 50, 95, 60]))   # 3
    

    Proyek: filter ke daftar baru

    def merit(marks):
        return [m for m in marks if m >= 80]
    
    print(merit([88, 71, 95, 60]))     # [88, 95]
    

    Tugas AP Create meminta sebuah daftar, prosedur berparameter yang menggunakan seleksi dan iterasi, serta input/output. Setiap proyek di atas memiliki bentuk persis itu — bangun potongan kecil, lalu gabungkan.

    Kesalahan umum

    • Bangun dalam langkah-langkah kecil dan uji setiap bagian sebelum melanjutkan — jangan tulis semuanya sekaligus.
    • Baca seluruh tugas terlebih dahulu, lalu rencanakan alur input → proses → output sebelum memprogram.
    Proyek mini: data → fungsi → hasil cetak
    Proyek mini: data → fungsi → hasil cetak

Masuk atau buat akun

IGCSE, A-Level & AP