Tutorial Enumerate Python

Dalam tutorial ini, kita akan membahas apa itu fungsi enumerate() di Python, kapan digunakan, jenis objek apa yang dibuatnya, sintaksnya, dan bagaimana cara kerjanya. Lalu, kita akan melihat beberapa contoh enumerasi berbagai jenis objek di Python, alternatif dari fungsi enumerate(), dan mengapa alternatif tersebut kurang cocok untuk tugas yang sama.

Apa itu Enumerate di Python dan Kapan Digunakan?

Fungsi enumerate() adalah fungsi bawaan Python yang menerima sebuah iterable (kumpulan item atau objek Python lain yang mendukung iterasi, seperti tuple, list, set, atau string), melakukan iterasi atas item-itemnya di balik layar, dan mengembalikan sebuah objek enumerate. Dengan kata lain, fungsi ini memberikan hitungan yang bertambah 1 untuk setiap item dalam iterable dan membantu kita melacak iterasi saat melakukan loop pada objek tersebut. Setelah membuat objek enumerate, kita bisa mengonversinya menjadi list, tuple, atau dictionary (masing-masing menggunakan fungsi list(), tuple(), atau dict()), atau melakukan loop langsung pada objek tersebut untuk mengakses item dan indeks yang sesuai.

Menggunakan fungsi enumerate() bermanfaat dari sisi efisiensi memori dan komputasi dibandingkan menggunakan for-loop karena fungsi ini mengembalikan indeks dan item yang sesuai sekaligus.

Sintaks

Sintaks fungsi enumerate() sangat sederhana:

enumerate(iterable, start=0)

Di sini, iterable adalah objek iterable yang ingin kita enumerasi, dan start adalah parameter opsional yang menentukan indeks awal penghitung (secara default, akan menggunakan indeks Python berbasis 0).

Perlu dicatat bahwa menerapkan fungsi enumerate() pada sebuah iterable tidak mengubah objek awal itu sendiri. Sebagai gantinya, objek enumerate yang dihasilkan harus ditetapkan ke sebuah variabel jika ingin kita gunakan lebih lanjut.

Sekarang, mari kita lihat bagaimana fungsi ini bekerja pada berbagai jenis iterable Python.

Mengenumerasi List

Pertama, kita akan menerapkan fungsi enumerate() pada sebuah list Python:

drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
enumerated_drinks = enumerate(drinks)
print(type(enumerated_drinks))
print(enumerated_drinks)

Keluaran:

<class 'enumerate'>
<enumerate object at 0x000002DC3A1145C0>

Jenis objek yang dihasilkan adalah enumerate, dan saat kita mencoba mencetaknya, kita hanya menegaskan kembali tipe objek tersebut dan di mana objek itu disimpan di memori komputer. Mari coba mengakses elemen pertama dari objek ini dengan cara yang sama seperti kita melakukannya pada list atau tuple Python:

print(enumerated_drinks[0])

Keluaran:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_5948/1233607596.py in <module>
----> 1 print(enumerated_drinks[0])

TypeError: 'enumerate' object is not subscriptable

Kita mendapatkan error yang menunjukkan bahwa komponen objek enumerate tidak dapat diakses dengan cara ini. Untuk tujuan tersebut, kita perlu mengonversinya menjadi list, tuple, atau dictionary, atau melakukan loop langsung pada objek enumerate. Mari konversi objek enumerate kita menjadi list:

list_enumerated_drinks = list(enumerated_drinks)
print(list_enumerated_drinks)

Keluaran:

[(0, 'tea'), (1, 'coffee'), (2, 'cappuccino'), (3, 'lemonade')]

Sekarang, kita dapat melihat dengan jelas struktur internal list yang dihasilkan: setiap item merepresentasikan tuple berisi 2 elemen, di mana elemen pertama adalah indeks item yang sesuai dalam list asli dan elemen kedua adalah item itu sendiri. Kita dapat menggunakan pendekatan pengindeksan umum untuk mengakses elemen dari list ini:

print(list_enumerated_drinks[0])
print(list_enumerated_drinks[0][1])

Keluaran:

(0, 'tea')
tea

Sekarang mari kita coba mengonversi objek enumerate yang dibuat dari list asli menjadi tuple. Selain itu, kali ini kita akan menetapkan parameter opsional start ke 1:

tuple_enumerated_drinks = tuple(enumerate(drinks, start=1))
print(tuple_enumerated_drinks)

Keluaran:

((1, 'tea'), (2, 'coffee'), (3, 'cappuccino'), (4, 'lemonade'))

Struktur internal tuple di atas identik dengan list yang dibuat sebelumnya. Namun, kali ini kita juga mengubah hitungan agar lebih “gaya manusia” alih-alih pengindeksan Python berbasis 0.

Ada satu metode menarik dari objek enumerate yang perlu disebutkan di sini: metode next(). Mari kita buat ulang objek enumerated_drinks dan coba metode ini:

enumerated_drinks = enumerate(drinks)
print(next(enumerated_drinks))
print(next(enumerated_drinks))
print(next(enumerated_drinks))
print(next(enumerated_drinks))
print(next(enumerated_drinks))

Keluaran:

(0, 'tea')
(1, 'coffee')
(2, 'cappuccino')
(3, 'lemonade')

---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_5948/330134057.py in <module>
      4 print(next(enumerated_drinks))
      5 print(next(enumerated_drinks))
----> 6 print(next(enumerated_drinks))

StopIteration: 

Seperti yang terlihat, setiap kali kita memanggil metode ini pada objek enumerate, ia mengembalikan item berikutnya dari objek tersebut (dan kita kembali dapat memastikan bahwa setiap item adalah tuple 2 elemen yang berisi pasangan hitungan-item yang sesuai). Ketika semua item telah habis, objek enumerate menjadi kosong, dan upaya memanggil metode next() padanya akan menimbulkan error StopIteration. Memang, jika sekarang kita mencoba mengonversi objek enumerate ini menjadi list, kita akan melihat bahwa objek tersebut kosong

print(list(enumerated_drinks))

Keluaran:

[]

Ini berarti bahwa pada setiap penerapan metode next() pada objek enumerate, satu item diambil dari objek tersebut, sehingga setiap kali ukurannya berkurang hingga benar-benar habis. Kita akan melihat sifat objek enumerate ini lagi nanti saat membahas penerapan for-loop pada objek tersebut.

Jika Anda ingin belajar lebih banyak tentang list Python dan konsep dasar Python lainnya, Anda dapat mengikuti kursus Introduction to Python dari DataCamp.

Mengenumerasi Tuple

Penerapan fungsi enumerate() pada tuple identik dengan pada list:

drinks = ('tea', 'coffee', 'cappuccino', 'lemonade')
enumerated_drinks = enumerate(drinks)
print(enumerated_drinks)

Keluaran:

<enumerate object at 0x000002DC3A098D40>

Kembali, kita memperoleh objek enumerate yang item-itemnya tidak dapat diakses dengan pengindeksan Python umum. Mari transformasi objek ini menjadi objek lain, kali ini menjadi dictionary:

dict_enumerated_drinks = dict(enumerated_drinks)
print(dict_enumerated_drinks)

Keluaran:

{0: 'tea', 1: 'coffee', 2: 'cappuccino', 3: 'lemonade'}

Setiap pasangan key:value pada dictionary yang dihasilkan merepresentasikan pasangan hitungan-item yang sesuai. Kita dapat mengakses nilai pada dictionary dengan cara Pythonic yang umum:

print(dict_enumerated_drinks[0])
print(dict_enumerated_drinks[3])

Keluaran:

tea
lemonade

Jika Anda ingin memperdalam pemahaman tentang dictionary Python dan pandas, jelajahi kursus Intermediate Python.

Mengenumerasi String

Karena string Python adalah deretan karakter dan karenanya juga merupakan objek iterable, kita juga dapat membuat objek enumerate untuk sebuah string:

enumerated_hello_world = enumerate('Hello, World!', start=10)
print(enumerated_hello_world)

Keluaran:

<enumerate object at 0x000002DC3A145C40>

Seperti sebelumnya, mari konversi objek ini menjadi list:

list_enumerated_hello_world = list(enumerated_hello_world)
print(list_enumerated_hello_world)

Keluaran:

[(10, 'H'), (11, 'e'), (12, 'l'), (13, 'l'), (14, 'o'), (15, ','), (16, ' '), (17, 'W'), (18, 'o'), (19, 'r'), (20, 'l'), (21, 'd'), (22, '!')]

Kita melihat tuple 2 elemen yang sudah familier, di mana elemen pertama adalah hitungan dari karakter yang sesuai dalam string (dalam kasus ini mulai dari 10), dan elemen kedua adalah karakter itu sendiri. Spasi dan tanda baca juga dihitung.

Mari buat ulang objek enumerated_hello_world, kali ini tanpa start=10, dan terapkan metode next padanya:

enumerated_hello_world = enumerate('Hello, World!')
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
​
# Creating a list from the remaining enumerate object
print(list(enumerated_hello_world))

Keluaran:

(0, 'H')
(1, 'e')
(2, 'l')
(3, 'l')
(4, 'o')
(5, ',')
[(6, ' '), (7, 'W'), (8, 'o'), (9, 'r'), (10, 'l'), (11, 'd'), (12, '!')]

Pada baris terakhir potongan kode di atas, kita berhenti menerapkan metode next() dan mengonversi objek enumerated_hello_world menjadi list. List yang dihasilkan berisi karakter yang tersisa dari objek enumerate awal setelah beberapa kali penerapan metode next() padanya.

Mengenumerasi dengan For-Loop

Terakhir, mari lihat bagaimana fungsi enumerate() bekerja bila digabungkan dengan for-loop:

for item in enumerate(['tea', 'coffee', 'cappuccino', 'lemonade']):
  print(item)

Keluaran:

(0, 'tea')
(1, 'coffee')
(2, 'cappuccino')
(3, 'lemonade')

Pada setiap iterasi, tuple hitungan-item yang sesuai dikembalikan, seperti saat kita menggunakan metode next(). Meskipun tidak terlihat jelas dari potongan kode di atas, objek enumerate juga kehilangan item-itemnya (yakni tuple 2 elemen) satu per satu pada setiap iterasi. Untuk menunjukkannya, mari tulis ulang potongan kode di atas dalam bentuk berbeda dan periksa panjang list yang dihasilkan setelah semua iterasi selesai:

drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
enumerated_drinks = enumerate(drinks)
​
for item in enumerated_drinks:
  print(item)
 
print(list(enumerated_drinks))

Keluaran:

(0, 'tea')
(1, 'coffee')
(2, 'cappuccino')
(3, 'lemonade')
[]

Sama seperti saat menerapkan metode next(), melakukan iterasi pada objek enumerate secara bertahap menghabiskannya.

Namun, mari kembali ke potongan kode sebelumnya. Bagaimana kita dapat mengakses setiap elemen secara terpisah dari setiap tuple 2 elemen? Untuk tujuan ini, kita akan menambahkan satu variabel iterasi lagi dan melakukan unpack pada tuple:

for count, drink in enumerate(['tea', 'coffee', 'cappuccino', 'lemonade']):
  print(count, drink)

Keluaran:

0 tea
1 coffee
2 cappuccino
3 lemonade

Di atas, kita mengembalikan dua variabel untuk setiap tuple: satu untuk hitungan item dan satu untuk item itu sendiri.

Perhatikan bahwa kita juga dapat mengimplementasikan operasi yang sama seperti di atas tanpa menggunakan fungsi enumerate(). Misalnya, kita dapat memperkenalkan variabel penghitung di luar loop dan menambahkannya 1 pada setiap iterasi loop:

count = 0
for drink in ['tea', 'coffee', 'cappuccino', 'lemonade']:
  print(count, drink)
  count += 1

Keluaran:

0 tea
1 coffee
2 cappuccino
3 lemonade

Atau, kita dapat menggunakan kombinasi fungsi range() dan len() pada list yang telah ditentukan (atau tuple, string, dll.):

drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
for count in range(len(drinks)):
  print(count, drinks[count])

Keluaran:

0 tea
1 coffee
2 cappuccino
3 lemonade

Selain itu, pada kedua alternatif fungsi enumerate() ini, kita tetap dapat menyesuaikan variabel hitungan agar tidak dimulai dari nol:

count = 1
for drink in ['tea', 'coffee', 'cappuccino', 'lemonade']:
  print(count, drink)
  count += 1
​
print('\n')
 
drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
for count in range(len(drinks)):
  print(count + 1, drinks[count])

Keluaran:

1 tea
2 coffee
3 cappuccino
4 lemonade


1 tea
2 coffee
3 cappuccino
4 lemonade

Namun, dibandingkan dengan penggunaan fungsi enumerate(), kedua pendekatan di atas lebih canggung, rentan bug (misalnya, kita bisa lupa memperbarui penghitung secara manual pada setiap iterasi), dan membutuhkan lebih banyak kode. Oleh karena itu, menggunakan fungsi enumerate() adalah pendekatan paling Pythonic kapan pun kita perlu mengakses baik hitungan maupun item dari sebuah iterable pada setiap iterasi.

Kesimpulan

Dalam tutorial ini, kita mempelajari banyak hal tentang fungsi enumerate() di Python, termasuk berbagai penggunaannya, alternatif potensial, dan mengapa pada akhirnya ia lebih efektif daripada alternatifnya. Fungsi enumerate() mungkin tidak familier bagi sebagian besar pengguna Python pemula, dan bahkan programmer tingkat lanjut mungkin belum menyadari betapa bergunanya fungsi ini.

Jika Anda ingin mempelajari lebih lanjut tentang enumerate(), pertimbangkan kursus Python Data Science Toolbox (Bagian 2) yang mengulas iterator dan iterable secara detail dan menawarkan latihan interaktif untuk mempraktikkan keterampilan baru. Selain itu, jika Anda ingin menguasai konsep Python lainnya, Anda mungkin tertarik dengan Learn Python with DataCamp yang menyediakan berbagai jalur keterampilan dan karier, lembar contekan, tutorial, sertifikasi Python, dan tes asesmen.