Aula 30 - Linguagem R - Prof Thiago Cavalcanti

Aula 30 - (Prof.
Thiago
Cavalcanti).
Polícia Federal (Agente de Polícia)
Informática - 2023 (Pré-Edital)
Autor:
Diego Carvalho, Equipe
Informática e TI, Renato da Costa,
Thiago Rodrigues Cavalcanti
21 de Junho de 2023
40181815826 - Flávio Ricardo Cirino

Diego Carvalho, Equipe Informática e TI, Renato da Costa, Thiago Rodrigues Cavalcanti
Aula 30 - (Prof. Thiago Cavalcanti).
Índice
1) Linguagem R - Introdução
..............................................................................................................................................................................................3
2) Uma Viagem pelo R

..............................................................................................................................................................................................
21
3) Questões Comentadas - Linguagem R - Multibancas

..............................................................................................................................................................................................
49
4) Lista de Questões - Linguagem R - Multibancas

..............................................................................................................................................................................................
57
Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 2

www.estrategiaconcursos.com.br 61

LINGUAGEM R - INTRODUÇÃO
CONCEITOS BÁSICOS
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:
Um passo a passo para produzir

algo. O computador precisa que
você descreva TODAS as ações
que você quer que ele execute!
Se algum passo for esquecido,
ele não será executado ... Pense
em uma receita de bolo ...
esquecer algum ingrediente
pode gerar um efeito terrível
sobre o resultado.


O R é uma linguagem funcional/orientada a objetos criada em 1996 por Ross Ihaka e

Robert Gentleman que aliada a um ambiente integrado permite a manipulação de dados,
realização de cálculos e geração de gráficos. Uma curiosidade é que o nome R é a letra
inicial do primeiro nome de cada um dos seus criadores. Mas não foi apenas por isso que a
linguagem recebeu esse nome ...
R é semelhante à linguagem S desenvolvida pela AT&T’s Bell Laboratories e que já era
utilizada para análise de dados, mas com a vantagem de ser de livre distribuição (open-
source). Para a instalação do R basta conectar-se ao site http://cran.r-project.org. CRAN
é o acrônimo para “Comprehensive R Archive Network, neste site você consegue escolher
o local mais próximo de onde você encontra-se e fazer o download da última versão do R.
Mas ... para que serve o R mesmo?
R é uma linguagem de programação com foco em análise de dados. Ou seja, voltada à
interação dinâmica com os dados e modelos. Além disso, R é gratuito e de código aberto
e seu ambiente permite explorar dados interativamente; mas, à medida que a análise evolui,
R é visto como uma linguagem de programação completa para desenvolver e automatizar
soluções, desenvolver softwares e pacotes.
Vejamos uma figura que resume as funcionalidades ou capacidades da programação em
R.
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:
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!
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
Environment- IDE) 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.
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/


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.
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
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


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 <- “HelloWorld
A linha acima permite a criação de uma variável denominada olamundo, o símbolo <- é
usado para atribuição, ele faz com que o valor presente do seu lado direito seja atribuído a
variável do lado esquerdo. Esse valor fica disponível no ambiente e pode ser acessado. A
função print() pode ser usada para imprimir o valor da variável no console. Observamos o
comando na listagem abaixo.
> print(olamundo)
[1] "HelloWorld!"
Se você ainda não instalou o R e RStudio na sua máquina, gostaria de reforçar que a prática
dos comandos vai ajudar significativamente seu aprendizado.
Ok! Já temos uma variável no nosso ambiente, mas queremos mais!! Agora vamos definir
um vetor. Um vetor pode ser construído a partir da concatenação de valores do mesmo tipo.
No nosso caso vamos criar um conjunto de dados numérico simples que é formado pelos
números 1, 2 e 4 e nomeá-lo como x:
> x <- c (1,2,4)
Mais uma vez, temos o operador de atribuição padrão em R (<-). Você também pode usar
=, mas isso é desencorajado, pois não funciona em algumas situações especiais. Observe
que não há tipos fixos associados a variáveis. Ou seja, não definimos que os valores 1, 2 e
4 são números, mas o R entende que estamos criando um vetor numérico. Aqui, atribuímos
um vetor a x. Sendo x uma variável, pode ter seu valor alterado, basta usar o símbolo de
atribuição e passar outro valor válido.
O c significa concatenar. No exemplo acima, estamos concatenando os números 1, 2 e 4.
Mais precisamente, estamos concatenando três vetores de um elemento que consistem
nesses números. Isso ocorre porque qualquer número também é considerado um vetor
de um elemento.
Agora também podemos escrever o seguinte:
> q <- c (x, x, 8)
que define q como um vetor com os valores (1,2,4,1,2,4,8) (sim, incluindo os duplicados).
Perceba que estamos concatenando duas vezes o conjunto de valores de x e, em seguida
o 8 em um novo conjunto.


Agora vamos confirmar que os dados estão realmente em x. Para imprimir o vetor na tela,
basta digitar seu nome. Se você digitar qualquer nome de variável (ou qualquer expressão)
enquanto estiver no modo interativo, o R imprimirá o valor dessa variável (ou expressão) no
Console. Os programadores familiarizados com outras linguagens, como o Python, acharão
esse recurso familiar. Para o nosso exemplo, insira isto:
> x
[1] 1 2 4
Sim, com certeza, x consiste nos números 1, 2 e 4. Outro ponto interessante é que você
pode acessar elementos individuais de um vetor via colchetes “[ ]” . Veja como podemos
imprimir o terceiro elemento de 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 <- c (1,2,4)

> 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.


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 <- mean(x)
Mais uma vez, vamos confirmar que y realmente contém a média de x:
> 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 (Nilo)


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,


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!



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 <- "Thiago Cavalcanti tem um grupo massa no Telegram, você já

conhece? Ainda não? Então, tá perdendo!"
4) Para tirar a média dos valores do conjunto de dados do datasets Nile

devemos usar o comando media(Nile)
Comentário: Vamos comentar cada uma das alternativas acima. Desta vez, nem todas estavam
certas. Espero que você tenha percebido! :)
1) Alternativa errada, essa é a interface do RStudio.
2) Certa! Se usarmos o plot(Orange) ele vai exibir o seguinte resultado na aba Plots:


==275324==
3) Certa. Perceba que a variável Nome possui uma letra maiúscula. Logo, se você precisar
utilizá-la novamente deve respeitar essa característica, caso contrário o R não vai encontrar
a variável.
4) Errada. Perceba que as funções padrão do R são em inglês, logo, para calcular a média você
deve usar a função mean(Nile). Se tentarmos rodar o comando media(Nile) vamos obter a
seguinte mensagem de erro:
Error in media(Nile) : could not find function "media"
Gabarito: E C C E


OBJETOS EM R
O que são os Objetos do R? Existem muitos tipos de objetos no R que só passamos a

conhecê-los bem com o passar do tempo. Por enquanto vamos aprender os tipos básicos
de objetos.
a) vetores: uma sequência de valores numéricos ou de caracteres (letras,

palavras) sempre do mesmo tipo. Os vetores no R podem ser, entre outros, de
tipos:
• numeric (número comum) – ex: 1,2,3;

• integer (inteiro) – ex: 20L,10L;
• complex (número complexo) ex.: 6 – 4i;
• character (texto) – ex.: “O Estratégia é TOP”;
• logical (lógicos, booleanos) ex.: TRUE, FALSE.
b) matrizes: coleção de vetores em linhas e colunas, todos os vetores dever ser

do mesmo tipo (numérico ou de caracteres).
c) dataframe: O mesmo que uma matriz, mas aceita vetores de tipos diferentes
(numérico e caracteres). Geralmente nós guardamos nossos dados em objetos
do tipo data frame, pois sempre temos variáveis numéricas e variáveis categóricas
(por exemplo, largura do rio e nome do rio, respectivamente). Similar a uma tabela
do SQL, um banco de dados.
d) listas: conjunto de vetores, dataframes ou de matrizes. Não precisam ter o

mesmo comprimento, é a forma que a maioria das funções retorna os resultados.
Muito útil para armazenar resultados de cálculos estatísticos.
e) funções: as funções criadas para fazer diversos cálculos também são objetos
do R.
f) factors (fatores): fatores são formas de representar objetos categóricos no R.
Todo objeto possui atributos intrínsecos: tipo e tamanho. Com relação ao tipo ele pode ser:
numérico, caractere, complexo e lógico. Existem outros tipos, como por exemplo,
funções ou expressões, porém esses não representam dados. As funções mode() e
length() mostram o tipo e tamanho de um objeto, respectivamente. Por exemplo:


> x<-c(1,3,5,7,11)
> 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 <- 1
> class(x)
[1] "numeric"
> y <- "a"

> class(y)
[1] "character"
> z <- TRUE

> class(z)
[1] "logical"
A tabela abaixo sintetiza os objetos e seus possíveis atributos (tipos). Veja:


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<-1:10 #cria uma sequência de inteiros de 1 a 10
> 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.


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 ...
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 <- matrix(c(10,3,3,2),nrow=2,ncol=2) # Matriz de Var-Covar

> mu <- c(1, 10) # Médias
> x <- mvrnorm(n=100, mu, Sigma) # Tenta gerar 100 obs., mas dá erro!
Error in mvrnorm(n = 100, mu, Sigma) : could not find function "mvrnorm"
# não foi possível achar a função mvrnorm.
Para que a função esteja disponível é necessário carregarmos a biblioteca. Já sabemos que
para isso devemos usar a funçõa library().
> library(MASS) # Carrega pacote
> x <- mvrnorm(n=100, mu, Sigma) # Agora funciona
> 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" "package:stats"
[5] "package:graphics" "package:grDevices" "package:utils" "package:datasets"


[9] "package:methods" "Autoloads" "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 <- MASS::mvrnorm(n=100, mu, Sigma)
Grande parte dos pacotes do R estão centralizados em um repositório chamado CRAN (The
Comprehensive R Archive Network), com diversos espelhos ao redor do mundo. Se o
pacote não estiver na sua máquina, você vai precisar baixar e instalar o mesmo. Essas
ações vão deixar o pacote disponível para carregamento na sua área de trabalho. Para
instalar um pacote, use a função install.
O legal é que qualquer pessoa pode fazer um novo pacote e disponibilizar para a
comunidade, o que acelera bastante o desenvolvimento da ferramenta. Dificilmente você
vai fazer uma análise apenas com as funções básicas do R e quase sempre vai existir um
pacote com as funções que você precisa.
Existem três principais maneiras de instalar pacotes. Em ordem de frequência, são:
Via CRAN (Comprehensive R Archive Network):
> 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.


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


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 que o objeto precisa

existir no ambiente para ter sua descrição impressa no
console.
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 <- 100

> x <- 1:n
> y <- 5 + 2 * x + rnorm(n, sd = 30)


> plot(x, y)
Figura 1 - 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 2 - Gráfico de dispersão ligado por uma linha (l).
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 3 - 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)
Figura 4 - 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")
Figura 5 - 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 6 - Gráfico de boxplot com duas variáveis.
Gráfico de barras
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 <- table(diamonds$color)
> barplot(tabela)


Figura 7 - Gráfico de barplot das quantidades x cores dos diamantes da tabela
Também podemos mapear duas variáveis a um gráfico de barras utilizando tabelas de dupla
entrada. VADeaths representa o gráfico de mortes por 1000 mil habitantes na Virgínia em
1940 divididos por faixa etária, sexo e local de residência (urbana ou rural).
> 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)


Figura 8 - Gráfico de barras com duas variáveis.
names()
Objetos podem ter elementos nomeados. Por exemplo, vamos nomear os elementos do
vetor notas.
> notas <- c(9.5, 9.9, 10)

> notas
[1] 9.5 9.9 10.0
> names(notas) <- c('Ricardo', 'Aline', 'Amanda')
> 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 <- c(546.9, 10.0, 789.0)

> names(numero) <- c("numero1", "numero2", "numero3")
> 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:


> 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 ")


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<-lm(hwy ~ displ, mpg)
> summary(mediaLinear)
Call:
lm(formula = hwy ~ displ, data = mpg)
Residuals:
Min 1Q Median 3Q Max
-7.1039 -2.1646 -0.2242 2.0589 15.0105
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 35.6977 0.7204 49.55 <2e-16 ***
displ -3.5306 0.1945 -18.15 <2e-16 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
Residual standard error: 3.836 on 232 degrees of freedom
Multiple R-squared: 0.5868, Adjusted R-squared: 0.585
F-statistic: 329.5 on 1 and 232 DF, p-value: < 2.2e-16
Não quero, por favor, que você se preocupe em entender os valores acima!!! Se
preocupe apenas em perceber que a função summary descreve várias características do
objeto mediaLinear.
Aritimética
O R tem uma série de operadores de aritmética básica e todos são vetorizados. Os
operadores nada mais são do que um atalho conveniente para funções, isto é, 1+2 é a
mesma coisa de ‘+‘(1,2). Assim, temos a lista de operadores:
• Soma (+),
• Subtração (-),
• Multiplicação (*)
• Divisão (/)
• Exponenciação (^)
• Resto da divisão (%%)
Além dos operadores básicos, há uma série de funções matemáticas, tais como:
• abs(x) # valor absoluto

• log(x) # logaritmo
• exp(x) #exponenciação


• sqrt (x) # raiz quadrada

• factorial (x) #fatorial
• choose (10,2) #combinação
Há também diversas funções trigonométricas, como seno sin(), cosseno cos(), tangente
tan() e outras.
> sin(0.5);cos(0.4);tan(3)
[1] 0.4794255
[1] 0.921061
[1] -0.1425465
Há também funções que operam com todos os valores do vetor. Por exemplo, a função
sum() retorna o somatório ou a função prod() o produtório. Essas funções também têm sua
versão acumulada. Vamos criar um vetor x e brincar um pouco com ele:
> 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
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)
– NULL valor indefinido (objeto nulo)


– Inf ou -Inf infinito (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”
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 9 - 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 <- matrix(

seq(1, 100),
ncol = 10,
nrow = 10)
Percebemos que o R, por default, preenche a matriz por colunas e não por linhas. No
entanto, podemos criar uma matriz preenchendo primeiro as linhas e depois as colunas.
Para isso, basta definirmos o argumento byrow = TRUE. Vejamos o resultado do exemplo
anterior com o preenchimento por linhas e depois por colunas.
> matriz01 <- matrix(


seq(1, 100),
ncol = 10,
nrow = 10,
byrow = TRUE)
O R trabalha com o conceito de reciclagem, onde operações ou objetos criados de um

vetor, quando necessário repete os elementos do vetor. Para que haja reciclagem um dos
elementos envolvidos deve ser um vetor (e.g. o outro pode ser uma matriz). Veja o exemplo:
> A <- matrix(1:10, nrow = 1);

> B <- 4:5;
> A + B;
> A * B
Operações matemáticas com matrizes

As operações com matrizes numéricas seguem praticamente a mesma lógica dos vetores.
Ao realizar qualquer operação com uma constante numérica, a operação é feita para todos
os elementos da matriz.
> matriz01 * 10
Já funções como mean(), sum(), sd() funcionam também como ocorre com os vetores, ou
seja, levam em consideração todos os elementos da matriz. Há uma série de funções úteis
para trabalharmos com matrizes, seguem algumas:
Função Descrição
t() Retorna a matriz transposta
diag(k) Cria uma matriz identidade k x k
det() Calcula o determinante da matriz
diag() Retorna os elementos da diagonal principal
dim() Retorna a dimensão da matriz
ncol Retorna o número de colunas da matriz


nrow() Retorna o número de linhas da matriz
rowSums() Retorna a soma das linhas da matriz
rowMeans() Retorna a média das linhas da matriz
colSums() Retorna a soma das colunas da matriz
colMeans() Retorna a média das colunas da matriz
Manipulando matrizes
==275324==
Assim como nos vetores, podemos selecionar quaisquer elementos de uma matriz. A
diferença é que, para selecionarmos um elemento em uma matriz, devemos informar em
qual linha e coluna se encontra o dado que queremos. Digamos que o elemento que
desejamos obter o valor se encontra na terceira linha da quarta coluna da nossa matriz01,
criada anteriormente. A solução é a seguinte:
> 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:
> 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) <- c("bim-1", "bim-2", "bim-3", "bim-4")

> rownames(notas) <- c("João", "Pedro", "Amanda", "Fábio",
"Fernanda", "Gustavo","Severino", "Paulo", "Laura", "Túlio")
> notas
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
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", ]
8 10 5 5
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
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)

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.


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,
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.


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;
• 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.
Laços com for (repetições)
Frequentemente, precisamos executar uma sequência de comandos um certo número de
vezes. O conjunto de comandos é executado uma vez e, em seguida, o fluxo de execução
retorna ao primeiro comando do conjunto e o processo continua um certo número de vezes.
Esta estrutura de repetições de uma sequência de comandos é chamada de laço (em inglês
loop). Cada uma das repetições é chamada de iteração.
Suponhamos você queira somar os elementos de um vetor numérico e não tivéssemos a
função sum() à nossa disposição. Um maneira de realizar esta soma no R é usar uma
estrutura como no exemplo abaixo:
x = c(1:10, 21:30)
soma = 0
for (i in 1:length(x)) {
soma = soma + x[i]
}
soma
## [1] 310
Os laços formados com a palavra-chave for executam os comandos entre chaves quantas
vezes a expressão entre parênteses especificar. No exemplo acima, o comando soma =
soma + x[i] vai ser executado para cada valor de i, que assume em sequência os valores de
1 até o comprimento do vetor x. Assim, a variável soma vai adicionando sucessivamente os
valores do vetor x.
Existe uma função chamada seq_len() que substitui a expressão 1:length(). Então laço for
acima poderia ser escrito como:
for (i in seq_len(x)) {
soma = soma + x[i]
}
Laços aninhados
Laços podem ser aninhamos quantas vezes forem necessárias, embora, normalmente,
mais de três níveis de aninhamento seja raramente necessário.


O código abaixo calcula a soma dos elementos de uma matriz, onde no laço externo, i
percorre as linhas da matriz, e, no laço interno, j percorre as colunas da matriz.
Inicialmente i = 1 e j assume o valor 1. O laço interno é executado para cada valor de j, que
assume sucessivamente os valores de 1 a 5. No laço interno, a variável soma vai
adicionando os respectivos valores de x[1,j]. Quando j chegar a 5, o fluxo retorna para o
laço mais externo, i é incrementado de uma unidade e o fluxo retorna para o laço interno,
onde j novamente assume os valores de 1 a 5. A sequência de iterações se encerra quando
i chega à última linha e j percorre as colunas da matriz.
x <- matrix(11:35, 3, 5)
## Warning in matrix(11:35, 3, 5): comprimento dos dados [25] não é um submúltiplo
## ou múltiplo do número de linhas [3]
soma = 0
for(i in seq_len(nrow(x))) {
for(j in seq_len(ncol(x))) {
soma = soma + x[i,j]
}
}
soma
## [1] 270
laços com while
Laços do tipo while possuem a seguinte estrutura:
while ( expressão lógica ) { * sequência de comandos }*
Inicialmente a expressão lógica é avaliada. Se ela for verdadeira, a sequência de comandos
entre chaves é executada. Em seguida a expressão lógica é novamente avaliada e, assim
por diante, até que a expressão lógica seja falsa e então o fluxo de execução sai do laço.
Vamos reescrever o código para calcular a soma dos elementos de um vetor numérico
utilizando o laço com while. Observe a expressão lógica i <= length(x) que é testada a cada
iteração. Inicialmente i é igual a 1 e é incrementado em uma unidade a cada iteração.
Quando i atinge o valor igual ao comprimento de x, o laço é interrompido.
x = c(1:10, 21:30)
soma = 0
i=1
while (i <= length(x)) {
soma = soma + x[i]
i=i+1
}
soma
## [1] 310
No exemplo, o laço com for é mais simples. Em laços com while, é preciso tomar cuidado
para que a expressão lógica não seja sempre verdadeira. Caso a expressão lógica nunca
se torne falsa, o laço nunca terminará. Esse tipo de situação é conhecido como loop infinito.


laços com repeat e break

Um laço com repeat no R é executado sucessivas vezes até ser interrompido pelo
comando break.
Vamos novamente reescrever o código para calcular a soma dos elementos de um vetor
numérico utilizando agora o laço com repeat. Inicialmente i é igual a 1 e é aumentado de
uma unidade a cada iteração. Quando i atinge o valor igual ao comprimento de x, a
condição i > length(x) é verdadeira e o comando break é executado, interrompendo o laço.
x = c(1:10, 21:30)
soma = 0
i=1
repeat {
soma = soma + x[i]
i=i+1
if (i > length(x)) {
break
}
}
soma
## [1] 310
O comando break, como o nome indica, interrompe a execução de um loop sempre que for
executado.
next
O comando next é usado para pular uma iteração de um laço.
Vamos supor que desejamos somar somente os elementos a partir do décimo-primeiro. O
código deveria ser alterado como abaixo:
x = c(1:10, 21:30)
soma = 0
for (i in 1:length(x)) {
if (i < 11) {
next
}
soma = soma + x[i]
}
soma
## [1] 255


RESUMO
Nesta aula, aprendemos que R é uma linguagem de programação multi-paradigma
(funcional e orientada a objetos), dinâmica, fortemente 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 também 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
Mostra o resumo de ‘a’. Geralmente um resumo estatístico. Mas há

summary(a)
diferentes operações para diferentes classes de ‘a’.
ls() lista os objetos criados no console.
dir(“diretório”) lista arquivos de determinado diretório.
IMPORTANDO E EXPORTANDO


Comando Descrição
load(): carrega datasets(dados) escritos com save
data(x) carrega dados específicos
library(x) carrega um pacote de dados.
lê um arquivo no formato de tabela e cria a partir dele um dataframe; O

read.table(file) 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
pode se entender c de combinar. É uma função genérica que combina os

c(...)
argumentos em um vetor.
gera uma sequência. Os dois pontos (:) tem a prioridade na operação.

from:to
Exemplo: 1:4+1, a saída no console é “2,3,4,5”.
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(from,to)
> 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.
Exemplos:
rep(x,times) > 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
data.frame() cria um data frame com os argumentos, nomeados ou não.


list() cria uma lista com os argumentos
cria uma matrix; com nrow=número de linhas e ncol=número de colunas.

matrix(x,nrow=,ncol=)
Elementos menores serão reciclados.
combina os argumentos por linhas em uma matriz, data frame e entre

rbind(...)
outros.
combina os argumentos por colunas em uma matriz, data frame e entre

cbind(...)
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
Seleciona os elementos do vetor x nas posições especificadas,

x[c(1,3,5)]
neste caso, 1,3 e 5.
x[“nome”] Seleciona o elemento do vetor x, pelo nome indicado.
Seleciona todos os elementos do vetor x maiores que 3, vejamos

um exemplo:
x[x>3] x[x>1]
[1] 2.549633 5.888932 4.145929 1.332829 4.538
487 4.140993 4.745690 2.988220


PLOTANDO GRÁFICOS
Comando Descrição
Cria um gráfico com os valores de a no eixo y e no eixo x a sua respectiva

plot(a)
posição.
Cria um gráfico em que os valores de a estarão no eixo x e os valores de

plot(a,b)
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).


cria um gráfico do tipo box-plot.
boxplot(x)


QUESTÕES COMENTADAS
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.

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

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

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



A função abaixo pula as primeiras 20 iterações do loop.

for(i in 1:100)
if(i <= 20) {
next
}
print(i)
}
Comentário: O comando next pula para a próxima iteração loop.
Gabarito: C

O resultado da função abaixo é 5
x <-3
switch(x, 2+2, mean(1:10), rnorm(5))
Comentário: Na função switch(valor, lista, ...), se o primeiro parâmetro for um número entre 1
e o comprimento da lista, o elemento correspondente da lista será avaliado e o resultado
retornado. Aqui, valor é um número (3), portanto, o terceiro valor é obtido da lista de valores,
que é rnorm (5). A saída para rnorm (5) será impressa.
> x <- 3
> switch(x, 2+2, mean(1:10), rnorm(5))
[1] 0.2363995 0.1745040 -2.7320329 0.1886224 -0.2821843
Se o valor numérico estiver fora do intervalo (maior que o número de itens na lista ou menor
que 1), NULL será retornado. Vejamos alguns exemplos:
> switch(2,"red","green","blue")
[1] "green"
[1] "red"
NULL
NULL
Gabarito: E.



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 <- 1:5
for (val in x) {
if (val == 3){
next
}
print(val)
}
[1] 1
[1] 2
[1] 4
[1] 5
Gabarito: C

Uma instrução break é usada dentro de um loop (repaet, for, while) para interromper as
iterações e fazer fluir o controle para fora do loop.
Comentário: O break é usado para sair de um loop imediatamente, independentemente de
qual iteração o loop possa estar. Vejamos um exemplo:
x <- 1:5
for (val in x) {
if (val == 3){
break
}
print(val)
}
[1] 1


[1] 2
Gabarito: C

break e next são duas estruturas de controle para controlar explicitamente o loop.
Comentário: Existem duas instruções que podem ser usadas para controlar explicitamente
looping, break e next.
Gabarito: C

Escrever funções é uma atividade secundária de um programador R.
Comentário: Escrever funções é uma atividade principal de um programador R. As funções são
frequentemente usadas para encapsular uma sequência de expressões que precisam ser
executadas várias vezes.
Gabarito: E

As funções são definidas usando a diretiva function() e são armazenadas como objetos R.
Comentário: As funções são criadas usando a diretiva function() e são armazenadas como
objetos R, assim como todos os outros elementos de R. Em suma, são objetos R da classe
"function".
Gabarito: C

A função graph() é usada para plotagem de gráficos no R base.
Comentário: plot () é uma função genérica para plotagem de objetos R. Para gráficos de
dispersão simples, o plot será usado. No entanto, existem métodos de plotagem para muitos
objetos R, incluindo funções, data.frames, objetos de densidade, etc.
Gabarito: E

A função names() lista nomes das variáveis em um data.frame.


Comentário: names é uma função assessora genérica para lista o nome das variáveis. Os
métodos padrão obtêm e definem o atributo "names" de um vetor (incluindo uma lista) ou
pairlist.
Gabarito: C

x <- c(1, 2, NA, 4, NA, 5)
deuruim <- is.na(x)
print(deuruim)
O resultado do código acima é:
FALSE FALSE TRUE FALSE TRUE FALSE
Comentário: Uma tarefa comum na análise de dados é remover valores ausentes (NAs). is.na()
retornará TRUE se o elemento for NA, caso contrário, retornará false. Aqui, o vetor x contém
dois valores NAs no terceiro e quinto índice.
Portanto, ele exibirá no console:
Gabarito: C

O pacote dplyr pode ser instalado a partir do CRAN, usando library(“dplyr”).
Comentário: Você pode instalar pacotes R disponíveis nos repositórios online usando
install.packages e carregá-los. O código correto seria:
install.packages ("dplyr")
Gabarito: E

Arquivos contendo scripts R terminam com a extensão .R
Comentário: Os arquivos que contêm scripts R têm uma extensão ".R".
Gabarito: C
16. Ano: 2018 Banca: CESPE Assunto: Informática para Polícia Federal Cargo:
Agente Conteúdo: Linguagem R


Julgue os próximos itens, relativos a noções de programação Python e R.

93 Considere o programa a seguir, escrito em R.
x <- c (3, 5, 7)
y <- c (1, 9, 11)
print (x + y)
Após a execução do programa, será obtido o seguinte resultado.
[1] 36
x <- TRUE
y <- FALSE
print (xy)
[1] FALSE
Comentário: Vamos comentar as alternativas acima.
93. Neste caso temos 2 vetores com 3 elementos cada um. A operação x + y vai fazer
o somatório dos de cada um dos termos. Veja o código abaixo:
> x <- c (3, 5, 7)
> y <- c (1, 9, 11)
> print (x + y)
[1] 4 14 18
Neste caso o valor retornado pela função print vai retornar como resultado o vetor 4 ,
14 e 18. Logo, a alternativa está incorreta.
94. Nesta alternativa atribuímos valores booleanos as variáveis x e y. Em seguida,
pedimos para imprimir o atributo xy, que não existe no sistema. Isso retornar um erro
conforme visto abaixo.
> x <- TRUE
> y <- FALSE
> print (xy)
Error in print(xy): object 'xy' not found
Logo, temos mais uma alternativa errada.

Gabarito: 93. E 94. E
17. Ano: 2018 Prova: Perito – Polícia Federal Banca: CESPE Assunto:
Conhecimentos básicos – banco de dados e teoria da informação.
Com relação à programação Python e R, julgue os itens que se seguem.
43 Considere os comandos a seguir, na linguagem R, os quais serão executados no
ambiente do R, e considere, ainda, que > seja um símbolo desse ambiente.


> helloStr <- "Hello world!"

> print(helloStr)
Nesse caso, após a execução dos comandos, será obtido o resultado a seguir.
[1] "Hello world!"
Comentário: Vamos comentar cada uma das afirmações acima.
Neste caso os comandos vão de fato fazer o que está descrito. Primeiramente, vamos
atribuir a uma variável helloStr um conjunto de caracteres (“Hello world!”). Em seguida
vamos imprimir no Console esse mesmo valor. Neste caso temos [1] "Hello world!",
exatamente como no enunciado. Logo, a alternativa está correta.
Gabarito: C.
Nossa sugestão é que você tente usar o R para fazer alguns exercícios que vão ajudar você
==275324==
na fixação do conteúdo. Você pode usar como referência a própria aula ou os slides da
videoaula sobre R.
18. Banca: TRC Ano: 2020 Concurso: Simualdo
Abra o R Studio e tente fazer o seguinte exercício.
1. Remova todos os objetos do ambiente de trabalho.
2. Crie objetos com nomes dados_Agente, dados_Perito, dados_Papi, dados_Escrivao.
Faça com que os objetos sejam do tipo numérico, character, lógico e inteiro.
3. Verifique a classe e a estrutura dos objetos criados.
4. Use ls() para listar apenas os dados de Perito. E depois para listar apenas os
dados de Agente.
5. Use rm() para remover apenas os dados de Escrivao (dica: você vai precisar de
usar o resultado de ls()).
6. Salve sua área de trabalho com o nome exercicio_objetos_aula_de_R.RData.
Uma possível solução para os itens acima:
1. rm(list=ls()) # remove todos os objetos
2. dados_Agente <- 10.5
dados_Perito <- "texto"
dados_Papi <- TRUE
dados_Escrivao <- 24L
3. class(dados_Agente)
class(dados_Perito)
class(dados_Papi)
class(dados_Escrivao)
str(dados_Agene)


str(dados_Parito)
str(dados_Papi)
str(dados_Escrivao)
4. perito <- ls(pattern="Perito")
agente <- ls(pattern="Agente")
5. rm(list=(ls(pattern="Escrivao"))
1) save.image(file=" objetos_aula_de_R.


LISTA DE QUESTÕES
As funcionalidades do R são divididas em vários pacotes.
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.
Os pacotes utils, lang e tools são considerados pacotes básicos do R.
A função abaixo pula as primeiras 20 iterações do loop.
for(i in 1:100)
if(i <= 20) {
next
}
print(n)
}
O resultado da função abaixo é 5
x <-3
switch(x, 2+2, mean(1:10), rnorm(5))
next é usado para pular uma iteração dentro do loop.


Uma instrução break é usada dentro de um loop (repaet, for, while) para interromper as
iterações e fazer fluir o controle para fora do loop.
break e next são duas estruturas de controle para controlar explicitamente o loop.
Escrever funções é uma atividade secundária de um programador R.
==275324==
As funções são definidas usando a diretiva function() e são armazenadas como objetos R.
A função graph() é usada para plotagem de gráficos no R base.
A função names() lista nomes das variáveis em um data.frame.
x <- c(1, 2, NA, 4, NA, 5)
deuruim <- is.na(x)
print(deuruim)
O resultado do código acima é :
O pacote dplyr pode ser instalado a partir do CRAN, usando library(“dplyr”).
Arquivos contendo scripts R terminam com a extensão .R
16. Ano: 2018 Banca: CESPE Assunto: Informática para Polícia Federal Cargo:
Agente Conteúdo: Linguagem R
Julgue os próximos itens, relativos a noções de programação Python e R.



x <- c (3, 5, 7)
y <- c (1, 9, 11)
print (x + y)
[1] 36
x <- TRUE
y <- FALSE
print (xy)
[1] FALSE
17. Ano: 2018 Prova: Perito – Polícia Federal Banca: CESPE Assunto:
Conhecimentos básicos – banco de dados e teoria da informação.
Com relação à programação Python e R, julgue os itens que se seguem.
43 Considere os comandos a seguir, na linguagem R, os quais serão executados no
ambiente do R, e considere, ainda, que > seja um símbolo desse ambiente.
> helloStr <- "Hello world!"
> print(helloStr)
Nesse caso, após a execução dos comandos, será obtido o resultado a seguir.
[1] "Hello world!"


GABARITO
1. C
2. C
3. E
4. C
5. E
6. C
7. C
8. C
9. E
10. C
11. E
12. C
13. C
14. E
15. C
16. E E
17. C


Aula 30 - Linguagem R - Prof Thiago Cavalcanti

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Aula 30 - Linguagem R - Prof Thiago Cavalcanti

Enviado por

Direitos autorais:

Formatos disponíveis

Aula 30 - (Prof.

40181815826 - Flávio Ricardo Cirino

2) Uma Viagem pelo R

3) Questões Comentadas - Linguagem R - Multibancas

4) Lista de Questões - Linguagem R - Multibancas

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 2

40181815826 - Flávio Ricardo Cirino

Em nossa videoaula, mostramos o passo a passo para instalação do R e do R Studio. É um

Um passo a passo para produzir

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 3

40181815826 - Flávio Ricardo Cirino

O R é uma linguagem funcional/orientada a objetos criada em 1996 por Ross Ihaka e

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 4

40181815826 - Flávio Ricardo Cirino

Além disso, R é uma linguagem interpretada e uma ferramenta poderosa para

Linguagem compiladas x interpretadas

Uma das classificações possíveis para linguagens de programação é quanto a

O processo de converter um programa de uma linguagem para outra é chamado

O processo de tradução consiste em três atividades – análise léxica, análise

Observem que o programa objeto será executado e sua organização depende do

Já a linguagem interpretada é uma linguagem de programação, onde o código

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 5

40181815826 - Flávio Ricardo Cirino

Como vantagens da linguagem interpretada podemos listar:

• São rápidas e práticas, permitem agregar funcionalidades sem depender de

• Por não ser compilada, erros de sintaxe não são identificados no

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 6

40181815826 - Flávio Ricardo Cirino

Podemos dividir a tela do RStudio em quatro grandes áreas:

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 7

40181815826 - Flávio Ricardo Cirino

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 8

40181815826 - Flávio Ricardo Cirino

Acostume-se a escrever o código no Script ao invés de ficar escrevendo diretamente no console.

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 9

40181815826 - Flávio Ricardo Cirino

1. Ano: 2020 Prova: Simulado Banca: TRC Assunto: Linguagem R

NOSSA PRIMEIRA AULA DE R

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 10

40181815826 - Flávio Ricardo Cirino

> olamundo <- “HelloWorld

> x <- c (1,2,4)

> q <- c (x, x, 8)

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 11

40181815826 - Flávio Ricardo Cirino

Como em outras linguagens, o seletor (aqui, 3) é chamado de índice. Aqueles

> x <- c (1,2,4)

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 12

40181815826 - Flávio Ricardo Cirino

Se quisermos salvar a média calculada em uma variável em vez de apenas imprimi-la na

> y <- mean(x)

Mais uma vez, vamos confirmar que y realmente contém a média de x:

Como observado anteriormente, usamos # para escrever comentários, assim:

Os comentários são especialmente valiosos para documentar o código do programa, mas

> mean (Nile)

Podemos também traçar um histograma dos dados:

> hist (Nilo)

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 13

40181815826 - Flávio Ricardo Cirino

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

Polícia Federal (Agente de Polícia) Informática - 2023 (Pré-Edital) 14

40181815826 - Flávio Ricardo Cirino

especialmente ao trabalhar com conjuntos de dados grandes ou numerosos. Responder “y”