Master Finance et Data Science

Fiche de TP1 :
Exercice 1 :
Une agence météorologique collecte des données sur les précipitations annuelles (en mm ou litres/m²) et les
températures moyennes annuelles (en °C) dans 4 régions : Nord, Sud, Est et Ouest sur les 3 dernières années :
Données :
Précipitations annuelles (en mm)
Année Nord Sud Est Ouest
Année 1 1200 900 1100 950
Année 2 1350 850 1200 980
Année 3 1400 920 1150 1000

Températures moyennes annuelles (en °C)

Année Nord Sud Est Ouest
Année 1 12,5 22,2 17,8 17,0
Année 2 13,0 22,8 18,5 17,5
Année 3 14,8 22,5 18,0 17,2
1. Créer deux matrices : matrice_precip pour les précipitations, et matrice_temp pour les températures.
2. Nommer les lignes et colonnes des deux matrices.
3. Calculer les totaux et les moyennes :
a. Le total des précipitations pour chaque région sur les 3 années.
b. La moyenne des températures pour chaque région.
4. Ajouter une nouvelle colonne dans la matrice matrice_precip représentant le total des précipitations
pour chaque année.
5. Extraire les régions où la température moyenne sur 3 ans est supérieure à 14°C.
6. Ajouter 0,5 °C à chaque température pour simuler un réchauffement climatique.
7. Afficher les résultats
7. Extraire des informations spécifiques :
a. Quelle région a enregistré le total de précipitations le plus élevé sur 3 ans ?
b. Quelles sont les précipitations combinées des 2 premières années pour la région Ouest ?
c. Quels sont les écarts de température entre les régions Nord et Sud sur les 3 années ?
# Création des données de précipitations (en mm) pour 3 années et 4 régions
precipitations <- c(1200, 900, 1100, 950, # Année 1
1350, 850, 1200, 980, # Année 2
1400, 920, 1150, 1000) # Année 3

# Création d'une matrice pour les précipitations

matrice_precip <- matrix(precipitations, nrow = 3, byrow = TRUE)

# Étiquettes pour les lignes (années) et colonnes (régions)

etiquetes_ligne <- c("Annee1", "Annee2", "Annee3")
etiquetes_colonne <- c("Nord", "Sud", "Est", "Ouest")

# Nommer les lignes et colonnes de la matrice de précipitations

rownames(matrice_precip) <- etiquetes_ligne
colnames(matrice_precip) <- etiquetes_colonne
# Création des données de températures pour 3 années et 4 régions
temperatures <- c(12.5, 22.2, 17.8, 17.0, # Année 1
13.0, 22.8, 18.5, 17.5, # Année 2
14.8, 22.5, 18.0, 17.2) # Année 3

# Création d'une matrice pour les températures avec noms de lignes et colonnes
matrice_temp <- matrix(temperatures, nrow = 3, byrow = TRUE, dimnames = list(etiquetes_ligne,
etiquetes_colonne)

# Calcul du total des précipitations pour chaque région sur 3 ans

total_region <- colSums(matrice_precip)

# Calcul de la moyenne des températures pour chaque région sur 3 ans

mean_region <- colMeans(matrice_temp)

# Ajouter une colonne à la matrice de précipitations représentant le total annuel

matrice_precip <- cbind(matrice_precip, Total_Year = rowSums(matrice_precip))
# Extraire les régions avec une température moyenne sur 3 ans supérieure à 14°C
mean_temp_above_14 <- matrice_temp[, mean_region > 14]

# Affichage des résultats

print("Matrice des précipitations avec le total annuel :")
print(matrice_precip)
print("Total des précipitations par région sur 3 ans :")
print(total_region)
print("Moyenne des températures par région sur 3 ans :")
print(mean_region)
print("Régions avec une température moyenne > 14°C :")
print(mean_temp_above_14)
# La région ayant enregistré le total de précipitations le plus élevé sur 3 ans
region_max_precip <- names(total_region[which.max(total_region)])
paste("La région ayant enregistré le total de précipitations le plus élevé sur 3 ans est :",
region_max_precip)

# Les précipitations combinées des 2 premières années pour la région Ouest

precip_ouest_2_annees <- sum(matrice_precip[1:2, "Ouest"])
paste("Les précipitations combinées des 2 premières années pour la région Ouest sont :",
precip_ouest_2_annees, "mm")

# Les écarts de température entre les régions Nord et Sud sur les 3 années
ecart_temp_nord_sud <- matrice_temp[, "Nord"] - matrice_temp[, "Sud"]
print("Les écarts de température entre les régions Nord et Sud sur les 3 années sont :")
print(ecart_temp_nord_sud)
Exercice 2 :
1. Créer un vecteur « salaires » qui contient les salaires mensuels de 12 employés (8500, 8700,
8800, 9000, 9200, 9150, 7800, 7900, 8000, 9500, 9700, 9600) répartis en 4 départements sur 3
mois.
2. Organiser ces salaires dans une matrice, de 4 lignes et 3 colonnes, nommée matSalaires.
3. Nommer les lignes de la matrice par Production, Marketing, RH et R&D, et les colonnes par
Mois1, Mois2, Mois3.
4. Afficher la matrice des salaires
5. Calculer les totaux des salaires pour chaque mois.
6. Calculer les totaux des salaires par département sur les trois mois.
7. Calculer le salaire moyen par département.
8. Ajouter une nouvelle colonne représentant le total des salaires pour chaque département.
9. Extraire les départements avec un salaire moyen supérieur à 8500
3. Les facteurs
Un facteur est une structure de données utilisée pour regrouper des valeurs textuelles en catégories
distinctes. Il permet d’organiser un vecteur de caractères en niveaux (ou catégories). Par exemple, une
variable comme le sexe d’une personne peut être représentée par un facteur avec deux niveaux : Homme et
Femme. Pour créer un facteur à partir d’un vecteur nous utilisons : factor(vect)

sexe <- c("homme", "femme", "homme", "homme", "femme", "femme")

sexe.facteur <- factor(sexe)
sexe.facteur
[1] femme homme homme femme femme
Levels: femme homme # 2 catégories (niveaux) classées en ordre alphabétique
str(sexe) ; str(sexe.facteur) # Un vecteur de caractères
typeof(sexe) ; typeof(sexe.facteur) # Les données sont converties en valeurs entières.

En R, les niveaux d’un facteur peuvent être obtenus à l’aide de la fonction levels(). Les niveaux représentent
les différentes catégories ou valeurs possibles d’un facteur : levels(sexe.facteur)
On peut obtenir des statistiques descriptives sur les facteurs avec summary(sexe.facteur), et compter le
nombre d'occurrences de chaque niveau dans le facteur avec la fonction table(sexe.facteur)
# Autre syntaxe
factor(data , levels = ) # définit l’ordre du codage
fact <- factor(sexe, levels = c("homme", "femme"))
str(fact)
levels(fact) <- c("H", "F")
str(fact)
fact <- factor(sexe, levels = c("homme", "femme"), labels = c("H", "F"))

facteur <- factor(c("chat", "chien", "oiseau", "chat", "chien", "chien"), levels = c("chat", "chien", "oiseau"))

La syntaxe "factor(c("chat", "chien", "oiseau", "chat", "chien", "chien"), levels = c("chat", "chien",
"oiseau"))" crée également un facteur à partir du vecteur "animaux", mais elle spécifie également les niveaux
à utiliser en utilisant l'argument "levels". Cela signifie que les niveaux seront créés en fonction des valeurs
spécifiées dans l'argument "levels", et non en fonction des valeurs qui apparaissent dans le vecteur.

En d'autres termes, cette syntaxe crée un facteur avec des niveaux spécifiques qui peuvent être différents de
ceux qui existent dans le vecteur.
Ajouter un ordre aux facteurs
Certains facteurs ont un ordre logique, comme les tailles de vêtements (Petit, Moyen, Grand). Cela
peut être utile pour des analyses. On peut alors ordonner les catégories comme l’exemple suivant :

# Vecteur des températures

temperature <- c("basse", "élevée", "basse", "moyenne", "élevée")
# Créer un facteur avec un ordre spécifié
temp_factor <- factor(temperature, levels = c("basse", "moyenne", "élevée"), order = TRUE)
print(temp_factor)
# Le résultat :
[1] basse, élevée, basse, moyenne, élevée
Levels : basse < moyenne < élevée
Exercice : Préférences d'achat des consommateurs par catégorie de revenu
Contexte :
Une étude cherche à analyser les préférences d'achat des consommateurs en fonction de leur catégorie de
revenu (bas, moyen, élevé). Les produits achetés sont classés dans les catégories suivantes : Alimentation,
Électronique, Vêtements.
1.Représenter les catégories de revenu et de produit achetés sous forme de facteurs.
2.Compter le nombre de consommateurs par catégorie de revenu pour chaque type de produit.

Données :
Revenu Produit
Bas Alimentation
Bas Alimentation
Moyen Électronique
Élevé Vêtements
Moyen Vêtements
Bas Alimentation
Élevé Électronique
Moyen Alimentation
Bas Électronique
Solution :

# Vecteur des catégories de revenu

revenu <- c("Bas", "Bas", "Moyen", "Élevé", "Moyen", "Bas", "Élevé", "Moyen", "Bas")

# Vecteur des produits

produit <- c("Alimentation", "Alimentation", "Électronique", "Vêtements",
"Vêtements", "Alimentation", "Électronique", "Alimentation", "Électronique")

# Convertir en facteurs
facteur_revenu <- factor(revenu, levels = c("Bas", "Moyen", "Élevé"), order = T)
facteur_produit <- factor(produit, levels = c("Alimentation", "Électronique", "Vêtements"))

# Créer une table croisée

tableau <- table(facteur_revenu, facteur_produit)
print(tableau)
4. Les listes
Une liste est une structure de données qui peut contenir différents types d'objets, tels que des
vecteurs, des matrices, des data frames, des facteurs, des autres listes, etc.
Les vecteurs ont une longueur fixe, tandis que les listes peuvent être de longueur variable.
Les éléments d'un vecteur sont indexés par des entiers, tandis que les éléments d'une liste sont
indexés par des noms de composants.
Les listes sont créées à l'aide de la fonction "list()"
# Exemples de création d'une liste :
ma_liste <- list(nom = "Imane", age = 23, taille = 1.70, notes = c(15, 13, 18))
ma_liste
liste_mixte <- list(revenus, matrice_rev, head(iris, 5), tail(iris,3), ma_liste)
liste_mixte
etudiants <- list(nom = c("Amine", "Nada", "Houda", "Ahmed"),
age = c(20, 22,20, 21),
note = list(c(15, 16, 17), c(13, 14, 15), c(16, 14, 17), c(12, 13, 14)))
etudiants
liste <- list( v1 = v1, v3 = v3, v4 = v4, matrice = matrice, donnees = donnees)
print(liste)
Sélection d'éléments

Voici quelques exemples de sélection d’éléments d’une liste :

#Sélectionner les valeurs d’un composant par son nom
ma_liste$age
liste$matrice
liste[["v1"]]
#Sélectionner les valeurs d’un composant par son numéro dans la liste
ma_liste[[1]]
#Sélectionner une valeur d’un composant par son indice
ma_liste$notes[3]
liste_mixte[[5]]$age
Modification d'éléments

Voici quelques exemples de modification de composants d’une liste :

# Modifier la valeur de l'élément 'age' de la liste

ma_liste[['age']] <- 25

print(ma_liste)

# Modifier le nom de l'élément 'revenus' de la liste

names(liste_mixte)[1] <- ‘Salaires’

liste_mixte
Ajout d'éléments

Voici quelques exemples d'ajout d'éléments :

#Créer une liste vide
Li = list()
Li
# Ajouter des éléments
Li[[1]] <- "Langage R"
Li[[2]] <- c(1, 2, 3,5)
# Ajouter un nouvel élément avec le nom 'Bool' et la valeur TRUE
Li$Bool <- TRUE
Li[['Bool']] <- TRUE #2ème possibilité
print(Li)
# Ajouter un nouvel élément à la fin de la liste
Li <- c(Li, "nouvel_element")
print(Li)
Suppression d'éléments
Voici quelques exemples de suppression d’éléments d’une liste :
# Supprimer le premier élément de la liste
Ma_liste <- ma_liste[-1]
print(ma_liste)
# Supprimer l'élément 'taille' de la liste
ma_liste[['taille']] <- NULL
print(ma_liste)
# Supprimer les éléments à la position 2 et 3 de la liste
ma_liste <- ma_liste[-c(2, 3)]
print(ma_liste)
# Création d'une liste avec des éléments numériques
liste2 <- list(a = 1, b = 2, c = 3)
# Supprimer les éléments supérieurs à 2 de la liste
liste2 <- subset(liste2, liste2 <= 2)
print(liste2)
Quelques fonctions utilisées pour les listes
length() : renvoie le nombre d'éléments dans une liste
names() : renvoie les noms des éléments d'une liste
unlist() : convertit une liste en un vecteur
Application :
# Créer une liste
ma_list <- list(nom = "Jalal", age = 30, sexe = "homme")
# Sélectionner l'élément age de la liste
print(ma_list$age)
# Modifier l'élément nom de la liste
ma_list$nom <- "Maria"
print(ma_list)
# Ajouter un nouvel élément à la liste
ma_list$profession <- "médecin"
print(ma_list)
# Convertir une liste en vecteur
vecteur_liste <- unlist(ma_list)
print(vecteur_liste)
− Opérateurs arithmétiques, logiques et relationnels
− Structures conditionnelles
− Fonctions any() et all()
− Structures répétitives
− Fonctions personnalisées
1. Opérateurs arithmétiques, logiques et relationnels
Opérateur Description Exemple Résultat
+ Addition 2+3 5
- Soustraction 7-4 3
* Multiplication 6*3 18
/ Division 8/2 4
^ ou ** Puissance 3^2 9
%/% Division entière 10 %/% 3 3
%% Modulo (reste) 10 %% 3 1
b. Opérateurs logiques

Les opérateurs logiques servent à vérifier des conditions.

Opérateur Description Exemple Résultat

& ET logique TRUE & FALSE FALSE
| OU logique TRUE | FALSE TRUE
! NON logique ! TRUE FALSE

Exemple :

x <- TRUE
y <- FALSE
print(x & y) # Résultat : FALSE
print(x | y) # Résultat : TRUE
print(!x) # Résultat : FALSE
c. Opérateurs relationnels

Les opérateurs relationnels permettent de comparer des valeurs.

Opérateur Description Exemple Résultat

== Egal à 5==5 TRUE
!= Différent de 5 != 3 TRUE
> Supérieur à 5>3 TRUE
< Inférieur à 5<3 FALSE
>= Supérieur ou égale à 5 >= 5 TRUE
<= Inférieur ou égale à 5 <= 3 FALSE
Exemple :

a <- 10
b <- 7
print(a > b) # Résultat : TRUE
print(a == b) # Résultat : FALSE
2. Structures conditionnelles

Les structures conditionnelles permettent d'exécuter du code en fonction de certaines conditions.

Les instructions conditionnelles "if-else", "if - else if – else" & "ifelse"

La structure de contrôle "if-else" permet de tester une condition et d'exécuter différents blocs de
code en fonction du résultat du test.

Syntaxe : Syntaxe : Syntaxe :

if(condition) { if(condition1) { ifelse(condition, valeur_si_vrai,
Instructions Instructions valeur_si_faux)
} else { } else if(condition2) {
Instructions Instructions
} }else {
Instructions
}
Exemples :
# Cas 1
note <- 15
if (note > =10) {
print("Validé")
} else {
print("Rattrapage")
}
Dans ca cas, si la valeur de la variable "note" est supérieure ou égale à 10, le premier bloc de code est
exécuté, sinon le deuxième bloc de code est exécuté.
# Cas 2 :
if (note >= 10) {
print("Validé")
} else if (note < 5) {
print("Non validé")
} else
print ("Rattrapage")
Cas de ifelse : Une manière concise pour gérer des conditions sur des vecteurs. Elle applique
une condition à chaque élément d’un vecteur de manière vectorisée et renvoie un vecteur.

age <- c(18, 20, 17, 21, 17.5, 19)

categorie <- ifelse(age >= 18, "Adulte", "Mineur")
print(categorie)
# Résultat : [1] "Adulte" "Adulte" "Mineur" "Adulte" "Mineur" "Adulte"

Exercice : Analyse des taux d'intérêt bancaires

Vous travaillez pour une institution financière qui souhaite analyser les taux d'intérêt proposés
par différentes banques.
Votre mission est de créer un programme en R qui classifie les offres de taux d'intérêt en
fonction de seuils et propose des recommandations aux clients.
Données : les taux sont : 1.8, 2.5, 4.7, 5.2, 1.5, 3.8, 6.0
Travail à faire :
Classifier les taux en trois catégories avec la recommandation appropriée :
• Faible si le taux est inférieur à 2%.
• Modéré si le taux est entre 2% et 5%.
• Élevé si le taux est supérieur à 5%.
Les recommandations pour chaque catégorie :
• Faible : "Investissement recommandé."
• Modéré : "Investissement à considérer."
• Élevé : "Évitez cet investissement.«
Utiliser différentes structures conditionnelles (if else if else, ifelse) pour automatiser cette
analyse pour le cas d’un seul taux = 4.7 et pour le cas d’un ensemble de taux.
Solution :
# Cas 1 : Analyser un seul taux avec if else if else
taux_unique <- 4.7
if (taux_unique < 2) {
print("Faible : Investissement recommandé.")
} else if (taux_unique <= 5) {
print("Modéré : Investissement à considérer.")
} else {
print("Élevé : Évitez cet investissement.")
}
# Cas 2 : Analyser tous les taux avec ifelse
taux <- c(1.8, 2.5, 4.7, 5.2, 1.5, 3.8, 6.0)
classification <- ifelse(taux < 2,
"Faible : Investissement recommandé.",
ifelse(taux <= 5,
"Modéré : Investissement à considérer.",
"Élevé : Évitez cet investissement."))

# Afficher les résultats

print(classification)
3. Fonctions any() et all()
a. Fonction any()

La fonction any() vérifie si au moins un élément d’un vecteur satisfait une condition logique :

any(condition_logique)

Retourne :
TRUE : Si au moins une condition est satisfaite et FALSE si aucune condition n'est satisfaite.

Exemple : Vérifier la présence d’une note inférieure à 10

notes <- c(13, 17, 10, 9, 18)

resultat <- any(notes < 10)
print(resultat)
# Résultat : TRUE
b. Fonction all()

La fonction all() vérifie si tous les éléments d’un vecteur satisfont une condition logique:

all(condition_logique)

Retourne :
TRUE : Si toutes les conditions sont satisfaites et FALSE si au moins une condition n'est satisfaite.

Exemple : Vérifier si toutes les notes sont supérieures à 10

notes <- c(13, 17, 10, 9, 18)

resultat <- all(notes < 10)
print(resultat)
# Résultat : FALSE
Exemple : Les notes sont valides s’ils sont entre 0 et 20.
Vérifier si toutes les notes sont dans cette plage et si au moins une note est supérieure à 15 (excellence).

notes <- c(18, 14, 19, 11, 8)

# Vérifications
valide <- all(notes >= 0 & notes <= 20) # Toutes les notes entre 0 et 20
excellence <- any(notes > 15) # Au moins une note > 15
# Résultat
if (valide && excellence) {
print("Les notes sont valides et au moins une est excellente.")
} else if (!valide) {
print("Erreur : certaines notes ne sont pas dans la plage autorisée.")
} else {
print("Les notes sont valides, mais aucune note excellente n'est détectée.")
}
Exercice d'application : Analyse d'investissements en R
Un investisseur analyse un portefeuille d’actions composé de 10 entreprises. Les données suivantes sont
disponibles pour chaque entreprise :
1. Nom de l’entreprise (vecteur de caractères).
2. Secteur d'activité (vecteur de facteurs : "Technologie", "Santé", "Finance").
3. Prix actuel de l’action (vecteur numérique).
4. Variation du prix de l’action en % par rapport à l’année précédente (vecteur numérique).
5. Dividendes payés par action cette année (vecteur numérique).
L’investisseur souhaite effectuer des calculs et des analyses pour prendre des décisions.
Entreprise Secteur Prix actuel (en €) Variation (%) Dividendes (€)
AlphaTech Technologie 120 15 2.5
BetaPharma Santé 80 -5 1.8
GammaFinance Finance 60 3 1.2
DeltaTech Technologie 150 20 3.0
EpsilonHealth Santé 50 -10 1.0
ZetaBank Finance 100 8 2.0
EtaTech Technologie 200 25 4.5
ThetaHealth Santé 70 -2 1.5
IotaInvest Finance 90 6 2.3
KappaTech Technologie 180 18 4.0
TAF :
1. Créez des vecteurs Entreprise, Secteur, Prix, Variation et Dividendes pour enregistrer ces données.
2. Transformez le vecteur Secteur en un facteur.
3. Analyse des données
a. Identifiez les entreprises avec une variation de prix positive à l’aide d’une structure de contrôle.
b. Filtrez les entreprises dont le secteur est "Technologie" et le prix de l’action est supérieur à 150 €.
c. Calculez le rendement total de chaque action (dividendes + variation en pourcentage appliquée au
prix initial). Associer le résultat aux entreprises.
4. Décisions financières
a. Affichez un message indiquant si l’investisseur doit vendre, acheter, ou conserver chaque action, selon
les règles suivantes :
•"Vendre" si la variation est négative.
•"Conserver" si la variation est entre 0 % et 10 %.
•"Acheter" si la variation est supérieure à 10 %.
b. Vérifier si toutes les entreprises ont des variations positives et si au moins une est en perte
Solution :
# Vecteurs de données
Entreprise <- c("AlphaTech", "BetaPharma", "GammaFinance", "DeltaTech", "EpsilonHealth",
"ZetaBank", "EtaTech", "ThetaHealth", "IotaInvest", "KappaTech")
Secteur <- factor(c("Technologie", "Santé", "Finance", "Technologie", "Santé",
"Finance", "Technologie", "Santé", "Finance", "Technologie"))
Prix <- c(120, 80, 60, 150, 50, 100, 200, 70, 90, 180)
Variation <- c(15, -5, 3, 20, -10, 8, 25, -2, 6, 18)
Dividendes <- c(2.5, 1.8, 1.2, 3.0, 1.0, 2.0, 4.5, 1.5, 2.3, 4.0)

# Identifier les variations positives

variation_positive <- ifelse(Variation > 0, "Oui", "Non")
names(variation_positive) <- Entreprise
print(variation_positive)

# Filtrer avec des conditions

tech_prix_elevé <- Entreprise[Secteur == "Technologie" & Prix > 150]
print(tech_prix_elevé)
# Calcul du rendement total
rendement <- Dividendes + (Prix + Variation)
names(rendement) <- Entreprise
print(rendement)

# Décision basée sur la variation

decision <- ifelse(Variation < 0, "Vendre", ifelse(Variation <= 10, "Conserver", "Acheter"))
names(decision) <- Entreprise
print(decision)

# Vérifier si toutes les entreprises ont une variation positive

if (all(Variation > 0)) {
print("Toutes les entreprises ont une variation positive.")
} else {
print("Certaines entreprises ont une variation négative.")
}
# Vérifier si au moins une entreprise a une variation négative
if (any(Variation < 0)) {
print("Au moins une entreprise a une variation négative.")
} else {
print("Aucune entreprise n'a de variation négative.")}
4. Structures répétitives
a. La boucle "for"
L’utilisation de la boucle "for" dans R est une manière courante d'itérer sur des éléments d'un
vecteur, d'une liste ou d'autres structures de données. Elle permet d'exécuter un bloc de code
plusieurs fois en fonction d'une variable de contrôle. Voici des exemples :

Syntaxe :
for (var in séquence)
Instructions
}

# Exemple 1
for (i in 1:5) {
print(i)
}
Dans cet exemple, la boucle "for" est exécutée 5 fois, et la variable "i" prend successivement les
valeurs de 1 à 5.
Exemple 2
for(i in seq(20, 0, -2)) {
print(i)
}
Exemple 3
outils <- list('R', 'Shiny', 'Python', 'Excel', 'Power BI', 'Tableau', 'SAS', 'STATA', 'SPSS')
for (i in outils) {
print(paste('Maria est Formatrice en', i))
}

Exemple 4 : Affichage de la table de multiplication par a

a <- 5
for (i in 0 : 10) {
print(paste(a, "x", i, "=", 5*i))
}
Exemple 5 : utilisation de for avec if pour afficher la somme des nombres pairs d’un vecteur

# Création d'un vecteur de nombres entiers

vecteur <- 1:20

# Initialisation de la variable somme à zéro

somme <- 0

# Boucle for pour calculer la somme des nombres pairs dans le vecteur
for (i in vecteur) {
if (i %% 2 == 0) {
somme <- somme + i }
}
# Affichage de la somme des nombres pairs
print(somme)
Exemple 6 : Utilisation de for avec la saisie au clavier

# Lecture des entiers au clavier

print("entrer les valeurs")
valeur <- scan(n=6) # Lire n valeurs saisies
s <- 0
for(i in 1:6) {
cat("valeur[",i,"] est : ", valeur[i],"\n")
s<- s+valeur[i]
}
paste("La somme est :", s)
# Lecture des réels au clavier
print('Entrer les valeurs :')
valeurs <- numeric(5) # Initialisation d'un vecteur de taille 5 pour stocker les valeurs saisies
# Autres manière de déclaration de vecteur : valeurs<- numeric() ou valeurs <- rep(NA,5)
# ou valeurs <- vector("numeric", length = 5)

for (i in 1:5) {
valeurs[i] <- as.numeric(readline(paste("Valeur ", i, " : ")))
}
for (i in 1:5) {
cat("valeurs[", i, "] est : ", valeurs[i], "\n")
}
sum(valeurs)
# D’une manière générale
print('Entrer les valeurs :')
valeurs <- numeric(5)
for (i in 1:5) {
valeurs[i] <- as.numeric(readline(prompt = paste("Valeur ", i, ": ")))
}
for (i in 1:length(valeurs)) {
cat("valeurs[", i, "] est : ", valeurs[i], "\n")
}
b. La boucle "while"
La boucle "while" permet d'exécuter un bloc de code tant qu'une condition est vraie.

Syntaxe :
Initialisation
while (condition d’arrêt) {
Instructions
Incrémentation
}
# Exemple 1 : Afficher les valeur de 1 à 5
i <- 1
while (i <= 5) {
print(i)
i <- i + 1
}
Dans cet exemple, la boucle "while" est exécutée tant que la variable "i" est inférieure ou égale à 5.
La variable "i" est incrémentée à chaque itération de la boucle.
Exemple 2 : Afficher les 10 premiers entiers naturels
i<- 0 # Initialiser un compteur
while (i < 10) {
print(i)
i<- i+1 }

Exemple 3 : Calcul du factoriel de 5

# Initialisation
n <- 5 # Nombre pour lequel on calcule le factoriel
factoriel <- 1 # Variable pour stocker le résultat
i <- 1 # Compteur
while (i <= n) {
factoriel <- factoriel * i # Calcul du produit
i <- i + 1 # Incrémentation du compteur
}

# Afficher le résultat
print(paste("Le factoriel de", n, "est :", factoriel))
c. Utilisation de "break"

Le mot clé break est utilisé pour interrompre prématurément l'exécution d'une boucle.
Lorsqu'une instruction break est rencontrée, la boucle en cours est immédiatement arrêtée, et le
programme continue à exécuter les instructions qui suivent la boucle.
N.B : break s'utilise uniquement dans les boucles for ou while.

Syntaxe :
for (variable in sequence) {
# Code
if (condition) {
break # Interrompt la boucle
}
}

Exemple 1 : On souhaite afficher les nombres de 1 à 5 avant de sortir de la boucle lorsqu’on arrive
à 6.
# Arrêter à la valeur 6
i=1 # Initialisation de i à 1
while (i <= 10) {
if (i == 6) {
break # break permet de sortir de la boucle
}
print (i)
i= i+1
}
Fonctionnement du code :
1. i commence à 1
2. La boucle while continue tant que i <= 10
3. Si i == 6, la commande break est exécutée. Cela stoppe immédiatement l'exécution de la boucle,
même si la condition de la boucle est encore vraie.
4. À chaque itération, i est augmenté de 1.
5. Les valeurs de i sont affichées pour chaque itération avant d'atteindre 6.
Exemple 2 : Supposons qu’on cherche une valeur spécifique dans un vecteur, et qu’on veule
arrêter la recherche dès que la valeur est trouvée.

# Recherche dans un vecteur

vecteur <- c(2, 4, 6, 8, 10, 12)

for (valeur in vecteur) {

if (valeur == 8) {
print(paste("Valeur trouvée :", valeur))
break # Interrompt la boucle
}
print(paste("Valeur analysée :", valeur))
}
Exemple 3 : Supposons qu’on suit une liste de transactions et qu’on souhaite arrêter l'analyse dès
qu'une transaction dépasse un certain montant (par exemple, 100 000 Dh).
# Liste des montants des transactions
transactions <- c(25000, 48000, 32000, 150000, 67000)

# Vérifier les transactions jusqu'à une limite

for (montant in transactions) {
if (montant > 100000) {
print(paste("Transaction trop élevée :", montant))
break # Interrompt la boucle
}
print(paste("Transaction analysée :", montant))
}

N.B : break est essentiel pour optimiser les boucles en arrêtant l'exécution dès qu'une condition
spécifique est remplie, évitant ainsi des calculs ou analyses inutiles.
5. Les fonctions
Permettent de regrouper un ensemble d'instructions qui peuvent être réutilisées dans le code. Une
fonction peut avoir un ou plusieurs paramètres d'entrée (arguments) et retourner une valeur.
Il existe de nombreuses fonctions intégrées dans R, mais il est également possible de définir ses
propres fonctions avec l'instruction "function".

Syntaxe :
nomFonction <- function(arguments) {
Instructions
return résultat #ou sans return
}
Exemple :
carre <- function(x){
return (x^2)
}
print("Entrer un nombre")
n <- scan(n=1)
carre(n)
Utilisation/appel de la fonction
a <- 5
b <- carre(a)
print(b) # Affiche 25

Dans cet exemple, la fonction "carre" prend en entrée un nombre "x", calcule le carré de
"x" et retourne la valeur du carré. La fonction est appelée avec l'argument "a", qui a la
valeur 5, et le résultat est stocké dans la variable "b". La fonction est définie avec
l'instruction "function", suivie du nom de la fonction et des paramètres d'entrée entre
parenthèses. Le corps de la fonction est constitué des instructions à exécuter et se termine
par l'instruction "return" qui renvoie la valeur de sortie.
Fonctions récursives
Une fonction récursive est une fonction qui s'appelle elle-même pour résoudre un
problème. Voici un exemple classique d'une fonction récursive en R : le calcul de la
factorielle d'un nombre.
factoriel <- function(n) {
if (n == 0) {
return(1)
} else {
return(n * factoriel(n - 1))
}
}
Exercice : Calculer la moyenne des notes saisies au clavier
Créer un programme en R pour calculer la moyenne des notes saisies par l'utilisateur. Le programme
demandera à l'utilisateur de saisir plusieurs notes et calculera la moyenne de ces notes.

Les étapes à suivre :

− Créer une fonction pour saisir les notes :
Cette fonction demandera à l'utilisateur de saisir les notes jusqu'à ce qu'il saisisse une valeur
négative pour indiquer la fin de la saisie.
− Créer une fonction pour calculer la moyenne des notes :
Cette fonction prendra un vecteur de notes en entrée et calculera la moyenne.
− Créer une fonction principale pour gérer le processus :
La fonction principale appellera les autres fonctions et affichera la moyenne des notes.
Solution

# Fonction pour saisir les notes

saisir_notes <- function() {
notes <- numeric()
note <- 0
while (note >= 0) {
note <- as.numeric(readline(prompt = "Entrez une note (entrez une valeur négative pour terminer) : "))
if (note >= 0) {
notes <- c(notes, note)
}
}
return(notes)
}
# Fonction pour calculer la moyenne des notes
calculer_moyenne <- function(notes) {
if (length(notes) == 0) {
return(NA) # Si aucune note n'a été saisie, retourner NA
}
return(mean(notes))
}
# Fonction principale
main <- function() {
cat("Bienvenue dans le programme de calcul de la moyenne des notes.\n")
notes <- saisir_notes()
moyenne <- calculer_moyenne(notes)
if (is.na(moyenne)) {
cat("Aucune note saisie.\n")
} else {
cat("La moyenne des notes est : ", moyenne, "\n")
}
}
# de la fonction principale
main()
un data frame ou tableau des données est une structure de données rectangulaire qui
contiennent des colonnes de même taille avec différents types de données. Chaque ligne
correspond à un individu et chaque colonne à une variable.
Pour créer un data frame, nous pouvons utiliser la fonction data.frame(argumets). Ces
arguments sont des vecteurs représentant les variables, chacun de même longueur.

Exemple 1 :

donnees <- data.frame(

prenom = c("Amine", "Ahmed", "Maria", "Sophia"), age = c(25, 35, 30, 28),
sexe = c("homme", "homme", "femme", "femme") )
print(donnees)
Exemple 2:
nom <- c("Amine", "Badr", "Salma", "Aya")
age <- c(25, 30, 35, 40)
ville <- c("Rabat", "Tanger", "Casablanca", "Mohammedia")
df <- data.frame(nom, age, ville)
print(df)

Pour créer un data frame, nous pouvons utiliser aussi l’une de ces fonctions :

read.table() qui permet d’importer un tableau de données provenant d’un fichier externe
(.csv, .txt, etc.)

as.data.frame() pour la conversion explicite d’un objet à deux dimensions (comme une
matrice)
La fonction data() est utilisée pour lister et charger les jeux de données disponibles dans
l’environnement R, y compris ceux inclus dans les packages de base et ceux chargés à partir
d'autres packages.

Exemples de data frame existant dans le package « datasets » : mtcars, iris

Fonctions de partitionnement : head(), tail()

head(iris) # renvoie les 6 premières lignes du data frame iris
head(iris,n) # renvoie les n premières lignes
tail(iris) # renvoie les 6 dernières lignes du data frame iris
head(iris,n) # renvoie les n dernières lignes

N.B : le principe d’extraction des données est le même que les matrices, sauf que pour
sélectionner une variable, on utilise le symbole $ (ex : dataframe$variable).
Sélection d'éléments
Voici quelques exemples de sélection d’éléments d’un data frame :
#Sélectionner la 1ère ligne du data frame
print(donnees[1, ])
#Sélectionner la 3ème colonne du tableau de données
print(donnees[ , 3]) # Récupère la colonne via son numéro
print(donnees$sexe) # Récupère la colonne via son nom
#Sélectionner la 2ème et la 4ème ligne du tableau de données
donnee[c(2,4), ]
#Sélectionner les lignes où l'âge <= 30, et «,» est utilisé pour indiquer que nous souhaitons
conserver toutes les colonnes (filtre).
donnees[donnees$age <=30, ]
#Sélectionner les lignes où sexe = "femme"
donnees[donnees$sexe =="femme", ]
Modification d'éléments
Voici quelques exemples de modification d'éléments d’un data frame :
# Modifier la 1ère ligne et la 3ème colonne de la matrice
df[1, 3] <- "Fès"
df
# Modification de la 2ème colonne avec de nouvelles valeurs
df[, 3] <- c(26, 31, 36, 41)
print(df)
# Modification de la deuxième ligne avec de nouvelles valeurs
df[2, ] <- c("Hicham", 33, "Tanger")
print(df)
# Trier le data frame par ordre croissant de l’age
df_trié <- df[order(df$age, decreasing = FALSE),]
df_trié
Modifier une donnée avec which

# La position des personnes âgées de plus de 30 ans

which(df$age > 30)

# La position des plus âgés

which.max(df$age)

# La position des personnes ayant l'âge minimal

which.min(df$age)

# Le plus grand âge

df$age[which.max(df$age)]

# Changer les valeurs de la colonne âge.

df$age[df$age <= 30] <- 0 ; df$age[df$age > 30] <- 1

Ajout d'éléments

Voici quelques exemples d'ajout d'éléments :

# Ajouter une nouvelle colonne au data frame
taille <- c(1.72, 1.75,1.70, 1.63)
df <- cbind(df, taille)
# Ajouter une nouvelle ligne au data frame
observ <- c("Rania", 24, "Rabat", 1.67)
df <- rbind(df, observ)
print(df)
donnees <- rbind(donnees, c("Mouad", 32, "homme"))
print(donnees)
Suppression d'éléments
Voici quelques exemples de suppression d’éléments d’un tableau de données :
# Supprimer la ligne numéro i
df <- df[-i, ]
# Supprimer la 2ème ligne et la 3ème colonne du data frame
df <- df[-2,-3]
print(df)
# Supprimer la colonne numéro j
df <- df[ ,-j]
# Supprimer une colonne (2ème manière)
df <- df[, -which(names(df) == "age")]
print(df)
# Supprimer une colonne par son nom (3ème manière)
df$ville <- NULL
print(df)
Quelques fonctions utilisées pour les data frame

str(df) : affiche une vue d'ensemble structurée des données contenues dans un data frame
(structure des variables, type de données, nombre d'observations,…).
dim(df) : renvoie les dimensions d'un data frame
View(df) : ouvrir une interface de visualisation des données sous forme de tableau dans
une fenêtre distincte
head(df,n) : renvoie les n premières lignes d'un data frame
tail(df, n) : renvoie les n dernières lignes d'un data frame
summary() : renvoie un résumé statistique d'un data frame
row.names : permet de nommer les lignes d’un data frame (ou matrice)
(row.names(donnees) <- c("Lig1","Lig2","Lig3","Lig4"))
Pour sélectionner des lignes au hasard dans un data frame

# Créer un vecteur d'indices représentant les lignes du data frame

indices_lignes <- 1: nrow(dataframe)

# Sélectionner n indices au hasard

indices_aleatoires <- sample(indices_lignes, n)

# Extraire les lignes correspondantes du data frame

lignes_aleatoires <- dataframe[indices_aleatoires, ]
Exercice : Itérer sur un data frame
# Créer un data frame
df <- data.frame(
nom = c("Amine", "Hanane", "Salma", "Ahmed"),
age = c(25, 30, 28, 35))
# Initialiser un compteur
i <- 1
# Utiliser une boucle while pour itérer sur les lignes du data frame
while (i <= nrow(df)) {
print(df[i, ])
i <- i + 1
}
Fiche de TP2 :
Exercice 1 : Etude sur l'indice de masse corporelle
Un échantillon de 10 dossiers d'enfants a été collecté lors de visites médicales dans des écoles préscolaires. Ces
enfants, âgés de 3 à 4 ans, ont fourni les données suivantes :
•Prénom : Le prénom de l’enfant.
•Sexe : F (fille) ou G (garçon).
•ZEP : Indique si l'école est située en zone d'éducation prioritaire : O (oui) ou N (non).
•Âge : En années (An) et en mois (Mois).
•Poids : En kilogrammes, arrondi à 100 g près.
•Taille : En centimètres, arrondie à 0,5 cm près

Nada Silia Ali Lina Mehdi Jad Adam Zaid Karim Saad
Sexe F F G F G G G G G G
ZEP O O O O N O N O O O
Poids 16.0 14.0 13.5 15.4 16.5 16.0 17.0 14.8 17.0 16.7

Âge (An) 3 3 3 4 3 4 3 3 4 3

Âge (Mois) 5 10 5 0 8 0 11 9 1 3

Taille 100.0 97.0 95.5 101.0 100.0 98.5 103.0 98.0 101.5 100.0
Travail a faire :
1. Choisissez les fonctions R appropriées pour enregistrer chaque type de données (Prénom, Sexe,
ZEP, Poids, etc.) dans des vecteurs nommés respectivement Individus, Sexe, ZEP, Poids, Taille,
An et Mois.

2. Calculez la moyenne des variables pour lesquelles cela est possible.

3. Calculer l'indice de masse corporelle (IMC) en utilisant la formule :
IMC = Poids (en kg)/(Taille (en m))²
4. Rassemblez toutes ces informations dans une structure R adaptée.
5. Consultez l’aide en ligne de R pour obtenir des informations sur la fonction
6. Tracez un graphique montrant le poids en fonction de la taille, avec :
▪ Un titre descriptif ;
▪ Des étiquettes pour les axes.
Solution :
# Enregistrer les données dans des vecteurs
Individus <- c("Nada", "Silia", "Ali", "Lina", "Mehdi", "Jad", "Adam", "Zaid", "Karim", "Saad")
Sexe <- c("F", "F", "G", "F", "G", "G", "G", "G", "G", "G")
ZEP <- c("O", "O", "O", "O", "N", "O", "N", "O", "O", "O")
Poids <- c(16, 14, 13.5, 15.4, 16.5, 16, 17, 14.8, 17, 16.7)
An <- c(3, 3, 3, 4, 3, 4, 3, 3, 4, 3)
Mois <- c(5, 10, 5, 0, 8, 0, 11, 9, 1, 3)
Taille <- c(100.0, 97.0, 95.5, 101.0, 100.0, 98.5, 103.0, 98.0, 101.5, 100.0)

# Calcul des moyennes

mean_poids <- mean(Poids)
mean_taille <- mean(Taille)
# Afficher les résultats
cat("Moyenne du poids :", mean_poids, "kg\n")
cat("Moyenne de la taille :", mean_taille, "cm\n")

# Calculer l'IMC
IMC <- Poids / (Taille / 100)^2
IMC
# Créer un data frame
data <- data.frame(Individus, Sexe, ZEP, Poids, Taille, An, Mois, IMC)

# Afficher le data frame

print(data)

help(plot) # ou ?plot

# Tracer le nuage de points

plot(Taille, Poids,
main = "Nuage de points : Poids en fonction de la Taille",
xlab = "Taille (cm)",
ylab = "Poids (kg)",
pch = 19, col = "blue")
Exercice 2 :
1. Créez un data frame "products" avec les informations suivantes :

Nom Catégorie Prix Stock Couleur

Laptop Ordinateur 12000 49 Noir
Smartphone Téléphone 10500 80 Blanc
Tablet Tablette 4550 50 Gris
Smartwatch Accessoire 1999 120 Blanc
Camera Caméra 3500 30 Noir
Headphone
Accessoire 1500 100 Noir
s
Mouse Accessoire 450 150 Noir
Printer Imprimante 2000 40 Blanc
2. Ajoutez une nouvelle colonne "Etat" au data frame "products" pour afficher l’état du stock :

"suffisant" si le stock est supérieur à 50 et "insuffisant" sinon.

3. Sélectionnez les accessoires de couleur blanche.

4. Triez le data frame "products" par ordre croissant du stock.

5. Afficher le produit ayant le prix le plus bas.

6. Créez un nouveau data frame "special_product" qui ne contient que les lignes pour

lesquelles la couleur est « Gris » ou « Noir » et le prix ne dépasse pas 5000.

7. Afficher le nombre de produits du data frame special_product ayant un état de stock

insuffisant.
Exercice 3 : Analyse de prêt bancaire
Une banque offre des prêts à ses clients, mais le taux d'intérêt qu'elle applique varie en fonction du
montant du prêt et de la durée du remboursement.
On vous demande de créer un programme pour vérifier si un client peut obtenir un prêt en
fonction de ces critères et calculer les intérêts payés sur le prêt.
Données à utiliser :
•Le montant du prêt (en euros).
•La durée du remboursement (en années).
•Le taux d'intérêt appliqué, qui est calculé en fonction du montant du prêt et de la durée :
• Si le montant du prêt est inférieur à 10 000€, le taux est de 5%.
• Si le montant du prêt est compris entre 10 000€ et 50 000€, le taux est de 3%.
• Si le montant du prêt est supérieur à 50 000€, le taux est de 2.5%.
Jeu de données :

Client Montant_prêt (€) Durée_remboursement (ans)

Imane 45 000 20
Farid 12 000 7
Sara 60 000 15
Lina 8 000 5
Badr 25 000 10

T.A.F. :
1. Utiliser les données fournies pour implémenter un programme en R.
2. Calculer le taux d'intérêt en fonction des critères donnés.
3. Déterminer si chaque client peut obtenir un prêt et calculez les intérêts payés sur la durée totale.