R Vector-como criar, combinar e indexar Vectores em R?

BY admin

| Julho 18, 2021

neste tutorial TechVidvan, você vai aprender sobre o vetor na programação R. Você vai aprender a criar, combinar e indexar vetores em R.

vetores são as estruturas de dados mais simples em R. eles são sequências de elementos do mesmo tipo básico.

estes tipos podem ser numéricos, inteiros, complexos, característicos e lógicos. Em R, As estruturas de dados mais complicadas são feitas com vetores como blocos de construção.

neste artigo, você receberá a resposta a todas estas perguntas em detalhe:

como criar vetor em R?
quais são os tipos de vectores em R?
como encontrar o tipo de vetor R?Como combinar Vectores R?
o que é a coerção no vetor R?
How to access elements of R Vector?
What are some basic vector arithmetic in R?
What is vector function in R?Sem mais demoras, vamos começar!Mantendo-o actualizado com as últimas tendências tecnológicas, Junte-se a TechVidvan num Telegrama.
Existem várias maneiras de se criar um R vetor:
Usando c() a Função

Para criar um vetor, podemos usar o c() função:

Código:
```
> vec <- c(1,2,3,4,5) #creates a vector named vec> vec #prints the vector vec
```
Saída:

Usando atribuir() função

Outra maneira de criar um vetor é o assign() função.

Código:
```
> assign("vec2",c(6,7,8,9,10)) #creates a vector named vec2> vec2 #prints the vector vec2
```
Resultado:

usando: operador

uma maneira fácil de fazer vetores inteiros é usar o operador :.

Código:
```
> vec3 <- 1:20> vec3
```
resultado:

quais são os tipos de vectores em R?

um vetor pode ser de diferentes tipos, dependendo dos elementos que contém. Estes podem ser:

1. Vectores numéricos

Vectores contendo valores numéricos.

Código:
```
> num_vec <- c(1,2,3,4,5)> num_vec
```
2. Vetores inteiros

vetores contendo valores inteiros.

Código:
```
> int_vec <- c(6L,7L,8L,9L,10L)> int_vec
```
3. Vetores lógicos

vetores contendo valores lógicos de verdadeiro ou falso.

Código:
```
> log_vec <- c(TRUE,FALSE,TRUE,FALSE,FALSE)> log_vec
```
4. Vetores de caracteres

vetores contendo texto.

Código:
```
> char_vec <- c("aa","bb","cc","dd","ee")> char_vec
```
5. Vectores complexos

Vectores contendo valores complexos.

Código:
```
> comp_vec <- c(12+1i,3i,5+4i,4+9i,6i)> comp_vec
```
resultado:

como encontrar o tipo de vetor R?

podemos usar a função typeof() para encontrar o tipo de um vetor. Por exemplo:

Código:
```
> typeof(num_vec)> typeof(int_vec)> typeof(log_vec)> typeof(char_vec)> typeof(comp_vec)
```
Saída:

Nota: typeof() retorna a função de “duplo” para valores numéricos. Isto é por causa da forma como a classe numérica armazena um valor. A classe numérica armazena valores como números de ponto flutuante de precisão dupla. Seu tipo é duplo enquanto sua classe é numérica.Como combinar Vectores R?

a função c() também pode combinar dois ou mais vetores e adicionar elementos aos vetores.

Exemplo 1

Código:
```
> vec4 <- c(vec, vec2)> vec4
```
Exemplo 2

Código:
```
> vec5 <- c(vec4,4,55,vec)> vec5
```
saída:

o que é coerção no vetor R?

os vectores contêm apenas elementos do mesmo tipo de dados. Se houver mais de um tipo de dados, a função c() converte os elementos. Isto é conhecido como coerção. A conversão ocorre de tipos mais baixos para tipos mais elevados.

logical < integer < double < complex < character.

Código:
```
> vec6 <- c(1,FALSE,3L,12+5i,"hello")> typeof(vec6)
```
resultado:

como acessar elementos do vetor R?

usamos indexação vetorial para acessar os elementos de um vetor. Podemos selecionar ou omitir elementos de um vetor, adicionando um vetor índice entre parênteses quadrados ao nome do vetor.

Existem quatro tipos de índice de vetores:
1. Lógico índice do vetor
2. Positivo-integral do índice do vetor
3. Negativo integral do índice do vetor
4. índice de Caractere vector
Vamos examinar essas diferentes técnicas de indexação:

1. Vetores de índice lógico

podemos usar um vetor de valores lógicos para indexar outro vetor do mesmo comprimento. R inclui os elementos correspondentes a TRUE no vetor índice e omite os elementos correspondentes A FALSE. Por exemplo:

Código:
```
> logind_vec <- vec> logind_vec
```
Saída:

em Vez de usar lógica vetores de igual comprimento, podemos usar também uma condição lógica. Isto inclui os elementos que satisfazem a condição enquanto remove aqueles que não o fazem.

Código:
```
> logind_vec2 <- vec3 #only allow those divisible by 3> logind_vec2
```
resultado :

2. Vetores de índice integral positivo

índices vetoriais em R começar a partir de 1. Podemos usar inteiros positivos para selecionar elementos específicos. Também podemos usar vetores de inteiros positivos para incluir vários elementos específicos, deixando outros.

Exemplo 1

Código:
```
> posint_vec <- vec> posint_vec
```
Exemplo 2

Código:
```
> posint_vec2 <- vec4> posint_vec2
```
Saída:

3. Vetores de índice integral negativo

em indexação integral negativa, inteiros negativos indicam os elementos a excluir. Ao usar vetores integrais negativos, R remove os elementos denotados e retorna o restante como resultado.

Código:
```
> negint_vec <- vec> negint_vec
```
resultado:

4. Vetores de indexação de caracteres

usamos um vetor de caracteres, apenas para indexar vetores com um atributo “nomes”. A indexação do vector de caracteres é útil quando se lida com Vectores R nomeados.

Código:
```
> named_vec <- c("first"=1,"second"=2,"third"=3,"fourth"=4)> named_vec> charind_vec <- named_vec > charind_vec
```
Resultado:

What are some basic vector arithmetic in R?

R realiza operações aritméticas em vetores no sentido dos membros. Isto significa que as operações são realizadas em cada membro. Por exemplo:

Multiplicação:
```
> multivec <- vec*2> multivec
```
Além de:
```
> vec_plus_three <- vec+3> vec_plus_three
```
Subtração:
```
> vec_min_one <- vec-1> vec_min_one
```
Saída:

também podemos realizar uma operação aritmética como uma adição de dois vetores de mesmo comprimento. Isto adiciona os membros correspondentes nos dois vetores. Por exemplo:

Adição de vetores
```
> vector_add <- vec+vec2 #vec = 1,2,3,4,5 vec2 = 6,7,8,9,10> vector_add
```
Multiplicação de um vector
```
> vector_mul <- vec*vec2> vector_mul
```
Subtração do vetor
```
> vector_sub <- vec2-vec> vector_sub
```
Divisão de vector
```
> vector_div <- multivec/vec # multivec = 2,4,6,8,10> vector_div
```
Saída:

Se dois vetores são de comprimento desigual, a mais curta será reciclado para corresponder a mais de vetor.

Código:
```
> recycle_vec <- vec*vec4> recycle_vec
```
resultado:

Note: Here, the first vector vec has five elements. O segundo vector vec4 tem dez elementos. Portanto, o primeiro vetor é ciclado duas vezes para igualar o segundo.O que é a função vectorial em R?

R tem muitas funções que podem manipular vetores ou obter mais informações sobre eles. Aqui estão algumas das funções comumente usadas:

seq()– seq () função gera sequências numéricas regulares. A função tem os seguintes argumentos:
- a partir de: a partir do valor de
- para: valor final
- por: incremento (o padrão é 1)
- > comprimento.fora: Comprimento da sequência
- ao longo.com: o comprimento deste argumento pode definir o comprimento da sequência.
Código:
```
> vec_seq <- seq(from=1,to=20,length=30)> vec_seq
```
rep() – a função rep() repete um dado vector numérico. A função tem os seguintes argumentos:
- X: x é o vetor numérico que é repetido.
- vezes: Número de repetições.
- cada: número de repetições para cada elemento do vector.
- comprimento.out: o comprimento do vector resultante. A função repete-se até atingir o comprimento.
Código:
```
> vec_rep <- rep(c(2,3,4), times=3)> vec_rep
```
sum() – a função sum () devolve um valor inteiro que é a soma de todos os elementos num vector.

Código:
```
> sum(vec_rep)
```
4. Funções de verificação e conversão do tipo-as funções as.numérico () / as.carácter () / as.logical() / as.inteiro() pode converter um vetor em seu tipo correspondente. As funções são.numérico () / is.carácter() /is.logical () etc. diga se o vetor é do tipo correspondente ou não.

Código:
```
> is.numeric(vec_rep)> as.character(vec_rep)
```
resumo

Vectores são uma das estruturas básicas de dados de R. são sequências de valores do mesmo tipo de dados. Podemos classificá-los como estruturas de dados unidimensionais e homogêneas.

não sabe muito sobre estruturas de dados inbuilt em R? Em seguida, dê uma olhada em estruturas básicas de dados em R com exemplos.

neste tutorial, aprendemos sobre Vectores R. Aprendemos a criar vectores e quantos tipos de vectores existem. Analisámos também a coacção e as várias técnicas de indexação dos vectores.Finalmente, exploramos a mecânica da aritmética vetorial em R e algumas funções que podem gerar e manipular vetores.