Fungsi Python map(): Panduan Lengkap

Fungsi map() di Python adalah alat built-in yang kuat yang memfasilitasi pola pemrograman fungsional untuk transformasi data. Jika Anda ingin memproses dataset besar, membersihkan data teks, atau melakukan perhitungan massal, maka fungsi map() dapat sangat membantu untuk meningkatkan produktivitas.

Dalam tutorial ini, saya akan menunjukkan sintaks, penerapan praktis, dan teknik lanjutan dari fungsi map() di Python. Kita juga akan membahas lazy evaluation untuk efisiensi memori dan membandingkan map() dengan alternatif seperti list comprehension, serta membahas praktik terbaik untuk performa optimal.

Memahami iterator hanyalah langkah pertama untuk menulis kode yang efisien. Untuk benar-benar menguasai manipulasi data, Anda memerlukan kotak peralatan pemrograman Python yang lengkap, mencakup mulai dari penanganan error hingga iterable tingkat lanjut.

Sintaks Python map()

Sebelum melihat penggunaan fungsi map(), mari kita pahami cara kerjanya. Memahami sintaks dan perilakunya membantu kita mengaplikasikannya secara lebih efektif.

Dasar-dasar fungsi map()

Fungsi map() adalah utilitas bawaan Python yang menerapkan fungsi tertentu pada setiap item dalam sebuah iterable (seperti list, tuple, atau string) dan mengembalikan sebuah iterator berisi hasil transformasi. Hasilnya, fungsi ini mendorong sifat immutability dan reusable code, yang penting dalam pipeline pemrosesan data dan prapemrosesan fitur untuk model machine learning. 

Sintaksnya sederhana, seperti di bawah ini:

map(function, iterable, ...) Didukung oleh

Parameter function, yang bisa berupa fungsi bawaan seperti len() atau fungsi kustom, diterapkan pada setiap item dalam iterable. Kita juga bisa menambahkan beberapa iterable untuk memungkinkan pemetaan paralel. Ini akan dibahas nanti.

Berbeda dengan eager evaluation (yang menghitung semuanya di awal), map() menggunakan lazy evaluation. Fungsi ini mengembalikan objek map, sebuah iterator yang menghasilkan nilai sesuai permintaan. Perhitungan ditunda hingga Anda melakukan iterasi, sehingga menghemat memori untuk dataset besar.

Sebagai gambaran cepat, pertimbangkan contoh sederhana untuk menguadratkan angka:

numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared))Didukung oleh

[1, 4, 9, 16]Didukung oleh

Nilai parameter dan nilai kembalian

Fungsi map() memerlukan setidaknya dua parameter: fungsi yang dapat dipanggil dan sebuah iterable. Iterable tambahan opsional memungkinkan broadcasting fungsi ke urutan yang dijajar, sehingga cocok untuk operasi tervektorisasi mirip apply_along_axis() milik NumPy.

Di Python 3, map() mengembalikan objek map, sebuah turunan iterator, bukan list. Perubahan ini meningkatkan efisiensi memori, karena tidak mengalokasikan ruang untuk seluruh hasil sejak awal. Untuk mematerialkan hasil, konversikan secara eksplisit:

• Ke list: list(map(function, iterable))

• Ke set: set(map(function, iterable))

• Iterasi langsung: for item in map(function, iterable): ..

Berikut cuplikan kode yang memperlihatkan konversi:

words = ['python', 'data', 'science']
# Converts map object to list
lengths = list(map(len, words)) 
print(lengths)Didukung oleh

[6, 4, 7]Didukung oleh

Untuk ikhtisar cepat berbagai operasi Python yang digunakan sepanjang tutorial ini, saya sarankan melihat lembar contekan Python ini. 

Transisi dari Python 2 ke Python 3

Di Python 2, map() secara eager mengembalikan list, yang bisa membengkakkan memori untuk input besar—jebakan umum pada skrip data lama. Objek map yang lazy di Python 3 mengubah ini, selaras dengan protokol iterator untuk skalabilitas di lingkungan big data seperti PySpark.

Implikasinya? Penanganan dataset masif lebih mulus tanpa error Out of Memory (OOM), meski membutuhkan konversi eksplisit untuk pengindeksan. Misalnya, my_map[0] tidak akan berfungsi, sehingga kita harus menggunakan next(iter(my_map)) sebagai gantinya. 

Jika Anda terbiasa dengan logika berbasis list, lihat kursus Python untuk pengguna MATLAB untuk memudahkan peralihan dari operasi tervektorisasi ke iterator Python.

Cara Menggunakan map() di Python

Setelah melihat dasar-dasarnya, mari kita implementasikan fungsi map(). Kita akan melihat cara paling umum menerapkan map(), mulai dari fungsi bawaan sederhana hingga transformasi multi-iterable yang lebih kompleks.

Penggunaan dasar map()

Cara paling langsung menggunakan map() adalah dengan fungsi bawaan. Misalnya Anda memiliki daftar string dan ingin mengetahui panjang masing-masing. Untuk menerapkan fungsi map():

1. Identifikasi iterable Anda: words = ['apple', 'banana', 'cherry']

2. Identifikasi fungsi Anda: Fungsi bawaan len().

3. Terapkan map(): map(len, words)

4. Konversi ke list: list(map(len, words)

Mari lihat kodenya di bawah:

words = ['apple', 'banana', 'cherry']

# Apply the len() function to each item in the list
lengths_map = map(len, words)

# Convert the map object to a list to see the results
lengths_list = list(lengths_map)

print(lengths_list)Didukung oleh

[5, 6, 6]Didukung oleh

Seperti terlihat, ini lebih ringkas dibanding menulis for loop, menambahkan ke list baru, dan mengelola state dari list tersebut.

Menggunakan map() dengan fungsi lambda

Sering kali, operasi yang ingin Anda lakukan itu sederhana dan sekali pakai. Alih-alih mendefinisikan fungsi penuh dengan def, Anda dapat menggunakan fungsi lambda, yaitu fungsi kecil, anonim, satu baris.

Ini sangat umum dalam pemrosesan data. Misalnya, jika Anda ingin menguadratkan daftar angka, fungsi lambda adalah pilihan yang tepat. Mari lihat contohnya di bawah:

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

# Use a lambda function to square each number
squared_map = map(lambda x: x * x, numbers)

squared_list = list(squared_map)
print(squared_list)Didukung oleh

[1, 4, 9, 16, 25]Didukung oleh

Menggunakan fungsi lambda dengan map() direkomendasikan dalam kasus berikut:

• Transformasinya sederhana (idealnya satu ekspresi).

• Fungsinya tidak digunakan kembali di bagian lain kode Anda.

Untuk mempelajari lebih lanjut tentang fungsi lambda, lihat tutorial interaktif Python lambda ini.

Menggunakan map() dengan fungsi buatan pengguna

Untuk transformasi yang lebih kompleks atau berulang, gunakan fungsi kustom yang didefinisikan dengan kata kunci def. Ini membuat kode Anda lebih mudah dibaca, modular, dan mudah diuji.

Misalnya Anda memiliki daftar suhu dalam Celsius dan perlu mengonversinya ke Fahrenheit. Kita bisa melakukannya sebagai berikut:

def celsius_to_fahrenheit(c):
    # The formula is (Celsius * 9/5) + 32
    return (c * 9/5) + 32

celsius_temps = [0, 10, 25, 30.5, 100]

# Pass the user-defined function to map()
fahrenheit_map = map(celsius_to_fahrenheit, celsius_temps)

fahrenheit_list = list(fahrenheit_map)
print(fahrenheit_list)Didukung oleh

[32.0, 50.0, 77.0, 86.9, 212.0]Didukung oleh

Menggunakan fungsi dengan nama deskriptif, seperti celsius_to_fahrenheit(), menjelaskan maksud kode dengan jelas, sehingga menjadi praktik terbaik untuk logika bisnis khusus.

Menggunakan map() dengan banyak iterable

Salah satu fitur kuat map() adalah kemampuannya memproses beberapa iterable secara bersamaan. Untuk melakukannya, fungsi Anda harus menerima jumlah argumen yang sama dengan jumlah iterable yang Anda berikan.

Misalkan Anda memiliki dua daftar angka dan ingin menjumlahkannya per elemen:

list_a = [1, 2, 3, 4]
list_b = [10, 20, 30, 40]

# The lambda function now takes two arguments, x and y
sums_map = map(lambda x, y: x + y, list_a, list_b)

sums_list = list(sums_map)
print(sums_list)Didukung oleh

[11, 22, 33, 44]Didukung oleh

Bagaimana jika ukuran iterable berbeda? Fungsi map() akan berhenti memproses segera setelah iterable terpendek habis, sehingga output memiliki panjang sama dengan iterable terpendek. Mari lihat contohnya:

list_a = [1, 2, 3]          # Length 3
list_b = [10, 20, 30, 40]   # Length 4

# map() will stop after the 3rd element
short_map = map(lambda x, y: x + y, list_a, list_b)

print(list(short_map))Didukung oleh

[11, 22, 33]Didukung oleh

Perilaku ini dapat diprediksi dan bermanfaat, mencegah pengecualian IndexError. Jika Anda perlu memproses semua elemen dan mengisi nilai default untuk daftar yang lebih pendek, Anda dapat menggunakan itertools.zip_longest(). 

Selanjutnya, mari lihat beberapa kasus penggunaan sehari-hari untuk fungsi map().

Kasus Penggunaan map() Python yang Umum

Fungsi map() serbaguna dan sangat berguna untuk banyak tugas pemrosesan dan pembersihan data yang umum. Mari lihat di mana fungsi ini paling bermanfaat.

Melakukan perhitungan pada list

Ini adalah kasus penggunaan paling klasik. Ketika Anda memiliki daftar angka dan perlu menerapkan operasi matematis yang seragam ke setiap elemen, map() adalah solusi yang bersih dan efisien.

Kita sudah melihat contoh bagusnya dengan konversi dari Celsius ke Fahrenheit di bagian sebelumnya. Skenario umum lainnya adalah menerapkan rumus finansial, seperti menghitung pajak penjualan atau mengonversi mata uang.

Bayangkan Anda memiliki daftar harga produk dalam USD dan perlu mengonversinya ke EUR. Kita bisa melakukannya seperti berikut:

def usd_to_eur(price_usd):
    # Assuming a static exchange rate for this example
    EXCHANGE_RATE = 0.92
    return round(price_usd * EXCHANGE_RATE, 2)

prices_usd = [99.99, 150.00, 45.50, 78.25]

prices_eur_map = map(usd_to_eur, prices_usd)

print(list(prices_eur_map))Didukung oleh

[91.99, 138.0, 41.86, 71.99]Didukung oleh

Pola ini jauh lebih mudah dibaca daripada for loop, terutama saat logika konversi kompleks dan sebaiknya disimpan dalam fungsinya sendiri.

Memproses string secara massal

Pembersihan data sering kali melibatkan pemrosesan volume besar data teks. Anda mungkin memiliki ribuan entri teks yang perlu dinormalisasi sebelum analisis. Fungsi map() sangat cocok untuk menerapkan metode string ke seluruh list.

Sebagai contoh, mari bersihkan daftar nama dengan menghapus spasi yang tidak diinginkan dan menstandarkan kapitalisasi:

raw_names = ['  Alice Smith ', ' bob johnson', 'Charlie Brown  ', ' david lee']

# Use map() with the built-in .strip() method
cleaned_names_map = map(str.strip, raw_names)

# Now chain another map() to convert to title case
# Note: we apply the second map to the *results* of the first map
final_names_map = map(str.title, cleaned_names_map)

print(list(final_names_map))Didukung oleh

['Alice Smith', 'Bob Johnson', 'Charlie Brown', 'David Lee']Didukung oleh

Kemampuan untuk merangkai operasi map() (karena masing-masing mengembalikan iterator) penting untuk menangani pipeline data yang efisien. 

Memfilter dan memetakan data

Sering kali, Anda tidak ingin mentransformasi setiap item. Anda hanya ingin mentransformasi item yang memenuhi kondisi tertentu. Ini adalah pola umum dalam analisis data, dan mudah diatasi dengan menggabungkan map() dengan filter() milik Python.

Fungsi filter(function, iterable) bekerja mirip dengan map(), tetapi hanya mengembalikan item untuk yang fungsinya menghasilkan True. 

Misalkan kita memiliki daftar pembacaan sensor, dan kita ingin menguadratkan hanya nilai positif, mengabaikan nilai negatif (yang mungkin error). Kita bisa melakukan:

1. Filter: Pertama, gunakan filter() untuk mendapatkan hanya angka positif.

2. Map: Kemudian, gunakan map() untuk menerapkan fungsi kuadrat ke hasil yang telah difilter.

readings = [10, -5, 3, -1, 20, 0]

# 1. Filter out the negative numbers
positive_readings = filter(lambda x: x > 0, readings)

# 2. Map the squaring function to the filtered iterator
squared_positives = map(lambda x: x * x, positive_readings)

print(list(squared_positives))Didukung oleh

[100, 9, 400]Didukung oleh

Karena map() dan filter() keduanya lazy, proses dua langkah ini sangat hemat memori. Tidak ada list perantara yang dibuat. Pola filter lalu map ini merupakan alternatif kuat untuk list comprehension Python yang lebih kompleks.

Contoh Praktis map() dalam Aksi

Setelah melihat konsep dasar dan kasus penggunaan umum, mari tinjau beberapa contoh praktis spesifik yang menunjukkan bagaimana fungsi map() menyediakan sintaks yang bersih dan efisien untuk berbagai tugas transformasi data.

Mengonversi ke huruf kapital

Ini tugas klasik pemrosesan string. Diberi daftar string, Anda dapat menggunakan fungsi map() dengan metode bawaan str.upper() untuk mengonversi setiap item menjadi huruf kapital, seperti berikut:

words = ['data science', 'python', 'map function']

# Apply the str.upper method to each item
upper_words = map(str.upper, words)

print(list(upper_words))Didukung oleh

['DATA SCIENCE', 'PYTHON', 'MAP FUNCTION']Didukung oleh

Mengekstrak karakter pertama dari string

Terkadang Anda perlu mengekstrak bagian informasi tertentu dari setiap item. Di sini, kita bisa menggunakan fungsi lambda untuk mengambil karakter pertama (pada indeks 0) dari setiap string dalam list.

names = ['Alice', 'Bob', 'Charlie']

# Use a lambda function to get the character at index 0
first_chars = map(lambda s: s[0], names)

print(list(first_chars))Didukung oleh

['A', 'B', 'C']Didukung oleh

Menghapus spasi dari string

Seperti kita lihat pada bagian pemrosesan string, pembersihan spasi adalah langkah mendasar dalam penyiapan data teks. map() dengan str.strip() adalah cara paling Pythonic untuk melakukan ini.

raw_data = ['  value1 ', ' value2  ', '  value3']

# Apply the str.strip method
cleaned_data = map(str.strip, raw_data)

print(list(cleaned_data))Didukung oleh

['value1', 'value2', 'value3']Didukung oleh

Untuk lebih banyak cara mengelola data string dan list, tutorial interaktif tentang fungsi dan metode list di Python menyediakan banyak contoh.

Memutakhirkan data dalam framework (mis., Django)

Dalam aplikasi web atau berbasis data, Anda sering menerima data sebagai daftar dictionary (seperti payload JSON). Fungsi map() dapat digunakan untuk menyiapkan data untuk pembaruan basis data, seperti di Django atau saat bekerja dengan MongoDB.

Bayangkan kita memiliki daftar dictionary yang merepresentasikan pembaruan produk, dan kita perlu menambahkan stempel waktu processed pada masing-masing sebelum dikirim ke basis data:

import datetime

def add_timestamp(record):
    # Don't modify the original! Return a new copy.
    new_record = record.copy() 
    new_record['processed_at'] = datetime.datetime.now()
    return new_record

product_updates = [
    {'id': 101, 'price': 50.00},
    {'id': 102, 'price': 120.50},
    {'id': 103, 'price': 75.25}
]

processed_data = map(add_timestamp, product_updates)

print(list(processed_data))Didukung oleh

[{'id': 101, 'price': 50.0, 'processed_at': datetime.datetime(2025, 11, 11, 13, 40, 25, 123456)}, 
 {'id': 102, 'price': 120.5, 'processed_at': datetime.datetime(2025, 11, 11, 13, 40, 25, 123457)}, 
 {'id': 103, 'price': 75.25, 'processed_at': datetime.datetime(2025, 11, 11, 13, 40, 25, 123458)}]Didukung oleh

Pola ini ideal untuk pembaruan batch dan benar-benar menunjukkan nilai dari memahami dictionary.

Menghasilkan elemen HTML

Bagi pengembang web, map() bisa menjadi mesin templat sederhana. Anda dapat mengubah daftar item data menjadi daftar string HTML yang siap dirender. Berikut contoh cara mengubah list Python menjadi daftar HTML tak berurutan:

def create_list_item(text):
    return f"<li>{text}</li>"

menu_items = ['Home', 'About', 'Contact']

# Map the function to the list
html_items = map(create_list_item, menu_items)

# Join the results into a single string
html_list = "\n".join(html_items)

print(f"<ul>\n{html_list}\n</ul>")Didukung oleh

<ul>
<li>Home</li>
<li>About</li>
<li>Contact</li>
</ul>Didukung oleh

Aplikasi Lanjutan map() di Python

Meskipun map() sangat baik untuk transformasi satu-ke-satu yang sederhana, kekuatannya yang sesungguhnya terlihat pada skenario yang lebih kompleks. Mari lihat beberapa pola lanjutan di mana map() menjadi komponen kunci strategi pemrosesan data yang canggih.

Pemrosesan multi-iterable

Kita telah menyinggung penggunaan map() dengan beberapa iterable, dan ini merupakan pola yang mendasar bagi banyak komputasi data dan sains tingkat lanjut. Saat Anda memberikan beberapa iterable, map() bertindak seperti resleting, memberi makan elemen ke-i dari setiap iterable ke fungsi Anda, artinya jumlah argumen harus sesuai dengan jumlah iterable.

Sebagai contoh, untuk menghitung total nilai berbagai produk dalam inventaris, Anda mungkin memiliki tiga daftar terpisah. Mari lihat bagaimana map() digunakan di sini:

product_ids = ['A-101', 'B-202', 'C-303']
quantities = [50, 75, 30]
prices = [10.99, 5.49, 20.00]

# A function that takes three arguments
def calculate_line_total(pid, qty, price):
    # Returns a tuple of (id, total_value)
    return (pid, round(qty * price, 2))

# map() feeds one element from each list into the function
line_totals = map(calculate_line_total, product_ids, quantities, prices)

print(list(line_totals))Didukung oleh

[('A-101', 549.5), ('B-202', 411.75), ('C-303', 600.0)]Didukung oleh

Seperti disebutkan sebelumnya, map() berhenti pada iterable terpendek. Ini adalah fitur yang disengaja untuk mencegah pengecualian IndexError. Jika logika Anda mengharuskan memproses semua item dari daftar terpanjang (misalnya mengisi nilai default), ingat untuk menggunakan itertools.zip_longest(). Anda dapat mempelajarinya bersama banyak fungsi berguna lainnya dalam kursus tentang menulis kode Python yang efisien.

itertools.starmap() untuk iterable bertingkat

Apa yang terjadi ketika data Anda sudah “dijajar” menjadi daftar tuple? Ini sangat umum saat bekerja dengan hasil kueri basis data, file CSV, atau pasangan koordinat.

Misalkan Anda memiliki daftar titik (x,y) seperti di bawah, dan Anda ingin menghitung hasil kali tiap pasangan.

points = [(1, 5), (3, 9), (4, -2)]Didukung oleh

Anda bisa menggunakan lambda dengan map(), tetapi agak canggung dengan fungsi bertingkat panjang di dalamnya:

list(map(lambda p: p[0] * p[1], points))Didukung oleh

Solusi yang jauh lebih bersih dan Pythonic adalah itertools.starmap(). Fungsi ini menerima sebuah fungsi dan satu iterable dari iterable (seperti daftar tuple kita). Ia kemudian membongkar setiap tuple dalam sebagai argumen bagi fungsi tersebut. Mari lihat praktiknya:

import itertools

points = [(1, 5), (3, 9), (4, -2)]

# A simple function that takes two arguments
def product(x, y):
    return x * y

# starmap() unpacks each tuple from 'points' into (x, y)
# and passes them to product()
products = itertools.starmap(product, points)

print(list(products))Didukung oleh

[5, 27, -8]Didukung oleh

starmap() adalah alat yang tepat ketika argumen fungsi Anda sudah dikemas sebelumnya dalam tuple. Pola ini sangat berguna saat memproses data geospasial, seperti daftar koordinat (latitude, longitude). Untuk pendalaman konsep ini, saya merekomendasikan kursus tentang bekerja dengan data geospasial di Python.

Integrasi pemrograman fungsional

Fungsi map() sangat berguna dalam pemrograman fungsional. Kita dapat menggabungkannya dengan alat fungsional lain seperti filter() dan functools.reduce() untuk membangun pipeline pemrosesan data yang bersih dan sangat efisien.

Kita sudah melihat kombinasi filter() dan map(). Sekarang, mari lihat cara menggunakan reduce(), yang mengagregasi (atau “mereduksi”) sebuah iterable menjadi satu nilai kumulatif.

Misalkan Anda ingin mencari jumlah kuadrat dari semua angka ganjil dalam daftar tertentu. Kita bisa melakukan seperti berikut:

from functools import reduce

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

# 1. Filter: Get only the odd numbers
odd_numbers = filter(lambda x: x % 2 != 0, numbers)
# -> Iterator(1, 3, 5, 7)

# 2. Map: Square the odd numbers
squared_odds = map(lambda x: x * x, odd_numbers)
# -> Iterator(1, 9, 25, 49)

# 3. Reduce: Sum the results
#    (lambda a, b: a + b) is the summing function
#    'a' is the accumulator, 'b' is the next item
total = reduce(lambda acc, val: acc + val, squared_odds)

print(total)Didukung oleh

84Didukung oleh

Ini adalah pola yang kuat. Karena map() dan filter() sama-sama mengembalikan iterator lazy, seluruh operasi ini sangat hemat memori. Tidak ada list perantara besar yang dibuat di memori. Data mengalir melalui pipeline, item demi item. 

Lazy Evaluation dan Manajemen Memori

Salah satu fitur paling penting dari map() di Python 3 adalah penggunaan lazy evaluation. Memahami konsep ini diperlukan untuk menulis kode yang efisien dan skalabel, terutama bagi praktisi data yang menangani dataset besar secara rutin. Di bagian ini, kita akan melihat cara kerjanya.

Manfaat lazy evaluation

Di Python 3, map() tidak langsung menjalankan fungsi Anda dan mengembalikan list. Sebaliknya, ia mengembalikan objek map, yaitu sebuah iterator. Iterator ini “tahu” fungsi dan data apa yang digunakan, tetapi tidak benar-benar melakukan perhitungan sampai Anda secara eksplisit meminta item berikutnya.

Perhitungan “tepat waktu” ini memiliki manfaat besar, seperti:

• Efisiensi Memori: Objek map hanya menempati sejumlah kecil memori konstan, terlepas apakah memproses 10 item atau 10 miliar. Ia tidak membuat list baru di memori untuk menampung seluruh hasil.

• Performa pada Dataset Besar: Saat Anda melakukan iterasi pada objek map (misalnya dalam for loop), ia menghitung dan menghasilkan satu nilai pada satu waktu. Ini memungkinkan Anda memproses berkas besar atau aliran data yang terlalu besar untuk dimuat sekaligus ke memori.

• Dapat Dirangkaikan: Seperti yang kita lihat pada bagian pemrograman fungsional, iterator lazy dapat dirangkaikan (mis., map() setelah filter()). Karena tidak ada list perantara yang dibuat, data mengalir melalui pipeline satu per satu item, yang sangat efisien.

Bandingkan ini dengan list comprehension, yang menggunakan evaluasi eager. Pertimbangkan contoh ini:

squared = [x * x for x in range(10000000)]Didukung oleh

Kode ini akan langsung mencoba membuat list dengan 10 juta angka, yang berpotensi mengonsumsi banyak RAM.

Menggunakan ekspresi generator

Ekspresi generator adalah padanan lazy dari list comprehension. Bentuknya sangat mirip, tetapi berperilaku seperti map() dalam hal memori. 

squared = (x * x for x in range(10000000))Didukung oleh

Kode di atas juga membuat iterator yang hemat memori, seperti halnya map(). Pilihan antara map() dan ekspresi generator sering bergantung pada keterbacaan. map() bisa lebih jelas saat menerapkan fungsi yang kompleks dan sudah ada, sementara ekspresi generator sering lebih mudah dibaca untuk ekspresi sederhana dan inline. 

Mari bandingkan penggunaan memori untuk operasi-operasi ini:

import tracemalloc

# Define the base data for comparison
large_numbers = range(10000000)

print("--- Memory Usage (Object Creation vs. List Materialization) ---")

# --- 1. Memory for List Comprehension (creates full list immediately) ---
tracemalloc.start()
list_comp_obj = [x * x for x in large_numbers]
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak RAM for List Comprehension (full list): {peak / (1024 * 1024):.2f} MB")
del list_comp_obj  # Free up memory


# --- 2. Memory for Map Object (lazy) ---
tracemalloc.start()
map_obj = map(lambda x: x * x, large_numbers)
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak RAM for Map Object (iterator itself): {peak / (1024 * 1024):.2f} MB")
del map_obj  # Free up memory


# --- 3. Memory for Generator Expression (lazy) ---
tracemalloc.start()
gen_exp_obj = (x * x for x in large_numbers)
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak RAM for Generator Expression (iterator itself): {peak / (1024 * 1024):.2f} MB")
del gen_exp_obj  # Free up memoryDidukung oleh

--- Memory Usage (Object Creation vs. List Materialization) ---
Peak RAM for List Comprehension (full list): 390.16 MB
Peak RAM for Map Object (iterator itself): 0.03 MB
Peak RAM for Generator Expression (iterator itself): 0.03 MBDidukung oleh

Catatan: 'Peak RAM' untuk Objek Map/Generator di sini mengacu pada memori yang dialokasikan untuk objek iterator itu sendiri, bukan memori list penuh yang akan dihasilkan jika dikonversi, menunjukkan sifat lazy-nya.

Mengonversi objek map ke iterable

Karena map() mengembalikan iterator lazy, sering kali Anda perlu mematerialkannya atau mengonversinya menjadi koleksi konkret untuk benar-benar menggunakan hasilnya.

Anda sebaiknya mengonversi objek map ketika Anda perlu:

• Melihat semua hasil sekaligus (mis., untuk print()).

• Mengakses elemen berdasarkan indeks (mis., results[0]).

• Mendapatkan panjang hasil (mis., len(results)).

• Memberikan hasil ke fungsi yang memerlukan list atau set.

• Melakukan iterasi atas hasil beberapa kali. (Objek map, seperti semua iterator, dapat habis.) Anda hanya bisa melakukan loop sekali.

Berikut cara mengonversi objek map:

def square(x):
    return x * x

numbers = [1, 2, 3, 3, 4, 5]
map_obj = map(square, numbers)

# --- Common Conversions ---

# 1. To a list:
list_results = list(map_obj) 
print(f"List: {list_results}")

# Important 
# The map_obj is now exhausted. 
# If you try to do list(map_obj) again, you'll get an empty list.
# You must re-create the map object to reuse it.

map_obj = map(square, numbers) # Re-create it

# 2. To a set (removes duplicates):
set_results = set(map_obj)
print(f"Set: {set_results}")

map_obj = map(square, numbers) # Re-create it

# 3. To a tuple:
tuple_results = tuple(map_obj)
print(f"Tuple: {tuple_results}")Didukung oleh

List: [1, 4, 9, 9, 16, 25] 
Set: {1, 4, 9, 16, 25} 
Tuple: (1, 4, 9, 9, 16, 25)Didukung oleh

Untuk mengonversi ke dictionary (jika output berupa pasangan key-value), Anda bisa menggunakan map() dengan dict(), namun sering kali dictionary comprehension Python lebih jelas.

Inti utamanya adalah bersikaplah sengaja. Biarkan map() tetap menjadi iterator lazy selama mungkin dalam pipeline Anda, dan hanya konversi ke list pada saat terakhir ketika Anda benar-benar memerlukan hasil konkret.