Ferramentas do usuário
03_apostila:04-dados
Diferenças
Aqui você vê as diferenças entre duas revisões dessa página.
| Ambos lados da revisão anterior Revisão anterior | Próxima revisão Ambos lados da revisão seguinte | ||
|
03_apostila:04-dados [2020/08/14 08:59] adalardo |
03_apostila:04-dados [2020/08/20 16:10] adalardo |
||
|---|---|---|---|
| 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> | ||
| 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 296: | Linha 296: | ||
| 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 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: | ||
| - | <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 | ||
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
