Ferramentas do usuário
03_apostila:04-dados
Diferenças
Aqui você vê as diferenças entre duas revisões dessa página.
| Próxima revisão | Revisão anterior Próxima revisão Ambos lados da revisão seguinte | ||
|
03_apostila:04-dados [2020/08/12 06:04] 127.0.0.1 edição externa |
03_apostila:04-dados [2020/09/21 13:15] adalardo [Atributos de um Objeto de Dados] |
||
|---|---|---|---|
| Linha 1: | Linha 1: | ||
| <WRAP tabs> | <WRAP tabs> | ||
| - | * [[bie5782:02_tutoriais:tutorial3:start|Tutorial]] | + | * [[02_tutoriais:tutorial3:start|Tutorial]] |
| - | * [[bie5782:01_curso_atual:exercicios3| Exercícios]] | + | * [[01_curso_atual:exercicios3| Exercícios]] |
| - | * [[bie5782:03_apostila:04-dados| Apostila]] | + | * [[03_apostila:04-dados| Apostila]] |
| </WRAP> | </WRAP> | ||
| ====== 3. Leitura e Manipulação de Dados ====== | ====== 3. Leitura e Manipulação de Dados ====== | ||
| Linha 16: | Linha 16: | ||
| As funções de criação de vetores já foram detalhadas na [[03-funcoes#criando_vetores|seção anterior]]. Basta lembrar aqui que todas elas são usadas para entrar diretamente dados em vetores no R: | As funções de criação de vetores já foram detalhadas na [[03-funcoes#criando_vetores|seção anterior]]. Basta lembrar aqui que todas elas são usadas para entrar diretamente dados em vetores no R: | ||
| - | <code> | + | <code rsplus> |
| > meu.vetor <- c(10.5,11.3,12.4,5.7) | > meu.vetor <- c(10.5,11.3,12.4,5.7) | ||
| > meu.vetor | > meu.vetor | ||
| Linha 29: | Linha 29: | ||
| A função ''matrix'' cria uma matriz com os valores do argumento ''data''. O números de linhas e colunas são definidos pelos argumentos ''nrow'' e ''ncol'': | A função ''matrix'' cria uma matriz com os valores do argumento ''data''. O números de linhas e colunas são definidos pelos argumentos ''nrow'' e ''ncol'': | ||
| - | <code> | + | <code rsplus> |
| > minha.matriz <- matrix(data=1:12,nrow=3,ncol=4) | > minha.matriz <- matrix(data=1:12,nrow=3,ncol=4) | ||
| > minha.matriz | > minha.matriz | ||
| Linha 39: | Linha 39: | ||
| Como o //default// do argumento ''data'' é ''NA'', se ele é omitido o resultado é uma matriz vazia: | Como o //default// do argumento ''data'' é ''NA'', se ele é omitido o resultado é uma matriz vazia: | ||
| - | <code> | + | <code rsplus> |
| > matriz.vazia <- matrix(nrow=3,ncol=4) | > matriz.vazia <- matrix(nrow=3,ncol=4) | ||
| > matriz.vazia | > matriz.vazia | ||
| Linha 49: | Linha 49: | ||
| Também por //default//, os valores são preenchidos por coluna. Para preencher por linha basta o alterar o argumento ''byrow'' para ''TRUE'': | Também por //default//, os valores são preenchidos por coluna. Para preencher por linha basta o alterar o argumento ''byrow'' para ''TRUE'': | ||
| - | <code> | + | <code rsplus> |
| > minha.matriz <- matrix(data=1:12,nrow=3,ncol=4,byrow=T) | > minha.matriz <- matrix(data=1:12,nrow=3,ncol=4,byrow=T) | ||
| > minha.matriz | > minha.matriz | ||
| Linha 60: | Linha 60: | ||
| Se o argumento ''data'' tem menos elementos do que a matriz, eles são repetidos até preenchê-la: | Se o argumento ''data'' tem menos elementos do que a matriz, eles são repetidos até preenchê-la: | ||
| - | <code> | + | <code rsplus> |
| > elementos <- matrix(c("ar","água","terra","fogo","Leeloo"),ncol=4,nrow=4) | > elementos <- matrix(c("ar","água","terra","fogo","Leeloo"),ncol=4,nrow=4) | ||
| Warning message: | Warning message: | ||
| Linha 73: | Linha 73: | ||
| === Função ''data.frame()'' === | === Função ''data.frame()'' === | ||
| Com a função ''data.frame'' reunimos vetores de mesmo comprimento em um só objeto: | Com a função ''data.frame'' reunimos vetores de mesmo comprimento em um só objeto: | ||
| - | <code> | + | <code rsplus> |
| > nome <- c("Didi","Dedé","Mussum","Zacarias") | > nome <- c("Didi","Dedé","Mussum","Zacarias") | ||
| > ano.nasc <- c(1936,1936,1941,1934) | > ano.nasc <- c(1936,1936,1941,1934) | ||
| Linha 91: | Linha 91: | ||
| === Funçao ''edit()''=== | === Funçao ''edit()''=== | ||
| Esta função abre uma interface simples de edição de dados em formato planilha, e é útil para pequenas modificações. Mas para salvar as modificações atribua o resultado da função ''edit'' a um objeto: | Esta função abre uma interface simples de edição de dados em formato planilha, e é útil para pequenas modificações. Mas para salvar as modificações atribua o resultado da função ''edit'' a um objeto: | ||
| - | <code> | + | <code rsplus> |
| trapalhoes.2<-edit(trapalhoes) | trapalhoes.2<-edit(trapalhoes) | ||
| </code> | </code> | ||
| - | {{:bie5782:03_apostila:fetch_edit.png|}} | + | {{:03_apostila:fetch_edit.png|}} |
| Linha 107: | Linha 107: | ||
| Para criar um objeto com os dados do arquivo {{:dados:gbmam93.csv.pdf|gbmam93.csv (apagar extensão .pdf)}}, por exemplo, digitamos: | Para criar um objeto com os dados do arquivo {{:dados:gbmam93.csv.pdf|gbmam93.csv (apagar extensão .pdf)}}, por exemplo, digitamos: | ||
| - | <code> | + | <code rsplus> |
| > gbmam93 <- read.table(file="gbmam93.txt",header=T,row.names=1,sep=",") | > gbmam93 <- read.table(file="gbmam93.txt",header=T,row.names=1,sep=",") | ||
| > gbmam93 | > gbmam93 | ||
| Linha 134: | Linha 134: | ||
| === Conjuntos de Dados Distribuídos com os Pacotes do R === | === Conjuntos de Dados Distribuídos com os Pacotes do R === | ||
| Muitos pacotes do R incluem conjuntos de dados para exemplos, treinamento e verificação de análises. Se o pacote já está carregado (funções ''library'' ou ''require'') todos os seus objetos estão disponíveis, inclusive os objetos de dados. Incluindo as séries temporais de número de peles de linces caçados no Canadá, analisadas pelo ecólogo Charles Elton obtém-se: | Muitos pacotes do R incluem conjuntos de dados para exemplos, treinamento e verificação de análises. Se o pacote já está carregado (funções ''library'' ou ''require'') todos os seus objetos estão disponíveis, inclusive os objetos de dados. Incluindo as séries temporais de número de peles de linces caçados no Canadá, analisadas pelo ecólogo Charles Elton obtém-se: | ||
| - | <code> | + | <code rsplus> |
| > lynx | > lynx | ||
| Time Series: | Time Series: | ||
| Linha 152: | Linha 152: | ||
| Como qualquer objeto de um pacote, ''lynx'' tem um arquivo de ajuda, que é exibido com o comando ''help(lynx)'' ou ''?lynx'': | Como qualquer objeto de um pacote, ''lynx'' tem um arquivo de ajuda, que é exibido com o comando ''help(lynx)'' ou ''?lynx'': | ||
| - | <code> | + | <code rsplus> |
| lynx package:datasets R Documentation | lynx package:datasets R Documentation | ||
| Linha 186: | Linha 186: | ||
| A página de ajuda mostra que o objeto de dados ''lynx'' está no pacote ''datasets'' que contém uma grande quantidade de conjuntos de dados. Para ter mais informações, execute o comando: | A página de ajuda mostra que o objeto de dados ''lynx'' está no pacote ''datasets'' que contém uma grande quantidade de conjuntos de dados. Para ter mais informações, execute o comando: | ||
| - | <code> | + | <code rsplus> |
| help(datasets) | help(datasets) | ||
| </code> | </code> | ||
| Esse pacote faz parte da distribuição básica do R, e é carregado automaticamente quando se executa o R: | Esse pacote faz parte da distribuição básica do R, e é carregado automaticamente quando se executa o R: | ||
| - | <code> | + | <code rsplus> |
| > search() | > search() | ||
| [1] ".GlobalEnv" "package:stats" "package:graphics" | [1] ".GlobalEnv" "package:stats" "package:graphics" | ||
| Linha 199: | Linha 199: | ||
| Para fazer uma cópia de um objeto de dados de um pacote em sua área de trabalho, use a função ''data'': | Para fazer uma cópia de um objeto de dados de um pacote em sua área de trabalho, use a função ''data'': | ||
| - | <code> | + | <code rsplus> |
| > ls() | > ls() | ||
| [1] "gbmam93" "trapalhoes" "vetor.vazio" | [1] "gbmam93" "trapalhoes" "vetor.vazio" | ||
| Linha 295: | Linha 295: | ||
| ==== Atributos de um Objeto de Dados ==== | ==== Atributos de um Objeto de Dados ==== | ||
| - | Todo objeto no R tem dois atributos básicos, que são o tipo de dado que contém((em termos técnicos, trata-se do modo de armazenamento, e.g., apenas números, apenas caracteres, ou uma mistura, que é uma lista)) e o número de elementos que contêm. As funções ''mode'' e ''length'' retornam esses atributos: | + | Todo objeto no R tem dois atributos básicos, que são o tipo de dado((em termos técnicos, trata-se do modo de armazenamento, e.g., apenas números, apenas caracteres, ou uma mistura, que é uma lista)) e o número de elementos que contêm. As funções ''mode'' e ''length'' retornam esses atributos: |
| - | <code> | + | <code rsplus> |
| > pares | > pares | ||
| [1] 2 4 6 8 10 | [1] 2 4 6 8 10 | ||
| Linha 306: | Linha 306: | ||
| Objetos também podem ter uma ou mais classes. Um vetor numérico pode ser da classe dos inteiros ou da classe dos fatores. Um objeto da classe matriz pode ter dados do tipo numérico, lógicos((V= verdadeiro ou F = Falso)) ou caracteres. O comando ''class'' retorna a classe de um objeto: | Objetos também podem ter uma ou mais classes. Um vetor numérico pode ser da classe dos inteiros ou da classe dos fatores. Um objeto da classe matriz pode ter dados do tipo numérico, lógicos((V= verdadeiro ou F = Falso)) ou caracteres. O comando ''class'' retorna a classe de um objeto: | ||
| - | <code> | + | <code rsplus> |
| > matriz.letras | > matriz.letras | ||
| [,1] [,2] [,3] [,4] | [,1] [,2] [,3] [,4] | ||
| Linha 336: | Linha 336: | ||
| São um conjunto de elementos do mesmo tipo, como números ou caracteres. Há várias classes de vetores. Os vetores que temos trabalhado até agora são numéricos: | São um conjunto de elementos do mesmo tipo, como números ou caracteres. Há várias classes de vetores. Os vetores que temos trabalhado até agora são numéricos: | ||
| - | <code> | + | <code rsplus> |
| > class( a ) | > class( a ) | ||
| [1] "numeric" | [1] "numeric" | ||
| Linha 348: | Linha 348: | ||
| É possível ter no R um vetor tipo '''character''' formado por palavras ou frases: | É possível ter no R um vetor tipo '''character''' formado por palavras ou frases: | ||
| - | <code> | + | <code rsplus> |
| > sp = c( "Myrcia sulfiflora", "Syagrus romanzoffianus" , "Tabebuia cassinoides", "Myrcia sulfiflora" ) | > sp = c( "Myrcia sulfiflora", "Syagrus romanzoffianus" , "Tabebuia cassinoides", "Myrcia sulfiflora" ) | ||
| > mode( sp ) | > mode( sp ) | ||
| Linha 372: | Linha 372: | ||
| A função ''factor'' cria um fator, a partir de um vetor : | A função ''factor'' cria um fator, a partir de um vetor : | ||
| - | <code> | + | <code rsplus> |
| > sexo <- factor(rep(c("F","M"),each=9)) | > sexo <- factor(rep(c("F","M"),each=9)) | ||
| > sexo | > sexo | ||
| Linha 390: | Linha 390: | ||
| Note que fatores têm um atributo que especifica seu níveis ou categorias (''levels'') , que seguem ordem alfanumérica crescente, por //default//. Como essa ordem é importante para muitas análises, pode-se alterá-la com o argumento ''levels'', por exemplo para colocar o controle antes dos tratamentos: | Note que fatores têm um atributo que especifica seu níveis ou categorias (''levels'') , que seguem ordem alfanumérica crescente, por //default//. Como essa ordem é importante para muitas análises, pode-se alterá-la com o argumento ''levels'', por exemplo para colocar o controle antes dos tratamentos: | ||
| - | <code> | + | <code rsplus> |
| > tratamentos <- factor(rep(c("Controle","Adubo A","Adubo B"),each=4)) | > tratamentos <- factor(rep(c("Controle","Adubo A","Adubo B"),each=4)) | ||
| > tratamentos | > tratamentos | ||
| Linha 406: | Linha 406: | ||
| Há ainda a função ''levels'', que retorna os níveis de um fator: | Há ainda a função ''levels'', que retorna os níveis de um fator: | ||
| - | <code> | + | <code rsplus> |
| > tratamentos <- factor(rep(1:3,each=4)) | > tratamentos <- factor(rep(1:3,each=4)) | ||
| > tratamentos | > tratamentos | ||
| Linha 417: | Linha 417: | ||
| Fatores podem conter níveis não usados (vazios): | Fatores podem conter níveis não usados (vazios): | ||
| - | <code> | + | <code rsplus> |
| > politicos <- factor(rep("corrupto",10),levels=c("corrupto","honesto")) | > politicos <- factor(rep("corrupto",10),levels=c("corrupto","honesto")) | ||
| > politicos | > politicos | ||
| Linha 433: | Linha 433: | ||
| === A função ''tapply'' === | === A função ''tapply'' === | ||
| Para aplicar uma função aos subconjuntos de um vetor definidos por um fator use a função ''tapply'': | Para aplicar uma função aos subconjuntos de um vetor definidos por um fator use a função ''tapply'': | ||
| - | <code> | + | <code rsplus> |
| > pop.2007 | > pop.2007 | ||
| Feira de Santana Salvador São Paulo Niterói | Feira de Santana Salvador São Paulo Niterói | ||
| Linha 461: | Linha 461: | ||
| Os argumentos básicos são o vetor de valores (''X''), o fator que será usado para definir os subconjuntos (''INDEX''), e a função que será aplicada (''FUN''). É possível usar mais de um fator para definir os subconjuntos: | Os argumentos básicos são o vetor de valores (''X''), o fator que será usado para definir os subconjuntos (''INDEX''), e a função que será aplicada (''FUN''). É possível usar mais de um fator para definir os subconjuntos: | ||
| - | <code> | + | <code rsplus> |
| > sexo <- factor(rep(c("F","M"),each=9)) | > sexo <- factor(rep(c("F","M"),each=9)) | ||
| > dieta <- factor(rep(rep(c("normal","light","diet"),each=3),2), levels=c("normal","light","diet")) | > dieta <- factor(rep(rep(c("normal","light","diet"),each=3),2), levels=c("normal","light","diet")) | ||
| Linha 483: | Linha 483: | ||
| === A função ''table'' === | === A função ''table'' === | ||
| Para contar elementos em cada nível de um fator, use a função ''table'': | Para contar elementos em cada nível de um fator, use a função ''table'': | ||
| - | <code> | + | <code rsplus> |
| > table(politicos) | > table(politicos) | ||
| politicos | politicos | ||
| Linha 492: | Linha 492: | ||
| A função pode fazer tabulações cruzadas, gerando uma tabela de contingência((em termos técnicos, a função table retorna um "array" (veja abaixo) com o mesmo número de dimensões que os fatores fornecidos como argumentos)): | A função pode fazer tabulações cruzadas, gerando uma tabela de contingência((em termos técnicos, a função table retorna um "array" (veja abaixo) com o mesmo número de dimensões que os fatores fornecidos como argumentos)): | ||
| - | <code> | + | <code rsplus> |
| > table(sexo,dieta) | > table(sexo,dieta) | ||
| dieta | dieta | ||
| Linha 502: | Linha 502: | ||
| A função ''table'' trata cada valor de um vetor como um nível de um fator. Portanto, é útil também para contar a frequência de valores em vetores de números inteiros e de caracteres: | A função ''table'' trata cada valor de um vetor como um nível de um fator. Portanto, é útil também para contar a frequência de valores em vetores de números inteiros e de caracteres: | ||
| - | <code> | + | <code rsplus> |
| > x <- rep(1:5,each=10) | > x <- rep(1:5,each=10) | ||
| > class(x) | > class(x) | ||
| Linha 528: | Linha 528: | ||
| Uma lista é um objeto composto de vetores que podem ser diferentes classes e tamanhos, e podem ser criadas com o comando ''list'' | Uma lista é um objeto composto de vetores que podem ser diferentes classes e tamanhos, e podem ser criadas com o comando ''list'' | ||
| - | <code> | + | <code rsplus> |
| > minha.lista <- list(um.vetor=1:5, uma.matriz=matrix(1:6,2,3), um.dframe=data.frame(seculo=c("XIX","XX","XXI"),inicio=c(1801,1901,2001))) | > minha.lista <- list(um.vetor=1:5, uma.matriz=matrix(1:6,2,3), um.dframe=data.frame(seculo=c("XIX","XX","XXI"),inicio=c(1801,1901,2001))) | ||
| > minha.lista | > minha.lista | ||
| Linha 549: | Linha 549: | ||
| Nas palavras de Bill Venables, listas são como "varais" onde se pode pendurar qualquer outro objeto, inclusive outras listas, o que as torna **objetos recursivos**: | Nas palavras de Bill Venables, listas são como "varais" onde se pode pendurar qualquer outro objeto, inclusive outras listas, o que as torna **objetos recursivos**: | ||
| - | <code> | + | <code rsplus> |
| super.lista <- list(lista.velha=minha.lista, um.numero=1) | super.lista <- list(lista.velha=minha.lista, um.numero=1) | ||
| </code> | </code> | ||
| Alguns objetos têm como atributo o nome de seus elementos, como é o caso das listas. A função ''names'' retorna esses nomes: | Alguns objetos têm como atributo o nome de seus elementos, como é o caso das listas. A função ''names'' retorna esses nomes: | ||
| - | <code> | + | <code rsplus> |
| > names(minha.lista) | > names(minha.lista) | ||
| [1] "um.vetor" "uma.matriz" "um.dframe" | [1] "um.vetor" "uma.matriz" "um.dframe" | ||
| Linha 566: | Linha 566: | ||
| O operador ''$'' permite selecionar rapidamente um objeto de uma lista: | O operador ''$'' permite selecionar rapidamente um objeto de uma lista: | ||
| - | <code> | + | <code rsplus> |
| > minha.lista$um.vetor | > minha.lista$um.vetor | ||
| [1] 1 2 3 4 5 | [1] 1 2 3 4 5 | ||
| Linha 585: | Linha 585: | ||
| A tabela de dados (//data frame//) é um tipo especial de lista, composta por vetores de mesmo tamanho, mas que podem ser de classes diferentes: | A tabela de dados (//data frame//) é um tipo especial de lista, composta por vetores de mesmo tamanho, mas que podem ser de classes diferentes: | ||
| - | <code> | + | <code rsplus> |
| > names(trapalhoes) | > names(trapalhoes) | ||
| [1] "nomes" "ano.nasc" "vive" | [1] "nomes" "ano.nasc" "vive" | ||
| Linha 612: | Linha 612: | ||
| Esse operador também pode ser usado para criar novas variáveis (vetores) e acrescentá-las ao objeto. Para isso, basta acrescentar após o operador o nome da nova variável, e atribuir a ela um valor: | Esse operador também pode ser usado para criar novas variáveis (vetores) e acrescentá-las ao objeto. Para isso, basta acrescentar após o operador o nome da nova variável, e atribuir a ela um valor: | ||
| - | <code> | + | <code rsplus> |
| > trapalhoes$idade.2008 <- 2008 - trapalhoes$ano.nasc | > trapalhoes$idade.2008 <- 2008 - trapalhoes$ano.nasc | ||
| > trapalhoes | > trapalhoes | ||
| Linha 628: | Linha 628: | ||
| Como seu resultado é sempre um //data frame//, a função ''aggregate'' é mais adequada que ''tapply'' para fazer estatíticas de muitos casos por uma ou muitas combinações de critérios: | Como seu resultado é sempre um //data frame//, a função ''aggregate'' é mais adequada que ''tapply'' para fazer estatíticas de muitos casos por uma ou muitas combinações de critérios: | ||
| - | <code> | + | <code rsplus> |
| > carros.marcas | > carros.marcas | ||
| [1] Chevrolet Chevrolet Chevrolet Chevrolet Chevrolet Chevrolet Chevrolet | [1] Chevrolet Chevrolet Chevrolet Chevrolet Chevrolet Chevrolet Chevrolet | ||
| Linha 679: | Linha 679: | ||
| Matrizes são vetores cujos valores são referenciados por dois índices, o número da linha e o número da coluna. | Matrizes são vetores cujos valores são referenciados por dois índices, o número da linha e o número da coluna. | ||
| - | <code> | + | <code rsplus> |
| > my.matrix | > my.matrix | ||
| [,1] [,2] [,3] [,4] | [,1] [,2] [,3] [,4] | ||
| Linha 688: | Linha 688: | ||
| Os índices entre colchetes são a referência do par [linha,coluna]((a notação [,1] significa "todas as linhas da coluna 1", mais detalhes no ítem sobre indexação, mais abaixo)). Esses índices são exibidos quando as dimensões não têm nomes, que são controlados pelas funções ''rownames'' e ''colnames'': | Os índices entre colchetes são a referência do par [linha,coluna]((a notação [,1] significa "todas as linhas da coluna 1", mais detalhes no ítem sobre indexação, mais abaixo)). Esses índices são exibidos quando as dimensões não têm nomes, que são controlados pelas funções ''rownames'' e ''colnames'': | ||
| - | <code> | + | <code rsplus> |
| > rownames(my.matrix) <- c("R1","R2","R3") | > rownames(my.matrix) <- c("R1","R2","R3") | ||
| > colnames(my.matrix) <- c("C1","C2","C3","C4") | > colnames(my.matrix) <- c("C1","C2","C3","C4") | ||
| Linha 701: | Linha 701: | ||
| A função ''dimnames'' retorna uma lista com os nomes de cada dimensão de uma matriz | A função ''dimnames'' retorna uma lista com os nomes de cada dimensão de uma matriz | ||
| - | <code> | + | <code rsplus> |
| > dimnames(my.matrix) | > dimnames(my.matrix) | ||
| [[1]] | [[1]] | ||
| Linha 711: | Linha 711: | ||
| A função ''dim'' retorna o comprimento de cada dimensão de uma matriz, no caso três linhas e quatro colunas: | A função ''dim'' retorna o comprimento de cada dimensão de uma matriz, no caso três linhas e quatro colunas: | ||
| - | <code> | + | <code rsplus> |
| > dim(my.matrix) | > dim(my.matrix) | ||
| [1] 3 4 | [1] 3 4 | ||
| Linha 720: | Linha 720: | ||
| Para aplicar qualquer função a uma das dimensões de uma matriz, use a função ''apply'': | Para aplicar qualquer função a uma das dimensões de uma matriz, use a função ''apply'': | ||
| - | <code> | + | <code rsplus> |
| ##Soma dos valores de cada linha: | ##Soma dos valores de cada linha: | ||
| > apply(X=my.matrix,MARGIN=1,FUN=sum) | > apply(X=my.matrix,MARGIN=1,FUN=sum) | ||
| Linha 738: | Linha 738: | ||
| Todas as operações matriciais podem ser realizadas com as matrizes numéricas. O R possui funções para estas operações, como ''%*%'', para multiplicação, entre outras: | Todas as operações matriciais podem ser realizadas com as matrizes numéricas. O R possui funções para estas operações, como ''%*%'', para multiplicação, entre outras: | ||
| - | <code> | + | <code rsplus> |
| > m | > m | ||
| [,1] [,2] [,3] | [,1] [,2] [,3] | ||
| Linha 770: | Linha 770: | ||
| Os //arrays// são a generalização das matrizes para mais de duas dimensões. Um exemplo é o objeto ''Titanic'', com as seguintes dimensões: | Os //arrays// são a generalização das matrizes para mais de duas dimensões. Um exemplo é o objeto ''Titanic'', com as seguintes dimensões: | ||
| - | <code> | + | <code rsplus> |
| > dim(Titanic) | > dim(Titanic) | ||
| [1] 4 2 2 2 | [1] 4 2 2 2 | ||
| Linha 776: | Linha 776: | ||
| Com os seguintes nomes: | Com os seguintes nomes: | ||
| - | <code> | + | <code rsplus> |
| > dimnames(Titanic) | > dimnames(Titanic) | ||
| $Class | $Class | ||
| Linha 794: | Linha 794: | ||
| Todas as operações aplicáveis a matrizes também o são para //arrays//: | Todas as operações aplicáveis a matrizes também o são para //arrays//: | ||
| - | <code> | + | <code rsplus> |
| > adultos.por.sexo <- apply(Titanic, c(2, 4), sum) | > adultos.por.sexo <- apply(Titanic, c(2, 4), sum) | ||
| ##Mulheres primeiro? | ##Mulheres primeiro? | ||
| Linha 841: | Linha 841: | ||
| - Crie o seguinte objeto da classe matriz: | - Crie o seguinte objeto da classe matriz: | ||
| - | <code> | + | <code rsplus> |
| > minha.matriz <- matrix(seq(from=2,to=10,by=2),ncol=5,nrow=3,byrow=T) | > minha.matriz <- matrix(seq(from=2,to=10,by=2),ncol=5,nrow=3,byrow=T) | ||
| Linha 847: | Linha 847: | ||
| </code> | </code> | ||
| - Mude os nomes das linhas para "L1" a "L3" e das colunas para "C1" a "C5". **Dica**: A função ''paste'' pode poupar trabalho. | - Mude os nomes das linhas para "L1" a "L3" e das colunas para "C1" a "C5". **Dica**: A função ''paste'' pode poupar trabalho. | ||
| - | - O que acontece com a matriz após o comando:<code> > dim(minha.matriz) <- NULL</code> | + | - O que acontece com a matriz após o comando:<code rsplus> > dim(minha.matriz) <- NULL</code> |
| - Como reverter este resultado? | - Como reverter este resultado? | ||
| - Se você respondeu ao item anterior, percebeu que os nomes da matriz foram perdidos. Como restituí-los sem ter que refazer o passo 2? **Dica**: o resultado da função ''dimnames'' é uma lista com os nomes de cada dimensão. | - Se você respondeu ao item anterior, percebeu que os nomes da matriz foram perdidos. Como restituí-los sem ter que refazer o passo 2? **Dica**: o resultado da função ''dimnames'' é uma lista com os nomes de cada dimensão. | ||
| Linha 857: | Linha 857: | ||
| - A partir desse objeto, crie um novo //data frame// com o número de ordens, famílias, gêneros e espécies de insetos por tribo de planta. | - A partir desse objeto, crie um novo //data frame// com o número de ordens, famílias, gêneros e espécies de insetos por tribo de planta. | ||
| **DICA:** para calcular a riqueza, crie esta função, digitando o comando abaixo: | **DICA:** para calcular a riqueza, crie esta função, digitando o comando abaixo: | ||
| - | <code> riqueza <- function(x) { length(na.omit(unique(x))) } </code> | + | <code rsplus> riqueza <- function(x) { length(na.omit(unique(x))) } </code> |
| Detalhes sobre construção de funções estão no tópico [[.:programar_ale|"Noções de Programação em Linguagem S"]]. Por ora basta saber que essa função conta quantos elementos diferentes há num vetor, excluindo os valores faltantes, e.g.: | Detalhes sobre construção de funções estão no tópico [[.:programar_ale|"Noções de Programação em Linguagem S"]]. Por ora basta saber que essa função conta quantos elementos diferentes há num vetor, excluindo os valores faltantes, e.g.: | ||
| - | <code> | + | <code rsplus> |
| > letras <- rep( c(letters[1:3],NA), each=2) | > letras <- rep( c(letters[1:3],NA), each=2) | ||
| > letras | > letras | ||
| Linha 873: | Linha 873: | ||
| As matrizes de transição são uma maneira conveniente de modelar o crescimento de uma população dividida em faixas etárias, ou estágios de desenvolvimento. Para uma população de //Coryphanta robinsorum// (Cactaceae) no deserto do Arizona, divida em três estágios, a matriz de transição foi: | As matrizes de transição são uma maneira conveniente de modelar o crescimento de uma população dividida em faixas etárias, ou estágios de desenvolvimento. Para uma população de //Coryphanta robinsorum// (Cactaceae) no deserto do Arizona, divida em três estágios, a matriz de transição foi: | ||
| - | <code> | + | <code rsplus> |
| 0,43 0 0,56 | 0,43 0 0,56 | ||
| 0,33 0,61 0 | 0,33 0,61 0 | ||
| Linha 897: | Linha 897: | ||
| Para vetores do tipo '''character''' operações matemáticas não fazem sentido e retornam uma mensagem de erro e o valor ''NA'': | Para vetores do tipo '''character''' operações matemáticas não fazem sentido e retornam uma mensagem de erro e o valor ''NA'': | ||
| - | <code> | + | <code rsplus> |
| > mean( sp ) | > mean( sp ) | ||
| [1] NA | [1] NA | ||
| Linha 906: | Linha 906: | ||
| Mas existem algumas operações que são próprias desse tipo de vetores: | Mas existem algumas operações que são próprias desse tipo de vetores: | ||
| - | <code> | + | <code rsplus> |
| > sort( sp ) | > sort( sp ) | ||
| [1] "Myrcia sulfiflora" "Myrcia sulfiflora" "Syagrus romanzoffianus" | [1] "Myrcia sulfiflora" "Myrcia sulfiflora" "Syagrus romanzoffianus" | ||
| Linha 919: | Linha 919: | ||
| 2 1 1 | 2 1 1 | ||
| </code> | </code> | ||
| - | <code> | + | <code rsplus> |
| > bicho <- c("pato","gato","boi") | > bicho <- c("pato","gato","boi") | ||
| Linha 935: | Linha 935: | ||
| Algumas operações são válidas para qualquer tipo de vetor. Essas operações envolvem comparações e são chamadas de operações lógicas: | Algumas operações são válidas para qualquer tipo de vetor. Essas operações envolvem comparações e são chamadas de operações lógicas: | ||
| - | <code> | + | <code rsplus> |
| > "Tabebuia cassinoides" == sp | > "Tabebuia cassinoides" == sp | ||
| [1] FALSE FALSE TRUE FALSE | [1] FALSE FALSE TRUE FALSE | ||
| Linha 956: | Linha 956: | ||
| Como o R é um **ambiente vetorial** o resultado de operações lógicas também podem ser guardadas em vetores. Assim, surgem os vetores de classe '''logical''': | Como o R é um **ambiente vetorial** o resultado de operações lógicas também podem ser guardadas em vetores. Assim, surgem os vetores de classe '''logical''': | ||
| - | <code> | + | <code rsplus> |
| > b | > b | ||
| [1] 1 2 3 4 5 6 7 8 | [1] 1 2 3 4 5 6 7 8 | ||
| Linha 972: | Linha 972: | ||
| O indicador de valor faltante (//"missing values//) no R é ''NA'', e o de valores não-numéricos (em geral resultantes de operações que não têm um valor definido) é ''NaN''. A operação lógica para testar esses valores é feita com a função ''is.na'', e não com os operadores ''=='' ou ''!='' | O indicador de valor faltante (//"missing values//) no R é ''NA'', e o de valores não-numéricos (em geral resultantes de operações que não têm um valor definido) é ''NaN''. A operação lógica para testar esses valores é feita com a função ''is.na'', e não com os operadores ''=='' ou ''!='' | ||
| - | <code> | + | <code rsplus> |
| > a <- seq(-100,100,50) | > a <- seq(-100,100,50) | ||
| > a | > a | ||
| Linha 993: | Linha 993: | ||
| <box 90% center red> | <box 90% center red> | ||
| **Operadores Lógicos no R** ((Incluímos aqui a função ''is.na'' para lembrar que para testar a ocorrência de valores faltantes ou não numéricos (Na e NaN) ela deve ser usada, e não os operadores ''=='' ou ''!='')) | **Operadores Lógicos no R** ((Incluímos aqui a função ''is.na'' para lembrar que para testar a ocorrência de valores faltantes ou não numéricos (Na e NaN) ela deve ser usada, e não os operadores ''=='' ou ''!='')) | ||
| - | <code> | + | <code rsplus> |
| ========================================= | ========================================= | ||
| OPERADOR DESCRIÇÃO | OPERADOR DESCRIÇÃO | ||
| Linha 1022: | Linha 1022: | ||
| Já tratamos dos sinais de atribuição no item sobre [[02-entrada#Criação de Objetos: Atribuição|criação de objetos]] da seção de Introdução ao R, onde vimos que um dos sinais de atribuição é um sinal de igual (**=**): | Já tratamos dos sinais de atribuição no item sobre [[02-entrada#Criação de Objetos: Atribuição|criação de objetos]] da seção de Introdução ao R, onde vimos que um dos sinais de atribuição é um sinal de igual (**=**): | ||
| - | <code> | + | <code rsplus> |
| > a = log(2) | > a = log(2) | ||
| > a | > a | ||
| Linha 1032: | Linha 1032: | ||
| O sinal de igualdade faz uma comparação entre dois elementos. No R o sinal de igualdade são dois sinais de igual seguidos (**==**). Este operador retorna o resultado do teste lógico //"a igual b?"//, que só pode ter dois valores, ''T'' (verdadeiro), ou ''F'' (falso): | O sinal de igualdade faz uma comparação entre dois elementos. No R o sinal de igualdade são dois sinais de igual seguidos (**==**). Este operador retorna o resultado do teste lógico //"a igual b?"//, que só pode ter dois valores, ''T'' (verdadeiro), ou ''F'' (falso): | ||
| - | <code> | + | <code rsplus> |
| > a = 2 + 2 | > a = 2 + 2 | ||
| > a == 4 | > a == 4 | ||
| Linha 1048: | Linha 1048: | ||
| Os vetores lógicos ('''logical''') podem participar de operações matemáticas. Nesse caso o valor '''TRUE''' assume o valor 1, e valor '''FALSE''' assume o valor 0: | Os vetores lógicos ('''logical''') podem participar de operações matemáticas. Nesse caso o valor '''TRUE''' assume o valor 1, e valor '''FALSE''' assume o valor 0: | ||
| - | <code> | + | <code rsplus> |
| > f | > f | ||
| [1] TRUE TRUE TRUE TRUE TRUE FALSE FALSE FALSE | [1] TRUE TRUE TRUE TRUE TRUE FALSE FALSE FALSE | ||
| Linha 1059: | Linha 1059: | ||
| </code> | </code> | ||
| Para ter frequência de dados que satisfaçam uma certa condição basta somar o vetor lógico resultante: | Para ter frequência de dados que satisfaçam uma certa condição basta somar o vetor lógico resultante: | ||
| - | <code> | + | <code rsplus> |
| > notas.dos.alunos | > notas.dos.alunos | ||
| [1] 6.0 5.1 6.8 2.8 6.1 9.0 4.3 10.4 6.0 7.9 8.9 6.8 9.8 4.6 11.3 | [1] 6.0 5.1 6.8 2.8 6.1 9.0 4.3 10.4 6.0 7.9 8.9 6.8 9.8 4.6 11.3 | ||
| Linha 1077: | Linha 1077: | ||
| Considere o seguinte vetor: | Considere o seguinte vetor: | ||
| - | <code> | + | <code rsplus> |
| > cores = c("amarelo","vermelho","azul","laranja") | > cores = c("amarelo","vermelho","azul","laranja") | ||
| > | > | ||
| </code> | </code> | ||
| Para gerar uma amostra, com reposição, dessas cores execute o comando: | Para gerar uma amostra, com reposição, dessas cores execute o comando: | ||
| - | <code> | + | <code rsplus> |
| > muitas.cores = sample(cores, 20, TRUE) | > muitas.cores = sample(cores, 20, TRUE) | ||
| > muitas.cores | > muitas.cores | ||
| Linha 1100: | Linha 1100: | ||
| Para gerar uma amostra de 1000 números de uma distribuição Normal com média 23 e desvio padrão 5, utilize o comando: | Para gerar uma amostra de 1000 números de uma distribuição Normal com média 23 e desvio padrão 5, utilize o comando: | ||
| - | <code> | + | <code rsplus> |
| > vnormal = rnorm(1000, 23, 5) | > vnormal = rnorm(1000, 23, 5) | ||
| </code> | </code> | ||
| Linha 1132: | Linha 1132: | ||
| A) **Vetor de números inteiros positivos**: os números se referem às posições desejadas do vetor indexado. | A) **Vetor de números inteiros positivos**: os números se referem às posições desejadas do vetor indexado. | ||
| - | <code> | + | <code rsplus> |
| > a | > a | ||
| [1] 1.0000000 10.0000000 3.4000000 3.1415927 0.7853982 0.3678794 0.8020016 | [1] 1.0000000 10.0000000 3.4000000 3.1415927 0.7853982 0.3678794 0.8020016 | ||
| Linha 1147: | Linha 1147: | ||
| B) **Vetor de números inteiros negativos**: os números se referem as posições **não** desejadas do vetor indexado. | B) **Vetor de números inteiros negativos**: os números se referem as posições **não** desejadas do vetor indexado. | ||
| - | <code> | + | <code rsplus> |
| a | a | ||
| [1] 1.0000000 10.0000000 3.4000000 3.1415927 0.7853982 0.3678794 0.8020016 | [1] 1.0000000 10.0000000 3.4000000 3.1415927 0.7853982 0.3678794 0.8020016 | ||
| Linha 1162: | Linha 1162: | ||
| C) **Vetor lógico**: os elementos do vetor lógico correspondentes a '''TRUE''' são selecionados, os elementos correspondentes a '''FALSE''' são excluídos. | C) **Vetor lógico**: os elementos do vetor lógico correspondentes a '''TRUE''' são selecionados, os elementos correspondentes a '''FALSE''' são excluídos. | ||
| - | <code> | + | <code rsplus> |
| > b | > b | ||
| [1] 1 2 3 4 5 6 7 8 | [1] 1 2 3 4 5 6 7 8 | ||
| Linha 1179: | Linha 1179: | ||
| Na indexação por vetores lógicos, esses vetores devem ter **o mesmo comprimento** do vetor indexado. Caso contrário a operação será defeituosa: | Na indexação por vetores lógicos, esses vetores devem ter **o mesmo comprimento** do vetor indexado. Caso contrário a operação será defeituosa: | ||
| - | <code> | + | <code rsplus> |
| > b | > b | ||
| [1] 1 2 3 4 5 6 7 8 | [1] 1 2 3 4 5 6 7 8 | ||
| Linha 1190: | Linha 1190: | ||
| As operações por vetores lógicos podem combinar vários critérios, por meio dos operadores "E", "OU" e "NÃO": | As operações por vetores lógicos podem combinar vários critérios, por meio dos operadores "E", "OU" e "NÃO": | ||
| - | <code> | + | <code rsplus> |
| <WRAP center round box 60%> | <WRAP center round box 60%> | ||
| Por questão de segurança do wiki contra spam algumas palavras são proibidas. Nos exemplos a seguir a palavra "estupro" em inglês foi substituida por "Abuso", por esse motivo para rodar as linhas de código deve retornar a palavra para o idioma inglesa. | Por questão de segurança do wiki contra spam algumas palavras são proibidas. Nos exemplos a seguir a palavra "estupro" em inglês foi substituida por "Abuso", por esse motivo para rodar as linhas de código deve retornar a palavra para o idioma inglesa. | ||
| Linha 1215: | Linha 1215: | ||
| D) **Vetor caracter**: nesse caso o vetor deve ser //nomeado// (função '''names''') por um vetor '''character''': | D) **Vetor caracter**: nesse caso o vetor deve ser //nomeado// (função '''names''') por um vetor '''character''': | ||
| - | <code> | + | <code rsplus> |
| > zoo = c(4, 10, 2, 45) | > zoo = c(4, 10, 2, 45) | ||
| > names(zoo) = c("onça", "anta", "tatu", "guará") | > names(zoo) = c("onça", "anta", "tatu", "guará") | ||
| Linha 1230: | Linha 1230: | ||
| ==== Indexação de Fatores ==== | ==== Indexação de Fatores ==== | ||
| A indexação de um fator pode resultar em níveis não usados. Caso você queira exluir esses níveis, use o argumento ''drop'', do operador ''[]'': | A indexação de um fator pode resultar em níveis não usados. Caso você queira exluir esses níveis, use o argumento ''drop'', do operador ''[]'': | ||
| - | <code> | + | <code rsplus> |
| > tratamentos | > tratamentos | ||
| [1] Controle Controle Controle Controle Adubo A Adubo A Adubo A Adubo A | [1] Controle Controle Controle Controle Adubo A Adubo A Adubo A Adubo A | ||
| Linha 1257: | Linha 1257: | ||
| O modo de indexação de matrizes é ''[linhas,colunas]'': | O modo de indexação de matrizes é ''[linhas,colunas]'': | ||
| - | <code> | + | <code rsplus> |
| > matriz | > matriz | ||
| [,1] [,2] [,3] [,4] | [,1] [,2] [,3] [,4] | ||
| Linha 1275: | Linha 1275: | ||
| A mesma notação é válida para //data frames//: | A mesma notação é válida para //data frames//: | ||
| - | <code> | + | <code rsplus> |
| > USArrests[1:5,c(2,4)] | > USArrests[1:5,c(2,4)] | ||
| Assault abuso | Assault abuso | ||
| Linha 1304: | Linha 1304: | ||
| Para incluir todas as linhas ou colunas, omita o valor (mas mantenha a vírgula!): | Para incluir todas as linhas ou colunas, omita o valor (mas mantenha a vírgula!): | ||
| - | <code> | + | <code rsplus> |
| > matriz[,1] | > matriz[,1] | ||
| [1] 1 2 3 | [1] 1 2 3 | ||
| Linha 1333: | Linha 1333: | ||
| A notação é estendida para um //array// de qualquer dimensão, como o objeto ''Titanic'', que tem quatro dimensões: | A notação é estendida para um //array// de qualquer dimensão, como o objeto ''Titanic'', que tem quatro dimensões: | ||
| - | <code> | + | <code rsplus> |
| > dimnames(Titanic) | > dimnames(Titanic) | ||
| $Class | $Class | ||
| Linha 1374: | Linha 1374: | ||
| Combinando as operações de indexação e de atribuição é possível alterar os valores de qualquer parte de um objeto: | Combinando as operações de indexação e de atribuição é possível alterar os valores de qualquer parte de um objeto: | ||
| - | <code> | + | <code rsplus> |
| > zoo | > zoo | ||
| onça anta tatu guará | onça anta tatu guará | ||
| Linha 1411: | Linha 1411: | ||
| Com a indexação é possível mudar a ordem de um vetor: | Com a indexação é possível mudar a ordem de um vetor: | ||
| - | <code> | + | <code rsplus> |
| > zoo | > zoo | ||
| onça anta tatu lobo-guará | onça anta tatu lobo-guará | ||
| Linha 1427: | Linha 1427: | ||
| A função ''order'' retorna os **índices** dos elementos de um vetor: | A função ''order'' retorna os **índices** dos elementos de um vetor: | ||
| - | <code> | + | <code rsplus> |
| ##Vetor de nomes do vetor zoo: | ##Vetor de nomes do vetor zoo: | ||
| > names(zoo) | > names(zoo) | ||
| Linha 1438: | Linha 1438: | ||
| E com isso podemos usar seu resultado para ordenar um vetor em função de quaisquer outros: | E com isso podemos usar seu resultado para ordenar um vetor em função de quaisquer outros: | ||
| - | <code> | + | <code rsplus> |
| > zoo[order(names(zoo))] | > zoo[order(names(zoo))] | ||
| anta lobo-guará onça tatu | anta lobo-guará onça tatu | ||
| Linha 1446: | Linha 1446: | ||
| O argumento da função comporta múltiplos vetores de critério. Em caso de empate pelo(s) primeiro(s) critério(s), os seguintes são usados: | O argumento da função comporta múltiplos vetores de critério. Em caso de empate pelo(s) primeiro(s) critério(s), os seguintes são usados: | ||
| - | <code> | + | <code rsplus> |
| > cidades | > cidades | ||
| regiao estado pop.2007 | regiao estado pop.2007 | ||
| Linha 1498: | Linha 1498: | ||
| <box 100% left | //**Exercício 4.13.** Comando Curto, Resultado nem Tanto//> | <box 100% left | //**Exercício 4.13.** Comando Curto, Resultado nem Tanto//> | ||
| Verifique o resultado do comando: | Verifique o resultado do comando: | ||
| - | <code> | + | <code rsplus> |
| > ?"[" | > ?"[" | ||
| </code> | </code> | ||
| Linha 1505: | Linha 1505: | ||
| <box 100% left | //**Exercício 4.14** Indexação de Listas//> | <box 100% left | //**Exercício 4.14** Indexação de Listas//> | ||
| Crie uma lista com o comando: | Crie uma lista com o comando: | ||
| - | <code> | + | <code rsplus> |
| minha.lista <- list(um.vetor=1:5, uma.matriz=matrix(1:6,2,3), | minha.lista <- list(um.vetor=1:5, uma.matriz=matrix(1:6,2,3), | ||
| um.dframe=data.frame(seculo=c("XIX","XX","XXI"), | um.dframe=data.frame(seculo=c("XIX","XX","XXI"), | ||
| Linha 1511: | Linha 1511: | ||
| </code> | </code> | ||
| Qual a diferença entre os subconjuntos obtidos com os três comandos a seguir: | Qual a diferença entre os subconjuntos obtidos com os três comandos a seguir: | ||
| - | <code> | + | <code rsplus> |
| minha.lista[1] | minha.lista[1] | ||
| minha.lista[[1]] | minha.lista[[1]] | ||
| Linha 1520: | Linha 1520: | ||
| Para gerar uma amostra de 10.000 números de uma distribuição Normal com média 30 e desvio padrão 7, utilize o comando: | Para gerar uma amostra de 10.000 números de uma distribuição Normal com média 30 e desvio padrão 7, utilize o comando: | ||
| - | <code> | + | <code rsplus> |
| > vnormal = rnorm(10000, 30, 7) | > vnormal = rnorm(10000, 30, 7) | ||
| </code> | </code> | ||
03_apostila/04-dados.txt · Última modificação: 2023/08/15 18:33 (edição externa)
Exceto onde for informado ao contrário, o conteúdo neste wiki está sob a seguinte licença: CC Attribution-Noncommercial-Share Alike 4.0 International
