Tutorial Menggunakan Fungsi di R

Jika Anda mempertimbangkan untuk memulai karier di data science, semakin cepat Anda mulai ngoding, semakin baik. Apa pun bahasa pemrograman yang Anda pilih untuk memulai perjalanan belajar, pada titik tertentu Anda akan berkenalan dengan fungsi.

Fungsi adalah konsep utama di hampir setiap bahasa pemrograman modern, termasuk bahasa yang populer di data science seperti Python, Julia, dan tentu saja R.

Dalam tutorial ini, kita akan membahas apa itu fungsi di R dan bagaimana Anda dapat menggunakannya. Dengan mengulas tujuan, sintaks, dan tipologi fungsi yang tersedia di R, Anda akan mendapatkan semua yang Anda butuhkan untuk menguasai konsep penting dalam pemrograman ini. Selain itu, Anda juga akan diperkenalkan pada seni membuat fungsi.

Apa itu Fungsi di R?

Dalam pemrograman, fungsi adalah sekumpulan instruksi yang diorganisasi untuk menjalankan tugas tertentu. Alasan penggunaan fungsi adalah untuk membuat program yang berdiri sendiri dan hanya dipanggil saat diperlukan.

Dengan fungsi, programmer tidak perlu menulis program dari nol, sehingga menghindari pengulangan, serta meningkatkan ketahanan dan keterbacaan kode. Karena itu, sebagai aturan praktis, merupakan kebiasaan baik untuk membuat fungsi setiap kali Anda memperkirakan akan menjalankan seperangkat instruksi tertentu lebih dari dua kali di dalam kode.

Fungsi dapat digunakan untuk berbagai tujuan dan dapat berbentuk beragam. Secara umum, sebagian besar fungsi akan menerima data masukan, memprosesnya, dan mengembalikan hasil. Data yang dioperasikan fungsi ditentukan oleh argumen, yang juga dapat digunakan untuk mengendalikan atau mengubah cara fungsi menjalankan tugasnya.

Bergantung pada asal usulnya, kita dapat membedakan tiga jenis fungsi utama di R:

• Fungsi bawaan
• Fungsi yang tersedia dalam paket R
• Fungsi buatan pengguna (User-Defined Functions/UDF)

Pada bagian-bagian berikut, kami akan menjelaskan kekhasan berbagai jenis fungsi yang tersedia di R.

Fungsi Bawaan di R

R adalah bahasa pemrograman yang kuat dengan katalog luas fungsi bawaan yang dapat dipanggil kapan saja. Sebagai bahasa yang berorientasi matematika, R hadir dengan banyak fungsi untuk melakukan operasi numerik. Di bawah ini adalah beberapa yang paling berguna:

• print(). Menampilkan objek R di konsol R
• min(), max(). Menghitung nilai minimum dan maksimum dari sebuah vektor numerik
• sum(). Menghitung jumlah dari sebuah vektor numerik
• mean(). Menghitung mean dari sebuah vektor numerik
• range(). Menghitung nilai minimum dan maksimum dari sebuah vektor numerik
• str(). Menampilkan struktur sebuah objek R
• ncol(). Mengembalikan jumlah kolom dari sebuah matriks atau dataframe
• length(). Mengembalikan jumlah item dalam sebuah objek R, seperti vektor, list, dan matriks.

Pada kode di bawah, Anda dapat melihat betapa mudahnya menggunakan fungsi-fungsi ini untuk menghitung statistik tertentu dari sebuah vektor:

>>> v <- c(1, 3, 0.2, 1.5, 1.7)
>>> print(v)
[1] 1.0 3.0 0.2 1.5 1.7
>>> sum(v)
[1] 7.4
>>> mean(v)
[1] 1.48
>>> length(v)
[1] 5

Anda dapat mempelajari fungsi-fungsi R dan lainnya dalam R skill track komprehensif kami, yang akan membantu Anda belajar ngoding seperti seorang programmer.

Fungsi dalam Paket R

Meski banyak dan beragam, fungsi bawaan saja tidak cukup untuk melakukan semua hal menarik yang bisa Anda lakukan dengan R, mulai dari membuat visualisasi data yang memikat hingga melatih model machine learning yang kuat.

Mayoritas fungsi untuk melakukan tugas-tugas tersebut tersedia dalam paket atau library eksternal. Paket adalah kumpulan fungsi R, data, dan kode terkompilasi dalam format yang terdefinisi dengan baik untuk menambahkan fungsionalitas tertentu. Sebagian besar paket ini dapat digunakan secara gratis, dan dapat ditemukan di repositori paket populer seperti CRAN, yang saat ini menampilkan hampir 20.000 paket kontribusi.

Untuk menggunakan fungsi yang tersedia dalam sebuah paket, Anda harus memasangnya terlebih dahulu. Misalnya, jika Anda ingin memasang stringr, paket populer untuk bekerja dengan regular expressions, Anda dapat menggunakan pernyataan berikut:

install.packages('stringr')

Setelah terpasang, untuk memuatnya ke lingkungan R Anda, gunakan pernyataan library

library(stringr)

Sekarang Anda siap menggunakan semua fungsi yang tersedia dalam paket stringr. Misalnya, mari coba fungsi str_detect(), yang mengembalikan vektor logis dengan TRUE untuk setiap elemen string yang cocok dengan pola dan FALSE jika tidak.

str_detect('DataCamp', "Data")
[1] TRUE

Jika Anda tertarik mengetahui lebih lanjut tentang paket R dan cara menggunakannya, lihat tutorial paket R dari DataCamp ini.

Fungsi Buatan Pengguna

Cara terbaik untuk memahami bagaimana fungsi di R bekerja adalah dengan membuat fungsi Anda sendiri. Fungsi buatan pengguna (User-Defined Functions/UDF) dirancang oleh programmer untuk menjalankan tugas tertentu.

Fungsi R umumnya menggunakan sintaks berikut:

function_name <- function(argument_1, argument_2) { 
  function body
  return (output)
}

Kita dapat membedakan empat elemen utama:

• Nama fungsi. Untuk membuat UDF, pertama-tama Anda harus memberinya nama dan menyimpannya sebagai objek baru. Anda hanya perlu memanggil nama tersebut kapan pun ingin menggunakan fungsi.
• Argumen. Argumen fungsi (juga dikenal sebagai parameter) disediakan di dalam tanda kurung. Argumen penting agar fungsi tahu data apa yang diambil sebagai masukan dan/atau bagaimana memodifikasi perilaku fungsi.
• Body fungsi. Di dalam kurung kurawal terdapat body fungsi, yaitu instruksi untuk menyelesaikan tugas tertentu berdasarkan informasi yang diberikan oleh argumen.
• Pernyataan return. Pernyataan return diperlukan jika Anda ingin fungsi menyimpan hasil operasi di dalam body fungsi sebagai variabel.

Sebagai contoh, jika Anda ingin membuat fungsi yang menghitung mean dari dua angka:

mean_two_numbers <- function(num_1, num_2) {
  mean <- (num_1 + num_2) / 2
  return (mean)
}

Sekarang, jika Anda ingin menghitung mean dari 10 dan 20, cukup panggil fungsinya sebagai berikut:

>>> mean_two_numbers(10,20)
[1] 15

Jenis-jenis argumen dalam fungsi R

Argumen adalah elemen penting dalam setiap fungsi. Meskipun secara teoretis mungkin menulis fungsi tanpa parameter (lihat contoh di bawah), sebagian besar fungsi memiliki argumen. Itu masuk akal, karena argumen memberi tahu fungsi data apa yang diambil sebagai masukan. Demikian pula, jika kita ingin melengkapi fungsi dengan berbagai cara untuk melakukan suatu tugas, argumenlah yang menjalankannya.

hello <- function() {
  print('hello, my friend')
}

>>> hello()
[1] "hello, my friend"

Tidak ada batasan jumlah argumen dalam fungsi R; Anda dapat menambahkannya di dalam tanda kurung yang dipisahkan koma. Umumnya, fungsi dengan lebih banyak argumen cenderung lebih kompleks.

Setelah Anda membuat fungsi dengan parameter, setiap kali ingin menggunakannya, Anda harus menyediakan nilai untuk setiap parameter; jika tidak, R akan menampilkan error. Misalnya, jika Anda tidak memberikan nilai untuk dua angka guna menghitung meannya, fungsi kita tidak akan berjalan.

Namun, Anda dapat menghindari error ini dengan menggunakan argumen default saat mendefinisikan fungsi. Argumen default menyediakan nilai baku yang akan digunakan jika Anda memanggil fungsi tanpa memberikan argumen tersebut. Mari kembali ke fungsi kita untuk menghitung mean dari dua angka. Kali ini, kita akan menambah argumen default untuk angka kedua.

mean_two_numbers <- function(num_1, num_2 = 30) {
  mean <- (num_1 + num_2) / 2
  return (mean)
}

Jika sekarang kita memanggil fungsi tanpa memberikan nilai parameter num_2, R akan otomatis mengambil nilai default (yaitu 30):

>>> mean_two_numbers(num_1 = 10)
[1] 20

Memahami Nilai Keluaran (Return) dalam Fungsi R

Fungsi biasanya menerima beberapa data sebagai masukan dan memberikan hasil sebagai keluaran. Dalam beberapa bahasa pemrograman, untuk menyimpan hasil fungsi sebagai variabel, Anda perlu secara eksplisit menyertakan pernyataan return di akhir body fungsi. Jika tidak, fungsi hanya akan menampilkan nilai yang hanya ada dalam cakupan variabel.

Hal ini tidak berlaku di R, yang selalu mengembalikan nilai yang bisa disimpan dalam variabel. Namun, demi keterbacaan, selalu merupakan praktik baik untuk menyertakan pernyataan return saat mendefinisikan fungsi.

mean_two_numbers <- function(num_1, num_2) {
  # Function with return 
  mean <- (num_1 + num_2) / 2
  return (mean)
}
mean_two_numbers_2 <- function(num_1, num_2) {
  # Function without return
  mean <- (num_1 + num_2) / 2
  mean
}

> mean_two_numbers(10,50)
[1] 30
 > mean_two_numbers_2(10,50)
[1] 30

Terakhir, jika Anda ingin fungsi mengembalikan beberapa nilai, Anda harus menyimpan hasil yang berbeda dalam sebuah list dan menyertakannya dalam pernyataan return:

mean_sum <- function(num_1, num_2) {
  mean <- (num_1 + num_2) / 2
  sum <- num_1 + num_2
  return (list(mean, sum))
}

>>> mean_sum (10, 20)
[[1]]
[1] 15
[[2]]
[1] 30

Memanggil Fungsi di R

Pada bagian sebelumnya, kita sudah melihat berbagai contoh cara memanggil fungsi. Namun, penting untuk memperjelas bagaimana R bekerja di balik layar saat kita mengoper argumen.

R mengizinkan dua cara mengoper argumen: berdasarkan posisi dan berdasarkan nama. Jika mengikuti strategi pertama, kita harus menuliskan nilai sesuai urutan argumen yang didefinisikan dalam fungsi.

Jika kita mengoper argumen berdasarkan nama, kita perlu secara eksplisit menyebutkan nama argumen dan nilai yang terkait. Karena argumen dan nilai sudah dicocokkan, urutan tidak menjadi masalah.

Terakhir, juga dimungkinkan untuk mengombinasikan kedua strategi. Dalam hal ini, argumen bernama akan diekstrak dari daftar argumen dan dicocokkan terlebih dahulu, sementara sisanya dicocokkan berdasarkan posisi.

hello <- function(name, surname) {
  print(paste('Hello', name, surname))
}

# Memanggil argumen berdasarkan posisi
> hello('Greta','Thunberg')
[1] "Hello, Greta Thunberg"
# Memanggil argumen berdasarkan nama
> hello(surname='Thunberg', name='Greta')
[1] "Hello, Greta Thunberg"
# Memanggil argumen berdasarkan posisi dan nama
> hello(surname='Thunberg', 'Greta')
[1] "Hello, Greta Thunberg"

Mendokumentasikan Fungsi di R

Praktik yang baik saat membuat fungsi adalah menyediakan dokumentasi tentang cara menggunakannya, terutama ketika fungsi kompleks. Cara informal untuk melakukannya adalah dengan menambahkan komentar di dalam body fungsi. Anda dapat melihat dokumentasi tersebut dengan memanggil fungsi tanpa parameter:

hello <- function(name, surname) {
  # Say hello to a person with name and surname
  print(paste('Hello', name, surname))
}

>>> hello
function(name, surname) {
  # Say hello to a person with name and surname
  print(paste('Hello,', name, surname))

Namun, jika fungsi Anda adalah bagian dari paket yang lebih besar dan Anda ingin mendokumentasikannya, Anda harus menulis dokumentasi formal dalam dokumen .Rd terpisah. Anda melihat hasil dokumentasi ini saat membuka berkas bantuan untuk fungsi tertentu, misalnya ?mean.

Kesimpulan

Anda telah mencapai akhir tutorial. Selamat! Seperti pada banyak bahasa lainnya, fungsi adalah elemen penting di R. Baik fungsi bawaan, dikembangkan sebagai bagian dari paket eksternal, maupun dibuat oleh Anda sendiri, menguasai fungsi adalah tonggak penting dalam perjalanan pemrograman Anda. Jika Anda ingin terus mengembangkan keterampilan fungsi di R, lihat sumber daya berikut!

• Kursus Introduction to Writing Functions in R
• Kursus Intermediate R
• Tutorial Fungsi Keluarga R “Apply”
• R Programming Track