R Language
Creando vectores

Secuencia de numeros

Use el operador : para crear secuencias de números, como para usar en vectoresizar grandes porciones de su código:

x <- 1:5
x
## [1] 1 2 3 4 5

Esto funciona en ambos sentidos.

10:4
# [1] 10  9  8  7  6  5  4

e incluso con números de punto flotante

1.25:5
# [1] 1.25 2.25 3.25 4.25

o negativos

-4:4
#[1] -4 -3 -2 -1  0  1  2  3  4

seq ()

seq es una función más flexible que el operador : que permite especificar pasos distintos de 1.

La función crea una secuencia desde el start (el valor predeterminado es 1) hasta el final, incluido ese número.

Puede suministrar solo el parámetro final ( to )

seq(5)
# [1] 1 2 3 4 5

Así como el inicio

seq(2, 5) # or seq(from=2, to=5)
# [1] 2 3 4 5

Y finalmente el paso ( by ).

seq(2, 5, 0.5) # or seq(from=2, to=5, by=0.5)
# [1] 2.0 2.5 3.0 3.5 4.0 4.5 5.0

seq puede opcionalmente inferir los pasos (espaciados uniformemente) cuando se suministra alternativamente la longitud deseada de la salida ( length.out )

seq(2,5, length.out = 10)
# [1] 2.0 2.3 2.6 2.9 3.2 3.5 3.8 4.1 4.4 4.7 5.0

Si la secuencia necesita tener la misma longitud que otro vector, podemos usar el along.with como una abreviatura para length.out = length(x)

x = 1:8
seq(2,5,along.with = x)
# [1] 2.000000 2.428571 2.857143 3.285714 3.714286 4.142857 4.571429 5.000000

Hay dos funciones simplificadas útiles en la familia seq : seq_along , seq_len y seq.int . seq_along funciones seq_along y seq_len construyen los números naturales (contando) de 1 a N, donde N se determina por el argumento de la función, la longitud de un vector o lista con seq_along y el argumento entero con seq_len .

seq_along(x)
# [1] 1 2 3 4 5 6 7 8

Tenga en cuenta que seq_along devuelve los índices de un objeto existente.

# counting numbers 1 through 10
seq_len(10)
[1]  1  2  3  4  5  6  7  8  9 10
# indices of existing vector (or list) with seq_along
letters[1:10]
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"
seq_along(letters[1:10])
[1]  1  2  3  4  5  6  7  8  9 10

seq.int es el mismo que seq mantenido para compatibilidad antigua.

También hay una sequence función antigua que crea un vector de secuencias a partir de un argumento no negativo.

sequence(4)
# [1] 1 2 3 4
sequence(c(3, 2))
# [1] 1 2 3 1 2
sequence(c(3, 2, 5))
# [1] 1 2 3 1 2 1 2 3 4 5

Vectores

Los vectores en R pueden tener diferentes tipos (por ejemplo, entero, lógico, carácter). La forma más general de definir un vector es usar la función vector() .

vector('integer',2) # creates a vector of integers of size 2.
vector('character',2) # creates a vector of characters of size 2.
vector('logical',2) # creates a vector of logicals of size 2.

Sin embargo, en R, las funciones abreviadas son generalmente más populares.

integer(2) # is the same as vector('integer',2) and creates an integer vector with two elements
character(2) # is the same as vector('integer',2) and creates an character vector with two elements
logical(2) # is the same as vector('logical',2) and creates an logical vector with two elements

También es posible crear vectores con valores distintos de los valores predeterminados. A menudo, la función c() se utiliza para esto. La c es la abreviatura de combinar o concatenar.

c(1, 2) # creates a integer vector of two elements: 1 and 2.
c('a', 'b') # creates a character vector of two elements: a and b.
c(T,F) # creates a logical vector of two elements: TRUE and FALSE.

Es importante tener en cuenta que R interpreta cualquier entero (por ejemplo, 1) como un vector entero de tamaño uno. Lo mismo se aplica a los valores numéricos (por ejemplo, 1.1), los lógicos (por ejemplo, T o F) o los caracteres (por ejemplo, 'a'). Por lo tanto, en esencia estás combinando vectores, que a su vez son vectores.

Ten en cuenta que siempre tienes que combinar vectores similares. De lo contrario, R intentará convertir los vectores en vectores del mismo tipo.

c(1,1.1,'a',T) # all types (integer, numeric, character and logical) are converted to the 'lowest' type which is character.

La búsqueda de elementos en vectores se puede hacer con el [ operador.

vec_int <- c(1,2,3)
vec_char <- c('a','b','c')
vec_int[2] # accessing the second element will return 2
vec_char[2] # accessing the second element will return 'b'

Esto también puede ser usado para cambiar valores.

vec_int[2] <- 5 # change the second value from 2 to 5
vec_int # returns [1] 1 5 3

Finalmente, el operador : (abreviatura de la función seq() ) se puede usar para crear rápidamente un vector de números.

vec_int <- 1:10
vec_int # returns [1] 1 2 3 4 5 6 7 8 9 10

Esto también se puede usar para subcontratar vectores (de subconjuntos fáciles a complejos)

vec_char <- c('a','b','c','d','e')
vec_char[2:4] # returns [1] "b" "c" "d"
vec_char[c(1,3,5)] # returns [1] "a" "c" "e"

Creando vectores con nombre

El vector nombrado se puede crear de varias maneras. Con c :

xc <- c('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)

lo que resulta en:

> xc
a b c d 
5 6 7 8

con la list :

xl <- list('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)

lo que resulta en:

> xl
$a
[1] 5

$b
[1] 6

$c
[1] 7

$d
[1] 8

Con la función setNames , se pueden usar dos vectores de la misma longitud para crear un vector nombrado:

x <- 5:8
y <- letters[1:4]

xy <- setNames(x, y)

lo que resulta en un vector entero nombrado:

> xy
a b c d 
5 6 7 8

Como puede verse, esto da el mismo resultado que el método c .

También puede usar la función de names para obtener el mismo resultado:

xy <- 5:8
names(xy) <- letters[1:4]

Con tal vector también es posible seleccionar elementos por nombre:

> xy["c"]
c 
7 

Esta característica hace posible utilizar un vector denominado como tabla / vector de búsqueda para hacer coincidir los valores con los valores de otro vector o columna en el marco de datos. Teniendo en cuenta el siguiente marco de datos:

mydf <- data.frame(let = c('c','a','b','d'))

> mydf
  let
1   c
2   a
3   b
4   d

Supongamos que desea crear una nueva variable en el mydf mydf llamado num con los valores correctos de xy en las filas. Usando la función de match se pueden seleccionar los valores apropiados de xy :

mydf$num <- xy[match(mydf$let, names(xy))]

lo que resulta en:

> mydf
  let num
1   c   7
2   a   5
3   b   6
4   d   8

Expandiendo un vector con la función rep ()

La función rep se puede usar para repetir un vector de una manera bastante flexible.

# repeat counting numbers, 1 through 5 twice
rep(1:5, 2)
[1] 1 2 3 4 5 1 2 3 4 5

# repeat vector with incomplete recycling
rep(1:5, 2, length.out=7)
[1] 1 2 3 4 5 1 2

Cada argumento es especialmente útil para expandir un vector de estadísticas de unidades de observación / experimentales en un vector de datos. Cuadro con observaciones repetidas de estas unidades.

# same except repeat each integer next to each other
rep(1:5, each=2)
[1] 1 1 2 2 3 3 4 4 5 5

Una buena característica de la rep relacionada con la expansión de dicha estructura de datos es que la expansión de un vector a un panel no balanceado se puede lograr reemplazando el argumento de longitud con un vector que dicta el número de veces que se repite cada elemento en el vector:

# automated length repetition
rep(1:5, 1:5)
 [1] 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
# hand-fed repetition length vector
rep(1:5, c(1,1,1,2,2))
[1] 1 2 3 4 4 5 5

Esto debería exponer la posibilidad de permitir que una función externa alimente el segundo argumento de la rep para construir dinámicamente un vector que se expanda de acuerdo con los datos.

Al igual que con seq , las versiones más rápidas y simplificadas de rep son rep_len y rep.int . Éstos eliminan algunos atributos que las rep mantienen y, por lo tanto, pueden ser más útiles en situaciones en las que la velocidad es una preocupación y los aspectos adicionales del vector repetido son innecesarios.

# repeat counting numbers, 1 through 5 twice
rep.int(1:5, 2)
[1] 1 2 3 4 5 1 2 3 4 5

# repeat vector with incomplete recycling
rep_len(1:5, length.out=7)
[1] 1 2 3 4 5 1 2

Vectores de construcción en constantes: secuencias de letras y nombres de mes

R tiene una serie de construir en constantes. Las siguientes constantes están disponibles:

• LETTERS : las 26 letras mayúsculas del alfabeto romano
• letters : las 26 letras minúsculas del alfabeto romano.
• month.abb : las abreviaturas de tres letras para los nombres de los meses en inglés
• month.name : los nombres en inglés para los meses del año
• pi : la relación de la circunferencia de un círculo a su diámetro

A partir de las constantes de letras y meses, se pueden crear vectores.

1) Secuencias de letras:

> letters
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"

> LETTERS[7:9]
[1] "G" "H" "I"

> letters[c(1,5,3,2,4)]
[1] "a" "e" "c" "b" "d"

2) Secuencias de abreviaturas de mes o nombres de mes:

> month.abb
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

> month.name[1:4]
[1] "January"  "February" "March"    "April"   

> month.abb[c(3,6,9,12)]
[1] "Mar" "Jun" "Sep" "Dec"