Panduan ini untuk siapa

• Pembelajar yang sudah memahami dasar Python dan ingin alat yang lebih ekspresif
• Developer yang ingin kode lebih bersih, reusable, dan lebih Pythonic
• Siapa pun yang bersiap menghadapi project dunia nyata di mana readability dan performance sama-sama penting

Apa yang akan Anda pelajari

• Cara kerja variable scope di Python menggunakan model LEGB
• Cara mengorganisasi kode dengan modules dan imports
• Kapan memakai lambda function, comprehensions, dan generator expressions
• Pemakaian praktis decorators, generators, dan context managers
• Dasar regular expressions, dunder methods, dan awareness metaprogramming

Mengapa topik ini penting

Fitur lanjutan Python bukan sekadar “nice to know.” Fitur ini langsung meningkatkan kualitas kode, mengurangi duplikasi, dan membuat program lebih mudah dirawat. Banyak codebase production sangat bergantung pada pola-pola ini.

Jika Anda hanya tahu sintaks dasar, Anda bisa menulis kode yang berjalan. Jika Anda juga memahami fitur bahasa lanjutan, Anda bisa menulis kode yang lebih bersih, lebih cepat dipahami, dan lebih mudah dikembangkan oleh tim seiring waktu.

Konsep inti

Scope dan modules: struktur di balik kode yang bersih

Python me-resolve nama menggunakan urutan LEGB:

• Local
• Enclosing
• Global
• Built-in

x = "global"

def outer():
	x = "enclosing"

	def inner():
		x = "local"
		print(x)

	inner()
	print(x)

outer()
print(x)

Expected output:

local
enclosing
global

Memahami scope mencegah bug halus dan membantu Anda merancang batas function yang lebih baik.

Modules adalah langkah berikutnya untuk menskalakan kode. Letakkan function yang reusable pada file terpisah, lalu import sesuai kebutuhan.

Sorotan built-in module yang sering dipakai:

• os untuk operasi terkait environment dan process
• sys untuk detail interpreter/runtime
• datetime untuk penanganan tanggal dan waktu
• math untuk helper numerik
• random untuk operasi pseudo-random

import os
import sys
import datetime
import math
import random

print(os.name)
print(sys.version_info.major)
print(datetime.date.today())
print(math.sqrt(16))
print(random.randint(1, 3))

Alat ekspresif: lambda, comprehensions, dan generators

Fitur-fitur ini membantu Anda mentransformasikan data secara ringkas.

Contoh lambda:

numbers = [5, 1, 9, 3]
sorted_numbers = sorted(numbers, key=lambda n: -n)
print(sorted_numbers)

Contoh list comprehension vs loop:

squares = [n * n for n in range(6)]
print(squares)

Generator expression menjaga penggunaan memori tetap rendah untuk data besar:

total = sum(n * n for n in range(1_000_000))
print(total)

Gunakan list comprehension untuk transformasi yang mudah dibaca, dan generator expression untuk pemrosesan bergaya streaming.

Decorators, context managers, dan special methods

Decorators memungkinkan Anda membungkus perilaku di sekitar function tanpa mengubah logika intinya.

def log_call(func):
	def wrapper(*args, **kwargs):
		print(f"Calling {func.__name__}")
		return func(*args, **kwargs)
	return wrapper

@log_call
def greet(name):
	return f"Hello, {name}"

print(greet("Ava"))

Context managers (with) menjamin perilaku setup/cleanup:

with open("notes.txt", "w", encoding="utf-8") as file:
	file.write("Python context managers are safe and clean.")

Dunder methods (__str__, __repr__, __len__, dll.) membuat class Anda berperilaku natural dengan operasi bawaan.

Contoh class decorator:

def add_label(label):
	def decorator(cls):
		cls.label = label
		return cls
	return decorator


@add_label("service")
class PaymentService:
	pass


print(PaymentService.label)

Contoh iterator dan generator (yield):

def countdown(start):
	current = start
	while current > 0:
		yield current
		current -= 1


for number in countdown(3):
	print(number)

Contoh iterator protocol (__iter__ dan __next__):

class CountdownIterator:
	def __init__(self, start):
		self.current = start

	def __iter__(self):
		return self

	def __next__(self):
		if self.current <= 0:
			raise StopIteration
		value = self.current
		self.current -= 1
		return value


for number in CountdownIterator(3):
	print(number)

Contoh custom context manager (membuat sendiri):

class TimerContext:
	def __enter__(self):
		import time
		self._time = time
		self.start = self._time.perf_counter()
		return self

	def __exit__(self, exc_type, exc, tb):
		elapsed = self._time.perf_counter() - self.start
		print(f"Elapsed: {elapsed:.6f}s")
		return False


with TimerContext():
	_ = sum(i * i for i in range(100_000))

Dasar metaprogramming (pengantar opsional): metaclass mengustomisasi proses pembuatan class itu sendiri. Sebagian besar project belum membutuhkan custom metaclass di tahap awal, tetapi Anda akan menemukannya di framework lanjutan.

Contoh metaclass minimal:

class AutoTagMeta(type):
	def __new__(mcls, name, bases, namespace):
		namespace["kind"] = "auto-tagged"
		return super().__new__(mcls, name, bases, namespace)


class Service(metaclass=AutoTagMeta):
	pass


print(Service.kind)

Panduan langkah demi langkah

Langkah 1 — Refactor kode ke module

Buat math_utils.py:

def area_of_circle(radius):
	return 3.14159 * radius * radius

def is_even(value):
	return value % 2 == 0

Buat main.py:

import math_utils

print(math_utils.area_of_circle(3))
print(math_utils.is_even(10))

Ini mengajarkan modularitas dan code reuse.

Langkah 2 — Ganti loop verbose dengan comprehensions dan generators

Mulai dari loop, lalu tulis ulang.

numbers = [1, 2, 3, 4, 5]
evens_squared = [n * n for n in numbers if n % 2 == 0]
print(evens_squared)

Untuk range besar, pindah ke generator expression:

result = sum(n for n in range(10_000_000) if n % 2 == 0)
print(result)

Ini menyeimbangkan readability dan performance.

Langkah 3 — Tambahkan wrapper behavior dengan decorators

Gunakan decorator untuk timing atau logging tanpa mengubah business logic.

import time

def timing(func):
	def wrapper(*args, **kwargs):
		start = time.perf_counter()
		value = func(*args, **kwargs)
		end = time.perf_counter()
		print(f"{func.__name__} took {end - start:.6f}s")
		return value
	return wrapper

@timing
def compute():
	return sum(i * i for i in range(200_000))

print(compute())

Ini adalah pola praktis untuk diagnostics dan observability.

Contoh praktis

Contoh 1 — Parse log dengan regular expressions

Regular expressions berguna untuk mengekstrak data terstruktur dari teks.

import re

line = "2026-02-23 ERROR User 1024 failed login"
pattern = r"(\d{4}-\d{2}-\d{2})\s+(ERROR|INFO|WARN)\s+User\s+(\d+)"

match = re.search(pattern, line)
if match:
	date, level, user_id = match.groups()
	print(date, level, user_id)

Expected output:

2026-02-23 ERROR 1024

Ini adalah blok bangunan umum untuk script monitoring.

Contoh 2 — Buat custom class lebih readable dengan dunder methods

Dunder methods meningkatkan debugging dan developer experience.

class Cart:
	def __init__(self, items):
		self.items = items

	def __len__(self):
		return len(self.items)

	def __repr__(self):
		return f"Cart(items={self.items!r})"

	def __str__(self):
		return f"Cart with {len(self)} item(s): {self.items}"


cart = Cart(["book", "keyboard", "mouse"])
print(len(cart))
print(repr(cart))
print(cart)

Expected output:

3
Cart(items=['book', 'keyboard', 'mouse'])
Cart with 3 item(s): ['book', 'keyboard', 'mouse']

Sekarang class Anda terintegrasi mulus dengan built-in functions dan output print.

Kesalahan umum dan cara menghindarinya

• Terlalu sering memakai lambda saat named function lebih jelas -> Gunakan lambda hanya untuk ekspresi pendek; pilih def untuk hal non-trivial.
• Menulis nested comprehension yang sulit dibaca -> Jaga comprehension tetap sederhana; kembali ke loop jika logika jadi kompleks.
• Lupa menjaga metadata function pada decorator -> Gunakan functools.wraps pada decorator production.
• Menyalahgunakan regex untuk semua masalah string -> Mulai dari split, replace, atau method sederhana dulu, lalu regex jika memang perlu.
• Bingung antara scope dan mutability -> Pass nilai secara eksplisit dan hindari global state yang tidak perlu.

Latihan cepat

• Buat module utils.py berisi tiga helper function, lalu import dan gunakan dari file lain.
• Tulis ulang transformasi berbasis loop menjadi list comprehension dan generator expression, lalu bandingkan readability.
• Bangun decorator yang menghitung berapa kali sebuah function dipanggil.

Ringkasan utama

• Fitur Python lanjutan membantu Anda menulis kode yang lebih singkat, jelas, dan mudah dirawat.
• Awareness terhadap scope (LEGB) mencegah bug tersembunyi dan memperjelas kepemilikan variable.
• Comprehensions dan generators sangat kuat, tetapi readability harus tetap prioritas utama.
• Decorators, context managers, dan dunder methods adalah alat praktis yang dipakai di project nyata.

Langkah berikutnya

Lanjut ke Object-Oriented Programming (OOP) di Python. Di panduan berikutnya, Anda akan merancang class, memodelkan object, dan menerapkan inheritance, encapsulation, serta polymorphism pada aplikasi Python terstruktur.