40. Menulis Kode yang Bersih dan Mudah Dibaca

# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
def c(l):
    t=0
    for i in l:
        t=t+i
    return t/len(l)
 
data=[85,92,78,90,88]
result=c(data)
print(result)  # Output: 86.6

def calculate_average(numbers):
    """Hitung mean aritmetika dari sebuah list angka."""
    total = 0
    for number in numbers:
        total = total + number
    return total / len(numbers)
 
test_scores = [85, 92, 78, 90, 88]
average_score = calculate_average(test_scores)
print(average_score)  # Output: 86.6

# Sulit di-debug - variabel-variabel ini merepresentasikan apa?
# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
def process(x, y):
    if x > y:
        return x * (1 - y)
    return x
 
result = process(100, 0.1)

# Mudah di-debug - jelas apa yang terjadi
def apply_discount(price, discount_rate):
    """Hitung harga setelah menerapkan tingkat diskon (0.0 sampai 1.0)."""
    discount_amount = price * discount_rate
    final_price = price - discount_amount
    return final_price
 
original_price = 100
discount = 0.1  # diskon 10%
final_price = apply_discount(original_price, discount)
print(f"Final price: ${final_price}")
# Output: Final price: $90.0

# Nama buruk - tidak jelas apa yang direpresentasikan
# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
# Apa itu 'n'? Angka? Nama? Node?
# Apa itu 'd'? Tanggal? Jarak? Durasi?
# Apa itu 'l'? Terlihat seperti angka 1!
n = "Alice"
d = 25
l = [1, 2, 3]
calc = lambda x: x * 2
 
# Nama baik - jelas dan deskriptif
student_name = "Alice"
age_in_years = 25
test_scores = [1, 2, 3]
double_value = lambda x: x * 2

# Dapat diterima: sangat singkat, konteksnya jelas
for i in range(10):
    print(i)
 
for x, y in coordinates:
    distance = (x**2 + y**2) ** 0.5
 
# Tapi lebih baik gunakan nama deskriptif agar jelas
for student_index in range(len(students)):
    print(students[student_index])
 
for point_x, point_y in coordinates:
    distance = (point_x**2 + point_y**2) ** 0.5

# Variabel
user_name = "Bob"
total_price = 99.99
is_valid = True
max_retry_count = 3
 
# Fungsi
def calculate_tax(amount, rate):
    """Hitung pajak untuk jumlah tertentu."""
    return amount * rate
 
def send_email_notification(recipient, message):
    """Kirim email ke penerima yang ditentukan."""
    print(f"Sending to {recipient}: {message}")
 
# Menggunakan fungsi
tax_amount = calculate_tax(100, 0.08)
send_email_notification("user@example.com", "Welcome!")

# Konstanta di level modul
MAX_LOGIN_ATTEMPTS = 3
DEFAULT_TIMEOUT_SECONDS = 30
PI = 3.14159
DATABASE_URL = "postgresql://localhost/mydb"
 
def validate_password_length(password):
    """Periksa apakah password memenuhi syarat panjang minimum."""
    MIN_PASSWORD_LENGTH = 8  # Konstanta di dalam fungsi
    return len(password) >= MIN_PASSWORD_LENGTH
 
# Menggunakan konstanta
if login_attempts > MAX_LOGIN_ATTEMPTS:
    print("Account locked")

# Python tidak punya sintaks konstanta - ini hanya variabel biasa
MAX_LOGIN_ATTEMPTS = 3
 
# Python tidak akan mencegah kamu mengubahnya
MAX_LOGIN_ATTEMPTS = 5  # ❌ Secara teknis bisa, tapi melanggar konvensi
 
# Konvensi penamaan adalah sinyal tentang INTENT:
# "Saya menamai ini dengan HURUF BESAR untuk menunjukkan saya tidak ingin ini diubah"

# Nilai ini akan berubah - gunakan huruf kecil
max_login_attempts = 3
max_login_attempts = 5  # ✅ OK - namanya menunjukkan bisa berubah
 
# Nilai ini seharusnya tidak pernah berubah - gunakan HURUF BESAR
MAX_LOGIN_ATTEMPTS = 3
# Jangan meng-assign ulang nanti di kode

# Definisi class
class Student:
    """Merepresentasikan seorang siswa dengan nama dan nilai."""
    def __init__(self, name):
        self.name = name
        self.grades = []
 
class ShoppingCart:
    """Mengelola item di keranjang belanja."""
    def __init__(self):
        self.items = []
    
    def add_item(self, item):
        """Tambahkan item ke keranjang."""
        self.items.append(item)
 
class DatabaseConnection:
    """Menangani koneksi database dan query."""
    def __init__(self, url):
        self.url = url
 
# Membuat instance (catatan: instance memakai nama variabel snake_case)
student = Student("Alice")
shopping_cart = ShoppingCart()
db_connection = DatabaseConnection("localhost")

class BankAccount:
    """Merepresentasikan akun bank dengan pelacakan saldo."""
    
    def __init__(self, account_number, initial_balance):
        self.account_number = account_number
        self._balance = initial_balance  # Attribute internal
    
    def deposit(self, amount):
        """Tambahkan uang ke akun."""
        if self._validate_amount(amount):  # Method internal
            self._balance += amount
    
    def _validate_amount(self, amount):
        """Helper internal untuk memvalidasi jumlah transaksi."""
        return amount > 0
    
    def get_balance(self):
        """Kembalikan saldo saat ini."""
        return self._balance
 
# Menggunakan class
account = BankAccount("12345", 1000)
account.deposit(500)
print(account.get_balance())  # Output: 1500
 
# Secara teknis bisa, tapi melanggar konvensi
print(account._balance)
# Output: 1500 (works, but you shouldn't do this!)
 
# Secara teknis bisa, tapi melanggar konvensi
result = account._validate_amount(100)
# Output: True (works, but you shouldn't do this!)

class Point:
    """Merepresentasikan sebuah titik 2D."""
    
    def __init__(self, x, y):  # Method khusus: inisialisasi
        self.x = x
        self.y = y
    
    def __str__(self):  # Method khusus: representasi string
        return f"Point({self.x}, {self.y})"
    
    def __add__(self, other):  # Method khusus: operator penjumlahan
        return Point(self.x + other.x, self.y + other.y)
 
p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1)  # Output: Point(1, 2)
print(p1 + p2)  # Output: Point(4, 6)

def calculate_grade(score):
    """Tentukan nilai huruf dari skor numerik."""
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    else:
        return "F"
 
# Indentasi bertingkat: 4 spasi per level
def process_students(students):
    """Proses sebuah list data siswa."""
    for student in students:
        if student["active"]:
            grade = calculate_grade(student["score"])
            print(f"{student['name']}: {grade}")
 
students = [
    {"name": "Alice", "score": 92, "active": True},
    {"name": "Bob", "score": 78, "active": True}
]
process_students(students)
# Output:
# Alice: A
# Bob: C

# Terlalu panjang - sulit dibaca
# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
def calculate_monthly_payment(principal, annual_rate, years):
    return principal * (annual_rate / 12) * (1 + annual_rate / 12) ** (years * 12) / ((1 + annual_rate / 12) ** (years * 12) - 1)
 
# Lebih baik - dipecah menjadi baris yang mudah dibaca
def calculate_monthly_payment(principal, annual_rate, years):
    """Hitung cicilan bulanan pinjaman memakai rumus amortisasi."""
    monthly_rate = annual_rate / 12
    num_payments = years * 12
    
    numerator = principal * monthly_rate * (1 + monthly_rate) ** num_payments
    denominator = (1 + monthly_rate) ** num_payments - 1
    
    return numerator / denominator
 
payment = calculate_monthly_payment(200000, 0.045, 30)
print(f"Monthly payment: ${payment:.2f}")  # Output: Monthly payment: $1013.37

# Pemanggilan fungsi yang panjang
result = some_function(
    first_argument,
    second_argument,
    third_argument,
    fourth_argument
)
 
# List yang panjang
colors = [
    "red", "green", "blue",
    "yellow", "orange", "purple",
    "pink", "brown", "gray"
]
 
# String yang panjang
message = (
    "This is a very long message that needs to be broken "
    "across multiple lines for readability. Python automatically "
    "concatenates adjacent string literals."
)
print(message)
# Output: This is a very long message that needs to be broken across multiple lines for readability. Python automatically concatenates adjacent string literals.

# Spasi buruk - padat dan sulit dibaca
# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
x=5
y=x*2+3
result=calculate_tax(100,0.08)
data=[1,2,3,4,5]
 
# Spasi baik - jelas dan mudah dibaca
x = 5
y = x * 2 + 3
result = calculate_tax(100, 0.08)
data = [1, 2, 3, 4, 5]
 
# Spasi dalam ekspresi
total = (price * quantity) + shipping_cost
is_valid = (age >= 18) and (has_license == True)
 
# Spasi dalam definisi fungsi
def calculate_discount(price, discount_rate, minimum_purchase=0):
    """Hitung harga diskon jika pembelian minimum terpenuhi."""
    if price >= minimum_purchase:
        return price * (1 - discount_rate)
    return price

# Spasi yang benar untuk keyword argument
result = calculate_discount(price=100, discount_rate=0.1, minimum_purchase=50)
 
# Spasi yang benar untuk parameter default
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

def first_function():
    """Fungsi pertama."""
    pass
 
 
def second_function():
    """Fungsi kedua."""
    pass
 
 
class MyClass:
    """Sebuah definisi class."""
    pass

class Student:
    """Merepresentasikan seorang siswa dengan nilai."""
    
    def __init__(self, name):
        self.name = name
        self.grades = []
    
    def add_grade(self, grade):
        """Tambahkan nilai ke catatan siswa."""
        self.grades.append(grade)
    
    def get_average(self):
        """Hitung rata-rata nilai siswa."""
        if not self.grades:
            return 0
        return sum(self.grades) / len(self.grades)

def process_order(order_items, customer):
    """Proses pesanan pelanggan dan hitung total."""
    
    # Hitung subtotal
    subtotal = 0
    for item in order_items:
        subtotal += item["price"] * item["quantity"]
    
    # Terapkan diskon pelanggan
    discount = 0
    if customer["is_premium"]:
        discount = subtotal * 0.1
    
    # Hitung pajak
    tax = (subtotal - discount) * 0.08
    
    # Hitung total akhir
    total = subtotal - discount + tax
    
    return {
        "subtotal": subtotal,
        "discount": discount,
        "tax": tax,
        "total": total
    }

# Buruk - spasi di akhir baris yang tidak terlihat (ditunjukkan sebagai · untuk ilustrasi)
# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
def calculate(x):···
    return x * 2···
 
# Baik - tanpa spasi di akhir baris
def calculate(x):
    return x * 2

# Komentar buruk - menyatakan hal yang sudah jelas
# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
x = x + 1  # Tambahkan 1 ke x
 
# Komentar baik - menjelaskan kenapa
x = x + 1  # Sesuaikan untuk indexing berbasis nol
 
# Komentar buruk - redundan dengan kode
# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
# Periksa apakah age lebih besar atau sama dengan 18
if age >= 18:
    print("Adult")
 
# Komentar baik - menjelaskan logika bisnis
# Usia legal untuk minum alkohol di AS
if age >= 21:
    print("Can purchase alcohol")

def binary_search(sorted_list, target):
    """Cari target dalam sorted list menggunakan binary search."""
    left = 0
    right = len(sorted_list) - 1
    
    while left <= right:
        # Hitung titik tengah, menghindari integer overflow
        # (right + left) // 2 bisa overflow dengan indeks yang sangat besar
        mid = left + (right - left) // 2
        
        if sorted_list[mid] == target:
            return mid
        elif sorted_list[mid] < target:
            left = mid + 1  # Target ada di setengah kanan
        else:
            right = mid - 1  # Target ada di setengah kiri
    
    return -1  # Target tidak ditemukan

def calculate_shipping_cost(weight, distance):
    """Hitung biaya pengiriman berdasarkan berat dan jarak."""
    base_cost = 5.00
    
    # Promo gratis ongkir untuk barang berat (kebijakan perusahaan per 2024)
    # Ini mendorong pesanan dalam jumlah besar dan mengurangi biaya ongkir per unit
    if weight > 50:
        return 0
    
    # Tarif standar: $0.50 per pound ditambah $0.10 per mile
    # Berdasarkan kontrak carrier yang dinegosiasikan di Q1 2024
    return base_cost + (weight * 0.50) + (distance * 0.10)

def process_data(data):
    """Proses record data yang masuk."""
    # TODO: Ini perbaikan sementara untuk record yang tidak sesuai format
    # Hapus setelah validasi data diimplementasikan di upstream
    if not isinstance(data, list):
        data = [data]
    
    for record in data:
        # Proses setiap record
        pass

def calculate_bmi(weight_kg, height_m):
    """
    Hitung Body Mass Index (BMI).
    
    BMI dihitung sebagai berat dalam kilogram dibagi kuadrat tinggi dalam meter.
    
    Args:
        weight_kg: Berat dalam kilogram (float atau int)
        height_m: Tinggi dalam meter (float atau int)
    
    Returns:
        float: Nilai BMI yang dihitung
    
    Example:
        >>> calculate_bmi(70, 1.75)
        22.857142857142858
    """
    return weight_kg / (height_m ** 2)
 
# Mengakses docstring
print(calculate_bmi.__doc__)
# Output:
#     Hitung Body Mass Index (BMI).
#     
#     BMI dihitung sebagai berat dalam kilogram dibagi kuadrat tinggi dalam meter.
#     ...

def square(x):
    """Kembalikan kuadrat dari x."""
    return x * x
 
def is_even(n):
    """Return True jika n genap, False jika tidak."""
    return n % 2 == 0

def find_prime_factors(n):
    """
    Temukan semua faktor prima dari sebuah bilangan bulat positif.
    
    Fungsi ini mengembalikan list bilangan prima yang jika dikalikan
    bersama-sama akan sama dengan angka input. Faktor dikembalikan dalam urutan menaik.
    
    Args:
        n: Bilangan bulat positif yang lebih besar dari 1
    
    Returns:
        list: Faktor prima dalam urutan menaik
    
    Raises:
        ValueError: Jika n kurang dari 2
    
    Example:
        >>> find_prime_factors(12)
        [2, 2, 3]
        >>> find_prime_factors(17)
        [17]
    """
    if n < 2:
        raise ValueError("n must be at least 2")
    
    factors = []
    divisor = 2
    
    while n > 1:
        while n % divisor == 0:
            factors.append(divisor)
            n = n // divisor
        divisor += 1
    
    return factors

class BankAccount:
    """
    Merepresentasikan akun bank dengan operasi setoran dan penarikan.
    
    Class ini menjaga saldo akun dan menyediakan method untuk
    menyetor dan menarik uang. Semua transaksi divalidasi untuk mencegah saldo negatif.
    
    Attributes:
        account_number: Identifier unik untuk akun
        balance: Saldo akun saat ini dalam dolar
    """
    
    def __init__(self, account_number, initial_balance=0):
        """
        Inisialisasi akun bank baru.
        
        Args:
            account_number: Identifier akun yang unik (string)
            initial_balance: Saldo awal (default: 0)
        """
        self.account_number = account_number
        self.balance = initial_balance
    
    def deposit(self, amount):
        """
        Tambahkan uang ke akun.
        
        Args:
            amount: Jumlah yang akan disetor (harus positif)
        
        Raises:
            ValueError: Jika amount tidak positif
        """
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self.balance += amount

def calculate_compound_interest(principal, rate, time, compounds_per_year=1):
    """
    Hitung bunga majemuk pada investasi.
    
    Menggunakan rumus bunga majemuk: A = P(1 + r/n)^(nt)
    di mana A adalah jumlah akhir, P adalah pokok, r adalah suku bunga tahunan,
    n adalah jumlah penggandaan per tahun, dan t adalah waktu dalam tahun.
    
    Args:
        principal: Jumlah investasi awal (float)
        rate: Suku bunga tahunan dalam desimal (misalnya 0.05 untuk 5%)
        time: Periode investasi dalam tahun (float)
        compounds_per_year: Berapa kali bunga digandakan per tahun
                           (default: 1 untuk penggandaan tahunan)
    
    Returns:
        float: Jumlah akhir setelah bunga majemuk
    
    Example:
        >>> calculate_compound_interest(1000, 0.05, 10, 12)
        1647.0095
    """
    return principal * (1 + rate / compounds_per_year) ** (compounds_per_year * time)

def process_payment(amount, payment_method):
    """Proses transaksi pembayaran."""
    # TODO: Tambahkan dukungan untuk pembayaran cryptocurrency
    # TODO: Implementasikan pemeriksaan deteksi fraud
    
    if payment_method == "credit_card":
        return process_credit_card(amount)
    elif payment_method == "paypal":
        return process_paypal(amount)
    else:
        raise ValueError(f"Unsupported payment method: {payment_method}")

"""
student_manager.py
 
Kelola data siswa termasuk nilai dan perhitungan GPA.
 
Modul ini menyediakan fungsi untuk menambahkan siswa, mencatat nilai,
dan menghitung grade point average.
"""
 
# Import standard library
import sys
from datetime import datetime
 
# Import third-party (jika ada)
# import requests
 
# Import lokal (jika ada)
# from .database import save_student
 
# Konstanta
MAX_GRADE = 100
MIN_GRADE = 0
PASSING_GRADE = 60
 
# Fungsi
def calculate_gpa(grades):
    """
    Hitung GPA dari sebuah list nilai numerik.
    
    Args:
        grades: List nilai numerik (0-100)
    
    Returns:
        float: GPA pada skala 4.0
    """
    if not grades:
        return 0.0
    
    average = sum(grades) / len(grades)
    
    # Konversi ke skala 4.0
    if average >= 90:
        return 4.0
    elif average >= 80:
        return 3.0
    elif average >= 70:
        return 2.0
    elif average >= 60:
        return 1.0
    else:
        return 0.0
 
def validate_grade(grade):
    """
    Periksa apakah sebuah nilai berada dalam rentang yang valid.
    
    Args:
        grade: Nilai numerik yang akan divalidasi
    
    Returns:
        bool: True jika grade valid, False jika tidak
    """
    return MIN_GRADE <= grade <= MAX_GRADE
 
# Eksekusi main
if __name__ == "__main__":
    # Kode yang berjalan saat script dieksekusi langsung
    test_grades = [85, 92, 78, 88]
    gpa = calculate_gpa(test_grades)
    print(f"GPA: {gpa}")  # Output: GPA: 3.0

# Import standard library
import os
import sys
from datetime import datetime, timedelta
from pathlib import Path
 
# Import third-party
import requests
from flask import Flask, render_template
 
# Import aplikasi lokal
from myapp.database import connect_db
from myapp.models import User, Product
from myapp.utils import format_currency

# Import seluruh modul
import math
result = math.sqrt(16)  # Output: 4.0
 
# Import item tertentu
from math import sqrt, pi
result = sqrt(16)  # Output: 4.0
 
# Import dengan alias
import numpy as np
array = np.array([1, 2, 3])
 
# Import beberapa item
from os import path, getcwd, listdir

# Buruk - tidak jelas sqrt berasal dari mana
# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
from math import *
result = sqrt(16)
 
# Baik - import eksplisit
from math import sqrt
result = sqrt(16)

"""Pengaturan konfigurasi untuk aplikasi."""
 
import os
 
# Konstanta aplikasi
APP_NAME = "Student Manager"
VERSION = "1.0.0"
DEBUG_MODE = True
 
# Konfigurasi database
DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///students.db")
MAX_CONNECTIONS = 10
 
# Aturan bisnis
MAX_STUDENTS_PER_CLASS = 30
PASSING_GRADE = 60
GRADE_WEIGHTS = {
    "homework": 0.3,
    "midterm": 0.3,
    "final": 0.4
}
 
def calculate_final_grade(homework, midterm, final):
    """Hitung nilai akhir berbobot."""
    return (
        homework * GRADE_WEIGHTS["homework"] +
        midterm * GRADE_WEIGHTS["midterm"] +
        final * GRADE_WEIGHTS["final"]
    )

"""Modul pemrosesan pesanan."""
 
# Fungsi API publik
def process_order(order_items, customer):
    """
    Proses pesanan pelanggan.
    
    Ini adalah entry point utama untuk pemrosesan pesanan.
    """
    subtotal = _calculate_subtotal(order_items)
    discount = _calculate_discount(subtotal, customer)
    tax = _calculate_tax(subtotal - discount)
    total = subtotal - discount + tax
    
    return {
        "subtotal": subtotal,
        "discount": discount,
        "tax": tax,
        "total": total
    }
 
def validate_order(order_items):
    """Validasi bahwa sebuah pesanan berisi item yang valid."""
    if not order_items:
        return False
    
    for item in order_items:
        if not _validate_item(item):
            return False
    
    return True
 
# Fungsi helper internal
def _calculate_subtotal(items):
    """Hitung subtotal pesanan (penggunaan internal)."""
    total = 0
    for item in items:
        total += item["price"] * item["quantity"]
    return total
 
def _calculate_discount(subtotal, customer):
    """Hitung diskon pelanggan (penggunaan internal)."""
    if customer.get("is_premium"):
        return subtotal * 0.1
    return 0
 
def _calculate_tax(amount):
    """Hitung pajak penjualan (penggunaan internal)."""
    TAX_RATE = 0.08
    return amount * TAX_RATE
 
def _validate_item(item):
    """Validasi satu item pesanan (penggunaan internal)."""
    required_fields = ["name", "price", "quantity"]
    return all(field in item for field in required_fields)

"""Sistem manajemen pengguna."""
 
# Konstanta
DEFAULT_ROLE = "user"
ADMIN_ROLE = "admin"
 
# Base class dulu
class User:
    """Class user dasar."""
    
    def __init__(self, username, email):
        self.username = username
        self.email = email
        self.role = DEFAULT_ROLE
    
    def can_edit(self, resource):
        """Periksa apakah user dapat mengedit sebuah resource."""
        return resource.owner == self.username
 
# Derived class setelah base class
class AdminUser(User):
    """Administrator dengan hak istimewa lebih tinggi."""
    
    def __init__(self, username, email):
        super().__init__(username, email)
        self.role = ADMIN_ROLE
    
    def can_edit(self, resource):
        """Admin dapat mengedit resource apa pun."""
        return True
 
# Class terkait dikelompokkan bersama
class Resource:
    """Merepresentasikan sebuah resource yang bisa dimiliki dan diedit."""
    
    def __init__(self, name, owner):
        self.name = name
        self.owner = owner
 
# Fungsi utilitas terkait class
def create_user(username, email, is_admin=False):
    """Factory function untuk membuat tipe user yang sesuai."""
    if is_admin:
        return AdminUser(username, email)
    return User(username, email)

"""math_utils.py - Fungsi utilitas matematika."""
 
def add(a, b):
    """Tambah dua angka."""
    return a + b
 
def multiply(a, b):
    """Kalikan dua angka."""
    return a * b
 
# Kode ini hanya berjalan ketika file dieksekusi langsung
if __name__ == "__main__":
    # Uji fungsi
    print(f"5 + 3 = {add(5, 3)}")  # Output: 5 + 3 = 8
    print(f"5 * 3 = {multiply(5, 3)}")  # Output: 5 * 3 = 15

# another_file.py
from math_utils import add, multiply
 
result = add(10, 20)
print(result)  # Output: 30
# Kode test dari math_utils.py TIDAK berjalan

"""temperature.py - Utilitas konversi suhu."""
 
def celsius_to_fahrenheit(celsius):
    """Konversi Celsius ke Fahrenheit."""
    return (celsius * 9/5) + 32
 
def fahrenheit_to_celsius(fahrenheit):
    """Konversi Fahrenheit ke Celsius."""
    return (fahrenheit - 32) * 5/9
 
if __name__ == "__main__":
    # Demonstrasikan fungsi
    print("Temperature Conversion Examples:")
    print(f"0°C = {celsius_to_fahrenheit(0)}°F")  # Output: 0°C = 32.0°F
    print(f"100°C = {celsius_to_fahrenheit(100)}°F")  # Output: 100°C = 212.0°F
    print(f"32°F = {fahrenheit_to_celsius(32)}°C")  # Output: 32°F = 0.0°C

"""data_processor.py - Memproses dan menganalisis file data."""
 
import sys
 
def load_data(filename):
    """Muat data dari sebuah file."""
    with open(filename) as f:
        return [line.strip() for line in f]
 
def analyze_data(data):
    """Lakukan analisis pada data."""
    return {
        "count": len(data),
        "average_length": sum(len(item) for item in data) / len(data)
    }
 
if __name__ == "__main__":
    # Saat dijalankan sebagai script, proses argumen command-line
    if len(sys.argv) < 2:
        print("Usage: python data_processor.py <filename>")
        sys.exit(1)
    
    filename = sys.argv[1]
    data = load_data(filename)
    results = analyze_data(data)
    
    print(f"Processed {results['count']} items")
    print(f"Average length: {results['average_length']:.2f}")

$ python data_processor.py data.txt
Processed 42 items
Average length: 15.23

# my_analysis.py
from data_processor import load_data, analyze_data
 
my_data = load_data("myfile.txt")
results = analyze_data(my_data)
print(f"Found {results['count']} items")

"""calculator.py - Operasi kalkulator dasar."""
 
def add(a, b):
    """Tambah dua angka."""
    return a + b
 
def subtract(a, b):
    """Kurangi b dari a."""
    return a - b
 
if __name__ == "__main__":
    # Test cepat
    assert add(2, 3) == 5
    assert subtract(10, 4) == 6
    print("All tests passed!")  # Output: All tests passed!

"""report_generator.py - Menghasilkan laporan dari data."""
 
import sys
 
def load_data(filename):
    """Muat data dari file."""
    # Implementasi di sini
    pass
 
def generate_report(data):
    """Buat laporan dari data."""
    # Implementasi di sini
    pass
 
def save_report(report, output_file):
    """Simpan laporan ke file."""
    # Implementasi di sini
    pass
 
def main():
    """Entry point utama untuk script."""
    if len(sys.argv) < 3:
        print("Usage: python report_generator.py <input> <output>")
        return 1
    
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    
    try:
        data = load_data(input_file)
        report = generate_report(data)
        save_report(report, output_file)
        print(f"Report saved to {output_file}")
        return 0
    except Exception as e:
        print(f"Error: {e}")
        return 1
 
if __name__ == "__main__":
    # Keluar dengan status code dari main (0 = sukses, 1 = error)
    sys.exit(main())

# Buruk - logika kompleks di blok main
# PERINGATAN: Gaya buruk - hanya untuk demonstrasi
if __name__ == "__main__":
    data = []
    for i in range(100):
        if i % 2 == 0:
            data.append(i * 2)
    result = sum(data) / len(data)
    print(result)
 
# Baik - logika ada di fungsi, blok main mengoordinasikan
def generate_even_doubles(limit):
    """Hasilkan bilangan genap yang digandakan hingga limit."""
    return [i * 2 for i in range(limit) if i % 2 == 0]
 
def calculate_average(numbers):
    """Hitung rata-rata dari numbers."""
    return sum(numbers) / len(numbers)
 
if __name__ == "__main__":
    data = generate_even_doubles(100)
    result = calculate_average(data)
    print(result)  # Output: 99.0

"""
file_processor.py - Memproses file teks dengan berbagai operasi.
 
Usage:
    python file_processor.py <input_file> <output_file> [--uppercase]
 
Arguments:
    input_file: Path ke file input
    output_file: Path ke file output
    --uppercase: Ubah teks menjadi huruf besar (opsional)
"""
 
import sys
 
def process_file(input_path, output_path, uppercase=False):
    """Proses file dengan opsi yang ditentukan."""
    with open(input_path) as f:
        content = f.read()
    
    if uppercase:
        content = content.upper()
    
    with open(output_path, 'w') as f:
        f.write(content)
 
if __name__ == "__main__":
    if len(sys.argv) < 3:
        print(__doc__)  # Cetak docstring modul
        sys.exit(1)
    
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    uppercase = "--uppercase" in sys.argv
    
    process_file(input_file, output_file, uppercase)
    print(f"Processed {input_file} -> {output_file}")