Matematika, Variabel, dan String
Pada bagian ini, kita akan membahas bagaimana melakukan operasi matematika di R, memberi nilai pada variabel, dan membuat string. Operasi matematika dasar dilakukan dengan menggunakan simbol:
Simbol dan Makna
+ -> penjumlahan
- -> pengurangan
* -> perkalian
/ -> pembagian
^ -> perpangkatan
%% -> modulo
Perhatikan contoh berikut ( jalankan kode dengan `ctrl+enter` atau `ctrl+shift+enter` ):
```{r contoh operasi matematika}
5 + 4
3 - 5
6 * 2
10 / 3
2 ^ 3
5 %% 2
```
Operator-operator matematika ini memiliki urutan prioritas. Prioritas operator adalah:
1 -> ^
2 -> %%
3 -> * atau /
4 -> + atau -
Jika ingin mengubah urutan pengerjaan operator, gunakan ().
Hasil dari perhitungan dapat disimpan untuk digunakan lagi. Untuk menyimpan nilai, gunakan variabel. Misalkan `x` adalah variabel yang berisi nilai 10.
```{r assign variabel}
x <- 10
```
`<-` adalah operator untuk assignment. Selain menggunakan `<-`, kita juga dapat menggunakan `=` untuk melakukan assignment. Kita dapat mengganti isi dari variabel dengan meng-assign nilai baru ke variabel tersebut. Misalkan saja, variabel `x` yang sudah diisi dengan 10 akan diganti nilainya.
```{r reassign variabel}
x <- 3 + 9
```
Setelah potongan kode di atas dijalankan, nilai variabel `x` jadi berubah. Jalankan potongan kode di bawah ini untuk melihat nilai `x` yang baru.
```{r melihat isi variabel}
x
```
Setelah memberi nilai pada sebuah variabel, variabel tersebut akan disimpan oleh R. Anda dapat melihat variabel-variabel yang sudah ada di kanan atas R Studio pada bagian _Environment_. Variabel-variabel tersebut tidak akan terhapus jika Anda tidak menghapusnya. Untuk menghapus variabel, Anda bisa menggunakan perintah `rm(<nama var yang ingin dihapus>)`. Jalankan potongan kode berikut untuk menghapus variabel `x`.
```{r remove variabel}
rm(x)
```
Pemberian nama variabel sebaiknya sesuai dengan makna variabel tersebut (hindari penamaan variabel dengan hanya 1 huruf!).
String adalah sekumpulan karakter (kata atau kalimat). Untuk meng-assign sebuah variabel dengan string, gunakan `"<kalimat>"` atau `'<kalimat>'`. Jalankan kode di bawah ini sebagai contoh:
```{r contoh string}
x <- "saya kamu"
x
```
# Vectors
Vektor adalah array 1 dimensi yang berisi sekumpulan objek. Vektor digunakan untuk menyimpan data. Tipe elemen dalam sebuah vektor pasti sama. Tipe-tipe elemen di R adalah numerik, string, logical, dll. Untuk mengisi vektor, gunakan `c(<elemen1>, <elemen2>, ...)` atau `c(<bil awal>:<bil akhir>)`. Perintah `c(<bil awal>:<bil akhir>)` digunakan untuk membuat vektor yang berisi sebarisan elemen dari `bil awal` hingga `bil akhir`. Perhatikan contoh berikut ini:
```{r assign vector}
vektor1 <- c(1,3,5,6)
vektor1
vektor2 <- c(1:5)
vektor2
vektor3 <- c("saya","kamu", 23)
vektor3
vektor4 <- c(5 : 1)
vektor4
```
Elemen-elemen pada `vektor3` bertipe string, walaupun terdapat bilangan di sana. Hal ini dikarenakan vektor hanya bisa memiliki 1 tipe, sehingga bilangan tersebut diubah menjadi string. Bagaimana jika ingin membuat barisan bilangan dengan perbedaan yang bukan 1? Perhatikan contoh di bawah ini:
```{r}
vektor5 <- seq(1,10,3)
vektor5
```
Perintah `seq(<bil awal>, <bil akhir>, <penambah>)` digunakan untuk membuat barisan bilangan dari `bil awal` bertambah sebanyak `penambah` dan lebih kecil atau sama dengan `bil akhir`
Buatlah perintah untuk mengisi `vektor6` dengan barisan bilangan `100 98 96 ... 8 6 4 2`, kemudian tampilkan isi dari `vektor6`
```{r coba}
vektor6 <- seq(100,2,-2)
vektor6
```
Vektor Logikal
Selain bertipe numerik dan string, vektor juga dapat menyimpan data dengan tipe logical. Data logical adalah `"TRUE"` atau `"FALSE"`. Data logical biasanya dihasilkan dari operasi perbandingan. Perhatikan contoh di bawah ini:
```{r contoh logical}
x <- (3 < 5)
x
y <- (vektor1 > 5)
y
```
Ada beberapa operator untuk perbandingan:
Operator | Makna
-------- | -----
< | kurang dari
> | besar dari
== | sama dengan
<= | kurang dari sama dengan
>= | besar dari sama dengan
!= | tidak sama dengan
Buatlah vektor2_log yang berisi hasil perbandingan vektor2 yang tidak sama dengan 2 dan vektor5_log yang menunjukan apakah elemen-elemen di vektor5 bilangan genap atau bukan. Tampilkan hasil vektor2_log dan vektor5_log.
```{r, error=TRUE}
vektor2_log <- (vektor2 != 2)
vektor2_log
vektor5_log <- (vektor5 %% 2 == 0)
vektor5_log
```
Untuk dapat memastikan kode Anda sudah benar atau belum:
vektor2_log : `TRUE FALSE TRUE TRUE TRUE`
vektor5_log : `FALSE TRUE FALSE TRUE`
Selain membandingkan vektor dengan sebuah bilangan, vektor juga dapat dibandingkan dengan vektor lainnya. Agar dapat membandingkan vektor dengan vektor lainnya, maka vektor-vektor yang dibandingkan harus memiliki panjang yang sama. Cobalah potongan kode berikut ini:
```{r, error=TRUE}
vektor2 < vektor4
vektor2 < vektor5
```
Jelaskan mengapa hasil pertama dari `vektor2 < vektor 4` adalah `TRUE` dan hasil terakhir dari `vektor2 < vektor 4` adalah `FALSE`?
Vektor itu array. hasil pertama dari vektor2 < vektor4 itu TRUE dengan kondisi 1 < 5. Hasil akhir tersebut adalah FALSE dengan kondisi 6 < 1. Bisa menghasilkan jawaban berbeda karena pembanding kondisinya itu harus di tempat elemen yang sama
Mengapa `vektor2 < vektor5` menghasilkan error ?
Panjang vektornya beda, maka kalau beda bisa error
Bagaimana jika terdapat 2 perbandingan atau lebih? Ada operator-operator yang dapat digunakan pada tipe data logikal:
Simbol | Makna
----- | -----
`x | y` | x atau y
`x & y` | x dan y
`!x` | negasi x
Perhatikan contoh berikut ini:
```{r}
x <- c(TRUE, TRUE, FALSE, FALSE)
y <- c(TRUE, FALSE, TRUE, FALSE)
x | y
x & y
!x
```
Mengakses Elemen Vektor
Untuk mengakses elemen dari vektor, terdapat beberapa cara:
1. `<nama_vektor>[<nomor indeks>]`, contoh:
```{r contoh mengakses elemen vektor}
vektor1
vektor1[2]
vektor1[c(1,3)]
```
Perhatikan nama indeksnya dapat berupa vektor lagi.
Tuliskan perintah untuk dapat menampilkan isi vektor5 di indeks 2,3, dan 4
```{r}
vektor5[c(2,3,4)]
```
2. Dengan menggunakan operator logikal untuk menandakan elemen mana saja yang harus ditampilkan. Sintaks: `<nama vektor>[<vektor logical>]`.
```{r}
vektor1
vektor1[c(TRUE,FALSE,TRUE,FALSE)]
```
Perhatikan contoh di atas, hanya isi dari vektor dengan indeks `TRUE` yang ditampilkan. Penggunaan logikal sangat berguna untuk menampilkan isi vektor yang memenuhi syarat tertentu. Misalkan kita ingin menampilkan semua isi vektor1 yang lebih besar dari 4. Pertama buatlah sebuah vektor logikal dari `vektor1>4`, kemudian gunakan vektor logikal tersebut sebagai penunjuk indeks dari vektor1 yang ingin ditampilkan.
```{r}
indeks_logical <- vektor1 > 4
vektor1[indeks_logical]
```
atau kita bisa langsung menuliskan seperti ini:
```{r}
vektor1[vektor1>4]
```
Tampilkan semua isi vektor5 yang merupakan bilangan genap.
```{r}
vektor5[vektor5 %% 2 == 0]
```
Tampilkan semua isi vektor5 yang merupakan bilangan genap atau lebih kecil dari 5.
```{r}
vektor5[(vektor5 %% 2 == 0)|vektor5<5]
```
Operasi Pada Vektor
Operator matematika standard seperti +, *, /, - dapat digunakan pada vektor.
- Jika `vektor1+vektor2` maka akan menghasilkan vektor baru yang merupakan penjumlahan vektor1 dan vektor2 per elemen.
- Jika sebuah vektor dijumlahkan dengan skalar, maka akan menghasil vektor baru yang merupakan vektor lama dengan setiap elemen di dalam vektor lama akan dijumlahkan dengan skalar tersebut.
Hal ini berlaku untuk pengurangan, pembagian, dan juga perkalian.
Jumlahkan `vektor2` dan `vektor 4`, simpan dalam variabel `vektor_jumlah`. Kalikan `vektor1` dengan 3 dan simpan dalam variabel `vektor_kali`
```{r}
vektor_jumlah <- vektor2+vektor4
vektor_jumlah
vektor_kali <- vektor1*3
vektor_kali
```
Selain operasi matematika standard, terdapat fungsi untuk melakukan beberapa operasi vektor lainnya:
Fungsi | Makna
------- |------
`length(<nama vektor>) | mengembalikan panjang vektor
`sort(<nama vektor>) | mengembalikan vektor yang sudah terurut
`names(<nama vektor>) <- <vektor nama>` | memberi nama untuk masing-masing elemen vektor
`names(<nama vektor>)` | mengembalikan nama dari masing-masing elemen vektor
`max(<nama vektor>)` | mengembalikan nilai maksimum dari vektor
`min(<nama vektor>)` | mengembalikan nilai minimum dari vektor
`sum(<nama vektor>)` | mengembalikan jumlah elemen dari vektor
`mean(<nama vektor>)`| mengembalikan rata-rata dari elemen vektor
Tampilkanlah panjang vektor1, vektor1 yang elemennya sudah terurut, nilai maksimum yang ada di vektor1, nilai minimum yang ada di vektor1, penjumlahan semua elemen vektor1, dan rata-rata elemen vektor1
```{r}
length(vektor1)
sort(vektor1)
max(vektor1)
min(vektor1)
sum(vektor1)
mean(vektor1)
```
Factors
Factors biasanya digunakan untuk variabel kategorikal. Sintaks untuk membuat factor adalah `factor(<vektor>) Sebagai contoh, misal variabel `hari` berisi hari dari senin sampai minggu.
```{r contoh factor}
hari_vektor <- c("senin", "selasa", "rabu", "kamis", "jumat", "sabtu", "minggu")
hari_vektor
hari_factor <- factor(hari_vektor)
hari_factor
```
Sekilas mungkin tidak terlihat adanya perbedaan antara vektor dan factor. Tetapi ketika melihat ringkasan kedua struktur data ini dengan menggunakan perintah `summary(<nama variabel>)` akan terlihat hasil yang berbeda.
```{r summary vector dan factor}
summary(hari_vektor)
summary(hari_factor)
```
Perintah summary pada vektor hanya menampilkan informasi berupa tipe data pada vektor dan berapa panjang vektor tersebut. Perintah summary pada factor menampilkan frekuensi dari masing-masing kategori.
Pada variabel kategorikal yang ordinal, terdapat urutan pada kategorinya. Untuk memberikan urutan, maka tambahkan `ordered = TRUE` dan urutan dari kategori yang ada dengan `levels = c(<kategori1>, <kategori2>, ...))`. Sebagai contoh, misalkan kita ingin hari_factor memiliki urutan:
```{r contoh order factor}
hari_factor_order <- factor(hari_vektor, ordered = TRUE, levels = c("senin", "selasa", "rabu", "kamis", "jumat", "sabtu", "minggu"))
hari_factor_order
```
Array dan Matriks
Array adalah struktur data yang menyimpan data dengan tipe yang sama. Perbedaan array dengan vektor adalah array dapat memiliki lebih dari 1 dimensi. Begitu pula dengan matriks. Matriks adalah struktur data yang menyimpan data dengan tipe yang sama. Perbedaan array dengan matriks adalah matriks sudah pasti dua dimensi. Tentu kedua struktur data ini memiliki peran penting (matriks banyak digunakan jika menggunakan fungsi-fungsi pada library machine learning).
List
List adalah kumpulan objek. List sangat mirip dengan vektor. Perbedaannya adalah list dapat menyimpan data dengan tipe yang berbeda. Kita tidak akan membahas detil di modul ini. Anda dapat mempelajari lebih dalam tentang list melalui video atau source lainnya.
Data Frame
Misalkan vektor `nama_coklat` adalah kumpulan nama-nama coklat.
```{r}
nama_coklat <- c("Kitkit", "Toblerong", "Gold King", "Chatburi")
```
Vektor `rating_coklat` adalah rating dari masing-masing coklat.
```{r}
rating_coklat <- c(8.5, 10, 6, 7)
```
Kita ingin nama_coklat dan rating_coklat berada dalam sebuah struktur data yang sama dengan setiap nama coklat terhubungn dengan rating yang sesuai untuk coklat tersebut. Untuk membuat struktur data tersebut, dapat digunakan data frame. Untuk mudahnya, data frame dapat dibayangkan sebagai tabel di mana kolom-kolomnya adalah sebuah vektor atau faktor. Untuk membuat data frame dapat digunakan sintaks:
`data.frame(<nama_vek1>, <nama_vek2>, ..., <nama_vek_n>)`
Sebagai contoh:
```{r contoh data frame}
data_coklat <- data.frame(nama_coklat, rating_coklat)
data_coklat
```
Untuk mengakses elemen dalam data frame, dapat menggunakan perintah `<nama_dataframe>[<indeks_baris>,<indeks_kolom>]`. Indeks baris atau indeks kolom dapat tidak diisi seperti pada contoh berikut ini:
```{r contoh mengakses elemen pada data frame}
data_coklat[1,2]
data_coklat[1,]
data_coklat[,2]
data_coklat[1]
data_coklat['nama_coklat']
data_coklat['rating_coklat']
data_coklat[]
```
Apa yang terjadi jika indeks baris tidak dituliskan? Jika indeks kolom tidak dituliskan? Jika hanya berisi 1 angka di dalam `[]`?
Keluarannya adalah data coklat di salah satu kolom atau semua data jika kolom juga tidak diisi. Jika kolom tidak dituliskan, maka isinya berupa data per baris atau tidak ada jika baris tidak ditulis. Kalau hanya berisi 1 angka maka keluarannya itu adalah kolom di angka tersebut
Untuk mengakses sebuah kolom pada data frame, Anda juga bisa menggunakan perintah `<nama_dataframe>$<nama_vektor>`. Sebagai contoh:
```{r contoh mengakses sebuah kolom pada data frame}
data_coklat$nama_coklat
```
Tampilkan nama-nama coklat yang memiliki rating lebih dari 8.
```{r}
data_coklat$nama_coklat[rating_coklat>8.0]
```
Jawabannya adalah: `Kitkit Toblerong`.
Beberapa fungsi yang berhubungan dengan data frame:
Nama fungsi | Makna
------------ |-------
`str(<nama_dataframe>)` | Untuk mendapatkan informasi tentang struktur data frame
`head(<nama_dataframe>)` | Untuk melihat 6 elemen pertama data frame
`tail(<nama_dataframe>)` | Untuk melihat 6 elemen terakhir data frame
`rbind(<nama_dataframe>, <baris_baru>)` | Untuk menambahkan baris baru
Berikut ini adalah perintah-perintah yang berhubungan dengan data frame:
- Untuk menambahkan kolom, dapat menggunakan perintah `<nama_dataframe>['<nama_vektor>']`.
- Untuk menghilangkan baris, dapat menggunakan perintah `<nama_dataframe>[-<indeks yang mau dihapus>,]`
- Untuk menghilangkan sebuah kolom, dapat menggunakan perintah `<nama_dataframe>[<nama kolom>] <- NULL` atau `<nama_dataframe>[-<indeks kolom>]`
Tambahkan sebuah baris dengan nama coklat bang-bang dan rating coklat 7.5 ke data frame `data_coklat`
```{r}
data_coklat2 <- data.frame("bang-bang",7.5)
names(data_coklat2) <- c("nama_coklat","rating_coklat")
rbind(data_coklat,data_coklat2)
```
Hapuslah baris kedua dari data frame `data_coklat`
```{r}
data_coklat[-2,]
```
Hitunglah rata-rata rating dari data yang ada di `data_coklat` sekarang dan simpan dalam variabel `rata2rating_coklat`
```{r}
res <- mean(data_coklat[,2])
res
```
Tampilkan nama-nama coklat yang ratingnya lebih tinggi daripada rata-rata rating coklat yang dihitung di bagian sebelumnya
```{r }
data_coklat$nama_coklat[rating_coklat>res]
```
Membaca File CSV dan file Excel
Untuk membaca file csv, gunakan perintah:
`<nama_df> <- read.csv("</file_path/nama-file.csv>")`
Download data ramen, "baca" file tersebut, dan simpan dalam data frame dengan nama `ramen_ratings`
```{r}
ramen_ratings <- read.csv("C:/Users/ASUS/Desktop/ramen-ratings.csv")
```
Untuk membaca file excel, Anda harus terlebih dulu menambahkan library `readxl`. Untuk menambahkan library ini, pertama harus menambahkan package readxl dengan menggunakan perintah `install.package("readxl")`. Setelah meng-install package `readxl`, panggil library tersebut dengan fungsi `library(readxl)`. Jika package sudah diinstal, untuk berikutnya Anda tidak perlu meng-install package tersebut lagi dan bisa langsung memanggil library tersebut. Perintah untuk membaca file excel adalah:
`<nama_df> <- read_excel("</file_path/nama-file.xlsx>")`
Posting Komentar