Introdução aos data.frames

Programação

Introdução

data.frames

O que são data.frames e que operações podemos fazer com eles.

Autores

Afiliações

João O. Santos

ISPA

Cristina Mendonça

ISPA; WJCR

Vitória Melita

FP-UL

Mariona Pascual Peñas

UIB

João Raposo

ISPA

Marta Barros

FP-UL

0 Introdução aos data.frames

Neste capítulo vamos focar-nos em explicar uma classe de variáveis muito importante no R—os data.frames. Vamos ver que podemos representar a maioria das nossas bases de dados usando estas estruturas. Compreender bem como trabalhar com data.frames é essencial para poder importar, limpar, (re)formatar e analisar os nossos dados.

Vectores

Já vimos que a função c() combina os seus argumentos num vector e que podemos usá-la para combinar tudo e mais alguma coisa.

idade <- c(21, 32, 24, 46, 33, 20, 50, 39, 18, 20)

genero <- c("M", "F", "M", "F", "F", "F", "M", "M", "F", "M")

rts <- c(1435, 4352, 2232, 2820, 4552, 6454, 6500, 1005, 9001, 2003)

Também já vimos que o R nos permite fazer muitas coisas com os vectores, desde seleccionar valores que ficam em posições específicas, a realizar a mesma operação matemática em todos os elementos, a operações de lógica.

idade[1]   # pedir o primeiro elemento.

[1] 21

idade[3:5] # pedir todos os elementos entre 3 e 5.

[1] 24 46 33

idade[-2]  # pedir todos os elementos excepto o segundo.

[1] 21 24 46 33 20 50 39 18 20

idade * 3  # multiplicar todos os elementos por 3.

 [1]  63  96  72 138  99  60 150 117  54  60

idade > 5  # ver quais os elementos maiores que 5.

 [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

idade[idade > 20]  # pedir os elementos com maior que 20.

[1] 21 32 24 46 33 50 39

Noções Gerais

Se repararmos nos exemplos anteriores vemos que cada vector, pode conter vários elementos mas só tem uma dimensão. No entanto, as bases de dados com que estamos habituados a trabalhar têm duas dimensões—linhas e colunas. Normalmente temos um variável por coluna e depois uma ou mais linhas por sujeito/observação.

Um vector só tem uma dimensão mas um data.frame já tem duas—linhas e colunas—portanto podemos usar um data.frame como base de dados. Na maioria, dos casos vamos importar os dados de um ficheiro e guardá-lo numa variável do tipo data.frame.

Antes de fazermos isso, vamos ver alguns exemplos mais simples, que nos podem ajudar a perceber como os conhecimentos que temos sobre vectores nos ajudam a trabalhar com os data.frames. Mais concretamente, vamos ver que no fundo podemos trabalhar com cada dimensão do data.frame como se fosse um vector.

Criar um `data.frame`

Para criarmos um data.frame usamos a função data.frame(), essa função leva como argumentos os nomes das colunas e os seus valores.

teste <- data.frame(coluna1 = c("valores", "da", "primeira", "coluna"),
                    coluna2 = c("valores", "diferentes", "na", "segunda"))

print(teste)

   coluna1    coluna2
1  valores    valores
2       da diferentes
3 primeira         na
4   coluna    segunda

Se cada vector é unidimensional, podemos combinar vários vectores num só data.frame—um objecto bidimensional. Podemos fazê-lo de várias maneiras. Um exemplo intuitivo pode ser um caso em que tenhamos vários vectores como os de há pouco, cada um com os valores duma dada variável, que queremos combinar numa base de dados.

dados <- data.frame(idade = idade, genero = as.factor(genero), rts = rts)
# as.factor(genero) vai guardar a variável género como factorial.

print(idade)

 [1] 21 32 24 46 33 20 50 39 18 20

print(genero)

 [1] "M" "F" "M" "F" "F" "F" "M" "M" "F" "M"

print(rts)

 [1] 1435 4352 2232 2820 4552 6454 6500 1005 9001 2003

print(dados)

   idade genero  rts
1     21      M 1435
2     32      F 4352
3     24      M 2232
4     46      F 2820
5     33      F 4552
6     20      F 6454
7     50      M 6500
8     39      M 1005
9     18      F 9001
10    20      M 2003

Aceder às Linhas dum `data.frame`

Da mesma maneira que para acedermos ao primeiro valor do vector idade escrevíamos:

idade[1]

[1] 21

Para aceder à primeira linha do data.frame dados (que criámos há pouco) basta escrevermos:

dados[1, ]

idade	genero	rts
21	M	1435

Se reparem, a única diferença é que agora acrescentámos uma vírgula. Temos de fazer isso porque separamos cada dimensão dos objectos com uma vírgula. Assim sendo, o primeiro valor à esquerda da vírgula corresponde à linha. Portanto se quisermos a segunda linha, escrevemos:

dados[2, ]

	idade	genero	rts
2	32	F	4352

Por outro lado, se quisermos todas as linhas menos a segunda, escrevemos:

dados[-2, ]

	idade	genero	rts
1	21	M	1435
3	24	M	2232
4	46	F	2820
5	33	F	4552
6	20	F	6454
7	50	M	6500
8	39	M	1005
9	18	F	9001
10	20	M	2003

Da mesma maneira que podíamos pedir uma sequência de valores dum vector usando a notação início:fim, por exemplo:

idade[3:5]

[1] 24 46 33

Também podemos pedir várias linhas, usando a mesma notação, por exemplo:

dados[3:5, ]

	idade	genero	rts
3	24	M	2232
4	46	F	2820
5	33	F	4552

No geral, vamos poder fazer tudo o que fazemos com os vectores, com as linhas dos data.frames.

idade * 3

 [1]  63  96  72 138  99  60 150 117  54  60

idade > 5

 [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

dados[1, ] * 3

idade	genero	rts
63	NA	4305

dados[1, ] > 5

  idade genero  rts
1  TRUE     NA TRUE

Nota: O R pode avisar-nos que algumas operações podem não fazer sentido para alguns tipos de variáveis (como foi o caso com o género), ou mesmo dar erro se a operação não for permitida.

Aceder às Colunas dum `data.frame`

Para trabalhar com as colunas dum data.frame podemos fazer tudo o que fazemos com as linhas, sendo que escrevemos o/s números da/s coluna/s à direita da vírgula.

dados[ ,1]

 [1] 21 32 24 46 33 20 50 39 18 20

dados[ ,2:3]

genero	rts
M	1435
F	4352
M	2232
F	2820
F	4552
F	6454
M	6500
M	1005
F	9001
M	2003

dados[ ,-2]

idade	rts
21	1435
32	4352
24	2232
46	2820
33	4552
20	6454
50	6500
39	1005
18	9001
20	2003

dados[ ,1] * 3

 [1]  63  96  72 138  99  60 150 117  54  60

dados[ ,1] > 5

 [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

Caso as colunas tenham nomes (como na maioria dos nossos casos) também podemos aceder às colunas usando o seu nome. Para isso podemos usar a notação base_de_dados$nome_da_coluna ou a notação base_de_dados[ ,"nome_da_coluna"].

Isso quer dizer que para vermos a coluna idade podemos escrever:

dados$idade

 [1] 21 32 24 46 33 20 50 39 18 20

# Ou

dados[ ,"idade"]

 [1] 21 32 24 46 33 20 50 39 18 20

Como podemos descobrir os nomes das colunas? Basta invocarmos a função colnames() usando o nosso data.frame como argumento.

colnames(dados)

[1] "idade"  "genero" "rts"

Já vimos que o data.frame dados tem duas dimensões—linhas e colunas. Também já vimos como podemos aceder às suas linhas e colunas. Pensando que cada coluna (e linha) só tem uma dimensão, percebemos que podemos colunas como argumentos de algumas funções, que já conhecemos que aceitam, vectores como argumentos.

Exemplos:

mean(dados$idade)

[1] 30.3

mean(dados$rts)

[1] 4035.4

sd(dados$rts)

[1] 2619.45

max(dados$rts)

[1] 9001

summary(dados$rts)

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
   1005    2060    3586    4035    5978    9001

table(dados$genero)


F M 
5 5

summary(dados$genero)

F M 
5 5

Ao mesmo tempo, se pensarmos que cada coluna pode corresponder a uma variável do nosso estudo, começamos a ter uma noção de como vamos poder usar as funções do R nas nossas análises estatísticas…

Nota: Os data.frame também podem ter nomes de linhas (que aparecem à esquerda como se fossem uma coluna extra sem nome) mas normalmente esses nomes não nos dão jeito.

print(dados)

   idade genero  rts
1     21      M 1435
2     32      F 4352
3     24      M 2232
4     46      F 2820
5     33      F 4552
6     20      F 6454
7     50      M 6500
8     39      M 1005
9     18      F 9001
10    20      M 2003

Às vezes podem corresponder ao número da linha, que por vezes é o número do participante. Mesmo nesses casos, dá-nos mais jeito ter os números dos participantes numa coluna do que nos nomes da linha.

Se quisermos saber os nomes das linhas podemos usar a função row.names().

row.names(dados)

 [1] "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10"

row.names(dados) <- paste0("new_name", row.names(dados))

row.names(dados)

 [1] "new_name1"  "new_name2"  "new_name3"  "new_name4"  "new_name5" 
 [6] "new_name6"  "new_name7"  "new_name8"  "new_name9"  "new_name10"

Se quisermos apagar esses nomes para não nos confundirem podemos escrever:

row.names(dados) <- NULL

row.names(dados)

 [1] "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10"

Quando apagamos os nomes das linhas eles são substituídos apenas pelos números das linas, logo não ganhamos nada em tentar apagar os nomes das linhas se eles forem apenas os seus números. nome à esquerda.

row.names(dados) <- NULL

row.names(dados)

 [1] "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10"

# Por muito que apague os nomes das linhas eles continuam a ser
# substituídos pelos números das linhas.
row.names(dados) <- NULL

row.names(dados)

 [1] "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10"

Aceder às Linhas e Colunas dum `data.frame`

Já vimos que os data.frame têm duas dimensões [linhas, colunas]. Então para termos só uma célula basta acedermos a uma linha uma coluna [linha, coluna].

# Primeira célula da primeira coluna.
dados[1, 1]

[1] 21

# Segunda célula da terceira coluna.
dados[2, 3]

[1] 4352

Podemos também aceder apenas a alguns “bocados”, isto é conjuntos de linhas e colunas do data.frame. Por exemplo, para obtermos as primeiras três linhas da primeira coluna, escrevemos:

dados[1:3, 1]

[1] 21 32 24

Se quisermos a primeira linha da duas primeiras colunas, escrevemos:

dados[1, 1:2]

idade	genero
21	M

Podemos também usar um vector com os nomes das colunas que queremos:

dados[1, c("idade", "genero")]

idade	genero
21	M

Nota: Reparem que se quisermos mais que pôr os nomes de várias colunas temos mesmo de os colocar num vector. Se separarmos os nomes por vírgulas, sem usar a função c() o R vai dar erro, dado que as vírgulas dentro dos parêntesis rectos (e fora de funções) separam dimensões do objecto e os data.frames só têm duas.

dados[1, "idade", "genero"]

Error in `drop && length(x) == 1L`:
! invalid 'x' type in 'x && y'

Explorar um `data.frame`

Como podemos explorar a nossa base de dados, por exemplo, para saber as suas dimensões, estrutura, ou mesmo visualizá-la?

Para descobrir o número de colunas usamos a função ncol(), para o número de linhas a função nrow(), para sabermos as dimensões (i.e., as linhas e colunas) usamos dim().

# número de colunas.
ncol(dados)

[1] 3

# número de linhas.
nrow(dados)

[1] 10

# Os dois.
dim(dados)

[1] 10  3

Para espreitarmos o topo ou o fim da nossa base de dados podemos usar as funções head() e tail() respectivamente.

head(dados)

idade	genero	rts
21	M	1435
32	F	4352
24	M	2232
46	F	2820
33	F	4552
20	F	6454

tail(dados)

	idade	genero	rts
5	33	F	4552
6	20	F	6454
7	50	M	6500
8	39	M	1005
9	18	F	9001
10	20	M	2003

Também podemos usar a função str() para perceber a sua estrutura.

str(dados)

'data.frame':   10 obs. of  3 variables:
 $ idade : num  21 32 24 46 33 20 50 39 18 20
 $ genero: Factor w/ 2 levels "F","M": 2 1 2 1 1 1 2 2 1 2
 $ rts   : num  1435 4352 2232 2820 4552 ...

Para visualizarmos a base de dados numa spreadsheet parecida com as do Libreoffice Calc ou Microsoft Excel podemos usar a função View().

View(dados)

Alterar, Criar e Apagar Linhas, Colunas e Células

Já explorámos várias formas de como podemos trabalhar com as nossas bases de dados, mas se reparem, ainda não vimos nenhuma forma de como as alterar. Se o R só permitisse seleccionar células, fazer operações com linhas e colunas, mas não permitisse alterar, apagar, e criar colunas, linhas, ou mesmo células individuais, teríamos de estar sempre a abrir o Libreoffice Calc, o Microsoft Excel ou outro programa para fazer essas operações. Assim não teríamos como usufruir das vantagens do R para esses procedimentos, por exemplo, não ficaríamos com um script que registasse e permitisse reproduzir o processo de limpeza dos dados.

Alterar Valores

Felizmente, podemos usar o que já aprendemos para fazer essas operações. Por exemplo, podemos fazer operações matemáticas com uma coluna, guardando o resultado nessa própria coluna, alterando assim o seu valor. Parece complicado, mas é daquelas operações que é muito fácil de ler no código apesar de ser difícil de explicar com linguagem natural.

Imaginem que tínhamos registado os tempos de resposta em milissegundos e queríamos convertê-los para segundos.

Sendo que um segundo são 1000 milissegundos, basta dividirmos os milissegundos por 1000 para obtermos os segundos.

dados$rts / 1000

 [1] 1.435 4.352 2.232 2.820 4.552 6.454 6.500 1.005 9.001 2.003

Mas como não guardámos o resultado em nenhuma variável continuamos a ter os tempos de resposta em milissegundos na base de dados.

dados$rts

 [1] 1435 4352 2232 2820 4552 6454 6500 1005 9001 2003

Mas se guardarmos o resultado da conversão na própria coluna alteramos o seu valor.

dados$rts <- dados$rts / 1000

print(dados)

   idade genero   rts
1     21      M 1.435
2     32      F 4.352
3     24      M 2.232
4     46      F 2.820
5     33      F 4.552
6     20      F 6.454
7     50      M 6.500
8     39      M 1.005
9     18      F 9.001
10    20      M 2.003

Podemos usar a mesma lógica para alterar um valor duma linha. Por exemplo, para alterar os dados do primeiro participante.

dados[1, ] <- c(31, "F", 3.521)

print(dados)

   idade genero   rts
1     31      F 3.521
2     32      F 4.352
3     24      M 2.232
4     46      F  2.82
5     33      F 4.552
6     20      F 6.454
7     50      M   6.5
8     39      M 1.005
9     18      F 9.001
10    20      M 2.003

O mesmo raciocínio ajuda-nos a perceber como podemos alterar os valores duma só célula. Para alterar a idade do terceiro participante poderíamos escrever:

dados[3, "idade"] <- 52

print(dados)

   idade genero   rts
1     31      F 3.521
2     32      F 4.352
3     52      M 2.232
4     46      F  2.82
5     33      F 4.552
6     20      F 6.454
7     50      M   6.5
8     39      M 1.005
9     18      F 9.001
10    20      M 2.003

Apagar Colunas

Para apagarmos colunas basta atribuirmos o valor muito especial de NULL a essa coluna.

AVISO: Como as outras operações que alteram valores das variáveis, esta operação é irreversível.

Para podermos experimentar usar estas operações e não perdermos dados que precisaremos para exemplos futuros, podemos começar por copiar a nossa base de dados para uma nova variável.

teste <- dados

print(teste)

   idade genero   rts
1     31      F 3.521
2     32      F 4.352
3     52      M 2.232
4     46      F  2.82
5     33      F 4.552
6     20      F 6.454
7     50      M   6.5
8     39      M 1.005
9     18      F 9.001
10    20      M 2.003

Agora que criámos a variável teste, podemos usá-la em algumas experiências.

Por exemplo podemos apagar a primeira coluna.

teste[ ,1] <- NULL

Agora podemos confirmar se a variável teste se mantém parecida com a dados, sendo que a variável dados vai ter mais uma coluna.

ncol(dados)

[1] 3

ncol(teste)

[1] 2

print(dados)

   idade genero   rts
1     31      F 3.521
2     32      F 4.352
3     52      M 2.232
4     46      F  2.82
5     33      F 4.552
6     20      F 6.454
7     50      M   6.5
8     39      M 1.005
9     18      F 9.001
10    20      M 2.003

print(teste)

   genero   rts
1       F 3.521
2       F 4.352
3       M 2.232
4       F  2.82
5       F 4.552
6       F 6.454
7       M   6.5
8       M 1.005
9       F 9.001
10      M 2.003

Nota: A variável teste continua a ter uma primeira coluna.

teste[ ,1]

 [1] F F M F F F M M F M
Levels: F M

Mas essa primeira coluna tem agora os valores que estavam na segunda, e a segunda tem os valores da terceira.

Também podemos apagar colunas usando os seus nomes.

teste$rts <- NULL

print(teste)

Apagar Linhas

Para apagarmos linhas não lhes podemos atribuir o valor de NULL como fizemos para as colunas. O que podemos fazer então?

Antes de avançarmos vamos voltar a copiar a nossa base de dados para a variável teste.

teste <- dados

print(teste)

   idade genero   rts
1     31      F 3.521
2     32      F 4.352
3     52      M 2.232
4     46      F  2.82
5     33      F 4.552
6     20      F 6.454
7     50      M   6.5
8     39      M 1.005
9     18      F 9.001
10    20      M 2.003

Como podemos então apagar linhas? Temos de fazer alguma batota e dizer que a nossa base de dados é igual a ela própria sem essas linhas. Por exemplo, para apagar a linha 1.

teste <- teste[-1, ]

# Apagar os nomes das linhas para evitar bugs com os números/nomes de cada
row.names(teste) <- NULL

Criar Linhas e Colunas

Para criar colunas basta usarmos a notação base_de_dados$nome_da_coluna usando um nome duma coluna que não existe.

Por exemplo:

teste$nova_coluna <- c(1, 2, 3, 4, 5, 6, 7, 8, 9)

Para criarmos uma nova linha (algo menos frequente no dia a dia), basta indicarmos um ou vários números de linha que não existem.

Sabendo que o data.frame teste tem nove linhas:

nrow(teste)

[1] 9

Podemos acrescentar uma décima escrevendo:

teste[10, ] <- c(24, "M", 3.005, 10)

print(teste)

   idade genero   rts nova_coluna
1     32      F 4.352           1
2     52      M 2.232           2
3     46      F  2.82           3
4     33      F 4.552           4
5     20      F 6.454           5
6     50      M   6.5           6
7     39      M 1.005           7
8     18      F 9.001           8
9     20      M 2.003           9
10    24      M 3.005          10

Nota: Reparem que se não soubermos o número de linhas podemos simplesmente escrever:

teste[nrow(teste) + 1, ] <- c(66, "F", 1.020, 11)

Mudar os Nomes das Colunas.

Já vimos que para apagar os nomes das linhas podíamos escrever:

row.names(teste) <- NULL

Da mesma forma, se quisermos apagar os nomes das colunas, podemos escrever:

colnames(teste) <- NULL

Se repararem as colunas do data.frame teste já não têm nome.

print(teste)

                
1  32 F 4.352  1
2  52 M 2.232  2
3  46 F  2.82  3
4  33 F 4.552  4
5  20 F 6.454  5
6  50 M   6.5  6
7  39 M 1.005  7
8  18 F 9.001  8
9  20 M 2.003  9
10 24 M 3.005 10
11 66 F  1.02 11

Na prática, isto não é algo que queiramos fazer dado que normalmente os nomes das colunas correspondem a nomes das nossas variáveis. O que pode ser mais frequente é querermos mudar os nomes das colunas para algo que nos faça mais sentido, que seja mais rápido de escrever, etc…

Para mudarmos os nomes das colunas podemos escrever:

colnames(teste) <- c("idade", "genero", "rts_seg", "participante")

Nota: Ás vezes podemos querer mudar o nome de apenas uma ou algumas colunas. Seria cansativo termos de escrever todos os nomes das colunas para mudar apenas um. Para além disso, o nome que queríamos mudar ficava facilmente perdido no meio dos outros não sendo fácil de perceber qual era o nome da coluna que estávamos a mudar. Por isso, no capítulo seguinte, veremos como mudar os nomes de apenas uma ou algumas colunas.

Juntar data.frames

Uma das vantagens do R, é podermos trabalhar facilmente com vários data.frames (mesmo que sejam bases de dados distintas) ao mesmo tempo.

Se tivermos dois data.frames com o mesmo número de linhas podemos juntá-los lado a lado. Para isso basta usarmos a função cbind().

Como o data.frame dados tem uma linha a menos que o teste não podemos usar a função cbind() sem primeiro apagar uma linha.

dim(dados)

[1] 10  3

dim(teste)

[1] 11  4

# Apaga a última linha do data.frame teste.
teste <- teste[-nrow(teste), ]

De seguida já podemos usar a função cbind() para combinar os data.frames.

cbind(dados, teste)

idade	genero	rts	idade	genero	rts_seg	participante
31	F	3.521	32	F	4.352	1
32	F	4.352	52	M	2.232	2
52	M	2.232	46	F	2.82	3
46	F	2.82	33	F	4.552	4
33	F	4.552	20	F	6.454	5
20	F	6.454	50	M	6.5	6
50	M	6.5	39	M	1.005	7
39	M	1.005	18	F	9.001	8
18	F	9.001	20	M	2.003	9
20	M	2.003	24	M	3.005	10

Se guardarmos o output dessa função numa nova variável ficamos com mais um data.frame.

combinado <- cbind(dados, teste)

print(combinado)

   idade genero   rts idade genero rts_seg participante
1     31      F 3.521    32      F   4.352            1
2     32      F 4.352    52      M   2.232            2
3     52      M 2.232    46      F    2.82            3
4     46      F  2.82    33      F   4.552            4
5     33      F 4.552    20      F   6.454            5
6     20      F 6.454    50      M     6.5            6
7     50      M   6.5    39      M   1.005            7
8     39      M 1.005    18      F   9.001            8
9     18      F 9.001    20      M   2.003            9
10    20      M 2.003    24      M   3.005           10

Se quisermos juntar data.frames que tenham as mesmas colunas (i.e., o mesmo número e o mesmo nome), podemos usar a função rbind(). A título de exemplo podemos invocar a função repetindo o mesmo data.frame para termos a certeza que tem as mesmas colunas.

rbind(dados, dados)

idade	genero	rts
31	F	3.521
32	F	4.352
52	M	2.232
46	F	2.82
33	F	4.552
20	F	6.454
50	M	6.5
39	M	1.005
18	F	9.001
20	M	2.003
31	F	3.521
32	F	4.352
52	M	2.232
46	F	2.82
33	F	4.552
20	F	6.454
50	M	6.5
39	M	1.005
18	F	9.001
20	M	2.003

Caso queiramos juntar data.frames lado a lado que tenham números de linhas diferentes, ou se quisermos juntar pelas linhas (i.e., rbind()) data.frames com colunas diferentes, teremos de seguir outras abordagens. O pacote dplyr traz funções que nos podem ajudar, mas deixaremos esses casos mais tarde.

Exercícios

Tentem resolver todos os problemas sem consultar as soluções.

Exercício 1

Crie uma variável do tipo data.frame com os seguintes dados.

coluna1	coluna2	coluna3
1	a	100
2	b	200
3	c	300
4	d	400
5	e	500

Aceda à primeira linha do data.frame que criou.
Aceda à terceira coluna.
Aceda à primeira célula da segunda coluna.
Aceda às linhas dois a quatro da primeira e segunda colunas.

Soluções

Clique para ver as soluções

dados <- data.frame(coluna1 = c(1, 2, 3, 4, 5),
                    coluna2 = c("a", "b", "c", "d", "e"),
                    coluna3 = c(100, 200, 300, 400, 500))

dados[1, ]

coluna1	coluna2	coluna3
1	a	100

dados[ , 3]

[1] 100 200 300 400 500

dados[1, 2]

[1] "a"

dados[2:4, 1:2]

	coluna1	coluna2
2	2	b
3	3	c
4	4	d

Exercício 2

Crie uma nova coluna chamada metade que guarde os resultados da divisão dos valores da coluna3 por dois.
Apague a coluna metade.
Crie uma cópia do data.frame que não inclua as duas primeiras linhas.
Apague a última linha dessa cópia do data.frame.

Soluções

Clique para ver as soluções

dados$metade <- dados$coluna3 / 2

dados$metade <- NULL

dados2 <- dados[-c(1:2), ]

dados2 <- dados2[-nrow(dados2), ]

Exercício 3

Quais os valores da coluna3 que são superiores a 100?
Seleccione apenas as linhas do data.frame dados cujos valores na coluna coluna1 são inferiores a 5.
Responda à alínea anterior sem usar o caractere $.
Seleccione os valores da coluna1 referentes a participantes com valores superiores a 200 na coluna3.
Dê novos nomes às colunas do data.frame.
Verifique se os nomes foram alterados.

Soluções

Clique para ver as soluções

dados$coluna3[dados$coluna3 > 100]

[1] 200 300 400 500

dados[dados$coluna1 < 5, ]

coluna1	coluna2	coluna3
1	a	100
2	b	200
3	c	300
4	d	400

dados[dados[ ,1] < 5, ]

coluna1	coluna2	coluna3
1	a	100
2	b	200
3	c	300
4	d	400

dados[dados$coluna3 > 200, "coluna1"]

[1] 3 4 5

colnames(dados) <- c("novo1", "novo2", "novo3")

print(colnames(dados))

[1] "novo1" "novo2" "novo3"

# head(dados), tail(dados), print(dados), ou View(dados) também dariam.

0 Introdução aos data.frames

Vectores

Noções Gerais

Criar um data.frame

Aceder às Linhas dum data.frame

Aceder às Colunas dum data.frame

Aceder às Linhas e Colunas dum data.frame

Explorar um data.frame

Alterar, Criar e Apagar Linhas, Colunas e Células

Alterar Valores

Apagar Colunas

Apagar Linhas

Criar Linhas e Colunas

Mudar os Nomes das Colunas.

Juntar data.frames

Exercícios

Exercício 1

Soluções

Exercício 2

Soluções

Exercício 3

Soluções

Criar um `data.frame`

Aceder às Linhas dum `data.frame`

Aceder às Colunas dum `data.frame`

Aceder às Linhas e Colunas dum `data.frame`

Explorar um `data.frame`