Syntactic Sugar

Penulisan Ringkas untuk Pola Kode yang Berulang

Syntactic sugar adalah notasi ringkas untuk perilaku yang juga dapat ditulis secara lebih eksplisit. Notasi ini dapat mengurangi bagian yang berulang, tetapi sintaks yang lebih pendek hanya berguna jika pembaca tetap memahami maksud kode.

Python menyediakan beberapa bentuk ringkas untuk pola yang umum. Bentuk tersebut tidak otomatis membuat program berjalan lebih cepat dan tidak selalu identik dalam setiap detail. Gunakan bentuk ringkas ketika maksud kode menjadi lebih jelas.

List Comprehension

List comprehension membuat list baru dari iterable. Bentuk ini dapat mentransformasi nilai, memfilternya, atau menggabungkan kedua operasi dalam satu ekspresi.

List comprehension memiliki beberapa bentuk sintaks:

# Bentuk dasar
newlist = [expression for item in iterable]

# Dengan kondisi
newlist = [expression for item in iterable if condition]

# Dengan if-else (conditional expression harus sebelum for)
newlist = [if_expr if condition else else_expr for item in iterable]

Pada bentuk ketiga, ekspresi if-else harus muncul sebelum loop for. Pada bentuk kedua, kondisi if justru muncul setelah loop.

Implementasi List Comprehension

Contoh berikut memisahkan dua kasus: ekspresi kondisional dan filter.

# Data awal
x = [1, 2, 3, 4, 5, 6]

# Ekspresi kondisional di dalam list comprehension
parity = ["ganjil" if i % 2 else "genap" for i in x]
print(parity)
# Output: ['ganjil', 'genap', 'ganjil', 'genap', 'ganjil', 'genap']

# Contoh lain dengan kondisi
numbers = [1, 2, 3, 4, 5, 6]
result = [i**2 for i in numbers if i%2 == 0]
print(result)
# Output: [4, 16, 36]

Nested List Comprehension

Python juga mendukung list comprehension bersarang untuk menangani struktur data yang lebih kompleks:

# Data matriks
x = [[1, 2], [3, 4], [5, 6]]

# List comprehension bersarang
y = [col for row in x for col in row]
print(y)
# Output: [1, 2, 3, 4, 5, 6]

# Bandingkan dengan sintaks standar
y_standard = []
for row in x:
  for col in row:
      y_standard.append(col)
print(y_standard)
# Output yang sama: [1, 2, 3, 4, 5, 6]

List comprehension dapat menyatakan transformasi atau filter sederhana secara ringkas. Bentuk ini sering efisien, tetapi keterbacaan lebih penting daripada menghemat baris. Gunakan loop biasa jika ekspresinya mulai sulit dipahami. Notasinya menyerupai notasi pembentuk himpunan, tetapi list Python mempertahankan urutan dan nilai duplikat, sedangkan himpunan matematika tidak.

Sebagai contoh, [i**2 for i in range(4)] menghasilkan [0, 1, 4, 9]. Daftar kuadrat ini berhubungan dengan notasi matematika $\{i^2 : i \in \{0,1,2,3\}\}$.

Lambda Functions

Ekspresi lambda membuat objek fungsi tanpa statement def. Gunakan lambda untuk fungsi kecil yang langsung diberikan sebagai argumen.

Isi fungsi lambda hanya boleh berupa satu ekspresi, dan hasil ekspresi itu menjadi return value. Fungsi tersebut boleh memanggil fungsi lain seperti print(), tetapi tidak dapat memuat statement seperti return, assignment biasa, for, atau while. Fungsi lambda dapat disimpan dalam variabel, tetapi def bernama biasanya lebih jelas jika fungsi akan digunakan kembali.

Cara Menggunakan Lambda

Lambda menuliskan fungsi kecil dalam satu ekspresi. Contoh berikut memperlihatkan sintaksisnya lalu menugaskannya ke sebuah nama.

# Sintaks dasar lambda
lambda parameters : expression

# Contoh lambda sederhana
square = lambda x: x**2
print(square(5))  # Output: 25

# Lambda dengan beberapa parameter
add = lambda x, y: x + y
print(add(3, 4))  # Output: 7

# Bandingkan dengan fungsi biasa
def square_normal(x):
  return x**2

def add_normal(x, y):
  return x + y

Lambda dengan Built In Functions

Lambda pendek cocok digunakan sebagai callback, terutama sebagai fungsi pengurutan melalui key untuk sorted(). map() dan filter() juga menerimanya, walaupun comprehension yang setara kadang lebih mudah dibaca:

# Dengan map()
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # Output: [1, 4, 9, 16, 25]

# Dengan filter()
even_numbers = list(filter(lambda x: x%2 == 0, numbers))
print(even_numbers)  # Output: [2, 4]

# Dengan sorted()
students = [('Alice', 85), ('Bob', 90), ('Charlie', 78)]
sorted_by_grade = sorted(students, key=lambda student: student[1])
print(sorted_by_grade)  # Output: [('Charlie', 78), ('Alice', 85), ('Bob', 90)]

Fitur Syntactic Sugar Lainnya

Python memiliki sintaks ringkas lain untuk operasi yang umum. Bentuk tersebut dapat meningkatkan keterbacaan, tetapi tidak menjamin performa runtime yang lebih baik. Periksa kesetaraan perilaku sebelum mengganti bentuk panjang, terutama ketika operasi dapat mengubah objek.

Assignment Operators

Python menyediakan assignment operator yang lebih ringkas untuk operasi umum:

# Compound assignment
a = 10
a += 1    # sama dengan: a = a + 1
print(a)  # Output: 11

a -= 2    # sama dengan: a = a - 2
print(a)  # Output: 9

a *= 3    # sama dengan: a = a * 3
print(a)  # Output: 27

a /= 3    # sama dengan: a = a / 3
print(a)  # Output: 9.0

Untuk angka immutable, contoh ini menghasilkan nilai yang sama dengan bentuk panjangnya. Pada objek mutable atau class buatan sendiri, += dapat mengubah objek yang sama secara langsung. Karena itu, perilakunya tidak selalu identik dengan reassignment melalui a = a + value.

Negative Indexing

Python memungkinkan penggunaan indeks negatif untuk mengakses elemen dari belakang:

# Negative indexing
data = [10, 20, 30, 40, 50]

# Mengakses elemen terakhir
print(data[-1])    # Output: 50
# sama dengan: data[len(data) - 1]

print(data[-2])    # Output: 40
print(data[-3])    # Output: 30

# Slicing dengan negative index
print(data[-3:])   # Output: [30, 40, 50]
print(data[:-2])   # Output: [10, 20, 30]

Multiple Assignment

Python mendukung multiple assignment untuk menetapkan beberapa variabel dalam satu baris:

# Multiple assignment
x, y, z = 1, 2, 3
print(f"x={x}, y={y}, z={z}")  # Output: x=1, y=2, z=3

# Unpacking list
coordinates = [10, 20]
x, y = coordinates
print(f"x={x}, y={y}")  # Output: x=10, y=20

# Swapping variables
a, b = 5, 10
print(f"Before: a={a}, b={b}")
a, b = b, a  # Swap tanpa variabel temporary
print(f"After: a={a}, b={b}")  # Output: After: a=10, b=5

Perbandingan Sintaks

Gunakan bentuk ringkas hanya jika pembaca dapat mengenali operasi yang dilakukan tanpa menelusuri alur kontrol atau efek samping yang tersembunyi. Jika tidak, gunakan bentuk eksplisit.