Tutorial Python List Comprehension

Saat melakukan data science, Anda mungkin ingin membaca list berisi list, memfilter nama kolom, menghapus huruf vokal dari sebuah list, atau memipihkan sebuah matriks. Anda bisa dengan mudah menggunakan fungsi lambda atau for loop; Seperti yang Anda ketahui, ada banyak cara untuk melakukannya. Cara lain yang bisa digunakan adalah list comprehension.

Tutorial ini akan membahas topik terakhir ini:

• Pertama, Anda akan mengulas singkat apa itu list Python dan bagaimana perbandingannya dengan struktur data Python lainnya;
• Berikutnya, Anda akan menyelami list comprehension di Python: Anda akan mempelajari lebih lanjut matematika di balik list Python, bagaimana membangun list comprehension, bagaimana menuliskannya ulang sebagai for loop atau fungsi lambda, .... Anda tidak hanya akan membacanya, tetapi juga mengerjakan beberapa latihan!
• Setelah memahami dasar-dasarnya, saatnya menyempurnakan list comprehension Anda dengan menambahkan kondisi: Anda akan belajar bagaimana memasukkan kondisi dalam list comprehension serta menangani beberapa kondisi if dan pernyataan if-else.
• Terakhir, Anda akan menyelami nested list comprehension untuk melakukan iterasi beberapa kali pada list.

Tertarik juga mempelajari list comprehension bersama iterator dan generator? Lihat kursus Python Data Science Toolbox dari DataCamp!

Python Lists

Sejauh ini, Anda mungkin sudah mencoba nilai dengan berbagai tipe data. Anda menyimpan setiap nilai dalam variabel terpisah: setiap variabel merepresentasikan satu nilai. Namun, dalam data science, Anda sering bekerja dengan banyak titik data, yang akan membuat sulit terus menyimpan setiap nilai dalam variabel terpisah. Sebagai gantinya, Anda menyimpan semua nilai ini dalam sebuah list Python.

List adalah salah satu dari empat struktur data bawaan di Python. Struktur data lain yang mungkin Anda kenal adalah tuple, dictionary, dan set. Sebuah list di Python berbeda dari, misalnya, int atau bool, dalam arti bahwa ini adalah tipe data majemuk: Anda dapat mengelompokkan nilai dalam list. Faktanya, nilai-nilai ini tidak perlu bertipe sama: bisa berupa kombinasi boolean, string, integer, ... dan lainnya.

Penting untuk dicatat bahwa list adalah kumpulan item atau objek yang terurut. Ini menjadikan list di Python sebagai "tipe deret" (sequence types), karena berperilaku seperti deret. Artinya, list dapat diiterasi; Contoh deret lain adalah string, tuple, atau set.

Tip: jika Anda ingin tahu lebih lanjut, menguji, atau melatih pengetahuan Anda tentang list Python, Anda dapat melakukannya dengan menelusuri pertanyaan paling umum tentang list Python di sini.

Sekarang, secara praktis: Anda membangun sebuah list dengan dua tanda kurung siku; Di dalam kurung ini, gunakan koma untuk memisahkan nilai. Anda kemudian dapat menetapkan list Anda ke sebuah variabel. Nilai yang Anda masukkan dalam list Python bisa dari tipe data apa pun, bahkan list!

Perhatikan contoh list berikut:

Tip: buat list Anda sendiri di IPython shell yang terdapat di chunk DataCamp Light di atas!

Python List Comprehension

Dengan ulasan singkat tentang list Python masih segar, Anda bisa melihat bahwa mendefinisikan dan membuat list di Python bisa menjadi pekerjaan yang melelahkan: mengetik semua nilai satu per satu bisa memakan waktu dan Anda mudah melakukan kesalahan.

List comprehension di Python dibangun sebagai berikut:

list_variable = [x for x in iterable]

Tapi bagaimana Anda sampai pada cara membangun dan menggunakan konstruk ini di Python yang mirip rumus? Mari kita gali lebih dalam.

List Comprehension di Python: Matematika

Untungnya, Python punya solusinya: ia menawarkan cara untuk menerapkan notasi matematika guna melakukan hal ini: list comprehension.

Ingat dalam matematika, cara umum untuk mendeskripsikan list (atau set, atau tuple, atau vektor) adalah:

S = {x² : x in {0 ... 9}}
V = (1, 2, 4, 8, ..., 2¹²)
M = {x | x in S and x even}

Dengan kata lain, Anda akan menemukan bahwa definisi di atas sebenarnya memberi tahu hal berikut:

• Deret S sebenarnya berisi nilai antara 0 dan 9 (inklusif) yang dipangkatkan dua.
• Deret V, di sisi lain, berisi nilai 2 yang dipangkatkan ke suatu bilangan. Untuk elemen pertama dalam deret, pangkatnya 0, untuk yang kedua 1, dan seterusnya, hingga 12.
• Terakhir, deret M berisi elemen dari deret S, tetapi hanya yang genap.

Jika definisi di atas membuat Anda pusing, lihat list sebenarnya yang dihasilkan definisi tersebut:

S = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
V = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096}
M = {0, 4, 16, 36, 64}

Anda jelas melihat hasil dari setiap list dan operasi yang dijelaskan di dalamnya!

Sekarang setelah Anda memahami sebagian matematika di balik list, Anda bisa menerjemahkan atau mengimplementasikan notasi matematika untuk membangun list di Python menggunakan list comprehension! Lihat baris kode berikut:

Semuanya terlihat sangat mirip dengan definisi matematika yang baru saja Anda lihat, bukan?

Jangan khawatir jika Anda sedikit bingung pada titik ini; Bahkan jika Anda bukan jago matematika, list comprehension ini cukup mudah jika Anda meluangkan waktu untuk mempelajarinya. Lihat sekali lagi, lebih saksama, pada kode Python di chunk kode di atas.

Anda akan melihat bahwa kode tersebut menyatakan bahwa:

• List S dibangun dengan tanda kurung siku seperti yang Anda baca di bagian pertama. Di dalam kurung itu, ada elemen x yang dipangkatkan 10. Sekarang, Anda hanya perlu tahu untuk berapa banyak nilai (dan nilai yang mana!) yang perlu Anda pangkatkan 2. Ini ditentukan dalam range(10). Dengan mempertimbangkan semua ini, Anda dapat menyimpulkan bahwa Anda akan memangkatkan semua angka dari 0 sampai 9 dengan pangkat 2.
• List V berisi nilai dasar 2, yang dipangkatkan ke suatu bilangan. Sama seperti sebelumnya, sekarang Anda perlu tahu pangkat mana atau i yang tepat akan digunakan. Anda melihat bahwa i dalam kasus ini merupakan bagian dari range(13), yang berarti Anda mulai dari 0 hingga 12. Semua ini berarti list Anda akan memiliki 13 nilai—nilai tersebut adalah 2 dipangkatkan 0, 1, 2, ... sampai 12.
• Terakhir, list M berisi elemen yang merupakan bagian dari S jika—dan hanya jika—mereka dapat dibagi 2 tanpa sisa. Nilai modulo harus 0. Dengan kata lain, list M dibangun dari nilai genap yang tersimpan dalam list S.

Sekarang setelah semuanya dituliskan, jadi jauh lebih masuk akal, bukan?

Rekap dan Latihan

Singkatnya, Anda melihat ada beberapa elemen yang berulang di semua baris kode ini:

• Tanda kurung siku, yang merupakan ciri khas list Python;
• Kata kunci for, diikuti variabel yang melambangkan item list; dan
• Kata kunci in, diikuti oleh sebuah deret (yang bisa berupa list!).

Dan ini menghasilkan potongan kode yang Anda lihat di awal bagian ini:

list_variable = [x for x in iterable]

Sekarang giliran Anda untuk mulai menggunakan list comprehension di Python! Mari tetap dekat dengan list matematis yang telah Anda lihat sebelumnya:

List Comprehension sebagai Alternatif untuk...

List comprehension dapat sepenuhnya menggantikan for loop, fungsi lambda, serta fungsi map(), filter(), dan reduce(). Lebih dari itu, bagi sebagian orang, list comprehension bahkan lebih mudah dipahami dan digunakan dalam praktik! Anda akan membaca lebih lanjut tentang ini di bagian berikut!

Namun, jika Anda ingin tahu lebih banyak tentang fungsi dan fungsi lambda di Python, lihat Tutorial Fungsi Python kami.

For Loop

Seperti yang mungkin sudah Anda ketahui, Anda menggunakan for loop untuk mengulang blok kode sejumlah kali yang tetap. List comprehension sebenarnya merupakan alternatif yang baik untuk for loop, karena lebih ringkas. Pertimbangkan contoh berikut yang dimulai dengan variabel numbers, didefinisikan sebagai range dari 0 hingga 10 (tidak termasuk).

Ingat bahwa angka yang Anda berikan ke fungsi range() sebenarnya adalah jumlah bilangan bulat yang ingin Anda hasilkan, tentu mulai dari nol. Ini berarti range(10) akan mengembalikan [0,1,2,3,4,5,6,7,8,9].

# Initialize `numbers`
numbers = range(10)

Jika sekarang Anda ingin melakukan operasi pada setiap elemen di numbers, Anda dapat melakukannya dengan for loop, seperti ini:

# Initialize `new_list`
new_list = []

# Add values to `new_list`
for n in numbers:
    if n%2==0:
        new_list.append(n**2)

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Ini sudah baik, tetapi sekarang perhatikan contoh list comprehension berikut, di mana Anda pada dasarnya melakukan hal yang sama dengan notasi yang lebih ringkas:

# Create `new_list` 
new_list = [n**2 for n in numbers if n%2==0]

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Mari pelajari perbedaan performa antara list comprehension dan for loop dengan uji kecil: Anda bisa menyiapkannya dengan cepat menggunakan pustaka timeit, yang bisa dipakai untuk mengukur waktu potongan kecil kode Python secara sederhana. Dalam kasus ini, potongan kode kecil yang akan Anda uji adalah for loop, yang Anda tempatkan dalam sebuah fungsi bernama power_two() untuk kenyamanan Anda, dan list comprehension persis seperti yang Anda tulis di atas.

Catatan bahwa Anda juga meneruskan jumlah eksekusi yang ingin dipertimbangkan. Dalam kasus ini, disetel ke 10000 pada argumen number.

# Import `timeit`
import timeit

# Print the execution time
print(timeit.timeit('[n**2 for n in range(10) if n%2==0]', number=10000))

0.05234622399802902

# Define `power_two()` 
def power_two(numbers):
    for n in numbers:
        if n%2==0:
            new_list.append(n**2)
    return new_list

# Print the execution time 
print(timeit.timeit('power_two(numbers)', globals=globals(), number=10000))

0.07795589299712447

Catatan bahwa pada potongan kode terakhir ini, Anda juga menambahkan argumen globals, yang akan menyebabkan kode dieksekusi dalam namespace global saat ini. Ini sangat berguna jika Anda memiliki User-Defined Function (UDF) seperti fungsi power_two() pada contoh di atas. Sebagai alternatif, Anda juga bisa meneruskan parameter setup yang berisi pernyataan import. Anda dapat membaca lebih lanjut di sini.

Tip: lihat tutorial Loops in Python dari DataCamp untuk informasi lebih lanjut tentang loop di Python.

Fungsi Lambda dengan map(), filter() dan reduce()

Fungsi lambda juga disebut "fungsi anonim" atau "fungsi tanpa nama". Itu berarti Anda hanya menggunakan tipe fungsi ini saat dibuat. Fungsi lambda mengambil namanya dari kata kunci lambda di Python, yang digunakan untuk mendeklarasikan fungsi-fungsi ini alih-alih kata kunci standar def.

Anda biasanya menggunakan fungsi-fungsi ini bersama dengan fungsi map(), filter(), dan reduce().

Cara Mengganti map() yang Dikombinasikan dengan Fungsi Lambda

Anda dapat menulis ulang kombinasi map() dan fungsi lambda seperti pada contoh di bawah ini:

# Initialize the `kilometer` list 
kilometer = [39.2, 36.5, 37.3, 37.8]

# Construct `feet` with `map()`
feet = map(lambda x: float(3280.8399)*x, kilometer)

# Print `feet` as a list 
print(list(feet))

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

Sekarang, Anda dapat dengan mudah mengganti kombinasi fungsi yang mendefinisikan variabel feet ini dengan list comprehension, dengan memperhatikan komponen yang telah Anda baca di bagian sebelumnya:

• Mulai dengan tanda kurung siku.
• Kemudian tambahkan isi fungsi lambda ke dalam tanda kurung siku itu: float(3280.8399)*x.
• Selanjutnya, tambahkan kata kunci for dan pastikan untuk mengulang elemen deret x, yang sudah Anda rujuk saat menambahkan isi fungsi lambda.
• Jangan lupa untuk menentukan dari mana x berasal: tambahkan kata kunci in, diikuti oleh deret tempat Anda akan mengambil x. Dalam kasus ini, Anda akan mentransformasikan elemen dari list kilometer.

Jika Anda melakukan semua ini, Anda akan mendapatkan hasil berikut:

# Convert `kilometer` to `feet` 
feet = [float(3280.8399)*x for x in kilometer]

# Print `feet`
print(feet)

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

filter() dan Fungsi Lambda ke List Comprehension

Sekarang setelah Anda melihat betapa mudahnya mengonversi fungsi map() yang dikombinasikan dengan fungsi lambda, Anda juga dapat menangani kode yang berisi fungsi Python filter() dengan fungsi lambda dan menuliskannya ulang.

Pertimbangkan contoh berikut:

# Map the values of `feet` to integers 
feet = list(map(int, feet))

# Filter `feet` to only include uneven distances 
uneven = filter(lambda x: x%2, feet)

# Check the type of `uneven`
type(uneven)

# Print `uneven` as a list
print(list(uneven))

[122375, 124015]

Untuk menulis ulang baris kode pada contoh di atas, Anda sebenarnya dapat menggunakan dua list comprehension, yang disimpan dalam variabel feet dan uneven.

Pertama, Anda menulis ulang fungsi map(), yang Anda gunakan untuk mengonversi elemen list feet menjadi integer. Lalu, Anda menangani fungsi filter(): Anda mengambil isi fungsi lambda, menggunakan kata kunci for dan in untuk menghubungkan x dan feet secara logis:

# Constructing `feet` 
feet = [int(x) for x in feet]

# Print `feet`
print(feet)

# Get all uneven distances
uneven = [x%2 for x in feet]

# Print `uneven`
print(uneven)

[128608, 119750, 122375, 124015]
[0, 0, 1, 1]

Reduce reduce() dan Fungsi Lambda di Python

Terakhir, Anda juga dapat menulis ulang fungsi lambda yang digunakan dengan fungsi reduce() menjadi baris kode yang lebih ringkas. Perhatikan contoh berikut:

# Import `reduce` from `functools` 
from functools import reduce

# Reduce `feet` to `reduced_feet`
reduced_feet = reduce(lambda x,y: x+y, feet)

# Print `reduced_feet`
print(reduced_feet)

[128608, 119750, 122375, 124015]
494748

Catatan bahwa di Python 3, fungsi reduce() telah dipindahkan ke paket functools. Oleh karena itu, Anda perlu mengimpor modulnya untuk menggunakannya, seperti pada contoh kode di atas.

Potongan kode di atas cukup panjang, bukan?

Mari kita tulis ulang potongan kode ini!

Hati-hati! Anda perlu mempertimbangkan bahwa Anda tidak dapat menggunakan y. List comprehension hanya bekerja dengan satu elemen saja, seperti x yang telah Anda lihat di banyak contoh pada tutorial ini.

Bagaimana Anda akan menyelesaikannya?

Nah, dalam kasus seperti ini, fungsi agregasi seperti sum() bisa sangat berguna:

# Construct `reduced_feet`
reduced_feet = sum([x for x in feet])

# Print `reduced_feet`
print(reduced_feet)

494748

Catatan bahwa jika dipikir-pikir, penggunaan fungsi agregasi saat menulis ulang fungsi reduce() yang digabungkan dengan fungsi lambda masuk akal: ini sangat mirip dengan yang Anda lakukan di SQL ketika Anda menggunakan fungsi agregasi untuk membatasi jumlah rekaman yang Anda dapatkan setelah menjalankan kueri. Dalam kasus ini, Anda menggunakan fungsi sum() untuk mengagregasi elemen di feet agar hanya mendapatkan satu nilai akhir!

Perlu dicatat bahwa meskipun pendekatan ini mungkin tidak se-performatif di SQL, ini jelas merupakan cara yang tepat saat Anda bekerja di Python!

List Comprehension dengan Kondisi

Sekarang setelah Anda memahami dasar-dasar list comprehension di Python, saatnya menyesuaikan alur kontrol dari comprehension Anda dengan bantuan kondisi.

# Define `uneven`
uneven = [x/2 for x in feet if x%2==0]

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Catatan bahwa Anda dapat menulis ulang chunk kode di atas dengan for loop Python dengan mudah!

# Initialize and empty list `uneven` 
uneven = []

# Add values to `uneven` 
for x in feet:
    if x % 2 == 0:
        x = x / 2
        uneven.append(x)

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Beberapa Kondisi If

Sekarang setelah Anda memahami bagaimana menambahkan kondisi, saatnya mengonversi for loop berikut menjadi list comprehension dengan kondisi.

divided = []

for x in range(100):
    if x%2 == 0 :
        if x%6 == 0:
            divided.append(x)

Hati-hati, Anda melihat bahwa for loop berikut berisi dua kondisi! Pikirkan baik-baik bagaimana Anda akan menyelesaikannya.

divided = [x for x in range(100) if x % 2 == 0 if x % 6 == 0]

print(divided)

[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

Kondisi If-Else

Tentu saja, jauh lebih umum bekerja dengan kondisi yang melibatkan lebih dari satu kondisi. Benar, Anda akan lebih sering melihat if dikombinasikan dengan elif dan else. Lalu, bagaimana menanganinya jika Anda berencana menulis ulang kode Anda?

Lihat contoh berikut dari kondisi yang lebih kompleks dalam sebuah for loop:

[x+1 if x >= 120000 else x+5 for x in feet]

[128609, 119755, 122376, 124016]

Sekarang lihat chunk kode berikut, yang merupakan penulisan ulang dari potongan kode di atas:

for x in feet:  
    if x >= 120000:
        x + 1
    else: 
        x+5

Anda melihat bahwa ini pada dasarnya kode yang sama, tetapi distrukturkan ulang: bagian terakhir for x in feet sekarang menginisialisasi for loop. Setelah itu, Anda menambahkan kondisi if x >= 120000 dan baris kode yang ingin Anda eksekusi jika kondisi ini True: x + 1. Jika kondisinya False, maka bagian terakhir kode dalam list comprehension Anda akan dieksekusi: x+5.

Nested List Comprehension

Selain kondisi, Anda juga dapat menyesuaikan list comprehension dengan menumpuknya di dalam list comprehension lain. Ini berguna saat Anda ingin bekerja dengan list berisi list: misalnya, membuat list berisi list, mentransposisi list berisi list, atau memipihkan list berisi list menjadi list biasa akan menjadi sangat mudah dengan nested list comprehension.

Lihat contoh berikut:

list_of_list = [[1,2,3],[4,5,6],[7,8]]

# Flatten `list_of_list`
[y for x in list_of_list for y in x]

[1, 2, 3, 4, 5, 6, 7, 8]

Anda menetapkan sebuah list berisi list yang cukup sederhana ke variabel list_of_list. Pada baris berikutnya, Anda mengeksekusi list comprehension yang mengembalikan list normal. Yang sebenarnya terjadi adalah Anda mengambil elemen list (y) dari list bersarang (x) dalam list_of_list dan mengembalikan list dari elemen-elemen y yang termasuk dalam x.

Anda melihat bahwa sebagian besar kata kunci dan elemen yang digunakan dalam contoh nested list comprehension serupa dengan yang Anda gunakan dalam contoh list comprehension sederhana:

• Tanda kurung siku
• Dua kata kunci for, diikuti oleh variabel yang melambangkan item dari list berisi list (x) dan item list dari list bersarang (y); dan
• Dua kata kunci in, diikuti oleh list berisi list (list_of_list) dan item list (x).

Sebagian besar komponennya hanya digunakan dua kali dan Anda naik satu tingkat (atau turun, tergantung sudut pandang!).

Butuh sedikit waktu untuk membiasakan diri, tetapi cukup sederhana, bukan?

Sekarang pertimbangkan contoh lain, di mana Anda melihat bahwa Anda juga dapat menggunakan dua pasang tanda kurung siku untuk mengubah logika nested list comprehension Anda:

matrix = [[1,2,3],[4,5,6],[7,8,9]]

[[row[i] for row in matrix] for i in range(3)]

[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Sekarang berlatih: tulis ulang chunk kode di atas menjadi nested for loop. Jika Anda memerlukan petunjuk tentang cara menyelesaikan latihan ini, lihat salah satu bagian sebelumnya dari tutorial ini.

transposed = []

for i in range(3):
     transposed_row = []
     for row in matrix:
            transposed_row.append(row[i])
     transposed.append(transposed_row)

Anda juga dapat menggunakan nested list comprehension saat perlu membuat list berisi list yang sebenarnya adalah sebuah matriks. Lihat contoh berikut:

matrix = [[0 for col in range(4)] for row in range(3)]

matrix

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Tip: latih keterampilan loop Anda di Python dan tulis ulang chunk kode di atas menjadi nested for loop!

Anda dapat menemukan solusinya di bawah.

for x in range(3):
    nested = []
    matrix.append(nested)
    for row in range(4):
        nested.append(0)

Jika Anda ingin kerja ekstra, coba terjemahkan for loop ini menjadi while loop. Anda dapat menemukan solusinya di bawah:

x = 0
matrix =[]

while x < 3:
    nested = []
    y = 0
    matrix.append(nested)
    x = x+1
    while y < 4:
        nested.append(0)
        y= y+1

Terakhir, ada baiknya mengetahui bahwa Anda juga dapat menggunakan fungsi seperti int() untuk mengonversi entri dalam list feet Anda ke integer. Dengan membungkus [int(x) for x in feet] di dalam list comprehension lain, Anda dapat membangun matriks atau list dari list Anda dengan cukup mudah:

[[int(x) for x in feet] for x in feet]

[[128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015]]

Kuasai Python untuk Data Science

Selamat! Anda telah sampai di akhir tutorial ini, di mana Anda mempelajari list comprehension, mekanisme yang sering digunakan di Python untuk data science. Sekarang setelah Anda memahami cara kerjanya, Anda siap juga untuk mempelajari dictionary, set, ... comprehension!

Jangan lupa bahwa Anda dapat melatih keterampilan Python setiap hari dengan mode latihan harian DataCamp! Anda bisa menemukannya langsung di dasbor Anda. Jika Anda belum mengenal mode latihan harian, baca selengkapnya di sini! Dan jelajahi katalog lengkap kursus Python DataCamp di sini.

Walaupun list comprehension dapat membuat kode kita lebih ringkas, penting untuk memastikan kode akhir kita tetap mudah dibaca, jadi baris kode tunggal yang terlalu panjang sebaiknya dihindari agar kode ramah pengguna.