R Language
Création de vecteurs

Séquence de nombres

Utilisez l'opérateur : pour créer des séquences de nombres, par exemple pour vectoriser des morceaux plus importants de votre code:

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

Cela fonctionne dans les deux sens

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

et même avec des nombres à virgule flottante

1.25:5
# [1] 1.25 2.25 3.25 4.25

ou des négatifs

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

seq ()

seq est une fonction plus flexible que l'opérateur : permettant de spécifier des étapes autres que 1.

La fonction crée une séquence du start (la valeur par défaut est 1) jusqu'à la fin, y compris ce nombre.

Vous ne pouvez fournir que le paramètre end ( to )

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

Ainsi que le départ

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

Et enfin l'étape ( 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 peut éventuellement déduire les pas (régulièrement espacés) lorsque la longueur désirée de la sortie ( length.out ) est fournie

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 séquence doit avoir la même longueur qu'un autre vecteur, nous pouvons utiliser la along.with comme raccourci pour 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

Il existe deux fonctions simplifiées utiles dans la famille seq : seq_along , seq_len et seq.int . seq_along fonctions seq_along et seq_len construisent les nombres naturels (comptage) de 1 à N où N est déterminé par l'argument de la fonction, la longueur d'un vecteur ou d'une liste avec seq_along et l'argument entier avec seq_len .

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

Notez que seq_along renvoie les index d'un objet existant.

# 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 est le même que seq maintenu pour la compatibilité ancienne.

Il existe également une ancienne sequence fonctions qui crée un vecteur de séquences à partir d’un argument non négatif.

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

Vecteurs

Les vecteurs dans R peuvent avoir différents types (p. Ex. Entier, logique, caractère). La manière la plus générale de définir un vecteur est d'utiliser la fonction 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.

Cependant, dans R, les fonctions de sténographie sont généralement plus populaires.

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

La création de vecteurs avec des valeurs autres que les valeurs par défaut est également possible. La fonction c() est souvent utilisée pour cela. Le c est l'abréviation de combiner ou concaténer.

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.

Il est important de noter que R interprète tout nombre entier (par exemple 1) comme un vecteur entier de taille un. Il en va de même pour les chiffres (par exemple, 1.1), les logiques (par exemple, T ou F) ou les caractères (par exemple, «a»). Par conséquent, vous combinez essentiellement des vecteurs, qui sont eux-mêmes des vecteurs.

Attention, vous devez toujours combiner des vecteurs similaires. Sinon, R tentera de convertir les vecteurs en vecteurs du même type.

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

La recherche d'éléments dans des vecteurs peut être effectuée avec [ opérateur.

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'

Cela peut également être utilisé pour modifier les valeurs

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

Enfin, l'opérateur : (abréviation de la fonction seq() ) peut être utilisé pour créer rapidement un vecteur de nombres.

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

Cela peut également être utilisé pour les sous-ensembles de vecteurs (de sous-ensembles faciles à plus complexes)

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"

Création de vecteurs nommés

Le vecteur nommé peut être créé de plusieurs manières. Avec c :

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

qui se traduit par:

> xc
a b c d 
5 6 7 8

avec list :

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

qui se traduit par:

> xl
$a
[1] 5

$b
[1] 6

$c
[1] 7

$d
[1] 8

Avec la fonction setNames , deux vecteurs de même longueur peuvent être utilisés pour créer un vecteur nommé:

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

xy <- setNames(x, y)

ce qui résulte en un vecteur d'entier nommé:

> xy
a b c d 
5 6 7 8

Comme on peut le voir, cela donne le même résultat que la méthode c .

Vous pouvez également utiliser la fonction de names pour obtenir le même résultat:

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

Avec un tel vecteur, il est également possible de sélectionner des éléments par leur nom:

> xy["c"]
c 
7 

Cette fonctionnalité permet d'utiliser un vecteur nommé comme vecteur / table de recherche pour faire correspondre les valeurs aux valeurs d'un autre vecteur ou d'une autre colonne dans le dataframe. Considérant le dataframe suivant:

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

> mydf
  let
1   c
2   a
3   b
4   d

Supposons que vous souhaitiez créer une nouvelle variable dans le mydf mydf appelé num avec les valeurs correctes de xy dans les lignes. En utilisant la fonction de match , les valeurs appropriées de xy peuvent être sélectionnées:

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

qui se traduit par:

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

Développement d'un vecteur avec la fonction rep ()

La fonction rep peut être utilisée pour répéter un vecteur de manière assez souple.

# 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

Chaque argument est particulièrement utile pour étendre un vecteur de statistiques d'unités d'observation / expérimentales en un vecteur de data.frame avec des observations répétées de ces unités.

# 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

Une caractéristique intéressante de rep concernant l’expansion vers une telle structure de données est que l’extension d’un vecteur à un panneau déséquilibré peut être réalisée en remplaçant l’argument de longueur par un vecteur qui dicte le nombre de fois que chaque élément du vecteur doit être répété:

# 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

Cela devrait exposer la possibilité de permettre à une fonction externe d'alimenter le second argument de rep afin de construire dynamiquement un vecteur qui se développe en fonction des données.

Comme dans le cas seq , plus rapide, des versions simplifiées de rep sont rep_len et rep.int . Ceux-ci suppriment certains attributs que rep maintient et peuvent donc être très utiles dans les situations où la vitesse est un problème et d'autres aspects du vecteur répété sont inutiles.

# 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

Vecteurs de constantes de construction: séquences de lettres et de noms de mois

R a un certain nombre de constantes de construction. Les constantes suivantes sont disponibles:

• LETTERS : les 26 lettres majuscules de l'alphabet romain
• letters : les 26 lettres minuscules de l'alphabet romain
• month.abb : les abréviations à trois lettres pour les noms de mois anglais
• month.name : les noms anglais pour les mois de l'année
• pi : le rapport de la circonférence d'un cercle à son diamètre

À partir des lettres et des constantes de mois, des vecteurs peuvent être créés.

1) Séquences de lettres:

> 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) Séquences des abréviations des mois ou des noms de mois:

> 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"