Commit 581d4dd3 authored by Guilherme Hathy's avatar Guilherme Hathy

13/02

parent 088f51aa
---
title: "Capítulo 3 - Dados"
author: "Igor Horrocks"
date: "2016"
output: html_document
---
#Introdução
Este capítulo contém as diferentes e mais adequadas formas de entrar com dados no R.
## 3. Importação e exportação de dados
A entrada de dados pode ser feita de duas maneiras: diretamente no R ou, quando já foram digitados em outro programa, em arquivos texto.
Já a exportação de dados é comumente feita através de uma função.
### 3.1 Entrada de dados diretamente no R
#### 3.1.1 Entrada via Teclado
Para entrar com OS dados no R a paritr do teclado é necessário utilizar a função **scan()** . Para utilizar essa função basta digitar no script ou no console **scan()** e então precionar a tecla **enter**. Como consequência, o console estará diponível para digitar os dados. A cada número digitado pressione a tecla enter. Outra maneira é digitar os números separados por espaçoes em branco para então pressionar enter. Para encerrar a entrada de dados basta pressionar enter duas vezes seguidas
```{r}
# Exemplo 1 da função scan()
x <- scan()
x
```
```{r}
# Exemplo 2 da função scan()
y <- scan()
```
A função scan ta,bém pode interpretar elementos de outras classes, para isso deve-se digitar **scan(what = "character")**. Os outros argumentos para *what* são: logical, integer, numeric, complex, character, raw e list.
#### 3.1.2 Entrada na forma *strings*
A função utilizada para esse fim é a **readLines()**. Um dosargumentos dessa função é *n*, que serve para indicar o númro de linhas que serão digitados. Para melhor entendimento, segue o exemplo
* texto <- readLines(n = 1)
Estou digitando o texto no console ou no script
texto
### 3.2 Entrada de dados em arquivos texto
Este tipo de entrada é sempre utilizada quando os dados já foram digitados em qualquer outro programa. Para isso é necessário ver o formato que o arquivo a ser importado foi salvo. É mais fácil importar arquivos em formato de texto, por isso, é possível entrar no arquivo e selecionar *salvar como* e gravar os arquivos em formato de texto. Os dois prncipais formatos de texto são:
* txt: arquivo onde as colunas são separadas geralmente por uma tabulação(tab) ou espaço(tecla space)
* csv: arquivo onde as colunas são geralmente separadas por vírgula (comma separated value), ou ponto-e-vírgula.
#### 3.2.1 A função read.table()
Para importar os dados será necessário utilizar a função **read.table()**. Essa função possui os seguintes argumentos:
*"~/diretório do arqv/nomeArquivo.csv" ou "~/diretório do arqv/nomeArquivo.txt"
*header = TRUE ou FALSE: significa que a primeira linha do arquivo deve ser inrpretada ou não como os nomes das colunas
*sep = ";" ou "\t": comumente ";" é utilizado para arquivos .csv e "\t" para arquivos .txt
*dec = "," ou ".": o separador de decimais
```{r}
dados <- read.table("~/Diretórios R/Dados ce083/crabs.csv", header = T, sep = ";", dec = ".")
dados
```
##### OBSERVAÇÃO
* Quando houver colunas com caracteres, elas serão interpretadas como factor. Para alterar esse padrão acrescente o argumento stringAsFactors = FALSE
#### 3.2.2 O argumento clipboard para copiar e colar dados
Como o título do tópico menciona, o argumento clipboard é utilizado quando deseja-se usar a área de transferência (*Ctrl + c*) para serem lidos no R. A utilização desse argumento é da seguinte forma:
* dados.clip <- read.table("clipboard", header = TRUE, dec = ",")
#### 3.2.3 Carregando dados já disponíveis no R
Use o comando *ls()* para veficar os objetos criados na sua seção. Agora digite *data("trees")* e verifique novamente sua lista de objetos criados. Agora "trees" foi adicionado a essa lista, ou seja, o comando **data()** serve para importar arquivos já disponíveis no R.
### 3.3 Exportando dados do R
Assim como read.table() foi utilizada para importar, a função **write.table()** terá a função de exportar. Os argumentos de ambas as funções são muito semelhantes. A função write.table(), segue um padrão de criar arquivos com colunas separadas por espaço, o separador de decimal é ponto e os nomes das linhas são incluídos. Portanto, para exportar arquivos basta digitar
* write.table(women, file = "~/Diretórios R/Dados ce083/women.csv", row.names = FALSE,
sep = ";", dec = ",")
Os argumentos dessa função são
* women: Nome do conjunto de dados a ser exportado (também pode ser o nome da variável que armazena o conjunto de dados salvos)
* "women.csv": nome e formato do arquivo a ser gerado (neste caso na pasta "Dados ce083").
* row.names = FALSE: para eliminar o nome das linhas do objeto.
* sep = ";": o separador de colunas (também pode ser "/t" para arquivos .txt e "" para espaços)
* dec = ",": o separador de decimais
### 3.4 Lendo dados de uma URL
url <- 'http://www.leg.ufpr.br/~walmes/data/brasilCopa2014.txt'
* dados <- read.table(url, header = T, sep = '\t')
dados
#Importação e exportação de dados
......@@ -12,4 +12,5 @@
## Gráficos com o pacote Lattice
## Gráficos com o pacote ggplot2
\ No newline at end of file
## Gráficos com o pacote ggplot2
#Programação
##Estruturas de controle e repetição
##Estruturas de controle e repetição (loop)
##Criando funções
As instruções condicionais permitem ao programador explicitar diferentes alternativas a serem executadas dependendo de alguma condição a ser testada no conjunto de dados.
Assim como em outras linguagens de programação, no R é possível criar funções, que são muito úteis para executar um bloco de código que será repetido varias vezes, economizando linhas de códigos. A sintaxe para definir funções no R é:
As estruturas de controle mais usadas são:
```{r pressure, echo=TRUE}
Nome_funcao <- function(argumento1, argumento2, ... ){
Comandos
- `if` e `else`: Testa um condição e executa um bloco de código.
- `for`: Executa um loop em um numero fixo de vezes.
- `while`: Executa um loop _while_ se a condição for verdadeira (`TRUE`).
- `repeat`: Executa uma infinidade de loops.
- `break`: Para a execução do loop.
- `next`: Pula uma interação do loop.
- `ifelse`: Testa um condição e executa um bloco de código para `TRUE` e outro para `FAlSE`.
### `if`-`else`
O `if`-`else` permite testar uma condição e e agir de acordo com com a resposta da condicional (`TRUE` ou `FALSE`).
A sintaxe dos comandos `if` - `else`, deve seguir a seguinte ordem:
```r
if(<condicional>) {
## Caso a condicional seja verdadeira (TRUE).
}
else {
## Caso a condicional seja falsa (FALSE).
}
```
Pode-se fazer infinitas condicionais `if` utilizando o comando `else if`.
```r
if(<condicional1>) {
## Caso a condicional 1 seja verdadeira (TRUE).
} else if(<condicional2>) {
## Caso a condicional 2 seja verdadeira (TRUE).
} else {
## Caso todas as condicionais sejam falsas.
}
```
Um exemplo da estrutura `if`-`else`:
```{r,prompt=FALSE}
x <- 5
if(x > 3) {
print("É maior que 3.")
} else {
print("É menor ou igual a 3.")
}
```
### `for`
O comando `for` executa um bloco de códigos em um determinado objeto. Por exemplo:
```{r}
x <- c(1, 2, 3, 4, 5, 6, 7, 8)
for(i in x) {
i = i + 1
print(i)
}
```
O início do loop se dá com o comando `for` seguido de parênteses e chaves. A função `for()` recebe como argumentos um indicador que será usado durante o loop (i) e o vetorno qual sera aplicado o for.
O comando `for` pode ser utilizado dentro de outro comando `for`, como no seguinte exemplo:
```{r, echo= TRUE}
x <- runif(5, min = 0, max = 10)
x
for(i in x) {
i = i + 3
for(j in i) {
j = j + 1
print(j)
}
}
```
### `while`
O `while` começa com um teste condicional. Se ele for verdadeiro, o corpo do código é executado. Esse loop é executado até o condicional ser falso.
```{r}
contador <- 0
while(contador < 5) {
print(contador)
contador <- contador + 1
}
```
### `next` e `break`
A função `next` é usada para pular uma interação do loop.
```{r}
x <- 1:5
for (i in x) {
if (i == 3){
next
}
print(i)
}
```
Já a função `break` é usada para sair do loop.
```{r}
for(i in 1:100) {
print(i)
if(i > 4) {
## Para o loop após 5 interações.
break
}
}
```
### `repeat`
O `repeat` é um loop infinito sem condições pré-definidas para começar a ser executado. Com isso, é necessário a função `break()` parar a execução.
```{r}
contador <- 0
repeat{
print(contador)
contador <- contador + 1
if(contador > 4){
break
}
}
```
### `ifelse`
```{r}
x <- c(9, 2, 4, 8, 6)
# Retorna 0 para valores iguais ou maiores que 5 e 1 para menores que 5.
ifelse(x >= 5, 0 , 1)
```
##A família de funções apply()
**Nome_funcao**
### apply()
Para criar uma função é preciso primeiramente definir um nome seguido do comando *function()*, depois de pronta, a função será executada usando o nome que foi atribuido.
A função `apply()` aplica uma mesma função em todas as linhas ou colunas de um objeto, podendo ser uma matriz ou um data frame. A função `apply()` recebe como argumentos o conjunto de dados, em seguida deve informar se a função vai ser aplicada em cada linha ou em cada coluna, para aplicar em cada linha deve-se usar `1` e para coluna, usa-se `2` e por fim é necessário informar qual função sera aplicada..
```{r}
X = matrix(rnorm(200), ncol=20) # matriz com 20 colunas e 10 linhas
apply(X, 1, mean) # média por linha
apply(X, 2, mean) # média por coluna
```
### lapply()
A função `lapply()` é aplicada em cada elemento de um vetor ou em cada nó de uma lista. O seu resultado tambem é uma lista. A função `lapply()` recebe como argumentos um vetor ou lista e a função que será aplicada.
```{r}
x <- list(a = 1:10, beta = exp(-3:3), logic = c(TRUE,FALSE,FALSE,TRUE))
lapply(x, mean)
```
### sapply()
A função `sapply()` é muito parecida com a `lapply()`, a unica diferença é que seu resultado é um vetor ou uma matriz e não uma lista. A função `sapply()` recebe como argumentos um vetor ou lista e a função que será aplicada.
```{r}
x <- list(a = 1:10, beta = exp(-3:3), logic = c(TRUE,FALSE,FALSE,TRUE))
sapply(x, mean)
```
### tapply()
A função `tapply()` tem como objetivo aplicar funções em grupos diferentes. A função `tapply()` recebe como argumentos um vetor, um vetor com os fatores que irão estratificar o resultado e a função a ser aplicada em cada estrato.
```{r}
Altura = runif(20, min = 1.40, max = 1.95)
Sexo = sample(factor(c('Masculino', 'Feminino')), 20, rep=T)
tapply(Altura, Sexo, mean)
```
##A família de funções apply()
\ No newline at end of file
No preview for this file type
This diff is collapsed.
......@@ -124,4 +124,4 @@
}
#TOC ul {
font-size: 1.2rem;
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment