Fungsi map()

map() adalah built-in function Python yang digunakan untuk menerapkan sebuah function kepada setiap elemen dalam sebuah iterable.

Iterable yang dapat digunakan antara lain:

list
tuple
set
dan struktur data lain yang dapat diiterasi

Konsep map() sangat berkaitan dengan Functional Programming karena kita dapat memisahkan:

Data
  ↓
Function
  ↓
Data hasil transformasi

Misalnya kita memiliki data:

[1, 2, 3]

dan ingin mengalikan setiap angka dengan 2.

Dengan map(), kita dapat menentukan function yang bertugas melakukan perkalian dan menyerahkannya kepada map().

Sintaks Dasar

Sintaks dasar map() adalah:

map(function, iterable)

Terdapat dua bagian utama:

Function

Function yang akan dijalankan terhadap setiap elemen.

Contohnya:

def multiply_by_two(number):
    return number * 2

Iterable

Data yang setiap elemennya akan diproses.

Contohnya:

numbers = [1, 2, 3]

Sehingga:

map(multiply_by_two, numbers)

dapat dibaca:

Jalankan multiply_by_two terhadap setiap elemen di numbers.

Menggunakan `map()` Tanpa `map()`

Sebelum memahami map(), kita dapat melihat pendekatan menggunakan for biasa.

Misalnya kita ingin mengalikan setiap angka dengan 2:

def multiply_by_two(numbers):
    new_numbers = []

    for number in numbers:
        new_numbers.append(number * 2)

    return new_numbers

numbers = [1, 2, 3]

result = multiply_by_two(numbers)

print(result)

Output:

[2, 4, 6]

Pada kode tersebut, kita melakukan beberapa langkah:

Membuat list baru
Melakukan looping
Mengambil setiap elemen
Mengalikan elemen dengan 2
Memasukkan hasil ke list baru

Menggunakan `map()`

Dengan map(), proses tersebut dapat ditulis lebih ringkas.

Pertama, kita membuat function:

def multiply_by_two(number):
    return number * 2

Kemudian:

numbers = [1, 2, 3]

result = map(
    multiply_by_two,
    numbers
)

print(list(result))

Output:

[2, 4, 6]

map() akan menjalankan:

multiply_by_two(number)

untuk setiap elemen dalam numbers.

Bagaimana `map()` Bekerja?

Misalnya:

numbers = [1, 2, 3]

dan function:

def multiply_by_two(number):
    return number * 2

Ketika kita menjalankan:

map(multiply_by_two, numbers)

secara konsep prosesnya adalah:

number = 1
    ↓
1 * 2
    ↓
    2

number = 2
    ↓
2 * 2
    ↓
    4

number = 3
    ↓
3 * 2
    ↓
    6

Hasilnya:

[2, 4, 6]

Mengapa Tidak Menggunakan `()`?

Perhatikan kode berikut:

map(multiply_by_two, numbers)

Kita menuliskan:

multiply_by_two

bukan:

multiply_by_two()

Mengapa?

Karena kita ingin memberikan function kepada map(), bukan menjalankan function tersebut terlebih dahulu.

Dengan:

map(multiply_by_two, numbers)

kita mengatakan:

Gunakan function multiply_by_two untuk memproses setiap elemen.

Sedangkan:

multiply_by_two()

berarti:

Jalankan function sekarang.

Ini merupakan penerapan konsep First-Class Function dan Higher-Order Function.

`map()` adalah Higher-Order Function

map() merupakan contoh Higher-Order Function karena menerima sebuah function sebagai argument.

Contohnya:

def multiply_by_two(number):
    return number * 2


numbers = [1, 2, 3]

result = map(
    multiply_by_two,
    numbers
)

Pada kode tersebut:

multiply_by_two
       ↓
   function
       ↓
     map()
       ↓
  numbers

Function multiply_by_two diberikan kepada map().

`map()` Menghasilkan Map Object

Hal penting yang perlu dipahami adalah map() tidak langsung menghasilkan list.

Contoh:

numbers = [1, 2, 3]


def multiply_by_two(number):
    return number * 2


result = map(
    multiply_by_two,
    numbers
)

print(result)

Hasilnya bukan:

[2, 4, 6]

Melainkan sebuah map object.

Untuk mendapatkan hasil dalam bentuk list, kita dapat menggunakan:

print(list(result))

Output:

[2, 4, 6]

Mengapa Harus Menggunakan `list()`?

map() menghasilkan object yang bersifat iterator.

Iterator memungkinkan Python menghasilkan data secara bertahap ketika data tersebut dibutuhkan.

Karena itu:

result = map(
    multiply_by_two,
    numbers
)

belum menghasilkan list baru yang dapat langsung ditampilkan seperti:

[2, 4, 6]

Kita dapat mengubah hasilnya menjadi list:

result = list(
    map(
        multiply_by_two,
        numbers
    )
)

Sekarang result berisi:

[2, 4, 6]

`map()` Tidak Mengubah Data Asli

Salah satu karakteristik penting map() adalah function yang digunakan dapat menghasilkan hasil baru tanpa harus memodifikasi iterable asli.

Contoh:

numbers = [1, 2, 3]


def multiply_by_two(number):
    return number * 2


result = list(
    map(
        multiply_by_two,
        numbers
    )
)

print(numbers)
print(result)

Output:

[1, 2, 3]
[2, 4, 6]

Data asli:

[1, 2, 3]

tetap sama.

Sedangkan hasil transformasinya:

[2, 4, 6]

disimpan sebagai hasil baru.

`map()` dan Pure Function

map() dapat digunakan bersama pure function.

Contoh:

def multiply_by_two(number):
    return number * 2

Function tersebut:

Menggunakan input yang diberikan.
Menghasilkan output berdasarkan input.
Tidak mengubah data di luar function.

Kemudian:

numbers = [1, 2, 3]

result = list(
    map(
        multiply_by_two,
        numbers
    )
)

Data asli tetap:

[1, 2, 3]

dan hasil transformasi menjadi:

[2, 4, 6]

Pendekatan seperti ini sesuai dengan prinsip Functional Programming.

`map()` dengan Lambda

Karena function dapat diberikan sebagai argument, kita juga dapat menggunakan lambda expression.

Contoh:

numbers = [1, 2, 3]

result = list(
    map(
        lambda number: number * 2,
        numbers
    )
)

print(result)

Output:

[2, 4, 6]

Pada contoh tersebut:

lambda number: number * 2

berfungsi sebagai function yang diberikan kepada map().

Membandingkan Function Biasa dan Lambda

Menggunakan function biasa:

def multiply_by_two(number):
    return number * 2


numbers = [1, 2, 3]

result = list(
    map(
        multiply_by_two,
        numbers
    )
)

Menggunakan lambda:

numbers = [1, 2, 3]

result = list(
    map(
        lambda number: number * 2,
        numbers
    )
)

Keduanya menghasilkan:

[2, 4, 6]

Function biasa biasanya lebih mudah dibaca ketika logikanya cukup kompleks atau digunakan kembali di beberapa tempat.

Lambda cocok untuk operasi sederhana yang hanya digunakan pada satu tempat.

`map()` dengan String

map() tidak hanya dapat digunakan untuk angka.

Contohnya kita ingin mengubah setiap nama menjadi huruf kapital:

names = [
    "budi",
    "andi",
    "citra"
]


def to_upper(name):
    return name.upper()


result = list(
    map(
        to_upper,
        names
    )
)

print(result)

Output:

["BUDI", "ANDI", "CITRA"]

Prosesnya:

"budi"
   ↓
upper()
   ↓
"BUDI"

"andi"
   ↓
upper()
   ↓
"ANDI"

"citra"
   ↓
upper()
   ↓
"CITRA"

`map()` dengan Beberapa Iterable

map() juga dapat menerima lebih dari satu iterable.

Contohnya kita ingin menjumlahkan dua list:

numbers1 = [1, 2, 3]
numbers2 = [10, 20, 30]


def add(a, b):
    return a + b


result = list(
    map(
        add,
        numbers1,
        numbers2
    )
)

print(result)

Output:

[11, 22, 33]

Secara konsep:

+  10  →  11
+  20  →  22
+  30  →  33

Function:

add(a, b)

menerima elemen dari masing-masing iterable.

`map()` dengan Tuple

map() juga dapat bekerja dengan tuple.

Contoh:

numbers = (1, 2, 3, 4)


def square(number):
    return number ** 2


result = list(
    map(
        square,
        numbers
    )
)

print(result)

Output:

[1, 4, 9, 16]

map() tidak terbatas pada list.

Yang penting data tersebut merupakan iterable.

`map()` dan List Comprehension

Operasi yang sama dapat dilakukan menggunakan list comprehension.

Dengan map():

numbers = [1, 2, 3]

result = list(
    map(
        lambda number: number * 2,
        numbers
    )
)

Dengan list comprehension:

numbers = [1, 2, 3]

result = [
    number * 2
    for number in numbers
]

Keduanya menghasilkan:

[2, 4, 6]

Dalam Python, list comprehension sering dianggap lebih mudah dibaca untuk transformasi list yang sederhana.

Namun, map() tetap penting untuk dipahami karena merupakan konsep fundamental dalam Functional Programming.

Kapan Menggunakan `map()`?

map() cocok digunakan ketika kita ingin melakukan transformasi yang sama terhadap setiap elemen.

Contohnya:

Angka → dikali 2
Angka → dikuadratkan
Nama → huruf kapital
Harga → dikonversi
Data → ditransformasikan

Pola sederhananya:

Input
  ↓
Function yang sama
  ↓
Setiap elemen
  ↓
Hasil transformasi

Hal yang Perlu Diperhatikan

Jangan Menggunakan `()` Saat Memberikan Function

Gunakan:

map(
    multiply_by_two,
    numbers
)

bukan:

map(
    multiply_by_two(),
    numbers
)

Karena map() membutuhkan function object.

`map()` Menghasilkan Iterator

Perhatikan:

result = map(
    multiply_by_two,
    numbers
)

Jika ingin mendapatkan list:

result = list(
    map(
        multiply_by_two,
        numbers
    )
)

Data Asli Tidak Otomatis Diubah

Contoh:

numbers = [1, 2, 3]

result = list(
    map(
        lambda number: number * 2,
        numbers
    )
)

numbers tetap:

[1, 2, 3]

sedangkan result:

[2, 4, 6]

Ringkasan

map() adalah built-in function Python yang digunakan untuk menerapkan sebuah function kepada setiap elemen dalam iterable.

Sintaks dasarnya:

map(function, iterable)

Contoh:

def multiply_by_two(number):
    return number * 2


numbers = [1, 2, 3]

result = list(
    map(
        multiply_by_two,
        numbers
    )
)

print(result)

Output:

[2, 4, 6]

Hal penting yang perlu diingat:

map() menerima function dan iterable.
Function diberikan tanpa tanda ().
Function dijalankan untuk setiap elemen.
map() menghasilkan iterator.
Hasil dapat dikonversi menjadi list menggunakan list().
map() dapat digunakan dengan function biasa maupun lambda.
map() dapat menerima lebih dari satu iterable.
map() sangat berkaitan dengan konsep First-Class Function dan Higher-Order Function.
map() cocok digunakan untuk melakukan transformasi terhadap setiap elemen data.

Secara sederhana, pola map() dapat diingat sebagai:

Data
  ↓
Function
  ↓
Transform setiap elemen
  ↓
Iterator hasil
  ↓
list()
  ↓
List baru

Sintaks Dasar​

Function​

Iterable​

Menggunakan map() Tanpa map()​

Menggunakan map()​

Bagaimana map() Bekerja?​

Mengapa Tidak Menggunakan ()?​

map() adalah Higher-Order Function​

map() Menghasilkan Map Object​

Mengapa Harus Menggunakan list()?​

map() Tidak Mengubah Data Asli​

map() dan Pure Function​

map() dengan Lambda​

Membandingkan Function Biasa dan Lambda​

map() dengan String​

map() dengan Beberapa Iterable​

map() dengan Tuple​

map() dan List Comprehension​

Kapan Menggunakan map()?​

Hal yang Perlu Diperhatikan​

Jangan Menggunakan () Saat Memberikan Function​

map() Menghasilkan Iterator​

Data Asli Tidak Otomatis Diubah​

Ringkasan​

Sintaks Dasar

Function

Iterable

Menggunakan `map()` Tanpa `map()`

Menggunakan `map()`

Bagaimana `map()` Bekerja?

Mengapa Tidak Menggunakan `()`?

`map()` adalah Higher-Order Function

`map()` Menghasilkan Map Object

Mengapa Harus Menggunakan `list()`?

`map()` Tidak Mengubah Data Asli

`map()` dan Pure Function

`map()` dengan Lambda

Membandingkan Function Biasa dan Lambda

`map()` dengan String

`map()` dengan Beberapa Iterable

`map()` dengan Tuple

`map()` dan List Comprehension

Kapan Menggunakan `map()`?

Hal yang Perlu Diperhatikan

Jangan Menggunakan `()` Saat Memberikan Function

`map()` Menghasilkan Iterator

Data Asli Tidak Otomatis Diubah

Ringkasan