---
output:
  knitrBootstrap::bootstrap_document:
    title: "TESTE YAML"
    theme: Spacelab
    highlight: Zenburn
    theme.chooser: TRUE
    highlight.chooser: TRUE
    menu: FALSE
---

```{r setup, include=FALSE, purl=FALSE, eval=TRUE}
opts_chunk$set(
    ## knitr options
    cache = TRUE,
    tidy = FALSE,
    comment = NA,
    fig.width = 10,
    fig.height = 8,
    fig.align = "center",
    dpi = 80, ## aumentar o dpi para exibir maior.
    dev = "png",
    # fig.path = "figures/",
    ## knitrBootstrap package options (YAML)
    # bootstrap.title = "TESTE",
    # bootstrap.theme.chooser = TRUE,
    # bootstrap.highlight.chooser = TRUE,
    # bootstrap.theme = "Cosmo",
    # bootstrap.highlight = "Github",
    # bootstrap.menu = TRUE,
    custom.header = NULL,
    clean_supporting = TRUE,
    ## knitrBootstrap chunck options
    bootstrap.thumbnail = TRUE,
    bootstrap.thumbnail.size = "col-md-12",
    bootstrap.panel = TRUE,
    bootstrap.show.code = TRUE,
    bootstrap.show.output = FALSE,
    bootstrap.show.message = FALSE,
    bootstrap.show.warning = FALSE,
    bootstrap.show.error = FALSE,
    bootstrap.class = "row"
    )
```

<center>
<h1>
CE 083 - Estatística Computacional I
</h1>
<h6>
<a href="http://leg.ufpr.br/doku.php/disciplinas:ce083-2015-02">http://www.leg.ufpr.br/ce083</a>
</h6>
</center>

<br><br>
<p style="display: flex; justify-content: space-between; line-height: 0.75;">
<span>
<a href="http://www.ufpr.br/portalufpr/">Universidade Federal do Paraná</a>
</span>
<span>
<a href="http://www.leg.ufpr.br/~fernandomayer">Prof. Fernando de Pol Mayer</a>
</span>
<p style="display: flex; justify-content: space-between; line-height: 0.75;">
<span>
<a href="http://www.coordest.ufpr.br/">Curso de Graduação em Estatística</a>
</span>
<span>
<a href="http://www.leg.ufpr.br">Lab. de Estatística e Geoinformação - LEG</a>
</span>
<p style="display: flex; justify-content: flex-end; line-height: 0.75;">
<a href="http://www.est.ufpr.br">Departamento de Estatística - UFPR</a>
</p> 

<center>
<hr width="100%" size="3px">
</center>

# Sumário

Funções e objetos. Classes de objetos.

#### Autores e licença

Paulo Justiniano Ribeiro Jr., Fernando de Pol Mayer, Walmes Marques
Zeviani

<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licença Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a><br />Este obra está licenciado com uma Licença <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Atribuição-NãoComercial-CompartilhaIgual 4.0 Internacional</a>.


# Funções e argumentos

As funções no R são definidas como:

```{r eval=FALSE}
nome(argumento1, argumento2, ...)
```

Exemplo: função `runif()` (para gerar valores aleatórios de uma
distribuição uniforme):

```{r eval=FALSE}
runif(n, min = 0, max = 1)
```
```{r }
runif(10, 1, 100)
```

Argumentos que já possuem um valor especificado (como `max` e `min`)
podem ser omitidos:

```{r eval=FALSE}
runif(10)
```

Se os argumentos forem nomeados, a ordem deles dentro da função não tem
mais importância:

```{r eval=FALSE}
runif(min = 1, max = 100, n = 10)
```

Argumentos nomeados e não nomeados podem ser utilizados, desde que os
não nomeados estejam na posição correta:

```{r eval=FALSE}
runif(10, max = 100, min = 1)
```

### Outros tipos de argumentos

Exemplo: função `sample()`:

```{r eval=FALSE}
sample(x, size, replace = FALSE, prob = NULL)
```

- `x` e `size` devem ser obrigatoriamente especificados
- `replace` é lógico: `TRUE` (`T`) ou `FALSE` (`F`)
- `prob` é um argumento vazio ou ausente (“opcional”)

Exemplo: função `plot()`:

```{r eval=FALSE}
plot(x, y, ...)
```

- "`...`" permite especificar argumentos de outras funções (por exemplo
  `par()`)

# Mecanismos de ajuda

Argumentos e detalhes do funcionamento das funções:

```{r eval=FALSE}
?runif
```

ou

```{r eval=FALSE}
help(runif)
```

A documentação contém os campos:

- **Description:** breve descrição
- **Usage:** função e todos seus argumentos
- **Arguments:** lista descrevendo cada argumento
- **Details:** descrição detalhada
- **Value:** o que a função retorna
- **References:** bibliografia relacionada
- **See Also:** funções relacionadas
- **Examples:** exemplos práticos

Procura por funções que contenham `palavra`:

```{r eval=FALSE}
help.search("palavra")
```

Ajuda através do navegador (também contém manuais, ...):

```{r eval=FALSE}
help.start()
```

Busca por `palavra` nos arquivos da lista de discussão do R:

```{r eval=FALSE}
RSiteSearch("palavra")
```

# Criando uma função

A ideia original do R é transformar usuários em programadores

Criar funções para realizar trabalhos específicos é um dos grandes
poderes do R

Por exemplo, podemos criar a famosa função

```{r }
ola.mundo <- function(){
    writeLines("Olá mundo")
}
```

E chama-la através de

```{r }
ola.mundo()
```

A função acima não permite alterar o resultado de saída. Podemos fazer
isso incluindo um **argumento**

```{r }
ola.mundo <- function(texto){
    writeLines(texto)
}
```

E fazer por exemplo

```{r }
ola.mundo("Funções são legais")
```

(Veremos detalhes de funções mais adiante)

# Exercícios

- Usando a função `runif()` gere $30$ números aleatórios entre:
    - 0 e 1
    - -5 e 5
    - 10 e 500
    alternando a posição dos argumentos da função.
- Veja o help da função (?) `"+"`
- Crie uma função para fazer a soma de dois números: `x` e `y`

# Objetos

## Programação orientada a objetos

O que é um objeto?

- Um **símbolo** ou uma **variável** capaz de armazenar qualquer valor
  ou estrutura de dados

Por quê objetos?

- Uma maneira simples de acessar os dados armazenados na memória (o R
  não permite acesso direto à memória)

Programação:

- Objetos &nbsp; &rArr; &nbsp; Classes &nbsp; &rArr; &nbsp; Métodos

> “Tudo no R é um objeto.”
>
> “Todo objeto no R tem uma classe”

- **Classe:** é a definição de um objeto. Descreve a forma do objeto e
  como ele será manipulado pelas diferentes funções
- **Método:** são **funções genéricas** que executam suas tarefas de
  acordo com cada classe. As funções genéricas mais importantes são:
    - `summary()`
    - `plot()`

Veja o resultado de

```{r eval=FALSE}
methods(summary)
methods(plot)
```

A variável `x` recebe o valor $2$ (tornando-se um objeto dentro do R):

```{r }
x <- 2
```

> O símbolo `<-` é chamado de **operador de atribuição**. Ele serve para
> atribuir valores a objetos, e é formado pelos símbolos `<` e `-`,
> obrigatoriamente **sem espaços**.

Para ver o conteúdo do objeto:

```{r }
x
```

> **Observação**: O símbolo `=` pode ser usado no lugar de `<-` mas não
> é recomendado.

Quando você faz

```{r }
x <- 2
```

está fazendo uma **declaração**, ou seja, declarando que a variável `x`
irá agora se tornar um objeto que armazena o número `2`. As declarações
podem ser feitas uma em cada linha

```{r }
x <- 2
y <- 4
```

ou separadas por `;`

```{r }
x <- 2; y <- 4
```

Operações matemáticas em objetos:

```{r }
x + x
```

Objetos podem armazenar diferentes estruturas de dados:

```{r }
y <- runif(10)
y
```

Note que cada objeto só pode armazenar uma estrutura (um número ou uma
sequência de valores) de cada vez! (Aqui, o valor $4$ que estava
armazenado em `y` foi sobrescrito pelos valores acima.)

## Nomes de objetos

- Podem ser formados por letras, números, "`_`", e "`.`"
- Não podem começar com número e/ou ponto
- Não podem conter espaços
- Evite usar acentos
- Evite usar nomes de funções como:

> `c q t C D F I T diff df data var pt`

- O R é *case-sensitive*, portanto:

> `dados` $\neq$ `Dados` $\neq$ `DADOS`

# Gerenciando a área de trabalho (*workspace*)

Liste os objetos criados com a função `ls()`:

```{r eval=FALSE}
ls()
```

Para remover apenas um objeto:

```{r eval=FALSE}
rm(x)
```

Para remover outros objetos:

```{r eval=FALSE}
rm(x, y)
```

Para remover todos os objetos:

```{r eval=FALSE}
rm(list = ls())
```

> **Cuidado!** O comando acima apaga todos os objetos na sua área de
> trabalho sem perguntar. Depois só é possível recuperar os objetos ao
> rodar os script novamente.

# Exercícios

1. Armazene o resultado da equação $32 + 16^2 - 25^3$ no objeto `x`
2. Divida `x` por $345$ e armazene em `y`
3. Crie um objeto (com o nome que você quiser) para armazenar $30$
   valores aleatórios de uma distribuição uniforme entre $10$ e $50$
4. Remova o objeto `y`
5. Remova os demais objetos de uma única vez
6. Procure a função utilizada para gerar numeros aleatórios de uma
   distribuição de Poisson, e gere $100$ valores para a VA $X \sim
   \text{Poisson}(5)$.

# Classes de objetos

O R possui 5 classes básicas de objetos, também chamados de objetos
"atômicos":

- `character`
- `numeric`
- `integer`
- `complex`
- `logical`

> Um vetor só pode conter elementos de uma mesma classe

(A única excessão é a lista).

### Vetor

Características:

- Coleção ordenada de valores
- Estrutura unidimensional

Usando a função `c()` para criar vetores:

```{r }
num <- c(10, 5, 2, 4, 8, 9)
num
class(num)
```

Por que `numeric` e não `integer`?

```{r}
x <- c(10L, 5L, 2L, 4L, 8L, 9L)
x
class(x)
```

Para forçar a representação de um número para inteiro é necessário usar
o sufixo `L`.

Note que a diferença entre `numeric` e `integer` também possui impacto
computacional, pois o armazenamento de números inteiros ocupa menos
espaço na memória. Dessa forma, esperamos que o vetor `x` acima ocupe
menos espaço na memória do que o vetor `num`, embora sejam aparentemente
idênticos. Veja:

```{r}
object.size(num)
object.size(x)
```

A diferença pode parecer pequena, mas pode ter um grande impacto
computacional quando os vetores são formados por milhares ou milhões de
números.

#### Notas sobre representação numérica dentro do R

Os números que aparecem na tela do console do R são apenas
representações simplificadas do número real armazenado na memória. Por
exemplo,

```{r, echo = -1}
set.seed(123)
x <- runif(10)
x
```

O objeto `x` contém números como `r x[1]`, `r x[2]`, etc, que possuem 7
casas decimais, que é o padrão do R. O número de casas decimais é
controlado pelo argumento `digits` da função `options`. Para visualizar
essa opção, use

```{r}
getOption("digits")
```

Note que esse valor de 7 é o número de **dígitos significativos**, e
pode variar conforme a sequência de números. Por exemplo,

```{r, echo = -1}
set.seed(12)
y <- runif(10)
y
```

possui valores com 9 casas decimais. Isto é apenas a representação do
número que aparece na tela. Internamente, cada número é armazenado com
uma precisão de 22 casas decimais! Você pode ver o número com toda sua
precisão usando a função `print()` e especificando o número de casas
decimais com o argumento `digits` (de 1 a 22)

```{r}
print(x, digits = 1)
print(x, digits = 7) # padrão
print(x, digits = 22)
```

Também é possível alterar a representação na tela para o formato
científico, usando a função `format()`

```{r, echo = -1}
xf <- format(x, scientific = TRUE)
format(x, scientific = TRUE)
```

Nessa representação, o valor `r xf[1]` = $2.875775 \times 10^{-01}$ =
`r x[1]`.



#### Sequências de números

Usando a função `seq()`

```{r }
seq(1, 10)
```

Ou `1:10` gera o mesmo resultado. Para a sequência variar em $2$

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

Para obter $15$ valores entre $1$ e $10$

```{r }
seq(from = 1, to = 10, length.out = 15)
```

Usando a função `rep()`

```{r }
rep(1, 10)
```

Para gerar um sequência várias vezes

```{r }
rep(c(1, 2, 3), 5)
```

Para repetir um número da sequência várias vezes

```{r }
rep(c(1, 2, 3), each = 5)
```

#### Operações matemáticas em vetores

Operações podem ser feitas entre um vetor e um número:

```{r }
num * 2
```

E também entre vetores de mesmo comprimento ou com comprimentos
múltiplos:

```{r }
num * num
num + c(2, 4, 1)
```

#### A Regra da Reciclagem

![Regra da reciclagem](img/reciclagem.png)

Agora tente:

```{r eval=FALSE}
num + c(2, 4, 1, 3)
```

# Exercícios

1.  Crie um objeto com os valores 54, 0, 17, 94, 12.5, 2, 0.9, 15.
1.  Some o objeto acima com os valores 5, 6.

#### Atributos de objetos

Os objetos possuem **atributos**, que servem para descrever o formato
do objeto:

- `names`, `dimnames`
- `length`
- `dim`
- `class`

Classe:

```{r }
class(num)
```

Comprimento:
```{r }
length(num)
```

Vetores também podem ter outras classes:

- Vetor de caracteres:
```{r }
caracter <- c("brava", "joaquina", "armação")
caracter
```
- Vetor lógico:
```{r }
logico <- caracter == "armação"
logico
```
ou
```{r }
logico <- num > 4
logico
```

No exemplo anterior, a condição `num > 4` é uma **expressão
condicional**, e o símbolo `>` um **operador lógico**.  Os operadores
lógicos utilizados no R são:

  ------ -------------
   `<`   menor
   `<=`  menor igual
   `>`   maior
   `>=`  maior igual
   `==`  igual
   `!=`  diferente
   `&`   e
   `|`   ou
  ------ -------------

### Fator

Características:

- Coleção de categorias ou **níveis** (*levels*)
- Estrutura unidimensional

Utilizando as funções `factor()` e `c()`:

```{r }
fator <- factor(c("alta","baixa","baixa","media",
                  "alta","media","baixa","media","media"))
fator
class(fator)
```

Caso haja uma hierarquia, os níveis dos fatores podem ser ordenados:

```{r }
fator <- factor(c("alta","baixa","baixa","media",
                  "alta","media","baixa","media","media"),
                levels = c("alta","media","baixa"))
fator
```

# Exercícios

1. Construa um único objeto com as letras: `A`, `B`, e `C`, repetidas
   cada uma 15, 12, e 8 vezes, respectivamente.
2. Mostre na tela, em forma de verdadeiro ou falso, onde estão as letras
   `B` nesse objeto.
3. Veja a página de ajuda da função `sum()` e descubra como fazer para
   contar o número de letras `B` neste vetor (usando `sum()`). 
4. Crie um objeto com 100 valores aleatórios de uma distribuição uniforme
   $U(0,1)$. Conte quantas vezes aparecem valores maiores ou iguais a 0,5.

### Misturando classes de objetos

Algumas vezes isso acontece por acidente, mas também pode acontecer de
propósito.

O que acontece aqui?

```{r}
w <- c(5L, "a")
x <- c(1.7, "a")
y <- c(TRUE, 2)
z <- c("a", T)
```

Lembre-se da regra:

> Um vetor só pode conter elementos de uma mesma classe

Quando objetos de diferentes classes são misturados, ocorre a
**coerção**, para que cada elemento possua a mesma classe.

Nos exemplos acima, nós vemos o efeito da **coerção implícita**, quando
o R tenta representar todos os objetos de uma única forma.

Nós podemos forçar um objeto a mudar de classe, através da **coerção
explícita**, realizada pelas funções `as.*`:

```{r}
x <- 0:6
class(x)
as.numeric(x)
as.logical(x)
as.character(x)
as.factor(x)
```

De `?logical`:

     Logical vectors are coerced to integer vectors in contexts where a
     numerical value is required, with ‘TRUE’ being mapped to ‘1L’,
     ‘FALSE’ to ‘0L’ and ‘NA’ to ‘NA_integer_’.

```{r}
(x <- c(FALSE, TRUE))
class(x)
as.numeric(x)
```

Algumas vezes não é possível fazer a coerção, então:

```{r}
x <- c("a", "b", "c")
as.numeric(x)
as.logical(x)
```

## Valores perdidos e especiais

Valores perdidos devem ser definidos como `NA` (*not available*):

```{r }
perd <- c(3, 5, NA, 2)
perd
class(perd)
```

Podemos testar a presença de `NA`s com a função `is.na()`:

```{r }
is.na(perd)
```

Ou:

```{r }
any(is.na(perd))
```

Outros valores especiais são:

- `NaN` (*not a number*) - exemplo: `0/0`
- `-Inf` e `Inf` - exemplo: `1/0`

A função `is.na()` também testa a presença de `NaN`s:

```{r }
perd <- c(-1,0,1)/0
perd
is.na(perd)
```

A função `is.infinite()` testa se há valores infinitos

```{r }
is.infinite(perd)
```

### Matriz

Características:

- Podem conter apenas um tipo de informação (números, caracteres)
- Estrutura bidimensional

Utilizando a função `matrix()`:

```{r }
matriz <- matrix(1:12, nrow = 3, ncol = 4)
matriz
class(matriz)
```

Alterando a ordem de preenchimento da matriz (por linhas):

```{r }
matriz <- matrix(1:12, nrow = 3, ncol = 4, byrow = TRUE)
matriz
```

Para verificar a dimensão da matriz:

```{r }
dim(matriz)
```

Adicionando colunas com `cbind()`

```{r }
cbind(matriz, rep(99, 3))
```

Adicionando linhas com `rbind()`

```{r }
rbind(matriz, rep(99, 4))
```

Matrizes também podem ser criadas a partir de vetores adicionando um
atributo de dimensão

```{r}
m <- 1:10
m
class(m)
dim(m)
dim(m) <- c(2, 5)
m
class(m)
```

#### Operações matemáticas em matrizes

Matriz multiplicada por um escalar

```{r }
matriz * 2
```

Multiplicação de matrizes (observe as dimensões!)

```{r }
matriz2 <- matrix(1, nrow = 4, ncol = 3)
matriz %*% matriz2
```

### Lista

Características:

- Pode combinar uma coleção de objetos de diferentes classes (é um tipo
  especial de vetor)
- Estrutura “unidimensional”: apenas o número de elementos é contado

Utilizando a função `list()`:

```{r }
lista <- list(a = 1:10, b = c("T1", "T2", "T3", "T4"), TRUE, 2 + 2)
lista
class(lista)
dim(lista)
length(lista)
```

Formando uma lista com objetos criados anteriormente:

```{r }
lista <- list(fator = fator, matriz = matriz)
lista
length(lista)
```

### Data frame

Características:

- Uma lista de vetores e/ou fatores, de **mesmo comprimento**
- Pode conter diferentes tipos de dados (numérico, fator, ...)
- Estrutura bidimensional

Utilizando a função `data.frame()`:

```{r }
da <- data.frame(ano = 2000:2004,
                 prod = c(32, 54, 25, 48, 29))
da
class(da)
dim(da)
```

Data frames podem ser formados com objetos criados anteriormente, desde
que tenham o mesmo comprimento!

```{r }
length(num)
length(fator)
da <- data.frame(numerico = c(num, NA, NA, NA),
                        fator = fator)
da
class(da)
dim(da)
## Estrutura dos dados
str(da)
```

> A função `str()` é uma das que você precisa decorar!

Para converter um data frame para uma matriz

```{r}
as.matrix(da)
data.matrix(da)
```

Geralmente é o resultado de `data.matrix()` o qeu você está procurando.

> Note que os níveis de um fator são armazenados internamente como
> números: $1^\circ$ nível = 1, $2^\circ$ nível = 2, $\ldots$

## Nomes

Objetos do R podem ter nomes, que facilitam a auto-descrição

```{r}
x <- 1:3
names(x)
names(x) <- c("Curitiba", "Paraná", "Brasil")
x
names(x)
```

Listas também podem ter nomes

```{r}
x <- list(Curitiba = 1, Paraná = 2, Brasil = 3)
x
names(x)
```

Associando nomes às *linhas* e *colunas* de uma matriz:

```{r }
rownames(matriz) <- c("A","B","C")
colnames(matriz) <- c("T1","T2","T3","T4")
matriz
```

Para data frames existe uma função especial para os nomes de linhas,
`row.names()`. Data frames também não possuem nomes de colunas, apenas
nomes, já que é um caso particular de lista. Então para
verificar/alterar nomes de colunas de um data frame também use
`names()`.

```{r}
names(da)
row.names(da)
```

Um resumo das funções para alterar/acessar nomes de linhas e colunas em
matrizes e data frames.


 Classe      | Nomes de colunas | Nomes de linhas
------------ |------------------|---------------
`data.frame` | `names()`        | `row.names()`
`matrix`     | `colnames()`     | `rownames()`


# Exercícios

1.  Crie um objeto para armazenar a seguinte matriz
    $$\left[ \begin{array}{ccc}
            2 & 8 & 4 \\
            0 & 4 & 1 \\
            9 & 7 & 5
			\end{array} \right]$$
1. Atribua nomes para as linhas e colunas dessa matriz.
1. Crie uma lista com dois componentes: (1) um vetor com as letras `A`,
   `B`, e `C`, repetidas 2, 5, e 4 vezes respectivamente; (2) a matriz
   do exemplo anterior.
1. Atribua nomes para estes dois componentes da lista.
1. Inclua mais um componente nesta lista, com o nome de `fator`, e que
   seja um vetor da classe fator, idêntico ao objeto `caracter` criado
   acima (que possui apenas os nomes `brava`, `joaquina`, `armação`).
1. Você contou 42 caranguejos na Joaquina, 34 no Campeche, 59 na
   Armação, e 18 na Praia Mole. Crie um data frame para armazenar estas 
   informações (número de caranguejos observados e local).


<!-- Manipulação de dados -->

<!-- Indexação -->

<!-- \[fragile\]<span>Indexação de vetores</span> Crie um vetor para exemplo: -->

<!-- `         `\ -->

<!--     [1]  8  4 NA  9  6  1  7  9 -->

<!-- Para acessar o valor que está na posição 4, faça: -->

<!--     [1] 9 -->

<!-- \[fragile\]<span>Indexação de vetores</span> Para acessar os valores nas -->
<!-- posições 1, 4 e 8 é necessário o uso da função `c()`: -->

<!-- `  ` -->

<!--     [1] 8 9 9 -->

<!-- Ou: -->

<!-- `    `\ -->

<!--     [1] 8 9 9 -->

<!-- Para selecionar todos os valores, *excluindo* aqueles das posições 1, 4 -->
<!-- e 8: -->

<!-- `  ` -->

<!--     [1]  4 NA  6  1  7 -->

<!-- \[fragile\]<span>Indexação de vetores</span> Também é possível -->
<!-- selecionar uma sequência de elementos: -->

<!--     [1]  8  4 NA  9  6 -->

<!-- Para selecionar todos os elementos, menos os `NA`s: -->

<!--     [1] 8 4 9 6 1 7 9 -->

<!-- Para substituir os `NA`s por algum valor (*e.g.* 0): -->

<!-- `  `\ -->

<!--     [1] 8 4 0 9 6 1 7 9 -->

<!-- \[fragile\]<span>Indexação de matrizes</span> Crie uma matriz para -->
<!-- exemplo: -->

<!-- `   `\ -->

<!--          [,1] [,2] [,3] -->
<!--     [1,]    1    4    7 -->
<!--     [2,]    2    5    8 -->
<!--     [3,]    3    6    9 -->

<!-- Acesse o valor que está na linha 2 da coluna 3: -->

<!--     [1] 8 -->

<!-- \[fragile\]<span>Indexação de matrizes</span> Para acessar todas as -->
<!-- linhas da coluna 1: -->

<!--     [1] 1 2 3 -->

<!-- Para acessar todas as colunas da linha 1: -->

<!--     [1] 1 4 7 -->

<!-- Para acessar as linhas 1 e 3 das colunas 2 e 3: -->

<!-- ` ` -->

<!--          [,1] [,2] -->
<!--     [1,]    4    7 -->
<!--     [2,]    6    9 -->

<!-- \[fragile\]<span>Indexação de listas</span> Crie uma lista para exemplo: -->

<!-- `          `\ -->

<!--     $vetor1 -->
<!--     [1] 3 8 7 4 -->

<!--     $vetor2 -->
<!--     [1] 5 4 3 2 1 0 -->

<!-- Para acessar o segundo componente da lista: -->

<!--     [1] 5 4 3 2 1 0 -->

<!-- \[fragile\]<span>Indexação de listas</span> Para acessar o terceiro -->
<!-- valor do primeiro componente: -->

<!--     [1] 7 -->

<!-- Os componentes das listas também podem ser acessados com `$`: -->

<!--     [1] 5 4 3 2 1 0 -->

<!-- \[fragile\]<span>Indexação de data frames</span> Crie um data frame para -->
<!-- exemplo: -->

<!-- `       `\ -->

<!--       col1 col2 -->
<!--     1    4    2 -->
<!--     2    3   NA -->
<!--     3    2    5 -->
<!--     4    1    8 -->

<!-- Para acessar o segundo elemento da primeira coluna: -->

<!--     [1] 3 -->

<!-- \[fragile\]<span>Indexação de data frames</span> Acesse todas as linhas -->
<!-- da coluna 2: -->

<!--     [1]  2 NA  5  8 -->

<!-- Ou: -->

<!--     [1]  2 NA  5  8 -->

<!-- Todas as colunas da linha 1: -->

<!--       col1 col2 -->
<!--     1    4    2 -->

<!-- Ou: -->

<!--       col1 col2 -->
<!--     1    4    2 -->

<!-- \[fragile\]<span>Indexação de data frames</span> As colunas de um data -->
<!-- frame podem ser acessadas com `$`: -->

<!--     [1] 4 3 2 1 -->

<!-- Para acessar o terceiro elemento da coluna 2: -->

<!--     [1] 5 -->

<!-- Para acessar os elementos nas posições 2 e 4 da coluna 2: -->

<!--     [1] NA  8 -->

<!-- \[fragile\]<span>A função `with()`</span> Para evitar fazer muitas -->
<!-- indexações de um mesmo data frame, por exemplo, podemos utilizar a -->
<!-- função `with()` -->

<!--     [1] 4 3 2 1 -->

<!-- é o mesmo que -->

<!--     [1] 4 3 2 1 -->

<!-- Seleção condicional -->

<!-- \[fragile\]<span>Seleção condicional em vetores</span> -->

<!-- Crie o seguinte vetor: -->

<!-- `         ` -->

<!-- Selecione apenas os valores maiores do que 15: -->

<!-- `  ` -->

<!--     [1] 42 28 79 -->

<!-- Selecione os valores maiores que 15 **E** menores ou iguais a 35: -->

<!-- `      ` -->

<!--     [1] 28 -->

<!-- \[fragile\]<span>Seleção condicional em vetores</span> Para entender -->
<!-- como funciona a seleção condicional, observe apenas o resultado da -->
<!-- condição dentro do colchetes: -->

<!-- `      ` -->

<!--     [1] FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE -->

<!-- Os valores selecionados serão aqueles em que a condição for `TRUE`, -->
<!-- nesse caso apenas o quarto elemento do vetor `dados`. -->

<!-- \[fragile\]<span>Seleção condicional em data frames</span> Crie um data -->
<!-- frame: -->

<!-- `    `\ -->
<!-- `                      `\ -->
<!-- `                      ` -->

<!-- Extraia deste objeto apenas a linha correspondente ao ano 2004: -->

<!-- `  ` -->

<!--        ano captura porto -->
<!--     4 2004      26    SC -->

<!-- Mostre as linhas apenas do porto “SC”: -->

<!-- `  ` -->

<!--        ano captura porto -->
<!--     3 2003      28    SC -->
<!--     4 2004      26    SC -->

<!-- \[fragile\]<span>Seleção condicional em data frames</span> Observe as -->
<!-- linhas onde a captura seja maior que 20, selecionando apenas a coluna -->
<!-- `captura`: -->

<!-- `   ` -->

<!--     [1] 26 28 26 NA -->

<!-- Também exclua as linhas com `NA`s (agora com todas as colunas): -->

<!-- `   ` -->

<!--        ano captura porto -->
<!--     1 2001      26    SP -->
<!--     3 2003      28    SC -->
<!--     4 2004      26    SC -->

<!-- \[fragile\]<span>Seleção condicional em data frames</span> A condição -->
<!-- pode ser feita com diferentes colunas: -->

<!-- `      ` -->

<!--        ano captura porto -->
<!--     1 2001      26    SP -->

<!-- A função `subset()` serve para os mesmos propósitos: -->

<!-- `      ` -->

<!--        ano captura porto -->
<!--     1 2001      26    SP -->

<!-- \[fragile\]<span>Exercícios</span> -->

<!-- 1.  Com o vetor criado no exercício (1) da sessão anterior, mostre quais -->
<!--     são os valores nas posições 2, 5, e 7. -->

<!-- 2.  Com esse mesmo vetor, mostre todos os valores menos o zero. -->

<!-- 3.  Com o data frame criado no exercício (6) da sessão anterior, mostre -->
<!--     qual a praia onde foram coletadas menos de 30 plantas (usando -->
<!--     seleção condicional!). -->

<!-- 4.  Crie uma nova coluna (região) neste data frame indicando que -->
<!--     Joaquina e Praia Mole estão localizadas no leste da ilha (leste), e -->
<!--     Campeche e Armação estão no sul (sul). -->

<!-- 5.  Você está interessado em saber em qual das duas praias do sul, o -->
<!--     número de plantas coletadas foi maior do que 40. Usando a seleção -->
<!--     condicional, mostre essa informação na tela. -->

<!-- Finalizando o programa -->
<!-- ====================== -->

<!-- \[fragile\]<span>Finalizando o programa</span> O passo mais importante é -->
<!-- salvar seu **script**! No RStudio: -->

<!-- -   `File > Save As…` -->

<!-- -   Na janela que abrir, digite o nome do arquivo (por exemplo -->
<!--     `script_aula`) e salve -->

<!-- -   Automaticamente o script será salvo com a extensão `.R` (nesse caso -->
<!--     `script_aula.R`) no diretório de trabalho que você configurou no -->
<!--     início -->

<!-- \[fragile\]<span>Finalizando o programa</span> Alternativamente, você -->
<!-- pode também salvar toda sua área de trabalho, clicando em -->
<!-- `Workspace > Save As Default Workspace`. Este processo irá gerar dois -->
<!-- arquivos: -->

<!-- -   `.Rdata`: contém todos os objetos criados durante uma sessão. Não é -->
<!--     necessário (e nem recomendado) dar um nome antes do ponto. Dessa -->
<!--     forma, a próxima vez que o programa for iniciado neste diretório, a -->
<!--     área de trabalho será carregada automaticamente. -->

<!-- -   `.Rhistory`: um arquivo texto que contém todos os comandos que foram -->
<!--     digitados no console. -->

<!-- A qualquer momento durante uma sessão você pode usar o comando -->

<!-- para salvar a área de trabalho. **Note que o mais importante é salvar o -->
<!-- *script* que contém todos os comandos para gerar novamente os objetos.** -->


<center>
<hr width="100%" size="3px">
</center>


Última atualização: `r Sys.time()`
