Fungsi Python: Cara Memanggil & Menulis Fungsi

Argumen Default

Argumen default adalah argumen yang mengambil nilai bawaan jika tidak ada nilai argumen yang diteruskan saat pemanggilan fungsi. Anda dapat menetapkan nilai default ini dengan operator penugasan =, seperti pada contoh berikut:

Argumen Wajib

Sesuai namanya, argumen wajib dari UDF adalah argumen yang harus ada. Argumen ini perlu diteruskan saat pemanggilan fungsi dan dalam urutan yang tepat, seperti pada contoh berikut:

Anda membutuhkan argumen yang dipetakan ke parameter a maupun b untuk memanggil fungsi tanpa error. Jika Anda menukar a dan b, hasilnya tidak akan berbeda, tetapi bisa berbeda jika Anda mengubah plus() menjadi berikut ini:

Argumen Kata Kunci

Jika Anda ingin memastikan bahwa Anda memanggil semua parameter dalam urutan yang benar, Anda dapat menggunakan argumen kata kunci dalam pemanggilan fungsi. Anda menggunakannya untuk mengidentifikasi argumen berdasarkan nama parameternya. Mari ambil contoh di atas untuk memperjelas:

Perhatikan bahwa dengan menggunakan argumen kata kunci, Anda juga dapat menukar urutan parameter dan tetap mendapatkan hasil yang sama saat mengeksekusi fungsi Anda:

Jumlah Argumen Variabel

Dalam kasus ketika Anda tidak mengetahui jumlah argumen yang tepat yang ingin Anda teruskan ke suatu fungsi, Anda dapat menggunakan sintaks berikut dengan *args:

Tanda bintang (*) diletakkan sebelum nama variabel yang menampung nilai semua argumen variabel non-kata kunci. Perhatikan di sini bahwa Anda juga bisa saja meneruskan *varint, *var_int_args atau nama lain apa pun ke fungsi plus().

Tip: coba ganti *args dengan nama lain yang menyertakan tanda bintang. Anda akan melihat kode di atas tetap bekerja!

Anda melihat bahwa fungsi di atas menggunakan fungsi bawaan Python sum() untuk menjumlahkan semua argumen yang diteruskan ke plus().

Variabel global vs. lokal

Pada umumnya, variabel yang didefinisikan di dalam badan fungsi memiliki cakupan lokal, dan yang didefinisikan di luar memiliki cakupan global. Artinya, variabel lokal didefinisikan dalam blok fungsi dan hanya dapat diakses di dalam fungsi tersebut, sementara variabel global dapat diakses oleh semua fungsi yang mungkin ada di skrip Anda:

Anda akan melihat bahwa Anda akan mendapatkan NameError yang menyatakan bahwa name 'total' is not defined ketika Anda mencoba mencetak variabel lokal total yang didefinisikan di dalam badan fungsi. Variabel init, di sisi lain, dapat dicetak tanpa masalah.

Parameter hanya-posisional dan hanya-kata kunci

Sejak Python 3.8, Anda dapat mengambil lebih banyak kendali atas bagaimana argumen harus diteruskan dengan menggunakan dua penanda khusus dalam tanda tangan fungsi Anda: / dan *. Apa pun sebelum / hanya dapat diteruskan secara posisional; apa pun setelah * hanya dapat diteruskan dengan kata kunci.

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")

 Berikut cara penerapannya saat pemanggilan:

greet("Alice")                          # works
greet("Alice", greeting="Hi")           # works
greet("Alice", "Hi", punctuation="?")   # works

greet(name="Alice")                     # TypeError: name is positional-only
greet("Alice", "Hi", "?")               # TypeError: punctuation is keyword-only

Mengapa Anda menginginkan ini? Dua alasan utama.

Pertama, parameter hanya-posisional memungkinkan Anda mengganti namanya di kemudian hari tanpa merusak kode siapa pun — karena tidak ada yang diizinkan menggunakan nama parameter sebagai kata kunci, Anda bebas mengubahnya.

Kedua, parameter hanya-kata kunci memaksa pemanggil untuk eksplisit tentang apa yang mereka teruskan, yang membuat pemanggilan lebih mudah dibaca ketika Anda memiliki beberapa flag atau pengaturan opsional.

Singkatnya, ini adalah cara yang rapi untuk menegakkan maksud.

Fungsi Anonim dalam Python

Fungsi anonim juga disebut fungsi lambda dalam Python karena alih-alih mendeklarasikannya dengan kata kunci standar def, Anda menggunakan kata kunci lambda.

Pada potongan DataCamp Light di atas, lambda x: x*2 adalah fungsi anonim atau lambda. x adalah argumen, dan x*2 adalah ekspresi atau instruksi yang dievaluasi dan dikembalikan. Yang istimewa dari fungsi ini adalah tidak memiliki nama, tidak seperti contoh yang Anda lihat di bagian pertama tutorial fungsi ini. Jika Anda harus menulis fungsi di atas dalam UDF, hasilnya akan seperti berikut:

def double(x):
  return x*2

Mari pertimbangkan contoh lain dari fungsi lambda di mana Anda bekerja dengan dua argumen:

Anda menggunakan fungsi anonim ketika Anda memerlukan fungsi tanpa nama untuk periode singkat, dan dibuat saat runtime. Konteks spesifik di mana ini relevan adalah ketika Anda bekerja dengan filter(), map() dan reduce():

Fungsi filter() menyaring, seperti namanya, list masukan asli my_list berdasarkan kriteria >10. Dengan map(), di sisi lain, Anda menerapkan fungsi ke semua item list my_list. Dalam kasus ini, Anda mengalikan semua elemen dengan 2.

Perhatikan bahwa fungsi reduce() merupakan bagian dari pustaka functools. Anda menggunakan fungsi ini secara kumulatif pada item-item list my_list, dari kiri ke kanan dan mereduksi urutan menjadi satu nilai, 55, dalam hal ini.

Menggunakan main() sebagai Fungsi di Python

Jika Anda memiliki pengalaman dengan bahasa pemrograman lain seperti Java, Anda akan tahu bahwa fungsi main diperlukan untuk mengeksekusi fungsi. Seperti yang telah Anda lihat pada contoh di atas, ini tidak selalu diperlukan untuk Python. Namun, menyertakan fungsi main() dalam program Python Anda bisa berguna untuk menyusun kode secara logis — semua komponen terpenting berada dalam fungsi main() ini.

Anda dapat dengan mudah mendefinisikan fungsi main() dan memanggilnya seperti yang telah Anda lakukan dengan semua fungsi lainnya di atas:

Namun, seperti saat ini, kode fungsi main() Anda akan dipanggil ketika Anda mengimpornya sebagai modul. Untuk memastikan itu tidak terjadi, Anda memanggil fungsi main() ketika __name__ == '__main__'.

Itu berarti kode pada potongan kode di atas menjadi:

Catatan bahwa selain fungsi __main__, Anda juga memiliki fungsi __init__ yang menginisialisasi instance dari sebuah kelas atau objek. Sederhananya, ini bertindak sebagai konstruktor atau inisialisator dan dipanggil secara otomatis ketika Anda membuat instance baru dari sebuah kelas. Dengan fungsi itu, objek yang baru dibuat ditetapkan ke parameter self, yang telah Anda lihat sebelumnya dalam tutorial ini. Lihat contoh berikut:

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())