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
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.
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)
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.
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
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.
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:
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.
Kode di dalamnya hanya berjalan ketika Anda memanggil fungsi.
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.
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
# 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.
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.
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.
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
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)
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)
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
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 sebuah slot; dua kunci dapat bertabrakan di satu slot
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
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
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.
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
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.
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.
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.
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
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.
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.
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.