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 | Revisão anterior | ||
|
03_apostila:04-dados [2020/08/14 08:59] adalardo |
03_apostila:04-dados [2023/08/15 18:33] (atual) |
||
|---|---|---|---|
| Linha 14: | Linha 14: | ||
| === Função ''c()'' (concatenate ou combine) === | === Função ''c()'' (concatenate ou combine) === | ||
| - | 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 seção [[03-funcoes#o_r_como_uma_calculadora_vetorial|Funções Matemáticas e Estatísticas]] desta apostila. 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 | ||
| - | [1] 10.5 11.3 12.4 5.7 | + | [1] 10.5 11.3 12.4 5.7 |
| > | > | ||
| > vetor.vazio <- c() | > vetor.vazio <- c() | ||
| 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 71: | Linha 71: | ||
| [4,] "fogo" "terra" "água" "ar" | [4,] "fogo" "terra" "água" "ar" | ||
| </code> | </code> | ||
| + | |||
| === 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 89: | Linha 90: | ||
| </code> | </code> | ||
| - | === Funçao ''edit()''=== | + | === Função ''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 104: | Linha 105: | ||
| ==== Dados que já Estão em Arquivos==== | ==== Dados que já Estão em Arquivos==== | ||
| === Leitura e Exportação de Arquivos-Texto: ''read.table()'' e ''write.table()'' === | === Leitura e Exportação de Arquivos-Texto: ''read.table()'' e ''write.table()'' === | ||
| - | Para conjuntos de dados grandes, é mais prático gerar um arquivo de texto (ASCII) a partir e uma planilha ou banco de dados, e usar a função ''read.table'' para ler os dados para um objeto no R. | + | Para conjuntos de dados grandes, é mais prático gerar um arquivo de texto (ASCII) a partir de uma planilha ou banco de dados, e usar a função ''read.table'' para ler os dados para um objeto no R. |
| 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.csv",header=T,row.names=1,sep=",") |
| > gbmam93 | > gbmam93 | ||
| a b c d e f g h i j k l m n o p q r s | a b c d e f g h i j k l m n o p q r s | ||
| Linha 134: | Linha 135: | ||
| === 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 153: | ||
| 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 {datasets} R Documentation |
| Annual Canadian Lynx trappings 1821-1934 | Annual Canadian Lynx trappings 1821-1934 | ||
| Linha 169: | Linha 170: | ||
| Source: | Source: | ||
| - | Brockwell, P. J. and Davis, R. A. (1991) _Time Series and | + | Brockwell, P. J. and Davis, R. A. (1991) Time Series and |
| - | Forecasting Methods._ Second edition. Springer. Series G (page | + | Forecasting Methods. Second edition. Springer. Series G (page |
| 557). | 557). | ||
| References: | References: | ||
| - | Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S | + | Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S |
| - | Language_. Wadsworth & Brooks/Cole. | + | Language. Wadsworth & Brooks/Cole. |
| Campbell, M. J.and A. M. Walker (1977). A Survey of statistical | Campbell, M. J.and A. M. Walker (1977). A Survey of statistical | ||
| work on the Mackenzie River series of annual Canadian lynx | work on the Mackenzie River series of annual Canadian lynx | ||
| - | trappings for the years 1821-1934 and a new analysis. _Journal of | + | trappings for the years 1821-1934 and a 'new' analysis. Journal of |
| - | the Royal Statistical Society series A_, *140*, 411-431. | + | the Royal Statistical Society series A, 140, 411-431. |
| </code> | </code> | ||
| 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 200: | ||
| 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 212: | Linha 213: | ||
| No segundo caso, o pacote //vegan//, que tem o conjunto de dados, não está carregado e por isso deve ser indicado no argumento ''package''. | No segundo caso, o pacote //vegan//, que tem o conjunto de dados, não está carregado e por isso deve ser indicado no argumento ''package''. | ||
| - | === Importacao de Pacotes Estatísticos === | + | === Importação de Arquivos de Outros Pacotes Estatísticos === |
| O pacote //foreign// contém funções para importar e exportar diretamente arquivos de pacotes estatísticos. | O pacote //foreign// contém funções para importar e exportar diretamente arquivos de pacotes estatísticos. | ||
| Linha 249: | Linha 250: | ||
| * Atenas a Estocolmo: 3927 | * Atenas a Estocolmo: 3927 | ||
| * Madri a Paris: 1273 | * Madri a Paris: 1273 | ||
| - | * Madri a Estocolomo: 3188 | + | * Madri a Estocolmo: 3188 |
| * Paris a Estocolmo: 1827 | * Paris a Estocolmo: 1827 | ||
| Linha 291: | Linha 292: | ||
| Vetores, matrizes e listas são objetos com características diferentes, formalmente definidas no R como //atributos//. Em uma linguagem orientada a objetos, são esses atributos que definem o contexto para a execução de um comando e, portanto, seu resultado. Fazendo uma analogia com o mundo físico, uma mesma ação tem resultados diferentes de acordo com as características do objeto em que é aplicada. | Vetores, matrizes e listas são objetos com características diferentes, formalmente definidas no R como //atributos//. Em uma linguagem orientada a objetos, são esses atributos que definem o contexto para a execução de um comando e, portanto, seu resultado. Fazendo uma analogia com o mundo físico, uma mesma ação tem resultados diferentes de acordo com as características do objeto em que é aplicada. | ||
| - | O que é importante reter aqui é que os resultados que obtemos de um comando no R (incluindo as mensagens de erro!) são em boa parte definidas pelo objeto de dados, e não pela função. Por isso, quando enfrentar algum problema, verifique com cuidado na documentação se e como o seu comando se aplica à classe de objeto de dados que você está usando.((em termos técnicos: verifique se e como a função usada define um método para o objeto de dados usado)) | + | O que é importante reter aqui é que os resultados que obtemos de um comando no R (incluindo as mensagens de erro!) são em boa parte definidas pelo objeto de dados, e não apenas pela função. Por isso, quando enfrentar algum problema, verifique com cuidado na documentação se o seu comando se aplica à classe de objeto de dados que você está usando e, se sim, como.((em termos técnicos: verifique se e como a função usada define um método para o objeto de dados usado)) |
| ==== 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 307: | ||
| 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 337: | ||
| 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 349: | ||
| É 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 373: | ||
| 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 389: | Linha 390: | ||
| Em muitos casos, indicar que um vetor é um fator é importante para a análise, e várias funções no R exigem variáveis dessa classe, ou têm respostas específicas para ela ((em termos técnicos, dizemos que há métodos para cada classe de objeto, e que algumas funções têm métodos específicos para fatores, ou só têm para essa classe. Veja a seção sobre programação para detalhes)). | Em muitos casos, indicar que um vetor é um fator é importante para a análise, e várias funções no R exigem variáveis dessa classe, ou têm respostas específicas para ela ((em termos técnicos, dizemos que há métodos para cada classe de objeto, e que algumas funções têm métodos específicos para fatores, ou só têm para essa classe. Veja a seção sobre programação para detalhes)). | ||
| - | 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 seus 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 407: | ||
| 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 418: | ||
| 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 427: | Linha 428: | ||
| <box center 50% red| **Duas Coisa que Você Precisa Saber sobre Fatores**> | <box center 50% red| **Duas Coisa que Você Precisa Saber sobre Fatores**> | ||
| * Um fator pode ter níveis para os quais não há valores. Isso pode acontecer quando alguns valores são selecionados ou excluídos (ver item sobre [[04-dados#Subconjuntos e Indexação|indexação]], nessa seção). Isso é muito importante, pois afeta o resultado de muitas funções (Veja os exemplos da função ''tapply'', a seguir e também no item sobre [[04-dados#Indexação de Fatores|indexação de fatores]]). | * Um fator pode ter níveis para os quais não há valores. Isso pode acontecer quando alguns valores são selecionados ou excluídos (ver item sobre [[04-dados#Subconjuntos e Indexação|indexação]], nessa seção). Isso é muito importante, pois afeta o resultado de muitas funções (Veja os exemplos da função ''tapply'', a seguir e também no item sobre [[04-dados#Indexação de Fatores|indexação de fatores]]). | ||
| - | * Ao importar um arquivo texto, a função ''read.table'' transforma por //default// em fatores todas as variáveis que tenham caracteres. Você pode indicar quais dessas variáveis não são fatores com o argumento ''as.is''. | + | * Em versões mais antigas do R, a função ''read.table'' transformava em fatores todas as variáveis que tivessem caracteres por //default//. Em versões mais recentes, esse não é mais o padrão. Mas você pode decidir como você quer lidar com os caracteres durante a leitura usando o argumento ''as.is''. |
| </box> | </box> | ||
| Linha 433: | Linha 434: | ||
| === 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 462: | ||
| 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 484: | ||
| === 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 493: | ||
| 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 503: | ||
| 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 529: | ||
| 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 550: | ||
| 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 567: | ||
| 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 586: | ||
| 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 613: | ||
| 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 627: | Linha 628: | ||
| A função ''aggregate'' gera subconjuntos de cada um dos vetores de um //data frame//, executa uma função para cada um desses subconjuntos, e retorna um novo //data frame// com os resultados. | A função ''aggregate'' gera subconjuntos de cada um dos vetores de um //data frame//, executa uma função para cada um desses subconjuntos, e retorna um novo //data frame// com os resultados. | ||
| - | 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ísticas 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 665: | Linha 666: | ||
| </code> | </code> | ||
| - | Os argumentos básicos da função são o //data.frame// com os valores (''x''), o(s) fator(es) que definem os subconjuntos (''by'', que deve ser uma lista), e a função a calcular de cada vetor do //data frame// (''FUN''). | + | Os argumentos básicos da função são o objeto com os valores (''x''), o(s) fator(es) que definem os subgrupos (''by'', que deve ser uma lista), e a função a ser aplicada a cada vetor em ''x'' (''FUN''). |
| Linha 679: | Linha 680: | ||
| 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 686: | Linha 687: | ||
| [3,] 3 3 3 3 | [3,] 3 3 3 3 | ||
| </code> | </code> | ||
| - | 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 item 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 702: | ||
| 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 712: | ||
| 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 721: | ||
| 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 739: | ||
| 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 771: | ||
| 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 777: | ||
| Com os seguintes nomes: | Com os seguintes nomes: | ||
| - | <code> | + | <code rsplus> |
| > dimnames(Titanic) | > dimnames(Titanic) | ||
| $Class | $Class | ||
| Linha 794: | Linha 795: | ||
| 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 827: | Linha 828: | ||
| - Quais são as classes desses dois objetos? | - Quais são as classes desses dois objetos? | ||
| - Calcule a média de cada uma das quatro medidas por espécie, dos dois objetos. | - Calcule a média de cada uma das quatro medidas por espécie, dos dois objetos. | ||
| - | - Os nomes das variaveis estão em inglês. Mude-os para português no objeto ''iris''. (//DICA: Como tudo mais no R, os resultados da função ''names'' podem ser armazenados em um objeto//) | + | - Os nomes das variáveis estão em inglês. Mude-os para português no objeto ''iris''. (//DICA: Como tudo mais no R, os resultados da função ''names'' podem ser armazenados em um objeto//) |
| </box> | </box> | ||
| Linha 841: | Linha 842: | ||
| - 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 848: | ||
| </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 858: | ||
| - 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 874: | ||
| 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 879: | Linha 880: | ||
| </code> | </code> | ||
| - | Os elementos da matriz são a probabilidades de transição, num intervalo de tempo, do estágio correspondente ao número da coluna para o estágio correspondente ao número da linha. Por exemplo, a chance de um indivíduo passar do estágio 1 para o 2 é 0,33, e de permanecer em 1 é de 0,43. | + | Os elementos da matriz são as probabilidades de transição, num intervalo de tempo, do estágio correspondente ao número da coluna para o estágio correspondente ao número da linha. Por exemplo, a chance de um indivíduo passar do estágio 1 para o 2 é 0,33, e de permanecer em 1 é de 0,43. |
| - Crie um objeto da classe matriz com esses valores. Isso permite realizar as operações matriciais a seguir. | - Crie um objeto da classe matriz com esses valores. Isso permite realizar as operações matriciais a seguir. | ||
| - Para calcular o número de indivíduos em cada estágio após um intervalo de tempo, basta multiplicar a matriz de transição pelas abundâncias dos indivíduos em cada estágio. Começando com 50 indivíduos do estágio 1, 25 do estágio 2 e 10 no estágio 3, qual será o número de plantas em cada estágio após três intervalos? | - Para calcular o número de indivíduos em cada estágio após um intervalo de tempo, basta multiplicar a matriz de transição pelas abundâncias dos indivíduos em cada estágio. Começando com 50 indivíduos do estágio 1, 25 do estágio 2 e 10 no estágio 3, qual será o número de plantas em cada estágio após três intervalos? | ||
| - | - **Opcional**: A taxa de crescimento geométrico da população é o primeiro autovalor da matriz de transição, que pode ser calculado com a função ''eigen''((consulte a ajuda para interpretar o resultados dessa função)). Se a taxa é maior que um a população está crescendo. É o caso dessa população? | + | - **Opcional**: A taxa de crescimento geométrico da população é o primeiro autovalor da matriz de transição, que pode ser calculado com a função ''eigen''((consulte a ajuda para interpretar o resultados dessa função)). Se a taxa é maior que um a população está crescendo. É o caso dessa população? |
| </box> | </box> | ||
| Linha 890: | Linha 891: | ||
| ===== O R como Ambiente de Operações Vetoriais ===== | ===== O R como Ambiente de Operações Vetoriais ===== | ||
| - | Na verdade, o R é muito mais que uma simples calculadora. O R é um **ambiente** onde podemos realizar operações vetoriais e matriciais. | + | Na verdade, o R é muito mais que uma simples calculadora. O R é um **ambiente** onde podemos realizar operações vetoriais e matriciais. |
| Além das regras básicas para operações com vetores numéricos (ver [[03-funcoes#Vetores: Operações Matemáticas]]), há operações aplicáveis a outros tipos de dados, e as importantíssimas **operações lógicas**, aplicáveis a qualquer classe. | Além das regras básicas para operações com vetores numéricos (ver [[03-funcoes#Vetores: Operações Matemáticas]]), há operações aplicáveis a outros tipos de dados, e as importantíssimas **operações lógicas**, aplicáveis a qualquer classe. | ||
| Linha 897: | Linha 898: | ||
| 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 | ||
| Warning message: | Warning message: | ||
| - | argument is not numeric or logical: returning NA in: mean.default(sp) | + | argument 'is' not numeric or logical: returning NA in: mean.default(sp) |
| > | > | ||
| </code> | </code> | ||
| - | Mas existem algumas operações que são próprias desse tipo de vetores: | + | Mas existem muitas operações que funcionam ou são próprias desse tipo de vetores: |
| - | <code> | + | <code rsplus> |
| - | > sort( sp ) | + | > sort( sp ) # ordenação de caracteres em ordem crescente |
| [1] "Myrcia sulfiflora" "Myrcia sulfiflora" "Syagrus romanzoffianus" | [1] "Myrcia sulfiflora" "Myrcia sulfiflora" "Syagrus romanzoffianus" | ||
| [4] "Tabebuia cassinoides" | [4] "Tabebuia cassinoides" | ||
| > | > | ||
| - | > grep("Myrcia", sp) | + | > grep("Myrcia", sp) # busca por elementos do vetor de caracteres contendo "Myrcia" |
| [1] 1 4 | [1] 1 4 | ||
| > | > | ||
| - | > table( sp ) | + | > table( sp ) # contagem do numero de elementos para cada classe de elemento |
| sp | sp | ||
| Myrcia sulfiflora Syagrus romanzoffianus Tabebuia cassinoides | Myrcia sulfiflora Syagrus romanzoffianus Tabebuia cassinoides | ||
| 2 1 1 | 2 1 1 | ||
| + | > | ||
| + | > sub("Myrcia", "M.", sp ) # substituição de caracteres | ||
| + | [1] "M. sulfiflora" "Syagrus romanzoffianus" "Tabebuia cassinoides" "M. sulfiflora" | ||
| + | > | ||
| + | > strsplit(sp, " ") # divisão de cada elemento do vetor por um dado caractere ou símbolo (no caso, um espaço) | ||
| + | [[1]] | ||
| + | [1] "Myrcia" "sulfiflora" | ||
| + | |||
| + | [[2]] | ||
| + | [1] "Syagrus" "romanzoffianus" | ||
| + | |||
| + | [[3]] | ||
| + | [1] "Tabebuia" "cassinoides" | ||
| + | |||
| + | [[4]] | ||
| + | [1] "Myrcia" "sulfiflora" | ||
| + | > | ||
| </code> | </code> | ||
| - | <code> | + | |
| + | Também é possível concatenar vetores de caracteres usando a função ''paste'': | ||
| + | |||
| + | <code rsplus> | ||
| > bicho <- c("pato","gato","boi") | > bicho <- c("pato","gato","boi") | ||
| Linha 934: | Linha 955: | ||
| ==== Operações Lógicas ==== | ==== 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: | + | 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 977: | ||
| 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 993: | ||
| 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 1014: | ||
| <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 1043: | ||
| 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 1053: | ||
| 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 1047: | Linha 1068: | ||
| === Uma maneira simples de quantificar frequências === | === Uma maneira simples de quantificar frequências === | ||
| - | 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 1080: | ||
| </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 1066: | Linha 1087: | ||
| > sum(notas.dos.alunos>=5) | > sum(notas.dos.alunos>=5) | ||
| [1] 14 | [1] 14 | ||
| - | ##Qual a proporção deste valores em relação ao total? | + | ##Qual a proporção deste valor em relação ao total? |
| > sum(notas.dos.alunos>=5)/length(notas.dos.alunos) | > sum(notas.dos.alunos>=5)/length(notas.dos.alunos) | ||
| [1] 0.7777778 | [1] 0.7777778 | ||
| Linha 1077: | Linha 1098: | ||
| 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 1121: | ||
| 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 1127: | Linha 1148: | ||
| ===== Subconjuntos e Indexação ===== | ===== Subconjuntos e Indexação ===== | ||
| - | Freqüentemente teremos que trabalhar não com um vetor inteiro, mas com um //subconjunto// dele. Para obter subconjuntos de um vetor temos que realizar operações de **indexação**, isto é, associar ao vetor um outro vetor de mesmo tamanho com os **índices** do elementos selecionados. | + | Frequentemente teremos que trabalhar não com um vetor inteiro, mas com um //subconjunto// dele. Para obter subconjuntos de um vetor temos que realizar operações de **indexação**, isto é, associar ao vetor um outro vetor de mesmo tamanho com os **índices** dos elementos selecionados. |
| - | O **operador** de indexação é o colchetes '''[]''', e um vetor pode ser indexado de três formas principais: | + | O **operador** de indexação é o colchetes ''[]'', e um vetor pode ser indexado de três formas principais: |
| - | 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 1146: | Linha 1167: | ||
| - | 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 às 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 1161: | Linha 1182: | ||
| - | 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 1178: | Linha 1199: | ||
| </code> | </code> | ||
| - | 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 1211: | ||
| 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> | + | |
| <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 substituída por "Abuso", por esse motivo para rodar as linhas de código deve retornar a palavra para o idioma inglesa. |
| </WRAP> | </WRAP> | ||
| + | <code rsplus> | ||
| ## Primeiras 5 linhas do data frame USArrests (crimes/1000 habitantes em cada estado dos EUA, em 1973): | ## Primeiras 5 linhas do data frame USArrests (crimes/1000 habitantes em cada estado dos EUA, em 1973): | ||
| > USArrests[1:5,] | > USArrests[1:5,] | ||
| Linha 1214: | Linha 1236: | ||
| </code> | </code> | ||
| - | 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á") | ||
| - | > zoo[ c("anta","guará") ] | + | > zoo[ c("anta", "guará") ] |
| anta guará | anta guará | ||
| 10 45 | 10 45 | ||
| Linha 1229: | Linha 1251: | ||
| ==== 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 excluir 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 1279: | ||
| 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 1297: | ||
| 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 1326: | ||
| 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 1355: | ||
| 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 1396: | ||
| 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 1433: | ||
| 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 1449: | ||
| 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 1460: | ||
| 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 1468: | ||
| 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 1520: | ||
| <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 1527: | ||
| <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 1533: | ||
| </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 1542: | ||
| 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.1597406349.txt.gz · Última modificação: 2020/08/14 08:59 por adalardo
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
