Aula 14 – Curso de R – Criando objetos

toticavalcanti

Aula 14 – Curso de R – Criando objetos

Criando objetos no R

Antes, quero deixar meus links de afiliados pra vocês:

Se cadastrando, vocês poderão conhecer, usar e testar gratuitamente alguns recursos dos serviços oferecidos por eles.

Por favor, se gostarem do conteúdo dêem um joinha 👍, curtam e compartilhem a página do Código Fluente no Facebook.

Pinterest:
https://br.pinterest.com/codigofluente/

Endereço para baixar os arquivos e o script:

https://github.com/toticavalcanti/curso_r

Manipulando objetos

Criando objetos

É possível criar um objeto e especificar seu modo, tamanho, tipo, etc.

Essa abordagem é interessante na perspectiva de manipulação de objetos.

Pode-se, por exemplo, criar um objeto vazio e depois modificar seu elementos, o que é mais eficiente do que colocar todos os seus elementos com c().

Também pode ser muito conveniente criar objetos a partir de outros.

Por exemplo, se alguém quiser uma série de modelos, é simples colocar as fórmulas em uma lista e extrair os elementos sucessivamente para inseri-los na função lm().

A construção explícita de objetos fornece uma melhor compreensão de sua estrutura.

Vector

A função Vector, possui dois argumentos modo e tamanho, ela cria um vetor cujos elementos têm um valor, dependendo do modo especificado como argumento: 0 se numérico, FALSE se lógico ou “” se caractere.

As seguintes funções têm exatamente o mesmo efeito e, para um único argumento, o tamanho do vetor: numeric(), logical(), e character().


vector(mode = "logical", length = 4) 
[1] FALSE FALSE FALSE FALSE 
character(5) 
[1] "" "" "" "" "" 
logical(4) 
[1] FALSE FALSE FALSE FALSE 
numeric(4) 
[1] 0 0 0 0

Factor

Um Factor inclui não apenas os valores correspondente de uma variável categórica, mas também, os diferentes níveis possíveis dessa variável (mesmo que não estejam presentes nos dados).

A função Factor tem as seguintes opções:

factor(x, levels = sort(unique(x), na.last = TRUE), labels = levels, exclude = NA, ordered = is.ordered(x))

O x é um vetor de dados, geralmente usando um pequeno número de valores distintos, levels especifica os níveis possíveis do fator, um vetor opcional dos valores exclusivos (como cadeias de caracteres) que x pode ter recebido.

Os labels definem os nomes dos níveis, exclude exclui os valores de x a serem retirados dos levels e ordered é um argumento lógico que especifica se os níveis do fator são ordenados.


status <- c("Lo", "Hi", "Med", "Med", "Hi") 
ordered.status <- factor(status, levels=c("Lo", "Med", "Hi"), ordered=TRUE)
ordered.status
[1] Lo  Hi  Med Med Hi 
Levels: Lo < Med < Hi

Lembre-se de que x é do modo numérico ou caractere.

Mais exemplos de factor:


factor(1:3)
[1] 1 2 3
Levels: 1 2 3
#o 1:5 é a criação de um vetor de entrada [1, 2, 3, 4, 5]
factor(1:5, levels=1:3)
[1] 1    2    3    <NA> <NA>
Levels: 1 2 3
factor(1:3, labels=c("A", "B", "C"))
[1] A B C
Levels: A B C
factor(1:5, exclude=4)
[1] 1 2 3 NA 5
Levels: 1 2 3 5
#cria um vetor como entrada e atribui a data
data <- c("East","West","East","North","North","East","West","West","West","East","South")
factor_data <- factor(data)
[1] East  West  East  North North East  West  West  West  East  South
Levels: East North South West

A função levels extrai os níveis possíveis de um fator:


categories <- factor(c(2, 4), levels=2:5)
categories 
[1] 2 4
Levels: 2 3 4 5
levels(categories )
[1] "2" "3" "4" "5"

Matrix

Uma matriz é na verdade um vetor com um atributo adicional (dim) que é um vetor numérico com comprimento 2 e define os números de linhas e colunas da matriz.

Uma matriz pode ser criada com a função matrix().

matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)

A opção byrow indica se os valores fornecidos pelos dados devem preencher as colunas sucessivamente (o padrão) ou as linhas (se TRUE).

A opção dimnames permite dar nomes às linhas e colunas.


matrix(data=5, nr=2, nc=2)
     [,1] [,2]
[1,]    5    5
[2,]    5    5

matrix(1:6, 2, 3)
     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

matrix(1:6, 2, 3, byrow=TRUE)
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

# Define os nomes das colunas e das linhas.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")
p <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
p
     col1 col2 col3
row1    3    4    5
row2    6    7    8
row3    9   10   11
row4   12   13   14

Outra maneira de criar uma matriz é fornecer os valores apropriados para o atributo dim (que é inicialmente NULL):


x <- 1:15
x
[1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

dim(x)
NULL

dim(x) <- c(5, 3)
x
     [,1] [,2] [,3]
[1,]    1    6   11
[2,]    2    7   12
[3,]    3    8   13
[4,]    4    9   14
[5,]    5   10   15

Data frame

Vimos que um Data frame é criado implicitamente pelo função read.table, também é possível criar um Data frame com o função data.frame.

Os vetores incluídos no Data frame devem ter o mesmo tamanho.

Veja alguns exemplos:


x <- 1:4; n <- 10; M <- c(10, 35); y <- 2:4
data.frame(x, n)
  x  n
1 1 10
2 2 10
3 3 10
4 4 10

data.frame(x, M)
  x  M
1 1 10
2 2 35
3 3 10
4 4 35

x
[1] 1 2 3 4
n
[1] 10
data.frame(x, y)
Error in data.frame(x, y) : 
  arguments imply differing number of rows: 4, 3

Se um fator for incluído em um Data frame, ele deverá ter o mesmo comprimento que o(s) vetor(es).

É possível alterar os nomes das colunas com, por exemplo, data.frame (A1 = x, A2 = n).


data.frame (x, n)
  x  n
1 1 10
2 2 10
3 3 10
4 4 10

df <- data.frame (A1 = x, A2 = n)
df
  A1 A2
1  1 10
2  2 10
3  3 10
4  4 10

Também é possível atribuir nomes às linhas com a opção row.names, que devem ser, é claro, um vetor de caractere de modo e comprimento igual ao número de linhas do Data frame.


df <- data.frame (A1 = x, A2 = n, row.names = c("line 01", "line 02", "line 03", "line 04"))
df
        A1 A2
line 01  1 10
line 02  2 10
line 03  3 10
line 04  4 10

Por fim, observe que os Data frame tem um atributo dim semelhante às matrizes.


dim(df)
[1] 4 2

List

Um List é criado de maneira semelhante aos Data frames com a função list().

Não há restrições quanto aos objetos que podem ser incluídos.

Diferente do data.frame(), os nomes dos objetos não são usados por padrão, vamos utilizar os vetores x(1, 2, 3, 4) e y(2, 3, 4) do exemplo anterior:


L1 <- list(x, y); L2 <- list(A=x, B=y)
L1
[[1]]
[1] 1 2 3 4
[[2]]
[1] 2 3 4
L2
$A
[1] 1 2 3 4
$B
[1] 2 3 4

Time-series

A função ts() cria um objeto da classe “ts” a partir de um vetor (série temporal única) ou uma matriz (série temporal multivariada) e algumas opções que caracterizam a série.

As opções, com os valores padrão, são:

ts(data = NA, start = 1, end = numeric(0), frequency = 1, deltat = 1, ts.eps = getOption(“ts.eps”), class, names)

data – um vetor ou uma matriz.
start – o tempo inicial da primeira observação, um número ou um vetor de dois números inteiros (veja os exemplos abaixo).
end – o tempo da última observação especificada da mesma maneira do start.
frequency – o número de observações por unidade de tempo.
deltat – a fração do período de amostragem entre sucessivas observações (ex. 1/12 para dados mensais), apenas um frequency ou deltat deve ser dado.
ts.eps – tolerância para a comparação de séries. As frequências são consideradas iguais se a diferença for menor que ts.eps.
class – classe para dar ao objeto, o padrão é “ts” para série única e c(“mts”, “ts”) para uma série multivariada.
names – um vetor modo caracter, com os nomes das séries individuais e no caso de série multivariada, por padrão os nomes das colunas de dados, ou Série 1, Série 2, …

Alguns exemplos de séries temporais criadas com ts():


ts(1:10, start = 1959)
Time Series:
Start = 1959 
End = 1968 
Frequency = 1 
 [1]  1  2  3  4  5  6  7  8  9 10

ts(1:47, frequency = 12, start = c(1959, 2))
     Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
1959       1   2   3   4   5   6   7   8   9  10  11
1960  12  13  14  15  16  17  18  19  20  21  22  23
1961  24  25  26  27  28  29  30  31  32  33  34  35
1962  36  37  38  39  40  41  42  43  44  45  46  47

my.ts <- ts(1:12, start=c(2009, 1), end=c(2019, 12), frequency=12)
     Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
2009   1   2   3   4   5   6   7   8   9  10  11  12
2010   1   2   3   4   5   6   7   8   9  10  11  12
2011   1   2   3   4   5   6   7   8   9  10  11  12
2012   1   2   3   4   5   6   7   8   9  10  11  12
2013   1   2   3   4   5   6   7   8   9  10  11  12
2014   1   2   3   4   5   6   7   8   9  10  11  12
2015   1   2   3   4   5   6   7   8   9  10  11  12
2016   1   2   3   4   5   6   7   8   9  10  11  12
2017   1   2   3   4   5   6   7   8   9  10  11  12
2018   1   2   3   4   5   6   7   8   9  10  11  12
2019   1   2   3   4   5   6   7   8   9  10  11  12

Os valores de 4 e 12 em frequency são usados, por exemplo, para métodos de impressão de séries trimestral e mensal, respectivamente.

Então, usar frequency = 12 implica uma série mensal.

No start = 1959 é o ano e o 2 é o mês (February), o ponto inicial.


ts(1:10, frequency = 4, start = c(1959, 2))
     Qtr1 Qtr2 Qtr3 Qtr4
1959         1    2    3
1960    4    5    6    7
1961    8    9   10

Expression

Os objetos do modo Expression têm um papel fundamental em R.

Uma Expression é uma série de caracteres que faz sentido no R.

Todos os comandos válido são expressões.

Quando um comando é digitado no teclado, ele é avaliado pelo interpretador do R e executado se for válido.

Em muitas circunstâncias, é útil construir uma expressão sem avaliar ela, é para isso que a Expression é feita.

É possível avaliar a expressão posteriormente com eval().


 # Cria expressão de exemplo
x1 <- expression(3 * 5)
x1
expression(3 * 5)
eval(x1)
[1] 15
x <- 3; y <- 2.5; z <- 1
exp1 <- expression(x / (y + exp(z)))
exp1
expression(x/(y + exp(z)))
eval(exp1)
[1] 0.5749019

Expressões podem ser usadas, entre outras coisas, para incluir equações em gráficos.

Uma expressão pode ser criada a partir de uma variável de modo character.

Algumas funções tomam expressões como argumentos, por exemplo D que retorna derivadas parciais:


D(exp1, "x")
1/(y + exp(z))
D(exp1, "y")
-(x/(y + exp(z))^2)
D(exp1, "z")
-(x * exp(z)/(y + exp(z))^2)