Bagaimana Cara Menggunakan Operator Pembongkar (*, **) dengan Python?

Python adalah bahasa pemrograman yang paling banyak digunakan. Hari ini Anda akan belajar menggunakan salah satu fitur intinya — tetapi sering diabaikan —, membongkar dengan Python.

Anda mungkin pernah melihat * dan ** dalam kode orang lain atau bahkan telah menggunakannya tanpa benar-benar mengetahui apa tujuannya. Kami akan membahas konsep membongkar, dan bagaimana menggunakannya untuk menulis lebih banyak kode Pythonic.

Berikut adalah daftar konsep yang menurut Anda berguna saat membaca tutorial ini:

• Iterable : Setiap urutan yang dapat diulang oleh for-loop , seperti set, daftar, tupel, dan kamus
• Callable : Objek Python yang dapat dipanggil menggunakan tanda kurung ganda (), misalnya, myfunction()
• Shell: Lingkungan runtime interaktif yang memungkinkan kita menjalankan kode Python. Kita dapat menyebutnya dengan menjalankan "python" di terminal
• Variabel: Nama simbolik yang menyimpan objek dan memiliki lokasi memori yang dicadangkan.

Mari kita mulai dengan kebingungan yang paling sering terjadi: Asteristik dalam Python juga merupakan operator aritmatika. Satu asterisk (*) digunakan untuk perkalian, sedangkan dua di antaranya (**) mengacu pada eksponensial.

Kita dapat membuktikannya dengan membuka shell Python dan mengetik:

 >>> 3*3 9 >>> 3**3 27

Catatan: Anda harus menginstal Python 3 untuk mengikuti tutorial ini. Jika Anda belum menginstalnya, lihat panduan instalasi Python kami.

Seperti yang Anda lihat, kami menggunakan tanda bintang setelah angka pertama dan sebelum angka kedua. Ketika Anda melihat ini, itu berarti kami menggunakan operator aritmatika.

Di sisi lain, kami menggunakan tanda bintang (*, **) sebelum iterable untuk membongkarnya — misalnya:

 >>> *range(1, 6), (1, 2, 3, 4, 5) >>> {**{'vanilla':3, 'chocolate':2}, 'strawberry':2} {'vanilla': 3, 'chocolate': 2, 'strawberry': 2}

Jangan khawatir jika Anda tidak mengerti, ini hanyalah pembukaan untuk membongkar dengan Python. Jadi lanjutkan dan baca seluruh tutorial!

Apa yang sedang dibongkar?

Membongkar adalah proses mengeluarkan barang — dapat diubah seperti daftar, tupel, dan kamus. Anggap saja seperti membuka kotak dan mengeluarkan berbagai item seperti kabel, headphone, atau USB.

Mari kita terjemahkan contoh yang sama ini ke dalam kode untuk pemahaman yang lebih baik:

 >>> mybox = ['cables', 'headphones', 'USB'] >>> item1, item2, item3 = mybox

Seperti yang Anda lihat, kami menugaskan tiga item dalam daftar mybox untuk tiga variabel item1, item2, item2. Penugasan variabel semacam ini adalah konsep dasar membongkar dengan Python.

Jika Anda mencoba untuk mendapatkan nilai setiap item, Anda akan melihat bahwa item1 , mengacu pada "kabel", item2 , mengacu pada "headphone" dan seterusnya.

 >>> item1 'cables' >>> item2 'headphones' >>> item3 'USB'

Sampai di sini, semuanya tampak baik-baik saja dengan kode ini, tetapi bagaimana jika kita ingin membongkar daftar dengan lebih banyak elemen di dalamnya — menjaga jumlah variabel yang ditetapkan sama?

 >>> newbox = ['cables', 'headphones', 'USB', 'mouse'] >>> item1, item2, item3 = newbox Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: too many values to unpack (expected 3)

Mungkin Anda mengharapkan kesalahan semacam ini. Pada dasarnya kami menugaskan 4 item daftar ke tiga variabel, bagaimana cara Python mengatur untuk menetapkan nilai yang benar?

Tidak, itu karena kami mendapatkan ValueError dengan pesan "terlalu banyak nilai untuk dibongkar". Ini terjadi karena kita menyetel tiga variabel di sebelah kiri, dan empat nilai (sesuai dengan daftar kotak baru) di sebelah kanan.

Jika Anda mencoba melakukan proses serupa, tetapi dengan lebih banyak variabel daripada nilai untuk dibongkar, Anda akan mendapatkan ValueError lain kecuali dengan pesan yang sedikit berbeda:

 >>> lastbox = ['cables', 'headphones'] >>> item1, item2, item3 = lastbox Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: not enough values to unpack (expected 3, got 2)

Catatan: Kami telah bekerja dengan daftar tetapi Anda dapat menggunakan bentuk pembongkaran ini dengan iterable apa pun (daftar, set, tupel, kamus)

Jadi bagaimana kita mengatasi situasi ini? Apakah ada cara untuk membongkar semua item dari iterable ke beberapa variabel tanpa mendapatkan kesalahan?

Tentu ada, dan itu disebut operator unpacking atau operator asterisk (*, **). Mari kita lihat cara menggunakannya dengan Python.

Cara Membongkar Daftar Dengan operator *

Operator asterisk (*) digunakan untuk membongkar semua nilai dari iterable yang belum ditetapkan.

Misalkan Anda ingin mendapatkan elemen pertama dan terakhir dari daftar tanpa menggunakan indeks, kita dapat melakukannya dengan operator asterisk:

 >>> first, *unused, last = [1, 2, 3, 5, 7] >>> first 1 >>> last 7 >>> unused [2, 3, 5]

Seperti yang dapat Anda hargai, kami mendapatkan semua nilai yang tidak digunakan dengan operator asterisk. Cara yang lebih disukai untuk membuang nilai adalah dengan menggunakan variabel garis bawah (_), yang terkadang digunakan sebagai "variabel dummy".

 >>> first, *_, last = [1, 2, 3, 5, 7] >>> _ [2, 3, 5]

Kita masih dapat menggunakan trik ini meskipun daftar hanya memiliki dua elemen:

 >>> first, *_, last = [1, 2] >>> first 1 >>> last 2 >>> _ []

Dalam hal ini, variabel garis bawah (variabel dummy) menyimpan daftar kosong sehingga dua variabel lain di sekitarnya dapat mengakses nilai daftar yang tersedia.

Pemecahan masalah umum

Kami dapat membongkar elemen unik dari iterable. Misalnya, Anda akan menemukan sesuatu seperti ini:

 >>> *string = 'PythonIsTheBest'

Namun, kode di atas akan mengembalikan SyntaxError :

 >>> *string = 'PythonIsTheBest' File "<stdin>", line 1 SyntaxError: starred assignment target must be in a list or tuple

Ini karena menurut spesifikasi PEP:

Tuple (atau daftar) di sisi kiri tugas sederhana

Jika kita ingin membongkar semua nilai dari sebuah iterable ke satu variabel, kita harus menyiapkan sebuah tuple, maka menambahkan koma sederhana sudah cukup:

 >>> *string, = 'PythonIsTheBest' >>> string ['P', 'y', 't', 'h', 'o', 'n', 'I', 's', 'T', 'h', 'e', 'B', 'e', 's', 't']

Contoh lain akan menggunakan fungsi rentang , yang mengembalikan urutan angka.

 >>> *numbers, = range(5) >>> numbers [0, 1, 2, 3, 4]

Sekarang setelah Anda mengetahui cara membongkar daftar dan tupel dengan tanda bintang, saatnya untuk membuka kamus.

Cara Membongkar Kamus Dengan operator **

Sementara tanda bintang tunggal digunakan untuk membongkar daftar dan tupel, tanda bintang ganda (**) digunakan untuk membongkar kamus.

Sayangnya, kami tidak dapat membongkar kamus ke satu variabel seperti yang telah kami lakukan dengan tupel dan daftar. Itu berarti yang berikut ini akan menimbulkan kesalahan:

 >>> **greetings, = {'hello': 'HELLO', 'bye':'BYE'} ... SyntaxError: invalid syntax

Namun, kita dapat menggunakan operator ** di dalam callable dan kamus lainnya. Misalnya, jika kita ingin membuat kamus gabungan yang dibuat dari kamus lain, kita bisa menggunakan kode di bawah ini:

 >>> food = {'fish':3, 'meat':5, 'pasta':9} >>> colors = {'red': 'intensity', 'yellow':'happiness'} >>> merged_dict = {**food, **colors} >>> merged_dict {'fish': 3, 'meat': 5, 'pasta': 9, 'red': 'intensity', 'yellow': 'happiness'}

Ini adalah cara yang cukup singkat untuk membuat kamus majemuk, namun, ini bukan pendekatan utama untuk membongkar dengan Python.

Mari kita lihat bagaimana kita dapat menggunakan unpacking dengan callables

Pengepakan dalam Fungsi: args dan kwargs

Anda mungkin pernah melihat args dan kwargs sebelum diimplementasikan pada kelas atau fungsi. Mari kita lihat mengapa kita perlu menggunakannya bersama dengan callable.

Pengepakan dengan operator * (args)

Misalkan kita memiliki fungsi yang menghitung produk dari dua angka.

 >>> def product(n1, n2): ... return n1 * n2 ... >>> numbers = [12, 1] >>> product(*numbers) 12

Seperti yang Anda lihat, kami membongkar nomor daftar ke fungsi, jadi kami sebenarnya menjalankan yang berikut:

 >>> product(12, 1) 12

Sampai di sini, semuanya bekerja dengan baik, tetapi bagaimana jika kita ingin melewati daftar yang lebih panjang? Ini pasti akan menimbulkan kesalahan karena fungsi menerima lebih banyak argumen daripada yang mampu dikelolanya.

 >>> numbers = [12, 1, 3, 4] >>> product(*numbers) ... TypeError: product() takes 2 positional arguments but 4 were given

Kita dapat menyelesaikan semua ini hanya dengan mengemas daftar secara langsung pada fungsi, yang menciptakan iterable di dalamnya dan memungkinkan kita untuk meneruskan sejumlah argumen ke fungsi.

 >>> def product(*args): ... result = 1 ... for i in args: ... result *= i ... return result ... >>> product(*numbers) 144

Di sini kita memperlakukan parameter args sebagai sebuah iterable, berjalan melintasi elemen-elemennya dan mengembalikan produk dari semua angka. Perhatikan bagaimana angka awal dari hasil harus satu karena jika kita mulai dengan nol, fungsi akan selalu mengembalikan nol.

Catatan: args hanyalah sebuah konvensi, Anda dapat menggunakan nama parameter lainnya

Kami juga dapat meneruskan angka arbitrer ke fungsi tanpa menggunakan daftar, sama seperti fungsi cetak bawaan.

 >>> product(5, 5, 5) 125 >>> print(5, 5, 5) 5 5 5

Akhirnya, mari kita dapatkan tipe objek dari argumen suatu fungsi.

 >>> def test_type(*args): ... print(type(args)) ... print(args) ... >>> test_type(1, 2, 4, 'a string') <class 'tuple'> (1, 2, 4, 'a string')

Seperti disebutkan dalam kode di atas, jenis args akan selalu Tuple , dan isinya akan menjadi semua argumen tanpa kata kunci yang diteruskan ke fungsi.

Pengepakan dengan operator ** (kwargs)

Seperti yang kita lihat sebelumnya, operator ** digunakan secara eksklusif untuk kamus. Ini berarti bahwa dengan operator ini kita dapat meneruskan pasangan nilai kunci ke fungsi sebagai parameter.

Mari kita buat fungsi make_person , yang menerima argumen posisional "nama", dan jumlah argumen kata kunci yang tidak ditentukan.

 >>> def make_person(name, **kwargs): ... result = name + ': ' ... for key, value in kwargs.items(): ... result += f'{key} = {value}, ' ... return result ... >>> make_person('Melissa', id=12112, location='london', net_worth=12000) 'Melissa: id = 12112, location = london, net_worth = 12000, '

Seperti yang Anda lihat, pernyataan **kwargs mengonversi semua argumen dengan kata kunci ke kamus, yang dapat kita iterasi di dalam fungsi.

Catatan: kwargs hanyalah sebuah konvensi Anda dapat memberi nama parameter ini dengan apa pun yang Anda inginkan

Kita dapat memeriksa jenis kwargs dengan cara yang sama seperti yang kita lakukan dengan args :

 >>> def test_kwargs(**kwargs): ... print(type(kwargs)) ... print(kwargs) ... >>> test_kwargs(random=12, parameters=21) <class 'dict'> {'random': 12, 'parameters': 21}

Variabel internal kwargs selalu berubah menjadi kamus, yang menyimpan pasangan nilai kunci yang diteruskan ke fungsi.

Akhirnya, mari kita gunakan args dan kwargs dalam fungsi yang sama:

 >>> def my_final_function(*args, **kwargs): ... print('Type args: ', type(args)) ... print('args: ', args) ... print('Type kwargs: ', type(kwargs)) ... print('kwargs: ', kwargs) ... >>> my_final_function('Python', 'The', 'Best', language='Python', users='A lot') Type args: <class 'tuple'> args: ('Python', 'The', 'Best') Type kwargs: <class 'dict'> kwargs: {'language': 'Python', 'users': 'A lot'}

Kesimpulan

Operator pembongkaran sangat berguna dalam tugas sehari-hari, sekarang Anda tahu cara menggunakannya baik dalam pernyataan individual maupun parameter fungsi.

Dalam tutorial ini Anda belajar:

• Anda menggunakan * untuk tupel dan daftar dan ** untuk kamus
• Anda dapat menggunakan operator pembongkaran dalam fungsi dan konstruktor kelas
• args digunakan untuk meneruskan parameter tanpa kata kunci ke fungsi
• kwargs digunakan untuk meneruskan parameter kata kunci ke fungsi.