map() — Terapkan Fungsi ke Setiap Elemen List Sekaligus

Pada artikel sebelumnya tentang decorator, kamu sudah melihat cara membungkus perilaku tambahan di sekitar fungsi. Kali ini, kamu akan beralih dan melihat fungsi bawaan map() — alat yang kamu raih saat kamu ingin menerapkan fungsi yang sama ke setiap elemen list sekaligus.

map() berpasangan secara alami dengan lambda, dan mekanisme dasarnya mirip dengan list comprehension. Akhir-akhir ini, comprehension biasanya merupakan pilihan yang direkomendasikan daripada map().

Apa Itu map() — Higher-Order Function yang Mengenai Setiap Elemen

map(function, iterable) menerapkan fungsi argumen pertama ke setiap elemen dari argumen kedua (sebuah list, tuple, dll.) dan mengembalikan objek map yang memungkinkan kamu menarik hasil satu per satu. Kamu bisa mengiterasinya dengan for, atau membungkusnya dengan list() untuk memateralisasi semuanya sebagai list.

Karena argumen pertamanya adalah fungsi, map() itu sendiri terhitung sebagai higher-order function.

numbers = [1, 2, 3, 4, 5]

squared = map(lambda x: x ** 2, numbers)
print(type(squared))   # <class 'map'>
print(squared)         # <map object at 0x...>

# Tarik nilai keluar dengan list()
print(list(squared))   # [1, 4, 9, 16, 25]

# Fungsi bawaan juga bekerja (konversi list of strings ke int)
str_nums = ["10", "20", "30"]
print(list(map(int, str_nums)))   # [10, 20, 30]

Objek map sekali pakai

Nilai kembali map() adalah iterator — jenis yang sama yang kamu dapat dari generator — dan begitu kamu sudah menelusurinya, ia kosong. Panggil list(squared) kedua kalinya dan kamu akan mendapatkan []. Jika kamu perlu memakai hasilnya lebih dari sekali, lakukan list(map(...)) di depan dan bekerja dengan list.

Bangun list harga termasuk pajak (10%) dari list prices harga produk.

① Deklarasikan prices = [100, 250, 480, 1200].

② Kalikan setiap elemen dengan 1.1, konversi ke int, bangun list yang dihasilkan, dan tetapkan ke tax_included.

③ Cetak hasil dengan print(tax_included).

(Saat jawaban benar, penjelasan akan muncul.)

Meneruskan Beberapa Iterable Sekaligus

Dari argumen kedua dan seterusnya, map() menerima beberapa iterable. Dalam kasus itu, fungsi argumen pertama perlu menerima satu elemen dari masing-masing pada posisi yang sesuai. Tulis map(function, A, B) dan fungsinya diterapkan pada pasangan A[0] dan B[0], lalu A[1] dan B[1], dan seterusnya.

Misalnya, untuk mengalikan dua list numerik secara element-wise, map(lambda a, b: a * b, A, B) memberimu list hasil perkalian berpasangan.

A = [1, 2, 3]
B = [10, 20, 30]

# Kalikan elemen pada index yang sama
print(list(map(lambda a, b: a * b, A, B)))   # [10, 40, 90]

# Sama dengan tiga iterable
def calculate(x, y, op):
    return x + y if op == "plus" else x - y

xs = [10, 20, 30]
ys = [3,  3,  3]
ops = ["plus", "minus", "plus"]

print(list(map(calculate, xs, ys, ops)))     # [13, 17, 33]

Panjang yang tidak sesuai berhenti pada yang terpendek

Saat iterable yang kamu teruskan memiliki panjang berbeda, map() berhenti pada yang terpendek. Misalnya, map(f, [1, 2, 3, 4], [10, 20]) hanya berjalan dua kali. Jika kamu ingin penyelarasan eksplisit, periksa panjang sebelumnya, atau pasangkan map() dengan `zip()` tergantung kebutuhanmu.

Dari list nama produk dan list jumlah, bangun list string "nama × jumlah" menggunakan map().

① Deklarasikan items = ["apel", "jeruk", "anggur"] dan counts = [3, 5, 2].

② Bungkus map(lambda name, n: f"{name} × {n}", items, counts) dengan list(...) dan tetapkan ke labels.

③ Cetak masing-masing pada barisnya sendiri dengan for label in labels: print(label).

map() vs List Comprehension — Mana yang Harus Kamu Pakai?

Hampir semua yang bisa dilakukan map(), list comprehension juga bisa. Dokumentasi resmi Python dan buku-buku seperti Fluent Python merekomendasikan memprioritaskan comprehension dalam kode baru, dan dalam Python modern, comprehension adalah bentuk standar.

map() dahulu adalah default dalam kode lama, tetapi perannya menyusut ke kasus di mana kamu bisa menyerahkan nama fungsi yang ada tanpa menulis lambda (pikirkan map(int, str_nums)). Mari kita berderet perbedaannya.

nums = [1, 2, 3, 4, 5]

# Versi map()
print(list(map(lambda x: x ** 2, nums)))   # [1, 4, 9, 16, 25]

# Versi comprehension (lebih disukai)
print([x ** 2 for x in nums])              # [1, 4, 9, 16, 25]

# Saat kamu bisa meneruskan nama fungsi langsung, map() terlihat lebih bersih
str_nums = ["10", "20", "30"]
print(list(map(int, str_nums)))            # [10, 20, 30]
print([int(s) for s in str_nums])          # [10, 20, 30]

# Saat memfilter, comprehension jauh lebih ringkas
print([x for x in nums if x % 2 == 0])     # [2, 4]

Saat ragu, raihlah comprehension

Apakah kamu ingin mentransformasi, memfilter, atau melakukan keduanya, comprehension memungkinkan kamu menulis semuanya secara alami di dalam kurung yang sama. Jika kamu berkomitmen memakai map() hanya saat kamu menyerahkan nama fungsi yang ada apa adanya, kode kamu tetap konsisten. Lebih ringan untuk penulis dan pembaca, jadi prioritaskan comprehension dalam kode baru.

Konversi list string input ke list integer dalam dua cara: dengan map() dan dengan comprehension.

① Deklarasikan inputs = ["10", "20", "30", "40"].

② Bungkus map(int, inputs) dengan list(...), tetapkan ke via_map, dan print(via_map).

③ Bangun hasil yang sama dengan [int(s) for s in inputs], tetapkan ke via_comp, dan print(via_comp).

④ Akhirnya, jalankan print(via_map == via_comp) untuk memastikan kedua nilai sama.