Belajar Math - Logika Proposisional (Boolean Logic)
Statement, AND/OR/NOT/XOR/NAND, truth table, dan precedence operator logika adalah fondasi dari if/else, bit mask, SQL WHERE clause, dan short-circuit evaluation. Di episode ini kalian memahami logika proposisional secara formal dan menerapkannya dalam kode.
#Pendahuluan
Setelah di episode 4 kita memahami fungsi dan grafik — termasuk hubungan dengan Big-O notation — pada episode ini kita mulai masuk ke discrete mathematics: cabang matematika yang berurusan dengan objek diskrit (terpisah), bukan kontinu. Dan fondasi pertama discrete math adalah logika proposisional — atau yang lebih dikenal sebagai boolean logic.
Mengapa logika proposisional harus dipelajari secara formal? Karena setiap if/else, setiap kondisi dalam WHERE clause SQL, setiap regex pattern, dan setiap short-circuit evaluation dalam kode kalian pada dasarnya adalah operasi logika. Memahami truth table dan precedence operator logika membuat kalian bisa menulis kondisi yang lebih benar, lebih efisien, dan lebih mudah dibaca.
#Statement dan Boolean
#Apa Itu Statement?
Statement (pernyataan) adalah kalimat yang bisa dinilai benar (True) atau salah (False). Dalam kode, ini adalah boolean expression:
# Statement sederhana
is_even = 4 % 2 == 0 # True — 4 habis dibagi 2
is_positive = -5 > 0 # False — -5 tidak positif
age = 25
is_adult = age >= 18 # True — 25 ≥ 18
print(f"4 genap? {is_even}")
print(f"-5 positif? {is_positive}")
print(f"25 dewasa? {is_adult}")#Literal Boolean
Python punya dua nilai boolean: True dan False. Tetapi banyak tipe data lain juga bisa dievaluasi sebagai boolean — konsep yang disebut truthy dan falsy:
# Falsy values
falsy_values = [False, None, 0, 0.0, "", [], {}, set(), tuple()]
for val in falsy_values:
print(f" {repr(val):>12} → bool: {bool(val)}")
# Truthy values (contoh)
truthy_values = [True, 1, -1, "hello", [1], {"a": 1}, (1,)]
for val in truthy_values:
print(f" {repr(val):>12} → bool: {bool(val)}")#Operator Logika Dasar
#AND, OR, NOT
Tiga operator logika fundamental:
A, B = True, False
print(f"AND: True AND True = {True and True}") # True
print(f"AND: True AND False = {True and False}") # False
print(f"OR: False OR True = {False or True}") # True
print(f"NOT: NOT True = {not True}") # False
# Truth table AND
print("\nAND Truth Table:")
for A in [True, False]:
for B in [True, False]:
print(f" {A} AND {B} = {A and B}")
# Truth table OR
print("\nOR Truth Table:")
for A in [True, False]:
for B in [True, False]:
print(f" {A} OR {B} = {A or B}")#XOR — Exclusive OR
XOR menghasilkan True hanya jika persis satu operand bernilai True. Ini penting untuk bit manipulation dan enkripsi:
# XOR: True jika beda, False jika sama
print("XOR Truth Table:")
for A in [True, False]:
for B in [True, False]:
result = A != B # XOR dalam Python
print(f" {A} XOR {B} = {result}")
# XOR untuk swap tanpa variabel sementara
a, b = 5, 9
a ^= b
b ^= a
a ^= b
print(f"\nSetelah swap: a={a}, b={b}") # a=9, b=5
# XOR untuk menemukan elemen unik
def find_unique(arr):
"""Satu elemen muncul sekali, lainnya muncul dua kali."""
result = 0
for num in arr:
result ^= num
return result
print(f"Unique in [1,2,3,2,1]: {find_unique([1, 2, 3, 2, 1])}") # 3#NAND — NOT AND
NAND adalah kebalikan dari AND — menghasilkan False hanya jika kedua operand True. NAND adalah universal gate — semua operasi logika bisa dibangun dari NAND saja:
def nand(a, b):
return not (a and b)
# AND dari NAND: a AND b = NAND(NAND(a,b), NAND(a,b))
def and_from_nand(a, b):
return nand(nand(a, b), nand(a, b))
# OR dari NAND: a OR b = NAND(NAND(a,a), NAND(b,b))
def or_from_nand(a, b):
return nand(nand(a, a), nand(b, b))
# NOT dari NAND: NOT a = NAND(a, a)
def not_from_nand(a):
return nand(a, a)
print(f"NAND: True NAND False = {nand(True, False)}") # True
print(f"AND from NAND: {and_from_nand(True, True)}") # True
print(f"OR from NAND: {or_from_nand(False, True)}") # True
print(f"NOT from NAND: {not_from_nand(True)}") # False#Precedence Operator Logika
Urutan evaluasi operator logika: NOT > AND > OR (mirip matematika: eksponensial > perkalian > penjumlahan):
A, B, C = True, False, True
# NOT diutamakan, lalu AND, lalu OR
result1 = A or B and not C
# = A or (B and (not C))
# = True or (False and False)
# = True or False
# = True
result2 = (A or B) and (not C) # paksa urutan dengan parentheses
# = (True or False) and (False)
# = True and False
# = False
print(f"A or B and not C = {result1}") # True
print(f"(A or B) and (not C) = {result2}") # False
print("Perbedaan! Gunakan parentheses untuk kejelasan.")#Short-Circuit Evaluation
Python mengevaluasi operator logika secara short-circuit — berhenti segera setelah hasil sudah ditentukan:
def check_expensive():
print(" [check_expensive dipanggil!]")
return True
def check_cheap():
print(" [check_cheap dipanggil!]")
return False
# AND: berhenti di False pertama
print("False AND expensive:")
result = check_cheap() and check_expensive()
# check_expensive tidak dipanggil!
# OR: berhenti di True pertama
print("\nTrue OR expensive:")
result = check_cheap() or check_expensive()
# check_expensive dipanggil karena check_cheap False
print(f"\nHasil: {result}")Short-circuit digunakan secara luas untuk guard clauses — mengecek kondisi murah dulu sebelum kondisi mahal:
def aman_aksi(user, data, permission):
"""Cek keamanan dengan short-circuit — kondisi murah dulu."""
return (
user is not None
and data is not None
and permission is not None
and user.is_active
and data.is_valid
and permission.has_access
)#Aplikasi Nyata
#Bit Mask untuk Permission (Linux)
# Bit permission: rwxrwxrwx = 9 bit
READ = 0b100000000 # 256
WRITE = 0b010000000 # 128
EXECUTE = 0b001000000 # 64
# Buat permission: owner=rwx, group=rx, other=r
owner = READ | WRITE | EXECUTE
group = READ | EXECUTE
other = READ
permission = (owner << 6) | (group << 3) | other
# Cek permission dengan AND
is_readable = bool(permission & READ)
is_writable = bool(permission & WRITE << 6) # cek bit owner write
print(f"Permission: {bin(permission)}")
print(f"Readable: {is_readable}, Writable: {is_writable}")#SQL WHERE Clause
Setiap WHERE clause adalah kombinasi boolean logic:
-- AND: kedua kondisi harus True
SELECT * FROM users WHERE age >= 18 AND is_active = true;
-- OR: salah satu cukup True
SELECT * FROM products WHERE category = 'electronics' OR price < 100000;
-- NOT: negasi
SELECT * FROM orders WHERE NOT is_cancelled;
-- Kombinasi dengan parentheses
SELECT * FROM users
WHERE (role = 'admin' OR role = 'editor')
AND is_active = true
AND last_login > '2026-01-01';#Regex sebagai Logika
Setiap regex pattern adalah ekspresi logika kompleks:
import re
# Pattern: "harus mulai dengan huruf, diikuti angka, atau hanya huruf"
pattern = r"^[a-zA-Z]+\d*$|^[a-zA-Z]+$"
test_strings = ["hello", "hello123", "123hello", "HELLO", ""]
for s in test_strings:
match = bool(re.match(pattern, s))
print(f" '{s}' → {match}")Note
Short-circuit evaluation bukan sekadar optimasi — ia adalah pola desain yang berguna. Gunakan untuk guard clauses yang mengecek kondisi murah dulu (pointer null, empty string) sebelum kondisi mahal (parsing, network call, database query).
#Penutup
Inti yang harus dibawa pulang:
- Statement adalah kalimat yang bernilai
TrueatauFalse; banyak tipe data Python punya truthy/falsy values. - AND, OR, NOT adalah operator logika fundamental; XOR penting untuk bit manipulation; NAND adalah universal gate.
- Precedence: NOT > AND > OR — gunakan parentheses untuk kejelasan.
- Short-circuit evaluation berhenti segera setelah hasil ditentukan — berguna untuk guard clauses.
- Logika proposisional muncul di
if/else, bit mask, SQL WHERE clause, dan regex pattern.
Di episode 6 selanjutnya kita akan mempelajari quantifier (∀, ∃) dan logika predikat — universal ("untuk semua") dan existential ("ada satu"), bagaimana ini berkaitan dengan all() / any() di Python, dan mengapa ini penting untuk spec/assertion testing. Logika proposisional yang baru kalian kuasai adalah fondasi untuk memahami quantifier!