Python Handout · ⁨Catatan Tangan Python⁩

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.

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.

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.

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)

• Tanda = tidak berarti "sama dengan". Artinya "simpan sisi kanan di bawah nama sisi kiri".
• Untuk menguji apakah dua nilai sama, gunakan == (lihat di bawah).

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:

• / selalu menghasilkan float, sehingga 4 / 2 adalah 2.0.
• // dan % berjalan beriringan: 17 // 5 adalah 3, dan 17 % 5 adalah 2.

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

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

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.

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

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

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):

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

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

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.

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.

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.

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

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

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

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.

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:

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

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

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]

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 tidak menyalin list: kedua nama menunjuk ke list yang sama, sehingga mengubah satu mengubah yang lain. Gunakan a.copy() atau a[:].
• 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].

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.

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.

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.

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

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.

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.

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.

# 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 traceback yang menunjukkan di mana kegagalan terjadi. Bacalah dari bawah ke atas.

Bungkus kode berisiko dalam try. Jika gagal, except menangkap pengecualian dan menanganinya, alih-alih membuat program crash.

def to_int(text):
    try:
        return int(text)
    except ValueError:
        return 0

print(to_int("42"))    # 42
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

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 yang tangguh tidak crash pada input aneh; ia menanganinya dengan halus.

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.

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

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.

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.

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.

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

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.

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)

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

stack = []
stack.append("a")
stack.append("b")
print(stack.pop())   # b
print(stack.pop())   # a

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

Daftar linked adalah rantai node. Setiap node memegang data dan pointer ke node berikutnya; yang terakhir menunjuk ke 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

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.

table = {}
table["Mei"] = 88
table["Sam"] = 71
print(table["Mei"])   # 88  (fast lookup by key)

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

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]

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

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.

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

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]

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

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)

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.

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

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

Enkapsulation menyembunyikan data di balik method; garis bawah di awal menandainya sebagai privat.

class Account:
    def __init__(self):
        self._balance = 0           # private
    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

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.

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.

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

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.

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.

Internet adalah jaringan dari jaringan. Data dibagi menjadi paket yang traveling secara terpisah dan digabungkan kembali di ujung lain. Aturan bersama yang disebut protokol (seperti TCP/IP)使它工作。 Jika satu jalur rusak, paket mengambil rute lain — ini redundansi, yang memberikan toleransi kesalahan.

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.

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.

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.