Tipos de dados em R com exemplo

Quais são os tipos de dados em R?

A seguir estão os tipos de dados ou estruturas de dados na programação R:

• Escalares
• Vetores (numéricos, caracteres, lógicos)
• Matrizes
• Quadros de dados
• listas

Essa lista mistura duas ideias relacionadas, e separá-las facilita a compreensão do restante desta página. tipo de dados Descreve o que é um valor único — um número, um texto, um VERDADEIRO ou um FALSO. estrutura de dados descreve quantos valores são mantidos juntos e em que formato. Escalares, vetores, matrizes, data frames e listas são estruturas; os valores dentro delas ainda pertencem a um dos tipos básicos do R.

Em R, não existe um tipo escalar separado: um escalar é simplesmente um vetor de comprimento um, razão pela qual grande parte do código em R é escrita para vetores inteiros de uma só vez.

Tipos de dados básicos em R

Em R, cada valor pertence a um pequeno conjunto de tipos básicos (atômicos):

• 4.5 é um valor decimal chamado numérico.
• O número 4 parece um número inteiro, mas o R ainda o armazena como um número de ponto flutuante de dupla precisão (double). Escreva 4L quando for necessário um número inteiro verdadeiro.
• VERDADEIRO ou FALSO é um valor booleano, chamado de valor lógico em R.
• O valor entre aspas simples (“ ”) ou aspas duplas (' ') é um texto (uma cadeia de caracteres). Esses valores são chamados de caracteres.

Dois outros tipos completam o conjunto. Valores complexos, como 3+2i, contêm uma parte real e uma parte imaginária, e valores brutos contêm bytes. Ambos aparecem raramente em análises do dia a dia, mas estão listados no R básico. documentação typeof() juntamente com os quatro tipos comuns.

Podemos verificar o tipo de uma variável com a função de classe.

Exemplo 1: Verificar uma variável numérica

# Declare variables of different types
# Numeric
x <- 28
class(x)

Saída:

## [1] "numeric"

Exemplo 2: Verificar uma variável de caractere

# String
y <- "R is Fantastic"
class(y)

Saída:

## [1] "character"

Exemplo 3: Verificar uma variável lógica

# Boolean
z <- TRUE
class(z)

Saída:

## [1] "logical"

Note que a função `class()` retorna "numérico" para 28, mesmo que 28 não tenha parte decimal. O R o armazenou como um número de ponto flutuante de dupla precisão (`double`), e somente a função `typeof()` revela isso. A próxima diferença que vale a pena aprender é como esses valores recebem nomes.

Variáveis ​​em R

As variáveis ​​são um dos blocos de construção básicos em R, responsáveis ​​pelo armazenamento de valores, e são essenciais para qualquer pessoa que trabalhe com ciência de dados. Uma variável em R pode armazenar um número, um objeto, um resultado estatístico, um vetor, um conjunto de dados ou uma previsão de modelo — basicamente qualquer coisa que o R produza. Podemos usar essa variável posteriormente simplesmente chamando seu nome.

Para declarar uma variável em R, precisamos atribuir um nome a ela. O nome não deve conter espaços. Podemos usar o caractere _ para unir duas palavras.

Os nomes podem conter letras, dígitos, pontos e sublinhados, mas devem começar com uma letra ou um ponto, e palavras reservadas como TRUE, FALSE e NULL não podem ser usadas como nomes. Para adicionar um valor à variável, use <- ou =.

Aqui está a sintaxe:

# First way to declare a variable:  use the `<-`
name_of_variable <- value
# Second way to declare a variable:  use the `=`
name_of_variable = value

Na linha de comando, podemos escrever os seguintes códigos para ver o que acontece:

Exemplo 1: Atribua um valor e imprima-o.

# Print variable x
x <- 42
x

Saída:

## [1] 42

Exemplo 2: Declarar uma segunda variável

y  <- 10
y

Saída:

## [1] 10

Exemplo 3: Usar duas variáveis ​​em uma única expressão

# We call x and y and apply a subtraction
x-y

Saída:

## [1] 32

Uma variável que armazena vários valores do mesmo tipo é um vetor, que é a estrutura esperada por quase todas as funções em R.

Vetores em R

Um vetor é uma coleção unidimensional na qual todos os elementos compartilham o mesmo tipo. Podemos criar um vetor com todos os tipos de dados básicos do R aprendidos anteriormente. A maneira mais simples de construir um vetor em R é usar a função `c()`.

Exemplo 1: Criar um vetor numérico

# Numerical
vec_num <- c(1, 10, 49)
vec_num

Saída:

## [1]  1 10 49

Exemplo 2: Criar um vetor de caractere

# Character 
vec_chr <- c("a", "b", "c")
vec_chr

Saída:

## [1] "a" "b" "c"

Exemplo 3: Criar um vetor lógico

# Boolean 
vec_bool <-  c(TRUE, FALSE, TRUE)
vec_bool

Saída:

##[1] TRUE FALSE TRUE

Se c() receber uma mistura de tipos, ela não falha. Ela silenciosamente converte cada elemento para o tipo mais geral presente, então c(1, "a", TRUE) se torna um vetor de caracteres. Também podemos fazer cálculos aritméticos com vetores em R.

Exemplo 4: Adicionar dois vetores elemento por elemento

# Create the vectors
vect_1 <- c(1, 3, 5)
vect_2 <- c(2, 4, 6)
# Take the sum of A_vector and B_vector
sum_vect <- vect_1 + vect_2
# Print out total_vector
sum_vect

Saída:

[1]  3  7 11

A adição funcionou elemento por elemento porque ambos os vetores têm o mesmo comprimento. Quando os comprimentos diferem, o R recicla o vetor mais curto, repetindo-o até que ele corresponda ao mais longo, e emite um aviso apenas quando o comprimento do vetor mais longo não for um múltiplo do mais curto.

Exemplo 5: Fatie os cinco primeiros elementos

Em R, é possível fatiar um vetor. Em algumas ocasiões, estamos interessados ​​apenas nos cinco primeiros elementos de um vetor. Podemos usar o comando [1:5] para extrair esses elementos.tract os valores de 1 a 5.

# Slice the first five rows of the vector
slice_vector <- c(1,2,3,4,5,6,7,8,9,10)
slice_vector[1:5]

Saída:

## [1] 1 2 3 4 5

Exemplo 6: Criar um intervalo com os dois pontos Operator

A maneira mais curta de criar um intervalo de valores é usar o operador de dois pontos (:) entre dois números. Por exemplo, no exemplo acima, podemos escrever c(1:10) para criar um vetor de valores de um a dez.

# Faster way to create adjacent values
c(1:10)

Saída:

## [1]  1  2  3  4  5  6  7  8  9 10

Como um vetor muda de tipo silenciosamente quando é misturado, é importante saber como inspecionar e converter tipos sob demanda.

Como verificar e converter tipos de dados em R

Três famílias de funções respondem às três perguntas que surgem constantemente: o que é isto, isto é de um determinado tipo e isto pode se tornar de outro tipo?

# Three different views of the same value
x <- 28
class(x)      # "numeric"  -- the class used for method dispatch
typeof(x)     # "double"   -- how R stores the value internally
mode(x)       # "numeric"  -- the older S-style mode

# Ask a yes/no question about a type
is.numeric(x)     # TRUE
is.character(x)   # FALSE

# Convert between types
as.character(x)   # "28"
as.integer("28")  # 28 stored as an integer
as.numeric("abc") # NA, with a coercion warning

Duas regras explicam a maioria das surpresas aqui. Primeiro, `class()` reporta a classe usada para o despacho de métodos, enquanto `typeof()` reporta o armazenamento interno, razão pela qual 28 é "numérico" para um e "double" para o outro. Segundo, uma conversão que não pode ser bem-sucedida não interrompe o script: `as.numeric("abc")` retorna NA e imprime um aviso de coerção, portanto, valores NA silenciosos após uma importação são quase sempre um problema de tipo. A mesma lógica conduz a... fatores, que armazenam categorias como códigos inteiros mais uma tabela de níveis.

Com os tipos definidos, o próximo passo são os operadores que atuam sobre eles.

R Aritmética Operatoros

Primeiramente, veremos os operadores aritméticos básicos em R. A seguir, apresentamos os operadores aritméticos na linguagem de programação R e seus respectivos significados:

Cada um desses operadores é vetorizado, portanto a mesma expressão funciona em um único valor ou em uma coluna inteira.

Exemplo 1: Adição

# An addition
3 + 4

Saída:

## [1] 7

Você pode facilmente copiar e colar o código R acima no RStudio Console. Neste artigo, a saída é exibida nas linhas que começam com ##. Por exemplo, se escrevermos o código print("Guru99") o console imprime [1] "Guru99", que esta página mostraria como ## [1] "Guru99 ".

O ## marca uma linha de saída impressa e o número entre colchetes ([1]) é o índice do primeiro valor nessa linha, não fazendo parte do resultado.

Frases que começam com # são comentários. Podemos usar # dentro de um script R para adicionar qualquer nota que quisermos, e o R a ignora em tempo de execução.

Exemplo 2: Multiplicação

# A multiplication
3*5

Saída:

## [1] 15

Exemplo 3: Divisão

# A division
(5+5)/2

Saída:

## [1] 5

Exemplo 4: Exponenciação

# Exponentiation
2^5

Saída:

## [1] 32

Exemplo 5: Módulo

# Modulo
28%%6

Saída:

## [1] 4

A aritmética produz números. O próximo grupo de operadores produz VERDADEIRO e FALSO.

R Relacional (Comparação) Operatoros

Os operadores relacionais comparam dois valores e retornam um resultado lógico. São eles que estabelecem as condições utilizadas para a filtragem e são vetorizados exatamente da mesma forma que os operadores aritméticos.

a <- 10
b <- 3

a > b     # TRUE
a < b     # FALSE
a >= 10   # TRUE
a <= 3    # FALSE
a == b    # FALSE
a != b    # TRUE

# Relational operators are vectorised
scores <- c(45, 78, 90, 62)
scores >= 60   # FALSE TRUE TRUE TRUE

Dois hábitos economizam tempo aqui. Use == para comparação e <- para atribuição, porque um único = dentro de uma condição é um erro comum de iniciantes. E evite == em números de ponto flutuante de dupla precisão: o arredondamento de ponto flutuante significa que 0.1 + 0.2 == 0.3 é FALSO, então isTRUE(all.equal(0.1 + 0.2, 0.3)) é o teste seguro. Comparações em quadros de dados ordenados seguem as mesmas regras.

R Lógico Operatoros

Com os operadores lógicos, queremos retornar valores dentro do vetor com base em condições lógicas. A tabela abaixo lista os operadores lógicos disponíveis em R.

Em R, as declarações lógicas são delimitadas por colchetes []. Podemos adicionar quantas declarações condicionais quisermos, mas precisamos incluí-las entre parênteses. Podemos seguir esta estrutura para criar uma declaração condicional:

variable_name[(conditional_statement)]

Com `variable_name` referindo-se à variável que queremos usar na instrução, criamos a declaração lógica, por exemplo, `variable_name > 0`. Finalmente, usamos colchetes para finalizar a declaração lógica. Abaixo está um exemplo de uma declaração lógica.

Exemplo 1: Compare cada elemento de um vetor

# Create a vector from 1 to 10
logical_vector <- c(1:10)
logical_vector>5

Saída:

## [1]FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

Na saída acima, o R lê cada valor e o compara com a condição `logical_vector>5`. Se o valor for estritamente maior que cinco, a condição é VERDADEIRA; caso contrário, é FALSA. O R retorna um vetor com os valores VERDADEIRO e FALSO.

Exemplo 2: Mantenha apenas os elementos que correspondem

No exemplo abaixo, queremos extracPara selecionar os valores que atendem à condição "é estritamente maior que cinco", podemos envolver a condição entre colchetes, precedida pelo vetor que contém os valores.

# Print value strictly above 5
logical_vector[(logical_vector>5)]

Saída:

## [1]  6  7  8  9 10

Exemplo 3: Combinar duas condições

# Print 5 and 6
logical_vector <- c(1:10)
logical_vector[(logical_vector>4) & (logical_vector<7)]

Saída:

## [1] 5 6

O exemplo 3 usa o caractere único & propositalmente. Os operadores de um único caractere & e | comparam vetores elemento por elemento e retornam um vetor, que é o que a criação de subconjuntos exige. As formas duplas && e || retornam um único valor e pertencem às condições if() e while(). R 4.3.0Passar um argumento com mais de um elemento para && ou || resulta em um erro, e não em um aviso; portanto, as duas famílias de operadores não são mais intercambiáveis. O operador ! nega uma condição, e xor() realiza o OU exclusivo.

Tarefa em R Operatoros

Os operadores de atribuição vinculam um valor a um nome. O R oferece mais operadores de atribuição do que a maioria das linguagens, e as diferenças são importantes quando o código entra em desenvolvimento. funções.

# Left assignment -- the idiomatic form
count <- 5

# Equals sign: works, but reserve it for function arguments
count = 5
round(3.14159, digits = 2)

# Right assignment
5 -> count

# Superassignment, used inside functions to reach an outer scope
count <<- 5

Os guias de estilo recomendam o uso de `<` para criar objetos e `=` para nomear argumentos dentro de uma chamada, pois assim as duas funções permanecem visualmente distintas. Use `<<` com moderação: ele modifica um objeto fora da função atual e dificulta a compreensão do código. Depois de dominar a atribuição e os tipos, os próximos passos são: importando dados reais e reshaping com dplyr; O Visão geral da linguagem R Coloca toda a cadeia de ferramentas em contexto.

Perguntas Frequentes