FunctionsFix.tex

\section{Python Functions}
Fungsi adalah blok kode terorganisir dan dapat digunakan kembali yang digunakan untuk melakukan tindakan tunggal dan terkait. Fungsi menyediakan modularitas yang lebih baik untuk aplikasi Anda dan tingkat penggunaan kode yang tinggi. Seperti yang sudah Anda ketahui, Python memberi Anda banyak fungsi built-in seperti cetak (), dll. Tetapi Anda juga dapat membuat fungsi Anda sendiri. Fungsi ini disebut fungsi yang ditentukan pengguna. 

Ada tiga jenis fungsi dengan Python: 
\begin{enumerate}
\item Built-in Functions, seperRekursif ti help () untuk meminta bantuan, min () untuk mendapatkan nilai minimum, print () untuk mencetak objek ke terminal.
\item User-Defined Functions (UDFs), yang merupakan fungsi yang dibuat untuk membantu pengguna
\item Anonymous Functions, yang juga disebut fungsi lambda karena tidak dinyatakan dengan kata kunci def standar.
\end{enumerate}

Keuntungan-keuntungan menggunakan Function, yaitu: 
\begin{enumerate}
\item Program besar dapat di bagi menjadi program-program kecil menggunakan function.
\item Kemudahan mencari error atau kesalahan karena alur logika jelas dan kesalahan dapat ditempatkan pada suatu modul tertentu.
\item Memodifikasi dan memperbaiki program dapat digunakan pada suatu modul tertentu saja tanpa mempengaruhi keseluruhan program.
\item Dapat digunakan lagi (Reusability) oleh program atau fungsi lain.
\item Meminimalkan penulisan perintah yang sama. 
\end{enumerate}

function di Python biasanya mempunyai sebuah parameter dan return statement. Function di Python mempunyai pola sebagai berikut:
\begin{verbatim}
def nama function yang ingin anda buat (param1, param2, ... paramn):
   
   # kode Anda diisi
    return sesuatu
\end{verbatim}    
Tipe data yang dikembalikan bisa bermacam jenis tipe data yang didukung Python. Meskipun parameter yang akan diterima oleh function tersebut. 

\section{Kategori Fungsi}
\begin{enumerate}
\item Standard Library Function ialah fungsi-fungsi yang telah disediakan oleh Interpreter Python dalam file-file atau librarynya.  Misalnya: raw\_input(), input(), print(), open(), len(), max(), min(), abs()  dan lain-lain. 
\item Programme-Defined Function ialah function yang dibuat oleh programmer itu sendiri. Function ini memiliki nama tertentu yang unik dalam programnya, letaknya terpisah dari program utama, dan bisa dijadikan satu ke dalam suatu library yang di buat oleh programmer itu sendiri.
\end{enumerate}

Dalam python terdapat dua buah perintah yang dapat digunakan untuk membuat sebuah fungsi, yaitu def dan lambda. def adalah perintah standar di dalam python untuk mendefinisikan sebuah fungsi. Tidak seperti function dalam bahasa pemrograman compiler seperti C/C++, def dalam bahasa python merupakan perintah yang executable, artinya function yang tidak akan aktif sampai python merunning perintah def tersebut. Sedangkan lambda, dalam python lebih dikenal dengan nama Anonymous Function (Fungsi yang tidak disebutkan namanya). Lambda bukanlah sebuah perintah (statemen) namun lebih kepada ekspresi (expression).


\subsection{Defining a Function} 
Anda dapat menentukan fungsi untuk menyediakan fungsionalitas yang dibutuhkan. Berikut adalah aturan sederhana untuk mendefinisikan fungsi dengan Python. 
\begin{enumerate}
\item Blok fungsi dimulai dengan defensi kata kunci diikuti oleh nama fungsi dan tanda kurung (()).
\item Setiap parameter masukan atau argumen harus ditempatkan di dalam tanda kurung ini. Anda juga dapat menentukan parameter di dalam tanda kurung ini.
\item Pernyataan fungsi pertama dapat berupa pernyataan opsional - string dokumentasi fungsi atau docstring.
\item Blok kode dalam setiap fungsi dimulai dengan titik dua (:) dan indentasi.
\item Pernyataan kembali [ekspresi] keluar dari sebuah fungsi, secara opsional menyampaikan kembali ekspresi ke pemanggil. Pernyataan pengembalian tanpa argumen sama dengan return None.
\end{enumerate}

\subsection{Parameter Fungsi} 
Parameter Fungsi adalah sebuah fungsi yang dapat mempunyai daftar argumen (parameter) atau tidak. 

\subsubsection{Parameter Posisi} 
Parameter Posisi merupakan parameter fungsi pada urutan posisi yang valid. Saat pemanggilan fungsi, parameter itu diharuskan sesuai dengan jumlah parameter yang sudah didefinisikan. 

Contoh : 
\begin{verbatim}
def perhitunan (k,l) :
            m=k+l
            return m
perhitungan (4,5)
0utput = 9
\end{verbatim}

\subsubsection{Parameter Nama} 
Parameter Nama adalah Dipanggilnya fungsi  nilai pada parameternya dijelaskan langsung dari nama parameternya. 

Contoh :
\begin{verbatim}
def totalTransfer(hari, uangTransfer):
            gaji= hari*uangTransfer
            return gaji
totalTransfer(hari=20,uangTransfer=20000)
Output = 400000
\end{verbatim}

\subsubsection{Parameter Default}
Parameter default adalah nilai yang diambil ke parameter pada saat pendefinisian fungsi.
Contoh :
\begin{verbatim}
def koin (ratusan, ribuan=5) :
Print “koin ratusannya adalah ; “, ratusan;
Print “koin ribuannya adalah ; “, ribuan;
Uang(7)
Output : 7 dan 5 , nilai default yang digunakan.
\end{verbatim}

\subsubsection{Parameter Bertipe List} 
Parameter Bertipe List adalah satu parameter yang diawali oleh tanda  *. 
Contoh :
\begin{verbatim}
def angka(*bilangan) ;
            Print angka
angka (2,7,9)
Output : (2,7,9)
\end{verbatim}

\section{Syntax} 
Berikut adalah contoh program kalkulator menggunakan Function pada Python : 
\begin{verbatim}
def menu()
    print "Hallo Guys :) Selamat Datang di Program Kalkulator"
    print "Pilih Operasi Bilangan :"
    print " "
    print "1) Penjumlahan"
    print "2) Pengurangan"
    print "3) Perkalian"
    print "4) Pembagian"
    print "5) Keluar Program"
    print " "
    return input ("Pilih Operasi Matematikanya : ")

# Function untuk Penjumlahan
def tbh(a,b):
    print a, "+", b, "=", a + b

# Function untuk Pengurangan
def kur(a,b):
    print b, "+", a, "=", b + a

# Function untuk Perkalian
def kal(a,b):
    print a, "*", b, "=", a * b

# Function untuk Pembagian
def bag(a,b):
    print a, "/", b, "=", a / b

loop = 1
choice = 0
while loop == 1:
    choice = menu()
    if choice == 1:
        tbh(input("Tambahkan Ini: "),input("Dengan ini: "))
    elif choice == 2:
        kur(input("Kurangkan Ini: "),input("Dengan ini: "))
    elif choice == 3:
        kur(input("Kalikan Ini: "),input("Dengan ini: "))
    elif choice == 4:
        kur(input("Bagikan Ini: "),input("Dengan ini: "))
    elif choice == 5:
        loop = 0

print "GoodBye :( Terimakasih Telah Menggunakan calc.py :)"
\end{verbatim}

Berikut contoh Program Mencetak Menu dan Menghitung Luas menggunakan Function pada Python : 
\begin{verbatim}
def menu(): 
print "Menu Options" 
print 
print "1. Segitiga" 
print "2. Persegi Panjang" 
print "3. Lingkaran" 
print "4. Keluar" 

def segitiga(): 
print "Menghitung Luas Segitiga" 
a = input("Tambahkan Alas : ") 
t = input("Tambahkan Tinggi : ") 
luas = (a*t)/2 
print "Luas Segitiga yaitu ",luas 
print 
print "Coba lagi [Y/N]? " 
back = raw_input().upper() 
if back == "Y": 
menu() 
else: 
exit()

def persegipanjang(): 
print "Menghitung Luas Persegi Panjang" 
p = input("Masukkan Panjang : ") 
l = input("Masukkan Lebar : ") 
luas = p*l 
print "Luas Persegi Panjang yaitu ",luas 
print 
print "Coba lagi [Y/N]? " 
back = raw_input().upper() 
if back == "Y": 
menu() 
else: 
exit() 

def lingkaran(): 
print "Menghitung Luas Lingkaran" 
r = input("Tambahkan Jari-Jari : ") 
luas = 3.14*(r**2) 
print "Luas Lingkaran yaitu ",luas 
print 
print "Coba lagi [Y/N]? " 
back = raw_input().upper() 
if back == "Y": 
menu() 
else: 
exit() 

#Program Perhitungan Luas 
print "Selamat Bahagia di Program Menghitung Luas" 
print "-----------------------------------------------" 
print 
menu() 
while l: 
#input 
pilih = input("Masukkan options : ") 
if pilih == 1: 
Segitiga() 
elif pilih == 2: 
Persegi Panjang() 
elif pilih == 3: 
Lingkaran() 
elif pilih == 4: 
print "\n"*100 
break 
else: 
print "Sorry Option yang di masukkan tidak ada" 
print "Coba lagi [Y/N] ? " 
coba = raw_input().upper() 
if coba == "Y": 
menu() 
else: 
print "\n"*100 
break
\end{verbatim}

\begin{verbatim}
def functionname( parameters ): 
"function \$  \_  \$docstring"
function \$  \_  \$suite 
return [expression] 
\end{verbatim}
Secara default, parameter memiliki perilaku posisi dan Anda perlu memberi tahu mereka dengan urutan yang sama seperti yang ditetapkan. 
Example:
Fungsi berikut mengambil string sebagai parameter masukan dan mencetaknya di layar standar.
\begin{verbatim}
def printme( str ): 
"This prints a passed string into this function" 
print str 
return \par
\end{verbatim}
\section{Calling a Function} 
Mendefinisikan sebuah fungsi hanya memberinya sebuah nama, menentukan parameter yang akan disertakan dalam fungsi dan menyusun blok kode. Setelah struktur dasar fungsi selesai, Anda dapat menjalankannya dengan memanggilnya dari fungsi lain atau langsung dari prompt Python. Berikut adalah contoh untuk memanggil fungsi printme ().
\begin{verbatim}
\$  \#  \$!/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") 
\end{verbatim}
Bila kode diatas dieksekusi, maka menghasilkan hasil sebagai berikut 

I'm first call to user defined function! 
Again second call to the same function 

\section{Pass by reference vs value}
Semua parameter (argumen) dalam bahasa Python dilewatkan dengan referensi. Ini berarti jika Anda mengubah parameter yang mengacu pada suatu fungsi, perubahan tersebut juga mencerminkan kembali fungsi pemanggilan. Sebagai contoh:
\begin{verbatim}
\$  \#  \$!/usr/bin/python 

\$  \#  \$ Function definition is here 
def changeme( mylist ): 
"This changes a passed list into this function" 
mylist.append([1,2,3,4]); 
"Values inside the function: ", mylist

return


\$  \#  \$ Now you can call changeme function 
mylist = [10,20,30]; 
changeme( mylist );
print "Values outside the function: ", mylist
\end{verbatim}
Di sini, kita mempertahankan referensi objek yang dilewati dan menambahkan nilai pada objek yang sama. Jadi, ini akan menghasilkan hasil sebagai berikut:
\begin{verbatim}
Values~inside the function:  [10, 20, 30, [1, 2, 3, 4]] 
Values~outside the function:  [10, 20, 30, [1, 2, 3, 4]] 
\end{verbatim}
Ada satu contoh lagi di mana argumen dilewatkan melalui referensi dan rujukannya ditimpa di dalam fungsi yang disebut. 
\begin{verbatim}
\$  \# \$!/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 
\end{verbatim}
Parameter mylist adalah local ke fungsi changeme. Mengubah mylist dalam fungsi tidak mempengaruhi mylist. Fungsi ini tidak menghasilkan apa-apa dan akhirnya ini akan menghasilkan hasil sebagai berikut: 
\begin{verbatim}
Values~inside the function:  [1, 2, 3, 4] 

Values~outside the function:  [10, 20, 30] 

Function Arguments
\end{verbatim}
Anda dapat memanggil fungsi dengan menggunakan jenis argumen formal berikut: 
\begin{verbatim}
\$ \bullet \$ Argumen yang dibutuhkan
\$ \bullet \$ Argumen kata kunci 

\$ \bullet \$ Argumen baku

\$ \bullet \$ Argumen panjang variable
\end{verbatim}
\section{Required arguments} 
Argumen yang diperlukan adalah argumen yang diberikan ke sebuah fungsi dalam urutan posisi yang benar. Di sini, jumlah argumen dalam pemanggilan fungsi harus sesuai persis dengan definisi fungsi. Untuk memanggil fungsi printme (), Anda pasti perlu melewati satu argumen, jika tidak maka akan memberikan kesalahan sintaks sebagai berikut :
\begin{verbatim}
\$  \#  \$!/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() 
\end{verbatim}
Bila kode diatas dieksekusi, maka menghasilkan hasil sebagai berikut: 
\begin{verbatim}
Traceback (most recent call last): 

 ~ File "test.py", line 11, in <module> 
~~~ printme();

 TypeError: printme() takes exactly 1 argument (0 given) 
\end{verbatim}
\section{Keyword arguments} 
Argumen kata kunci terkait dengan pemanggilan fungsi. Bila Anda menggunakan argumen kata kunci dalam pemanggilan fungsi, penelepon mengidentifikasi argumen berdasarkan nama parameter. Hal ini memungkinkan Anda melewatkan argumen atau menempatkannya agar tidak bermasalah karena penerjemah Python dapat menggunakan kata kunci yang diberikan agar sesuai dengan nilai parameter. Anda juga dapat membuat panggilan kata kunci ke fungsi printme () dengan cara berikut - 
\begin{verbatim}
\$  \#  \$!/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") 
\end{verbatim}
Bila kode diatas dieksekusi, maka menghasilkan hasil sebagai berikut:

My string 

Contoh berikut memberikan gambaran yang lebih jelas. Perhatikan bahwa urutan parameter tidak masalah. 
\begin{verbatim}
\$  \#  \$!/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" )
\end{verbatim}
Bila kode diatas dieksekusi, maka menghasilkan hasil sebagai berikut:
Name:\~ miki

Age\~ 50 


\section{Default arguments} 
Argumen default adalah argumen yang mengasumsikan nilai default jika nilai tidak diberikan dalam pemanggilan fungsi untuk argumen itu. Contoh berikut memberi ide pada argumen default, ini mencetak usia default jika tidak lulus.
\begin{verbatim}
\$  \#  \$!/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" ) 
\end{verbatim}
Bila kode diatas dieksekusi, maka menghasilkan hasil sebagai berikut

Name:\~ miki 

Age\~ 50 

Name:\~ miki

Age\~ 35 

\section{Variable-length arguments} 
Anda mungkin perlu memproses sebuah fungsi untuk argumen lebih banyak daripada yang Anda tentukan saat menentukan fungsinya. Argumen ini disebut variable-lengtharguments dan tidak disebutkan dalam definisi fungsi, tidak seperti argumen yang dibutuhkan dan standar. 

Sintaks untuk fungsi dengan argumen variabel non-kata kunci adalah ini :
\begin{verbatim}
def functionname([formal \$  \_  \$args,] *var \$  \_  \$args \$  \_  \$tuple ): 

~~ "function \$  \_  \$docstring" 

~~ function \$  \_  \$suite 

~~ return [expression]
\end{verbatim}
Tanda asterisk (*) ditempatkan sebelum nama variabel yang menyimpan nilai dari semua argumen variabel nonkeyword. Tuple ini tetap kosong jika tidak ada argumen tambahan yang ditentukan selama pemanggilan fungsi. Berikut adalah contoh sederhana : 
\begin{verbatim}
\$  \#  \$!/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 ) 
\end{verbatim}
Bila kode diatas dieksekusi, maka menghasilkan hasil sebagai berikut - 
Output is: 
0
Output is: 
70 
60 
50 
\section{The Anonymous Functions} 
Fungsi ini disebut anonim karena tidak dinyatakan secara standar dengan menggunakan kata kunci def. Anda bisa menggunakan kata kunci lambda untuk membuat fungsi anonim yang kecil. 

\begin{enumerate}
\item Bentuk lambda bisa mengambil sejumlah argumen tapi hanya mengembalikan satu nilai dalam bentuk ekspresi. Mereka tidak dapat berisi perintah atau beberapa ekspresi. 
\item Fungsi anonim tidak bisa menjadi panggilan langsung untuk dicetak karena lambda membutuhkan ekspresi 
\item  Fungsi Lambda memiliki namespace lokal mereka sendiri dan tidak dapat mengakses variabel selain yang ada dalam daftar parameter dan yang ada di namespace global. 
\item Meskipun tampak bahwa lambda adalah versi satu baris dari sebuah fungsi, mereka tidak setara dengan pernyataan inline di C atau C ++, yang tujuannya adalah dengan melewatkan alokasi stack fungsi selama pemanggilan untuk alasan kinerja. 
\end{enumerate}


\section{Syntax} 
Sintaks fungsi lambda hanya berisi satu pernyataan, yaitu sebagai berikut : 
  lambda [arg1 [,arg2,.....argn]]:expression 
Berikut adalah contoh untuk menunjukkan bagaimana lambda bentuk fungsi bekerja :
\begin{verbatim}
   \$  \#  \$!/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 ) 
  \end{verbatim}
Bila kode diatas dieksekusi, maka menghasilkan hasil sebagai berikut - 
 Value~of total :  30 
 Value~of total :  40 
\section{The return Statement} 
Pernyataan kembali [ekspresi] keluar dari sebuah fungsi, secara opsional menyampaikan kembali ekspresi ke pemanggil. Pernyataan pengembalian tanpa argumen sama dengan return None. 
Semua contoh di atas tidak mengembalikan nilai apapun. Anda bisa mengembalikan nilai dari sebuah fungsi sebagai berikut :
\begin{verbatim}
  \$  \#  \$!/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  
 \end{verbatim}
  \begin{figure}[ht]
 	\centerline{\includegraphics[width=0.70\textwidth]{figures/Functions1}}
 	\caption{Python Tuple Functions}
 	\label{Python Tuple Functions}
 \end{figure} 
 
Bila kode diatas dieksekusi, maka menghasilkan hasil sebagai berikut -
  Inside\~the function :  30 
 Outside\~the function :  30 
\section{Scope of Variables} 
Semua variabel dalam sebuah program mungkin tidak dapat diakses di semua lokasi dalam program tersebut. Ini tergantung di mana Anda telah menyatakan sebuah variabel. 
Contoh penggunaan scope variabel : 
\begin{verbatim}
 def bljrScope(A):
 A = 10
 print "Nilai A di dalam fungsi, a = ", A
 # program utama
 A = 30
 print "Nilai a di luar fungsi, a = ", A
 bljrScope(A)
\end{verbatim
 Output :
 Nilai a di luar fungsi, a = 30
 Nilai A di dalam fungsi, a = 10
Pada contoh diatas, variabel A didefinisikan di dua tempat yaitu di dalam fungsi bljrScope() dan di dalam program utama.Ketika nilai A awal di beri nilai 30, kemudian di cetak, nilai A masih bernilai 30. Namun ketika kita memanggil fungsi bljrScope() dengan mengirim parameter A yang bernilai 30, terlihat bahwa nilai A yang berlaku adalah nilai A yang didefinisikan didalam fungsi tersebut. Atau nilai A yang bernilai 10. ini terbukti bahwa variabel A yang di cetak dalam fungsi bljrScope() merupakan variabel local yang didefinisikan didalam fungsi, bukan variabel A global yang dicetak di luar fungsi.  
Ruang lingkup variabel menentukan bagian dari program di mana Anda dapat mengakses pengenal tertentu. Ada dua lingkup dasar variabel dengan Python - 
   \$ \bullet \$ Variabel global 
   \$ \bullet \$ Variabel local 

\section{Global vs. Local variables} 
Variabel yang didefinisikan di dalam badan fungsi memiliki lingkup lokal, dan yang didefinisikan di luar memiliki cakupan global. 
Ini berarti bahwa variabel lokal dapat diakses hanya di dalam fungsi di mana 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 lingkup. Berikut adalah contoh sederhana :
\begin{verbatim}
  \$  \#  \$!/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  
 \end{verbatim}
Bila kode diatas dieksekusi, maka menghasilkan hasil sebagai berikut : 
  Inside~the function local total :  30 
 Outside~the function global total :  0 


\section{Pembelajaran Function Python}
Function dalam Python didefinisikan menggunakan kata kunci def. Setelah def ada nama pengenal function diikut dengan parameter yang diapit oleh tanda kurung dan diakhir dingan tanda titik dua :. Baris berikutnya berupa blok fungsi yang akan dijalankan jika fungsi dipanggil.