FACTORES Y VECTORES

Lección 4 Vectores y otros tipos de listas

Un vector es una secuencia ordenada de datos. R dispone de muchos tipos de datos, entre los que
destacamos:

logical (lógicos: TRUE, verdadero, o FALSE, falso)

integer (números enteros)

numeric o double (números reales)

complex (números complejos)

character (palabras)

Una restricción fundamental de los vectores en R es que todos sus objetos han de ser del mismo
tipo: todos números, todos palabras, etc. Cuando queramos usar vectores formados por objetos
de diferentes tipos, tendremos que usar listas heterogéneas (véase la Sección 4.5).

4.1 Construcción de vectores

Para definir un vector con unos elementos dados, por ejemplo

1, 5, 6, 2, 5, 7, 8, 3, 5, 2, 1, 0

podemos aplicar la función c a estos elementos separados por comas.

x=c(1,5,6,2,5,7,8,3,5,2,1,0)

#> [1] 1 5 6 2 5 7 8 3 5 2 1 0

Si queremos crear un vector de palabras con la instrucción c, tenemos que entrarlas

obligatoriamente entre comillas. R también nos las muestra entre comillas.

nombres=c("Pep","Catalina","Joan","Pau")

nombres
#> [1] "Pep" "Catalina" "Joan" "Pau"

Si nos olvidamos de las comillas:

nombres=c(Pep,Catalina,Joan,Pau)

#> Error in eval(expr, envir, enclos): objeto 'Pep' no encontrado

Hemos mencionado que todos los elementos de un vector han de ser del mismo tipo. Por este
motivo, si juntamos datos de diferentes tipos en un vector, R automáticamente los convertirá a un
tipo que pueda ser común a todos ellos. El orden de conversión entre los tipos que hemos
explicado al principio de la lección es: character gana a complex, que gana a numeric, que gana a
integer, que gana a logical. Así, cuando alguna entrada de un vector es de tipo palabra, R considera
el resto de sus entradas como palabras (y las muestra entre comillas), como se puede ver en el
siguiente ejemplo:

c(2,3.5,TRUE,"casa")

#> [1] "2" "3.5" "TRUE" "casa"

Otra posibilidad para crear un vector es usar la función scan. Si ejecutamos la instrucción scan()
(así, con el argumento vacío), R abre en la consola un entorno de diálogo donde podemos ir
entrando datos separados por espacios en blanco; cada vez que pulsemos la tecla Entrar, R
importará los datos que hayamos escrito desde la vez anterior en que la pulsamos y abrirá una
nueva línea donde esperará más datos; cuando hayamos acabado, dejamos la última línea en
blanco (pulsando por última vez la tecla Entrar) y R cerrará el vector.

Por ejemplo, para crear un vector x_scan que contenga dos copias de

1, 5, 6, 2, 5, 7, 8, 3, 5, 2, 1, 0

una posibiidad sería primero entrar scan(), a continuación copiar esta secuencia con el editor de
textos y pegarla dos veces en la última línea de la consola, pulsando Entrar después de cada vez, y
finalmente pulsar Entrar por tercera vez en la última línea en blanco. Probadlo vosotros.

x_scan=scan() #Y pulsamos Entrar

1: 1 5 6 2 5 7 8 3 5 2 1 0

13: 1 5 6 2 5 7 8 3 5 2 1 0
25:

Read 24 items

x_scan

#> [1] 1 5 6 2 5 7 8 3 5 2 1 0 1 5 6 2 5 7 8 3 5 2 1 0

La función scan también se puede usar para copiar en un vector el contenido de un fichero de
texto situado en el directorio de trabajo, o del que conozcamos su dirección en Internet. La
manera de hacerlo es aplicando scan al nombre del fichero o a su url, entrados en ambos casos
entre comillas. Por ejemplo, para definir un vector llamado notas con las notas de un examen que
tenemos guardadas en el fichero http://aprender.uib.es/Rdir/notas.txt , sólo tenemos que entrar:

notas=scan("http://aprender.uib.es/Rdir/notas.txt")

notas

#> [1] 4.1 7.8 5.8 6.5 4.8 6.9 1.3 6.4 4.6 6.9 9.4 3.0 6.8 4.8 5.6

#> [16] 7.7 10.0 4.4 1.7 8.0 6.3 3.0 7.5 3.8 7.2 5.7 7.3 6.0 5.7 4.7

#> [31] 5.1 1.5 7.0 7.0 6.0 6.6 7.2 5.0 3.5 3.3 4.7 5.4 7.1 8.2 6.7

#> [46] 0.1 5.1 6.8 6.9 8.8 4.5 6.6 2.0 3.0 6.7 7.9 7.7 6.4 3.0 5.3

#> [61] 5.1 5.3 5.1 5.4 3.0

Si primero descargamos este fichero, sin cambiarle el nombre, en el directorio de trabajo de R,

para definir el vector anterior bastará entrar:

notas2=scan("notas.txt")

notas2

Si usamos el menú Import Dataset de la pestaña Environment para importar un vector contenido
en un fichero externo como explicamos en el Ejemplo 3.1, obtendremos en realidad un data frame
de una sola columna, llamada V1. Para construir un vector con esta columna, podemos usar luego
la instrucción

nombre_del_vector=nombre_del_dataframe$V1

Véase la Lección 6 para más detalles.

La función scan dispone de muchos parámetros, que podéis consultar en su Ayuda. Estos
parámetros se entran entre los paréntesis de scan(). Los más útiles en este momento son los
siguientes:

sep: sirve para indicar el signo usado para separar entradas consecutivas si no son espacios en
blanco. Para ello se ha de igualar sep a este signo, entrecomillado. Por ejemplo, si vamos a entrar
las entradas separadas por comas (o si están así en el fichero que vamos a importar), tenemos que
especificar sep=",".

x_scan2=scan()

1: 1,2,3,4

1:

## Error in scan() : scan() expected 'a real', got '1,2,3,4'

x_scan2=scan(sep=",")

1: 1,2,3,4

5:

Read 4 items

x_scan2

#> [1] 1 2 3 4

dec: sirve para indicar el separador decimal cuando no es un punto. Para ello hemos de igualar dec
al separador decimal entre comillas. Por ejemplo, si queremos crear con scan un vector formado
por los dos números reales 4,5 y 6,2 escritos exactamente de esta manera, tenemos que
especificar dec=",".

x_scan3=scan()

1: 4,5 6,2

## Error in scan() : scan() expected 'a real', got '4,5'

x_scan3=scan(dec=",")

1: 4,5 6,2

3:

Read 2 items

x_scan3

#> [1] 4.5 6.2

what: sirve para indicar a R de qué tipo tiene que considerar los datos que se le entren. En
particular, what="character" especifica que los valores que se le entran son palabras, aunque no
estén entre comillas (si se entran entre comillas, no hace falta especificarlo).

x_scan4=scan()

1: Pep Catalina Joan Pau

## Error in scan() : scan() expected 'a real', got 'Pep'

x_scan4=scan(what="character")

1: Pep Catalina Joan Pau

5:

Read 4 items

x_scan4

#> [1] "Pep" "Catalina" "Joan" "Pau"

encoding: sirve para indicar la codificación de alfabeto del fichero externo que se va a importar.
Sólo es necesario especificarlo si dicho fichero contiene caracteres que no sean de 7 bits; o sea,
letras acentuadas o caracteres especiales. En este caso, si su codificación no es la que espera
nuestro ordenador y no la especificamos con este parámetro, estos caracteres se importarán mal.
Sus dos posibles valores son "latin1" y "UTF-8". Por ejemplo, si sois usuarios de Windows,
seguramente vuestro ordenador espere que el fichero a importar esté codificado en latin1;
entonces, si está codificado en utf8 y contiene letras acentuadas, no las entenderá a no ser que
especifiquéis encoding="UTF-8".

Para definir un vector constante podemos usar la función

rep(a, n)

que genera un vector que contiene el valor

repetido

veces.

rep(1, 6)

#> [1] 1 1 1 1 1 1

rep("Palma", 5) #Las palabras, siempre entre comillas

#> [1] "Palma" "Palma" "Palma" "Palma" "Palma"

La función rep también se puede usar para repetir vectores. Ahora bien, cuando decimos que
queremos repetir cinco veces los valores 1, 2, 3, podemos referirnos a

1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3

oa

1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3.

Para especificar el tipo de repetición tenemos que usar el parámetro adecuado en el argumento
de rep: si añadimos times=5, repetiremos el vector en bloque cinco veces (en el primer sentido), y
si en cambio añadimos each=5, repetiremos cada valor cinco veces (en el segundo sentido).

rep(c(1,2,3), times=5)

#> [1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3

rep(c(1,2,3), each=5)

#> [1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3

Si queremos repetir cada elemento de un vector un número diferente de veces, podemos

especificarlo con el parámetro times igualado al vector de estas multiplicidades.

rep(c(1,2,3,4), times=c(2,3,4,5))

#> [1] 1 1 2 2 2 3 3 3 3 4 4 4 4 4

Las progresiones aritméticas se pueden especificar de manera compacta usando la función seq.
Una primera manera de hacerlo es mediante la instrucción

seq(a, b, by=p)

que especifica la progresión aritmética de paso

que empieza en

a
,

, hasta llegar a

. En concreto, si

<

>

, la función seq(a, b, by=p) genera un vector con la secuencia creciente

p
,

hasta llegar al último valor de esta sucesión menor o igual que

. Por ejemplo:

seq(3, 150, by=4.5)

#> [1] 3.0 7.5 12.0 16.5 21.0 25.5 30.0 34.5 39.0 43.5 48.0 52.5

#> [13] 57.0 61.5 66.0 70.5 75.0 79.5 84.0 88.5 93.0 97.5 102.0 106.5

#> [25] 111.0 115.5 120.0 124.5 129.0 133.5 138.0 142.5 147.0

Si en cambio

>

<

, entonces seq(a, b, by=p) genera un vector con la secuencia decreciente

p
,

hasta parar en el último valor de esta sucesión mayor o igual que

. Por ejemplo:

seq(80, 4, by=-3.5)

#> [1] 80.0 76.5 73.0 69.5 66.0 62.5 59.0 55.5 52.0 48.5 45.0 41.5 38.0 34.5 31.0

#> [16] 27.5 24.0 20.5 17.0 13.5 10.0 6.5

Finalmente, si el signo de

no es el correcto, obtenemos un mensaje de error:

seq(80, 4, by=3.5)

#> Error in seq.default(80, 4, by = 3.5): wrong sign in 'by' argument

Como vimos en la lección anterior, la instrucción seq con paso

se puede abreviar con el signo :. La instrucción a:b define la secuencia de números consecutivos
entre dos números

, es decir, la secuencia
a

hasta llegar a

(si

<

), o

…
 hasta llegar a

(si

>

).

1:15

#> [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

2.3:12.5

#> [1] 2.3 3.3 4.3 5.3 6.3 7.3 8.3 9.3 10.3 11.3 12.3

34:-5

#> [1] 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10

#> [26] 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5

Id con cuidado con los paréntesis y las operaciones al usar este operador:

-3:5

#> [1] -3 -2 -1 0 1 2 3 4 5

-(3:5)

#> [1] -3 -4 -5

2:3*4

#> [1] 8 12

2:(3*4)

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

La función seq también se puede usar para definir progresiones aritméticas de otras dos maneras.
En primer lugar, la función

seq(a, b, length.out=n)
define la progresión aritmética de longitud

que va de

; su paso es, por lo tanto,

si

>

; si

sólo produce el valor

a

seq(2, 10, length.out=10)

#> [1] 2.000000 2.888889 3.777778 4.666667 5.555556 6.444444 7.333333

#> [8] 8.222222 9.111111 10.000000