# INFORMÁTICA -TAREFA 380 - TRILHA 16 - AULA 25 - curso-161002-aula-25-grifado-033d

61 Pages • 12,103 Words • PDF • 4.9 MB

This document was submitted by our user and they confirm that they have the consent to share it. Assuming that you are writer or own the copyright of this document, report to us by using this DMCA report button.

Linguagem R - Introdução ................................................................................................ 2 1)

Conceitos básicos ...................................................................................................................... 2

2)

Nossa primeira aula de R .......................................................................................................... 9

3)

Objetos em R ........................................................................................................................... 17

Uma viagem pelo R........................................................................................................ 20 1)

Pacotes .................................................................................................................................... 20

2)

Funções do R-base .................................................................................................................. 22

3)

Constantes .............................................................................................................................. 32

4)

Matrizes .................................................................................................................................. 33

5)

Funções ................................................................................................................................... 38

6)

Estruturas de controle ............................................................................................................ 39

Resumo ......................................................................................................................... 41 Exercícios ...................................................................................................................... 46 1)

Questões e Exercício Prático – Baixe o R e R STUDIO! ........................................................... 46

2)

Exercícios ................................................................................................................................. 54

3)

Gabarito .................................................................................................................................. 57

4)

Código da videoaula ............................................................................................................... 58

1

61

LINGUAGEM R - INTRODUÇÃO 1) CONCEITOS BÁSICOS Bom dia! Boa tarde!! Boa noite!!! Não sei quando você está lendo essa aula, mas quero que você se sinta à vontade na leitura das próximas páginas. Você é meu convidado para adentrar dentro do universo da programação em R. Mas ... antes de começar a explicar o conteúdo teórico desta aula, gostaria que você configurasse o ambiente de programação na sua máquina. Em nossa videoaula, mostramos o passo a passo para instalação do R e do R Studio. É um processo simples, semelhante a instalação de um programa qualquer. É muito importante você ter o ambiente configurado na sua máquina para fazer os exemplos que veremos ao longo da aula. Dito isto, vamos começar nossa aula com uma simples pergunta: o que é R? R é uma linguagem computacional que permite que usuário programe algoritmos e utilize ferramentas que foram programadas por outras pessoas. Calma professor!! Já tem um monte de informações nas linhas acima que eu não entendi! Ok! Vamos devagar! As unidades de processamento (CPUs) são projetadas para reconhecer instruções codificadas como padrões de bits. Essa coleção de instruções, juntamente com o sistema de codificação, é chamada de linguagem de máquina. Pense como seria difícil se todo programa que fosse escrito tivesse que fazer uso de linguagem de máquina. As linguagens de programação têm sido desenvolvidas buscando permitir que algoritmos sejam expressos em um formato palatável aos humanos e facilmente convertidos em instruções de linguagem de máquina. Ou seja, uma linguagem de programação é uma forma se comunicar com o computador. Agora vamos falar de algoritmos. Vejamos a definição de algoritmos na figura abaixo:

2

61

3

61

Figura 1 - (1) Trabalhar com todos os conjuntos de dados. (2) Muitos pacotes. (3) Várias bibliotecas gráficas. (4) Cálculos rápidos. (5) Linguagem abrangente. (6) Código aberto.

Além disso, R é uma linguagem interpretada e uma ferramenta poderosa para manipulação, processamento, visualização e análise de dados, bem como simulações e modelagem estatísticas. Mas o que seria uma linguagem interpretada? Relaxa ... eu explico.

Linguagem compiladas x interpretadas Uma das classificações possíveis para linguagens de programação é quanto a execução. Nesta taxonomia podemos classificar a linguagem como compilada ou interpretada. O processo de converter um programa de uma linguagem para outra é chamado de tradução ou compilação. O programa em sua forma original é o programa fonte; a versão traduzida é o programa objeto. O processo de tradução consiste em três atividades – análise léxica, análise sintática e geração de código –, realizadas por unidades do tradutor conhecidas como analisador léxico, analisador sintático (ou parser) e gerador de código. Vejamos esse fluxo em uma figura: 4

61

Observem que o programa objeto será executado e sua organização depende do sistema operacional. Na execução do código os dados ou parâmetros são passados. Já a linguagem interpretada é uma linguagem de programação, onde o código fonte é executado por um programa de computador chamado interpretador. O interpretador lê um programa escrito em linguagem de alto nível e o executa, ou seja, faz o que o programa diz. Ele processa o programa um pouco de cada vez, alternadamente: ora lendo algumas linhas, ora realizando computações.

Como vantagens da linguagem interpretada podemos listar: • São rápidas e práticas, permitem agregar funcionalidades sem depender de ferramentas e compiladores. • Podem ser adaptadas a diversas tecnologias • Não dependem de instalações e ou bibliotecas. • Não precisam de uma ferramenta específica de desenvolvimento. Já as desvantagens são: • Por não ser compilada, erros de sintaxe não são identificados no desenvolvimento. • Não tem acesso completo a recursos da máquina por questões de segurança. • Depende de um interpretador local para ser executado. Agora ... se eu pedir para você preencher a lacuna ... R é uma linguagem ____________! O que você acha? Interpretada, certo?! Preenche a lacuna e grifa para você não esquecer! Vamos em frente! 5

61

Hora de abrir o R ... muito provavelmente você terá esse ícone na área de trabalho (esse do lado esquerdo!) A instalação padrão do R vem com uma interface gráfica para o usuário (Graphical User Interface – GUI). No Windows, você encontrará o R no menu iniciar e no Mac você verá o ícone do R entre seus aplicativos. No meu caso, consigo encontrar o executável RGui (64-bits) na busca do Windows. Ao executar o mesmo, a seguinte interface é aberta. Apesar de o R vir com uma interface gráfica interessante, existe um Ambiente de Desenvolvimento Integrado (Integrated Development EnvironmentIDE) chamado RStudio, com várias funcionalidades e gratuito. O RStudio possui algumas vantagens em relação ao R Gui:

• • • • • • •

Highlight do código; Autocomplete; Match automático de parênteses e chaves; Interface intuitiva para objetos, gráficos e script; Criação de “projetos” com interface para controle de versão; Facilidade na criação de pacotes; Interação com HTML, entre outras.

Você pode abrir o RStudio em seu computador e iniciar um novo Script em “File” -> “New File” -> “New RScript”. Você também pode fazer isso com CTRL + SHIFT + N ou acessando o botão abaixo.

6

61

Podemos dividir a tela do RStudio em quatro grandes áreas: 1. Script: A tela superior esquerda do RStudio é o editor de texto onde você vai escrever seus Scripts. Ele possui code highlighting entre outras funcionalidades. 2. Console: No canto inferior esquerdo fica o console. O console nada mais é do que uma seção aberta de R, em que os comandos são executados. 3. Área de trabalho e histórico: Ficam no canto superior direito. Os objetos criados e o histórico dos comandos podem ser acessados ali. 4. Arquivos, Gráficos, Pacotes, Ajuda: Ficam no canto inferior direito. Você pode explorar pastas e arquivos diretamente do RStudio na aba “Files”; os gráficos que forem feitos apareceram na aba “Plots”. Os pacotes instalados em sua máquina estão listados em “Packages”. As ajudas das funções aparecem em “Help”. E o “Viewer” serve para visualização de páginas em HTML e JavaScript. Essas áreas podem ser vistas na figura a seguir:

Nossa aula apresentará os conceitos básicos sobre o assunto que são suficientes para provas de concursos. Caso você queira se aprofundar um pouco mais no assunto e conhecer mais sobre a linguagem sugiro o seguinte curso gratuito e on-line: http://material.curso-r.com/ 7

61

Acostume-se a escrever o código no Script ao invés de ficar escrevendo diretamente no console. Para começarmos a nos familiarizarmos com o RStudio, escreva o código abaixo no Script: >1+1 E aperte CTRL+ENTER (CMD+ENTER no mac). Isso envia o comando para o console e o resultado é exibido logo abaixo. > 1+1 [1] 2

Agora escreva o seguinte código no Script. > # Gráfico dos números de 1 a 10 > plot(1:10)

O primeiro comando #Gráfico dos números de 1 a 10 é, na verdade, um comentário. Comentários nos scripts do R são precedidos do símbolo #, e tudo que estiver após # não será executado. É uma boa prática comentar seu código! Isso faz com que ele seja de fácil manutenção, tanto para você mesmo (acredite, depois de um tempo você não lembrará o que fez) quanto para seus colegas. O segundo comando diz ao R para plotar um gráfico. Aperte CTRL+ENTER nas duas linhas. O gráfico aparecerá no canto inferior direito do RStudio.

8

61

Vamos fazer alguns exercícios para ver se você compreendeu tudo que vimos até aqui:

1. Ano: 2020 Prova: Simulado Banca: TRC Assunto: Linguagem R Julgue os itens baixo a respeito dos conceitos básicos do R. 1) R é uma linguagem e um ambiente de desenvolvimento integrado, para cálculos estatísticos e gráficos. 2) Foi criada originalmente por Ross Ihaka e por Robert Gentleman no departamento de Estatística da universidade de Auckland, Nova Zelândia, e foi desenvolvido por um esforço colaborativo de pessoas em vários locais do mundo. 3) O código fonte do R está disponível sob a licença GNU GPL e as versões binárias précompiladas são fornecidas para Windows, Macintosh, e muitos sistemas operacionais Unix/Linux. 4) R é também altamente expansível com o uso dos pacotes, que são bibliotecas para funções específicas ou áreas de estudo específicas. 5) Um conjunto de pacotes é incluído com a instalação de R, com muito outros disponíveis na rede de distribuição do R (em inglês CRAN). Comentário: A lista acima é um resumo de tudo que vimos até aqui. Todas as alternativas estão corretas, espero que você não tenha encontrado nenhum erro também. A título de curiosidade ... o nome R provêm em parte das iniciais dos criadores e de um jogo desenvolvido com a linguagem S (da Bell Laboratories, antiga AT&T). Gabarito: C C C C C

2) NOSSA PRIMEIRA AULA DE R Agora que já sabemos alguns conceitos básicos sobre R e o R Studio vamos tentar organizar melhor as ideias apresentando alguns outros pontos importantes da linguagem. Se você nunca programou deixa eu conversar um pouco contigo. Vamos mudar de contexto! Qual a comida que você mais gosta? Pode ser a pizza caseira da sua tia, a dobradinha da sua mãe ou a feijoada da sua sogra ... Mas o que essas comidas tem em comum? Uma receita!!! Uma receita que estabelece os ingredientes, a quantidade e a sequência correta de ações para que seu prato predileto fique perfeito. Agora vamos pensar no contexto computacional. O computador é uma máquina que obedece às suas instruções e se você quiser fazer com que ele faça algum cálculo ou desenhe algum gráfico, é necessário passar os comandos corretos. Esses comandos devem ser escritos em uma linguagem de computação, que pode ser compilada ou interpretada. Você deve se lembrar que R é uma linguagem INTERPRETADA. Os dados processados pelo nosso programa precisam ser armazenados em algum lugar, numa planilha Excel ou num banco de dados. Durante o processamento, vamos trazer os 9

61

dados para o nosso ambiente e armazená-los em variáveis ou símbolos. Vamos criar uma variável e associar a essa variável um valor. > olamundo x x [3] [1] 4

Como em outras linguagens, o seletor (aqui, 3) é chamado de índice. Aqueles familiarizados com as linguagens da família ALGOL, como C e C++, devem observar que os elementos dos vetores R são indexados a partir de 1, não do 0. Outro ponto é que os subconjuntos podem ser extraídos de vetores. Veja um exemplo: > x x [2:3] [1] 2 4

A expressão x [2: 3] refere-se ao subvetor de x que consiste dos elementos nas posições 2 e 3, que são 2 e 4. Podemos encontrar facilmente a média e o desvio padrão do nosso conjunto de dados, da seguinte forma: > mean(x) [1] 2,333333 > sd (x) [1] 1.527525

Isso demonstra, novamente, que a simples digitação de uma expressão no prompt (console) é suficiente para imprimir seu resultado. Na primeira linha, nossa expressão é a função média aritmética, em inglês mean(x). O valor de retorno da chamada é impresso automaticamente, sem exigir uma chamada para a função print( ) de R que apresentamos anteriormente.

11 61

Se quisermos salvar a média calculada em uma variável em vez de apenas imprimi-la na tela, poderíamos executar este código: > y y [1] 2,333333

Como observado anteriormente, usamos # para escrever comentários, assim: > y # imprime [1] 2,333333

Os comentários são especialmente valiosos para documentar o código do programa, mas também são úteis em sessões interativas, uma vez que R registra o histórico de comandos executados. Se você salvar sua sessão e retomar mais tarde, os comentários podem ajudálo a lembrar o que você estava fazendo. Por fim, vamos fazer algo com um dos conjuntos de dados internos de R. O R oferece uma lista de dados que podem ser usados para demonstrações e aprendizado. Por exemplo, a lista Orange armazena dados sobre o crescimento de algumas árvores de laranja. Você pode obter uma lista desses conjuntos de dados digitando o seguinte: > data ()

Um dos conjuntos de dados é chamado de Nile e contém dados sobre o fluxo de água do rio Nilo ao longo de 100 anos. Essa lista é uma série temporal que vai de 1870 a 1970. Vamos encontrar a média e o desvio padrão desse conjunto de dados: > mean (Nile) [1] 919,35 > sd (Nile) [1] 169.2275

Podemos também traçar um histograma dos dados: > hist (Nile)

12 61

Se estivermos usando o RGui, uma janela aparece com o histograma, conforme mostrado na figura abaixo. Este gráfico é simples, mas R tem todos os tipos de gráficos para plotagem. Dentro de cada tipo de gráfico você pode manipular algumas das suas características, por exemplo, no histograma você pode alterar o número de categorias especificando o parâmetro. Uma chamada ao comando hist(z,breaks=12) desenharia um histograma do conjunto de dados z com 12 caixas ou intervalos. Você também pode criar rótulos mais agradáveis, fazer uso de cores e outras alterações para criar um gráfico mais informativo e atraente. Quando você se familiarizar mais com o R, poderá construir gráficos de cores ricas e complexas de beleza impressionante (mas isso será depois da sua aprovação), por enquanto seu foco é passar no concurso. Enquanto isso vejamos o gráfico com os dados do Nilo em uma apresentação simples.

Figura 2 - Histograma com os dados do Nilo

Bem, esse é o final de nossa introdução de cinco minutos ao R. Saia do R chamando a função q() (ou alternativamente pressionando ctrl-D no Linux ou cmd-D em um Mac): > q () Save workspace image? [y/n/c]: n

Esse último prompt pergunta se você deseja salvar suas variáveis para que você possa retomar o trabalho mais tarde. Se você responder “y”, todos esses objetos serão carregados automaticamente na próxima vez que você executar R. Esse é um recurso muito importante,

13 61

especialmente ao trabalhar com conjuntos de dados grandes ou numerosos. Responder “y” aqui também salva o histórico de comandos da sessão. Para finalizar essa sessão gostaria de falar dos comandos de ajuda. A ajuda do R pode ser muito útil quando se deseja saber qual função utilizar ou como utilizar uma função determinada. Na tabela abaixo são listados alguns comandos para realizar buscas no R:

Vejamos algumas questões sobre esses assuntos para você não avançar no conteúdo sem ter a certeza de que está aprendo tudo!

14 61

2. Ano: 2020 Prova: Simulado Banca: TRC Assunto: Linguagem R Julgue os itens baixo a respeito dos comandos da linguagem R.

1) A figura acima representa uma imagem do RGui. 2) Se utilizamos o console e escrevermos plot(Orange) o aplicativo em questão vai gerar os gráficos referentes aos dados de Orange e apresentar na área de Output, mas especificamente na aba Plots. 3) O comando abaixo vai atribuir um valor textual a variável Nome: Nome x mode(x) > length(x) #mostra o tipo e tamanho do objeto x [1] "numeric" [1] 5 Observamos acima a atribuição de um vetor de números a variável x. Nomes de variáveis no R podem conter combinações arbitrárias de números, textos, bem como ponto (.) e underscore (_). Entretanto, os nomes não podem começar com números ou underscore. Outra forma de descobrir a classe de um objeto é usando a função class(). > x class(x) [1] "numeric" > y class(y) [1] "character" > z class(z) [1] "logical" A tabela abaixo sintetiza os objetos e seus possíveis atributos (tipos). Veja:

18 61

Tabela 1 - Quando um objeto suporta tipos diferentes ele é chamado de heterogêneo, quando admite apenas objetos do mesmo tipo é denominado homogêneo.

Saber as diferenças entre os diversos tipos de objetos é importante para um uso mais adequado do R. Existem vários tipos de objetos que podem ser criados e manipulados. Já vimos que o R pode trabalhar com vetores - objetos que armazenam mais de um valor. A função c() é usada para criar um vetor a partir de seus argumentos. Os argumentos de c() podem ser escalares ou vetores. Há ainda outras formas de se gerar um vetor. Por exemplo, para gerar uma sequência de números inteiros usam-se os “dois pontos”. Veja: > a a #exibe o conteúdo do objeto “a” [1] 1 2 3 4 5 6 7 8 9 10 Uma maneira mais geral de produzir sequências de valores é usando a função seq() que tem como argumentos o início, fim e o incremento da sequência, por exemplo,. seq(1,10,1) é o mesmo que 1:10. Outra função útil para produzir vetores é a função rep() que retorna o primeiro argumento repetido o número de vezes indicado pelo segundo argumento, o comando rep(1,10) cria um vetor com 10 valores 1.

19 61

UMA VIAGEM PELO R Agora que já temos conhecimento dos objetos em R vamos conhecer um pouco mais sobre as funções. Funções são operações que pode ser executada sobre os objetos. Elas podem ser implementadas pelo próprio usuário/desenvolvedor ou serem distribuídas por meio de pacotes. Esses pacotes são interessantes para realizar diversas operações sobre os dados, desde a parte gráfica, melhorando a exibição das informações, até as funções estatísticas. Vamos falar um pouco mais sobre pacotes ...

1) PACOTES A principal forma de distribuição de códigos no R é por meio de pacotes. Um pacote pode ser entendido como um conjunto de códigos autocontido que adiciona funcionalidades ao R. Para carregar um pacote, use a função library(). Ao carregar um pacote, você está adicionando suas funções ao search da seção, permitindo que você chame estas funções diretamente. Por exemplo, a função mvrnorm, que gera números aleatórios de uma normal multivariada, está no pacote MASS. Vamos tentar gerar um vetor x que é representado pelo conjunto de 100 observações geradas por uma função mvrnorm. O código abaixo gera uma matriz de variância e covariância, estabelece as médias e tenta chamar a função. Mas veja que recebemos uma mensagem de erro. > Sigma mu x library(MASS) # Carrega pacote > x x

Para ver o que está disponível para utilização do R, utilize a função search(). Note que o pacote MASS agora está lá. > search() [1] ".GlobalEnv"

"package:MASS"

"tools:rstudio"

[5] "package:graphics" "package:grDevices" "package:utils"

"package:stats" "package:datasets"

20 61

[9] "package:methods"

"package:base"

Para descarregar um pacote, utilize a função detach(). > detach(package:MASS)

Às vezes, você pode ter o mesmo nome de funções em pacotes distintos. Neste caso, se ambos forem carregados, a função que prevalece é a do pacote que foi carregado por último. Uma outra forma de resolver isso é usar o nome do pacote e o operador “::” antes de chamar a função e descrever o nome do pacote que você está querendo usar.. Neste caso não há ambiguidade. > x install.packages("nome-do-pacote").

Via Github: > devtools::install_github("nome-do-repo/nome-do-pacote").

Via arquivo .zip/.tar.gz: > install.packages("C:/caminho/nome-do-pacote.zip", repos = NULL).

Esses pacotes instalados via CRAN são pacotes de contribuições feitas por desenvolvedores da comunidade R.

21 61

2) FUNÇÕES DO R-BASE Quando instalamos o R em nosso computador, programa R é composto de 3 partes básicas: 1. O R-base, o “coração” do R que contém as funções principais disponíveis quando iniciamos o programa, 2. Os pacotes recomendados (recommended packages) que são instalados junto com o R-base mas não são carregados quando iniciamos o programa. Por exemplo os pacotes MASS, lattice, nlme são pacotes recomendados – e há vários outros. 3. Os pacotes de contribuição de usuários (contributed packages) não são instalados junto com o R-base. Já vimos acima como resolver esse problema! Agora queria apresentar para os senhores e as senhoras algumas funções que são bastante usadas quando estamos desenvolvendo. Vamos a elas.... is.xxx() Já vimos que a função class() é útil para identificar a classe de um objeto. Mas, muitas vezes, no meio do nosso código, queremos ter certeza de que uma variável armazena um valor de um tipo específico. Você pode testar se um vetor é de determinada classe com as funções is.xxx (sendo “xxx” a classe). Vejamos alguns exemplos: > is.numeric(numero) [1] TRUE > is.character(numero) [1] FALSE > is.character(texto) [1] TRUE > is.logical(texto) [1] FALSE as.xxx() Você pode forçar a conversão de um vetor de uma classe para outra com as funções as.xxx() (sendo “xxx” a classe). Entretanto, nem sempre essa conversão faz sentido, e pode resultar em erros ou NA’s. NA significa não disponível em inglês, falaremos sobre ele mais adiante. Vamos mostrar alguns exemplos do uso das funções as.xxx(): > as.character(numero) # Vira texto [1] "546.9" "10" "789" > as.numeric(logico) # TRUE -> 1, FALSE -> 0 [1] 1 0 1 > as.numeric(texto) # Não faz sentido Warning: NAs introduzidos por coerção [1] NA NA NA > as.numeric("1012312") # Faz sentido [1] 1012312

22 61

lenght() Para obter o tamanho de um objeto, utilize a função length(). Por exemplo: > lenght(y) Aproveito para inserir aqui uma nova característica da linguagem. Comandos no R podem ser colocados na mesma linha se separados por ponto-e-vírgula (;), por exemplo. > length(ItensDoChurrascoDePosse);length(x);length(logico) str() Para ver a estrutura de um objeto no R, use a função str(). Esta é uma função simples, mas talvez das mais úteis do R. > str(aprovadoConcurso) #lembre-se existir no ambiente para ter sua console.

que o objeto precisa descrição impressa no

plot() O R já vem com funções básicas que fazem gráficos estatísticos de todas as naturezas. As funções abaixo podem ser usadas para melhorar a apresentação dos dados e facilitar o entendimento das relações entre eles. •

Vantagens: são rápidas e simples.

Desvantagens: são feias e difíceis para gerar gráficos complexos.

Nesta seção, mostraremos como construir alguns tipos de gráficos usando as funções base do R, existem outros pacotes mais robustos como o ggplot2. Gráfico de dispersão Para construir um gráfico de dispersão, utilizamos a função plot(). Seus principais parâmetros são: •

x, y - vetores para representarem os eixos x e y.

type - tipo de gráfico. Pode ser pontos, linhas, escada, entre outros.

Para mais detalhes sobre os argumentos, ver help(plot). Além de gerar gráficos de dispersão, tentar chamar a função plot(objeto_diferentao) para qualquer tipo de objeto do R geralmente gera um gráfico interessante! Sempre tente fazer isso, a menos que seu objeto seja um data.frame com milhares de colunas! Vejamos um exemplo: > n x y plot(x, y)

Figura 3 - Gráfico de dispersão gerado pelo plot.

Se quisermos podemos inserir entre parênteses o parâmetro type = "l" indicando que desejamos que os pontos sejam interligados por linhas. O comando por ser visto abaixo: > plot(x, y, type = "l")

Figura 4 - Gráfico de dispersão ligado por uma linha (l).

24 61

Histograma Para construir histogramas, utilizamos a função hist(). Os principais parâmetros são: •

x - o vetor numérico para o qual o histograma será construído.

Breaks - o número (aproximado) de retângulos. > hist(rnorm(1000))

Figura 5 - Histograma de mil elementos.

Veja que se definirmos o parâmetro breaks, o nosso histograma será dividido em n barras, no exemplo abaixo temos que breaks = 6. > hist(rnorm(1000), breaks = 6)

25 61

Figura 6 - Histograma com 6 breaks

Boxplot Para construir esse tipo de gráfico, utilizamos a função boxplot(). Os principais parâmetros são: •

X - O vetor numérico para o qual o boxplot será construído.

Vejamos um exemplo, neste exemplo usamos mais um conjunto de dados do próprio R. O InsectSprays é um data.frame que apresenta a contagem de insetos em unidades experimentais agrícolas tratadas com diferentes inseticidas. Possui duas colunas ou variáveis count e spray. Observe que o argumento col= “purple” muda a cor da caixa do boxplot. > boxplot(InsectSprays\$count, col = "purple")

26 61

Figura 7 - Boxplot de uma variável.

Para mapear duas variáveis no gráfico, utilizamos um objeto da classe formula (~) e o argumento data=. Veja que o comando abaixo descreve para cada tipo de inseticida (A, B, C, D, E e F) a variação da quantidade de insetos contabilizados. > boxplot(count ~ spray, data = InsectSprays, col = "blue")

Figura 8 - Gráfico de boxplot com duas variáveis.

Gráfico de barras 27 61

Para construir gráficos de barras, precisamos combinar as funções table() e barplot(). No gráfico abaixo, criamos uma tabela de frequências com a função table() e, em seguida, construímos o gráfico com a função barplot(). Lembre-se que a função data carrega bases de dados de pacotes instalados. Neste caso, como vamos usar uma base do pacote ggplot2 vamos precisar instalar o mesmo. > > > > >

install.packages("ggplot2") library(ggplot2) data(diamonds, package = "ggplot2") tabela VADeaths Rural Male Rural Female Urban Male Urban Female 50-54 11.7 8.7 15.4 8.4 55-59 18.1 11.7 24.3 13.6 60-64 26.9 20.3 37.0 19.3 65-69 41.0 30.9 54.6 35.1 70-74 66.0 54.3 71.1 50.0 > barplot(VADeaths)

28 61

Figura 10 - Gráfico de barras com duas variáveis.

names() Objetos podem ter elementos nomeados. Por exemplo, vamos nomear os elementos do vetor notas.

> notas notas [1] 9.5 9.9 10.0 > names(notas) notas Ricardo Aline Amanda 9.5 9.9 10.0 Quando colocamos nomes nos elementos de um vetor ou nas colunas e linhas de uma matriz, é possível acessar os dados usando esses nomes. Por exemplo:

> numero names(numero) numero["numero1"] numero1 546.9 Outra questão interessante sobre acessar elementos de um vetor passando parâmetros entre colchetes é a possibilidade de usar números negativos, neste caso estamos recuperando o vetor sem o dado da posição especificada pelo número. Por exemplo:

29 61

> numero[-1] # todos menos o primeiro numero2 numero3 10 789 sort() e order() A função order() retorna um vetor com as posições para que um objeto fique em ordem crescente. > order(numero) #índices [1] 3 2 1 > numero[order(numero)] # ordena numero numero3 numero2 numero1 -10.0 12.3 100.0 A função sort() retorna o vetor ordenado. > sort(numero) numero3 numero2 numero1 -10.0 12.3 100.0 Perceba que o resultado das duas funções acima sempre apresenta os vetores ordenados de forma crescente (do menor para o maior). As duas funções têm o parâmetro decreasing (decrescente) que, quando TRUE, retornam o vetor de em ordem decrescente. Neste caso o código seria escrito da seguinte forma: > sort(numero, decreasing = TRUE) # Retorna o vetor ordenado de forma decrescente. ls() e objects() Para listar todos os objetos que estão na sua área de trabalho, você pode usar a função ls() ou objects(). Faça um teste e veja se todos os objetos que você criou até aqui aparecem na lista. rm() A função rm(objeto) remove um objeto da área de trabalho. Ele recebe um parâmetro de texto ou uma lista com os nomes dos objetos para remover. save.image() e load() Para salvar uma cópia da sua área de trabalho você pode utilizar a função save.image(): # salva a área de trabalho no arquivo "aula_linguagemR.RData" > save.image(file=" aula_linguagemR.RData ") Agora você pode recuperar todos os objetos com load() > load(file=" aula_linguagemR.RData ") 30 61

summary() A função summary() é uma função genérica usada para produzir resumos de resultados de várias funções. A função chama métodos específicos que dependem da classe do primeiro argumento. Vejamos um exemplo:

> mediaLinear summary(mediaLinear) Call: lm(formula = hwy ~ displ, data = mpg) Residuals: Min 1Q Median -7.1039 -2.1646 -0.2242

3Q Max 2.0589 15.0105

Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 35.6977 0.7204 49.55 x [1] 1.0 2.0 -3.0 4.0 -20.3 > mean(x) # média [1] -3.26 > sum(x) # somatório [1] -16.3 > prod(x) # produtório [1] 487.2 > cumsum(x) # somatório acumulado [1] 1.0 3.0 0.0 4.0 -16.3 > cumprod(x) # produtório acumulado [1] 1.0 2.0 -6.0 -24.0 487.2

3) CONSTANTES Algumas constantes especiais estão disponíveis. I. Lógicas: TRUE, FALSE (evite T e F) II. Valores especiais: Em muitos casos, o resultado de uma operação é infinito ou não determinado. Outras vezes, há valores ausentes em sua base de dados. O R tem objetos especiais para lidar com esses tipos de situação. Por exemplo, quando tiramos o log de um número negativo, obtemos como resultado o valor NaN (Not an Number). Outros valores de interesse são Inf (Infinito) e NA (Not Available). Vejam uma lista de valões especiais abaixo: Descrição

Exemplo

– NaN

“not a number”

(0/0) ou log(-1)

– NA

valor faltante

(desconhecido)

32 61

– NULL – Inf ou -Inf

valor indefinido infinito

(objeto nulo) (1/0, -1/0)

– pi

3.141593...

O NA representa valores ausentes e é bastante utilizado quando se lida com bases de dados. Muitas funções têm parâmetros que indicam como ela deve lidar com valores ausentes. III. Outras Constantes: – LETTERS “A”, “B”, ..., “Z” – letters “a”, “b”, ..., “z” – month.abb “Jan”, “Feb”, ..., “Dec” – month.name “January”, “February”, ..., “December”

4) MATRIZES A ideia de matriz no R é similar a da matriz que conhecemos na matemática. Seus componentes são indexados pelo índice da linha e da coluna correspondente. Para o R, uma matriz é uma coleção de elementos de uma mesma classe arranjados em duas dimensões.

Figura 11 - Exemplo de uma matriz m x n

Criando matrizes O processo de criação de uma matriz no R é relativamente simples. No exemplo a seguir, vamos criar uma matriz com 100 elementos numéricos em sequência de 1 a 100. Nossa matriz terá 10 linhas e 10 colunas.

> matriz01 matriz01 > > >

A B A A

matriz01[3, 4] [1] 24 Muitas vezes não desejamos extrair o dado de apenas um elemento, mas de uma linha ou de uma coluna inteira de uma matriz. Para selecionarmos uma linha da nossa matriz01, utilizamos o seguinte comando: matriz01[i, ]. Onde i é a posição da linha que desejamos selecionar. Vejamos como fazemos para selecionar a linha 4 da matriz01: > matriz01[4, ] [1] 31 32 33 34 35 36 37 38 39 40 Para selecionar um intervalo de linhas, a lógica é semelhante a que utilizamos para intervalos de elementos em vetores. Segue exemplo: > matriz01[2:6, ] [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [1,] 11 12 13 14 15 16 17 18 19 20 [2,] 21 22 23 24 25 26 27 28 29 30 [3,] 31 32 33 34 35 36 37 38 39 40 [4,] 41 42 43 44 45 46 47 48 49 50 [5,] 51 52 53 54 55 56 57 58 59 60 Na seleção de colunas, o R funciona de maneira igual, bastando informar qual coluna, ou intervalo de colunas, que queremos fazer a seleção. Segue exemplo de seleção da coluna 5: 35 61

> matriz01[ ,5] [1] 5 15 25 35 45 55 65 75 85 95 Nomeando linhas e colunas de uma matriz Para facilitar a utilização e leitura dos dados de uma matriz, às vezes é interessante nomear suas linhas e colunas. Como exemplo, suponha que você está diante de uma matriz das notas de matemática de uma turma durante o ano de 2020. Cada linha representa um aluno e cada coluna representa um bimestre. Os dados estão estruturados conforme segue. > notas [,1] [,2] [,3] [,4] [1,] 5 7 5 6 [2,] 9 7 4 6 [3,] 6 7 4 5 [4,] 6 7 4 7 [5,] 8 10 5 5 [6,] 8 9 9 6 [7,] 4 4 8 10 [8,] 6 8 10 5 [9,] 8 10 7 8 [10,] 8 5 9 5 Para deixar a leitura mais fácil, podemos nomear as linhas e colunas através das funções rownames() e colnames(), respectivamente. Segue exemplo: > colnames(notas) rownames(notas) notas João Pedro Amanda Fábio Julia Gustavo Severino Paulo Laura Túlio

bim-1 bim-2 bim-3 bim-4 5 7 5 6 9 7 4 6 6 7 4 5 6 7 4 7 8 10 5 5 8 9 9 6 4 4 8 10 6 8 10 5 8 10 7 8 8 5 9 5

Uma vez com nomes das linhas e colunas, podemos utilizar os mesmos para realizar filtros em nossa matriz. Para exibir apenas as notas da aluna Fernanda, fazemos: > notas["Julia", ] bim-1 bim-2 bim-3 bim-4 8 10 5 5

36 61

O procedimento para seleção das colunas segue a mesma lógica. Unindo matrizes A união de matrizes é bastante importante para formarmos um conjunto de dados maior a partir de dados menores. Essa união pode ocorrer de duas formas: por linhas e por colunas. Para unirmos duas matrizes através das colunas, utilizamos a função cbind(). Já para fazer a união através das linhas, usamos a função rbind(). Vamos continuar os exemplos com nossa matriz notas. No entanto, considere que, durante o ano de 2020, dois alunos foram transferidos da escola e suas notas de matemática nos dois primeiros bimestres estão armazenadas na matriz notas_transf. Vamos aos dados: > notas_transf bim-1 bim-2 bim-3 bim-4 Dimas 6 8 NA NA Alessandra 8 9 NA NA Para consolidar os dados, precisamos unir as matrizes notas e notas_transf por linhas. Para executar tal tarefa, vamos usar a função rbind(). > rbind(notas, notas_transf) bim-1 bim-2 bim-3 bim-4 João 5 7 5 6 Pedro 9 7 4 6 Amanda 6 7 4 5 Fábio 6 7 4 7 Julia 8 10 5 5 Gustavo 8 9 9 6 Severino 4 4 8 10 Paulo 6 8 10 5 Laura 8 10 7 8 Túlio 8 5 9 5 Dimas 6 8 NA NA Alessandra 8 9 NA NA Para unirmos duas matrizes por colunas, o procedimento é similar. Porém, temos que observar que para unir matrizes através das colunas, devemos ter o mesmo número de linhas em todas as matrizes que desejamos unir. A lógica se aplica também à união por linhas, ou seja, as matrizes envolvidas devem ter o mesmo número de colunas. Resumindo ... cbind() é a função combina vetor, matrizes ou quadro de dados por colunas.

rbind() é a função combina vetor, matriz ou quadro de dados por linhas. 37 61

5) FUNÇÕES Uma das grandes vantagens de usar uma linguagem de programação é automatizar o seu trabalho ou análise. Você será capaz de realizar grande parte do trabalho utilizando as funções internas do R ou de pacotes de terceiros em um script. Entretanto, você ganha ainda mais flexibilidade e agilidade criando suas próprias funções. Uma função, no R, é definida da seguinte forma:

• o comando function() diz para o R que você está definindo uma função. • os valores dentro dos parênteses de function() são os argumentos (ou parâmetros) da função. Argumentos podem ter valores default(padrão), que são definidos com o sinal de igualdade (no caso arg3 tem como default o valor default3). Existe um parâmetro “coringa” muito útil, o ..., que permite passar argumentos para outras funções. • dentro das chaves encontra-se o “corpo” da função, isto é, uma série de comandos válidos que serão realizados. • o comando return() encerra a função e retorna seu argumento. O return() é opcional. Caso omitido, a função retorna o último objeto calculado. Criemos uma função simples que retorna o quadrado de um valor passado como parâmetro:

Funções criam um ambiente local e, em geral, não alteram o objeto ao qual são aplicadas. Isto é, se você passa um valor x para uma função que eleva x ao quadrado, o valor original de x não muda. Funções tomam objetos como argumentos e criam outro objeto, modificado,

38 61

como resultado. Na maior parte dos casos, a ideia é que uma função no R não tenha efeitos colaterais, isto é, que ela não modifique objetos fora de seu ambiente.

6) ESTRUTURAS DE CONTROLE Para escrever funções mais complexas pode ser necessário utilizarmos algumas estruturas de controle como if, ifelse e for. Vejamos algumas informações a respeito deles. Há ocasiões em queremos ou precisamos executar parte do código apenas se alguma condição for atendida. O R fornece três opções básicas para estruturar seu código dessa maneira: if(), if() else e ifelse(). Vejamos cada uma delas. A estrutura básica do if() é a seguinte:

• O início do código se dá com o comando if seguido de parênteses e chaves; • Dentro dos parênteses temos uma condição lógica, que deverá ter como resultado ou TRUE ou FALSE; • Dentro das chaves temos o bloco de código que será executado se – e somente se – a condição dos parênteses for TRUE. A estrutura básica do if() else é a seguinte:

• O início do código se dá com o comando if seguido de parênteses e chaves; • Dentro dos parênteses temos uma condição lógica, que deverá ter como resultado ou TRUE ou FALSE; • Dentro das chaves do if() temos um bloco de código que será executado se – e somente se – a condição do parênteses for TRUE. • Logo em seguida temos o else seguido de chaves;

39 61

• Dentro das chaves do else temos um bloco de código que será executado se – e somente se – a condição dos parênteses for FALSE. Os comandos if() e if() else não são vetorizados. Uma alternativa para casos como esses é utilizar a função ifelse(). A função ifelse() tem a seguinte estrutura básica:

• o primeiro argumento é um vetor (ou uma expressão que retorna um vetor) com vários TRUE e FALSE; • o segundo argumento é o valor que será retornado quando o elemento do vetor_de_condicoes for TRUE; • o terceiro argumento é o valor que será retornado quando o elemento do vetor_de_condicoes for FALSE. Minha experiência com programação tem demonstrado que usar funções que operam sobre vetores ou matrizes é muito mais performático do que usar outras funções não vetorizadas.

40 61

RESUMO Nesta aula, aprendemos que R é uma linguagem de programação multi-paradigma (funcional e orientada a objetos), dinâmica, fracamente tipada, voltada à manipulação, análise e visualização de dados. O código fonte do R está disponível sob a licença GNU GPL (software livre) e as versões binárias pré-compiladas são fornecidas para Windows, Macintosh, e muitos sistemas operacionais Unix/Linux. A linguagem R disponibiliza uma ampla variedade de técnicas estatísticas e gráficas, incluindo modelação linear e não linear, testes estatísticos clássicos, análise de séries temporais (time-series analysis), classificação, agrupamento e outras. R é facilmente extensível através de funções e extensões, e a comunidade R é reconhecida pelas contribuições feitas por meio de pacotes. A R é uma linguagem interpretada tipicamente utilizada através de um Interpretador de comandos. Como muitas outras linguagens, a R suporta matrizes aritméticas. A estrutura de dados da R inclui escalares, vetores, matrizes, dataframes (similares a tabelas numa base de dados relacional) e listas. O sistema de objetos da R é extensível e inclui objetos para, entre outros, modelos de regressão, séries temporais e coordenadas geoespaciais. Mais uma vantagem de utilizar a linguagem R está no RStudio, que é uma IDE, ou ambiente de desenvolvimento integrado, para o R. Com sua utilização gratuita, o RStudio é uma excelente ferramenta para desenvolvimento em R, extremamente visual quando comparado com ambientes de outras linguagens e com o console do R, e muito simples de se utilizar. Ao longo da aula, mostramos vários comandos e apresentamos suas respectivas descrições e sintaxe. Abaixo vamos fazer um resumo destes comandos separados por categoria: PEDINDO AJUDA e COMPREENDENDO OBJETOS Comando

Descrição

help(tópico)

Documentação do tópico, que pode ser uma função ou um objeto.

str(“tópico”)

Mostra a estrutura do tópico no R

summary(a)

Mostra o resumo de ‘a’. Geralmente um resumo estatístico. Mas há diferentes operações para diferentes classes de ‘a’.

ls()

lista os objetos criados no console.

dir(“diretório”)

IMPORTANDO E EXPORTANDO

41 61

Comando

Descrição

data(x)

library(x)

lê um arquivo no formato de tabela e cria a partir dele um dataframe; O separador padrão sep=”” é qualquer espaço em branco; use header=TRUE para ler a primeira linha como cabeçalho das colunas.

save(arquivo,...)

salva o objeto especificado na plataforma binária

print(a,...)

mostra a saída no console do objeto ‘a’. CRIANDO DADO

Comando

Descrição

c(...)

pode se entender c de combinar. É uma função genérica que combina os argumentos em um vetor.

from:to

gera uma sequência. Os dois pontos (:) tem a prioridade na operação. Exemplo: 1:4+1, a saída no console é “2,3,4,5”.

seq(from,to)

gera uma sequência. Possui os seguintes parâmentros, by=específica o incremento. length=específica o tamanho desejado da sequência. Perceba que by e lenght não podem ser usados como argumentos ao mesmo tempo. Ex:

> seq(1,10, by= 2) [1] 1 3 5 7 9 > seq(1,4, length = 5) [1] 1.00 1.75 2.50 3.25 4.00 repete x vezes; use each=para repetir cada elemento x vezes.

rep(x,times)

data.frame()

Exemplos:

> rep(c(1,2,3),2) [1] 1 2 3 1 2 3 > rep(c(1,2,3),2, each = 2) [1] 1 1 2 2 3 3 1 1 2 2 3 3 cria um data frame com os argumentos, nomeados ou não.

42 61

list()

cria uma lista com os argumentos

matrix(x,nrow=,ncol=)

cria uma matrix; com nrow=número de linhas e ncol=número de colunas. Elementos menores serão reciclados.

rbind(...)

combina os argumentos por linhas em uma matriz, data frame e entre outros.

cbind(...)

combina os argumentos por colunas em uma matriz, data frame e entre outros. FRAGMENTANDO E EXTRAINDO DADOS

Em vetores podemos ter acesso elementos específicos, vejamos algumas opções Comando

Descrição

x[n]

Seleciona o elemento presente no n índice do vetor x

x[-n]

Seleciona todos os elementos do vetor x, exceto o elemento n

x[1:n]

Seleciona os primeiros n elementos do vetor x

x[c(1,3,5)]

Seleciona os elementos do vetor x nas posições especificadas, neste caso, 1,3 e 5.

x[“nome”]

Seleciona o elemento do vetor x, pelo nome indicado.

x[x>3]

Seleciona todos os elementos do vetor x maiores que 3, vejamos um exemplo:

x[x>1] [1] 2.549633 5.888932 4.145929 1.332829 4.538 487 4.140993 4.745690 2.988220

43 61

PLOTANDO GRÁFICOS Comando

Descrição

plot(a)

Cria um gráfico com os valores de a no eixo y e no eixo x a sua respectiva posição.

plot(a,b)

Cria um gráfico em que os valores de a estarão no eixo x e os valores de b no eixo y. cria um histograma de frequência de x.

hist(x)

cria um histograma com os valores de x; use horiz=TRUE para criar barras horizontais.

barplot(x)

pie(x)

cria um gráfico de setores (o famoso gráfico de pizza).

44 61

cria um gráfico do tipo box-plot.

boxplot(x)

45 61

EXERCÍCIOS 1) QUESTÕES E EXERCÍCIO PRÁTICO – BAIXE O R E R STUDIO! Como não temos muitas questões sobre R para alegrar nossa aula e abrilhantar nosso estudo, resolvemos ressuscitar uma banca histórica de concurso público conhecida como TRC. Criativa, inteligente, dinâmica e objetiva a banca vai focar nos principais pontos do assunto com questões.

1. Ano: 2020 Prova: Simulado Banca: TRC Assunto: Linguagem R Julgue os itens baixo a respeito dos conceitos básicos do R. As funcionalidades do R são divididas em vários pacotes. Comentário: A funcionalidade R é dividida em vários pacotes. O sistema R possui pacotes básicos e recomendados. O CRAN também hospeda muitos pacotes complementares que podem ser usados para estender a funcionalidade do R. Gabarito: C 2. Ano: 2020 Prova: Simulado Banca: TRC Assunto: Linguagem R Julgue os itens baixo a respeito dos conceitos básicos do R. O sistema base R contém, entre outras coisas, o pacote base necessário para executar o R e contém as funções mais fundamentais. Comentário: A funcionalidade R é dividida em vários pacotes. O pacote "base" no R contém as funções mais fundamentais. Gabarito: C 3. Ano: 2020 Prova: Simulado Banca: TRC Assunto: Linguagem R Julgue os itens baixo a respeito dos conceitos básicos do R. Os pacotes utils, lang e tools são considerados pacotes básicos do R. Comentário: O sistema R "base" contém, entre outras coisas, o pacote base necessário para executar o R e contém as funções mais fundamentais. Os outros pacotes contidos no sistema "base" incluem utils, stats, datasets, graphics, grDevices, grid, methods, tools, parallel, compiler, splines, tcltk, and stats4. Veja que lang não faz parte dos pacotes básicos. Gabarito: E

46 61

4. Ano: 2020 Prova: Simulado Banca: TRC Assunto: Linguagem R Julgue os itens baixo a respeito dos conceitos básicos do R. A função abaixo pula as primeiras 20 iterações do loop. for(i in 1:100) { if (i switch(2,"red","green","blue") [1] "green" > switch(1,"red","green","blue") [1] "red" > switch(4,"red","green","blue") NULL > switch(0,"red","green","blue") 47 61

NULL Gabarito: E. 6. Ano: 2020 Prova: Simulado Banca: TRC Assunto: Linguagem R Julgue os itens baixo a respeito dos conceitos básicos do R. next é usado para pular uma iteração dentro do loop. Comentário: Em construções de loop como while, repeat, e podemos usar next para pular para a próxima iteração. Vejamos um exemplo: x

## Related documents

7 Pages • 1,676 Words • PDF • 660.6 KB

11 Pages • 1,397 Words • PDF • 914.7 KB

32 Pages • 2,701 Words • PDF • 2.6 MB

13 Pages • 477 Words • PDF • 357.9 KB

3 Pages • 338 Words • PDF • 843.3 KB

6 Pages • 1,172 Words • PDF • 242.9 KB

4 Pages • 1,440 Words • PDF • 646.9 KB