Serie N1 Langage R /Python
Voici un guide détaillé pour l'installation de R et de RStudio sur différents systèmes d'exploitation. Ce
processus vous permettra d'installer R, un environnement de programmation pour l'analyse statistique,
ainsi que RStudio, un IDE (environnement de développement intégré) populaire pour R.
1. Télécharger et Installer R
A. Télécharger R sur le site officiel
Allez sur le site de CRAN (Comprehensive R Archive Network), qui est la source officielle de R :
[Link]
B. Choisir votre Système d'Exploitation
1. Pour Windows :
Télécharger R pour Windows : Cliquez sur "Download R for Windows".
Cliquez ensuite sur "base" (pour télécharger la version de base de R).
Cliquez sur "Download R x.x.x for Windows" (la version la plus récente).
Exécuter l'installateur :
Une fois le fichier .exe téléchargé, double-cliquez dessus pour démarrer
l'installation.
Suivez les étapes d'installation avec les paramètres par défaut, sauf si vous avez
une préférence spécifique.
L'installateur vous proposera plusieurs options comme l'ajout de R au PATH, ce
qui est recommandé pour faciliter l'utilisation du terminal.
2. Pour Linux : L'installation de R sous Linux se fait via le gestionnaire de paquets de votre
distribution.
Sur Ubuntu/Debian : Ouvrez un terminal et exécutez les commandes suivantes :
sudo apt update
sudo apt install r-base
Sur Fedora : Utilisez cette commande :
sudo dnf install R
Autres distributions : Consultez la documentation officielle de R pour votre
distribution spécifique (RedHat, CentOS, etc.).
2. Vérifier l'Installation de R
Après avoir installé R, vous pouvez vérifier son bon fonctionnement en ouvrant une fenêtre de terminal
(ou la console R sur Windows ou macOS) et en tapant la commande suivante :
R
Cela ouvrira la console R, où vous pouvez exécuter des commandes comme :
print("Hello, World!")
Si tout fonctionne correctement, vous devriez voir la sortie Hello, World!.
3. Télécharger et Installer RStudio (facultatif mais fortement recommandé)
RStudio est un IDE puissant pour travailler avec R. Bien qu’il ne soit pas strictement nécessaire, il
simplifie l’écriture et l’exécution de votre code R.
A. Télécharger RStudio
1. Allez sur le site officiel de RStudio :
[Link]
2. Choisissez la version correspondant à votre système d'exploitation (Windows, macOS ou
Linux).
B. Installer RStudio
Sur Windows :
Après avoir téléchargé le fichier .exe, double-cliquez dessus pour démarrer
l'installation.
Suivez les instructions de l'assistant d'installation (paramètres par défaut recommandés).
Sur Linux :
Vous pouvez télécharger le fichier .deb ou .rpm (selon votre distribution) et l'installer
en utilisant le gestionnaire de paquets. Par exemple, pour Ubuntu :
sudo apt install ./[Link]
4. Vérification de l'installation de RStudio
Lancer RStudio : Une fois l’installation terminée, vous pouvez ouvrir RStudio en cliquant sur
son icône dans le menu de démarrage (Windows) ou le dossier "Applications" (macOS). Sous
Linux, vous pouvez le lancer depuis le terminal ou le menu des applications.
Vérification du fonctionnement : Une fois RStudio ouvert, vous verrez un éditeur de texte
(pour écrire du code), un terminal intégré, et un environnement graphique pour visualiser des
objets R. Tapez une simple commande dans la console, par exemple :
print("Hello from RStudio!")
Si vous voyez le message "Hello from RStudio!" dans la console, cela signifie que tout fonctionne
correctement.
5. Mettre à jour R (si nécessaire)
Il est recommandé de garder votre installation R à jour. Pour mettre à jour R sur votre machine :
Windows : Téléchargez la dernière version de R depuis CRAN et installez-la par-dessus votre
ancienne version.
Linux : Utilisez le gestionnaire de paquets pour mettre à jour R avec les commandes
appropriées.
6. Installer des packages R supplémentaires
Une fois que R est installé, vous pouvez également installer des packages (bibliothèques)
supplémentaires pour étendre ses fonctionnalités. Pour cela, utilisez la fonction
[Link]() dans la console de RStudio.
Par exemple, pour installer le package ggplot2 (pour la visualisation de données) :
[Link]("ggplot2")
Une fois installé, vous pouvez charger ce package avec :
library(ggplot2)
7. Conseils supplémentaires
Utilisation des R Markdown : RStudio permet d’utiliser R Markdown, une excellente
fonctionnalité pour combiner le texte et le code R dans des rapports interactifs.
R pour les applications de data science : R est très populaire pour les analyses statistiques, la
modélisation, et la visualisation des données. Apprenez à utiliser les packages populaires
comme dplyr, tidyr, et shiny.
Pour installer Python sur votre système, voici les étapes à suivre selon votre système d'exploitation.
1. Installation sur Windows
1. Télécharger Python:
Allez sur le site officiel de Python [Link].
Allez dans la section Downloads et téléchargez la dernière version stable de Python
pour Windows.
Cliquez sur l'option correspondant à votre architecture (32 bits ou 64 bits).
2. Lancer l'installateur:
Une fois le fichier téléchargé, ouvrez-le pour lancer l'installation.
Important : Cochez la case "Add Python to PATH" avant de cliquer sur "Install
Now". Cela vous permettra de lancer Python depuis n'importe quel répertoire de votre
terminal.
3. Vérifier l'installation:
Ouvrez l'invite de commande (CMD) ou PowerShell et tapez :
python --version
Vous devriez voir la version de Python installée, par exemple Python 3.x.x.
2. Installation sur Linux (Ubuntu/Debian)
1. Mettre à jour les paquets :
Ouvrez un terminal et mettez à jour votre liste de paquets avec la commande :
sudo apt update
Installer Python :
Pour installer Python 3, tapez la commande suivante :
sudo apt install python3
Vérifier l'installation :
Vérifiez la version installée avec :
python3 --version
Installer pip (le gestionnaire de paquets) :
Si vous souhaitez installer des bibliothèques Python, vous devrez installer pip. Vous pouvez
l'installer avec :
sudo apt install python3-pip
Vérification de pip :
Vérifiez que pip est installé correctement en tapant :
pip3 --version
4. Installation de Python via Anaconda (optionnel)
Si vous souhaitez utiliser Python pour la science des données, l'analyse de données, ou l'intelligence
artificielle, Anaconda est une distribution de Python qui inclut des bibliothèques populaires comme
NumPy, Pandas, Matplotlib, etc.
1. Télécharger Anaconda :
Allez sur le site officiel Anaconda et téléchargez la version d'Anaconda qui correspond à
votre système d'exploitation.
2. Lancer l'installation :
Ouvrez le fichier téléchargé et suivez les instructions d'installation.
3. Vérification :
Une fois Anaconda installé, vous pouvez vérifier en ouvrant un terminal et en tapant :
conda --version
Vérification finale
Après l'installation, vous pouvez vérifier si Python et pip (le gestionnaire de paquets) sont correctement
installés en ouvrant un terminal ou une invite de commande et en tapant :
Pour Python :
python --version
# ou
python3 --version
Pour pip :
pip --version
# ou
pip3 --version
Exercice 1
- "Initialiser un tableau de 1000 valeurs réelles de manière aléatoire, les valeurs devant être
comprises entre 1 et 1000."
- Trier le tableau dans un ordre croissant
- Trier le tableau dans un ordre decroissant
Voici un exemple de code en R pour initialiser un tableau de 1000 valeurs réelles aléatoires comprises
entre 1 et 1000 :
# Générer un tableau de 1000 valeurs aléatoires entre 1 et 1000
tableau <- runif(1000, min = 1, max = 1000)
# Afficher les premières valeurs pour vérifier
head(tableau)
Explication :
runif(1000, min = 1, max = 1000) : Cette fonction génère 1000 nombres réels
aléatoires suivant une distribution uniforme, compris entre 1 et 1000.
head(tableau) permet d'afficher les premières valeurs du tableau pour vérifier que
l'initialisation a bien été effectuée.
Si vous souhaitez des entiers plutôt que des réels, vous pouvez utiliser sample() pour tirer des
nombres entiers aléatoires dans cet intervalle :
# Générer un tableau de 1000 valeurs entières aléatoires entre 1 et 1000
tableau_entiers <- sample(1:1000, 1000, replace = TRUE)
# Afficher les premières valeurs pour vérifier
head(tableau_entiers)
Ce code générera des entiers aléatoires entre 1 et 1000, avec ou sans répétition, selon la valeur de
replace.
Pour trier un tableau dans un ordre croissant en R, vous pouvez utiliser la fonction sort(). Voici
comment vous pouvez trier le tableau généré précédemment dans un ordre croissant :
Si vous avez utilisé runif() pour générer des réels :
# Générer un tableau de 1000 valeurs réelles aléatoires entre 1 et 1000
tableau <- runif(1000, min = 1, max = 1000)
# Trier le tableau dans un ordre croissant
tableau_trie <- sort(tableau)
# Afficher les premières valeurs triées pour vérifier
head(tableau_trie)
Si vous avez utilisé sample() pour générer des entiers :
# Générer un tableau de 1000 valeurs entières aléatoires entre 1 et 1000
tableau_entiers <- sample(1:1000, 1000, replace = TRUE)
# Trier le tableau dans un ordre croissant
tableau_entiers_trie <- sort(tableau_entiers)
# Afficher les premières valeurs triées pour vérifier
head(tableau_entiers_trie)
Explication :
sort(tableau) : Cette fonction trie les éléments du tableau tableau dans un ordre
croissant.
head(tableau_trie) ou head(tableau_entiers_trie) permet d'afficher les
premières valeurs triées pour vérifier le résultat.
Cela permet de trier efficacement votre tableau d'éléments aléatoires.
Pour trier un tableau dans un ordre décroissant en R, vous pouvez utiliser la fonction sort() en
spécifiant l'argument decreasing = TRUE. Voici comment procéder :
Si vous avez utilisé runif() pour générer des réels :
# Générer un tableau de 1000 valeurs réelles aléatoires entre 1 et 1000
tableau <- runif(1000, min = 1, max = 1000)
# Trier le tableau dans un ordre décroissant
tableau_trie_decroissant <- sort(tableau, decreasing = TRUE)
# Afficher les premières valeurs triées pour vérifier
head(tableau_trie_decroissant)
Si vous avez utilisé sample() pour générer des entiers :
# Générer un tableau de 1000 valeurs entières aléatoires entre 1 et 1000
tableau_entiers <- sample(1:1000, 1000, replace = TRUE)
# Trier le tableau dans un ordre décroissant
tableau_entiers_trie_decroissant <- sort(tableau_entiers, decreasing = TRUE)
# Afficher les premières valeurs triées pour vérifier
head(tableau_entiers_trie_decroissant)
Explication :
sort(tableau, decreasing = TRUE) : Cette fonction trie les éléments du tableau
tableau dans un ordre décroissant en utilisant l'argument decreasing = TRUE.
head(tableau_trie_decroissant) ou
head(tableau_entiers_trie_decroissant) permet d'afficher les premières valeurs
du tableau trié pour vérifier le résultat.
Voici un code Python pour répondre à ces trois demandes :
1. Initialiser un tableau de 1000 valeurs réelles aléatoires comprises entre 1 et 1000
2. Trier le tableau dans un ordre croissant
3. Trier le tableau dans un ordre décroissant
4.
import random
# 1. Initialisation du tableau de 1000 valeurs réelles entre 1 et 1000
tableau = [[Link](1, 1000) for _ in range(1000)]
# 2. Trier le tableau dans un ordre croissant
tableau_croissant = sorted(tableau)
# 3. Trier le tableau dans un ordre décroissant
tableau_decroissant = sorted(tableau, reverse=True)
# Affichage des premiers éléments pour vérifier
print("Premiers éléments du tableau trié croissant:", tableau_croissant[:10])
print("Premiers éléments du tableau trié décroissant:", tableau_decroissant[:10])
Explication :
[Link](1, 1000) : Génère un nombre réel (float) aléatoire compris entre 1 et
1000.
sorted(tableau) : Trie le tableau dans un ordre croissant (par défaut).
sorted(tableau, reverse=True) : Trie le tableau dans un ordre décroissant.
Le code génère d'abord un tableau de 1000 valeurs réelles aléatoires, puis effectue les tris demandés.
Enfin, il affiche les 10 premiers éléments des tableaux triés pour une vérification rapide.
Exercice 2:
Créer un DataFrame de 100 lignes et 3 colonnes. Les noms des colonnes sont : Note TD, TP et
Examen, respectivement. Remplir le DataFrame avec des valeurs aléatoires telles que :
Les valeurs de la colonne TD sont entre 0 et 20.
Les valeurs de la colonne TP sont entre 0 et 20.
Les valeurs de la colonne Examen sont entre 0 et 50 et suivent une distribution gaussienne
avec une moyenne de 40 et un écart-type de 10.
Ajouter ensuite une colonne au DataFrame avec le nom Notation. La colonne Notation aura comme
valeur :
A si la somme des valeurs TD, TP et Examen est supérieure ou égale à 80.
B si la somme des valeurs TD, TP et Examen est supérieure ou égale à 60 et strictement
inférieure à 80.
C si la somme des valeurs TD, TP et Examen est supérieure ou égale à 40 et strictement
inférieure à 60.
D si la somme des valeurs TD, TP et Examen est strictement inférieure à 40.
Voici un exemple de code Python utilisant pandas et numpy pour créer ce DataFrame et effectuer les
opérations demandées :
import pandas as pd
import numpy as np
# Création d'un DataFrame de 100 lignes et 3 colonnes avec des valeurs aléatoires
[Link](42) # Pour garantir la reproductibilité des résultats
# Génération des valeurs pour chaque colonne
TD = [Link](0, 20, 100) # Valeurs aléatoires entre 0 et 20 pour la
colonne TD
TP = [Link](0, 20, 100) # Valeurs aléatoires entre 0 et 20 pour la
colonne TP
Examen = [Link](40, 10, 100) # Valeurs suivant une distribution
gaussienne avec moyenne 40 et écart-type 10
# On s'assure que les valeurs d'Examen sont dans l'intervalle [0, 50]
Examen = [Link](Examen, 0, 50)
# Création du DataFrame
df = [Link]({
'Note TD': TD,
'Note TP': TP,
'Examen': Examen
})
# Calcul de la somme des notes TD, TP et Examen
df['Somme'] = df['Note TD'] + df['Note TP'] + df['Examen']
# Ajouter la colonne "Notation" selon les règles spécifiées
def assigner_note(somme):
if somme >= 80:
return 'A'
elif somme >= 60:
return 'B'
elif somme >= 40:
return 'C'
else:
return 'D'
df['Notation'] = df['Somme'].apply(assigner_note)
# Afficher les 5 premières lignes pour vérification
print([Link]())
Explication du code :
1. Création des valeurs aléatoires :
Pour les colonnes Note TD et Note TP, nous utilisons [Link](0,
20, 100) pour générer 100 valeurs comprises entre 0 et 20.
Pour la colonne Examen, nous utilisons [Link](40, 10, 100)
pour générer des valeurs suivant une distribution normale avec une moyenne de 40 et un
écart-type de 10. Ensuite, nous utilisons [Link]() pour limiter ces valeurs à
l'intervalle [0, 50] (comme précisé dans l'énoncé).
2. Création du DataFrame : Nous combinons les trois séries en un DataFrame avec
[Link]().
3. Calcul de la somme des notes : Nous calculons la somme des trois colonnes (Note TD, Note
TP et Examen) et la stockons dans une nouvelle colonne Somme.
4. Attribution des notes : Nous définissons une fonction assigner_note() qui attribue la
notation ('A', 'B', 'C', 'D') en fonction de la somme des notes. Cette fonction est appliquée à
chaque ligne du DataFrame à l'aide de .apply().
5. Affichage des résultats : Finalement, nous affichons les 5 premières lignes du DataFrame avec
[Link]().
Résultat attendu :
Le DataFrame aura la structure suivante, avec les colonnes Note TD, Note TP, Examen, Somme et
Notation :
Note TD Note TP Examen Somme Notation
13.78 17.16 40.22 71.16 B
16.74 18.81 48.68 84.23 A
15.47 6.13 38.93 60.53 B
3.78 12.95 43.17 59.90 B
2.32 19.98 37.81 60.11 B
Chaque ligne sera classée dans la catégorie appropriée (A, B, C ou D) en fonction de la somme des
valeurs des colonnes.
le code en R
Voici l'équivalent du code Python en R pour créer un DataFrame avec les valeurs aléatoires et appliquer
la notation selon les règles définies :
[Link](42) # Pour garantir la reproductibilité des résultats
# Génération des valeurs pour chaque colonne
Note_TD <- runif(100, min = 0, max = 20) # Valeurs aléatoires entre 0 et 20 pour
la colonne Note TD
Note_TP <- runif(100, min = 0, max = 20) # Valeurs aléatoires entre 0 et 20 pour
la colonne Note TP
Examen <- rnorm(100, mean = 40, sd = 10) # Valeurs suivant une distribution
gaussienne (moyenne 40, écart-type 10)
# On s'assure que les valeurs d'Examen sont dans l'intervalle [0, 50]
Examen <- pmin(pmax(Examen, 0), 50)
# Création du DataFrame
df <- [Link](
Note_TD = Note_TD,
Note_TP = Note_TP,
Examen = Examen
)
# Calcul de la somme des notes TD, TP et Examen
df$Somme <- df$Note_TD + df$Note_TP + df$Examen
# Fonction pour attribuer la notation
assigner_note <- function(somme) {
if (somme >= 80) {
return("A")
} else if (somme >= 60) {
return("B")
} else if (somme >= 40) {
return("C")
} else {
return("D")
}
}
# Appliquer la fonction de notation à chaque ligne du DataFrame
df$Notation <- sapply(df$Somme, assigner_note)
# Affichage des 5 premières lignes pour vérification
head(df)
Explication du code :
1. Génération des valeurs aléatoires :
runif(100, min = 0, max = 20) génère 100 valeurs aléatoires uniformément
distribuées entre 0 et 20 pour les colonnes Note_TD et Note_TP.
rnorm(100, mean = 40, sd = 10) génère 100 valeurs suivant une distribution
normale avec une moyenne de 40 et un écart-type de 10 pour la colonne Examen.
Ensuite, nous utilisons pmin(pmax(Examen, 0), 50) pour limiter les valeurs de
Examen dans l'intervalle [0, 50].
2. Création du DataFrame :
Nous créons un DataFrame df en combinant les trois vecteurs (Note_TD, Note_TP,
Examen).
3. Calcul de la somme des notes :
Nous calculons la somme des trois colonnes (Note_TD, Note_TP, Examen) et l'ajoutons
à une nouvelle colonne Somme.
4. Attribution des notes :
Nous définissons une fonction assigner_note() qui attribue la notation ('A', 'B',
'C', 'D') en fonction de la somme des notes.
Nous appliquons cette fonction à chaque valeur de la colonne Somme avec sapply().
5. Affichage du DataFrame :
Enfin, nous affichons les 5 premières lignes du DataFrame avec head(df) pour
vérifier les résultats.
Résultat attendu :
Note_TD Note_TP Examen Somme Notation
13.812 5.217 45.379 64.408 B
10.173 0.889 40.352 51.414 C
5.358 13.574 50.000 68.932 B
6.287 7.124 43.775 57.186 B
12.412 10.708 38.634 61.754 B
Le DataFrame contient des colonnes Note_TD, Note_TP, Examen, Somme, et Notation avec la
notation attribuée selon les règles données.
