Keyword #

import keyword
print(keyword.kwlist)

# Cek apakah sebuah string adalah keyword
import keyword
print(keyword.iskeyword("for"))      # → True
print(keyword.iskeyword("forEach"))  # → False
print(keyword.iskeyword("type"))     # → True (Python 3.12+)

# True dan False adalah instance dari bool, subkelas int
print(type(True))    # → <class 'bool'>
print(type(False))   # → <class 'bool'>
print(isinstance(True, int))   # → True

# Konsekuensi aritmatika
print(True + True)   # → 2
print(True * 10)     # → 10
print(False + 1)     # → 1

# Konversi ke bool — truthy dan falsy
print(bool(0))       # → False
print(bool(""))      # → False
print(bool([]))      # → False
print(bool(None))    # → False
print(bool(42))      # → True
print(bool("teks"))  # → True

# ANTI-PATTERN: perbandingan eksplisit dengan True/False
if aktif == True:    # berlebihan
    pass
if aktif is True:    # perlu hati-hati — hanya cocok untuk bool sejati

# BENAR: evaluasi langsung
if aktif:
    pass
if not aktif:
    pass

# None adalah satu-satunya nilai dari NoneType
print(type(None))      # → <class 'NoneType'>
print(None == False)   # → False
print(None == 0)       # → False
print(None is None)    # → True   ← cara yang benar

# Penggunaan umum None
def cari(data, kunci):
    """Kembalikan None jika tidak ditemukan."""
    return data.get(kunci)   # dict.get() mengembalikan None secara default

# Fungsi tanpa return eksplisit mengembalikan None
def cetak_saja(teks):
    print(teks)

hasil = cetak_saja("halo")
print(hasil)   # → None

# None sebagai default parameter sentinel
def tambah(item, wadah=None):
    if wadah is None:
        wadah = []    # buat baru setiap kali — hindari mutable default
    wadah.append(item)
    return wadah

# SELALU bandingkan None dengan 'is' atau 'is not', bukan == atau !=
nilai = None
if nilai is None:        # ✓ benar
    pass
if nilai is not None:    # ✓ benar
    pass
if nilai == None:        # ✗ tidak idiomatis (meski bekerja)
    pass

# and — kembalikan operand pertama yang falsy, atau terakhir jika semua truthy
print(True and True)    # → True
print(True and False)   # → False
print(0 and "hello")    # → 0      (0 adalah falsy, berhenti)
print(1 and "hello")    # → "hello" (semua truthy, kembalikan terakhir)

# or — kembalikan operand pertama yang truthy, atau terakhir jika semua falsy
print(False or True)    # → True
print(0 or "")          # → ""     (semua falsy, kembalikan terakhir)
print(0 or "default")   # → "default"
print("ada" or "default") # → "ada"

# not — negasi boolean
print(not True)    # → False
print(not False)   # → True
print(not 0)       # → True
print(not "")      # → True
print(not [1, 2])  # → False

# Idiom praktis memanfaatkan short-circuit
nama = input_nama or "Tamu"          # nilai default
data and proses(data)                # eksekusi kondisional
hasil = x if x is not None else 0   # alternatif eksplisit

# is — cek apakah dua variabel menunjuk ke OBJEK YANG SAMA (bukan nilai sama)
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)    # → True  (nilai sama)
print(a is b)    # → False (objek berbeda di memori)
print(a is c)    # → True  (c adalah alias a — objek sama)

# Kapan is tepat digunakan:
# 1. Membandingkan dengan None
if hasil is None:
    pass
if pengguna is not None:
    pass

# 2. Membandingkan singleton (True, False, None)
# Hindari is untuk int, str, list, atau tipe lain
# karena Python meng-cache beberapa objek kecil secara tidak terduga
x = 256
y = 256
print(x is y)   # → True  (di-cache oleh Python)
x = 257
y = 257
print(x is y)   # → mungkin False (tidak selalu di-cache)

# in — cek keanggotaan dalam koleksi atau substring dalam string
print("a" in "bahasa")          # → True  (substring)
print("z" not in "bahasa")      # → True

print(3 in [1, 2, 3, 4])        # → True  (list — O(n))
print(3 in {1, 2, 3, 4})        # → True  (set  — O(1))
print("nama" in {"nama": "Budi"}) # → True  (dict — cek KEY)

# in dalam for loop — iterasi
for huruf in "Python":
    print(huruf, end=" ")
# → P y t h o n

for i in range(5):
    print(i, end=" ")
# → 0 1 2 3 4

nilai = 85

if nilai >= 90:
    grade = "A"
elif nilai >= 80:
    grade = "B"
elif nilai >= 70:
    grade = "C"
elif nilai >= 60:
    grade = "D"
else:
    grade = "E"

print(grade)   # → B

# Conditional expression (ternary) — if/else dalam satu baris
status = "lulus" if nilai >= 60 else "tidak lulus"

# if dalam comprehension
genap = [x for x in range(10) if x % 2 == 0]

# for — iterasi atas iterable
for item in ["apel", "jeruk", "mangga"]:
    print(item)

# while — ulangi selama kondisi True
hitung = 0
while hitung < 5:
    print(hitung)
    hitung += 1

# while True — loop tak terbatas dengan break sebagai exit
while True:
    perintah = input("Perintah: ")
    if perintah == "keluar":
        break
    jalankan(perintah)

# break menghentikan loop sepenuhnya dan keluar
angka = [1, 5, 3, 8, 2, 9]
for n in angka:
    if n > 7:
        print(f"Pertama > 7: {n}")
        break   # hentikan loop — tidak lanjut ke elemen berikutnya
# → Pertama > 7: 8

# break hanya keluar dari loop TERDALAM
for i in range(3):
    for j in range(3):
        if j == 1:
            break    # hanya keluar dari loop j, loop i terus
    print(f"i={i}")  # ini tetap dieksekusi

# continue melompat ke iterasi berikutnya tanpa menjalankan sisa blok
for i in range(10):
    if i % 2 == 0:
        continue    # lewati angka genap
    print(i, end=" ")
# → 1 3 5 7 9

# Berguna untuk early skip dengan guard clause
for pengguna in daftar_pengguna:
    if not pengguna.aktif:
        continue           # skip pengguna non-aktif
    if pengguna.saldo < 0:
        continue           # skip pengguna dengan saldo negatif
    kirim_promo(pengguna)  # hanya dieksekusi untuk pengguna valid

# pass adalah placeholder sintaks — digunakan saat blok kode wajib ada
# tapi belum diimplementasikan

class ModelBaru:
    pass   # kelas kosong — valid secara sintaks

def fungsi_todo():
    pass   # TODO: implementasi nanti

# Dalam kondisi yang diabaikan
for item in data:
    if kondisi_khusus(item):
        pass   # sengaja diabaikan
    else:
        proses(item)

# Berbeda dengan ...(Ellipsis) yang juga sering dipakai sebagai placeholder
def fungsi_abstract() -> None:
    ...   # Ellipsis — lebih sering di type stubs dan ABC

# else pada for/while — dieksekusi HANYA jika loop selesai TANPA break
for n in [2, 4, 6, 8]:
    if n % 2 != 0:
        print(f"{n} bukan genap")
        break
else:
    print("Semua bilangan genap!")   # → ini yang dieksekusi
# → Semua bilangan genap!

# Contoh pencarian
def cari_prima(n):
    for pembagi in range(2, int(n**0.5) + 1):
        if n % pembagi == 0:
            return False   # bukan prima
    return True            # prima

# def mendefinisikan fungsi
def sapa(nama: str) -> str:
    return f"Halo, {nama}!"

# return mengakhiri fungsi dan mengembalikan nilai
# Tanpa return eksplisit, fungsi mengembalikan None
def tanpa_return():
    x = 42   # tidak dikembalikan

# return bisa mengembalikan beberapa nilai (sebagai tuple)
def statistik(data):
    return min(data), max(data), sum(data) / len(data)

mn, mx, rata = statistik([1, 2, 3, 4, 5])

# return tanpa nilai — kembalikan None dan hentikan fungsi
def validasi(data):
    if not data:
        return    # early return — equivalent dengan return None
    proses(data)

# class mendefinisikan kelas (blueprint untuk objek)
class Hewan:
    def __init__(self, nama: str):
        self.nama = nama

    def bersuara(self) -> str:
        raise NotImplementedError

class Anjing(Hewan):       # Anjing mewarisi Hewan
    def bersuara(self) -> str:
        return "Guk!"

# class bisa mewarisi dari beberapa kelas (multiple inheritance)
class Amfibi(Hewan, Berenang, Melompat):
    pass

# lambda — fungsi anonim satu ekspresi
kuadrat = lambda x: x ** 2
print(kuadrat(5))   # → 25

# Paling berguna sebagai argumen fungsi
data = [{"nama": "Budi", "nilai": 85}, {"nama": "Ani", "nilai": 92}]
terurut = sorted(data, key=lambda d: d["nilai"], reverse=True)

# ANTI-PATTERN: lambda untuk logika kompleks
proses = lambda x, y: x**2 + y**2 if x > 0 and y > 0 else 0

# BENAR: fungsi biasa untuk logika yang tidak trivial
def proses(x, y):
    if x > 0 and y > 0:
        return x**2 + y**2
    return 0

# yield membuat fungsi menjadi generator — menghasilkan nilai satu per satu
def hitung_mundur(n):
    while n > 0:
        yield n    # "kembalikan" n, tapi jangan hentikan fungsi
        n -= 1

for angka in hitung_mundur(5):
    print(angka, end=" ")
# → 5 4 3 2 1

# Generator menghemat memori — nilai dihasilkan lazy
def baca_file_besar(path):
    with open(path) as f:
        for baris in f:
            yield baris.strip()   # hasilkan satu baris pada satu waktu

# yield from — delegasi ke generator lain
def gabung(*iterables):
    for it in iterables:
        yield from it   # lebih bersih dari: for item in it: yield item

list(gabung([1, 2], [3, 4], [5]))   # → [1, 2, 3, 4, 5]

# import — impor seluruh modul
import os
import math
import datetime

print(math.pi)      # akses dengan nama modul
print(os.getcwd())

# from ... import — impor item spesifik dari modul
from math import pi, sqrt, floor
from datetime import datetime, timedelta
from pathlib import Path

print(pi)           # akses langsung tanpa prefix modul
print(sqrt(16))     # → 4.0

# as — beri alias pada modul atau item yang diimpor
import numpy as np                    # alias untuk nama panjang
import pandas as pd
from datetime import datetime as dt   # alias untuk menghindari konflik

# from ... import * — impor semua (hindari ini!)
# from math import *   # ANTI-PATTERN: tidak jelas apa yang diimpor

# Import relatif (dalam package)
from . import utils          # impor dari modul dalam package yang sama
from ..models import User    # impor dari package induk

# Struktur lengkap penanganan eksepsi
try:
    hasil = int(input("Masukkan angka: "))
    print(10 / hasil)
except ValueError:
    print("Input bukan angka yang valid")
except ZeroDivisionError:
    print("Tidak bisa dibagi nol")
except (TypeError, OverflowError) as e:
    print(f"Error tidak terduga: {e}")
else:
    # Hanya dieksekusi jika TIDAK ada eksepsi di try
    print(f"Berhasil: {hasil}")
finally:
    # Selalu dieksekusi — untuk cleanup
    print("Selesai")

# raise — lempar eksepsi secara eksplisit
def bagi(a, b):
    if b == 0:
        raise ZeroDivisionError("Pembagi tidak boleh nol")
    return a / b

# raise from — exception chaining
def ambil_data(url):
    try:
        return requests.get(url)
    except ConnectionError as e:
        raise RuntimeError(f"Gagal ambil data dari {url}") from e

# raise tanpa argumen — re-raise eksepsi yang sedang ditangkap
try:
    proses_kritis()
except Exception:
    logging.exception("Proses gagal")
    raise   # teruskan eksepsi ke pemanggil

# global — deklarasikan bahwa variabel merujuk ke scope global
hitungan = 0

def tambah():
    global hitungan       # tanpa ini, assignment membuat variabel lokal baru
    hitungan += 1

tambah()
tambah()
print(hitungan)   # → 2

# ANTI-PATTERN: terlalu banyak menggunakan global
# Lebih baik: kembalikan nilai dari fungsi dan tangkap di luar
def tambah_bersih(hitungan):
    return hitungan + 1

hitungan = tambah_bersih(hitungan)

# nonlocal — merujuk ke variabel di enclosing scope (bukan global)
def buat_counter():
    n = 0

    def tambah():
        nonlocal n    # merujuk ke n di buat_counter, bukan global
        n += 1
        return n

    return tambah

counter = buat_counter()
print(counter())   # → 1
print(counter())   # → 2
print(counter())   # → 3

# with — context manager, memastikan cleanup otomatis
# Menggantikan pola try/finally yang verbose

# ANTI-PATTERN: buka file tanpa context manager
f = open("data.txt")
data = f.read()
f.close()   # bisa terlewat jika ada exception sebelumnya!

# BENAR: with memastikan file selalu ditutup
with open("data.txt", "r", encoding="utf-8") as f:
    data = f.read()
# f.close() dipanggil otomatis di sini — bahkan jika ada exception

# with untuk beberapa context manager sekaligus
with open("input.txt") as masuk, open("output.txt", "w") as keluar:
    keluar.write(masuk.read())

# with sering digunakan untuk:
# - file I/O
# - koneksi database
# - lock threading
# - transaction
# - mock dalam testing

import threading
lock = threading.Lock()
with lock:
    # kode thread-safe di sini
    modifikasi_data_bersama()
# lock dilepas otomatis

# del — hapus binding nama ke objek

# Hapus variabel
x = 42
del x
# print(x)   # → NameError: name 'x' is not defined

# Hapus elemen list
lst = [1, 2, 3, 4, 5]
del lst[2]          # hapus indeks 2
print(lst)          # → [1, 2, 4, 5]

del lst[1:3]        # hapus slice
print(lst)          # → [1, 5]

# Hapus key dari dict
d = {"a": 1, "b": 2, "c": 3}
del d["b"]
print(d)            # → {'a': 1, 'c': 3}

# Hapus atribut objek
class Konfigurasi:
    debug = True
    versi = "1.0"

del Konfigurasi.debug
# Konfigurasi.debug   # → AttributeError

# del membantu garbage collector membebaskan memori lebih cepat
data_besar = list(range(10_000_000))
# ... proses data ...
del data_besar   # lepas referensi agar GC bisa bebaskan memori

# assert ekspresi [, pesan] — lempar AssertionError jika ekspresi False
# Digunakan untuk memverifikasi asumsi selama development

def bagi(a, b):
    assert b != 0, f"Pembagi tidak boleh nol, diterima: {b}"
    return a / b

def proses_data(data):
    assert isinstance(data, list), "data harus berupa list"
    assert len(data) > 0, "data tidak boleh kosong"
    # proses...

# assert sangat berguna dalam testing
def test_tambah():
    assert tambah(2, 3) == 5
    assert tambah(-1, 1) == 0
    assert tambah(0, 0) == 0

import asyncio

# async def — mendefinisikan coroutine function
async def ambil_data(url: str) -> str:
    # await — tunggu coroutine lain selesai tanpa memblokir event loop
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

# async for — iterasi async
async def baca_stream(stream):
    async for chunk in stream:
        proses(chunk)

# async with — context manager async
async def dengan_koneksi():
    async with buat_koneksi() as conn:
        await conn.execute("SELECT 1")

# Menjalankan coroutine
async def main():
    hasil = await ambil_data("https://api.example.com/data")
    print(hasil)

asyncio.run(main())

# match/case — structural pattern matching
# Lebih dari sekadar switch — bisa mencocokkan struktur data

def proses_perintah(perintah):
    match perintah:
        case "keluar" | "exit" | "quit":
            return "Sampai jumpa!"
        case "bantuan":
            return "Perintah tersedia: keluar, bantuan, info"
        case str() if perintah.startswith("cari "):
            kata = perintah[5:]
            return f"Mencari: {kata}"
        case _:
            return f"Perintah tidak dikenal: {perintah}"

# Pattern matching pada struktur data
def analisis_titik(titik):
    match titik:
        case (0, 0):
            return "Titik asal"
        case (x, 0):
            return f"Pada sumbu X: {x}"
        case (0, y):
            return f"Pada sumbu Y: {y}"
        case (x, y):
            return f"Titik ({x}, {y})"

# Pattern matching pada dict
def routing_http(request):
    match request:
        case {"method": "GET", "path": path}:
            return handle_get(path)
        case {"method": "POST", "path": path, "body": body}:
            return handle_post(path, body)
        case {"method": method}:
            return f"Method {method} tidak didukung"

# type — mendefinisikan alias tipe (Python 3.12+)
# Menggantikan: NamaAlias = tipe  atau  NamaAlias: TypeAlias = tipe

type Vector = list[float]
type Matrix = list[Vector]
type Callback = Callable[[int, str], bool]

# Penggunaan dalam fungsi
def normalisasi(v: Vector) -> Vector:
    panjang = sum(x**2 for x in v) ** 0.5
    return [x / panjang for x in v]

# Sebelum Python 3.12, menggunakan TypeAlias dari typing
from typing import TypeAlias
Vector: TypeAlias = list[float]

# from dalam raise — exception chaining (bukan import)
try:
    data = json.loads(teks)
except json.JSONDecodeError as e:
    # Bungkus dalam eksepsi domain, tapi pertahankan konteks asli
    raise ValueError(f"Format data tidak valid: {teks!r}") from e

# from None — sembunyikan konteks asli
try:
    nilai = d["kunci"]
except KeyError:
    raise KeyError(f"Kunci 'kunci' tidak ditemukan") from None