Fungsi Python Dijelaskan: Membangun Modul Kode yang Dapat Digunakan Kembali
Previous Page Next Page
Fungsi adalah blok kode yang terorganisir dan dapat digunakan kembali yang digunakan untuk melakukan satu tindakan yang terkait. Fungsi menyediakan modularitas yang lebih baik untuk aplikasi Anda dan tingkat tinggi penggunaan ulang kode.
Seperti yang Anda ketahui, Python memberikan banyak fungsi bawaan seperti print(), dll. tetapi Anda juga dapat membuat fungsi Anda sendiri. Fungsi ini disebut user-defined functions.
Mendefinisikan Fungsi
Anda dapat mendefinisikan fungsi untuk menyediakan fungsionalitas yang diperlukan. Berikut adalah aturan sederhana untuk mendefinisikan fungsi dalam Python.
Blok fungsi dimulai dengan kata kunci def diikuti oleh nama fungsi dan tanda kurung ( ( ) ).
Parameter atau argumen masukan apa pun harus ditempatkan di dalam tanda kurung ini. Anda juga dapat mendefinisikan parameter di dalam tanda kurung ini.
Pernyataan pertama dari sebuah fungsi dapat merupakan pernyataan opsional - string dokumentasi fungsi atau docstring.
Blok kode dalam setiap fungsi dimulai dengan titik dua (:) dan diindentasi.
Pernyataan return [expression] keluar dari fungsi, secara opsional mengembalikan ekspresi ke pemanggil. Pernyataan return tanpa argumen sama dengan return None.
Sintaks
def functionname( parameters ): "function_docstring" function_suite return [expression]
Secara default, parameter memiliki perilaku posisi dan Anda perlu memberitahu mereka dalam urutan yang sama dengan yang didefinisikan.
Contoh
Fungsi berikut menerima string sebagai parameter masukan dan mencetaknya ke layar standar.
def printme( str ): "This prints a passed string into this function" print str return
Memanggil Fungsi
Mendefinisikan fungsi hanya memberinya nama, menentukan parameter yang akan disertakan dalam fungsi dan menyusun blok kode.
Setelah struktur dasar fungsi diselesaikan, Anda dapat mengeksekusinya dengan memanggilnya dari fungsi lain atau langsung dari prompt Python. Berikut adalah contoh untuk memanggil fungsi printme() −
Live Demo
#!/usr/bin/python # Function definition is here def printme( str ): "This prints a passed string into this function" print str return; # Now you can call printme function printme("I'm first call to user defined function!") printme("Again second call to the same function") Ketika kode di atas dieksekusi, hasilnya adalah sebagai berikut −
I'm first call to user defined function! Again second call to the same function
Pass by reference vs value
Semua parameter (argumen) dalam bahasa Python diteruskan oleh referensi. Ini berarti jika Anda mengubah apa yang dirujuk oleh parameter dalam fungsi, perubahan tersebut juga tercermin kembali di fungsi pemanggil. Misalnya −
Live Demo
#!/usr/bin/python # Function definition is here def changeme( mylist ): "This changes a passed list into this function" mylist.append([1,2,3,4]); print "Values inside the function: ", mylist return # Now you can call changeme function mylist = [10,20,30]; changeme( mylist ); print "Values outside the function: ", mylist
Di sini, kami memelihara referensi dari objek yang diteruskan dan menambahkan nilai dalam objek yang sama. Jadi, ini akan menghasilkan hasil berikut −
Values inside the function: [10, 20, 30, [1, 2, 3, 4]] Values outside the function: [10, 20, 30, [1, 2, 3, 4]]
Ada contoh lain di mana argumen diteruskan oleh referensi dan referensi ditimpa dalam fungsi yang dipanggil.
Live Demo
#!/usr/bin/python # Function definition is here def changeme( mylist ): "This changes a passed list into this function" mylist = [1,2,3,4]; # This would assig new reference in mylist print "Values inside the function: ", mylist return # Now you can call changeme function mylist = [10,20,30]; changeme( mylist ); print "Values outside the function: ", mylist
Parameter mylist adalah lokal untuk fungsi changeme. Mengubah mylist dalam fungsi tidak mempengaruhi mylist. Fungsi ini tidak mencapai apa-apa dan akhirnya akan menghasilkan hasil berikut −
Values inside the function: [1, 2, 3, 4] Values outside the function: [10, 20, 30]
Argumen Fungsi
Anda dapat memanggil fungsi dengan menggunakan jenis argumen formal berikut −
- Required arguments
- Keyword arguments
- Default arguments
- Variable-length arguments
Required arguments
Required arguments adalah argumen yang diteruskan ke fungsi dalam urutan posisi yang benar. Di sini, jumlah argumen dalam panggilan fungsi harus cocok tepat dengan definisi fungsi.
Untuk memanggil fungsi printme(), Anda tentu perlu melewatkan satu argumen, jika tidak akan menghasilkan syntax error sebagai berikut −
Live Demo
#!/usr/bin/python # Function definition is here def printme( str ): "This prints a passed string into this function" print str return; # Now you can call printme function printme()
Ketika kode di atas dieksekusi, hasilnya adalah sebagai berikut −
Traceback (most recent call last): File "test.py", line 11, in <module> printme(); TypeError: printme() takes exactly 1 argument (0 given)
Keyword arguments
Keyword arguments berkaitan dengan panggilan fungsi. Saat Anda menggunakan keyword arguments dalam panggilan fungsi, pemanggil mengidentifikasi argumen dengan nama parameter.
Ini memungkinkan Anda untuk melewatkan argumen atau menempatkannya di luar urutan karena interpreter Python dapat menggunakan kata kunci yang disediakan untuk mencocokkan nilai dengan parameter. Anda juga dapat membuat panggilan keyword ke fungsi printme() dengan cara berikut −
Live Demo
#!/usr/bin/python # Function definition is here def printme( str ): "This prints a passed string into this function" print str return; # Now you can call printme function printme( str = "My string")
Ketika kode di atas dieksekusi, hasilnya adalah sebagai berikut −
My string
Contoh berikut memberikan gambar yang lebih jelas. Perhatikan bahwa urutan parameter tidak penting.
Live Demo
#!/usr/bin/python # Function definition is here def printinfo( name, age ): "This prints a passed info into this function" print "Name: ", name print "Age ", age return; # Now you can call printinfo function printinfo( age=50, name="miki" )
Ketika kode di atas dieksekusi, hasilnya adalah sebagai berikut −
Name: miki Age 50
Default arguments
Default argument adalah argumen yang mengasumsikan nilai default jika nilai tidak disediakan dalam panggilan fungsi untuk argumen tersebut. Contoh berikut memberikan ide tentang default arguments, mencetak default age jika tidak diteruskan −
Live Demo
#!/usr/bin/python # Function definition is here def printinfo( name, age = 35 ): "This prints a passed info into this function" print "Name: ", name print "Age ", age return; # Now you can call printinfo function printinfo( age=50, name="miki" ) printinfo( name="miki" )
Ketika kode di atas dieksekusi, hasilnya adalah sebagai berikut −
Name: miki Age 50 Name: miki Age 35
Variable-length arguments
Anda mungkin perlu memproses fungsi untuk lebih banyak argumen daripada yang Anda tentukan saat mendefinisikan fungsi. Argumen ini disebut variable-length arguments dan tidak dinamai dalam definisi fungsi, tidak seperti required dan default arguments.
Sintaks untuk fungsi dengan non-keyword variable arguments adalah sebagai berikut −
def functionname([formal_args,] *var_args_tuple ): "function_docstring" function_suite return [expression]
Bintang (*) ditempatkan sebelum nama variabel yang menyimpan nilai semua nonkeyword variable arguments. Tuple ini tetap kosong jika tidak ada argumen tambahan yang ditentukan selama panggilan fungsi. Berikut adalah contoh sederhana −
Live Demo
#!/usr/bin/python # Function definition is here def printinfo( arg1, *vartuple ): "This prints a variable passed arguments" print "Output is: " print arg1 for var in vartuple: print var return; # Now you can call printinfo function printinfo( 10 ) printinfo( 70, 60, 50 )
Ketika kode di atas dieksekusi, hasilnya adalah sebagai berikut −
Output is: 10 Output is: 70 60 50
Fungsi Anonymous
Fungsi ini disebut anonim karena tidak dideklarasikan secara standar dengan menggunakan kata kunci def. Anda dapat menggunakan kata kunci lambda untuk membuat fungsi anonim kecil.
Lambda forms dapat mengambil sejumlah argumen apa pun tetapi mengembalikan hanya satu nilai dalam bentuk ekspresi. Mereka tidak dapat berisi perintah atau beberapa ekspresi.
Fungsi anonim tidak dapat menjadi panggilan langsung ke print karena lambda membutuhkan ekspresi
Fungsi lambda memiliki namespace lokal mereka sendiri dan tidak dapat mengakses variabel selain yang ada dalam daftar parameter mereka dan yang ada dalam namespace global.
Meskipun tampaknya lambda adalah versi satu baris dari fungsi, mereka tidak setara dengan pernyataan inline dalam C atau C++, yang tujuannya adalah melewati alokasi stack fungsi selama pemanggilan untuk alasan performa.
Sintaks
Sintaks fungsi lambda hanya berisi satu pernyataan, yaitu sebagai berikut −
lambda [arg1 [,arg2,.....argn]]:expression
Berikut adalah contoh untuk menunjukkan cara kerja bentuk lambda dari fungsi −
Live Demo
#!/usr/bin/python # Function definition is here sum = lambda arg1, arg2: arg1 + arg2; # Now you can call sum as a function print "Value of total : ", sum( 10, 20 ) print "Value of total : ", sum( 20, 20 )
Ketika kode di atas dieksekusi, hasilnya adalah sebagai berikut −
Value of total : 30 Value of total : 40
Pernyataan return
Pernyataan return [expression] keluar dari fungsi, secara opsional mengembalikan ekspresi ke pemanggil. Pernyataan return tanpa argumen sama dengan return None.
Semua contoh di atas tidak mengembalikan nilai apa pun. Anda dapat mengembalikan nilai dari fungsi sebagai berikut −
Live Demo
#!/usr/bin/python # Function definition is here def sum( arg1, arg2 ): # Add both the parameters and return them." total = arg1 + arg2 print "Inside the function : ", total return total; # Now you can call sum function total = sum( 10, 20 ); print "Outside the function : ", total
Ketika kode di atas dieksekusi, hasilnya adalah sebagai berikut −
Inside the function : 30 Outside the function : 30
Scope of Variables
Semua variabel dalam program mungkin tidak dapat diakses di semua lokasi dalam program tersebut. Ini tergantung pada di mana Anda mendeklarasikan variabel.
Scope dari variabel menentukan bagian program di mana Anda dapat mengakses pengidentifikasi tertentu. Ada dua scope dasar variabel dalam Python −
- Global variables
- Local variables
Global vs. Local variables
Variabel yang didefinisikan di dalam tubuh fungsi memiliki scope lokal, dan yang didefinisikan di luar memiliki scope global.
Ini berarti variabel lokal dapat diakses hanya di dalam fungsi tempat mereka dideklarasikan, sedangkan variabel global dapat diakses di seluruh tubuh program oleh semua fungsi. Saat Anda memanggil fungsi, variabel yang dideklarasikan di dalamnya dibawa ke dalam scope. Berikut adalah contoh sederhana −
Live Demo
#!/usr/bin/python total = 0; # This is global variable. # Function definition is here def sum( arg1, arg2 ): # Add both the parameters and return them." total = arg1 + arg2; # Here total is local variable. print "Inside the function local total : ", total return total; # Now you can call sum function sum( 10, 20 ); print "Outside the function global total : ", total
Ketika kode di atas dieksekusi, hasilnya adalah sebagai berikut −
Inside the function local total : 30 Outside the function global total : 0
