Fungsi

Fungsi yaitu grup/blok aktivitas untuk melaksanakan peran tertentu yang berulang. Fungsi membuat arahan aktivitas menjadi reusable, artinya hanya di definisikan sekali saja, dan kemudian mampu digunakan berulang kali dari kawasan lain di dalam program.

Fungsi memecah keseluruhan aktivitas menjadi kepingan – kepingan yang lebih kecil . Dengan semakin besarnya program, maka fungsi akan membuatnya menjadi lebih praktis diorganisir dan dimanage.

Sejauh ini, kita sudah menggunakan beberapa fungsi, misalnya fungsi print(), type(), dan sebagainya. Fungsi tersebut yaitu fungsi bawaan dari Python. Kita mampu membuat fungsi kita sendiri sesuai kebutuhan.

---

Mendefinisikan Fungsi

Berikut yaitu sintaks yang digunakan untuk membuat fungsi:

def function_name(parameters):
    """function_docstring"""
    statement(s)
    return [expression]

Penjelasannya dari sintaks fungsi di atas:

1. Kata kunci def diikuti oleh function_name (nama fungsi), tanda kurung dan tanda titik dua (:) menandai header (kepala) fungsi.




2. Parameter / argumen yaitu input dari luar yang akan diproses di dalam tubuh fungsi.




3. "function_docstring" bersifat opsional, yaitu sebagai string yang digunakan untuk dokumentasi atau penjelasan fungsi. “function_doctring” diletakkan paling atas setelah baris def.




4. Setelah itu diletakkan baris – baris pernyataan (statements). Jangan lupa indentasi untuk menandai blok fungsi.




5. return bersifat opsional. Gunanya yaitu untuk mengembalikan suatu nilai expression dari fungsi.

Berikut yaitu pola fungsi untuk menyapa seseorang.

 
def sapa(nama):
"""Fungsi ini untuk menyapa seseorang sesuai nama yang dimasukkan sebagai parameter"""
print("Hi, " + nama + ". Apa kabar?")

# pemanggilan fungsi
# output: Hi, Umar. Apa kabar?
sapa('Umar')


 

Memanggil Fungsi

Bila fungsi sudah didefinisikan, maka ia sudah mampu dipanggil dari kawasan lain di dalam program. Untuk memanggil fungsi caranya yaitu dengan mengetikkan nama fungsi berikut paramaternya.

Untuk fungsi di atas, kita mampu melakukannya mirip pola berikut:

>>> sapa('Galih')
Hi, Galih. Apa kabar?

>>> sapa('Ratna')
Hi, Ratna. Apa kabar?

Docstring

Docstring yaitu akronim dari documentation string. Ini berfungsi sebagai dokumentasi atau keterangan singkat perihal fungsi yang kita buat. Meskipun bersifat opsional, menuliskan docstring yaitu kebiasaan yang baik.

Untuk pola di atas kita menuliskan docstring. Cara mengaksesnya yaitu dengan menggunakan format namafungsi.__doc__

>>> print(sapa.__doc__)
"""Fungsi ini untuk menyapa seseorang sesuai nama yang dimasukkan sebagai parameter"""

Pernyataan return

Pernyataan return digunakan untuk keluar dari fungsi  dan kembali ke baris selanjutnya dimana fungsi dipanggil.

Adapun sintaks dari return adalah:

return [expression_list]

return mampu berisi satu atau beberapa mulut atau nilai yang dievaluasi dan nilai tersebut akan dikembalikan. Bila tidak ada pernyataan return yang dibuat atau mulut dikosongkan, maka fungsi akan mengembalikan objek None.

Perhatikan kalau hasil keluaran dari fungsi sapa kita simpan dalam variabel.

>>> keluaran = sapa('Gani')
>>> print(keluaran)
None

---

Argumen Fungsi

Kita mampu memanggil fungsi dengan menggunakan salah satu dari empat jenis argumen berikut:

1. Argumen wajib (required argument)




2. Argumen kata kunci (keyword argument)




3. Argumen default




4. Argumen dengan panjang sembarang

Argumen Wajib

Argumen wajib yaitu argumen yang dilewatkan ke dalam fungsi dengan urutan posisi yang benar. Di sini, jumlah argumen pada ketika pemanggilan fungsi harus sama persis dengan jumlah argumen pada pendefinisian fungsi

Pada pola fungsi sapa() di atas, kita perlu melewatkan satu argumen ke dalam fungsi sapa(). Bila tidak, maka akan muncul error.

>>> sapa('Umar')
Hi Umar. Apa kabar?

>>> # akan muncul error
>>> sapa()
Traceback (most recent call last):
 File "<pyshell#5>", line 1, in <module>
 sapa()
TypeError: sapa() missing 1 required positional argument: 'nama'

Argumen Kata Kunci

Argumen dengan kata kunci berkaitan dengan cara pemanggilan fungsi. Ketika menggunakan argumen dengan kata kunci, fungsi pemanggil menentukan argumen dari nama parameternya. Hal ini membuat kita mampu mengabaikan argumen atau menempatkannya dengan sembarang urutan.

Python mampu menggunakan kata kunci yang disediakan untuk mencocokkan nilai sesuai dengan parameternya. Jelasnya ada pada pola berikut:

 
# definisi fungsi print_string
def print_string( str ):
"""Menampilkan argumen string str ke layar"""
print (str)

# Kita memanggil fungsi dengan kata kunci
print_string( str = "Hello Python")


Urutan parameter tidak menjadi masalah. Perhatikan pola berikut:

 
# Definisi fungsi
def print_info( nama, usia ):
"""Fungsi ini menampilkan informasi yang dimasukkan"""
print ("Nama: ", nama)
print ("Usia: ", usia)

# Memanggil fungsi
# output
# Name: Budi
# Usia: 25
print_info( usia = 25, nama = "Budi" )


Argumen Default

Fungsi dengan argumen default menggunakan nilai default untuk argumen yang tidak diberikan nilainya pada ketika pemanggilan fungsi. Pada pola berikut, fungsi akan menampilkan usia default kalau argumen usia tidak diberikan:

 
# Definisi fungsi
def print_info( nama, usia= 17 ):
"""Fungsi ini menampilkan informasi yang dimasukkan"""
print ("Nama: ", nama)
print ("Usia ", usia)

# Memanggil fungsi print_info
print_info( usia = 29, nama = "Galih" )

# Pemanggilan fungsi tidak menyediakan argumen usia
print_info( nama = "Galih" )
 

Pada pola di atas, pemanggilan fungsi kedua tidak menyediakan nilai untuk parameter usia, sehingga yang digunakan yaitu nilai default yaitu 17. Bila aktivitas di atas dijalankan, alhasil yaitu mirip berikut:

Nama: Galih
Usia: 29
Nama: Galih
Usia: 17

Argumen Dengan Panjang Sembarang

Terkadang kita butuh untuk memproses fungsi yang memiliki banyak argumen. Nama – nama argumennya tidak disebutkan ketika pendefinisian fungsi, beda halnya dengan fungsi dengan argumen wajib dan argumen default.

Sintaksnya fungsi dengan argumen panjang sembarang yaitu mirip berikut:

def function_name([formal_args,] *var_args_tuple): 
    """function_docstring""" 
    statement(s) 
    return [expression]

Tanda asterisk (*) ditempatkan sebelum nama variabel yang menyimpan nilai dari semua argumen yang tidak didefinisikan. Tuple ini akan kosong kalau tidak ada argumen suplemen pada ketika pemanggilan fungsi. Berikut yaitu contohnya:

 
# Definisi fungsi
def print_info( arg1, *vartuple ):
"""Fungsi untuk menampilkan nilai argumen sembarang yang dilewatkan"""
print ("Outputnya adalah: ")
print (arg1)
for var in vartuple:
print (var)

# Pemanggilan fungsi
# Satu argumen
print_info( 10 )

# Empat argumen
print_info( 10, 30, 50, 70 )


Pada ketika aktivitas di atas dijalankan maka alhasil yaitu mirip berikut:

Outputnya adalah:
10
Outputnya adalah:
10
30
50
70

---

Ruang Lingkup (Scope) Variabel

Di Python, tidak semua variabel mampu diakses dari semua tempat. Ini tergantung dari kawasan dimana kita mendefinisikan variabel. Ruang lingkup variabel ada dua, yaitu:

• Global




• Local

Variabel yang didefinisikan di dalam fungsi memiliki scope lokal, sedangkan variabel yang didefinisikan di luar fungsi memiliki scope global.

Ini berarti, variabel lokal hanya mampu diakses dari dalam fungsi di mana ia di definisikan, sedangkan variabel global mampu diakses dari seluruh kawasan dimanapun di dalam program. Berikut yaitu contohnya:

 
total = 0
# Variabel global
# Definisi fungsi
def sum( arg1, arg2 ):
"""Menambahkan variabel dan mengembalikan hasilnya."""
total = arg1 + arg2;
# total di sini yaitu variabel lokal
print ("Di dalam fungsi nilai total : ", total)
return total

# Pemanggilan fungsi sum
sum( 10, 20 )
print ("Di luar fungsi, nilai total : ", total )
 

Pada ketika dijalankan, maka alhasil yaitu mirip berikut:

Di dalam fungsi nilai total : 30
Di luar fungsi, nilai total : 0

Perhatikan bagaimana variabel total di dalam dan di luar fungsi yaitu dua variabel yang berbeda.

 

Lebih lanjut perihal fungsi mampu Anda baca di fungsi lanjut Python.