slide-intro-r-parte-ii.qmd

---
title: "Introdução ao R - Parte II"
subtitle: "Oficina de Introdução ao R"
author: "[R-Ladies São Paulo](https://www.meetup.com/rladies-sao-paulo/)"
date: "2023-06-24"
format: 
  rladies-revealjs:
    footer: "Slides feitos com [Quarto](https://quarto.org/docs/presentations/revealjs/index.html) e [Quarto R-Ladies Theme](https://github.com/beatrizmilz/quarto-rladies-theme#quarto-r-ladies-theme)."
incremental: false
knitr:
  opts_chunk: 
    fig.align: "center"
    echo: true
    eval: true
---

# Conceitos iniciais de programação

## Scripts

-   Podemos salvar nossos scripts para utilizar depois!

-   Considere tudo no console como temporário, pois não salvamos o conteúdo.

-   Escreva no Script/Editor os códigos importantes para a análise.

```{r echo=FALSE, out.width="100%"}
knitr::include_graphics("https://r4ds.hadley.nz/diagrams/rstudio-editor.png")
```

## R como uma calculadora

-   Podemos usar o R como uma calculadora:

```{r}
1 / 200 * 30
(59 + 73 + 2) / 3
```

## Executando códigos

-   O atalho `Cmd/Ctrl + Enter` é um dos mais úteis! Executa o código selecionado, ou o trecho de código onde o cursor está.

-   O atalho `Cmd/Ctrl + Shift + S` executa todos os códigos do script!

## Criando objetos

-   Podemos criar objetos (e guardar resultados) usando o operador de atribuição `<-`, e a estrutura a seguir:

````         
``` {{r}}
nome_do_objeto <- valor
```
````

Exemplo:

```{r}
x <- 3 * 4
```

Podemos ver o conteúdo do objeto escrevendo o nome e executando:

```{r}
x
```

## Boas práticas e objetos

-   Atalho `Alt -` (Alt e menos) serve para escrever o sinal de atribuição mais rápido.

-   O sinal `=` também funciona neste caso: porém como boa prática de escrita de código nós não usamos

-   Aproveite para usar a tecla Tab no RStudio: ajuda a autocompletar!

-   O R é *case sensitive*: ele diferencia letras maiúsculas e minúsculas.

```{r}
r_rocks <- 2 ^ 3
```

```{r eval=FALSE, include=TRUE}
r_rock
#> Error: object 'r_rock' not found
R_rocks
#> Error: object 'R_rocks' not found
r_rocks
#> [1] 8
```

## Boas práticas e objetos

-   Erros de digitação e de maiúscula/minúscula importam!

-   Cuidado ao dar nomes aos objetos:

```{r eval=FALSE, include=TRUE}
eu_uso_snake_case
outrasPessoasUsamCamelCase
algumas.pessoas.usam.pontos
E_Algumas.Pessoas_RENUNCIAMconvenções
```

## Entendendo melhor um objeto

Um objeto é onde nossos dados são armazenados dentro do R.

Um objeto sempre tem uma **classe** e um **tipo**

Geralmente chamamos de "valor" tudo o que está dentro de um objeto, PORÉM:

-   Valores não precisam ser números.
-   Eles podem ser texto, por exemplo.

```{r}
#| echo: true
pessoa <- "Bruna"
pessoa 
```

## As classes dos objetos

-   Os objetos podem conter dados de diferentes naturezas (um texto, um número, um booleano). **É o quê estamos armazenando. Principais:**

| CLASSE        | SINÔNIMO                                              |
|---------------|-------------------------------------------------------|
| **character** | texto, string, caractere                              |
| **integer**   | números inteiros                                      |
| **numeric**   | números racionais (número representado por uma fração |
| **logic**     | lógico, booleano, valor TRUE/FALSE                    |

## Exemplos de classes

```{r}
nome <- 'Rladies' # texto
nome
idade <- '40' # texto
idade
idade2 <- 40L # numero inteiro
idade2
passagem <- 4.40 # numero decimal
passagem
```

## Exemplos de classes

```{r}
sou_linda <- TRUE # booleano
sou_linda
```

## Exemplos de classes

DICA: a função `class()` mostra a classe de um objeto

```{r}
nome <- 'R-ladies SP'
class(nome)

passagem <- 4.40
class(passagem)
```

## Os tipos de objetos

É como armazenamos os dados dentro do R. Principais neste momento:

**Vector:** armazena elementos de mesma classe.

**Data.frame:** são tabelas de dados com linhas e colunas, como uma tabela do Excel. C ada coluna pode ser de classe diferente. Dentro de cada coluna, teremos sempre a mesma classe!

## NA

Uma característica importante do R que pode dicultar a comparação são os valores ausentes ou NAs (não disponíveis).

```{r}
NA > 10
```

```{r}
NA == NA
```

`is.na()` é a função que testa se um objeto é NA

## Operadores relacionais

| Operador | Descrição          |
|----------|--------------------|
| ==       | igual              |
| !=       | diferente          |
| \>       | maior              |
| \<       | menor              |
| \>=      | maior ou igual a   |
| \<=      | menor ou igual que |

## Operadores lógicos

| Operador | Descrição          |
|----------|--------------------|
| !        | significa NÃO      |
| &        | significa E        |
| `|`      | significa OU       |
| %in%     | significa "contém" |

## O que é uma função?

-   Função: uma palavra que, no código, dá um comando ao computador.
-   Ela é escrita seguida de parênteses.
-   Nos parênteses incluímos os argumentos.
-   O output vai ser a informação que o computador retorna após rodar a função.

(pense nela como um **verbo**!)

## Função no R

```{r}
#| echo: true
#| fig-width: 10
#| fig-height: 4.5
altura_carol <- 1.54
altura_lucas <- 1.89
altura_media <- mean(c(altura_carol, altura_lucas))
altura_media
```

<br>

-   mean = função para calcular a média
-   argumentos = informações que vão entre parênteses para indicar o que a função deve fazer
-   c() = para criar um vetor (uma lista com mais de um item a ser aplicado no cálculo)

## Utilizando funções

-   O R possui muitas funções disponíveis

-   Estrutura para utilizar uma função:

```{r eval=FALSE, include=TRUE}
nome_da_funcao(nome_do_argumento_1 = valor_para_o_argumento1,
               nome_do_argumento_2 = valor_para_o_argumento2,
               nome_do_argumento_3 = valor_para_o_argumento3,
               ...)
```

Exemplo:

```{r}
seq(from = 1, to = 10)
```

-   Parênteses (e aspas) sempre devem estar em "duplas": se abrirmos, temos que fechar.

## O que é um pacote de R?

-   Conjunto de funções úteis pra determinada análise.

-   Eles são disponibilizados em repositórios. Os dois principais repositórios são o [CRAN](https://cran.r-project.org/) e o [GitHub](https://github.com/).

-   Os pacotes são **instalados apenas uma vez** e devem **ser carregados sempre** que queremos utilizá-los.

## Instalar e carregar pacotes

-   Para instalar um pacote que está no CRAN, usamos a função install.packages:

``` r
install.packages("tidyverse")
```

-   Caso o pacote esteja no GitHub, é possível fazer a instalação via função install_github do pacote devtools:

``` r
install.packages("devtools")

devtools::install_github('rfsaldanha/microdatasus')
```

-   Para carregar o pacote usamos a função library:

``` r
library(tidyverse)
```

## Boas práticas (resumo)

**Nome de variáveis:**

a)  Não usar maiúscula, espaços ou acentos pra criar o nome
b)  Não começar o nome com um número
c)  Escolher nomes úteis e não redundantes

**Código e comentários:**

a)  Inserir espaços só após as vírgulas e parênteses
b)  Comente seu código (com a hashtag #)
c)  Use a quebra de linha para facilitar a leitura

## Erros mais comuns!

-   Rodar uma linha de código sem ter rodado as anteriores, que fazem parte de uma "sequência" de comandos para o programa

-   Pequenos erros de digitação ao escrever o código