9 Instructions conditionnelles et boucles

Ce chapitre s’appuie sur les notes de cours concernant les boucles.

Lorsqu’une ou plusieurs instructions doivent être répétées jusqu’à ce qu’une condition soit atteinte, plutôt que d’évaluer manuellement chaque itération du processus de répétition, nous pouvons utiliser des boucles. Dans ce chapitre, nous allons dans un premier temps aborder la notion d’instructions conditionnelles, puis nous verrons deux types de boucles.

9.1 Instructions conditionnelles

Dans le chapitre 2, nous avons rencontré les données de type logique (TRUE, FALSE et NA). Lorsque nous avons réalisé des indexations d’objets par condition, nous avons fait appel à des valeurs logiques retournées par l’évaluation d’instructions conditionnelles. Dans ce chapitre, nous allons également nous appuyer sur des valeurs logiques retournées par l’évaluation d’instructions conditionnelles, pour savoir si un morceau de code doit être évalué ou non. La compréhension du fonctionnement des intructions conditionnelles nous permettra par la suite de pouvoir utiliser des boucles, pour savoir si le processur itératif doit continuer ou s’arrêter.

9.1.1 Instruction if

Avec une instruction if, une action sera prise seulement si une condition particulière est vérifiée. La syntaxe est simple :

if(instruction_conditionnelle) action

avec instruction_conditionnelle une instruction conditionnelle retournant une valeur logique, et action une instruction qui sera évaluée uniquement si le logique retourné par l’instruction conditionnelle vaut TRUE.

Voici un exemple simple. Admettons que nous disposons d’un objet x contenant un entier naturel. Par xemple, supposons que x contient l’âge d’une personne, et que nous soyons amenés à divulguer une information à cette personne que si celle-ci a 13 ans ou plus. L’information peut être par exemple l’affichage du message suivant : “La fée des dents n’existe pas”.

Admettons que la personne nous ait indiqué avoir 22 ans.

x <- 22

Pour vérifier si la personne a 13 ans ou plus, on peut écrire l’instruction conditionnelle suivante, qui nous retourne TRUE ici :

x >= 13
## [1] TRUE

Écrivons à présent notre instruction conditionnelle. Si la personne a 13 ans ou plus, nous afficherons un message dans la console, à l’aide de la fonction print() :

if(x >= 13) print("La fée des dents n'existe pas")
## [1] "La fée des dents n'existe pas"

Admettons à présent que la personne à qui nous faisons face n’est âgée que de 5 ans.

x <- 5

Cette fois-ci, lorsqu’on évalue notre instruction conditionnelle, la valeur logique retournée est FALSE :

x >= 13
## [1] TRUE

Aussi, l’évaluation de notre instruction if ne donnera pas lieu à l’évaluation de l’action :

if(x >= 13) print("La fée des dents n'existe pas")

Si l’action à réaliser est composée de plusieurs instructions, la syntaxe de l’instruction if est légèrement modifiée : l’action est simplement placée à l’intérieur d’accolades {}.

if(instruction_conditionnelle) {
  action_1
  action_2
  ...
  action_n
}

Retournons à notre exemple pour illustrer cela. Admettons que nous souhaitons afficher la carré de l’âge de la personne en plus du message.

Retournons à notre individu de 22 ans :

x <- 22

L’instruction if :

if(x >= 13) {
  age_carre <- x^2
  print(paste("Votre age au carré vaut :", age_carre))
  print("La fée des dents n'existe pas")
}
## [1] "Votre age au carré vaut : 484"
## [1] "La fée des dents n'existe pas"

Note

L’instruction conditionnelle a été évaluée et la valeur logique TRUE a été retournée :

x >= 13
## [1] TRUE

Comme l’instruction logique vaut TRUE, les instructions à l’intérieur des accoldes ont été exécutées. Dans un premier temps, la variable age_carre a été créée. On peut noter que cette variable existe encore après l’évaluation de l’instruction if :

age_carre
## [1] 484

Ensuite, les deux instructions suivantes permettant d’afficher des messages dans la console ont été évaluées.

Si notre individu est plus jeune :

x <- 5

Le test x >=13 retourne FALSE et les actions à l’intérieur des accolades ne sont pas réalisées.

if(x >= 13) {
  age_carre <- x^2
  print(paste("Votre age au carré vaut :", age_carre))
  print("La fée des dents n'existe pas")
}

Note

L’instruction conditionnelle x >=13 ayant retourné la valeur logique FALSE, la valeur de la variable age_carre calculée précédemment n’a pas été modifiée :

age_carre
## [1] 484

  1. La fonction readline() permet de demander à un utilisateur de rentrer une valeur dans la console. En affectant la valeur lue dans la console dans une variable, l’information donnée par l’utilisateur peut être stockée. Évaluez l’instruction suivante, et écrivez votre âge dans la console, puis validez en appuyant sur la touche Entrée :

    age <- readline(prompt="Votre âge : ")

  2. Rédigez une instruction conditionnelle qui retourne la racine carrée de l’âge renseigné par l’utilisateur (stockée dans l’objet age) uniquement si la valeur stockée dans age est comprise entre 20 et 25.

  3. Essayez d’évaluer votre instruction en renseignant différentes valeurs pour âge : 18 ans, 22 ans, 27 ans.

9.1.2 Instruction if-else

Dans notre exemple, si l’individu est âgé de 13 ans ou plus, nous lui retournons une information. Dans le cas contraire, aucune action n’est menée. Si nous souhaitons réaliser une action dans les deux cas, que notre individu soit âgé de moins de 13 ans ou qu’il ait 13 ans ou plus, nous pouvons utiliser une instruction if-else. La syntaxe est la suivante :

if(instruction_conditionnelle) {
  # Si instruction_conditionnelle retourne TRUE
  action_1
  action_2
  ...
  action_n
}else {
  # Sinon
  action_a
  action_b
  ...
  action_x
}

Pour notre individu, s’il est âgé de 13 ans ou plus, nous lui afficherons son âge au carré et le message d’information. Si en revanche l’individu est trop jeune, nous lui indiquerons un autre message. Admettons que l’utilisateur soit âgé de 22 ans :

age <- 22

Notre instructions if-else sera :

if(age >= 13){
  age_carre <- age^2
  print(paste("Votre age au carré vaut :", age_carre))
  print("La fée des dents n'existe pas")
}else{
  print("La fée des dents passera-t-elle cette nuit ?")
}
## [1] "Votre age au carré vaut : 484"
## [1] "La fée des dents n'existe pas"

Seules les instructions dans le bloc de code correspondant aux actions à conduire si l’âge est supérieur ou égal à 13 sont évaluées. Si à présent notre individu est âgé de 5 ans :

age <- 5

L’instruction logique age >= 13 retournera FALSE. Les actions à mener si l’instruction logique retourne TRUE ne seront pas évaluées. En revanche, l’instruction à conduire dans le cas où l’instruction logique retourne FALSE sera bien évaluée :

if(age >= 13){
  age_carre <- age^2
  print(paste("Votre age au carré vaut :", age_carre))
  print("La fée des dents n'existe pas")
}else{
  print("La fée des dents passera-t-elle cette nuit ?")
}
## [1] "La fée des dents passera-t-elle cette nuit ?"

Il est possible d’imbriquer des conditions if ou if-else à l’intérieure de conditions if et if-else. Par

age <- 22

if(age >= 13){
  
  if(age >= 18){
    print("Vous êtes majeur(e)")
  }
  
  age_carre <- age^2
  print(paste("Votre age au carré vaut :", age_carre))
  print("La fée des dents n'existe pas")
}else{
  
  if(age < 7){
    print("Vous n'avez pas atteint l'âge de raison")
  }else{
    print("Vous avez atteint l'âge de raison")
  }
  
  print("La fée des dents passera-t-elle cette nuit ?")
}
## [1] "Vous êtes majeur(e)"
## [1] "Votre age au carré vaut : 484"
## [1] "La fée des dents n'existe pas"

Dans le code précédent :

  • Si la valeur de l’objet age est supérieure ou égale à 13 :

    • Si la valeur de l’objet age est supérieure ou égale à 18 : le message “Vous êtes majeur(e)” s’affiche
    • Si la valeur de l’objet age est n’est pas supérieure ou égale à 18, le message “Vous êtes majeur(e)” ne s’affiche pas
    • Que la valeur de l’objet age soit supérieure ou égal à 18 ou non, du moment qu’elle est supérieure ou égale à 13, le carré de l’âge est calculé et les deux messages indiquant la valeur de l’âge au carré et la terrible vérité au sujet de l’existance de la fée des dents s’affichent.

  • Si la valeur de l’objet age n’est pas supérieure ou égale à 13 :

    • Si de surcroît la valeur de l’objet age est inférieure à 7 : le message “Vous n’avez pas atteint l’âge de raison” s’affiche
    • Si en revanche la valeur de l’objet age n’est pas inférieure à 7 (mais bien inférieure à 13) : le message “Vous avez atteint l’âge de raison” s’affiche.
    • Que la valeur de l’objet age soit inférieure ou non à 7 (du moment qu’elle est inférieure à 13), le message “La fée des dents passera-t-elle cette nuit ?” s’affiche.

  1. Demandez à l’utilisateur de renseigner sa moyenne dans les deux Éléments Constitutifs de l’Unité d’Enseignement d’Economie et Finance internationales :

    finance_inter <- 
  readline(prompt="Votre moyenne en Finance internationale : ")
eco_inter <- 
  readline(prompt="Votre moyenne en Economie internationale : ")

  2. Si la moyenne à l’Unité d’Enseignement est supérieure ou égale à 10, affichez dans la console le message suivant : “Vous validez l’UE”. Si en revanche la moyenne est inférieure à 10, affichez dans la console le message “Vous ne validez pas l’UE”.

  3. Reprenez le code de la question précédente, et ajoutez la fonctionnalité suivantes :

    • Si la personne ne valide pas l’Unité d’Enseignement (moyenne aux deux épreuves inférieure à 10), indiquez-lui quelles sont les matières à repasser (uniquement celles pour lesquelles la note est strictement inférieure à 10).

Il est possible de vérifier successivement des instructions conditionnelles et d’effectuer une action dès lors qu’une des instructions est évaluée à TRUE. Pour notre exemple de message à afficher en fonction de l’âge de l’utilisateur, on peut dans un premier temps regarder si l’individu a moins de 13 ans et lui adresser un message adapté ; puis, s’il n’a pas moins de 13 ans, s’il a moins de 18 ans et lui adresser un autre message ; et enfin, s’il n’a pas moins de 18, lui retourner un message encore différent. La syntaxe de ce type d’expression sera la suivante :

if(instruction_conditionnelle_1){
  actions_1
}else if(instruction_conditionnelle_2){
  actions_2
}else{
  actions_3
}

Si notre individu a 7 ans :

age <- 7

if(age < 13){
  print(paste("L'âge que vous avez indiqué :", age, "ans"))
  print("L'âge minimum pour s'inscrire est de 13 ans.")
}else if(age < 18){
  print(paste("L'âge que vous avez indiqué :", age, "ans"))
  print("Contenus sensibles masqués.")
}else{
  print(paste("L'âge que vous avez indiqué :", age, "ans"))
  print("Contenus sensibles non masqués.")
}
## [1] "L'âge que vous avez indiqué : 7 ans"
## [1] "L'âge minimum pour s'inscrire est de 13 ans."

La valeur de l’objet age étant 7, l’instruction age < 13 retourne TRUE et seules les instructions à l’intérieur du premier bloc défini par les accolades sont exécutées.

Si notre individu a 22 ans :

age <- 22

if(age <= 13){
  print(paste("L'âge que vous avez indiqué :", age, "ans"))
  print("L'âge minimum pour s'inscrire est de 13 ans.")
}else if(age < 18){
  print(paste("L'âge que vous avez indiqué :", age, "ans"))
  print("Contenus sensibles masqués.")
}else{
  print(paste("L'âge que vous avez indiqué :", age, "ans"))
  print("Contenus sensibles non masqués.")
}
## [1] "L'âge que vous avez indiqué : 22 ans"
## [1] "Contenus sensibles non masqués."

La valeur de l’objet age étant 7, l’instruction age < 13 retourne FALSE. Les instructions à l’intérieur du premier bloc défini par les accolades ne sont pas exécutées. La deuxième instruction conditionnelle, age < 18, est évaluée et retourne FALSE. Les instructions à l’intérieur du deuxième bloc défini par les accolades ne sont pas exécutées. Il n’y a pas d’autres instruction conditionnelle avant le mot clé else, donc le code à l’intérieur du bloc défini par les accolades associées à else est évalué.

9.2 Boucles

Il existe deux sortes de boucles dans R. Celles pour lesquelles les itérations continuent tant qu’une condition n’est pas invalidée (while()), et celles pour lesquelles le nombre d’itérations est défini au moment de lancer la boucle (for()).

9.2.1 Boucles while()

Les codes à l’intérieur d’une boucle while seront évaluées de manière itérative. Avant chaque itération, une instruction conditionnelle est évaluée. Si cette instruction retourne le logique TRUE, le code est évalué. Puis débute une nouvelle itération. Si en revanche l’instruction conditionnelle retourne le logique FALSE, le code n’est pas évalué et le processus itératif cesse. Le schéma de la Figure 9.1 illustre le fonctionnement d’une boucle while().

Figure 9.1: Fonctionnement d’une boucle while.

La syntaxte est la suivante :

while(condition) instruction

Ou encore, si plusieurs instructions doivent être évaluées à chaque itération :

while(condition){
  instruction_1
  instruction_2
  ...
  instruction_n
}

Prenons un exemple. Soit un entier x contenant une valeur qui peut varier. Admettons que cette valeur vaille 50 :

x <- 50

Créons une boucle while dans laquelle chaque itération vient diviser la valeur de x par 3, puis remplace l’ancienne de valeur de x par le résultat de la division :

while(x / 3 > 1){
  print(x / 3)
  x <- x/3
}
## [1] 16.66667
## [1] 5.555556
## [1] 1.851852

Regardons pas-à-pas les étapes du processus itératif précédent. Lors de l’initialisation, la valeur de x vaut 50.

L’instruction conditionnelle x / 3 > 1 est évaluée et retourne le logique TRUE. En effet, 50/3 ~ 16.66667 est bien strictement supérieur à 1.

  • La première itération commence.
  • Le bloc de code de la boucle, défini par les accolades, peut alors être évalué.
  • La valeur x/3 est affichée avec la fonction print() : la valeur 16.66667 s’affiche dans la console.
  • Puis, la valeur de x est remplacée par le tiers de sa valeur (x <- x/3).
  • La nouvelle valeur de x est donc 16.66667.
  • La première itération s’achève.

Ensuite, l’instruction conditionnelle x / 3 > 1 est évaluée et retourne le logique TRUE. En effet, 16.66667/3 ~ 5.555556 est bien strictement supérieur à 1.

  • La deuxième itération commence.
  • Le bloc de code de la boucle, défini par les accolades, peut alors être évalué.
  • La valeur x/3 est affichée avec la fonction print() : la valeur 5.555556 s’affiche dans la console.
  • Puis, la valeur de x est remplacée par le tiers de sa valeur (x <- x/3).
  • La nouvelle valeur de x est donc 5.555556.
  • La deuxième itération s’achève.

L’instruction conditionnelle x / 3 > 1 est évaluée et retourne le logique TRUE. En effet, 5.555556/3 ~ 1.851852 est bien strictement supérieur à 1.

  • La troisième itération commence.
  • Le bloc de code de la boucle, défini par les accolades, peut alors être évalué.
  • La valeur x/3 est affichée avec la fonction print() : la valeur 1.851852 s’affiche dans la console.
  • Puis, la valeur de x est remplacée par le tiers de sa valeur (x <- x/3).
  • La nouvelle valeur de x est donc 1.851852.
  • La troisième itération s’achève.

L’instruction conditionnelle x / 3 > 1 est évaluée et retourne le logique FALSE. En effet, 1.851852/3 ~ 0.617284 et n’est donc pas strictement supérieur à 1. Le processus itératif s’arrête. La valeur contenue dans x est donc 1.851852.

Il n’existe pas qu’une seule manière de rédiger des boucles. Il est parfois utile, avec une boucle while, de créer une variable (que l’on peut appeler continuer par exemple) contenant une valeur logique TRUE et d’utiliser cette variable comme instruction conditionnelle pour continuer les itérations. Le code à l’intérieur de la boucle se chargera de venir changer la valeur de cette variable au moment opportun. Par exemple, pour obtenir le même résultat dans x que dans l’exemple précédent, on pourra écrire :

x <- 50
continuer <- (x / 3 > 1)

while(continuer){
  print(x / 3)
  
  if(x / 3 < 1){
    continuer <- FALSE
  }else{
    x <- x/3
  }
}
## [1] 16.66667
## [1] 5.555556
## [1] 1.851852
## [1] 0.617284
x
## [1] 1.851852

Pour éviter de créer la variable continuer, nous pouvons utiliser le mot clé break à l’intérieur de la boucle pour stopper la boucle au moment opportun.

x <- 50
while(TRUE){
  print(x / 3)
  
  if(x / 3 < 1){
    break
  }else{
    x <- x/3
  }
}
## [1] 16.66667
## [1] 5.555556
## [1] 1.851852
## [1] 0.617284
x
## [1] 1.851852

Exercice

À l’aide de la fonction while(), créez une boucle qui permet de calculer la factorielle d’un nombre.

Exercice bonus

À l’aide d’une boucle while, créez un code dans lequel vous devrez tenter de faire deviner un nombre magique tiré aléatoirement entre 1 et 100.

Dans une première étape, un nombre magique est tiré aléatoirement :

nombre_magique <- sample(x=1:100, size = 1)

Votre code doit demander à l’utilisateur d’entrer une réponse :

tentative <- 
  readline(prompt="Nombre entier compris entre 1 et 100 : ")

Vous devez ensuite indiquer, à l’aide d’instructions conditionnelles si le nombre donné par l’utilisateur est inférieur, supérieur, ou égal au nombre magique.

9.2.2 Boucles for()

Lorsqu’on connaît a priori le nombre d’itérations que l’on souhaite faire, il est coutume de faire appel à une boucle for(). On définit un itérateur qui prendra successivement des valeurs dans un ensemble donné jusqu’à ce que toutes les valeurs de l’ensemble auront été utilisées comme itérateur. La syntaxe est la suivante :

for(iterateur in ensemble){
  instruction_1
  instruction_2
  ...
  instruction_n
}

Le schéma de la Figure 9.2 illustre le fonctionnement d’une boucle for().

Figure 9.2: Fonctionnement d’une boucle for

Illustrons par ailleurs le fonctionnement à l’aide d’un exemple simple. Considérons un itérateur que l’on nommera i et l’ensemble des entiers naturels de 1 à 10. À chaque itération, i prendra une des valeurs de l’ensemble :

for(i in 1:10){
  carre <- i^2
  print(paste("Le carré de", i, "est :", carre))
}
## [1] "Le carré de 1 est : 1"
## [1] "Le carré de 2 est : 4"
## [1] "Le carré de 3 est : 9"
## [1] "Le carré de 4 est : 16"
## [1] "Le carré de 5 est : 25"
## [1] "Le carré de 6 est : 36"
## [1] "Le carré de 7 est : 49"
## [1] "Le carré de 8 est : 64"
## [1] "Le carré de 9 est : 81"
## [1] "Le carré de 10 est : 100"

Regardons en détail ce qu’il s’est passé lors de l’éxécution de ce bout de code.

  • À la première itération, l’objet i est créé et la valeur 1 lui est affectée (si un objet i existait déjà, sa valeur eut été remplacée par la valeur 1).
  • L’objet carre est créé et le carré de i, c’est à dire \(1^2=1\) lui est affecté.
  • La chaîne de caractère indiquant la valeur de i et de son carré est ensuite affichée dans la console.
  • La première itération prend fin.
  • L’ensemble des valeurs des entiers de 1 à 10 n’a pas encore été utilisé lors du processus itératif ; ce dernier se poursuit donc.
  • La deuxième itération débute, et la valeur de l’objet i devient la valeur suivante de l’ensemble 1:10, c’est-à-dire 2.
  • La valeur du carré de i, c’est-à-dire \(2^2=4\) est affectée à l’objet carré.
  • La chaîne de caractère indiquant la valeur de i et de son carré est ensuite affichée dans la console.
  • La deuxième itération prend fin.
  • L’ensemble des valeurs des entiers de 1 à 10 n’a pas encore été utilisé lors du processus itératif ; ce dernier se poursuit donc.
  • …
  • La dixième itération débute, et la valeur de l’objet i devient la valeur suivante de l’ensemble 1:10, c’est-à-dire 10.
  • La valeur du carré de i, c’est-à-dire \(10^2=100\) est affectée à l’objet carré.
  • La chaîne de caractère indiquant la valeur de i et de son carré est ensuite affichée dans la console.
  • La dixième itération prend fin.
  • L’ensemble des valeurs des entiers de 1 à 10 a été utilisé lors du processus itératif ; ce dernier s’achève.

Note

À l’issue des itérations, l’objet i contient la dernière valeur de l’ensemble.

Note

Nous pouvons utiliser une boucle while() pour obtenir le même résultat. Le code est un tout petit moins lisible.

i <- 0
while(i < 10){
  i <- i+1
  carre <- i^2
  print(paste("Le carré de", i, "est :", carre))
}
## [1] "Le carré de 1 est : 1"
## [1] "Le carré de 2 est : 4"
## [1] "Le carré de 3 est : 9"
## [1] "Le carré de 4 est : 16"
## [1] "Le carré de 5 est : 25"
## [1] "Le carré de 6 est : 36"
## [1] "Le carré de 7 est : 49"
## [1] "Le carré de 8 est : 64"
## [1] "Le carré de 9 est : 81"
## [1] "Le carré de 10 est : 100"

L’ensemble de valeurs n’est pas nécessairement composé d’entiers. Il peut s’agir de n’importe quel élément contenu dans une structure sur laquelle il est possible d’itérer :

for(i in c("A", "B", "C")){
  print(paste("La valeur courante de i vaut :", i))
}
## [1] "La valeur courante de i vaut : A"
## [1] "La valeur courante de i vaut : B"
## [1] "La valeur courante de i vaut : C"
for(i in list(toto=c(1,2), titi=c("A", "B"))){
  print(i)
}
## [1] 1 2
## [1] "A" "B"

Exercice

Si vous avez quelques interrogations quant à l’utilité des boucles dans le cadre de vos études en économie, cet exercice devrait vous permettre d’apprécier le gain de temps potentiel que celles-ci peuvent vous faire gagner.

Il s’agit d’importer une multitude de fichiers CSV (en l’occurence, 35) présentant une structure similaire. Ces fichiers contiennent des observations de commptage de vélos à des points spécifiques de la ville de Paris, en 2018. Chaque fichier correspond à une localisation donnée, la localisation est utilisée comme nom de fichier.

Les 35 fichiers CSV sont contenus dans une archive Zip disponible à l’adresse suivante : https://egallic.fr/Enseignement/R/Exercices/Boucles/velo.zip. (Note : Les données brutes sont disponible sur le site de l’open data de la ville de Paris.)

  1. Téléchargez l’archive contenant les 35 fichiers CSV, puis extrayez son contenu dans le dossier Data de votre répertoire de projet.
  2. Créez un objet que vous nommerez df_velo qui contiendra la valeur NULL.
  3. Importez le fichier Voie_Georges_Pompidou.csv dans R, dans un objet que vous nommerez df_tmp.
  4. Utilisez la fonction bind_rows() pour empiler les données du tableau df_tmp sur df_velo. Le résultat doit venir écraser l’objet df_velo pour que son contenu devienne le résultat de l’application de la fonction bind_rows(). Le tableau df_velo contiendra alors 17 473 observations.
  5. Importez le fichier 106_Avenue_Denfert_Rochereau_NE-SO.csv dans R, dans un objet que vous nommerez df_tmp.
  6. Utilisez la fonction bind_rows() pour empiler les données du tableau df_tmp sur df_velo. Le résultat doit venir écraser l’objet df_velo pour que son contenu devienne le résultat de l’application de la fonction bind_rows(). Votre tableau df_velo contiendra alors les 17 473 observations du premier fichier et les 8 737 du deuxième, soit 26 210 observations.
  7. Importez le fichier 28_Boulevard_Diderot.csv dans R, dans un objet que vous nommerez df_tmp.
  8. Utilisez la fonction bind_rows() pour empiler les données du tableau df_tmp sur df_velo. Le résultat doit venir écraser l’objet df_velo pour que son contenu devienne le résultat de l’application de la fonction bind_rows(). Votre tableau df_velo contiendra alors les 17 473 observations du premier fichier, les 8 737 du deuxième, et les 17 473 du troisième, soit 43 684 observations.
  9. Prenez le temps d’imginer à quel point il serait pénible d’empiler les 35 fichiers.

À présent, tentons de réfléchir à l’utilisation d’une boucle pour effectuer la tâche. Les premières questions devraient vous laisser apercevoir que vous avez réalisé une tâche répétitive qui consiste à chaque itération à charger un fichier et à ajouter son contenu à un tableau existant. Vous avez donc besoin dans un premier temps de récupérer dans un vecteur le lien de chacun des fichiers. Pour ce faire, vous allez utiliser la fonction list.files(), qui permet de lister le contenu d’un répertoire.

N <- list.files("Data/velo/", full.names = TRUE)
N
##  [1] "Data/velo//10_avenue_de_la_Grande_Armée_SE-NO.csv"          
##  [2] "Data/velo//10_Bd_Auguste_Blanqui_NE-SO.csv"                 
##  [3] "Data/velo//100_Rue_La_Fayette_O-E.csv"                      
##  [4] "Data/velo//102_Bd_magenta_SE-NO.csv"                        
##  [5] "Data/velo//105_Rue_La_Fayette_E-O.csv"                      
##  [6] "Data/velo//106_Avenue_Denfert_Rochereau_NE-SO.csv"          
##  [7] "Data/velo//135_Avenue_Daumesnil_SE-NO.csv"                  
##  [8] "Data/velo//152_Boulevard_du_Montparnasse.csv"               
##  [9] "Data/velo//16_Avenue_de_la_Porte_des_Ternes_E-O.csv"        
## [10] "Data/velo//18_quai_de_l'hotel_de_ville.csv"                 
## [11] "Data/velo//21_Boulevard_Auguste_Blanqui_SO-NE.csv"          
## [12] "Data/velo//243_Boulevard_Saint_Germain_NO-SE.csv"           
## [13] "Data/velo//26_Boulevard_de_Ménilmontant_SE-NO.csv"          
## [14] "Data/velo//27_Boulevard_Diderot_E-O.csv"                    
## [15] "Data/velo//28_Boulevard_Diderot.csv"                        
## [16] "Data/velo//35_Boulevard_de_Menilmontant_NO-SE.csv"          
## [17] "Data/velo//39_Quai_François_Mauriac.csv"                    
## [18] "Data/velo//6_rue_Julia_Bartet.csv"                          
## [19] "Data/velo//67_boulevard_Voltaire_SE-NO.csv"                 
## [20] "Data/velo//7_Avenue_de_la_Grande_Armée_NO-SE.csv"           
## [21] "Data/velo//72_Bd_Richard_Lenoir_S-N.csv"                    
## [22] "Data/velo//72_boulevard_Voltaire_NO-SE.csv"                 
## [23] "Data/velo//77_Bd_Richard_Lenoir_N-S.csv"                    
## [24] "Data/velo//89_boulevard_de_Magenta_NO-SE.csv"               
## [25] "Data/velo//97_Avenue_Denfert_Rochereau_SO-NE.csv"           
## [26] "Data/velo//Face_104_Rue_d'Aubervilliers.csv"                
## [27] "Data/velo//Face_au_16_Avenue_de_la_Porte_des_Ternes_O-E.csv"
## [28] "Data/velo//Face_au_25_quai_de_l'Oise.csv"                   
## [29] "Data/velo//Face_au_48_quai_de_la_marne.csv"                 
## [30] "Data/velo//face_au_70_Quai_de_Bercy.csv"                    
## [31] "Data/velo//Pont_du_Garigliano_NO-SE.csv"                    
## [32] "Data/velo//Pont_du_Garigliano_SE-NO.csv"                    
## [33] "Data/velo//Pont_National_NE-SO.csv"                         
## [34] "Data/velo//Pont_National_SO-NE.csv"                         
## [35] "Data/velo//Voie_Georges_Pompidou.csv"

L’objet N consistera votre ensemble sur lequel itérer.

  1. À l’aide d’une boucle for(), chargez l’ensemble des 35 fichiers CSV du répertoire velo et placez leur contenu dans un tableau de données que vous nommerez df_velo.

Exercice bonus

Utilisez une boucle for() pour reproduire la suite de Fibonacci jusqu’à son dixième terme (la séquence \(F_n\) est définie par la relation de récurrence suivante : \(F_n=F_n−1+F_n−2\) ; les valeurs initiales sont : \(F_0=0\) et \(F_1=1\)).

Des compléments sur les fonctions de type lapply() ou map() vous permettront de réaliser des opérations répétées. Nous n’aurons malheureusement pas le temps de les aborder dans le cadre de ces travaux dirigés. En revanche, vous êtes invité(e) à consulter la section consacrée à la vectorisation sur les notes de cours.