2  Conceitos Básicos do Ambiente R e Importação e Exportação de Dados e Objetos

2.1 Introdução ao

O que é o ?

  • É parte do projeto GNU1: Portanto, é uma linguagem de progração livre e código aberto.

  • O é uma linguagem de programação e ambiente para computação estatística e gráfica.

Logo do R.
Fonte: CRAN

2.2 História e Contexto do R

R é um ambiente estatístico, cujo desenvolvimento se deu início em 1993, e lançamento em meados de 1995, quando os professores de estatística da Universidade de Auckland Ross Ihaka e Robert Gentleman perceberam a necessidade de uma linguagem de programação mais acessível e eficiente para análise de dados. O Objetivo era o desenvolvimento de uma ferramenta que combinasse a facilidade de uso e a flexibilidade da linguagem S com a escalabilidade e a extensibilidade necessárias para enfrentar os desafios da análise de dados cada vez mais complexa.

O nome “R” foi inspirado nas primeiras letras dos nomes dos criadores, mas também remete à ideia de um ambiente estatístico e reutilizável, referindo-se às características da linguagem S na qual o R foi baseado.

O R é um software de código aberto2, sendo isso fundamental para o seu crescimento e popularidade. Além de permitir que a comunidade global de estatísticos, cientistas de dados, pesquisadores e desenvolvedores colaborasse e compartilhasse suas contribuições em forma de pacotes, expandindo continuamente as capacidades da linguagem.

O R foi lançado ao público em 1995, sendo inicialmente adotado principalmente por pesquisadores e acadêmicos nas áreas de estatística e ciências sociais. Contudo, com o a expansão da era do Big Data e o crescimento da necessidade de análise de dados em diversas indústrias, o R passou a ser empregado em diversas áreas, desde a análise de dados financeiros até a ciência ambiental, biologia, marketing e muito mais.

Com o crescimento exponencial de usuários e desenvolvedores de R o ecossistema de pacotes no CRAN expandiu-se para incluir milhares de pacotes criados por usuários de todo o mundo. Esses pacotes fornecem funcionalidades especializadas para praticamente diversas tarefas, transformando o R em uma linguagem altamente flexível e poderosa para análise de dados.

2.2.1 Contribuições e Desenvolvimento Contínuo

Um dos principais pontos positivos do R é a colaboração da comunidade de usuários e desenvolvedores. O desenvolvimento do R é mantido por uma equipe central, porém qualquer pessoa pode contribuir com melhorias, correções de bugs e novos pacotes, resultando em um fluxo constante de inovações e melhorias.

Além disso, o R possui integração com outras linguagens de programação, como C, C++, Python e SQL, permitindo a otimização de tarefas computacionalmente intensivas e a integração com outros ecossistemas de software.

2.3 Características e Vantagens do R

  1. Gratuito e de código aberto: O R é distribuído gratuitamente e permite acesso ao seu código-fonte, incentivando a colaboração e transparência.

  2. Extensibilidade e Pacotes: Através do sistema de pacotes disponível no CRAN (Comprehensive R Archive Network), os usuários podem facilmente estender suas funcionalidades, aproveitando inúmeros pacotes criados pela comunidade para tarefas especializadas.

  3. Visualização de Dados: Reconhecido por suas poderosas capacidades nessa área, o R oferece gráficos e relatórios de alta qualidade.

  4. Análise Estatística e Manipulação de Dados: O R disponibiliza uma ampla variedade de funções e bibliotecas para análise estatística e manipulação de dados, tornando-o popular entre estatísticos e cientistas de dados.

  5. Documentação e Ajuda: O R possui extensa documentação oficial, bem como inúmeros tutoriais e exemplos disponíveis online.

  6. Ambiente de Programação e Linguagem: O R é uma linguagem interpretada, executando o código linha por linha e mostrando os resultados em tempo real. Sua natureza vetorial possibilita manipular e realizar operações eficientes em conjuntos de dados.

  7. Objetos e Tipos de Dados: No R, tudo é um objeto, podendo ser vetores, matrizes, data frames, listas e outros tipos de dados. É importante entender os diferentes tipos de dados para realizar operações apropriadas em cada um deles.

  8. Operações Aritméticas e Relacionais: O R suporta operações aritméticas básicas, como adição, subtração, multiplicação e divisão, bem como operações relacionais, como maior que, menor que e igual a.

  9. Estruturas de Controle e Funções: O R oferece estruturas de controle, como loops (for, while) e condicionais (if, else, ifelse), permitindo repetir tarefas ou executar comandos com base em condições específicas. Além disso, as funções são blocos de código reutilizáveis que executam tarefas específicas. O R possui uma ampla variedade de funções internas e permite a criação de funções personalizadas.

  10. Integração com Outras Linguagens: O R pode ser integrado com outras linguagens de programação, como C, C++, Python e SQL, permitindo a otimização de tarefas computacionalmente intensivas e a integração com outros ecossistemas de software.

2.4 Principais Características da Linguagem

  • Além de ser uma linguagem estatística, o também apresenta inúmeros recursos gráficos, arte, aplicativos, sites, etc. Além disso, o R possui mais de 20 mil de pacotes oficiais na CRAN. O R é multiplatorma: , , , .

Além da parte estatística, o R pode ser utilizado para arte generativa, como o exemplo abaixo:

R pode ser utilizado para arte generativa.

2.5 Comunidade

O apresenra uma comunidade muito ativa e engajada, com diversos grupos de usuários e desenvolvedores espalhados pelo mundo. Conhecida por ser muito acolhedora e inclusiva, a comunidade R oferece cursos online e treinamentos gratuitos e pagos, além de eventos e conferências que reúnem profissionais e entusiastas da linguagem.

Links: Cheat-Sheets, R-Ladies, R-Studio, R-Project

2.5.1 Day

1o. R Day

Primeiro R Day: Realizado pela UFPR em 2018. YouTube

2.6 Ladies

Gabriela de Queiroz

O -Ladies foi fundado em 2012, em San Francisco, com o objetivo de promover a diversidade de gênero no ecossistema R. A organização oferece cursos e eventos gratuitos, abertos a comunidade, independentemente do gênero. Atualmente, o -Ladies possui mais de 200 grupos em 60 países, promovendo a inclusão e a diversidade na comunidade R.

2.7 O Projeto

https://www.r-project.org/

O Projeto é uma organização sem fins lucrativos que mantém o desenvolvimento do R e fornece suporte para a comunidade de usuários e desenvolvedores. O site oficial do projeto, www.r-project.org, é a principal fonte de informações sobre o R, incluindo downloads, documentação, tutoriais e notícias sobre o desenvolvimento da linguagem.

2.7.1 Obtendo e Instalando o R

Para instalar o R, basta acessar o site oficial do projeto e baixar a versão adequada para o seu sistema operacional. O R está disponível para Windows, macOS e Linux, e o processo de instalação é simples e direto. Após a instalação, você pode iniciar o R a partir da linha de comando ou de um ambiente de desenvolvimento integrado (IDE), como o RStudio.

2.8 O CRAN (Comprehensive R Archive Network)

O CRAN é o principal repositório de pacotes do R, mantido e organizado pela comunidade de desenvolvedores de R. Sendo criado para fornecer aos usuários do R uma plataforma centralizada para compartilhar, distribuir e acessar pacotes (bibliotecas) que estendem as funcionalidades do R. O CRAN hospeda cerca de 20.000 de pacotes desenvolvidos por usuários, de diversas áreas, desde estatística e aprendizado de máquina até ecologia, bioinformática e visualização de dados.

2.8.1 Explorando o CRAN

Podemos explorar o CRAN através do site oficial ou diretamente do R.

  1. Navegando no Site do CRAN: No site oficial do CRAN (https://cran.r-project.org/) é possível pesquisar por palavras-chave, categorias temáticas ou até mesmo pelo nome do pacote procurado. Cada pacote possui uma página com informações detalhadas sobre sua funcionalidade, documentação, autor e data de lançamento.
  • Visualizando os Pacotes: Divididos por área
  • Visualizando os Pacotes: Ordenados por nome
  1. Acessando o CRAN do Ambiente R: Para pesquisar um pacote diretamente no R podemos utilizar a função install.packages(), que instalará o pacote escolhido. Podemos também utilizar a interface gráfica do RStudio para gerenciar pacotes.

2.8.2 Repositórios além do CRAN

Além do CRAN existem outros repositórios de pacotes que oferecem uma variedade de bibliotecas desenvolvidas por diferentes comunidades, e embora o CRAN seja a principal fonte de pacotes para a maioria dos usuários, esses outros repositórios também podem ser úteis, especialmente quando se trata de pacotes mais especializados ou em fase de desenvolvimento. Os principais repositórios de pacotes do R, além da CRAN são:

  1. Bioconductor: O Bioconductor é um repositório focado em bioinformática e análise de dados genômicos. São especialmente projetados para lidar com dados de biologia e geralmente requerem algum conhecimento em bioinformática para uso efetivo.

  2. GitHub ou GitLab: Muitos pacotes R são hospedados em repositórios do GitHub, e é possível instalar esses pacotes diretamente do GitHub usando o pacote devtools.

2.9 Como Aprender ?

2.9.1 Hands-On Programming with R

2.9.2 R for Data Science

2.9.3 Hands-On Data Science with R

2.9.4 R Graphics Cookbook

2.9.5 Advanced R

2.9.6 The Book of R

2.9.7 ggplot2

2.9.8 Tidy Modelling with R

3 Configurações do Ambiente de Trabalho

3.1 Download e Instalação do R

Após a instalação do R pela CRAN, já podemos começar a programar em R.

3.2 Modos de execução da Linguagem

3.2.1 Nativo

Podemos utilizar o R de forma nativa, interativa, digitando comandos diretamente no console. Para isso, podemos simplesmente abrir o R e começar a digitar os comandos.

3.2.2 IDE’s & Editores para a Linguagem

Existem diversas opções de ambientes de desenvolvimento integrado (IDEs) e editores de texto que facilitam a programação em R.

  • IDE: Ambiente de Desenvolvimento Integrado, são ambientes de programação que oferecem uma série de ferramentas para facilitar o desenvolvimento de código, como realce de sintaxe, depuração, visualização de gráficos e integração com o sistema de controle de versão.

  • Editores: Editores de Texto gerais, são editores de texto padrão que não necessariamente são voltados para programação, mas que com auxílio de plug-ins, podem ser utilizados para programar.

  • IDE’s: Ambientes de Desenvolvimento Integrado (Integrated Development Environment)
  • RStudio
  • RCode
  • TinnR
  • Editores: Editores de Texto gerais, que com auxílio de plug-ins, podem ser utilizados para programar em R.
  • VSCode
  • Vim
  • Atom
  • Emacs
  • Sublime Text

3.3 Modos de execução

Existem diversas maneiras que podemos executar códigos em R: - Utilizando scripts, que são arquivos de texto contendo uma sequência de comandos R. - Interativamente, digitando comandos diretamente no console. - Interativamente, utilizando um ambiente de desenvolvimento integrado (IDE).

3.3.1 Scripts

Podemos criar scripts em R, que são arquivos de texto contendo uma sequência de comandos R. Para criar um script, basta abrir um editor de texto, digitar os comandos R e salvar o arquivo com a extensão .R. Podemos executar um script em R direto pelo terminal, utilizando o comando Rscript:

  • R CMD BATCH meu_codigo.R minha_saida.Rout
  • Rscript meu_codigo.R

Também posso executar um script em R diretamente pelo R, utilizando o comando source():

  • source("meu_codigo.R")

3.3.2 Utilizando o RStudio

A IDE mais popular para a linguagem R é o RStudio. O RStudio é uma IDE de código aberto que oferece uma série de recursos para facilitar o desenvolvimento de código em R, além de sua integração com outras linguagens, como C, C++, Python e SQL.

O RStudio é mantido pela Posit, uma empresa especializada em ferramentas para ciência de dados e análise estatística. O RStudio é amplamente utilizado por estatísticos, cientistas de dados, pesquisadores e desenvolvedores de R em todo o mundo. Além da versão Desktop, existem versões online, como o RStudio Server, que permitem acessar o RStudio a partir de um navegador da web.

Como já vimos, o RStudio oferece integração automática com sistemas de versionamento de código (Git/SVN), facilitando o controle de versão e o trabalho colaborativo. Além disso, o RStudio possui uma interface gráfica intuitiva, com guias para visualização de gráficos, ambiente de trabalho, histórico de comandos e arquivos, facilitando a organização e a execução de tarefas.

3.3.2.1 Abrindo o RStudio

3.3.2.2 Criando Arquivos

Para criar um novo script em RStudio, basta clicar em File > New File > R Script ou utilizar o atalho Ctrl + Shift + N. Isso abrirá uma nova guia onde você pode digitar seus comandos R.

3.3.2.3 Tabs

O RStudio possui várias guias que facilitam a organização e a execução de tarefas. As principais guias são: - File: Navegação de arquivos - Plots: Visualização de gráficos - Session: Informações sobre a sessão atual - Tools: Onde podemos realizar nossas configurações

3.3.2.4 Configurações

O RStudio oferece uma série de configurações que podem ser personalizadas de acordo com as preferências do usuário. Para acessar as configurações, basta clicar em Tools > Global Options.

3.3.2.5 Criando Projetos

Uma das funcionalidades mais úteis do RStudio é a capacidade de criar projetos. Um projeto no RStudio é um ambiente de trabalho que inclui um diretório de trabalho, arquivos, scripts e configurações específicas para um projeto específico. Isso facilita a organização e a colaboração em projetos de análise de dados e programação em R.

Mais sobre o RStudio neste cheatsheet.

4 Mecanismos de ajuda

Saber buscar ajuda e consultar à documentação oficial de pacotes e funções são essenciais para qualquer usuário do R, independentemente do nível de experiência. No R cada função apresenta uma documentação padrão, além de mecanismos integrados para fornecer ajuda instantânea. As principais maneiras de obter ajuda em R são:

  1. ? e help(): No R, o ponto de interrogação ? e a função help() são utilizados para acessar a documentação de funções e pacotes. Por exemplo, para obter ajuda sobre a função mean(), você pode digitar ?mean ou help(mean) no console. Isso abrirá a ajuda (documentação) da função mean() com a descrição da função, os argumentos que ela recebe, seu uso correto, exemplos de uso e informações sobre os valores de retorno. Além disso, você pode encontrar links para outras funções relacionadas e exemplos de código úteis.

  2. ??, help.search() e apropos(): O ?? é outro operador que permite fazer uma pesquisa na documentação do R usando palavras-chave. Por exemplo, ??plot realizará uma busca por tópicos que contenham a palavra “plot” na documentação de funções e pacotes. O resultado será uma lista de funções e pacotes relacionados ao termo pesquisado. Para realizar a mesma pesquisa usando a função help.search(), você pode digitar help.search("plot") no console. Isso fornecerá um resultado semelhante ao ??. Já a função apropos() é útil para encontrar funções que contenham uma determinada palavra-chave no nome. Por exemplo, apropos("plot") retornará todas as funções que possuem “plot” no nome.

  3. vignette(): Muitos pacotes do R incluem documentos chamados “vignettes”, que são tutoriais e guias práticos sobre o uso do pacote. Para acessar as vignettes de um pacote específico, podemos executar vignette(package = "nomedopacote"). Isso abrirá uma lista das vignettes disponíveis para esse pacote.

4.1 Dicas para usar a Ajuda no R

  • Quando estiver no ambiente RStudio, a ajuda exibida pelo ? ou help() aparecerá em uma guia de ajuda na área de trabalho. Isso permite que você consulte a documentação sem sair do ambiente de desenvolvimento.

  • Se você não souber o nome exato de uma função, mas lembrar de uma palavra-chave relacionada, pode usar o ?? ou help.search() para encontrar funções que correspondam à palavra-chave.

  • A documentação oficial do R geralmente é bem escrita e detalhada, com muitos exemplos úteis. É uma boa prática ler a documentação para entender completamente como usar uma função ou pacote.

  • Além dos recursos internos de ajuda, também é possível encontrar tutoriais e guias online sobre o R. Blogs, sites de tutoriais e fóruns da comunidade podem ser ótimas fontes de informações adicionais e soluções para problemas específicos.

5 Uma (muito) Breve Introdução

5.1 Manipulação de expressões e diferenciação de letras maiúsculas e minúsculas.

No R, a manipulação de expressões e a diferenciação entre letras maiúsculas e minúsculas são aspectos importantes a serem considerados ao escrever scripts e trabalhar com objetos na linguagem. Vamos explorar esses conceitos em detalhes:

  1. Manipulação de Expressões: A manipulação de expressões refere-se à forma como o R interpreta e processa os comandos e expressões de código que são fornecidos pelo usuário. O R é sensível a espaços em branco e a outros caracteres especiais que podem afetar a execução dos comandos. Algumas considerações importantes são:

  • Final de linha: O R considera o final da linha como um indicador de que o comando está completo. Se um comando for muito longo, você pode usar a notação (...) para continuar o comando na próxima linha. Você também pode simplesmente continuar seu código na próxima linha.

  • Comentários: O R ignora qualquer texto após o símbolo #, permitindo que você insira comentários para explicar seu código.

  1. Diferenciação de Letras Maiúsculas e Minúsculas: O R é case sentive, isto é, o diferencia letras maiúsculas e minúsculas em nomes de objetos, funções e palavras reservadas. Isso significa que variavel e Variavel são tratadas como objetos distintos. Portanto, é importante manter a consistência na nomeação de objetos e funções.

  • Nomes de Variáveis e Funções: Ao nomear suas variáveis e funções, é aconselhável usar apenas letras minúsculas e, se necessário, separar palavras com underscore (_) ou camelCase. Por exemplo: nome_variavel, meu_contador, calcularMedia, etc. (Mais aqui)

  • Palavras Reservadas: O R possui palavras reservadas que são usadas para funções ou operações internas e não devem ser usadas como nomes de objetos. Algumas palavras reservadas incluem if, else, while, function, for, c, entre outras. (Mais aqui)

5.2 Exemplos de Manipulação de Expressões e Diferenciação de Letras Maiúsculas e Minúsculas

# Exemplo de manipulação de expressões
x <- 5
y<-10 # Não recomendado, espaços são mais legíveis
z <- (x +
        y) # Continuando o comando em outra linha
x # imprime na tela o valor de x
[1] 5
y # imprime o valor de y
[1] 10
z # imprime o valor de z
[1] 15
# Exemplo de diferenciação de letras maiúsculas e minúsculas
variavel <- 42
Variavel <- 24

variavel
[1] 42
Variavel
[1] 24

5.3 Convenções de Nomenclatura de Variáveis no R

As convenções de nomenclatura de variáveis são uma parte importante da prática de programação, pois tornam o código mais legível, consistente e facilitam a colaboração entre os membros da equipe de desenvolvimento. No R, existem duas convenções principais de nomenclatura de variáveis amplamente utilizadas:

  1. Camel Case e Pascal Case: Na convenção Camel Case, o nome da variável é escrito como uma frase sem espaços, onde as palavras são unidas e a primeira letra de cada palavra, exceto a primeira, é escrita em maiúscula. Por exemplo: calcularMedia, idadeDoUsuario, meuContador.

O Pascal Case é uma variação do Camel Case, onde a primeira letra de cada palavra, incluindo a primeira, é escrita em maiúscula. Por exemplo: CalcularMedia, IdadeDoUsuario, MeuContador.

Essas convenções são amplamente utilizadas em outras linguagens de programação, como Python, Java e C#.

  1. Snake Case: No Snake Case, o nome da variável é escrito como uma frase sem espaços, onde as palavras são unidas por underscores (_). Todas as letras são escritas em minúsculas. Por exemplo: calcular_media, idade_do_usuario, meu_contador.

Essa convenção é particularmente útil em ambientes que não diferenciam letras maiúsculas e minúsculas, pois ajuda a melhorar a legibilidade dos nomes das variáveis.

5.3.1 Compreensão de Palavras Reservadas

No R, palavras reservadas são termos que possuem significado especial para a linguagem e são usadas para funções, comandos ou operações internas. Essas palavras não podem ser usadas como nomes de variáveis, funções ou objetos, pois isso causaria conflito com o significado e comportamento original dessas palavras na linguagem.

Exemplos de palavras reservadas no R incluem if, else, for, while, function, TRUE, FALSE, NULL, break, next, entre outras.

É importante compreender as palavras reservadas do R para evitar problemas ao nomear suas variáveis e funções. Caso você acidentalmente tente utilizar uma palavra reservada como nome de variável, o R emitirá um erro e indicará que a palavra é uma palavra reservada e não pode ser usada.

x <- seq(1:10)
x
 [1]  1  2  3  4  5  6  7  8  9 10
for <- seq(1:10)
Error in parse(text = input): <text>:1:5: unexpected assignment
1: for <-
        ^
if <- seq(1:20)
Error in parse(text = input): <text>:1:4: unexpected assignment
1: if <-
       ^

5.4 Execução, Recuperação e Correção de Comandos

Ao trabalhar com o R, é comum escrever e executar comandos em um ambiente interativo, como o console do RStudio. No entanto, erros podem ocorrer durante a execução desses comandos. Existem várias formas de lidar com a execução, recuperação e correção de comandos no R:

1. Execução de Comandos: Para executar um comando, basta digitá-lo no console do RStudio ou em um script e pressionar a tecla Enter. O R executará o comando e exibirá o resultado, se houver. No entanto, se houver algum erro no comando, o R exibirá uma mensagem de erro, indicando o tipo e a causa do erro.

2. Recuperação de Comandos: Em alguns casos, você pode querer recuperar comandos anteriores para reexecutá-los ou modificá-los. No RStudio, você pode usar as teclas de seta para cima e para baixo para navegar pelos comandos anteriores digitados no console. Também é possível usar o histórico de comandos, que pode ser acessado clicando na guia “History” no ambiente do RStudio.

3. Correção de Comandos: Se um comando apresentar um erro, você pode corrigi-lo diretamente no console ou no script antes de reexecutá-lo. É importante observar a mensagem de erro fornecida pelo R, pois ela geralmente indica o local do erro e a causa do problema. Após fazer as correções necessárias, você pode pressionar a tecla Enter para reexecutar o comando.

4. Função traceback(): A função traceback() pode ser útil para depurar o código quando ocorrem erros mais complexos. Ela exibe o rastreamento das chamadas de função que levaram ao erro, ajudando a identificar em qual parte do código o problema ocorreu.

5. Modo Debug: O RStudio possui um modo de depuração (Debug) que pode ser ativado clicando no botão “Debug” ou usando a combinação de teclas Ctrl + Shift + D. O modo de depuração permite que você execute o código linha por linha, inspecione os valores das variáveis em cada etapa e localize a origem de possíveis erros.

6 Programando em R: Fundamentos

6.1 Operadores

Os operadores são símbolos especiais que realizam operações em variáveis e valores. Em R, os operadores são usados para realizar cálculos aritméticos, comparações, atribuições e outras operações. Os operadores em R podem ser classificados em várias categorias, incluindo operadores aritméticos, operadores relacionais, operadores lógicos e operadores de atribuição.

6.1.1 Operadores Aritméticos

Os operadores aritméticos são usados para realizar operações matemáticas em valores numéricos. Os operadores aritméticos em R incluem:

x <- 10
y <- 5
  1. + (Adição): Realiza a adição entre dois valores.
soma <- x + y
soma
[1] 15
  1. - (Subtração): Realiza a subtração entre dois valores.
subtracao <- x - y
subtracao
[1] 5
  1. * (Multiplicação): Realiza a multiplicação entre dois valores.
multiplicacao <- x * y
multiplicacao
[1] 50
  1. / (Divisão): Realiza a divisão entre dois valores.
divisao <- x / y
divisao
[1] 2
  1. ^ ou ** (Exponenciação): Eleva um valor à potência de outro.
exponenciacao <- x^2
exponenciacao
[1] 100
  1. %% (Módulo): Calcula o resto da divisão entre dois valores.
modulo <- x %% y
modulo
[1] 0
  1. %/% (Divisão inteira): Realiza a divisão entre dois valores e retorna o resultado como um número inteiro.
divisao_inteira <- x %/% y
divisao_inteira
[1] 2

6.1.2 Operadores Relacionais

Os operadores relacionais são usados para comparar valores e expressões. Eles retornam um valor lógico (TRUE ou FALSE) com base na comparação. Os operadores relacionais em R incluem:

# Operadores Relacionais
a <- 10
b <- 20
  1. == (Igual a): Verifica se dois valores são iguais.
igual_a <- a == b
igual_a
[1] FALSE
  1. != (Diferente de): Verifica se dois valores são diferentes.
diferente_de <- a != b
diferente_de
[1] TRUE
  1. > (Maior que): Verifica se o valor à esquerda é maior do que o valor à direita.
maior_que <- a > b
maior_que
[1] FALSE
  1. < (Menor que): Verifica se o valor à esquerda é menor do que o valor à direita.
menor_que <- a < b
menor_que
[1] TRUE
  1. >= (Maior ou igual a): Verifica se o valor à esquerda é maior ou igual ao valor à direita.
maior_ou_igual_a <- a >= b
maior_ou_igual_a
[1] FALSE
  1. <= (Menor ou igual a): Verifica se o valor à esquerda é menor ou igual ao valor à direita.
menor_ou_igual_a <- a <= b
menor_ou_igual_a
[1] TRUE

6.2 Resumo de Operadores

6.2.1 Operações Matemáticas

6.2.1.1 Operações Básicas

1 + 1 # Adição
2 - 1 # Subtração
3 * 2 # Multiplicação
4 / 2 # Divisão
5 ^ 2 # Potenciação
5 %% 2 # Resto da divisão
5 %/% 2 # Divisão inteira

6.2.1.2 Logarítimo

log(10) # Logarítimo natural
exp(10) # Exponencial
log10(100) # Logarítimo base 10
log2(10) # Logarítimo base 2
log(100, base = 8) # Log. base 8

6.2.1.3 Funções Trigonométricas

sin(0) # Seno
cos(0) # Cosseno
tan(0) # Tangente
asin(0) # Arco seno
acos(0) # Arco cosseno
atan(0) # Arco tangente

6.2.1.4 Arrerondamento

round(pi, digits = 2) # Arredondamento
ceiling(pi) # Teto
floor(pi) # Piso
trunc(pi) # Truncamento

6.2.2 Operações Lógicas

6.2.3 Comparativos

1 == 1 # Igual
1 != 2 # Diferente
1 > 2 # Maior
1 < 2 # Menor
1 >= 1 # Maior ou Igual
2 >= 1 # Menor ou Igual

a <- 1
b <- 2
a <= b

6.2.3.1 Operadores Lógicos

(1 == 1) & (2 == 2) # E / AND
(1 == 1) | (2 == 3) # OU / OR
!(1 == 2) # NÃO / NOT

6.2.4 Tipos Especiais

  • NA: Valores Ausentes
  • NaN: Not a Number
  • Inf e -Inf: Infinito
  • NULL: Valor Nulo (vazio)
NA + 5 # NA
is.na(NA + 5) # Verifica se é NA
10 + NULL # Retorna objeto vazio
is.null(10 + NULL) # Verifica se é NULL
0/0 # NaN
is.nan(0/0) # Verifica se é NaN
1/0 # Inf
is.infinite(1/0) # Verifica se é Infinito
is.finite(1/0) # Verifica se é Finito

6.2.5 Strings

"R" == "r" # Comparação de strings
"a" < "b" # Ordem Alfanumérica
"1" < "2" # Ordem Alfanumérica

6.3 Vetores em R: Fundamentos

Em R, vetores são estruturas de dados fundamentais que armazenam elementos de um mesmo tipo. Eles desempenham um papel crucial na linguagem, permitindo o armazenamento eficiente e a manipulação de dados. Os aspectos principais de vetores em R são:

  1. Homogeneidade: Vetores em R contêm elementos do mesmo tipo. Isso significa que um vetor não pode conter uma mistura de números, caracteres e outros tipos de dados. A homogeneidade é uma característica essencial para operações eficientes.

  2. Criação de Vetores: Você pode criar vetores usando a função c() (combine) ou a função vector(). Por exemplo, vetor_numerico <- c(1, 2, 3, 4, 5) cria um vetor numérico com os valores de 1 a 5.

vetor_numerico <- c(1,2,3,4,5)
vetor_numerico
[1] 1 2 3 4 5
sequencia_1_5 <- seq(1:5)
sequencia_1_5
[1] 1 2 3 4 5
sequencia_10_100 <- seq(from = 10,
                        to = 100, 
                        by = 5)
sequencia_10_100
 [1]  10  15  20  25  30  35  40  45  50  55  60  65  70  75  80  85  90  95 100
  1. Acesso a Elementos: Os elementos de um vetor podem ser acessados usando índices. O primeiro elemento tem índice 1, o segundo índice 2, e assim por diante. Por exemplo, vetor_numerico[3] retorna o terceiro elemento do vetor.
vetor_numerico[1]
[1] 1
vetor_numerico[3]
[1] 3

  1. Operações em Vetores: R permite realizar operações em vetores de forma conveniente e eficiente. Operações aritméticas e relacionais podem ser aplicadas elemento a elemento. Por exemplo, vetor_resultado <- vetor_numerico * 2 multiplica cada elemento por 2.

  2. Funções em Vetores: Muitas funções do R são vetorizadas, o que significa que elas podem operar diretamente em vetores. Isso evita a necessidade de loops explícitos. Por exemplo, mean(vetor_numerico) calcula a média dos elementos do vetor.

  3. Fatiamento de Vetores: Além de acessar elementos individuais, é possível fatiar vetores para obter subconjuntos. Por exemplo, subconjunto <- vetor_numerico[2:4] cria um novo vetor contendo os elementos do índice 2 ao 4.

vetor_numerico[2:4]
[1] 2 3 4
sequencia_10_100[3:8]
[1] 20 25 30 35 40 45
  1. Vetores de Caracteres: Vetores de caracteres são frequentemente usados para representar strings, nomes de variáveis e rótulos. Por exemplo, vetor_caracteres <- c("maçã", "banana", "laranja").
vetor_caracteres <- c("maçã", "banana", "laranja")

Vetores são uma das estruturas de dados mais essenciais em R e constituem a base para muitas operações e análises de dados. Eles permitem uma abordagem vetorial para a programação, que é eficiente e expressiva, tornando o R uma linguagem poderosa para análise estatística e manipulação de dados.

6.3.1 Exemplos de Criação de Vetores

numeros <- c(1, 2, 3, 4, 5)
numeros
[1] 1 2 3 4 5
letras <- c("a", "b", "c", "d", "e")
letras
[1] "a" "b" "c" "d" "e"
logicos <- c(TRUE, FALSE, TRUE, FALSE)
logicos
[1]  TRUE FALSE  TRUE FALSE
## Coerção
vetor <- c(numeros, letras, logicos)
vetor
 [1] "1"     "2"     "3"     "4"     "5"     "a"     "b"     "c"     "d"    
[10] "e"     "TRUE"  "FALSE" "TRUE"  "FALSE"
# Acessa o primeiro elemento
numeros[1] 
[1] 1
# Acessa o terceiro elemento
letras[3] 
[1] "c"
# Acessa o segundo elemento
logicos[2] 
[1] FALSE
# Acessa o quinto elemento
vetor[5] 
[1] "5"
# Acessa o segundo ao quarto elemento
vetor[2:4] 
[1] "2" "3" "4"

6.3.2 Exemplos de Uso de Operadores Aritméticos e Relacionais em vetores

# Operações aritméticas com vetores
vetor1 <- c(1, 2, 3)
vetor2 <- c(4, 5, 6)

# Soma 
soma_vetores <- vetor1 + vetor2
soma_vetores
[1] 5 7 9
# Subtração
subtracao_vetores <- vetor1 - vetor2
subtracao_vetores
[1] -3 -3 -3
# Multiplicação
multiplicacao_vetores <- vetor1 * vetor2
multiplicacao_vetores
[1]  4 10 18
# Divisão
divisao_vetores <- vetor1 / vetor2
divisao_vetores
[1] 0.25 0.40 0.50
# Exponenciação 
exponenciacao_numero <- vetor1^2  
exponenciacao_numero
[1] 1 4 9
# Módulo
modulo_numero <- vetor1 %% 3 
modulo_numero
[1] 1 2 0

6.3.3 Tipos, Classes, Métodos em vetores

6.3.3.1 Tipos de Vetores

Como vimos, os vetores em R são homogêneos, ou seja, todos os elementos de um vetor devem ser do mesmo tipo. Os tipos de vetores mais comuns em R são:

  • Numérico: numeric
  • c(1.2, 2.5, 3.14)
  • Inteiro: integer
  • c(1, 2, 3, 4, 5)
  • Lógico: logical
  • c(TRUE, FALSE, FALSE)
  • Complexo: complex
  • c(1 + 2i, 2 + 0i)
  • Caracter: character
  • c("a", "b", "c")
  • Factor: factor
  • factor(c("Tipo 1", "Tipo 2", "Tipo 3"))

Para que eu saiba qual o tipo de um vetor, posso utilizar a função class(), caso eu tenha uma suposição acerca do tipo do vetor, posso utilizar a função is. seguida do tipo que eu quero verificar.

# Funções que começam com `is.` 
# retornam TRUE ou FALSE
# Lista funções is.
apropos("^is\\.") 
# Verifica se é inteiro
is.integer(numeros) 
[1] FALSE
# Verifica se é numérico
is.numeric(numeros) 
[1] TRUE
# Verifica se é caracter
is.character(letras) 
[1] TRUE
# Verifica se é lógico
is.logical(logicos) 
[1] TRUE
# Verifica a classe do vetor
class(numeros)
[1] "numeric"
class(letras)
[1] "character"
fator = factor(c("Tipo 1", "Tipo 2", "Tipo 3"))
# Verifica se é fator
is.factor(fator) 
[1] TRUE

6.3.3.2 Conversão de Tipos

Muitas vezes precisamos converter um tipo de vetor em outro tipo. Para fazer isso, basta utilizar uma função específica para a conversão. As funções de conversão em R seguem o padrão as.tipo(), onde tipo é o tipo para o qual queremos converter o vetor.

# Funções que começam com `as.` 
# Lista funções as.
apropos("^as\\.") 
# Converte para caracter
as.character(numeros) 
[1] "1" "2" "3" "4" "5"
# Converte para numérico
as.numeric(fator) 
[1] 1 2 3
datas <- c("2021-01-01", "2021-01-02", "2021-01-03")
# Converte para data
as.Date(datas) 
[1] "2021-01-01" "2021-01-02" "2021-01-03"

6.3.4 Métodos

Métodos são funções genéricas que atuam conforme a classe do objeto. Para saber quais métodos estão disponíveis para uma classe, utilize a função methods(class = "class").

methods(class = "numeric")
methods(class = "character")
## Podemos ter um vetor numérico com nomes
altura <- c("João" = 1.82,
            "Bianca" = 1.68,
            "Eduarda" = 1.62)
class(altura)
[1] "numeric"
attributes(altura)
$names
[1] "João"    "Bianca"  "Eduarda"
names(altura)
[1] "João"    "Bianca"  "Eduarda"

6.3.5 Mais sobre a criação de vetores

Podemos criar vetores de diferentes formas, como: - Utilizando a função c() - Utilizando a função seq() - Utilizando a função rep() - Gerando de números aleatórios.

Já vimos a primeira forma, agora vamos ver as outras formas de criar vetores.

6.3.6 Sequências & Repetições

Para criar sequências ou repetir elementos, podemos utilizar as funções seq() e rep(), respectivamente.

  • Gerar sequências:
  • seq(from = x, to = y, by = z)
  • Repetir elementos:
  • rep(x, times = n)
  • rep(x, each = n)
# Sequência de 1 a 10
seq1 <- seq(1, 10)
seq1
 [1]  1  2  3  4  5  6  7  8  9 10
# Sequência de 10 a 1, de 2 em 2
seq2 <- seq(10, 1, by = -2)
seq2
[1] 10  8  6  4  2
# Repete 1, 2 e 3, 3 vezes
rep1 <- rep(c(1, 2, 3), times = 3)
rep1
[1] 1 2 3 1 2 3 1 2 3
# Repete 1, 2 e 3, 3 vezes cada
rep2 <- rep(c(1, 2, 3), each = 3)
rep2
[1] 1 1 1 2 2 2 3 3 3

6.3.7 Números Aleatórios

Para gerar números aleatórios, de uma distribuição de probabilidade, podemos utilizar as funções runif(), rnorm() e sample().

  • Números aleatórios:
  • runif(): Números aleatórios entre 0 e 1
  • rnorm() : Números aleatórios de uma normal, com média 0 e desvio padrão 1
  • sample() : Amostras aleatórias
  • Importante: Para garantir a reprodutibilidade dos resultados, podemos definir a semente aleatória com a função set.seed().
# 5 Números aleatórios entre 0 e 1
runif(5)
[1] 0.72837130 0.86886759 0.04289164 0.47154488 0.70211836
# 5 Números aleatórios de uma normal, 
# com média 0 e desvio padrão 1
rnorm(5)
[1] -0.47879958  0.06497995 -0.48012593  1.19685144  0.69212656
# Amostras aleatórias
sample(numeros, 
       size = 3, 
       replace = FALSE)
[1] 5 2 3
sample(letras,
       size = 5, 
       replace = TRUE)
[1] "d" "a" "b" "e" "a"

6.3.8 Exemplos de Uso de Operadores Relacionais em Vetores

6.3.8.1 Selecionando Elementos

Muias vezes precisamos selecionar elementos de um vetor que satisfaçam uma condição específica. Para isso, podemos utilizar operadores relacionais para comparar os elementos do vetor com um valor ou outro vetor.

# Comparação entre vetores
vetor1 <- c(1, 2, 3, 4)
vetor2 <- c(4, 5, 6, 7)

# Igualdade
vetores_iguais <- vetor1 == vetor2  
vetores_iguais
[1] FALSE FALSE FALSE FALSE
# Diferença
vetores_diferentes <- vetor1 != vetor2
vetores_diferentes
[1] TRUE TRUE TRUE TRUE
# Maior que
vetores_maior_que <- vetor1 > vetor2
vetores_maior_que
[1] FALSE FALSE FALSE FALSE
# Menor que
vetores_menor_que <- vetor1 < vetor2
vetores_menor_que
[1] TRUE TRUE TRUE TRUE
# Maior ou igual
vetores_maior_ou_igual_a <- vetor1 >= vetor2
vetores_maior_ou_igual_a
[1] FALSE FALSE FALSE FALSE
# Menor ou igual
vetores_menor_ou_igual_a <- vetor1 <= vetor2
vetores_menor_ou_igual_a
[1] TRUE TRUE TRUE TRUE

6.3.8.2 Seleção Posicional

A seleção posicional é uma forma de acessar elementos de um vetor com base em sua posição. Podemos selecionar elementos individuais, subconjuntos ou fatias de um vetor usando índices numéricos.

alturas <- c("João" = 1.82, 
"Bianca" = 1.68,
"Carlos" = 1.75, 
"Ana" = 1.70)

# Seleciona o primeiro elemento
alturas[1]
João 
1.82 
# Seleciona até o terceiro elemento
alturas[1:3]
  João Bianca Carlos 
  1.82   1.68   1.75 
# Seleciona elementos 1, 3 e 4
alturas[c(1, 3, 4)]
  João Carlos    Ana 
  1.82   1.75   1.70 
# remove o segundo elemento
alturas[-2]
  João Carlos    Ana 
  1.82   1.75   1.70

6.3.8.3 Seleção Condicional

A seleção condicional é uma forma de acessar elementos de um vetor com base em uma condição lógica. Podemos usar uma máscara lógica para selecionar elementos que atendam a uma condição específica.

# Seleciona alturas maiores que 1.70
mascara_logica <- alturas > 1.70
alturas[mascara_logica]
  João Carlos 
  1.82   1.75 
alturas[alturas > 1.70]
  João Carlos 
  1.82   1.75

6.3.8.4 Seleção por Nome

Quando um vetor possui nomes associados a seus elementos, podemos acessar os elementos por nome em vez de índice. Isso é útil para identificar e recuperar elementos de forma mais intuitiva.

# Seleciona a altura de João
alturas["João"]
João 
1.82 
# Seleciona a altura de João e Ana
alturas[c("João", "Ana")]
João  Ana 
1.82 1.70

6.3.9 Modificar e Adcionar Elementos

Podemos modificar e adicionar elementos em um vetor de diferentes formas, como atribuir um novo valor a um elemento existente, adicionar um novo elemento ao vetor ou remover um elemento do vetor.

6.3.10 Modificar

Para modificar um elemento de um vetor, basta selecionar o elemento de interesse e atribuir um novo valor a ele. Por exemplo, vetor[3] <- 10 atribui o valor 10 ao terceiro elemento do vetor.

alturas
  João Bianca Carlos    Ana 
  1.82   1.68   1.75   1.70 
# Modifica a altura de João
alturas["João"] <- 1.85
alturas
  João Bianca Carlos    Ana 
  1.85   1.68   1.75   1.70 
# Atribui altura desconhecida a Bianca
alturas["Bianca"] <- NA
alturas
  João Bianca Carlos    Ana 
  1.85     NA   1.75   1.70 
# Remove a altura de Carlos
alturas = alturas[-3]

6.3.11 Adicionar

Para adicionar um novo elemento a um vetor, podemos usar a função append(). A função append() permite adicionar um novo elemento ao final ou em uma posição específica do vetor.

# Adiciona a altura de Ivete
append(alturas, 
       value = c("Ivete" = 1.60))
  João Bianca    Ana  Ivete 
  1.85     NA   1.70   1.60 
# Adiciona a altura de Anderson no inicio
append(alturas,
       value = c("Anderson" = 1.75), 
       after = 0)
Anderson     João   Bianca      Ana 
    1.75     1.85       NA     1.70 
# Concatena alturas
alturas2 <- c("Alana" = 1.70, 
              "Rafael" = 1.80)
alturas <- c(alturas, alturas2)
alturas
  João Bianca    Ana  Alana Rafael 
  1.85     NA   1.70   1.70   1.80

6.4 Ordens de Execução no R

A ordem de execução é uma consideração importante ao escrever scripts ou interagir com o console do R. O R executa as operações seguindo uma sequência lógica, e entender essa sequência é fundamental para garantir que o código seja executado corretamente.

  1. Atribuição de Variáveis: A primeira etapa na ordem de execução é a atribuição de valores a variáveis. A atribuição é realizada usando os operadores de atribuição <- ou =. Por exemplo, x <- 5 atribui o valor 5 à variável x. Através da atribuição, você cria objetos que serão usados para realizar cálculos e manipulações no restante do código.
x <- 5
x
[1] 5
  1. Avaliação de Expressões: Depois que as variáveis são atribuídas, o R avalia as expressões aritméticas, lógicas ou outras expressões envolvendo as variáveis. Por exemplo, suponha que temos y <- x + 3, o R primeiro avaliará x + 3 (que é 5 + 3 = 8) e, em seguida, atribuirá o resultado (8) à variável y.
y <- x + 3
y
[1] 8

  1. Execução de Comandos: Após as atribuições e avaliações, o R executa os comandos. Os comandos são instruções que realizam ações específicas, como criar gráficos, calcular estatísticas, manipular dados, entre outros. Os comandos são fundamentais para executar tarefas específicas no R.

  2. Impressão de Resultados: Em um ambiente interativo, o R exibirá automaticamente na saída do console o resultado das expressões que não estão atribuídas a uma variável. Se você quiser evitar a impressão de resultados indesejados, pode utilizar a função invisible() para suprimir a saída.

x + 3
[1] 8
invisible(x + 3)
  1. Controle de Fluxo: Se o código contém estruturas de controle de fluxo, como condicionais (if, else) e loops (for, while), o R avaliará essas estruturas para decidir quais partes do código executar com base nas condições.

6.4.1 Exemplos de Atribuição

x <- 5         # Atribui o valor 5 à variável x
nome <- "João" # Atribui a string "João" à variável nome
meus_animais <- c("gato", " cachorro", "cachorro")
x
[1] 5
nome
[1] "João"
meus_animais
[1] "gato"      " cachorro" "cachorro" 
meus_animais[2] == meus_animais[3]
[1] FALSE
nome <- "Maria"
idade <- 30
altura <- 1.65
vetor <- c(1, 2, 3, 4, 5)
nome
[1] "Maria"
idade
[1] 30
altura
[1] 1.65
vetor
[1] 1 2 3 4 5
  1. = (sinal de igual): Também pode ser usado como operador de atribuição. Por exemplo:
y = 10         # Atribui o valor 10 à variável y
y
[1] 10

6.4.2 Exemplos de Ordens de Execução e Comandos de Atribuição:

a <- 5       # Atribuição primeiro
b <- a + 3   # Avaliação de expressão (a + 3 = 5 + 3 = 8)
print(b)     # Impressão do resultado (8)

6.5 Funções Matemáticas Básicas

  • sum(): Calcula a soma dos elementos de um vetor ou matriz.
vetor1
[1] 1 2 3 4
vetor2
[1] 4 5 6 7
vetor_caracteres
[1] "maçã"    "banana"  "laranja"
sum(vetor1)
[1] 10
sum(vetor2)
[1] 22
sum(vetor_caracteres)
Error in sum(vetor_caracteres): invalid 'type' (character) of argument
  • mean(): Calcula a média aritmética dos elementos de um vetor ou matriz.
mean(vetor1)
[1] 2.5
mean(vetor2)
[1] 5.5
mean(vetor_caracteres)
Warning in mean.default(vetor_caracteres): argument is not numeric or logical:
returning NA
[1] NA
  • median(): Calcula a mediana dos elementos de um vetor ou matriz.
median(vetor1)
[1] 2.5
median(vetor2)
[1] 5.5
median(vetor_caracteres)
[1] "laranja"
  • max(): Retorna o maior valor de um vetor ou matriz.
max(vetor1)
[1] 4
max(vetor2)
[1] 7
max(vetor_caracteres)
[1] "maçã"
  • min(): Retorna o menor valor de um vetor ou matriz.
min(vetor1)
[1] 1
min(vetor2)
[1] 4
min(vetor_caracteres)
[1] "banana"
  • sqrt(): Calcula a raiz quadrada de um número ou vetor.
sqrt(vetor1)
[1] 1.000000 1.414214 1.732051 2.000000
sqrt(vetor2)
[1] 2.000000 2.236068 2.449490 2.645751
sqrt(vetor_caracteres)
Error in sqrt(vetor_caracteres): non-numeric argument to mathematical function

6.5.1 Exemplo

dados <- c(10, 15, 20, 25, 30)
soma <- sum(dados)
media <- mean(dados)
mediana <- median(dados)
valor_maximo <- max(dados)
valor_minimo <- min(dados)
raiz_quadrada <- sqrt(25)

6.6 Funções de Manipulação de Dados

vetor3 = c(4,7,2,4,1,5)
  • length(): Retorna o número de elementos em um vetor ou matriz.
length(vetor3)
[1] 6
  • sort(): Ordena um vetor ou matriz em ordem crescente.
sort(vetor3)
[1] 1 2 4 4 5 7
  • rev(): Inverte a ordem dos elementos de um vetor ou matriz.
rev(vetor3)
[1] 5 1 4 2 7 4
  • unique(): Retorna os elementos únicos de um vetor ou matriz.
unique(vetor3)
[1] 4 7 2 1 5

6.6.1 Exemplo

dados <- c(5, 2, 8, 3, 2)
dados
[1] 5 2 8 3 2
tamanho <- length(dados)
tamanho
[1] 5
dados_ordenados <- sort(dados)
dados_ordenados
[1] 2 2 3 5 8
dados_invertidos <- rev(dados)
dados_invertidos
[1] 2 3 8 2 5
dados_unicos <- unique(dados)
dados_unicos
[1] 5 2 8 3

6.7 Operações Estatísticas

y <- c(7, 5, 2, 2, 4, 8, 
       5, 2, 6, 4, 5, 10, 
       3, 2, 6, 10, 7, 8,
       6, 10, 3, 4, 5, 1)

# Número de elementos
length(y)
[1] 24
# Soma dos elementos
sum(y)
[1] 125
# Média
mean(y)
[1] 5.208333
# Mediana
median(y)
[1] 5
# Máximo
max(y)
[1] 10
# Mínimo
min(y)
[1] 1
# Variância
var(y)
[1] 7.21558
# Desvio padrão
sd(y)
[1] 2.686183
# Desvio absoluto mediana
mad(y, constant = 1)
[1] 2
# Coeficiente de variação
100 * sd(y) / mean(y)
[1] 51.57472
# Quartis
quantile(y)
  0%  25%  50%  75% 100% 
   1    3    5    7   10 
# Amplitude Interquartilica
IQR(y)
[1] 4
# Tabela de Frequência
table(y)
y
 1  2  3  4  5  6  7  8 10 
 1  4  2  3  4  3  2  2  3

6.8 Funções para Criação de Gráficos

  • plot(): Cria um gráfico de dispersão ou linhas.
vetor4 = c(1:100)
vetor5 = sqrt(vetor4)

plot(x = vetor4, 
     y = vetor5, 
     las = 1, 
     pch = 16
)

  • hist(): Cria um histograma para visualização da distribuição de dados.
hist(vetor4, 
     las = 1)

6.8.1 Exemplo

x <- c(1, 2, 3, 4, 5)
y <- c(2, 4, 6, 8, 10)
plot(x, y, type = "b")  # Cria um gráfico de linhas e pontos

hist(x)  # Cria um histograma dos dados no vetor x

6.9 Funções Matemáticas

  • abs(): Retorna o valor absoluto de um número ou de cada elemento de um vetor ou matriz.
valor_negativo = -5.9
valor_negativo
[1] -5.9
abs(valor_negativo)
[1] 5.9
  • round(): Arredonda um número para o inteiro mais próximo.
round(valor_negativo)
[1] -6
  • ceiling(): Arredonda um número para cima (teto).
ceiling(valor_negativo)
[1] -5
  • floor(): Arredonda um número para baixo (piso).
floor(valor_negativo)
[1] -6
cos(0)
[1] 1
sin(0)
[1] 0
tan(0)
[1] 0
  • exp(): Calcula a exponencial de um número ou vetor (\(e^x\)).
exp(1)
[1] 2.718282
  • log(): Calcula o logaritmo natural de um número ou vetor.
log(10)
[1] 2.302585
##  log10 calcula o logaritimo na base 10
log10(10)
[1] 1
  • sum() e prod(): Calculam a soma e o produto dos elementos de um vetor ou matriz.
vetor1
[1] 1 2 3 4
sum(vetor1)
[1] 10
prod(vetor1)
[1] 24
numero <- -5.8
valor_absoluto <- abs(numero)
arredondado <- round(3.14159)
teto <- ceiling(5.1)
piso <- floor(5.9)
cosseno <- cos(pi)
exponencial <- exp(2)
soma_valores <- sum(c(1, 2, 3, 4, 5))
produto_valores <- prod(c(2, 3, 4))

6.10 Funções de Manipulação de Texto

  • paste(): Concatena várias strings em uma única string.
nomes = c("Maria", "Ana", "Rafaela")

paste(nomes[1], "e", nomes[2], "são minhas amigas.")
[1] "Maria e Ana são minhas amigas."
paste(nomes[1], nomes[2], nomes[3], sep = "|")
[1] "Maria|Ana|Rafaela"
paste(nomes, collapse = " ")
[1] "Maria Ana Rafaela"
  • toupper(): Converte uma string em letras maiúsculas.
toupper(nomes)
[1] "MARIA"   "ANA"     "RAFAELA"
  • tolower(): Converte uma string em letras minúsculas.
tolower(nomes)
[1] "maria"   "ana"     "rafaela"
  • substr(): Extrai uma subcadeia de caracteres de uma string.
substr(x = nomes[1], start = 1,stop = 3)
[1] "Mar"
  • gsub(): Substitui padrões em uma string por outros valores.
gsub(pattern = "G", 
     replacement = "R",
     x = "Gato")
[1] "Rato"

6.10.1 Exemplo

nome1 <- "João"
nome2 <- "Maria"
frase <- paste("Olá,", nome1, "e", nome2)  # Concatenação de strings
frase_upper <- toupper(frase)
frase_lower <- tolower(frase)
subcadeia <- substr(frase, start = 6, stop = 11)  # Extrai a subcadeia "João e"
frase_substituida <- gsub("João", "Pedro", frase)  # Substitui "João" por "Pedro"

6.11 Informações sobre Diretórios e Arquivos em R

Antes de realizar operações de importação e exportação de dados, é essencial entender o sistema de arquivos e diretórios em que você está trabalhando. No R, o diretório de trabalho é o local padrão onde o R procura arquivos para importação e salva arquivos exportados. Você pode obter informações sobre o diretório de trabalho atual e também alterá-lo conforme necessário.

  • getwd(): Retorna o diretório de trabalho atual, ou seja, o diretório em que o R procura por arquivos e onde salvará os resultados.
[1] "/Users/deisygysi/Library/CloudStorage/OneDrive-ufpr.br/DEST/2023/DEST/CE302/2023_2/CE302/chapters"

  • setwd(): Permite alterar o diretório de trabalho para um caminho específico. Isso é útil quando você precisa importar ou exportar dados em um diretório diferente do padrão.

  • ls(): Lista os objetos no ambiente de trabalho atual.

6.11.1 Exemplo

# Verificar o diretório de trabalho atual
diretorio_atual <- getwd()
print(diretorio_atual)
[1] "/Users/deisygysi/Library/CloudStorage/OneDrive-ufpr.br/DEST/2023/DEST/CE302/2023_2/CE302/chapters"
# Alterar o diretório de trabalho para uma pasta específica
# setwd("/caminho/para/a/pasta")

Além disso, para listar os arquivos e diretórios presentes em um determinado local, você pode utilizar a função list.files().

6.11.2 Exemplo

# Listar os arquivos no diretório de trabalho atual
arquivos <- list.files()
print(arquivos)
 [1] "01_markdown_git.html"     "01_markdown_git.qmd"     
 [3] "02_basicR_files"          "02_basicR.qmd"           
 [5] "02_basicR.rmarkdown"      "03_objects.qmd"          
 [7] "04_data_transf.qmd"       "04_data_transf.rmarkdown"
 [9] "05_loops.qmd"             "06_functions.qmd"        
[11] "07_graphics.qmd"          "07_graphics.rmarkdown"   
[13] "08_communicate.qmd"       "99_trab.qmd"             
[15] "Basic R.md"               "Basic R.Rmd"             
[17] "data"                     "Lista_01.qmd"            
[19] "Lista_02.qmd"             "Lista_03_files"          
[21] "Lista_03.html"            "Lista_03.qmd"

6.11.3 Funções para Importação e Exportação de Dados e Objetos

O R oferece diversas funções e pacotes para importar e exportar dados em diferentes formatos. Algumas das funções mais comuns incluem:

  • read.csv(): Importa dados de um arquivo CSV (Comma-Separated Values) e cria um dataframe. É um formato amplamente utilizado para armazenar dados tabulares.
  • read.table(): Importa dados de um arquivo de texto delimitado e cria um dataframe. Esse formato é útil quando os dados estão separados por caracteres específicos, como tabulações ou pontos e vírgulas.
  • read.xlsx() (do pacote “readxl”): Importa dados de um arquivo Excel (.xlsx) e cria um dataframe. O formato Excel é amplamente utilizado para armazenar dados em planilhas.
  • write.csv(): Exporta um dataframe para um arquivo CSV, permitindo compartilhar os resultados em formato legível por outros softwares.
  • write.table(): Exporta um dataframe para um arquivo de texto delimitado, permitindo compartilhar os resultados de forma mais flexível.

Exemplo:

# Importar dados de um arquivo CSV
dados <- read.csv("dados.csv")

# Exportar um dataframe para um arquivo CSV
write.csv(dados, "dados_novos.csv")

6.11.4 Exploração de Conjuntos de Dados Integrados e Edição dos Mesmos

O R inclui diversos conjuntos de dados integrados que estão disponíveis por padrão. Esses conjuntos são úteis para fins de prática, aprendizado e também para a demonstração de recursos da linguagem. Para explorar esses conjuntos, você pode usar funções como data(), head(), tail() e summary().

  • data(): Lista os conjuntos de dados integrados disponíveis no R. Isso permite que você veja quais conjuntos estão disponíveis para importação.
  • head(): Exibe as primeiras linhas de um dataframe, permitindo uma visualização rápida dos dados.
  • tail(): Exibe as últimas linhas de um dataframe, especialmente útil para conjuntos de dados com muitas observações.
  • summary(): Fornece um resumo estatístico dos dados em um dataframe, incluindo medidas como média, mediana, mínimo, máximo e quartis.

6.11.4.1 Exemplo

# Listar conjuntos de dados integrados disponíveis no R
data()

# Carregar o conjunto de dados "iris" (conjunto de dados de flores iris)
data(iris)

# Exibir as primeiras linhas do conjunto de dados "iris"
head(iris)
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa
# Exibir as últimas linhas do conjunto de dados "iris"
tail(iris)
    Sepal.Length Sepal.Width Petal.Length Petal.Width   Species
145          6.7         3.3          5.7         2.5 virginica
146          6.7         3.0          5.2         2.3 virginica
147          6.3         2.5          5.0         1.9 virginica
148          6.5         3.0          5.2         2.0 virginica
149          6.2         3.4          5.4         2.3 virginica
150          5.9         3.0          5.1         1.8 virginica
# Exibir um resumo estatístico do conjunto de dados "iris"
summary(iris)
  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width   
 Min.   :4.300   Min.   :2.000   Min.   :1.000   Min.   :0.100  
 1st Qu.:5.100   1st Qu.:2.800   1st Qu.:1.600   1st Qu.:0.300  
 Median :5.800   Median :3.000   Median :4.350   Median :1.300  
 Mean   :5.843   Mean   :3.057   Mean   :3.758   Mean   :1.199  
 3rd Qu.:6.400   3rd Qu.:3.300   3rd Qu.:5.100   3rd Qu.:1.800  
 Max.   :7.900   Max.   :4.400   Max.   :6.900   Max.   :2.500  
       Species  
 setosa    :50  
 versicolor:50  
 virginica :50

Uma vez que os dados são importados ou carregados no R, você pode realizar várias operações de edição, transformação e limpeza nos dataframes. Isso inclui seleção de colunas, filtragem de dados, criação de novas variáveis, cálculos estatísticos e muito mais. O R oferece uma ampla variedade de funções e pacotes que permitem manipular dados de forma eficiente e eficaz.

  1. GNU: Gnu’s not Unix↩︎

  2. software com código-fonte que qualquer pessoa pode inspecionar, modificar e aprimorar↩︎