For AI agents: use /llms.txt for the Nakafa content index.
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. Tujuannya adalah memperjelas maksud, bukan sekadar mengurangi jumlah karakter.
List comprehension membuat list baru dari iterable apa pun. 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]Perhatikan bahwa pada bentuk ketiga, ekspresi if-else harus muncul sebelum loop for. Ini berbeda dengan bentuk kedua di mana kondisi if muncul setelah loop.
Mari lihat bagaimana list comprehension bekerja dalam praktik:
# 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]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 x] dapat dibaca sebagai "kuadrat dari i untuk setiap i dalam x", yang sangat mirip dengan notasi matematika .
Ekspresi lambda membuat objek fungsi tanpa statement def. Lambda paling berguna untuk fungsi kecil yang langsung diberikan sebagai argumen.
Body lambda berisi tepat satu ekspresi, dan nilai ekspresi itu menjadi nilai kembalinya. Lambda boleh memanggil fungsi seperti print(), tetapi tidak dapat memuat statement seperti return, assignment biasa, for, atau while. Lambda dapat disimpan dalam variabel, tetapi def bernama biasanya lebih jelas jika fungsinya akan digunakan kembali.
# Sintaks dasar lambda
lambda parameters : expression
# Contoh lambda sederhana
square = lambda x: x**2
print(square(5)) # Output: 25
# Lambda dengan multiple 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 + yLambda pendek cocok digunakan sebagai callback, terutama sebagai fungsi 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)]Python memiliki sintaks ringkas lain untuk operasi yang umum. Bentuk tersebut dapat meningkatkan keterbacaan, tetapi tidak menjamin performa runtime yang lebih baik.
Python menyediakan operator assignment 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.0Untuk angka immutable, contoh ini menghasilkan nilai yang sama dengan bentuk panjangnya. Pada objek mutable atau class buatan sendiri, += dapat menjalankan operasi in-place, sehingga perilakunya tidak selalu identik dengan pengikatan ulang melalui a = a + value.
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]Python memungkinkan assignment multiple 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=5Untuk memahami keunggulan syntactic sugar, mari bandingkan cara penulisan yang berbeda:
| Konsep | Sintaks Standar | Syntactic Sugar |
|---|---|---|
| Membuat list kuadrat | result = [] kemudian loop dengan append() | result = [i**2 for i in range(5)] |
| Fungsi sederhana | def double(x): return x * 2 | double = lambda x: x * 2 |
| Assignment | a = a + 5 | a += 5 |
| Akses elemen terakhir | data[len(data) - 1] | data[-1] |
Pilih bentuk ringkas jika operasinya menjadi lebih mudah dikenali. Jika bentuk tersebut justru menyembunyikan alur kontrol atau efek samping, bentuk eksplisit lebih baik untuk penjelasan dan sering juga lebih baik untuk programnya.