Penggunaan Asterisk di Python

Kebanyakan dari kita menggunakan asterisk sebagai operator perkalian dan pangkat, tetapi operator ini juga memiliki beragam operasi lain saat digunakan sebagai operator prefiks di Python. Setelah membaca artikel ini, Anda akan mengetahui seluruh penggunaan asterisk.

Asterisk memiliki banyak kasus penggunaan khusus di Python. Secara umum, kita akrab dengan operator perkalian dan pangkat. Operator ini juga dapat melakukan operasi lain seperti unpacking, pengoperan argumen, dan sebagainya dalam berbagai situasi. Pertama, mari kita lihat penggunaan umum dari asterisk.

Penggunaan Umum * dan **

* digunakan sebagai operator perkalian sedangkan ** digunakan sebagai operator pangkat.

## declaring variables
a, b = 2,3

## multiplication
print("Multiplication of 2 and 3 is {}".format(a * b))

## as power operator
print("2 power 3 is {}".format(a ** b))

Multiplication of 2 and 3 is 6
2 power 3 is 8

Sekarang Anda telah melihat penggunaan asterisk yang umum dan paling sering digunakan. Namun, ada kasus penggunaan asterisk lain yang mungkin belum Anda ketahui. Mari kita telusuri penggunaan tersembunyi dari asterisk.

1. Unpacking Menggunakan *

Melakukan unpacking elemen dari list/tuple/set menggunakan *. Kita akan menggunakan unpacking pada kode selanjutnya untuk menerapkan fitur lain dari asterisk. Unpacking adalah gagasan dasar di balik penggunaan asterisk sebagai operator prefiks.

Misalkan kita ingin menugaskan elemen pertama dari list/tuple/set ke a dan elemen sisanya ke b. Umumnya, kita akan menyelesaikannya dengan slicing.

## general approach
nums = [i for i in range(1, 6)]
a = nums[0]
b = nums[1:]
print(a, b)

print("--------------------------")

## hard approach
squares = [i ** 2 for i in range(1, 6)]
a = squares[0]
b = []
for i in range(1, len(squares)):
    b.append(squares[i])
print(a, b)

1 [2, 3, 4, 5]
--------------------------
1 [4, 9, 16, 25]

Sekarang, kita akan menggunakan operator * untuk mengimplementasikannya dalam satu baris kode.

nums = [i for i in range(1, 6)]

## a will be 1 and b will be a list containing remaining elements
a, *b = nums
print(a, b)

1 [2, 3, 4, 5]

Di sini a bertipe variabel yang nilainya diambil dari list dan b adalah list. Unpacking dapat bekerja pada tuple dan set sama seperti pada list. Mari lihat beberapa contohnya.

## using tuple
## here first element will assign to a and last element to c
a, *b, c = (1, 2, 3, 4, 5)
print(a, b, c)

print("--------------------------")

## using sets
a, *b, c = {1, 4, 9, 16, 25}
print(a, b, c)

1 [2, 3, 4] 5
--------------------------
1 [4, 9, 16] 25

1.1. Menggabungkan Berbagai Iterable

Kita dapat menambahkan dua iterable yang berbeda ke dalam list/set/tuple menggunakan unpacking. Secara umum, kita harus mengonversi iterable tersebut dan menggabungkannya menjadi satu. Namun itu tidak perlu jika kita menggunakan *. Mari lihat contohnya.

## combining a tuple, list, set
nums = [1, 2, 3]
nums2 = (4, 5, 6)
nums3 = {7, 8, 9}

## we convert the combined elements into any iterable we want
## here i am converting into a list
_list = [*nums, *nums2, *nums3]
_tuple = (*nums, *nums2, *nums3)
_set = {*nums, *nums2, *nums3}

print(type(_list))
print(_list)
print("------------------------")
print(type(_tuple))
print(_tuple)
print("------------------------")
print(type(_set))
print(_set)

<class 'list'>
[1, 2, 3, 4, 5, 6, 8, 9, 7]
------------------------
<class 'tuple'>
(1, 2, 3, 4, 5, 6, 8, 9, 7)
------------------------
<class 'set'>
{1, 2, 3, 4, 5, 6, 7, 8, 9}

1.2. Unpacking Bersarang

Unpacking bersarang adalah mengambil elemen dari level pertama item yang diekstrak. Lihat contoh untuk mendapatkan gambaran tentang apa yang saya maksud.

languages = ["Python", "HTML", "CSS", "JS"]

## unpacking
[[first_letter, *remaining], *other] = languages

print(first_letter, remaining, other)

P ['y', 't', 'h', 'o', 'n'] ['HTML', 'CSS', 'JS']

2. Unpacking Menggunakan **

Seperti yang kita lihat sebelumnya, ** digunakan untuk melakukan unpacking elemen dari sebuah dictionary. Kita harus mengetahui key dari dictionary untuk mengekstrak nilainya saat unpacking. Mari lihat contohnya.

## sample dictionary
person = {"name":"John", "age":19, "year_of_passing":"2021"}
string = "Name:-{name} Year Of Graduation:-{year_of_passing} Age:-{age}".format(**person)
print(string)

Name:-John Year Of Graduation:-2021 Age:-19

Tidak umum menggunakan ** untuk mengekstrak elemen dari sebuah dictionary.

3. Asterisk dalam Fungsi

Kita dapat mengoper dan menangkap argumen menggunakan asterisk dalam fungsi untuk mengurangi baris kode.

3.1. Unpacking dalam Fungsi

Operator * digunakan untuk memanggil fungsi dengan melakukan unpacking pada sebuah iterable. Misalnya kita punya sebuah list dan harus mengoper semua elemennya ke print() secara terpisah. Apa yang akan Anda lakukan? Mungkin Anda terpikir memakai loop. Namun, * membuat ini menjadi sangat mudah.

Cukup oper iterable sebagai *nama_iterable. Ini akan melakukan unpacking pada iterable dan mengoper semua elemen secara terpisah.

nums = [i for i in range(1, 6)]
## passsing list using the *
print(*nums)

1 2 3 4 5

nums = (i for i in range(1, 6))
## passsing tuple using the *
print(*nums, sep = ", ")

1, 2, 3, 4, 5

3.2. Packing Elemen

Packing berarti menangkap banyak elemen sekaligus. Kita menggunakan fitur ini dalam pemanggilan fungsi.

def average(*nums):
    return sum(nums) / len(nums)

Sekarang, kita bisa mengoper berapa pun jumlah bilangan bulat untuk menghitung rata-ratanya. Fungsi average menangkap semua argumen sebagai sebuah list.

## calling the average with some numbers
print(average(1, 2, 3, 4, 5))

3.0

Kita telah melihat cara menangkap banyak elemen ke dalam list menggunakan *. Sekarang, kita akan mempelajari cara menangkap berbagai pasangan key-value menggunakan **.

def _object(name, **properties):
    print(name, properties)

_object("Car", color="Red", cost=999999, company="Ferrari")

Car {'ceo': 'Louis', 'color': 'Red', 'cost': 999999, 'company': 'Ferrari'}

4. Argumen Khusus-Kata Kunci dengan Argumen Posisional

Argumen yang memiliki nama disebut argumen kata kunci (keyword). Dan argumen lainnya disebut argumen posisional. Pertama, Anda perlu memahami perbedaan antara argumen kata kunci dan posisional. Mari lihat contohnya.

## name is a positional argument
## color and cost are keyword arguments
def sample(car, color = None, cost = None):
    print("Car:-{} Color:-{}, Cost:-{}".format(car, color, cost))

Kita dapat menggunakan nama parameter untuk mengoper argumen saat memanggil fungsi untuk argumen kata kunci. Jika kita tidak memberikan apa pun untuk argumen kata kunci, maka mereka akan mengambil nilai default yang disediakan dalam definisi fungsi.

Kita dapat menentukan argumen kata kunci menggunakan nama keyword atau posisi argumen.

sample("Ferrari", "Red", 999999)

Car:-Ferrari Color:-Red, Cost:-999999

sample("Ferrari", cost = 999999, color = "Red")

Car:-Ferrari Color:-Red, Cost:-999999

Urutan argumen kata kunci tidak penting jika kita memanggilnya menggunakan nama yang didefinisikan dalam fungsi.

sample("Ferrari", color = "Green")

Car:-Ferrari Color:-Green, Cost:-None

Sekarang, Anda sudah memahami tentang argumen posisional dan kata kunci. Mari masuk ke topik utama kita.

Argumen Khusus-Kata Kunci hanya ditentukan melalui keyword. Kita tidak bisa menetapkannya secara posisional seperti yang telah kita lihat sebelumnya. Kita harus mendeklarasikan argumen kata kunci setelah argumen * untuk menangkap khusus-kata kunci.

def keyword_only(*items, _list, default = False):
    print(items)
    print(_list)
    print(default)

Kita harus menggunakan keyword _list dan default saat memanggil fungsi karena keduanya berada setelah *items. Jika kita tidak menggunakan keyword untuk memanggilnya, kita akan mendapat error. Mari lihat kedua kasusnya.

nums = [i ** 2 for i in range(1, 6)]
## calling the function
keyword_only(1, 2, 3, 4, 5, _list = nums, default = True)

(1, 2, 3, 4, 5)
[1, 4, 9, 16, 25]
True

Bagaimana jika kita memanggil fungsi keyword_only menggunakan argumen posisional.

nums = [i ** 2 for i in range(1, 6)]
## calling the function will raise an error
keyword_only(1, 2, 3, 4, 5, nums, False)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-85-bf737d8a8bfc> in <module>()
      1 nums = [i ** 2 for i in range(1, 6)]
----> 2 keyword_only(1, 2, 3, 4, 5, nums, False)


TypeError: keyword_only() missing 1 required keyword-only argument: '_list'

Kita mendapat error yang menyatakan bahwa kita melewatkan satu argumen khusus-kata kunci yang wajib. Jadi, kita harus menggunakan keyword saat memanggil argumen khusus-kata kunci. Argumen Khusus-Kata Kunci hanya didefinisikan setelah argumen * dalam fungsi.

5. Argumen Khusus-Kata Kunci tanpa Argumen Posisional

Jika kita ingin menerima hanya argumen Khusus-Kata Kunci tanpa argumen posisional apa pun, Python memungkinkan kita menggunakan * pada parameter fungsi untuk mencapainya. Mari lihat contohnya.

def _sample(*, name):
    print(name)

Fungsi di atas hanya menerima argumen khusus-kata kunci. Kita harus mengoper argumen dengan keyword. Jika tidak, kita akan mendapatkan error. * dalam definisi fungsi memastikan bahwa fungsi hanya menerima argumen menggunakan keyword. Parameter apa pun yang kita definisikan setelah parameter * dalam fungsi harus ditentukan dengan keyword saat pemanggilan fungsi.

## calling the function using keyword 'name'
_sample(name = "Datacamp")

Datacamp

## calling the function without using keyword 'name'
## we will get a TypeError
_sample("Datacamp")

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-fe0d3718b56c> in <module>()
      1 ## calling the function without using keyword 'name'
      2 ## we will get a TypeError
----> 3 samp("Datacamp")


TypeError: samp() takes 0 positional arguments but 1 was given

Jelas bahwa fungsi _sample() hanya menerima argumen khusus-kata kunci*.

Kesimpulan

Para pengembang menambahkan fitur baru di setiap rilis Python. Asterisk itu istimewa dan dapat menyederhanakan sebagian kode. Kita tidak bisa menerima banyak argumen posisional tanpa *, dan argumen khusus-kata kunci juga memerlukan * untuk mengimplementasikan fitur tersebut. Operasi asterisk lainnya mungkin dapat dicapai dengan beberapa baris kode. Latihlah untuk memahaminya sepenuhnya. Terima kasih sudah membaca!

Jika Anda ingin mempelajari lebih lanjut tentang Python, ikuti kursus Python Data Science Toolbox (Bagian 1) dari DataCamp.

Selamat ngoding :)