# R'ın Temelleri {#basics}
```{r out.width = "100%", fig.align = "center", echo=F}
knitr::include_graphics(here::here("images", "basics_header_close.png"))
```
Hoş geldiniz!
Bu sayfa, R'ın temellerini gözden geçirmektedir. Kapsamlı bir eğitim olması amaçlanmamıştır. Ancak temel bilgileri sağlar ve hatırlamanız için faydalı olabilir. İleri ve daha kapsamlı eğitimler için ilgili [Öğrenme kaynağı](#learning) bölüme geçiş yapılabilir.
Bu sayfanın bazı bölümleri [R4Epis projesinden](https://r4epis.netlify.app/) izin alınarak uyarlanmıştır.
STATA, SAS veya Excel'den R'a geçişle ilgili ipuçları için [R'a Geçiş](transition_to_R.tr.qmd) hakkındaki sayfaya bakabilirsiniz.
```{r, echo=F}
# temizlenmiş ebola satır listesini içe aktar
linelist <- rio::import(here::here("data", "case_linelists", "linelist_cleaned.rds"))
pacman::p_load(apyramid)
```
## Neden R Kullanıyoruz?
[R proje web sitesinde](https://www.r-project.org/about.html) belirtildiği gibi, R, istatistiksel hesaplama ve grafikler için bir programlama dili ve ortamıdır. Çok yönlü, genişletilebilir ve topluluk odaklıdır.
**Maliyet**
R'ın kullanımı ücretsizdir! Açık kaynak ve ücretsiz olması yönünde topluluğun ciddi bir etik duruşu vardır.
**Yeniden üretilebilirlik**
Veri yönetiminizi ve analizinizi bir programlama dili aracılığıyla yürütmek (Excel'e veya başka bir öncelikli tıklama/manuel araçla karşılaştırıldığında), **tekrarlanabilirliği** artırır, **hata algılamayı** kolaylaştırır ve iş yükünüzü hafifletir.
**Topluluk**
R kullanıcı topluluğu kalabalık ve işbirlikçidir. Gerçek hayattaki sorunları ele almak için yeni paketler ve araçlar günlük olarak geliştirilir ve kullanıcı topluluğu tarafından incelenir. Örnek olarak, [R-Ladies](https://rladies.org/), amacı R topluluğunda cinsiyet çeşitliliğini teşvik etmek olan dünya çapında bir kuruluştur ve R kullanıcılarının en büyük kuruluşlarından biridir. Muhtemelen kullanmak üzere olduğunuz bir bölümleri vardır!
## Anahtar Kelimeler
**RStudio** - RStudio, **R**'ın daha kolay kullanımı için bir Grafik Kullanıcı Arayüzüdür (GUI). Daha fazlasını [RStudio bölümünde](#rstudio) okuyabilirsiniz.
**Objects** - R'da sakladığınız her şey - veri kümeleri, değişkenler, köy adlarının bir listesi, toplam nüfus sayısı, hatta grafikler gibi çıktılar - *bir isim atanan* nesnelerdir ve *sonraki komutlarda* başvurulabilir. Daha fazlasını [Nesneler bölümünde](#objects) okuyabilirsiniz.
**Functions** - Fonksiyon, girdileri kabul eden ve çıktıya dönüştüren bir kod işlemidir. Daha fazlasını [Fonksiyonlar bölümünde](#Fonksiyonlar) okuyabilirsiniz.
**Packages** - R paketi, aslında paylaşılabilir fonksiyonlar paketidir. Daha fazlasını [Paketler bölümünde](#packages) okuyabilirsiniz.
**Scripts** - Komut dosyası, komutlarınızı tutan belge dosyasıdır. Daha fazlasını [Komut Dosyaları bölümünde](#scripts) okuyabilirsiniz.
## Öğrenme Kaynakları {#learning}
### RStudio İçindeki Kaynaklar {.unnumbered}
**Yardım dosyaları**
R paketleri ve belirli fonksiyonlarla ilgili belgeler için RStudio "Yardım" sekmesini arayın. Bu, Dosyaları, Grafikleri ve Paketleri de içeren bölmenin içindedir (genellikle sağ alt bölmededir). Kısayol olarak, ilgili Yardım sayfasını açmak için bir soru işaretinden sonra R konsoluna bir paketin veya fonksiyonun adını da yazabilirsiniz. Kesme işareti eklemeyin.
Örneğin: `?filter` veya `?diagrammeR`.
**Etkileşimli öğreticiler**
RStudio *içinde* etkileşimli olarak R öğrenmenin birkaç yolu vardır.
RStudio'nun kendisi, [**learnr**](https://blog.rstudio.com/2020/02/25/rstudio-1-3-integrated-tutorials/) R paketi tarafından desteklenen bir eğitim bölmesi sunar. Basitçe bu paketi kurabilir ve sağ üst RStudio bölmesindeki (Ortam ve Geçmiş sekmelerini de içeren) yeni "Tutorial" sekmesi aracılığıyla bir öğretici açabilirsiniz.
R paketi [**swirl**](https://swirlstats.com/), R Konsolunda etkileşimli kurslar sunar. Bu paketi kurun ve yükleyin, ardından R konsolunda `swirl()` (boş parantezler) komutunu çalıştırın. Konsolda istemlerin göründüğünü göreceksiniz. Konsola yazarak yanıt verin. Seçtiğiniz bir kurs boyunca size rehberlik edecektir.
### Kopya Kağıtları {.unnumbered}
[RStudio web sitesinde](https://rstudio.com/resources/cheatsheets/) birçok PDF "kullanımı kolaylaştırıcı belge/ kopya kağıtları" bulunmaktadır, örneğin:
- **forcats** paketini içeren faktörler\
- **lubridate** paketi ile tarihler ve saatler\
- **stringr** paketi içeren dizeler\
- **purrr** paketi ile tekrarlanan işlemler\
- içeri_veri_aktar\
- **dplyr** paketi ile veri dönüştürme hile sayfası\
- R Markdown (PDF, Word, Powerpoint... gibi belgeler oluşturmak için)\
- Shiny (etkileşimli web uygulamaları oluşturmak için)\
- **ggplot2** paketi ile veri görselleştirme\
- Haritacılık (GIS)\
- **broşür** paketi (etkileşimli haritalar)\
- R ile Python (**reticulate** paketi)
Bu, özellikle [Excel kullanıcıları](https://jules32.github.io/r-for-excel-users/) için çevrimiçi bir R kaynağıdır.
### Twitter {.unnumbered}
- Bizi Takip Edin! [\@epiRhandbook](https://twitter.com/epirhandbook)\
- R Function A Day [\@rfuntionaday](https://twitter.com/rfunctionaday) *muazzam* bir kaynak\
- R for Data Science [\@rstats4ds](https://twitter.com/rstats4ds?lang=en)\
- RStudio [\@RStudio](https://twitter.com/rstudio?lang=en)\
- RStudio Tips [\@rstudiotips](https://twitter.com/rstudiotips)\
- R-Bloggers [\@Rbloggers](https://twitter.com/Rbloggers)\
- R-ladies [\@RLadiesGlobal](https://twitter.com/RLadiesGlobal)\
- Hadley Wickham [\@hadleywickham](https://twitter.com/hadleywickham?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor)
Aynı zamanda:
**\#epitwitter** ve **\#rstats**
### Ücretsiz Çevrimiçi Kaynaklar {.unnumbered}
Tanımlayıcı bir metin, Garrett Grolemund ve Hadley Wickham'ın [Veri Bilimi için R](https://r4ds.had.co.nz/) kitabı.
[R4Epis](https://r4epis.netlify.app/)
Proje web sitesi "bir MSF acil müdahale ortamında yürütülecek yaygın salgın türlerini ve nüfusa dayalı anketleri kapsayacak şekilde standartlaştırılmış veri temizleme, analiz ve raporlama araçları geliştirmeyi" amaçlamaktadır. R temel eğitim materyallerini, salgınlar ve anketlerle ilgili RMarkdown raporları için şablonları ve bunları ayarlamanıza yardımcı olacak öğreticileri bulabilirsiniz.
### İngilizce dışındaki dillerde {.unnumbered}
[Materiales de RStudio en Español](https://www.rstudio.com/collections/espanol/)
[Introduction à R et au tidyverse (Francais)](https://juba.github.io/tidyverse/index.html)
## Kurulum
### R ve RStudio {.unnumbered}
**R Nasıl Kurulur?**
Bu web sitesini ziyaret edin ve bilgisayarınıza uygun en son R sürümünü indirin.
**RStudio nasıl kurulur?**
Bu web sitesini ziyaret edin ve bilgisayarınıza uygun RStudio'nun en son ücretsiz masaüstü sürümünü indirin.
**İzinler**\
R ve RStudio'yu okuma ve yazma izinlerine sahip olduğunuz bir sürücüye kurmanız gerektiğini unutmayın. Aksi takdirde, R paketlerini kurma yeteneğiniz (sık rastlanan bir durum) etkilenecektir. Sorunlarla karşılaşırsanız, simgeye sağ tıklayıp "Yönetici olarak çalıştır"ı seçerek RStudio'yu açmayı deneyin. Diğer ipuçları [Ağ sürücülerinde R](network_drives.tr.qmd) sayfasında bulunabilir.
**R ve RStudio nasıl güncellenir?**
R sürümünüz, başlangıçta R Konsoluna yazdırılır. Ayrıca `sessionInfo()` komutunu da çalıştırabilirsiniz.
R'ı güncellemek için yukarıda belirtilen web sitesine gidin ve R'ı yeniden yükleyin. Alternatif olarak, **installr** paketini (Windows'ta) `installr::updateR()` çalıştırarak kullanabilirsiniz. Bu, en son R sürümünü indirmenize ve paketlerinizi yeni R sürümüne güncellemenize yardımcı olacak iletişim kutularını açacaktır. Daha fazla ayrıntıyı **installr** [belgelerde](https://www.r-project.org/nosvn/pandoc/installr.html) bulabilirsiniz.
Eski R sürümünün bilgisayarınızda hala var olacağını unutmayın. RStudio'da "Araçlar" -\> "Global Seçenekler"e tıklayarak ve bir R sürümü seçerek R'ın daha eski bir sürümünü (eski "kurulum") geçici olarak çalıştırabilirsiniz. Bu, R'ın en yeni sürümü üzerinde çalışacak şekilde güncellenmemiş bir paket kullanmak istiyorsanız yararlı olabilir.
RStudio'yu güncellemek için yukarıdaki web sitesine gidebilir ve RStudio'yu yeniden indirebilirsiniz. Başka bir seçenek de RStudio içinde "Yardım" -\> "Güncellemeleri Kontrol Et" seçeneğine tıklamaktır. Ancak bu en son güncellemeleri göstermeyebilir.
Bu El Kitabı hazırlanırken hangi R, RStudio veya paket sürümlerinin kullanıldığını görmek için [Editoryal ve teknik notlar](editorial_style.tr.qmd) sayfasına bakın.
### Kurulumuna ihtiyaç duyabileceğiniz diğer yazılımlar{.unnumbered}
- TinyTeX (*bir RMarkdown belgesini PDF'ye derlemek için*)\
- Pandoc (*RMarkdown belgelerini derlemek için*)\
- RTools (*R için paketler oluşturmak için*)\
- phantomjs (*iletim zincirleri gibi hareketli ağların hareketsiz görüntülerini kaydetmek için*)
#### TinyTex {.unnumbered}
TinyTex, özel bir LaTeX dağıtımıdır ve R'dan PDF'ler üretmeye çalışırken kullanışlıdır.\
Daha fazla bilgi için adresine bakın.
TinyTex'i R'dan yüklemek için:
```{r, eval=F}
install.packages('tinytex')
tinytex::install_tinytex()
# TinyTeX'i kaldırmak için, run tinytex::uninstall_tinytex()
```
#### Pandoc {.unnumbered}
Pandoc, R'dan ayrı bir yazılım olan belge dönüştürücüdür. **RStudio ile birlikte gelir ve indirilmesi gerekmez.** Rmarkdown belgelerini .pdf gibi biçimlere dönüştürme ve karmaşık fonksiyonlar ekleme sürecine yardımcı olur.
#### RTools {.unnumbered}
RTools, R için paketler oluşturmaya yönelik bir yazılım koleksiyonudur.
Bu internet sayfasından yükleyebilirsiniz:
#### phantomjs {.unnumbered}
Bu genellikle web sayfalarının "ekran görüntülerini" almak için kullanılır. Örneğin **epicontacts** paketi ile bir iletim zinciri yaptığınızda interaktif ve dinamik bir HTML dosyası üretilir. Statik bir görüntü istiyorsanız, bu işlemi otomatikleştirmek için [**webshot**](https://wch.github.io/webshot/articles/intro.html) paketini kullanmak faydalı olabilir. Bu, harici "phantomjs" programını gerektirecektir. phantomjs'yi **webshot** paketi aracılığıyla `webshot::install_phantomjs()` komutuyla kurabilirsiniz.
## RStudio {#rstudio}
### RStudio Yönlendirmesi {.unnumbered}
**Öncelikle RStudio'yu açın.** Simgeleri çok benzer görünebileceğinden, R'ı değil *RStudio*'yu açtığınızdan emin olun.
RStudio'nun çalışması için bilgisayarda R'ın da kurulu olması gerekir (kurulum talimatları için yukarıya bakın).
**RStudio**, **R**'ın daha kolay kullanımı için bir arayüzdür (GUI). R'ı kritik işi yapan aracın motoru ve RStudio'yu, ilerlemek için motoru gerçekten kullanmanıza yardımcı olan aracın gövdesi (koltuklar, aksesuarlar vb. ile) olarak düşünebilirsiniz! Tam RStudio kullanıcı arayüzünü kolaylaştırıcısını (PDF) [buradan](https://www.rstudio.com/wp-content/uploads/2016/01/rstudio-IDE-cheatsheet.pdf) görebilirsiniz.
Varsayılan olarak RStudio dört dikdörtgen bölme görüntüler.
```{r out.width = "100%", fig.align = "center", echo=F}
knitr::include_graphics(here::here("images", "RStudio_overview.png"))
```
[***İPUCU:*** RStudio'nuz yalnızca bir sol bölme gösteriyorsa, bunun nedeni henüz açık komut dosyanız olmamasıdır.]{style="color: darkgreen;"}
**Kaynak Bölmesi**\
Varsayılan olarak sol üstteki bu bölme, [komut dosyalarınızı](#scripts) düzenlemek, çalıştırmak ve kaydetmek için kullanılan bir alandır. Komut dosyaları, çalıştırmak istediğiniz komutları içerir. Bu bölme, görüntüleme için veri kümelerini/çerçevelerini (datasets/data frames) de görüntüleyebilir.
Stata kullanıcıları için bu bölme, Do-file ve Data Editor pencerelerinize benzer.
**R Konsol Bölmesi**
Varsayılan olarak R Studio'daki sol veya sol alt bölme olan R Konsolu, R "motorunun" evidir. Burası komutların fiilen çalıştırıldığı ve grafik olmayan çıktıların ve hata/uyarı mesajlarının göründüğü yerdir. Komutları doğrudan R Konsoluna girebilir ve çalıştırabilirsiniz. Ancak bu komutların bir komut dosyasından komut çalıştırırken olduğu gibi kaydedilmediğine dikkat ediniz.
Stata'ya aşina iseniz, R Konsolu komut penceresi "Sonuçlar" penceresi gibidir.
**Ortam Bölmesi**\
Varsayılan olarak sağ üstte bulunan bu bölme, çoğunlukla mevcut oturumda R Ortamındaki [nesnelerin](#nesneler) kısa özetlerini görmek için kullanılır. Bu nesneler, içe aktarılan, değiştirilen veya oluşturulan veri kümelerini, tanımladığınız parametreleri (örneğin, analiz için belirli bir epi haftası) veya analiz sırasında tanımladığınız vektörleri veya listeleri (örneğin, bölgelerin adları) içerebilir. Değişkenlerini görmek için bir veri kümesi adının yanındaki oka tıklayabilirsiniz.
Stata'da, bu en çok Değişkenler Yöneticisi penceresine benzer.
Bu bölme ayrıca daha önceki komutları görebileceğiniz *Geçmiş*i içerir. Ayrıca, **learnr** paketini yüklediyseniz etkileşimli R eğitimlerini tamamlayabileceğiniz bir "Öğretici" sekmesine de sahiptir. Ayrıca harici bağlantılar için bir "Bağlantılar" bölmesine sahiptir ve Github ile arabirim kurmayı seçerseniz bir "Git" bölmesine sahip olabilir.
**Grafikler, Görüntüleyici, Paketler ve Yardım Bölmesi**\
Sağ alt bölmede birkaç önemli sekme bulunur. Haritalar dahil tipik çizim grafikleri, Çizim bölmesinde görüntülenecektir. Etkileşimli veya HTML çıktıları, Görüntüleyici bölmesinde görüntülenecektir. Yardım bölmesi, belgeleri ve yardım dosyalarını görüntüleyebilir. Dosyalar bölmesi, dosyaları açmak veya silmek için kullanılabilen bir tarayıcıdır. Paketler bölmesi, R paketlerini görmenize, yüklemenize, güncellemenize, silmenize ve paketin hangi sürümüne sahip olduğunuzu görmenize olanak tanır. Paketler hakkında daha fazla bilgi edinmek için aşağıdaki [paketler bölümüne](#packages) bakın.
Bu bölme, Plots Manager ve Project Manager pencerelerinin Stata eşdeğerlerini içerir.
### RStudio ayarları {.numbered}
*Tools* açılır menüsünde *Global Options*'ı seçerek RStudio ayarlarını ve görünümünü değiştirin. Orada görünüm/arka plan rengi dahil varsayılan ayarları değiştirebilirsiniz.
```{r out.width = c('50%'), fig.show='hold', echo=F}
knitr::include_graphics(here::here("images", "RStudio_tools_options_1.png"))
knitr::include_graphics(here::here("images", "RStudio_tools_options.png"))
```
**Tekrar başlat**
R'ınız donarsa, Oturum menüsüne gidip "R'ı Yeniden Başlat" ı tıklayarak R'ı yeniden başlatabilirsiniz. Bu, RStudio'yu kapatıp açma zahmetini ortadan kaldırır. Bunu yaptığınızda R ortamınızdaki her şey kaldırılacaktır.
### Klavye kısayolları {.unnumbered}
Bazı çok kullanışlı klavye kısayolları aşağıdadır. Bu RStudio'nun ikinci sayfasında Windows, Mac ve Linux için tüm klavye kısayollarına ulaşabilirsiniz [kullanıcı arayüzü kolaylaştırıcısı](https://www.rstudio.com/wp-content/uploads/2016/01/rstudio-IDE-cheatsheet .pdf).
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Windows/Linux | Mac | Eylemi |
+==================================+========================+================================================================================================================================+
| Esc | Esc | Geçerli komutu kesintiye uğratın (yanlışlıkla eksik bir komut çalıştırdıysanız ve R konsolunda "+" görmekten kurtulamıyorsanız kullanışlıdır) |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl+s | Cmd+s | Kaydet (komut dosyası) |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Tab | Tab | Otomatik tamamlama |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Enter | Cmd + Enter | Geçerli satırları/kod seçimini çalıştır |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Shift + C | Cmd + Shift + c | Vurgulanan satırları yorumla/yorumu kaldır |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Alt + - | Option + - | Eklemek `<-` |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Shift + m | Cmd + Shift + m | Eklemek `%>%` |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + l | Cmd + l | R konsolunu temizle |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Alt + b | Cmd + Option + b | Baştan geçerli satıra çalıştır |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Alt + t | Cmd + Option + t | Geçerli kod bölümünü çalıştırın (R Markdown) |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Alt + i | Cmd + Shift + r | Kod öbeği ekle (R Markdown'a) |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Alt + c | Cmd + Option + c | Geçerli kod parçasını çalıştır (R Markdown) |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Yukarı/aşağı ok tuşları | Aynı | Son çalıştırılan komutlar arasında geçiş yap |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Shift + Yukarı/aşağı ok tuşları | Aynı | Birden çok kod satırı seçin |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + f | Cmd + f | Geçerli komut dosyasında bul ve değiştir |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Ctrl + Shift + f | Cmd + Shift + f | Dosyalarda bulun (birçok komut dosyasında arama yapın/değiştirin) |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Alt + l | Cmd + Option + l | Seçilen kodu katla |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
| Shift + Alt + l | Cmd + Shift + Option+l | Seçili kodu aç |
+----------------------------------+------------------------+--------------------------------------------------------------------------------------------------------------------------------+
[***İPUCU:*** Yazarken RStudio'nun otomatik tamamlama fonksiyonunu etkinleştirmek için Sekme tuşunuzu kullanın. Bu, yazım hatalarını önleyebilir. Şu ana kadar yazdıklarınıza bağlı olarak olası fonksiyonlar ve nesnelerin bir açılır menüsünü oluşturmak için yazarken Sekme tuşuna basın.]{style="color: darkgreen;"}
## Fonksiyonlar" {#functions}
Fonksiyonlar, R'ı kullanmanın merkezinde yer alır. Fonksiyonlar, görevleri ve işlemleri nasıl gerçekleştirdiğinizdir. Pek çok fonksiyon R ile kurulu olarak gelir, daha pek çoğu *paketlerde* indirilebilir ([paketler](#paketler) bölümünde açıklanmıştır) ve hatta kendi özel Fonksiyonlarınızı bile yazabilirsiniz!
Fonksiyonlarla ilgili bu temel bilgiler bölümü şunları açıklar:
- Fonksiyon nedir ve nasıl çalışır\
- Fonksiyonun *Değişkenleri*(arguments) nelerdir\
- Bir fonksiyonu anlamak için nasıl yardım alınır
*Sözdizimi (syntax) hakkında kısa bir not:* Bu el kitabında, fonksiyonlar açık ve kapalı parantezler içinde kod-metin içinde şöyle yazılmıştır: `filter()`. [Paketler](#packages) bölümünde açıklandığı gibi, Fonksiyonlar *paketler* içinde indirilir. Bu el kitabında, paket adları **dplyr** gibi **kalın** ile yazılmıştır. Bazen örnek kodda, fonksiyon adının, bunun gibi iki adet iki nokta üst üste (`::`) ile açıkça paketinin adıyla bağlantılı olduğunu görebilirsiniz: `dplyr::filter()`. Bu bağlantının amacı paketler bölümünde açıklanmıştır.
### Basit Fonksiyonlar {.unnumbered}
**Bir fonksiyon, girdileri alan, bu girdilerle bazı işlemler yapan ve bir çıktı üreten makine gibidir.** Çıktının ne olduğu fonksiyona bağlıdır.
**Fonksiyonlar genellikle fonksiyonun parantezleri içine yerleştirilmiş bazı nesneler üzerinde çalışır**. Örneğin, `sqrt()` fonksiyonu bir sayının karekökünü hesaplar:
```{r basics_function_sqrt}
sqrt(49)
```
Bir fonksiyona sağlanan nesne ayrıca veri kümesindeki bir sütun olabilir (tüm nesne türleri hakkında ayrıntılı bilgi için [Nesneler](#nesneler) bölümüne bakın). R, birden çok veri kümesini depolayabildiğinden, hem veri kümesini hem de sütunu belirtmeniz gerekecektir. Bunu yapmanın bir yolu, veri kümesinin adını ve sütunun adını ("veri kümesi$sütun") bağlamak için "$" gösterimini kullanmaktır. Aşağıdaki örnekte, "summary()" fonksiyonu, "linelist" veri kümesindeki "age" sayısal sütununa uygulanır ve çıktı, sütunun sayısal ve eksik değerlerinin bir özetidir.
```{r basics_functions_summary}
# 'linelist' veri kümesindeki 'age' sütununun özet istatistiklerini yazdır
summary(linelist$age)
```
[***NOT:*** Perde arkasında, bir fonksiyon, kullanıcı için tek bir kolay komuta sarılmış karmaşık ek kodu temsil eder.]{style="color: black;"}
### Birden çok bağımsız değişkene sahip fonksiyonlar {.unnumbered}
Fonksiyonlar genellikle,parantezleri içinde yer alan ve virgülle ayrılmış olan ***değişkenler*** adı verilen birkaç girdi ister.
- Fonksiyonun doğru çalışması için bazı değişkenler gereklidir, bazıları isteğe bağlıdır\
- İsteğe bağlı bağımsız değişkenlerin varsayılan ayarları vardır\
- Değişkenler karakter, sayısal, mantıksal (DOĞRU/YANLIŞ) ve diğer girdi değerlerini alabilir
Tipik bir fonksiyona örnek olarak, 'oven_bake()' adlı eğlenceli bir kurgusal fonksiyonu burada bulabilirsiniz. Bir girdi nesnesi (örneğin, bir veri kümesi veya bu örnekte "hamur") alır ve üzerinde ek bağımsız değişkenler ('dakikalar =' ve 'sıcaklık =') tarafından belirtildiği gibi işlemler gerçekleştirir. Çıktı konsola yazdırılabilir veya "<-" atama operatörü kullanılarak bir nesne olarak kaydedilebilir.
```{r basics_functions_image, echo=F, out.width = "75%", fig.align = "center"}
knitr::include_graphics(here::here("images", "Function_Bread_Example.png"))
```
**Daha gerçekçi bir örnekte**, aşağıdaki "age_pyramid()" komutu, tanımlanmış yaş gruplarına ve "cinsiyet" gibi ikili bir bölme sütununa dayalı bir yaş piramidi grafiği oluşturur. Fonksiyona, parantez içinde virgülle ayrılmış üç değişken verilir. Değişkenlere sağlanan değerler, kullanılacak veri çerçevesi olarak "satır listesi"ni, sayılacak sütun olarak "age_cat5"i ve piramidi renge göre bölmek için kullanılacak ikili sütun olarak "gender"i belirler.
```{r basics_functions_arguments, include=FALSE, results='hide', message=FALSE, warning=FALSE,}
## kategorik aralar belirterek bir yaş grubu değişkeni oluşturun
linelist$age_group <- cut(linelist$age, breaks = c(0, 5, 10, 15, 20, 30, 45, 60))
```
```{r message=FALSE, warning=FALSE, out.width = "75%", out.height="75%"}
# Bir yaş piramidi oluştur
age_pyramid(data = linelist, age_group = "age_cat5", split_by = "gender")
```
Yukarıdaki komut, her değişken için yeni bir satırla daha uzun bir tarzda aşağıdaki gibi eşdeğer olarak yazılabilir. Bu stilin okunması daha kolay olabilir ve her bölümü açıklamak için "#" ile "yorum" yazmak daha kolay olabilir (kapsamlı yorum yapmak iyi bir uygulamadır!). Bu daha uzun komutu çalıştırmak için tüm komutu vurgulayabilir ve "Çalıştır"a tıklayabilir veya imlecinizi ilk satıra getirip ardından Ctrl ve Enter tuşlarına aynı anda basabilirsiniz.
```{r message=FALSE, warning=FALSE, out.width = "75%", out.height="75%"}
# Bir yaş piramidi oluştur
age_pyramid(
data = linelist, # Satır listesini kullan
age_group = "age_cat5", # Yaş grubu sütununu kullan
split_by = "gender" # Piramidin iki tarafı için cinsiyet sütununu kullan
)
```
Bir bağımsız değişken atamasının ilk yarısının (örneğin, "veri ="), bağımsız değişkenler belirli bir sırada (fonksiyonun belgelerinde belirtilen) yazılmışsa belirtilmesi gerekmez. Aşağıdaki kod, yukarıdakiyle tam olarak aynı piramidi üretir, çünkü fonksiyon değişken sırasını kabul eder: satır listesi, "yaş_grubu" değişkeni, "bölme_göre" değişkeni.
```{r, basics_functions_pyramid2, eval = FALSE, warning=FALSE, message=FALSE, , out.width = "75%", out.height="75%", eval=F}
# Bu komut yukarıdaki ile aynı grafiği üretecektir.
age_pyramid(linelist, "age_cat5", "gender")
```
**Daha karmaşık bir "age_pyramid()" komutu, aşağıdakilere yönelik *isteğe bağlı* değişkenleri içerebilir:**
- Sayılar yerine oranları göster (varsayılan "YANLIŞ" olduğunda "orantılı = DOĞRU" olarak ayarlayın)\
- Kullanılacak iki rengi belirtin (`pal =`, "palet"in kısaltmasıdır ve iki renk adından oluşan bir vektörle sağlanır. ""c()" fonksiyonunun nasıl vektör oluşturduğunu öğrenmek için [nesneler](#objectstructure) sayfasına bakın)
[***NOT:*** İki taraflı belirtilecek değişkenler için (ör. `orantılı = DOĞRU`) değişkenlerin sıraları önemsizdir.]{style="color: black;"}
```{r message=FALSE, warning=FALSE, out.width = "75%", out.height="75%"}
age_pyramid(
linelist, # Satır listesini kullan
"age_cat5", # Yaş grubu sütununu kullan
"gender", # Cinsiyete göre ayır
proportional = TRUE, # sayı yerine yüzdelik kullan
pal = c("orange", "purple") # renkleri turuncu ve mor
)
```
### Fonksiyon Yazma {.unnumbered}
R, fonksiyonlara yönelik bir dildir, bu nedenle kendi fonksiyonlarınızı yazmak için yetkilendirilmiş hissetmeniz gerekir. Fonskiyonlar oluşturmak çeşitli avantajlar sağlar:
- Modüler programlamayı kolaylaştırmak için - kodun bağımsız ve yönetilebilir parçalara ayrılması\
- Hataya açık olabilen tekrarlayan kopyala ve yapıştır işlemlerinin değiştirilmesi\
- Kod parçalarına akılda kalıcı isimler verilmesi
Bir fonksiyonun nasıl yazılacağı [Fonksiyon Yazma](writing_functions.tr.qmd) sayfasında derinlemesine ele alınmıştır.
```{r, eval=F, echo=F}
my_function <- function( ARGUMENTS HERE ){ CODE HERE }
```
```{r eval=F, echo=F, message=FALSE, warning=FALSE, out.width = "75%", out.height="75%"}
staff_calc(daily_cases = 150)
```
```{r, eval=F, echo=F}
case_incidence <- tibble(
dates = seq.Date(from = as.Date("2020-05-01"), to = as.Date("2020-05-21"), by = 1),
projected_incidence = c(102,110,50,37,106,190,146,138,135,111,60,43,189,184,185,80,44,97,254,291,288),
staff_needed = staff_calc(projected_incidence)
)
ggplot(case_incidence, aes(x = dates))+
geom_line(aes(y = projected_incidence))+
geom_line(aes(y = staff_needed))
```
## Paketler {#packages}
**Paketler fonksiyonları içerir.**
Bir R paketi, önceden tanımlanmış fonksiyonları içeren, paylaşılabilir bir kod ve belge paketidir. R topluluğundaki kullanıcılar, her zaman belirli sorunlara yönelik paketler geliştirir, muhtemelen size yardımcı olabilecek bir tanesi mevcuttur! R kullanımınızda yüzlerce paket kuracak ve kullanacaksınız.
Kurulum sırasında R, yaygın kullanılan görevleri gerçekleştiren **"temel"** paketleri ve fonksiyonları içerir. Ancak birçok R kullanıcısı, R topluluğu tarafından doğrulanan ve kendi kullanımınız için bir **paket** olarak indirebileceğiniz özel fonksiyonlar oluşturur. Bu el kitabında paket adları **kalın** ile yazılmıştır. R'ın daha zorlu yönlerinden biri, belirli bir görevi tamamlamak için seçilebilecek çok sayıda farklı fonksiyon veya paketin olmasıdır.
### Kurulum ve Yükleme {.unnumbered}
*Fonksiyonlar*, internetten bilgisayarınıza indirebileceğiniz ("kurulu") **paketler** içerisinde yer almaktadır. Bir paket indirildiğinde, "kütüphanenizde" saklanır. Ardından, paketi "yükleyerek" mevcut R oturumunuz sırasında içerdiği fonksiyonlara erişebilirsiniz.
*R'ı kişisel kitaplığınız olarak düşünün*: Bir paket indirdiğinizde, kütüphaneniz yeni bir fonksiyon kitabı kazanır, ancak o kitaptaki bir fonksiyonu her kullanmak istediğinizde, kütüphanenizden o kitabı ödünç almanız ("yüklemeniz") gerekir.
Özetle: bir R paketinde bulunan fonksiyonları kullanmak için 2 adım uygulanmalıdır:
1) Paket (bir defaya mahsus) **kurulmalı**, *ve*\
2) Paket (her R oturumu sırasında) **yüklenmeli**
#### Senin Kütüphanen {.unnumbered}
"Senin kütüphanen" aslında bilgisayarınızda kurulu olan her paket için içerisinde farklı bir dosya oluşturulan bir klasördür. Bilgisayarınızda R'ın nerede kurulu olduğunu bulun ve "win-library" adlı bir klasör arayın. Örneğin: `R\win-library\4.0` (4.0, R sürümüdür - indirdiğiniz her R sürümü için farklı bir kitaplığınız olacaktır).
`.libPaths()` (boş parantezler) girerek kitaplığınızın dosya yolunu yazdırabilirsiniz. [Ağ sürücülerinde R](network_drives.tr.qmd) ile çalışırken bu özellikle önemlidir.
#### CRAN 'dan Kurulum {.unnumbered}
Çoğu zaman, R kullanıcıları paketleri CRAN'dan indirir. CRAN (Comprehensive R Archive Network - Kapsamlı R Arşiv Ağı), topluluk üyeleri tarafından yayınlanan R paketlerinin çevrimiçi genel deposudur.
CRAN'dan bir paket indirirken virüsler ve güvenlik konusunda endişeleniyor musunuz? Konuyla ilgili [bu makaleyi](https://support.rstudio.com/hc/en-us/articles/360042593974-R-and-R-Package-Security) okuyabilirsiniz.
#### Nasıl kurulum yapar ve yüklerim?{.unnumbered}
Bu el kitabında, **pacman** paketini ("paket yöneticisi" kısaltması) kullanmanızı öneririz. Gerekirse bir paketi kuracak *ve* mevcut R oturumunda kullanmak üzere yükleyecek uygun bir `p_load()` fonksiyonu sunar.
Sözdizimi oldukça basit. Paketlerin adlarını 'p_load()' parantezleri içinde virgülle ayırarak listeleyin. Bu komut, henüz kurulmamışlarsa **rio**, **tidyverse** ve **here** paketlerini kuracak ve bunları kullanım için yükleyecektir. Bu, komut dosyalarını başkalarıyla paylaşırken `p_load()` yaklaşımını kullanışlı ve özlü hale getirir. Paket adlarının büyük/küçük harfe duyarlı olduğunu unutmayın.
```{r}
# Paketleri kurup yükleyebilirsiniz.(Gerekli görürseniz)
pacman::p_load(rio, tidyverse, here)
```
Paket adını (**pacman**) fonksiyon adından (`p_load()`) önce açıkça yazan `pacman::p_load()` sözdizimini kullandığımızı ve iki adet iki nokta üst üste `::` ile bağlandığını unutmayın. Bu sözdizimi, **pacman** paketini de yüklediği için kullanışlıdır (zaten kurulu olduğu varsayılarak).
Sıklıkla göreceğiniz alternatif **temel** R fonksiyonları vardır. Bir paketi kurmak için **temel** R fonksiyonu `install.packages()` fonksiyonudur. Kurulacak paketin adı parantez içinde *tırnak içinde* belirtilmelidir. Bir komutta birden çok paket kurmak istiyorsanız, bunlar bir `c()` karakter vektörü içinde listelenmelidir.
Not: Bu komut bir paketi *kurar*, ancak geçerli oturumda kullanmak için *yüklemez*.
```{r, eval=F}
# Temel R için bir paketin kurulumu
install.packages("tidyverse")
# Temel R için çoklu paketlerin kurulumu
install.packages(c("tidyverse", "rio", "here"))
```
Kurulum ayrıca, RStudio "Paketler" bölmesine gidip istenen paket adını arayarak "Kur" seçeneğine tıklanarak da gerçekleştirilebilir.
Bir paketi kullanmak üzere (kurulduktan sonra) **yüklemek** için **temel** R fonksiyonu 'library()'dir. Bir seferde yalnızca bir paket yükleyebilir (`p_load()` kullanmanın başka bir nedeni). Paket adını tırnak işaretleri ile veya tırnak işaretleri olmadan sağlayabilirsiniz.
```{r, eval=F}
# Temel R için paket yüklenmesi
library(tidyverse)
library(rio)
library(here)
```
Bir paketin kurulu ve/veya yüklenmiş olup olmadığını kontrol etmek için RStudio'da Paketler bölmesini görüntüleyebilirsiniz. Paket kurulu ise sürüm numarası ile orada gösterilir. Kutusu işaretliyse, geçerli oturum için yüklenir.
**Github'dan Kurulum**
Bazen, henüz CRAN'da bulunmayan bir paketi yüklemeniz gerekir. Veya belki de paket CRAN'da mevcuttur, ancak daha kararlı yayınlanan CRAN sürümünde henüz sunulmayan yeni özelliklere sahip *geliştirme sürümünü* istiyorsunuzdur. Bunlar genellikle [github.com](https://github.com/) web sitesinde ücretsiz, halka açık bir kod "deposu" içinde barındırılır. [Git ve Github ile sürüm kontrolü ve işbirliği] El kitabı sayfasından Github hakkında daha fazla bilgi edinebilirsiniz.
Github'dan R paketlerini indirmek için, gerekirse paketi kuracak ve mevcut R oturumunuzda kullanmak üzere yükleyecek olan **pacman**'dan `p_load_gh()` fonksiyonunu kullanabilirsiniz. Kurulum alternatifleri arasında **remotes** veya **devtools** paketlerinin kullanılması yer alır. [Paket belgelerinde](https://cran.r-project.org/web/packages/pacman/pacman.pdf) tüm **pacman** fonksiyonları hakkında daha fazla bilgi edinin.
Github'dan yüklemek için daha fazla bilgi sağlamanız gerekir. Şunları sağlamalısın:
1) Depo sahibinin Github kimliği
2) Paketi içeren havuzun adı\
3) *(isteğe bağlı) İndirmek istediğiniz "dalın" (özel geliştirme sürümü) adı*
Aşağıdaki örneklerde, tırnak içindeki ilk kelime depo sahibinin Github ID'sidir, eğik çizgiden sonra deponun adı (paketin adı) olur.
```{r, eval=F}
# Github deposundan epicontacts paketini kur ve yükle.
p_load_gh("reconhub/epicontacts")
```
Ana dal dışında bir "daldan" (sürüm) kurulum yapmak istiyorsanız, dal adını depo adından sonra şu ifade ile birlikte "\@" ekleyin.
```{r, eval=F}
# Github'dan epicontacts paketinin "zaman çizelgesi" dalını kurun
p_load_gh("reconhub/epicontacts@timeline")
```
Github sürümü ile bilgisayarınızdaki sürüm arasında herhangi bir fark yoksa herhangi bir işlem yapılmayacaktır. "update = TRUE" değişkeni yerine "p_load_current_gh()" komutu kullanarak yeniden yüklemeyi "zorlayabilirsiniz" (force). Bu [çevrimiçi gösterimde] http://trinker.github.io/pacman/vignettes/Introduction_to_pacman.html adresinde **pacman** hakkında daha fazla bilgi edinin)
**ZIP veya TAR'dan yükleme**
Paketi bir URL'den yükleyebilirsiniz:
```{r, eval=F}
packageurl <- "https://cran.r-project.org/src/contrib/Archive/dsr/dsr_0.2.2.tar.gz"
install.packages(packageurl, repos=NULL, type="source")
```
Veya sıkıştırılmış bir dosyada bilgisayarınıza indirin:
Seçenek 1: **remotes** paketinden `install_local()` kullanmak
```{r, eval=F}
remotes::install_local("~/Downloads/dplyr-master.zip")
```
Seçenek 2: **base** R'dan `install.packages()` komutunu kullanarak, ZIP dosyasının dosya yolunu sağlayarak ve `type = "source` ve `repos = NULL` ayarını yaparak.
```{r, eval=F}
install.packages("~/Downloads/dplyr-master.zip", repos=NULL, type="source")
```
### Kod sözdizimi {.unnumbered}
Bu el kitabındaki netlik için, fonksiyonlar önüne bazen aşağıdaki şekilde `::` sembolü kullanılarak paketlerinin adı gelir: `package_name::function_name()`
Bir oturum için bir paket yüklendiğinde, belirgin stil gerekli değildir. Sadece `function_name()` kullanılabilir. Bununla birlikte, bir fonksiyon adı yaygın olduğunda ve birden çok pakette bulunabileceğinde paket adını yazmak yararlıdır (örneğin, `plot()`). Paket adının yazılması, henüz yüklenmemişse paketi de yükleyecektir.
```{r eval=FALSE}
# Bu komut, bir veri kümesini içe aktarmak için "rio" paketini ve "import()" fonksiyonunu kullanır.
linelist <- rio::import("linelist.xlsx", which = "Sheet1")
```
### Fonksiyon yardımı {.unnumbered}
Bir fonksiyon hakkında daha fazlasını okumak için, sağ alt RStudio'nun Yardım sekmesinde onu arayabilirsiniz. Ayrıca `?fonksiyonadı` (fonksiyonun adını bir soru işaretinden sonra koyun) gibi bir komut çalıştırabilirsiniz ve Yardım bölmesinde Yardım sayfası görünecektir. Son olarak, kaynakları çevrimiçi olarak aramayı deneyin.
### Paketleri güncelleyin {.unnumbered}
Paketleri yeniden yükleyerek güncelleyebilirsiniz. Hangi paketlerin kurulacak yeni sürümleri olduğunu görmek için RStudio Paketleri bölmenizdeki yeşil "Güncelle" düğmesini de tıklayabilirsiniz. Bir fonksiyonun nasıl çalıştığına dair büyük bir revizyon varsa, eski kodunuzun güncellenmesi gerekebileceğini unutmayın!
### Paketleri sil {.unnumbered}
**pacman**'den `p_delete()` veya **base** R'dan `remove.packages()` komutlarını kullanabilirsiniz. Alternatif olarak, kitaplığınızı içeren klasörü bulup manuel olarak silebilirsiniz.
### Bağlılıklar {.unnumbered}
Paketler genellikle çalışmak için diğer paketlere bağlıdır. Bunlara bağlılıklar (dependencies)denir. Bir bağlılık yüklenemezse, buna bağlı olan paket de yüklenemeyebilir.
`p_depends()` ile bir paketin bağlılıklarını görün ve `p_depends_reverse()` ile hangi paketlerin ona bağlı olduğunu görün
### Maskelenmiş fonksiyonlar {.numbered}
İki veya daha fazla paketin aynı fonksiyon adını içermesi nadir değildir. Örneğin, **dplyr** paketinin bir "filter()" fonksiyonu vardır, ancak **stats** paketinin de fonksiyonu vardır. Varsayılan 'filter()' fonksiyonu, bu paketlerin R oturumunda ilk yüklendiği sıraya bağlıdır - sonraki, 'filter()' komutu için varsayılan olacaktır.
Sırayı R Studio'nun Ortam bölmesinde kontrol edebilirsiniz - "Global Ortam" açılır menüsünü tıklayın ve paketlerin sırasını görün. Bu açılır listedeki *alt* paketlerdeki fonksiyonlar, açılır listede daha yukarıda görünen paketlerdeki aynı ada sahip fonksiyonları maskeleyecektir. Bir paketi ilk yüklerken, maskeleme meydana gelirse R sizi konsolda uyarır, ancak bunu gözden kaçırmak kolay olabilir.
```{r out.width = "50%", fig.align = "center", echo=F}
knitr::include_graphics(here::here("images", "masking_functions.png"))
```
Maskelemeyi düzeltmenin yolları şunlardır:
1) Komutta paket adını belirtin. Örneğin, `dplyr::filter()`\ kodunu kullanın
2) Paketlerin yüklenme sırasını yeniden düzenleyin (ör. `p_load()` içinde) ve **yeni bir R oturumu başlatın**
### Ayır / kaldır {.unnumbered}
Bir paketi ayırmak (kaldırmak) için, bu komutu doğru paket adı ve yalnızca bir iki nokta üst üste ile kullanın. Bunun maskelemeyi çözmeyebileceğini unutmayın.
```{r, eval=F}
detach(package:PACKAGE_NAME_HERE, unload=TRUE)
```
### Eski sürümü yükleyin {.unnumbered}
Belirli bir paketin daha eski bir sürümünü yüklemek için bu [kılavuza](https://support.rstudio.com/hc/en-us/articles/219949047-Installing-older-versions-of-packages) bakabilirsiniz.
### Önerilen paketler {.unnumbered}
Günlük epidemiyoloji için önerdiğimiz paketlerin listesi için [Önerilen paketler](packages_suggested.tr.qmd) sayfasına bakabilirsiniz.
## Komut Dosyaları {#scripts}
Komut dosyaları, programlamanın temel bir parçasıdır. Komutlarınızı tutan belgelerdir (örneğin, veri kümeleri oluşturma ve değiştirme fonksiyonları, baskı görselleştirmeleri vb.). Bir komut dosyasını kaydedebilir ve daha sonra yeniden çalıştırabilirsiniz. Komutlarınızı bir komut dosyasında saklamanın ve çalıştırmanın (komutları tek tek R konsolu "komut satırına" yazmaya kıyasla) birçok avantajı vardır:
- Taşınabilirlik - çalışmalarınızı komut dosyalarınızı göndererek başkalarıyla paylaşabilirsiniz\
- Tekrarlanabilirlik - böylece siz ve diğerleri tam olarak ne yaptığınızı bilir\
- Sürüm kontrolü - böylece kendiniz veya meslektaşlarınız tarafından yapılan değişiklikleri takip edebilirsiniz\
- Yorumlama/açıklama - meslektaşlarınıza ne yaptığınızı açıklamak için kullanabilirsiniz
### Yorum yapma {.unnumbered}
Bir komut dosyasında, R kodunuzun etrafına açıklama da ("yorum") yapabilirsiniz. Yorum yapmak, kendinize ve diğer okuyuculara ne yaptığınızı açıklamanıza yardımcı olur. Hashtag sembolünü (\#) yazıp ardından yorumunuzu yazarak yorum ekleyebilirsiniz. Yorum yapılan metin, R kodundan farklı bir renkte görünecektir.
\#'dan sonra yazılan hiçbir kod çalıştırılmayacaktır. Bu nedenle, kodun önüne bir \# koymak, silmek istemiyorsanız bir kod satırını geçici olarak engellemenin ("yorum yapma") da yararlı bir yoludur. Ctrl+Shift+c (Mac'te Cmd+Shift+c) tuşlarına basarak aynı anda birden fazla satırda yorum yapabilir ve vurgular oluşturabilirsiniz.
```{r, eval = F}
# Bir yorum tek başına bir satırda olabilir
# verileri içe aktar
linelist <- import("linelist_raw.xlsx") %>% # Bir yorum aynı zamanda kodun ardından gelebilir
# filtre(yaş > 50) # Bir kod satırını devre dışı bırakmak/kaldırmak için de kullanılabilir
count()
```
- *Ne* yaptığınız hakkında *ve **neden** yaptığınız* hakkında yorum yapın.\
- Kodunuzu mantıksal bölümlere ayırın\
- Yaptığınız işin adım adım açıklamasını içeren bir metinle kodunuza eşlik edin (ör. numaralandırılmış adımlar)
### Stil {.numbered}
Özellikle bir ekip üzerinde çalışıyorsanız, kodlama stilinizin bilincinde olmak önemlidir. Biz **tidyverse** [stil rehberini](https://style.tidyverse.org/) öneriyoruz. Bu stile uyum sağlamanıza yardımcı olan **styler** ve **lintr** gibi paketler de vardır.
Kodunuzu başkaları tarafından okunabilir kılmak için birkaç temel nokta:\
\* Nesneleri adlandırırken yalnızca küçük harf, sayı ve alt çizgi "_" kullanın, ör. `benim_verilerim`\
\* Sık boşluklar kullanın, ör. "n = 1" ve "age_new <- age_old + 3"
### Örnek Komut Dosyası {.unnumbered}
Aşağıda kısa bir R komut dosyası örneği verilmiştir. Unutmayın, kodunuzu yorumlarda ne kadar kısa ve öz bir şekilde açıklarsanız, iş arkadaşlarınız sizi o kadar çok sevecektir!
```{r out.width = "100%", fig.align = "center", echo=F}
knitr::include_graphics(here::here("images", "example_script.png"))
```
### R işaretleme (R Markdown) {.unnumbered}
Bir R işaretleme komut dosyası, betiğin kendisinin bir çıktı belgesi (PDF, Word, HTML, Powerpoint, vb.) *olduğu* türüdür. Bunlar, genellikle dinamik ve otomatik raporlar oluşturmak için kullanılan inanılmaz derecede kullanışlı ve çok yönlü araçlardır. Bu web sitesi ve el kitabı bile R işaretleme komut dosyaları ile üretilmiştir!
Yeni başlayan R kullanıcılarının da R Markdown'ı kullanabileceğini belirtmekte fayda var - gözünüz korkmasın! Daha fazla bilgi edinmek için, [R Markdown ile Raporlar](rmarkdown.tr.qmd) belgelerindeki el kitabı sayfasına bakabilirsiniz.
### R not defterleri {.unnumbered}
Rmarkdown ile R not defterine yazmak arasında hiçbir fark yoktur. Ancak belgenin işlenmesi biraz farklıdır. Daha fazla ayrıntı için bu [siteye](http://uc-r.github.io/r_notebook) bakabilirsiniz.
### Parlak {.unnumbered}
Parlak uygulamalar/web siteleri, "app.R" olarak adlandırılması gereken tek bir komut dosyası içinde bulunur. Bu dosyanın üç bileşeni vardır:
1) Bir kullanıcı arayüzü (user inteface(ui))\
2) Bir sunucu fonksiyonu\
3) "shinyApp" fonksiyonuna bir çağrı
[Shiny ile Panolar](shiny_basics.tr.qmd)'daki el kitabı sayfasına veya bu çevrimiçi eğiticiye bakabilirsiniz: [Parlak öğretici](https://shiny.rstudio.com/tutorial/write-tutorial/lesson1/)
*Önceleri yukarıdaki dosya iki dosyaya bölünmüş olarak mevcuttu. (`ui.R` ve `server.R`)*
### Kod katlama {.unnumbered}
Komut dosyanızın okunmasını kolaylaştırmak için kod bölümlerini daraltabilirsiniz.
Bunu yapmak için, \# ile bir metin başlığı oluşturun, başlığınızı yazın ve ardından tire (-), kare (\#) veya eşittir (=)'den birini en az 4 kez kullanın. Bunu yaptığınızda, soldaki "oluk"ta (satır numarasına göre) küçük bir ok belirecektir. Bu oku ve aşağıdaki kodu, bir sonraki başlık bitimine ve yerinde bir çift ok simgesi görünene kadar tıklayabilirsiniz.
Kodu genişletmek için, ya cilt payındaki oku ya da çift ok simgesini tıklayın. Bu sayfanın [RStudio bölümünde](#rstudio) açıklandığı gibi klavye kısayolları da mevcuttur.
\# ile başlıklar oluşturarak, komut dosyanızın altında (aşağıya bakın) komut dosyanızda gezinmek için kullanabileceğiniz İçindekiler Tablosunu da etkinleştirirsiniz. Daha fazla \# sembolü ekleyerek alt başlıklar oluşturabilirsiniz, örneğin birincil için \#, ikincil için \#\# ve üçüncül başlıklar için \#\#\#.
Aşağıda örnek bir komut dosyasının iki versiyonu bulunmaktadır. Solda, yorumlanmış başlıkları olan orijinaldir. Sağ tarafta, her başlıktan sonra daraltılabilir hale getiren dört çizgi yazılmıştır. Bunlardan ikisi daraltılmıştır ve alttaki İçindekiler'in artık her bölümü gösterdiğini görebilirsiniz.
```{r, out.width = c('50%'), fig.show='hold', echo=F}
knitr::include_graphics(here::here("images", "code_folding1.png"))
knitr::include_graphics(here::here("images", "code_folding2.png"))
```
Otomatik olarak katlama için uygun olan diğer kod alanları, fonksiyon tanımları veya koşullu bloklar (if else ifadeleri) gibi "{ }" köşeli parantezli "köşeli" bölgeleri içerir. RStudio [sitesinde](https://support.rstudio.com/hc/en-us/articles/200484568-Code-Folding-and-Sections) kod katlama hakkında daha fazla bilgi edinebilirsiniz.
## Çalışma dizini
Çalışma dizini, R tarafından işiniz için kullanılan kök klasör konumudur - burada R, varsayılan olarak dosyaları arar ve kaydeder. Varsayılan olarak, yeni dosyaları ve çıktıları bu konuma kaydedecek ve içe aktarılacak dosyaları (örneğin veri kümeleri) burada da arayacaktır.
Çalışma dizini, RStudio Konsol bölmesinin üst kısmında gri metin olarak görünür. Geçerli çalışma dizinini `getwd()` komutunu çalıştırarak da yazdırabilirsiniz (parantezleri boş bırakın).
```{r fig.align="center", out.width="100%"}
knitr::include_graphics(here::here("images", "working_directory_1.png"))
```
Yakın zamana kadar, R öğrenen birçok kişiye komut dosyalarına `setwd()` komutuyla başlamaları öğretiliyordu. Bunun yerine lütfen [R projesi](r_projects.tr.qmd) odaklı bir iş akışı kullanmayı düşünün ve [`setwd()` kullanmama nedenleriniz için okuyunuz](https://www.tidyverse.org/blog/2017/12/workflow-vs-script/). Kısacası, işiniz bilgisayarınıza özel hale gelir, dosyaları içe ve dışa aktarmak için kullanılan dosya yolları "kırılgan" hale gelir ve bu, işbirliğini ve kodunuzun başka herhangi bir bilgisayarda kullanılmasını ciddi şekilde engeller. Kolay alternatifler var!
Yukarıda belirtildiği gibi, çoğu durumda bu yaklaşımı önermesek de, `setwd()` komutunu alıntılarda istediğiniz klasör dosya yolu ile kullanabilirsiniz, örneğin:
```{r, eval=F}
setwd("C:/Documents/R Files/My analysis")
```
[***TEHLİKE:*** `setwd()` ile bir çalışma dizini ayarlamak dosya yolu bir bilgisayara özelse "kırılgan" *olabilir*. Bunun yerine, bir R Project kök dizinine göre dosya yollarını kullanın (**burada** paketiyle). ]{style="renk: kırmızı;"}
### Manuel olarak ayarla {.unnumbered}
Çalışma dizinini manuel olarak ayarlamak için ('setwd()'nin tıklamakla eşdeğeri), Oturum açılır menüsünü tıklayın ve "Çalışma Dizinini Ayarla"ya ve ardından "Dizin Seç"e gidin. Bu, o belirli R oturumu için çalışma dizinini ayarlayacaktır. Not: Bu yaklaşımı kullanıyorsanız, RStudio'yu her açtığınızda bunu manuel olarak yapmanız gerekecektir.
### Bir R projesi içinde {.unnumbered}
Bir R projesi kullanıyorsanız, çalışma dizini varsayılan olarak ".rproj" dosyasını içeren R projesi kök klasörü olacaktır. Bu, RStudio'yu R Project'i (".rproj" uzantılı dosya) tıklayarak açarsanız geçerli olacaktır.
### R markdown için çalışma dizini {.unnumbered}
Bir R markdown komut dosyasında, varsayılan çalışma dizini, Rmarkdown dosyasının (`.Rmd`) içinde kaydedildiği klasördür. Bir R projesi ve **here** paketi kullanılıyorsa, bu geçerli değildir ve çalışma dizini [R projeleri](r_projects.tr.qmd) sayfasında açıklandığı gibi 'here()' olacaktır.
Tek başına bir R markdown çalışma dizinini değiştirmek istiyorsanız (bir R projesinde değil), 'setwd()' kullanırsanız, bu yalnızca o belirli kod yığını için geçerli olacaktır. Bir R işaretlemesindeki tüm kod parçalarında değişiklik yapmak için, aşağıdaki gibi "root.dir =" parametresini eklemek için kurulum öbeğini düzenlemelisiniz:
```{r, eval=F}
knitr::opts_knit$set(root.dir = 'desired/directorypath')
```
Bir R projesinde sadece R işaretlemesini kullanmak ve **here** paketini kullanmak çok daha kolaydır.
### Dosya yolları sağlama {.unnumbered}
Yeni başlayanlar için (en azından bir Windows makinesinde) belki de en yaygın hayal kırıklığı kaynağı, verileri içe veya dışa aktarmak için bir dosya yoluna yazmaktır. [İçe ve dışa aktar] sayfasında dosya yollarının en iyi nasıl girileceğine dair kapsamlı bir açıklama vardır, ancak burada birkaç önemli nokta vardır:
**Bozuk yollar**
Aşağıda bir "mutlak" veya "tam adres" dosya yolu örneği verilmiştir. Bunlar başka bir bilgisayar tarafından kullanılırsa büyük olasılıkla kırılacaktır. Bir istisna, paylaşılan/ağ sürücüsü kullanmanızdır.
C:/Kullanıcılar/Ad/Belge/Analitik Yazılım/R/Projeler/Analiz2019/data/March2019.csv
** Eğik yön**
*Bir dosya yolu yazıyorsanız, eğik çizgilerin yönüne dikkat edin.* Bileşenleri ayırmak için *eğik çizgi* (`/`) kullanın ("data/provincial.csv"). Windows kullanıcıları için, dosya yollarının varsayılan görüntülenme şekli *ters eğik çizgi* (\\) iledir - bu nedenle her eğik çizginin yönünü değiştirmeniz gerekecektir. **here** paketini [R projeleri](r_projects.tr.qmd) sayfasında açıklandığı gibi kullanırsanız, eğik çizgi bir sorun olmaz.
**Göreceli dosya yolları**
Bunun yerine genellikle "göreceli" dosya yolları sağlamanızı öneririz - yani, R Projenizin köküne *göre* olan yol. Bunu, [R projeleri](r_projects.tr.qmd) sayfasında açıklandığı gibi **here** paketini kullanarak yapabilirsiniz. Göreceli bir dosya yolu şöyle görünebilir:
```{r, eval=F}
# Bir R projesinin veri/satır listesi/temiz/alt klasörlerinden csv satır listesini içe aktarın
linelist <- import(here("data", "clean", "linelists", "marin_country.csv"))
```
Bir R projesinde göreli dosya yolları kullanıyor olsanız bile, R projenizin dışında verileri içe/dışa aktarmak için mutlak yolları kullanabilirsiniz.
## Nesneler {#objects}
R'daki her şey bir nesnedir ve R, "nesne yönelimli" bir dildir. Bu bölümler şunları açıklayacaktır:
- Nesneler nasıl oluşturulur (`<-`)
- Nesne türleri (örn. veri çerçeveleri, vektörler..)\
- Nesnelerin alt bölümlerine nasıl erişilir (ör. bir veri kümesindeki değişkenler)\
- Nesne sınıfları (örn. sayısal, mantıksal, tamsayı, çift, karakter, faktör)
### Her şey bir nesnedir {.unnumbered}
*Bu bölüm [R4Epis projesinden](https://r4epis.netlify.app/training/r_basics/objects/) uyarlanmıştır.*\
R'da sakladığınız her şey - veri kümeleri, değişkenler, köy isimleri listesi, toplam nüfus sayısı, hatta grafikler gibi çıktılar - **atanmış bir adla** ve **alıntılanabilen** **nesnelerdir**.
Bir nesneye bir değer atadığınızda var olur (aşağıdaki atama bölümüne bakın). Bir değer atandığında, nesne Ortamda görünür (RStudio'nun sağ üst bölmesine bakın). Daha sonra çalıştırılabilir, manipüle edilebilir, değiştirilebilir ve yeniden tanımlanabilir.
### Nesneleri tanımlama (`<-`) {.unnumbered}
**\<- operatörüyle *nesnelere bir değer* atayarak nesneler oluşturun.**\
"<-" atama operatörü olarak tanımlanır. Atama komutları genellikle standart bir sıra izler:
**nesne_adı** \<- **değer** (veya bir değer üreten süreç/hesaplama)
Örneğin, mevcut epidemiyolojik raporlama haftasını daha sonraki kodda referans için bir nesne olarak kaydetmek isteyebilirsiniz. Bu örnekte, "current_week" nesnesi "2018-W10"' değeri atandığında oluşturulur (tırnak işaretleri bunu bir karakter değeri yapar). 'current_week' nesnesi daha sonra RStudio Ortam bölmesinde (sağ üst) görünecek ve sonraki komutlarda başvurulabilecektir.
Aşağıdaki kutularda R komutlarına ve çıktılarına bakabilirsiniz.
```{r basics_objects_assignment}
current_week <- "2018-W10" # bu komut, bir değer atayarak current_week nesnesini yaratır.
current_week # bu komut, geçerli_hafta nesnesinin geçerli değerini konsolda yazdırır
```
[***NOT:*** R konsol çıktısındaki `[1]` sadece çıktının ilk öğesini görüntülediğinizi belirtir]{style="color: black;"}
[***DİKKAT:*** **Bir nesnenin değerinin üzerine yeniden tanımlamak için bir atama komutu herhangi bir zamanda yazılabilir** Bu nedenle, **çalışan komutların sırası çok önemlidir**.]{style="color: orange;"}
Aşağıdaki komut, "current_week" değerini yeniden tanımlayacaktır:
```{r basics_objects_reassignment}
current_week <- "2018-W51" # current_week nesnesine YENİ bir değer atar
current_week # bu yeni değeri konsolda yazdırır
```
**Eşittir işaretleri `=`**
Ayrıca R kodunda eşittir işaretleri göreceksiniz:
- İki nesne veya değer arasındaki bir çift eşittir işareti `==` mantıksal bir *soru sorar*: "buna eşit mi?".\
- Ayrıca, fonskiyonların değişkenlerinin değerlerini belirtmek için kullanılan eşittir işaretlerini de göreceksiniz (bunlar hakkında aşağıdaki bölümlerde okuyun), örneğin `max(age, na.rm = TRUE)`.\
- Nesneleri oluşturmak ve tanımlamak için `<-` yerine tek bir eşittir işareti `=` *kullanabilirsiniz*, ancak bu önerilmez. Bunun neden önerilmediğini [buradan](https://renkun.me/2014/01/28/difference-between-assignment-operators-in-r/) okuyabilirsiniz.
**Veri kümeleri (Datasets)**
Veri kümeleri de nesnelerdir (tipik olarak "veri çerçeveleri") ve içe aktarıldıklarında adlarının atanması gerekir. Aşağıdaki kodda, 'linelist' nesnesi oluşturulur ve **rio** paketi ve 'import()' fonksiyonu ile içe aktarılan bir CSV dosyasının değeri atanır.
```{r basics_objects_dataframes, eval=FALSE}
# satır listesi oluşturulur ve içe aktarılan CSV dosyasının değeri atanır
linelist <- import("my_linelist.csv")
```
[İçe aktarma ve dışa aktarma](importing.tr.qmd) bölümünden veri kümelerini içe ve dışa aktarma hakkında daha fazla bilgi edinebilirsiniz.
[***DİKKAT:*** Nesnelerin adlandırılmasıyla ilgili kısa bir not:]{style="color: orange;"}
- Nesne adları boşluk içermemelidir, ancak boşluk yerine alt çizgi (\_) veya nokta (.) kullanabilirsiniz.\
- Nesne adları büyük/küçük harfe duyarlıdır (yani Veri Kümesi_A, veri kümesi_A'dan farklıdır).
- Nesne adları bir harfle başlamalıdır (1, 2 veya 3 gibi bir sayı ile başlayamaz).
**Çıktılar**
Tablolar ve çizimler gibi çıktılar, çıktıların nesneler olarak nasıl kaydedilebileceğine veya kaydedilmeden nasıl yazdırılabileceğine dair bir örnek sağlar. **Temel** R fonksiyonu "table()" kullanılarak cinsiyet ve kazanç tablosu doğrudan R konsoluna yazdırılabilir (*kaydedilmeden*).
```{r}
# yalnızca R konsoluna yazdırılır
table(linelist$gender, linelist$outcome)
```
Ancak aynı tablo adlandırılmış bir nesne olarak kaydedilebilir. Daha sonra isteğe bağlı olarak yazdırılabilir.
```{r}
# kayıt
gen_out_table <- table(linelist$gender, linelist$outcome)
# yazdırma
gen_out_table
```
**Sütunlar**
Bir veri kümesindeki sütunlar da nesnelerdir ve aşağıda Sütunlar bölümünde açıklandığı gibi tanımlanabilir, üzerine yazılabilir ve oluşturulabilirdir.
Yeni bir sütun oluşturmak için **temel** R'dan atama operatörünü kullanabilirsiniz. Aşağıda, yeni sütun "bmi" (Vücut Kitle İndeksi) oluşturulur ve her satır için yeni değer, satırın "wt_kg" ve "ht_cm" sütunlarındaki değeri üzerindeki matematiksel bir işlemin sonucudur.
```{r, eval=F}
# temel R sözdizimini kullanarak yeni "bmi" sütunu oluşturun
linelist$bmi <- linelist$wt_kg / (linelist$ht_cm/100)^2
```
Bununla birlikte, bu el kitabında, **dplyr** paketindeki `mutate()` fonksiyonunu ve tünel operatörüyle (`%>%`) *piping* fonksiyonunu kullanan sütunları tanımlamaya yönelik farklı bir yaklaşımı vurguluyoruz. Sözdiziminin okunması daha kolaydır ve [Temizleme verileri ve temel fonksiyonlar](cleaning.tr.qmd) sayfasında açıklanan başka avantajları da vardır. *tünelleme* hakkında daha fazla bilgiyi aşağıdaki Tünelleme bölümünde okuyabilirsiniz.
```{r, eval=F}
# dplyr sözdizimini kullanarak yeni "bmi" sütunu oluşturun
linelist <- linelist %>%
mutate(bmi = wt_kg / (ht_cm/100)^2)
```
### Nesne yapısı {.unnumbered}
**Nesneler tek bir veri parçası olabilir (ör. "my_number <- 24") veya yapılandırılmış verilerden oluşabilir.**
Aşağıdaki grafik [bu çevrimiçi R eğitiminden](http://venus.ifca.unican.es/Rintro/dataStruct.html) ödünç alınmıştır. Bazı yaygın veri yapılarını ve adlarını gösterir. [GIS temelleri](gis.tr.qmd) sayfasında tartışılan uzamsal veriler bu görüntüye dahil değildir.
```{r basics_objects_structures, echo=F, out.width = "75%", out.height="50%", fig.align = "center"}
knitr::include_graphics(here::here("images", "R_data_structures.png"))
```
Epidemiyolojide (ve özellikle saha epidemiyolojisinde), *en yaygın olarak* veri çerçeveleri ve vektörlerle karşılaşacaksınız:
+------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
| Yaygın Yapılar | Açıklama | Örnekler |
+==================+==================================================================================================+=====================================================================================+
| Vektörler | Hepsi aynı sınıftan (ör. sayısal, karakter) tekil nesneler dizisi için bir kapsayıcı. | **Veri çerçevelerindeki "Değişkenler" (sütunlar) vektörlerdir** (ör. "age_years" sütunu). |
+------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
| Veri Çerçeveleri | Hepsi aynı sayıda satıra sahip olan birbirine bağlı vektörler (örneğin sütunlar). | `satır_listesi` bir veri çerçevesidir. |
+------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+
"Tek başına" (bir veri çerçevesinin parçası olmayan) bir vektör oluşturmak için "c()" fonksiyonunun farklı öğeleri birleştirmek için kullanıldığını unutmayın. Örneğin, bir renk vektörü oluşturuyorsanız, grafiğin renk skalası: `vector_of_colors <- c("blue", "red2", "orange", "grey")`
### Nesne sınıfları {.unnumbered}
R'da depolanan tüm nesnelerin, R'a nesneyi nasıl kullanacağını söyleyen bir *sınıfı* vardır. Birçok olası sınıf vardır, ancak ortak olanlar şunları içerir:
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
| Sınıf | Açıklama | Örnekler |
+============+=========================================================================================================================================================================================+=======================================================================================================+
| Karakter | Bunlar **"tırnak içinde"** bulunan metin/kelimeler/cümlelerdir . Bu nesneler üzerinde matematik yapılamaz. | "Karakter nesneleri tırnak içindedir" |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
| Tam Sayı | **Yalnızca tam** olan sayılar (virgülden sonra ondalığı yok) | -5, 14, veya 2000 |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
| Sayısal(Nümerik) | Bunlar sayılardır ve **ondalık sayılar içerebilir**. Tırnak içindeyseler, karakter sınıfı olarak kabul edilirler. | 23.1 veya 14 |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
| Faktör | Bunlar, **belirtilmiş bir sıraya** veya değerler hiyerarşisine sahip vektörlerdir. | Sıralı değerlere sahip bir ekonomik durum değişkeni |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
| Tarih |**R'a belirli verilerin Tarih olduğu söylendiğinde**, bu veriler özel yollarla manipüle edilebilir ve görüntülenebilir. Daha fazla bilgi için [Tarihlerle çalışma](dates.tr.qmd) sayfasına bakın.| 2018-04-12 veya 15/3/1954 veya Çrş 4 Ocak 1980 |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
| Mantıksal (Logical) | Değerler DOĞRU veya YANLIŞ iki özel değerden biri olmalıdır (bunların tırnak içinde **değil** "DOĞRU" ve "YANLIŞ" olduğuna dikkat edin) | DOĞRU veya YANLIŞ |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
| veri Çerçevesi (data frame) | Veri çerçevesi, R'ın **tipik bir veri kümesini** nasıl depoladığıdır. Hepsi aynı sayıda gözleme (satır) sahip olan birbirine bağlı veri vektörlerinden (sütunlarından) oluşur. | 'linelist_raw' adlı örnek AJS veri kümesi, her biri 300 gözlem (satır) içeren 68 değişken içerir. |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
| Tibble | tibbles, veri çerçevesindeki bir varyasyondur, ana operasyonel fark, konsola daha güzel yazdırmalarıdır (ilk 10 satırı ve yalnızca ekrana uyan sütunları görüntüleyin) | Herhangi bir veri çerçevesi, liste veya matris, `as_tibble() ile bir tibble'a dönüştürülebilir.` |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
| Liste | Liste vektör gibidir, ancak diğer nesneler farklı sınıflara ait olabilir. | Bir liste tek bir sayıyı, bir veri çerçevesini ve bir vektörü ve hatta içinde başka bir listeyi içerebilir! |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+
**Bir nesnenin sınıfını, adını `class()`** fonksiyonuna vererek test edebilirsiniz. Not: Veri kümesinin adını ve sütunun adını ayırmak için "$" gösterimini kullanarak bir veri kümesi içindeki belirli bir sütuna başvurabilirsiniz.
```{r, echo=TRUE,}
class(linelist) # sınıfı bir veri çerçevesi veya tibble olmalıdır
class(linelist$age) # sınıfı sayısal olmalıdır
class(linelist$gender) # sınıfı karakter olmalı
```
Bazen bir sütun R tarafından otomatik olarak farklı bir sınıfa dönüştürülür. Buna dikkat edin! Örneğin, bir vektörünüz veya sayı sütununuz varsa, ancak bir karakter değeri eklenirse... sütunun tamamı sınıf karakterine dönüşür.
```{r}
num_vector <- c(1,2,3,4,5) # vektörü tüm sayılar olarak tanımla
class(num_vector) # vektör sayısal bir sınıftır
num_vector[3] <- "üç" # üçüncü elemanı bir karaktere çevir
class(num_vector) # vektör artık karakter sınıfıdır
```
Bunun yaygın bir örneği, bir tablo yazdırmak için bir veri çerçevesini manipüle etmektir - toplam bir satır yaparsanız ve sayılarla aynı hücredeki yüzdeleri yapıştırmaya çalışırsanız (örneğin '23 (%40)'), yukarıdaki sayısal sütunun tamamı karaktere dönüştürülecek ve artık matematiksel hesaplamalar için kullanılamayacak.**Bazen nesneleri veya sütunları başka bir sınıfa dönüştürmeniz gerekebilir.**
+------------------+---------------------------------------------------------------------------------------+
| Fonksiyon | Eylem |
+==================+=======================================================================================+
| `as.character()` | Karakter sınıfına çevirir |
+------------------+---------------------------------------------------------------------------------------+
| `as.numeric()` | Sayısal sınıfına çevirir |
+------------------+---------------------------------------------------------------------------------------+
| `as.integer()` | Tam Sayı sınıfına çevirir |
+------------------+---------------------------------------------------------------------------------------+
| `as.Date()` | Tarih sınıfına dönüştürür - Not: Ayrıntılar için [dates](#dates) bölümüne bakıns |
+------------------+---------------------------------------------------------------------------------------+
| `factor()` | Faktöre dönüştürür - Not: değer düzeylerinin sırasını yeniden tanımlamak için ekstra değişkenler gerekir |
+------------------+---------------------------------------------------------------------------------------+
Benzer şekilde, belirli bir sınıfa ait bir nesnenin IS olup olmadığını kontrol etmek için **temel** R fonksiyonları vardır. Örneğin "is.numeric()", "is.character()", "is.double()", "is.factor()`, `is.integer()`
[R'daki sınıflar ve veri yapıları hakkında daha fazla çevrimiçi materyal](https://swcarpentry.github.io/r-novice-inflammation/13-supp-data-structures/).
### Sütunlar/Değişkenler (`$`) {.unnumbered}
**Veri çerçevesindeki bir sütun teknik olarak bir "vektördür" (yukarıdaki tabloya bakın)** - tümü aynı sınıfta olması gereken bir dizi değer (karakter, sayısal, mantıksal vb.).
Bir vektör, bir veri çerçevesinden bağımsız olarak var olabilir. Örneğin, bir modelde açıklayıcı değişkenler olarak dahil etmek istediğiniz sütun adlarından oluşan bir vektör. "Bağımsız" bir vektör oluşturmak için aşağıdaki gibi `c()` fonksiyonunu kullanın:
```{r, warning=F, message=F}
# karakter değerlerinin bağımsız vektörünü tanımlayın
explanatory_vars <- c("gender", "fever", "chills", "cough", "aches", "vomit")
# bu adlandırılmış vektördeki değerleri yazdır
explanatory_vars
```
**Bir veri çerçevesindeki sütunlar da vektörlerdir ve çağrılabilir, referans alınabilir, ayıklanabilir veya `$` sembolü kullanılarak oluşturulabilir.** `$` sembolü, sütunun adını veri çerçevesinin adına bağlar. Bu el kitabında "değişken" yerine "sütun" kelimesini kullanmaya çalışıyoruz.
```{r basics_objects_call, eval=F}
# age_years vektörünün uzunluğunu alın
length(linelist$age) # (yaş, satır listesi veri çerçevesindeki bir sütundur)
```
Veri çerçevesinin adının ardından `$' yazarak, veri çerçevesindeki tüm sütunların bir açılır menüsünü de göreceksiniz. Ok tuşunuzu kullanarak aralarında gezinebilir, Enter tuşu ile birini seçebilir ve yazım hatalarından kaçınabilirsiniz!
```{r echo=F, out.width = "100%", fig.align = "center"}
knitr::include_graphics(here::here("images", "Calling_Names.gif"))
```
[***GELİŞMİŞ İPUCU:*** Bazı daha karmaşık nesnelerin (örneğin bir liste veya bir "epicontacts" nesnesi) birden çok dolar işaretiyle erişilebilen birden çok düzeyi olabilir. Örneğin, `epicontacts$linelist$date_onset`]{style="color: darkgreen;"}
### Köşeli ayraçlarla erişim/dizin (`[ ]`) {.unnumbered}
Genellikle "[ ]" köşeli parantezleri kullanılarak yapılan, "indeksleme" olarak da adlandırılan nesnelerin parçalarını görüntülemeniz gerekebilir. Bir sütuna erişmek için bir veri çerçevesinde `$` kullanmak da bir indeksleme türüdür.
```{r}
my_vector <- c("a", "b", "c", "d", "e", "f") # Vektörün tanımlanması
my_vector[5] # 5. ögenin yazdırılması
```
Köşeli parantezler ayrıca, bir "summary()" fonksiyonunun çıktısı gibi, döndürülen çıktının belirli bölümlerini döndürmek için de çalışır:
```{r}
# Özetin tamamı
summary(linelist$age)
# Özetin yalnızca ikinci ögesi, adıyla (yalnızca tek parantez kullanarak)
summary(linelist$age)[2]
# Sadece ikinci öge, isimsiz (çift parantez kullanarak)
summary(linelist$age)[[2]]
# Bir öğeyi, adını göstermeden adıyla ayıklayın
summary(linelist$age)[["Median"]]
```
Parantezler ayrıca belirli satırları ve sütunları görüntülemek için veri çerçeveleri üzerinde de çalışır. Bunu, `dataframe[rows, column]` sözdizimini kullanarak yapabilirsiniz:
```{r basics_objects_access, eval=F}
# Tüm sütunlarla birlikte veri kümesinden belirli bir satırı (2) görüntüleyin (virgül unutmayın!)
linelist[2,]
# Tüm satırları görüntüleyin, ancak yalnızca bir sütun
linelist[, "date_onset"]
# 2. satırdaki ve 5 ile 10 arasındaki sütunlardaki değerleri görüntüleyin
linelist[2, 5:10]
# 2. satırdaki ve 5. ila 10. ve 18. sütunlardaki değerleri görüntüleyin
linelist[2, c(5:10, 18)]
# 2'den 20'ye kadar olan satırları ve belirli sütunları görüntüleyin
linelist[2:20, c("date_onset", "outcome", "age")]
# Ölçüte göre satırları ve sütunları görüntüleyin
# *** Veri çerçevesinin kriterlerde hala adlandırılması gerektiğine dikkat edin!
linelist[linelist$age > 25 , c("date_onset", "outcome", "age")]
# RStudio Viewer bölmesindeki çıktıları görmek için View()'i kullanın (okunması daha kolay)
# *** View() fonksiyonunda büyük "V" harfini not edin
View(linelist[2:20, "date_onset"])
# Yeni bir nesne olarak kaydet
new_table <- linelist[2:20, c("date_onset")]
```
**dplyr** sözdizimini (satırlar için 'filter()' ve sütunlar için 'select()' fonksiyonları) kullanarak veri çerçeveleri ve tibbles üzerinde yukarıdaki satır/sütun indekslemeyi de gerçekleştirebileceğinizi unutmayın. [Temizleme verileri ve temel fonksiyonlar](cleaning.tr.qmd) sayfasında bu temel fonksiyonlar hakkında daha fazla bilgi edinin.
"Satır numarasına" göre filtrelemek için, mantıksal bir filtreleme ifadesinin parçası olarak açık parantezlerle **dplyr** `row_number()` fonksiyonunu kullanabilirsiniz. Aşağıda gösterildiği gibi, genellikle bu mantıksal ifadenin bir parçası olarak "%in%" operatörünü ve bir dizi sayıyı kullanacaksınız. *ilk* N satırı görmek için, özel **dplyr** fonksiyonu `head()` de kullanabilirsiniz.
```{r, eval=F}
# İlk 100 satırı görüntüle
linelist %>% head(100)
# Sadece 5. satırı görüntüke
linelist %>% filter(row_number() == 5)
# 2'den 20'ye kadar olan satırları ve üç özel sütunu görüntüleyin (sütun adlarında tırnak işareti gerekmediğini unutmayın)
linelist %>% filter(row_number() %in% 2:20) %>% select(date_onset, outcome, age)
```
**list** sınıfının bir nesnesini indekslerken, yalnızca tek bir nesne döndürülse bile, tek parantezler her zaman sınıf listesiyle birlikte döner. Ancak çift parantezler, tek bir öğeye erişmek ve listeden farklı bir sınıf döndürmek için kullanılabilir.\
Parantezler ayrıca aşağıda gösterildiği gibi birbiri ardına yazılabilir.
Bu [liste indekslemenin tuzlukla görsel açıklaması](https://r4ds.had.co.nz/vectors.html#lists-of-condiments) komik ve faydalıdır.
```{r}
# demo listesini tanımla
my_list <- list(
# Listedeki ilk öge karakter vektörü
hospitals = c("Central", "Empire", "Santa Anna"),
# Listedeki ikinci öge adreslerin veri çerçevesi
addresses = data.frame(
street = c("145 Medical Way", "1048 Brown Ave", "999 El Camino"),
city = c("Andover", "Hamilton", "El Paso")
)
)
```
Konsola yazdırıldığında listenin nasıl göründüğü aşağıda açıklanmıştır. Nasıl adlandırılmış iki öğe olduğunu görün:
- "hospitals", bir karakter vektörü\
- "addresses", adreslerin bir veri çerçevesi
```{r}
my_list
```
Şimdi çeşitli yöntemler kullanarak ayıklıyoruz:
```{r}
my_list[1] # bu, "list" sınıfındaki öğeyi döndürür - öğe adı hala görüntüleniyor
my_list[[1]] # bu yalnızca (adsız) karakter vektörünü döndürür
my_list[["hospitals"]] # ayrıca liste öğesinin adına göre dizin oluşturabilirsiniz
my_list[[1]][3] # "hastaneler" karakter vektörünün üçüncü öğesini döndürür
my_list[[2]][1] # Bu, adres veri çerçevesinin ilk sütununu ("sokak") döndürür
```
### Nesneleri kaldırma {.unnumbered}
'rm()' fonksiyonu ile (tırnak işaretleri olmadan) R ortamınızdan tek tek nesneleri kaldırabilirsiniz:
```{r, eval=F}
rm(object_name)
```
Aşağıdakileri çalıştırarak tüm nesneleri kaldırabilirsiniz (çalışma alanınızı temizleyin):
```{r, eval=F}
rm(list = ls(all = TRUE))
```
## Tünelleme (`%>%`)
**Nesnelerle çalışmaya yönelik iki genel yaklaşım şunlardır:**
1) **Tüneller/tidyverse** - tüneller nesneyi bir fonksiyondan diğerine gönderir - vurgu nesne değil *eylem* üzerindedir\
2) **Ara nesneleri tanımlayın** - bir nesne tekrar tekrar tanımlanır - vurgu nesne üzerindedir
### **Tüneller** {.unnumbered}
**Basitçe açıklandığı gibi, tünel operatörü (`%>%`) bir fonksiyondan diğerine bir ara çıktı iletir.**\
Bunu "sonrasında" demek gibi düşünebilirsiniz. Birçok fonksiyon `%>%` ile birbirine bağlanabilir.
- **Tünelleme, eylemlerin gerçekleştirildiği nesneyi değil, bir dizi eylemi vurgular**\
- Tüneller, bir nesne üzerinde bir dizi eylem gerçekleştirilmesi gerektiğinde en iyisidir\
- Tüneller, otomatik olarak **dplyr** ve **tidyverse** paketlerine dahil edilen **magrittr** paketinden gelir
- Tüneller, kodu daha temiz ve okunması daha kolay, daha sezgisel hale getirebilir
Bu yaklaşımla ilgili daha fazla bilgiyi tidyverse [stil kılavuzunda](https://style.tidyverse.org/pipes.html) okuyabilirsiniz.
İşte "kek pişirmek" için kurgusal fonksiyonları kullanan karşılaştırma için sahte bir örnek. İlk olarak, tünel yöntemi:
```{r piping_example_pipe, eval=F}
# Tünel sözdizimi kullanarak kek pişirmenin sahte bir örneği
cake <- flour %>% # Kek pişirmek için önce undan başlanır, sonrasında...
add(eggs) %>% # yumurtaları ekle
add(oil) %>% # yağı ekle
add(water) %>% # suyu ekle
mix_together( # birlikte karıştır
utensil = spoon,
minutes = 2) %>%
bake(degrees = 350, # pişir
system = "fahrenheit",
minutes = 35) %>%
let_cool() # soğumaya bırak
```
İşte tünellerin kullanımını açıklayan başka bir [bağlantı](https://cfss.uchicago.edu/notes/pipes/#:~:text=Pipes%20are%20an%20extremely%20useful,code%20and%20combine%20multiple%20operations).
Tünelleme bir **temel** fonksiyon değildir. Tünelleri kullanmak için **magrittr** paketi kurulmalı ve yüklenmelidir (bu genellikle, onu içeren **tidyverse** veya **dplyr** paketi yüklenerek yapılır). [magrittr belgelerinde tünelleme hakkında daha fazla bilgi edinebilirsiniz](https://magrittr.tidyverse.org/).
Diğer R komutlarında olduğu gibi, tünellerin yalnızca sonucu görüntülemek veya "<-" atama operatörünün dahil olup olmadığına bağlı olarak bir nesneyi kaydetmek/yeniden kaydetmek için kullanılabileceğini unutmayın. Her ikisine de bakın:
```{r, eval=F}
# Yaş kategorisine göre toplam sayım olarak tanımlayarak nesne oluşturun veya üzerine yazın (yazdırılmaz)
linelist_summary <- linelist %>%
count(age_cat)
```
```{r}
# Konsoldaki sayım tablosunu yazdırın, ancak kaydetmeyin
linelist %>%
count(age_cat)
```
**`%<>%`**\
Bu, **magrittr** paketinden bir "atama tüneli"dir ve bu, bir nesneyi ileriye taşır ve aynı zamanda nesneyi yeniden tanımlar*. Zincirdeki ilk tünel operatörü olmalıdır. Kısa yol. Aşağıdaki iki komut eşdeğerdir:
```{r, eval=F}
linelist <- linelist %>%
filter(age > 50)
linelist %<>% filter(age > 50)
```
### Ara nesneleri tanımlayın {.unnumbered}
Nesneleri/veri çerçevelerini değiştirmeye yönelik bu yaklaşım, aşağıdaki durumlarda daha iyi olabilir:
- Birden çok nesneyi manipüle etmeniz gerekirse\
- Anlamlı olan ve ayrı nesne adlarını hak eden ara adımlar varsa
**Riskler:**
- Her adım için yeni nesneler oluşturmak, çok sayıda nesne oluşturmak anlamına gelir. Eğer yanlış olanı kullanırsan, bunu fark etmeyebilirsin!\
- Tüm nesneleri adlandırmak kafa karıştırıcı olabilir\
- Hatalar kolayca tespit edilemeyebilir
Her bir ara nesneyi adlandırın veya orijinalin üzerine yazın veya tüm fonksiyonları bir araya getirin. Hepsi kendi riskleriyle birlikte gelir.
Aşağıda, yukarıdakiyle aynı sahte "kek" örneği verilmiştir, ancak bu stili kullanarak:
```{r piping_example_redefine, eval=F}
# bu yöntemi kullanarak kek pişirmenin sahte bir örneği (ara nesneleri tanımlama)
batter_1 <- left_join(flour, eggs)
batter_2 <- left_join(batter_1, oil)
batter_3 <- left_join(batter_2, water)
batter_4 <- mix_together(object = batter_3, utensil = spoon, minutes = 2)
cake <- bake(batter_4, degrees = 350, system = "fahrenheit", minutes = 35)
cake <- let_cool(cake)
```
Tüm fonksiyonları bir araya getirin - bunu okumak zordur:
```{r eval=F}
# birden çok fonksiyonu bir araya getirme/iç içe yerleştirme örneği - okunması zordur
cake <- let_cool(bake(mix_together(batter_3, utensil = spoon, minutes = 2), degrees = 350, system = "fahrenheit", minutes = 35))
```
## Anahtar operatörler ve fonksiyonlar {#operators}
Bu bölüm, R'daki operatörleri detaylandırır, örneğin:
- Tanımsal operatörler\
- İlişkisel operatörler (küçüktür, eşittir çok ..)\
- Mantıksal operatörler (ve, veya...)\
- Eksik değerlerin işlenmesi\
- Matematiksel operatörler ve fonksiyonlar (+/-, \>, toplam(), medyan(), ...)\
- `%in%` operatörü
### Atama operatörleri {.unnumbered}
**`<-`**
R'daki temel atama operatörü `<-` şeklindedir. Öyle ki `nesne_adı <- değer`.\
Bu atama operatörü `=` şeklinde de yazılabilir. Genel R kullanımı için `<-` kullanılmasını tavsiye ederiz.\
Okunabilirlik için bu tür operatörleri boşluklarla çevrelemenizi de öneririz.
**`<<-`**
[Yazma fonksiyonlarını](writing_functions.tr.qmd) veya R'ı kaynaklı komut dosyalarıyla etkileşimli bir şekilde kullanıyorsanız, bu atama operatörünü `<<-` (**base** R'dan) kullanmanız gerekebilir. Bu operatör, daha yüksek bir 'ana' R Ortamında bir nesneyi tanımlamak için kullanılır. Bu [çevrimiçi referansa](https://stat.ethz.ch/R-manual/R-devel/library/base/html/assignOps.html) bakabilirsiniz.
**`%<>%`**
Bu, bir nesneyi ileriye yönlendiren ve *aynı zamanda nesneyi yeniden tanımlayan* **magrittr** paketinden bir "atama tünelidir". Zincirdeki ilk tünel operatörü olmalıdır. Aşağıda iki eşdeğer örnekte gösterildiği gibi kısa yoldur:
```{r, eval=F}
linelist <- linelist %>%
mutate(age_months = age_years * 12)
```
Yukarıdaki aşağıdakine eşdeğerdir.
```{r, eval=F}
linelist %<>% mutate(age_months = age_years * 12)
```
**`%<+%`**
Bu, **ggtree** paketi ile filogenetik ağaçlara veri eklemek için kullanılır. [Filogenetik ağaçlar](phylogenetic_trees.tr.qmd) sayfasına veya bu çevrimiçi [kaynak kitap](https://yulab-smu.top/treedata-book/) sayfasına bakabilirsiniz.
### İlişkisel ve mantıksal operatörler {.unnumbered}
İlişkisel operatörler değerleri karşılaştırır ve genellikle yeni değişkenleri ve veri kümelerinin alt kümelerini tanımlarken kullanılır. R'daki ortak ilişkisel operatörler şunlardır:
+--------------------------+------------+--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| Anlamı | Operatör | Örnek | Örnek Sonucu |
+==========================+============+==============+========================================================================================================================================================+
| Eşittir | `==` | `"A" == "a"` | `FALSE` (çünkü R büyük/küçük harf duyarlıdır) *== (çift eşittir) öğesinin = (tekli eşittir) fonksiyonundan farklı olduğuna ve bu atama operatörünün `<-`* gibi davrandığına dikkat edin |
+--------------------------+------------+--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| Eşit değildir | `!=` | `2 != 0` | `TRUE` |
+--------------------------+------------+--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| Büyüktür | `>` | `4 > 2` | `TRUE` |
+--------------------------+------------+--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| Küçüktür | `<` | `4 < 2` | `FALSE` |
+--------------------------+------------+--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| Büyük eşittir | `>=` | `6 >= 4` | `TRUE` |
+--------------------------+------------+--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| Küçük eşittir | `<=` | `6 <= 4` | `FALSE` |
+--------------------------+------------+--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| Değer eksiktir | `is.na()` | `is.na(7)` | `FALSE` [Kayıp Veri](missing_data.tr.qmd) sayfasına bakabilirsiniz) |
+--------------------------+------------+--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
| Değer tamdır | `!is.na()` | `!is.na(7)` | `TRUE` |
+--------------------------+------------+--------------+--------------------------------------------------------------------------------------------------------------------------------------------------------+
AND ve OR gibi mantıksal operatörler, genellikle ilişkisel operatörleri bağlamak ve daha karmaşık kriterler oluşturmak için kullanılır. Karmaşık ifadeler, gruplama ve uygulama sırası için parantez ( ) gerektirebilir.
+---------------------+-----------------------------------------------------------------------+
| Anlamı | Operator |
+=====================+=======================================================================+
| VE | `&` |
+---------------------+-----------------------------------------------------------------------+
| VEYA | `|` (dikey çizgi) |
+---------------------+-----------------------------------------------------------------------+
| Parantezler | `( )` Kriterleri birlikte gruplandırmak ve işlem sırasını netleştirmek için kullanılır |
+---------------------+-----------------------------------------------------------------------+
Örneğin, aşağıda vaka tanımımızı oluşturmak için kullanmak istediğimiz iki değişkenli bir satır listemiz var, `hep_e_rdt`, bir test sonucu ve hanede başka vakalar olup olmadığını bize bildirecek `other_cases_in_hh`. Aşağıdaki komut, yeni "case_def" değişkenini yaratmak için "case_when()" fonksiyonunu kullanır:
```{r eval=FALSE}
linelist_cleaned <- linelist %>%
mutate(case_def = case_when(
is.na(rdt_result) & is.na(other_case_in_home) ~ NA_character_,
rdt_result == "Positive" ~ "Confirmed",
rdt_result != "Positive" & other_cases_in_home == "Yes" ~ "Probable",
TRUE ~ "Suspected"
))
```
+------------------------------------------------------------------------------------------------+--------------------------------------------+
| Üstteki örneğin kriteri | Yeni "case_def" değişkeninde elde edilen değer |
+================================================================================================+============================================+
| "rdt_result" ve "other_cases_in_home" değişkenlerinin değeri eksik ise | `NA` (eksik) |
+------------------------------------------------------------------------------------------------+--------------------------------------------+
| "rdt_result" içindeki değer "Pozitif" ise | "Onaylanmış" |
+------------------------------------------------------------------------------------------------+--------------------------------------------+
| "rdt_result" içindeki değer "Pozitif" DEĞİLSE VE "other_cases_in_home" içindeki değer "Evet" ise | "Muhtemel" |
+------------------------------------------------------------------------------------------------+--------------------------------------------+
| Yukarıdaki kriterlerden biri karşılanmazsa | "Şüpheli" |
+------------------------------------------------------------------------------------------------+--------------------------------------------+
*R'ın büyük/küçük harf duyarlı olduğuna dikkat edin, bu nedenle "Pozitif", "pozitif"ten farklıdır...*
### Eksik değerler {.unnumbered}
R'da, eksik değerler "NA" ("ayrılmış" bir değer) özel değeriyle temsil edilir (büyük harfler N ve A - tırnak içinde değil). Eksik verileri başka bir şekilde kaydeden verileri içe aktarırsanız (ör. 99, "Eksik" veya .), bu değerleri "NA" olarak yeniden kodlamak isteyebilirsiniz. Bunun nasıl yapılacağı [İçe ve dışa aktar](importing.tr.qmd) sayfasında ele alınmaktadır.
**Bir değerin "NA" olup olmadığını test etmek için "DOĞRU" veya "YANLIŞ" döndüren özel "is.na()"** fonksiyonunu kullanın.
```{r basics_operators_missing}
rdt_result <- c("Positive", "Suspected", "Positive", NA) # biri şüpheli, biri bilinmeyen iki pozitif vaka
is.na(rdt_result) # rdt_result değerinin NA olup olmadığını test eder
```
[Eksik veri](missing_data.tr.qmd) sayfasındaki eksik, sonsuz, "NULL" ve imkansız değerler hakkında daha fazla bilgi edinin. [İçe ve dışa aktar](importing.tr.qmd) sayfasındaki verileri içe aktarırken eksik değerleri nasıl dönüştüreceğinizi öğrenin.
### Matematik ve istatistik {.unnumbered}
Bu sayfadaki tüm operatörler ve fonksiyonlar, **base** R kullanılarak otomatik olarak kullanılabilir.
#### Matematiksel operatörler {.unnumbered}
Bunlar genellikle toplama, bölme, yeni sütunlar vb. oluşturmak için kullanılır. Aşağıda R'daki yaygın matematiksel operatörler verilmiştir. Operatörlerin etrafına boşluk koyup koymamanız önemli değildir.
| Amaç | R'da Örneği |
|---------------------|--------------|
| Toplama | 2 + 3 |
| Çıkarma | 2 - 3 |
| Çarpma | 2 \* 3 |
| Bölme | 30 / 5 |
| Üstel | 2\^3 |
| Operasyon sırası | ( ) |
#### Matematiksel fonksiyonlar {.unnumbered}
| Amaç | Fonksiyon |
|--------------------|---------------------------------------|
| yuvarlama | round(x, digits = n) |
| yuvarlama | janitor::round_half_up(x, digits = n) |
| tavana yuvarlama | ceiling(x) |
| tabana yuvarlama | floor(x) |
| kesin değer | abs(x) |
| karekök | sqrt(x) |
| üstel | exponent(x) |
| doğal logaritma | log(x) |
| log 10 tabanlı | log10(x) |
| log 2 tabanlı | log2(x) |
Not: "round()" için "digits =", yerleştirilen ondalık sayıyı belirtir. Bir dizi anlamlı rakama yuvarlamak için `signif()` kullanın.
#### Bilimsel gösterim {.unnumbered}
Bilimsel gösterimin kullanılma olasılığı, "scipen" seçeneğinin değerine bağlıdır.
`?options` belgesinden: scipen, sayısal değerleri sabit veya üstel gösterimde yazdırmaya karar verirken uygulanacak bir cezadır. Pozitif değerler sabite ve negatif değerler bilimsel gösterime eğilimlidir: 'scipen' basamaklarından daha geniş olmadığı sürece sabit gösterim tercih edilecektir.
Düşük bir sayıya (örneğin 0) ayarlanırsa, her zaman "açık" olacaktır. R oturumunuzda bilimsel gösterimi "kapatmak" için çok yüksek bir sayıya ayarlayın, örneğin:
```{r, eval=F}
# bilimsel gösterimi kapat
options(scipen=999)
```
#### Yuvarlama {.unnumbered}
[***TEHLİKE:*** 'round()', yalnızca üst sayı çift ise 0,5'ten yuvarlayan "banker yuvarlaması"nı kullanır. Yarımları tutarlı bir şekilde en yakın tam sayıya yuvarlamak için **janitor** 'dan 'round_half_up()' kullanın. [Bu açıklamaya](https://cran.r-project.org/web/packages/janitor/vignettes/janitor.html#explore-records-with-duplicated-values-for-spec-combinations-of-variables- with-get_dupes) ]{style="color: red;"}
```{r}
# işiniz için uygun yuvarlama fonksiyonunu kullanın
round(c(2.5, 3.5))
janitor::round_half_up(c(2.5, 3.5))
```
#### İstatistiksel fonksiyonlar{.unnumbered}
[***DİKKAT:*** Aşağıdaki fonksiyonlar varsayılan olarak hesaplamalarda eksik değerleri içerecektir. "na.rm = TRUE" bağımsız değişkeni belirtilmedikçe, eksik değerler "YOK" çıktısıyla sonuçlanır. Bu, kısaca `na.rm = T` şeklinde yazılabilir.]{style="color: orange;"}
| Amaç | Fonksiyon |
|-------------------------|--------------------|
| Ortalama | mean(x, na.rm=T) |
| Ortanca | median(x, na.rm=T) |
| Standart Deviasyon | sd(x, na.rm=T) |
| dağılım\* | quantile(x, probs) |
| toplam | sum(x, na.rm=T) |
| minimum değer | min(x, na.rm=T) |
| maksimum değer | max(x, na.rm=T) |
| Numerik veri aralığı | range(x, na.rm=T) |
| özet\*\* | summary(x) |
Notlar:
- "*quantile()": "x" incelenecek sayısal vektördür ve "prob =" olasılıkları 0 ile 1.0 arasında olan sayısal bir vektördür, ör. "c(0.5, 0.8, 0.85)"
- `**summary()`: ortalama, medyan ve ortak yüzdelikler dahil olmak üzere sayısal bir vektörün özetini verir
[***TEHLİKE:*** Yukarıdaki fonksiyonlardan birine bir sayı vektörü sağlıyorsanız, sayıları `c()` içine sardığınızdan emin olun.]{style="color: red;"}
```{r}
# Bir fonksiyona ham sayılar veriliyorsa, bunları c() içine sarın
mean(1, 6, 12, 10, 5, 0) # !!! YANLIŞ !!!
mean(c(1, 6, 12, 10, 5, 0)) # DOĞRU
```
#### Diğer kullanışlı fonksiyonlar {.unnumbered}
+----------------------------+-------------------+-------------------------------------------------+
| Amaç | Fonksiyon | Örnek |
+============================+===================+=================================================+
| Bir seri oluştur | seq(from, to, by) | `seq(1, 10, 2)` |
+----------------------------+-------------------+-------------------------------------------------+
| x, n kere tekrar et | rep(x, ntimes) | `rep(1:3, 2)` or `rep(c("a", "b", "c"), 3)` |
+----------------------------+-------------------+-------------------------------------------------+
| sayısal bir vektörü alt bölümlere ayır | cut(x, n) | `cut(linelist$age, 5)` |
+----------------------------+-------------------+-------------------------------------------------+
| Rastgele örnek al | sample(x, size) | `sample(linelist$id, size = 5, replace = TRUE)` |
+----------------------------+-------------------+-------------------------------------------------+
### `%in%` {.unnumbered}
Değerleri eşleştirmek ve bir değerin bir vektör veya veri çerçevesi içinde olup olmadığını hızlı bir şekilde değerlendirmek için çok kullanışlı bir operatör.
```{r}
my_vector <- c("a", "b", "c", "d")
```
```{r}
"a" %in% my_vector
"h" %in% my_vector
```
Bir vektörün **%in%'inde olup olmadığını sormak için mantık ifadesinin **önüne** bir ünlem işareti (!) koyun:
```{r}
# inkar etmek, önüne ünlem işareti koymak
!"a" %in% my_vector
!"h" %in% my_vector
```
"%in%", **dplyr** fonksiyonu "case_while()" kullanılırken çok kullanışlıdır. Bir vektörü önceden tanımlayabilir ve daha sonra ona başvurabilirsiniz. Örneğin:
```{r eval=F}
affirmative <- c("1", "Yes", "YES", "yes", "y", "Y", "oui", "Oui", "Si")
linelist <- linelist %>%
mutate(child_hospitaled = case_when(
hospitalized %in% affirmative & age < 18 ~ "Hospitalized Child",
TRUE ~ "Not"))
```
Not: Belki **stringr**'den `str_detect()` kullanarak kısmi bir dize algılamak istiyorsanız, `c("1", "Yes", "yes", "y" gibi bir karakter vektörünü kabul etmeyecektir. ")`. Bunun yerine, "1\|Yes\|yes\|y" gibi VEYA çubukları olan bir yoğunlaştırılmış dize *normal ifade* verilmelidir. Örneğin, `str_detect(hospitalized, "1|Yes|yes|y")`. Daha fazla bilgi için [Karakterler ve dizeler](characters_strings.tr.qmd) hakkındaki sayfaya bakın.
Bu komutla bir karakter vektörünü adlandırılmış bir normal ifadeye dönüştürebilirsiniz:
```{r}
affirmative <- c("1", "Yes", "YES", "yes", "y", "Y", "oui", "Oui", "Si")
affirmative
# condense to
affirmative_str_search <- paste0(affirmative, collapse = "|") # Temel R ile yapılması seçeneği
affirmative_str_search <- str_c(affirmative, collapse = "|") # stringr paketi seçeneği
affirmative_str_search
```
## Hatalar ve uyarılar
Bu bölüm şunları açıklar:
- Hatalar ve uyarılar arasındaki fark\
- R kodu yazmak için genel sözdizimi ipuçları\
- Kod yardımcıları
Genel hatalar, uyarılar ve sorun giderme ipuçları [Hatalar ve yardım](errors.tr.qmd) sayfasında bulunabilir.
### Hata VS. Uyarı {.unnumbered}
Bir komut çalıştırıldığında, R Konsolu size kırmızı metinle uyarı veya hata mesajları gösterebilir.
- Bir **uyarı**, R'ın komutunuzu tamamladığı, ancak farkında olmanız gereken ek adımlar atması veya olağandışı çıktılar üretmesi gerektiği anlamına gelir.
- Bir **hata**, R'ın komutunuzu tamamlayamadığı anlamına gelir.
İpuçlarını ara:
- Hata/uyarı mesajı genellikle sorun için bir satır numarası içerir.
- Bir nesne "bilinmiyorsa" veya "bulunamadıysa", yanlış yazmış olabilirsiniz, library() ile bir paketi çağırmayı unutmuş veya değişiklik yaptıktan sonra betiğinizi yeniden çalıştırmayı unutmuş olabilirsiniz.
Her şey başarısız olursa, bazı anahtar terimlerle birlikte hata mesajını Google'a kopyalayın - büyük olasılıkla başka biri bunun üzerinde çalışmıştır!
### Genel sözdizimi ipuçları {.unnumbered}
Hataları ve uyarıları önlemek için R'da komut yazarken hatırlamanız gereken birkaç şey:
- Parantezleri her zaman kapatın - ipucu: Her kod öbeği için "(" ve kapanış parantezleri ")" sayısını sayın
- Sütun ve nesne adlarında boşluklardan kaçının. Bunun yerine alt çizgi ( \_ ) veya nokta ( . ) kullanın
- Bir fonksiyonun değişkenlerini virgülle ayırmayı unutmayın ve takip edin
- R büyük/küçük harf duyarlıdır, yani "Değişken_A", "değişken_A"dan *farklıdır*
### Kod yardımı {.unnumbered}
Herhangi bir komut dosyası (RMarkdown veya başka türlü), bir hata yaptığınızda ipucu verecektir. Örneğin, gereken yere virgül yazmayı veya bir parantez kapatmayı unuttuysanız, RStudio sizi uyarmak için betiğin sağ tarafında o satırda bir bayrak kaldıracaktır.