Exploration des données avec R : Outils et Méthodes pour les archéologues
Intra MOM 2026: Bouzid Sofiane
2026-04-27 & 2026-04-28
Programme durant les deux jours
Introduction
Présentation de R et RSudio
Les notions de base sous R
Importation des données
Traitement des données
- Manipulation des tableaux avec dplyr : filter(), select(), mutate(), group_by(), summarise()
- Nettoyage des données : gestion des valeurs manquantes, recodage, renommage
- Fusion et jointure de jeux de données.
Visualisation des données
Prise en main
R et RStudio
Le langage R a été créé dans les années 1990 par Ross Ihaka et Robert Gentleman, en s’inspirant du langage S développé chez Bell Labs.Il dispose aujourd’hui d’une vaste communauté, qui participent à son évolution avec des packages disponibles sur le CRAN (Comprehensive R Archive Network). Aujourd’hui, R est largement utilisé en statistiques et data science, malgré la concurrence de Python. Actuellement, le dépôt de packages CRAN propose 23 646 packages (source : CRAN, 2026).
R offre :
De nombreuses fonctions statistiques et graphiques;
Gérer et analyser des données quantitatives (mesures, comptages, etc.);
Créer des graphiques de qualité professionnelle;
Documenter et reproduire les analyses de manière transparente.
RStudio est un Environnement de développement intégré (IDE) qui facilite l’utilisation de R et le développement de scripts. C’est un logiciel libre et gratuit.
Stocker un résultat
Pour stocker le résultat d’une opération, il faut créer un
objet à l’aide de l’opérateur d’assignation
<-. Cette “flèche” stocke ce qu’il y a à sa droite dans
un objet qui est à sa gauche.
Par exemple la ligne de commande ci-dessous prend le résultat
de100+2 et le met dans l’objet mon_objet.
Il suffit de taper le nom que j’ai attribué à mon objet pour en afficher le contenu. Il est possible de réutiliser cet objet dans d’autres opérations, il sera remplacé par sa valeur. On peut créer autant d’objets qu’on souhaite.
## [1] 10200## [1] 510Remarques !
Les noms d’objets peuvent contenir des lettres, des
chiffres, les symboles . et _. Les
noms d’objets ne peuvent pas commencer par un chiffre.
R fait la différence entre minuscules et
majuscules ce qui signifie que x et X seront deux objets
différents, tout comme mon_objet et MON_OBJET.
Il est conseillé d’éviter dans les noms d’objets les
majuscules (pour les risques d’erreur) et les caractères accentués (pour
des questions d’encodage).
Il est important de trouver un juste milieu entre clarté et concision dans le nommage des objets. Par exemple, on préférera un nom comme taille_jarre_S1 plutôt que taille_de_la_jarre_trouvée_dans_le_secteur_1 (trop long) ou tjs1 (trop peu explicite).
Quand on assigne une nouvelle valeur à un objet déjà existant, la valeur précédente est perdue. Les objets n’ont pas de mémoire.
## [1] "Lune"## [1] 3Opérateurs logiques
Les opérateurs logiques sont importants, notamment pour effectuer des comparaisons entre des valeurs ou pour formuler des conditions dans un traitement sur les données. En R, ces opérateurs permettent de tester des relations (par exemple, si une mesure est supérieure à une autre) ou de combiner plusieurs conditions logiques.
Voici les principaux opérateurs logiques que vous utiliserez en R :
| Opérateur | Description |
|---|---|
< |
inférieur à |
<= |
inférieur ou égal à |
> |
supérieur à |
>= |
supérieur ou égal à |
== |
égal à (exactement) |
!= |
différent de |
!x |
non x (négation) |
| x | y | x OU y (opérateur logique OU) |
| x & y | x ET y (opérateur logique ET) |
| isTRUE(x) | teste si x est TRUE (vrai) |
| *la barre verticale | ( appelée pipe en informatique) s’écrit sous Windows : Alt Gr +6 . macOs option⌥ + Maj ⇧ + L* |
Notez que R utilise le double signe égal == pour effectuer un test logique « est égal à ». Cela s’explique par le fait qu’un seul signe égal = peut être utilisé à la place de la flèche <-pour affecter une valeur à un objet.
Dans cet exemple, les dimensions de deux jarres ont été relevées et enregistrées dans deux objets distincts. Chaque opérateur est ensuite employé pour comparer ces données ou vérifier certaines conditions logiques. Voici la fonction de chaque instruction :
# deux jarres mesurées sur un site de fouilles
taille_jarre1 <- 45
taille_jarre2 <- 50
# < : inférieur à
taille_jarre1 < taille_jarre2 ## [1] TRUE## [1] TRUE## [1] FALSE## [1] TRUE## [1] TRUE## [1] TRUEExercice : Comparaison de tailles de jarres
Vous êtes en train d’analyser des mesures de jarres retrouvées sur un site archéologique. Créez des objets en R pour stocker les tailles (en cm) de trois jarres, puis utilisez des opérateurs logiques pour répondre aux questions suivantes.
- Créer les variables suivantes jarre1, jarre2 et jarre3 avec les valeurs suivantes : 34, 50, et 10.
- Effectuez les comparaisons :
- La jarre 1 est-elle plus petite que la jarre 2 ?
- La jarre 1 est-elle de la même taille que la jarre 3 ?
- La jarre 2 mesure-t-elle au moins 50 cm ?
- La jarre 1 et la jarre 3 ont-elles une taille supérieure à 40 cm ?
- Au moins une des trois jarres mesure-t-elle exactement 55 cm ?
- La jarre2 est-elle strictement >50 ?
Le vecteur
Imaginons que vous avez mesuré la hauteur (en cm) de 5 jarres retrouvées sur un site archéologique et que vous voulez mesurer la moyenne des 5 jarres. Une première manière de procéder serait de créer un objet par mesure, puis de faire manuellement le calcul de la moyenne :
h_jarre1 <- 42
h_jarre2 <- 51
h_jarre3 <- 48
h_jarre4 <- 50
h_jarre5 <- 45
# Calcul de la moyenne
moyenne <- (h_jarre1 + h_jarre2 + h_jarre3 + h_jarre4 + h_jarre5) / 5
moyenne## [1] 47.2Cette manière de procéder n’est pas pratique, surtout si l’on a de nombreuses mesures à traiter. Il est donc préférable de stocker l’ensemble des tailles dans un seul objet, appelé vecteur, en utilisant la syntaxe suivante :
On vient de créer un objet de type vecteur de 5 éléments : h_jarres. Un vecteur est un objet qui peut contenir plusieurs informations du même type, potentiellement en très grand nombre.
L’avantage d’un vecteur est que lorsqu’on lui applique une opération, celle-ci s’applique à toutes les valeurs qu’il contient. Ainsi, si on veut la taille en mètres plutôt qu’en centimètres, on peut faire :
## [1] 42 51 48 50 45## [1] 0.42 0.51 0.48 0.50 0.45Pour les mêmes jarres, nous avons également mesuré la largeur en centimètres et identifié le type de pâte utilisée. Cela montre qu’en plus de stocker des valeurs numériques, un vecteur en R peut aussi contenir des chaînes de caractères, comme les noms ou types de pâte.
l_jarres <- c(22, 25, 19, 23, 18)
type_pate <- c("sableuse", "argileuse", "sableuse", "argileuse", "calcaire")On peut alors effectuer des calculs utilisant nos deux vecteurs h_jarres et l_jarres. On peut par exemple calculer le ratio des jarres en divisant leur hauteur en cm par leur largeur en cm :
## [1] 1.909091 2.040000 2.526316 2.173913 2.500000# Hauteur vs Largeur
plot(l_jarres, h_jarres,
main="Hauteur en fonction de la largeur des jarres",
xlab="Largeur (cm)",
ylab="Hauteur (cm)",
pch=19, col="blue")
Types de vecteurs
Les vecteurs numériques (numeric) contiennent des nombres avec décimales, tandis que les vecteurs entiers (integer) stockent des nombres entiers. Les vecteurs de caractères (character) regroupent du texte, et les vecteurs logiques (logical) représentent des valeurs booléennes (TRUE ou FALSE).
En plus de ces types, les facteurs sont très importants pour représenter des variables qualitatives, notamment en archéologie (types de matériaux, catégories, etc.). Un facteur possède un ensemble fini de modalités appelées levels. Il peut aussi être ordonné, ce qui permet de définir un ordre logique entre les catégories, par exemple pour des périodes chronologiques.
# Les 4 grands types de vecteurs en R
# Numérique (double)
profondeur <- c(45.5, 120.0, 30.2)
class(profondeur) # "numeric"## [1] "numeric"## [1] "integer"## [1] "character"## [1] "logical"# Facteur ordonné (ex : période chronologique)
periode <- factor(c("Bronze", "Fer", "Néolithique", "Bronze"),
levels = c("Néolithique", "Bronze", "Fer"),
ordered = TRUE)
periode[1] < periode[3] # Bronze < Fer## [1] FALSEStocker les données dans un data.frame
Idéalement, chaque jeu de données à analyser doit être sous forme
d’un tableau où chaque ligne correspondant à une observation (individu)
et chaque colonne à une caractéristique (variable). Il est aisé de
stocker les vecteurs sous forme de tableau. Dans R on parle de
data.frame. 
jarres <- data.frame(hauteur = h_jarres,
largeur = l_jarres,
ratio = ratio_h_l,
Pate= type_pate
)
jarres## hauteur largeur ratio Pate
## 1 42 22 1.909091 sableuse
## 2 51 25 2.040000 argileuse
## 3 48 19 2.526316 sableuse
## 4 50 23 2.173913 argileuse
## 5 45 18 2.500000 calcaireExercice Pratique : Inventaire de fouilles avec données manquantes
Votre équipe effectue des fouilles sur un site gallo-romain. Vous devez informatiser le carnet de fouilles pour les cinq objets majeurs découverts aujourd’hui. Cependant, l’un des objets a été trouvé dans la terre de déblais : sa profondeur exacte d’origine est donc perdue.
Créez la table de données de ces cinq artefacts en gérant correctement l’information manquante.
Voici les notes de terrain :
- L’Amphore est en Terre cuite, a été trouvée à 120 cm de profondeur et pèse 4500 grammes.
- Le Silex est en Pierre, a été trouvé à 45 cm de profondeur et pèse 150 grammes.
- La Monnaie est en Bronze, a été trouvée à 80 cm de profondeur et pèse 12 grammes.
- L’écuelle de Poterie est en Céramique, a été trouvée à 150 cm de profondeur et pèse 850 grammes.
- La Fibule est en Fer et pèse 45 grammes. Ayant été trouvée dans les déblais, sa profondeur est inconnue.
Les Consignes :
- Créez vos 4 vecteurs (type_objet, materiau, profondeur_cm, poids_g).
- Attention : Pour la profondeur inconnue de la Fibule, utilisez le code spécifique R pour les données manquantes : NA (sans guillemets).
- Assemblez le data frame fouilles_df.
- Affichez le tableau.
La notion de Fonctions intégrées et Packages
Fonction
Les fonctions sont l’un des concepts fondamentaux du langage R. Elles servent à :
- Réaliser des calculs.
- Produire des résultats ou exécuter des actions.
Une fonction possède un nom et reçoit un ou plusieurs arguments placés entre parenthèses. Elle retourne ensuite un résultat.
Par exemple, pour connaître le nombre d’éléments contenus dans le
vecteur h_jarres que nous avons créé précédemment, on peut
utiliser la fonction length(). Cette fonction renvoie la
taille (le nombre d’éléments) du vecteur.
## [1] 5## [1] 47.2## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 42.0 45.0 48.0 47.2 50.0 51.0## [1] 47.2## [1] NA## [1] 48.5Packages
En R, un package (ou paquet) est une collection de fonctions regroupées pour être facilement partagées et utilisées. Un Package en R contient : Des fonctions; Des données; De la documentation.
Exemples de packages populaires : dplyr : pour la manipulation de données tidyr : pour la transformation de données ggplot2 : pour la visualisation de données caret : pour le machine learning
Il est possible d’utiliser l’interface de RStudio ou une ligne de
commande pour installer un package en utilisant la fonction.
install.packages("nom_du_package") Après l’installation
d’un package, celui-ci doit être chargé à l’aide de la fonction
library("nom_du_package") pour pouvoir être utilisé.
Regrouper ses commandes dans des scripts
lorsque R ou RStudio redémarre, tout ce qui a été effectué dans la console est perdu. Il est possible de regrouper ses commandes dans des scripts R pour la :
Mémorisation : Un script permet de garder une trace de toutes les commandes utilisées, au lieu de les taper une par une dans la console.
Réutilisation : Réutiliser le code plus tard, sans avoir à le réécrire.
Modification facile : Il est plus simple de corriger, adapter ou compléter un script que de retracer des commandes dans la console.
Reproductibilité : Un script vous permet à vous ou à d’autres personnes de reproduire exactement les mêmes résultats.
Organisation : On peut structurer le code par étapes (chargement des données, traitement, visualisation, etc.).
Pour créer et utiliser un script R, dans RStudio,
cliquez sur File > New File > R Script, un nouvel
onglet s’ouvre, c’est votre éditeur de script. Il permet :
- d’écrire des commandes;
- de sélectionner une ou plusieurs lignes, puis sur
Ctrl + Enter(ouCmd + Entersur Mac) pour exécuter les lignes.
Pour sauvegarder le script : File > Save ou Ctrl + S
puis donnez un nom à votre fichier, comme analyse.R
Bonnes pratiques :
- Utiliser des commentaires (#) pour expliquer ce que fait chaque section (ou les lignes).
- Organiser le script en blocs logiques : importation des données, nettoyage, analyse, visualisation, etc.
- Donner des noms clairs aux objets.
Exercice – Analyse de fragments de poterie
Dans cet exercice, vous allez apprendre à manipuler des données fictives en R, depuis la création de vecteurs jusqu’à la visualisation graphique. L’objectif est de vous familiariser avec les bases vues précédemment.
Vous devez :
Allez dans Fichier > Nouveau fichier > Script R.
Créez trois vecteurs représentant :
- les noms de 5 sites archéologiques Site1, Site2, Site3, Site4, Site5
- le nombre de fragments retrouvés sur chaque site est le suivant : 23, 17, 34, 28, 12
- la profondeur moyenne (en cm) de prélèvement par site : 120, 135, 110, 125, 140
Utilisez les fonctions mean() et max() pour calculer la moyenne et la profondeur maximale
Regroupez les données dans un tableau (data.frame)
Créez un graphique en barres représentant le nombre de fragments par site.
Sauvegardez le script : puis donnez un nom à votre fichier : Analyse_fragments_poterie.R
Importer des données
R n’est pas prévu pour la saisie de données, mais il
y a de nombreuses fonctions et packages permettant l’import de données
avec un grand nombre de formats. L’interface RStudio permet d’importer
des données (.text, .SPSS, . SAS, STATA). Pour charger un fichier JSON,
le package rjson et la fonction fromJSON pour analyser le
fichier JSON.
Le Projet
Il est préférable de travailler avec R en mode projet.
Un projet est un dossier que vous avez créé, et dans lequel vous regrouperez tous les fichiers en question. Utiliser des projets procure plusieurs avantages :
- RStudio lance automatiquement R dans le dossier du projet et facilite ainsi grandement l’accès aux fichiers de données à importer.
- Si vous déplacez votre dossier sur votre disque, le projet continuera à fonctionner.
- L’onglet Files de la zone en bas à droite de l’interface de RStudio vous permet de naviguer facilement dans les fichiers de votre projet.
- Vous pouvez très facilement passer d’un projet à l’autre si vous travaillez sur plusieurs jeux de données en parallèle.
Pour créer un projet, il faut aller dans le menu File puis sélectionner New project.
DartPoints Data
Nous allons travailler sur le jeu de données DartPoints. Ce jeu de données contient des mesures de cinq types de pointes de projectiles (pointes de sagaie) provenant de Fort Hood, situé dans le centre du Texas. Les échantillons ont été collectés lors de 10 projets de prospection pédestre réalisés dans les années 1980.Les objets ont été classés et mesurés par H. Blaine Ensor, selon le système développé par Futato (1983), tel que décrit dans : Carlson, S., et al. (1987), pages 51–70 et annexes 4 et 7.
Le tidyverse
Pour traiter cette donnée nous allons utilisé la boite à outils (packages) tidyverse, le terme tidyverse est une contraction de tidy (“bien rangé”) et de universe. Elles abordent un très grand nombre d’opérations courantes dans R (la liste n’est pas exhaustive) : - import/export de données - manipulation des tableaux de données - manipulation de variables - visualisation - et plus…
Un des objectifs de ces extensions est de fournir un écosystème de fonctions avec une syntaxe cohérente, qui fonctionnent bien ensemble.
tidyverse est également le nom d’une extension qu’on
peut installer de manière classique, soit via le bouton Install
de l’onglet Packages de RStudio, soit en utilisant la
commande :
Cette commande va en fait installer plusieurs extensions qui constituent le “coeur” du tidyverse, à savoir :
ggplot2(visualisation)dplyr(manipulation des données)tidyr(remise en forme des données)purrr(programmation)readr(importation de données)tibble(tableaux de données)forcats(variables qualitatives)stringr(chaînes de caractères)lubridate(manipulation de dates)
De la même manière, charger
l’extension avec :
Chargera l’ensemble des extensions précédentes. Il existe d’autres
extensions qui font partie du tidyverse mais qui doivent être
chargées explicitement, comme par exemple readxl (pour
l’importation de données depuis des fichiers Excel). La liste complète
se trouve sur le site
officiel du tidyverse.
Dans RStudio, créez un nouveau projet et sélectionnez comme dossier de travail le dossier que je vous ai transmis : Support_Formation_R_2025_Archeo
Importation des données
library(readr) # Pour read_delim() (lecture .txt ou .csv)
library(readxl) # Pour read_excel() (lecture .xlsx)
#XLSX
DartPoints_xlsx <- read_excel("DartPoints.xlsx")
#TXT TAB
Dartpoints_tab <- read_delim("Dartpoints_tab.txt",
delim = "\t", # Indique que le séparateur est une tabulation
escape_double = FALSE, # Pas besoin de gérer des guillemets doubles
trim_ws = TRUE) # Supprimer les espaces en début/fin de champ## Rows: 91 Columns: 17
## ── Column specification ────────────────────────────────────────────────────────
## Delimiter: "\t"
## chr (10): Name, Catalog, TARL, Quad, Blade.Sh, Base.Sh, Should.Sh, Should.Or...
## dbl (7): Length, Width, Thickness, B.Width, J.Width, H.Length, Weight
##
## ℹ Use `spec()` to retrieve the full column specification for this data.
## ℹ Specify the column types or set `show_col_types = FALSE` to quiet this message.#CSV
Dartpoints_sep_virgule <- read_delim("Dartpoints_sep_virgule.csv",
delim = ";", # Spécifie que le séparateur est un point-virgule
escape_double = FALSE,
trim_ws = TRUE)## Rows: 91 Columns: 17
## ── Column specification ────────────────────────────────────────────────────────
## Delimiter: ";"
## chr (10): Name, Catalog, TARL, Quad, Blade.Sh, Base.Sh, Should.Sh, Should.Or...
## num (7): Length, Width, Thickness, B.Width, J.Width, H.Length, Weight
##
## ℹ Use `spec()` to retrieve the full column specification for this data.
## ℹ Specify the column types or set `show_col_types = FALSE` to quiet this message.DartPoints<-DartPoints_xlsx
#head(DartPoints_xlsx)
#head(Dartpoints_tab)
#head(Dartpoints_sep_virgule)
str(Dartpoints_tab)## spc_tbl_ [91 × 17] (S3: spec_tbl_df/tbl_df/tbl/data.frame)
## $ Name : chr [1:91] "Darl" "Darl" "Darl" "Darl" ...
## $ Catalog : chr [1:91] "41-0322" "35-2946" "35-2921" "36-3487" ...
## $ TARL : chr [1:91] "41CV0536" "41CV0235" "41CV0132" "41CV0594" ...
## $ Quad : chr [1:91] "26/59" "21/63" "20/63" "10/54" ...
## $ Length : num [1:91] 42.8 40.5 37.5 40.3 30.6 41.8 40.3 48.5 47.7 33.6 ...
## $ Width : num [1:91] 15.8 17.4 16.3 16.1 17.1 16.8 20.7 18.7 17.5 15.8 ...
## $ Thickness: num [1:91] 5.8 5.8 6.1 6.3 4 4.1 5.9 6.9 7.2 5.1 ...
## $ B.Width : num [1:91] 11.3 NA 12.1 13.5 12.6 12.7 11.7 14.7 14.3 NA ...
## $ J.Width : num [1:91] 10.6 13.7 11.3 11.7 11.2 11.5 11.4 13.4 11.8 12.5 ...
## $ H.Length : num [1:91] 11.6 12.9 8.2 8.3 8.9 11 7.6 9.2 8.9 11.5 ...
## $ Weight : num [1:91] 3.6 4.5 3.6 4 2.3 3 3.9 6.2 5.1 2.8 ...
## $ Blade.Sh : chr [1:91] "S" "S" "S" "S" ...
## $ Base.Sh : chr [1:91] "I" "I" "I" "I" ...
## $ Should.Sh: chr [1:91] "S" "S" "S" "S" ...
## $ Should.Or: chr [1:91] "T" "T" "T" "T" ...
## $ Haft.Sh : chr [1:91] "S" "S" "S" "S" ...
## $ Haft.Or : chr [1:91] "E" "E" "E" "E" ...
## - attr(*, "spec")=
## .. cols(
## .. Name = col_character(),
## .. Catalog = col_character(),
## .. TARL = col_character(),
## .. Quad = col_character(),
## .. Length = col_double(),
## .. Width = col_double(),
## .. Thickness = col_double(),
## .. B.Width = col_double(),
## .. J.Width = col_double(),
## .. H.Length = col_double(),
## .. Weight = col_double(),
## .. Blade.Sh = col_character(),
## .. Base.Sh = col_character(),
## .. Should.Sh = col_character(),
## .. Should.Or = col_character(),
## .. Haft.Sh = col_character(),
## .. Haft.Or = col_character()
## .. )
## - attr(*, "problems")=<externalptr>Ce jeu de données est un data frame contenant 91 observations (lignes), réparties sur les 17 variables suivantes :
| Variable | Description |
|---|---|
Name |
Type de pointe de projectile : Darl, Ensor, Pedernales, Travis, Wells |
Catalog |
Numéro de catalogue Fort Hood |
TARL |
Numéro de site attribué par le Texas Archeological Research Laboratory |
Quad |
Secteur (quadrant) de Fort Hood |
Length |
Longueur maximale (en mm) |
Width |
Largeur maximale (en mm) |
Thickness |
Épaisseur maximale (en mm) |
B.Width |
Largeur basale (en mm) |
J.Width |
Largeur au point de jonction (en mm) |
H.Length |
Longueur de l’élément d’emmanchement (en mm) |
Weight |
Poids (en grammes) |
Blade.Sh |
Forme de la lame : E = Excurvée, I = Incurvée, R = Recurvée, S = Droite |
Base.Sh |
Forme de la base : E = Excurvée, I = Incurvée, R = Recurvée, S = Droite |
Should.Sh |
Forme des épaules : E = Excurvée, I = Incurvée, S = Droite, X = Aucune |
Should.Or |
Orientation des épaules : B = Barbelée, H = Horizontale, T = Rétrécie, X = Aucune |
Haft.Sh |
Forme latérale de l’élément d’emmanchement : A = Anguleuse, E = Excurvée, I = Incurvée, R = Recurvée, S = Droite |
Haft.Or |
Orientation latérale de l’emmanchement : C = Concave, E = Élargissante, P = Parallèle, T = Rétrécissante, V = Convexe |
Avant de commencer à manipuler un jeu de données, il est important de comprendre sa structure et son contenu. Les commandes ci-dessous sont utiles pour cela ; elles jouent également un rôle dans certains types de calculs et de fonctions.
#Pour la suite renommer le data.frame en DartPoints
DartPoints<-DartPoints_xlsx
#Supprimer l'objet DartPoints_xlsx
rm(DartPoints_xlsx)Structure pour un cadre de données, cette commande vous indique combien de variables il y a, combien d’observations (pensez aux lignes d’une feuille de calcul), puis elle liste chaque variable, son type de données et les premières valeurs comme exemples.
## tibble [91 × 17] (S3: tbl_df/tbl/data.frame)
## $ Name : chr [1:91] "Darl" "Darl" "Darl" "Darl" ...
## $ Catalog : chr [1:91] "41-0322" "35-2946" "35-2921" "36-3487" ...
## $ TARL : chr [1:91] "41CV0536" "41CV0235" "41CV0132" "41CV0594" ...
## $ Quad : chr [1:91] "26/59" "21/63" "20/63" "10/54" ...
## $ Length : num [1:91] 42.8 40.5 37.5 40.3 30.6 41.8 40.3 48.5 47.7 33.6 ...
## $ Width : num [1:91] 15.8 17.4 16.3 16.1 17.1 16.8 20.7 18.7 17.5 15.8 ...
## $ Thickness: num [1:91] 5.8 5.8 6.1 6.3 4 4.1 5.9 6.9 7.2 5.1 ...
## $ B.Width : num [1:91] 11.3 NA 12.1 13.5 12.6 12.7 11.7 14.7 14.3 NA ...
## $ J.Width : num [1:91] 10.6 13.7 11.3 11.7 11.2 11.5 11.4 13.4 11.8 12.5 ...
## $ H.Length : num [1:91] 11.6 12.9 8.2 8.3 8.9 11 7.6 9.2 8.9 11.5 ...
## $ Weight : num [1:91] 3.6 4.5 3.6 4 2.3 3 3.9 6.2 5.1 2.8 ...
## $ Blade.Sh : chr [1:91] "S" "S" "S" "S" ...
## $ Base.Sh : chr [1:91] "I" "I" "I" "I" ...
## $ Should.Sh: chr [1:91] "S" "S" "S" "S" ...
## $ Should.Or: chr [1:91] "T" "T" "T" "T" ...
## $ Haft.Sh : chr [1:91] "S" "S" "S" "S" ...
## $ Haft.Or : chr [1:91] "E" "E" "E" "E" ...Nombre de lignes & Nombre de colonnes
## [1] 91## [1] 17Étant donné que ces commandes renvoient des entiers, elles peuvent être utilisées pour faire des tests. Dans des cas plus complexes, cela peut être utile, par exemple lorsque vous souhaitez confirmer que deux ou plusieurs jeux de données ont le même nombre d’observations avant de les combiner.
## [1] FALSEAfficher les lignes de la table
## # A tibble: 6 × 17
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 41-0322 41CV0536 26/59 42.8 15.8 5.8 11.3 10.6 11.6
## 2 Darl 35-2946 41CV0235 21/63 40.5 17.4 5.8 NA 13.7 12.9
## 3 Darl 35-2921 41CV0132 20/63 37.5 16.3 6.1 12.1 11.3 8.2
## 4 Darl 36-3487 41CV0594 10/54 40.3 16.1 6.3 13.5 11.7 8.3
## 5 Darl 36-3321 41CV1023 12/58 30.6 17.1 4 12.6 11.2 8.9
## 6 Darl 35-2959 41CV0235 21/63 41.8 16.8 4.1 12.7 11.5 11
## # ℹ 7 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>## # A tibble: 4 × 17
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 41-0322 41CV0536 26/59 42.8 15.8 5.8 11.3 10.6 11.6
## 2 Darl 35-2946 41CV0235 21/63 40.5 17.4 5.8 NA 13.7 12.9
## 3 Darl 35-2921 41CV0132 20/63 37.5 16.3 6.1 12.1 11.3 8.2
## 4 Darl 36-3487 41CV0594 10/54 40.3 16.1 6.3 13.5 11.7 8.3
## # ℹ 7 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>## # A tibble: 6 × 17
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Wells 36-3088 41CV0918 17/65 65.4 25.1 8.6 7.1 15.1 16.1
## 2 Wells 35-3079 IF 23/62 58.9 24.4 8.8 10.3 17.1 23.3
## 3 Wells 35-2898 41CV0876 21/66 55.4 19.3 5.3 11.3 15.6 15.2
## 4 Wells 35-2458 41CV0810 23/62 45.8 18.9 6.5 12.1 12.2 10.9
## 5 Wells 35-3012 41CV0270 24/62 49.1 21.1 6.3 14.8 15.2 16.6
## 6 Wells 44-0732 41BL0239 39/55 63.1 24.7 5.4 10.3 12.1 21.1
## # ℹ 7 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>## # A tibble: 2 × 17
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Wells 35-3012 41CV0270 24/62 49.1 21.1 6.3 14.8 15.2 16.6
## 2 Wells 44-0732 41BL0239 39/55 63.1 24.7 5.4 10.3 12.1 21.1
## # ℹ 7 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>Traitement des données de base
Accéder aux variables d’un tableau
l’accès aux aux colonnes du tableau pour pouvoir les manipuler,
effectuer des calculs, etc s’effectue avec l’opérateur $,
qui permet, si l’on tape :
## [1] "Darl" "Darl" "Darl" "Darl" "Darl"
## [6] "Darl" "Darl" "Darl" "Darl" "Darl"
## [11] "Darl" "Darl" "Darl" "Darl" "Darl"
## [16] "Darl" "Darl" "Darl" "Darl" "Darl"
## [21] "Darl" "Darl" "Darl" "Darl" "Darl"
## [26] "Darl" "Darl" "Darl" "Ensor" "Ensor"
## [31] "Ensor" "Ensor" "Ensor" "Ensor" "Ensor"
## [36] "Ensor" "Ensor" "Ensor" "Pedernales" "Pedernales"
## [41] "Pedernales" "Pedernales" "Pedernales" "Pedernales" "Pedernales"
## [46] "Pedernales" "Pedernales" "Pedernales" "Pedernales" "Pedernales"
## [51] "Pedernales" "Pedernales" "Pedernales" "Pedernales" "Pedernales"
## [56] "Pedernales" "Pedernales" "Pedernales" "Pedernales" "Pedernales"
## [61] "Pedernales" "Pedernales" "Pedernales" "Pedernales" "Pedernales"
## [66] "Pedernales" "Pedernales" "Pedernales" "Pedernales" "Pedernales"
## [71] "Travis" "Travis" "Travis" "Travis" "Travis"
## [76] "Travis" "Travis" "Travis" "Travis" "Travis"
## [81] "Travis" "Wells" "Wells" "Wells" "Wells"
## [86] "Wells" "Wells" "Wells" "Wells" "Wells"
## [91] "Wells"## # A tibble: 91 × 1
## Name
## <chr>
## 1 Darl
## 2 Darl
## 3 Darl
## 4 Darl
## 5 Darl
## 6 Darl
## 7 Darl
## 8 Darl
## 9 Darl
## 10 Darl
## # ℹ 81 more rows## # A tibble: 3 × 4
## Name Catalog TARL Quad
## <chr> <chr> <chr> <chr>
## 1 Darl 41-0322 41CV0536 26/59
## 2 Darl 35-2946 41CV0235 21/63
## 3 Darl 35-2921 41CV0132 20/63## [1] "Darl" "Darl" "Darl"## [1] "Wells" "Wells" "Wells"R affiche toutes les valeurs de la colonne Name dans la
console. Cette affichage permet de constater que
DartPoints$Name est un vecteur de chaînes de caractères.Si
on souhaite afficher seulement les premières ou dernières valeurs d’une
variable, on peut utiliser les fonctions head et
tail.
Variables Quantitatives
Il est possible de fournir des statistiques et des résumées
## Name Catalog TARL Quad
## Length:91 Length:91 Length:91 Length:91
## Class :character Class :character Class :character Class :character
## Mode :character Mode :character Mode :character Mode :character
##
##
##
##
## Length Width Thickness B.Width
## Min. : 30.60 Min. :14.50 Min. : 4.000 Min. : 7.10
## 1st Qu.: 40.85 1st Qu.:18.55 1st Qu.: 6.250 1st Qu.:11.70
## Median : 47.10 Median :21.10 Median : 7.200 Median :13.60
## Mean : 49.33 Mean :22.08 Mean : 7.271 Mean :13.75
## 3rd Qu.: 55.80 3rd Qu.:25.15 3rd Qu.: 8.250 3rd Qu.:15.50
## Max. :109.50 Max. :49.30 Max. :10.700 Max. :21.20
## NA's :22
## J.Width H.Length Weight Blade.Sh
## Min. :10.60 Min. : 5.80 Min. : 2.300 Length:91
## 1st Qu.:13.12 1st Qu.:10.50 1st Qu.: 4.550 Class :character
## Median :15.55 Median :12.50 Median : 6.800 Mode :character
## Mean :15.40 Mean :13.41 Mean : 7.643
## 3rd Qu.:17.07 3rd Qu.:16.30 3rd Qu.:10.050
## Max. :21.20 Max. :23.30 Max. :28.800
## NA's :1
## Base.Sh Should.Sh Should.Or Haft.Sh
## Length:91 Length:91 Length:91 Length:91
## Class :character Class :character Class :character Class :character
## Mode :character Mode :character Mode :character Mode :character
##
##
##
##
## Haft.Or
## Length:91
## Class :character
## Mode :character
##
##
##
## # statistiques de base spécifiques pour une variable. Par exemple :
min(DartPoints$Length) # Minimum## [1] 30.6## [1] 109.5## [1] 22.07692## [1] 21.1# Définir le pourcentage que vous souhaitez avec "probs"
q1<-quantile(DartPoints$Weight, probs = 0.25)
q3<-quantile(DartPoints$Weight, probs = 0.75)
# Plage interquartile
q3-q1## 75%
## 5.5# Plage interquartile -- c'est-à-dire la distance du 25e percentile au 75e percentile
IQR(DartPoints$Weight) ## [1] 5.5## [1] 4.207088Créer une nouvelle colonne (variable)
On peut aussi utiliser l’opérateur $ pour créer une
nouvelle variable dans notre tableau : pour cela, il suffit de lui
assigner une valeur. Par exemple, les variables Length
etWidth donnent respectivement a longueur et la largeur des
pointes de projectile.
Il est possible de calculer un indicateur Ratio=
Length/Width : ce ratio donne une idée de la forme générale
de la pointe : un ratio élevé indique une pointe plutôt allongée, tandis
qu’un ratio plus faible indique une pointe plus large ou trapue. C’est
un indicateur simple mais utile pour comparer les styles ou les
fonctions potentielles des différentes pointes.
# Calcul du ratio longueur/largeur
DartPoints$Ratio_LW <- DartPoints$Length / DartPoints$Width
# Afficher les premières valeurs
head(DartPoints[, c("Length", "Width", "Ratio_LW")])## # A tibble: 6 × 3
## Length Width Ratio_LW
## <dbl> <dbl> <dbl>
## 1 42.8 15.8 2.71
## 2 40.5 17.4 2.33
## 3 37.5 16.3 2.30
## 4 40.3 16.1 2.50
## 5 30.6 17.1 1.79
## 6 41.8 16.8 2.49Graphiques simple
Pour explorer la distribution des valeurs d’une variable
quantitative, un graphique de type histogramme est particulièrement
adapté. Ce type de graphique permet de visualiser comment les données se
répartissent en classes. Dans R, il peut être généré à l’aide de la
fonction hist().
# Plage personnalisée
x_min <- 0
x_max <- 120
x_breaks <- seq(from = x_min, to = x_max, by = 10) # classes pour l’histogramme
x_ticks <- seq(from = x_min, to = x_max, by = 5) # graduations visibles
# Histogramme avec axe X personnalisé
hist(DartPoints$Length,
col = "red",
breaks = x_breaks,
main = "Distribution de la longueur",
xlab = "Longueur",
ylab = "Effectif",
border = "black",
xlim = c(x_min, x_max), # fixe la plage affichée
xaxt = "n",
labels=TRUE) # supprime l'axe X par défaut
# Ajout de l'axe X avec des graduations tous les 5
axis(side = 1, at = x_ticks)
On peut modifier les amplitudes des classes avec des arguments
supplémentaires à la fonction hist. L’argument le plus important est
breaks, qui permet d’indiquer le nombre de classes que l’on
souhaite.
a<-min(DartPoints$Length)
a<-trunc(a)
b<-max(DartPoints$Length)
b<-trunc(b)+1
pas<-seq(from = a, to = b, by =10)
a <- trunc(min(DartPoints$Length))
# arrondit vers le haut à la dizaine suivante
#Ça prend le max, le convertit en dizaine (/10 puis trunc),
#le remet à l’échelle #(*10) et ajoute 10 pour
#s’assurer que la dernière classe couvre bien le maximum.
b <- trunc(max(DartPoints$Length) / 10) * 10 + 10
pas<-seq(from = a, to = b, by =10)
hist(DartPoints$Length,
col = "red",
breaks = pas,
main = "Distribution de la longueur",
xlab = "Longueur",
ylab = "Effectif",
ylim = c(0, 50),
xlim = c(20, 120)) # ajuste selon ton jeu de données
Variables Qualitatives
Pour les données qualitatives, unique() est une commande précieuse. Elle renvoie toutes les valeurs uniques d’une variable. Par exemple :
## [1] "Darl" "Ensor" "Pedernales" "Travis" "Wells"## [1] "S" "I" "E" NA "R"## [1] "S" "I" "E" NA "A" "R"Une variable qualitative prend des valeurs limitées distinctes appelées modalités. Ces modalités représentent des catégories. Dans le jeu de données DartPoints, plusieurs variables sont qualitatives. Par exemple : - Name : type de pointe de projectile (Darl, Ensor, Pedernales, Travis, Wells) - Blade.Sh : forme de la lame (E pour Excurvate, I pour Incurvate, etc.) - Base.Sh, Should.Sh, Haft.Sh, Haft.Or : différentes formes et orientations des parties de la pointe.
À noter : Certaines de ces variables sont codées par des lettres, mais elles représentent bien des catégories distinctes.
De plus, certaines variables pourraient être traitées soit comme qualitatives, soit comme quantitatives, selon le contexte d’analyse. Par exemple : Weight (le poids) est une variable quantitative, mais on pourrait la regrouper en classes (légère, moyenne, lourde) pour des comparaisons, et la traiter comme qualitative ordonnée.
Comptage
Vous pouvez utiliser la commande table() pour obtenir un compte pour chaque valeur d’une variable. Par exemple :
##
## Darl Ensor Pedernales Travis Wells
## 28 10 32 11 10table(DartPoints$Length>=70 & DartPoints$Length<80 , # prendre les pointes entre 70 et 80
DartPoints$Name, # Type de pointe
useNA = "ifany", # si il y a des NA alors je veux les calculer
exclude = "Wells") # exclure la modlité "Wells"##
## Darl Ensor Pedernales Travis
## FALSE 28 10 30 11
## TRUE 0 0 2 0##
## Darl Ensor Pedernales Travis Wells
## 28 10 32 11 10##
## Ensor Wells Travis Darl Pedernales
## 10 10 11 28 32
On constate que Le type Pedernales est le plus fréquent 32, suivi par
Darl 28. Les autres types sont moins représentés. Un tableau de ce type
peut être stocké dans un objet, et lui appliquer des fonctions. Par
exemple, la fonction sort permet de trier le tableau selon la valeur de
l’effectif.
Attention, par défaut la fonction table n’affiche pas les valeurs manquantes (NA).
Pour les inclure il faut utiliser l’argument useNA = "always",
soit : table(matable$variable, useNA = "always")
ou l’argument useNA = "ifany" pour inclure les valeurs manquantes (NA)
uniquement si elles existent dans les données.
Possibilté de faire des statistiques croisées
Un tableau de contingence (ou tableau croisé) permet de visualiser la distribution conjointe de deux variables qualitatives (catégorielles).
Pour faciliter la lecture d’un tableau croisé, il est recommandé de calculer les pourcentages sur la variable indépendante. Si on considère que la variable Name dépend de la forme de la pointe, la variable dépendante est la variable Name (à expliquer) et la variable explicative est la forme de la pointe , on calcule donc les pourcentages colonnes qui permettent de comparer directement, pour chaque type de pointe Name, la répartition des formes de la pointe.
Pour simplifier la lecture, il est faut calculer les pourcentages sur la variable à expliquer.
Question : quelle fonction ? autres exemples ?
# croisement Forme de la lame = Blade.Sh VS type de pointe = Name
table(DartPoints$Blade.Sh, DartPoints$Name, useNA = "ifany") ##
## Darl Ensor Pedernales Travis Wells
## E 15 2 15 7 3
## I 2 1 1 0 0
## R 0 0 3 0 0
## S 10 6 13 4 7
## <NA> 1 1 0 0 0##
## E I R S <NA>
## Darl 15 2 0 10 1
## Ensor 2 1 0 6 1
## Pedernales 15 1 3 13 0
## Travis 7 0 0 4 0
## Wells 3 0 0 7 0# install.packages("questionr")
# Le package questionr,permet de manipuler facilement des tableaux de contingence.
# Il facilite notamment le calcul des profils en ligne et en colonne.
library(questionr)
# Tableau en pourcentages ligne ou colonne
# ligne
lprop(table(DartPoints$Blade.Sh, DartPoints$Name) )##
## Darl Ensor Pedernales Travis Wells Total
## E 35.7 4.8 35.7 16.7 7.1 100.0
## I 50.0 25.0 25.0 0.0 0.0 100.0
## R 0.0 0.0 100.0 0.0 0.0 100.0
## S 25.0 15.0 32.5 10.0 17.5 100.0
## All 30.3 10.1 36.0 12.4 11.2 100.0##
## Darl Ensor Pedernales Travis Wells All
## E 55.6 22.2 46.9 63.6 30.0 47.2
## I 7.4 11.1 3.1 0.0 0.0 4.5
## R 0.0 0.0 9.4 0.0 0.0 3.4
## S 37.0 66.7 40.6 36.4 70.0 44.9
## Total 100.0 100.0 100.0 100.0 100.0 100.0Visualiser un tableau de contingence
La fonction mosaicplot() permet de visualiser un tableau
de contingence sous forme de graphiques en mosaïque. Ces graphiques
montrent la relation entre deux (ou plusieurs) variables catégorielles,
en représentant les proportions par la taille des rectangles.
La fonction balloonplot() (du package
gplots) permet de représenter les valeurs d’un tableau sous
forme de bulles proportionnelles à l’intérieur d’une grille. C’est une
alternative visuelle au mosaicplot() pour explorer la relation entre
deux variables qualitatives.
##
## Attaching package: 'gplots'## The following object is masked from 'package:stats':
##
## lowessballoonplot(table(DartPoints$Blade.Sh, DartPoints$Name),
xlab="Name",
ylab="Blade.Sh",
label = TRUE,
show.margins = TRUE,
main="Visualisation du tableau de contingence")
## autre possibilité
library(ggpubr)
ggballoonplot(as.data.frame(
table(DartPoints$Blade.Sh,DartPoints$Name)) ,
)
Manipuler les données avec dplyr
dplyr est une extension facilitant le traitement et la
manipulation de données contenues dans une ou plusieurs tables. Elle
propose une syntaxe claire et cohérente, sous formes de verbes, pour la
plupart des opérations de ce type. dplyr fait partie du
tidyverse, elle est donc chargée automatiquement avec :
On peut également la charger individuellement.
Les verbes de dplyr
La manipulation de données avec dplyr se fait en
utilisant un nombre réduit de verbes, qui correspondent chacun à une
action différente appliquée à un tableau de données.
Le verbeslice
Le verbe slice sélectionne des lignes du tableau selon
leur position. Si on souhaite sélectionner la 35e ligne du tableau
DartPoints :
## # A tibble: 1 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Ensor 35-2176 41BL0773 25/48 38 17.5 5 15.6 21.1 7.4
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>Si on veut sélectionner les 5 premières lignes :
## # A tibble: 5 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 41-0322 41CV0536 26/59 42.8 15.8 5.8 11.3 10.6 11.6
## 2 Darl 35-2946 41CV0235 21/63 40.5 17.4 5.8 NA 13.7 12.9
## 3 Darl 35-2921 41CV0132 20/63 37.5 16.3 6.1 12.1 11.3 8.2
## 4 Darl 36-3487 41CV0594 10/54 40.3 16.1 6.3 13.5 11.7 8.3
## 5 Darl 36-3321 41CV1023 12/58 30.6 17.1 4 12.6 11.2 8.9
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>slice propose plusieurs variantes utiles, dont
slice_head et slice_tail, qui permettent de
sélectionner les premières ou les dernières lignes du tableau (on peut
spécifier le nombre de lignes souhaitées avec n, ou la
proportion avec prop).
## # A tibble: 2 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Wells 35-3012 41CV0270 24/62 49.1 21.1 6.3 14.8 15.2 16.6
## 2 Wells 44-0732 41BL0239 39/55 63.1 24.7 5.4 10.3 12.1 21.1
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>## # A tibble: 45 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 41-0322 41CV0536 26/59 42.8 15.8 5.8 11.3 10.6 11.6
## 2 Darl 35-2946 41CV0235 21/63 40.5 17.4 5.8 NA 13.7 12.9
## 3 Darl 35-2921 41CV0132 20/63 37.5 16.3 6.1 12.1 11.3 8.2
## 4 Darl 36-3487 41CV0594 10/54 40.3 16.1 6.3 13.5 11.7 8.3
## 5 Darl 36-3321 41CV1023 12/58 30.6 17.1 4 12.6 11.2 8.9
## 6 Darl 35-2959 41CV0235 21/63 41.8 16.8 4.1 12.7 11.5 11
## 7 Darl 35-2866 41CV0855 25/65 40.3 20.7 5.9 11.7 11.4 7.6
## 8 Darl 41-0323 41CV0536 26/59 48.5 18.7 6.9 14.7 13.4 9.2
## 9 Darl 35-2325 41CV0795 20/48 47.7 17.5 7.2 14.3 11.8 8.9
## 10 Darl 40-0847 41CV1287 05/48 33.6 15.8 5.1 NA 12.5 11.5
## # ℹ 35 more rows
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>Autres variantes utiles, slice_min et
slice_max permettent de sélectionner les lignes avec les
valeurs les plus grandes ou les plus petite d’une variable donnée.
Ainsi, la commande suivante sélectionne la pointe la plus petite.
## # A tibble: 1 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 36-3321 41CV1023 12/58 30.6 17.1 4 12.6 11.2 8.9
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>On peut aussi spécifier le nombre de lignes souhaitées, par exemple la commande suivante retourne les 10 pointes avec le poids le plus élevé.
## # A tibble: 5 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Pedernales 35-2855 41CV… 24/65 110. 49.3 7.5 12.9 20.9 16.4
## 2 Wells 44-0732 41BL… 39/55 63.1 24.7 5.4 10.3 12.1 21.1
## 3 Pedernales 41-0239 41CV… 16/62 67.2 27.1 10.2 NA 15.9 10.3
## 4 Pedernales 36-4266 41CV… 15/65 64.1 27.2 10.2 13.2 17 15.5
## 5 Travis 36-0006 41CV… 29/55 64.6 21.5 9.6 11.2 13.7 11.3
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>Le verbe filter
filter sélectionne des lignes d’une table selon une
condition. On lui passe en paramètre un test, et seules les lignes pour
lesquelles ce test renvoie TRUE (vrai) sont conservées.
Par exemple, si on veut sélectionner les pointes avec un poids
>11, on peut filtrer sur la variable Weight de la
manière suivante :
## # A tibble: 18 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Pedernal… 35-2391 41CV… 22/62 66 27.2 8 10 16.7 16.9
## 2 Pedernal… 35-2951 41CV… 21/63 64.5 28.5 8.2 14.1 20 17.5
## 3 Pedernal… 35-2875 41CV… 24/66 59 22.8 9.1 11.7 18.9 15.3
## 4 Pedernal… 35-2855 41CV… 24/65 110. 49.3 7.5 12.9 20.9 16.4
## 5 Pedernal… 35-2384 41CV… 22/62 59.8 31.7 10.7 NA 18.2 17
## 6 Pedernal… 36-3229 41CV… 14/60 55.3 27.3 9.5 8.8 18.6 15.2
## 7 Pedernal… 36-3081 41CV… 17/65 48 26.9 8.9 14.9 19.7 17.9
## 8 Pedernal… 35-0173 41CV… 22/66 78.3 28.1 8.5 10.5 15.5 21.2
## 9 Pedernal… 36-3897 41CV… 14/62 52 29.6 9.8 11.8 17.6 15.8
## 10 Pedernal… 41-0058 41BL… 30/44 61.1 25.2 8 12.2 17 11.4
## 11 Pedernal… 38-0098 41BL… 39/45 70.4 30.4 6.6 12.5 16.1 19.2
## 12 Pedernal… 41-0239 41CV… 16/62 67.2 27.1 10.2 NA 15.9 10.3
## 13 Pedernal… 36-4266 41CV… 15/65 64.1 27.2 10.2 13.2 17 15.5
## 14 Pedernal… 44-125… 41CV… 19/56 61.3 28.1 7.1 NA 18.2 20
## 15 Travis 36-0006 41CV… 29/55 64.6 21.5 9.6 11.2 13.7 11.3
## 16 Travis 43-0112 41CV… 15/70 69 20.9 7.8 16.4 12.8 13.8
## 17 Wells 36-3088 41CV… 17/65 65.4 25.1 8.6 7.1 15.1 16.1
## 18 Wells 44-0732 41BL… 39/55 63.1 24.7 5.4 10.3 12.1 21.1
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>Si on veut uniquement les pointes avec uen largeur Width
compris entre 16 et 19.5 mm :
Si on passe plusieurs arguments à filter, celui-ci
rajoute automatiquement une condition et entre les conditions.
La commande précédente peut donc être écrite de la manière suivante,
avec le même résultat :
## # A tibble: 24 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 35-2946 41CV0235 21/63 40.5 17.4 5.8 NA 13.7 12.9
## 2 Darl 35-2921 41CV0132 20/63 37.5 16.3 6.1 12.1 11.3 8.2
## 3 Darl 36-3487 41CV0594 10/54 40.3 16.1 6.3 13.5 11.7 8.3
## 4 Darl 36-3321 41CV1023 12/58 30.6 17.1 4 12.6 11.2 8.9
## 5 Darl 35-2959 41CV0235 21/63 41.8 16.8 4.1 12.7 11.5 11
## 6 Darl 41-0323 41CV0536 26/59 48.5 18.7 6.9 14.7 13.4 9.2
## 7 Darl 35-2325 41CV0795 20/48 47.7 17.5 7.2 14.3 11.8 8.9
## 8 Darl 41-0257 41BL0347 16/33 33.5 16.6 4.9 12.4 12.9 10.5
## 9 Darl 35-2905 41CV0878 22/66 41.8 16.7 5.1 14.2 14.3 10.5
## 10 Darl 36-3898 41CV1093 10/60 38 16.5 5.4 14.5 15.2 13.7
## # ℹ 14 more rows
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>On peut également placer des fonctions dans les tests, qui nous permettent par exemple de sélectionner les pointes ayant un poids supérieure au poids médian :
## # A tibble: 45 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 35-2004 41CV… 24/62 47.6 20.3 8.1 17 14.7 12.3
## 2 Darl 35-2960 41CV… 21/63 50.6 20.3 6.8 15.1 14.1 9.1
## 3 Darl 41-0237 41CV… 16/62 54.2 21 8 17.2 13.1 11.5
## 4 Ensor 36-3526 41CV… 16/63 55.2 22.5 7 NA 13.2 10.4
## 5 Ensor 41-0210 41CV… 16/59 48.5 27.3 7.8 NA 19.1 10.5
## 6 Pedernal… 36-3026 41CV… 17/68 53.5 27.8 7.2 NA 20.2 16.2
## 7 Pedernal… 35-2391 41CV… 22/62 66 27.2 8 10 16.7 16.9
## 8 Pedernal… 35-2951 41CV… 21/63 64.5 28.5 8.2 14.1 20 17.5
## 9 Pedernal… 35-2875 41CV… 24/66 59 22.8 9.1 11.7 18.9 15.3
## 10 Pedernal… 35-2901 41CV… 21/66 60 27.9 10 8.3 21.2 20.2
## # ℹ 35 more rows
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>Select et Rename select et rename
select permet de sélectionner des colonnes d’un tableau
de données. Ainsi, si on veut extraire les colonnes Length,
Width et Thickness du tableau DartPoints :
## # A tibble: 91 × 3
## Length Width Thickness
## <dbl> <dbl> <dbl>
## 1 42.8 15.8 5.8
## 2 40.5 17.4 5.8
## 3 37.5 16.3 6.1
## 4 40.3 16.1 6.3
## 5 30.6 17.1 4
## 6 41.8 16.8 4.1
## 7 40.3 20.7 5.9
## 8 48.5 18.7 6.9
## 9 47.7 17.5 7.2
## 10 33.6 15.8 5.1
## # ℹ 81 more rowsSi on fait précéder le nom d’un -, la colonne est
éliminée plutôt que sélectionnée :
## [1] 18## # A tibble: 91 × 15
## Name Catalog TARL Quad B.Width J.Width H.Length Weight Blade.Sh Base.Sh
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <chr> <chr>
## 1 Darl 41-0322 41CV0536 26/59 11.3 10.6 11.6 3.6 S I
## 2 Darl 35-2946 41CV0235 21/63 NA 13.7 12.9 4.5 S I
## 3 Darl 35-2921 41CV0132 20/63 12.1 11.3 8.2 3.6 S I
## 4 Darl 36-3487 41CV0594 10/54 13.5 11.7 8.3 4 S I
## 5 Darl 36-3321 41CV1023 12/58 12.6 11.2 8.9 2.3 S I
## 6 Darl 35-2959 41CV0235 21/63 12.7 11.5 11 3 S E
## 7 Darl 35-2866 41CV0855 25/65 11.7 11.4 7.6 3.9 I I
## 8 Darl 41-0323 41CV0536 26/59 14.7 13.4 9.2 6.2 E I
## 9 Darl 35-2325 41CV0795 20/48 14.3 11.8 8.9 5.1 E S
## 10 Darl 40-0847 41CV1287 05/48 NA 12.5 11.5 2.8 E I
## # ℹ 81 more rows
## # ℹ 5 more variables: Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>,
## # Haft.Or <chr>, Ratio_LW <dbl>## [1] 15select comprend toute une série de fonctions facilitant
la sélection de colonnes multiples. Par exemple,
starts_with, ends_width, contains
ou matches permettent d’exprimer des conditions sur les
noms de variables.
## # A tibble: 91 × 2
## Width Weight
## <dbl> <dbl>
## 1 15.8 3.6
## 2 17.4 4.5
## 3 16.3 3.6
## 4 16.1 4
## 5 17.1 2.3
## 6 16.8 3
## 7 20.7 3.9
## 8 18.7 6.2
## 9 17.5 5.1
## 10 15.8 2.8
## # ℹ 81 more rows## # A tibble: 91 × 5
## Length Width B.Width J.Width H.Length
## <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 42.8 15.8 11.3 10.6 11.6
## 2 40.5 17.4 NA 13.7 12.9
## 3 37.5 16.3 12.1 11.3 8.2
## 4 40.3 16.1 13.5 11.7 8.3
## 5 30.6 17.1 12.6 11.2 8.9
## 6 41.8 16.8 12.7 11.5 11
## 7 40.3 20.7 11.7 11.4 7.6
## 8 48.5 18.7 14.7 13.4 9.2
## 9 47.7 17.5 14.3 11.8 8.9
## 10 33.6 15.8 NA 12.5 11.5
## # ℹ 81 more rowsLa syntaxe colonne1:colonne2 permet de sélectionner
toutes les colonnes situées entre colonne1 et
colonne2 À noter que cette opération est un peu plus
“fragile” que les autres, car si l’ordre des colonnes change elle peut
renvoyer un résultat différent.
## # A tibble: 91 × 5
## Name Catalog TARL Quad Length
## <chr> <chr> <chr> <chr> <dbl>
## 1 Darl 41-0322 41CV0536 26/59 42.8
## 2 Darl 35-2946 41CV0235 21/63 40.5
## 3 Darl 35-2921 41CV0132 20/63 37.5
## 4 Darl 36-3487 41CV0594 10/54 40.3
## 5 Darl 36-3321 41CV1023 12/58 30.6
## 6 Darl 35-2959 41CV0235 21/63 41.8
## 7 Darl 35-2866 41CV0855 25/65 40.3
## 8 Darl 41-0323 41CV0536 26/59 48.5
## 9 Darl 35-2325 41CV0795 20/48 47.7
## 10 Darl 40-0847 41CV1287 05/48 33.6
## # ℹ 81 more rowsselect propose de nombreuses autres possibilités de
sélection qui sont décrites dans la
documentation de l’extension tidyselect.
rename permet de renommer des colonnes directement. On
l’utilise en lui passant des paramètres de la forme
nouveau_nom = ancien_nom. Ainsi, si on veut renommer les
colonnes Width et Weight de
DartPoints en Largeur et
Poids :
## # A tibble: 91 × 18
## Name Catalog TARL Quad Length Largeur Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 41-0322 41CV05… 26/59 42.8 15.8 5.8 11.3 10.6 11.6
## 2 Darl 35-2946 41CV02… 21/63 40.5 17.4 5.8 NA 13.7 12.9
## 3 Darl 35-2921 41CV01… 20/63 37.5 16.3 6.1 12.1 11.3 8.2
## 4 Darl 36-3487 41CV05… 10/54 40.3 16.1 6.3 13.5 11.7 8.3
## 5 Darl 36-3321 41CV10… 12/58 30.6 17.1 4 12.6 11.2 8.9
## 6 Darl 35-2959 41CV02… 21/63 41.8 16.8 4.1 12.7 11.5 11
## 7 Darl 35-2866 41CV08… 25/65 40.3 20.7 5.9 11.7 11.4 7.6
## 8 Darl 41-0323 41CV05… 26/59 48.5 18.7 6.9 14.7 13.4 9.2
## 9 Darl 35-2325 41CV07… 20/48 47.7 17.5 7.2 14.3 11.8 8.9
## 10 Darl 40-0847 41CV12… 05/48 33.6 15.8 5.1 NA 12.5 11.5
## # ℹ 81 more rows
## # ℹ 8 more variables: Poids <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>Si les noms de colonnes comportent des espaces ou des caractères
spéciaux, on peut les entourer de guillemets (") :
tmp <- rename(
DartPoints,
"Largeur Pointe" = Width,
"Poids Pointe" = Weight
)
select(tmp, "Largeur Pointe", "Poids Pointe")## # A tibble: 91 × 2
## `Largeur Pointe` `Poids Pointe`
## <dbl> <dbl>
## 1 15.8 3.6
## 2 17.4 4.5
## 3 16.3 3.6
## 4 16.1 4
## 5 17.1 2.3
## 6 16.8 3
## 7 20.7 3.9
## 8 18.7 6.2
## 9 17.5 5.1
## 10 15.8 2.8
## # ℹ 81 more rowsLe verbe Arrange arrange
arrange réordonne les lignes d’un tableau selon une ou
plusieurs colonnes.
Ainsi, si on veut trier le tableau DartPoints selon la
longeur croissante :
## # A tibble: 91 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 36-3321 41CV… 12/58 30.6 17.1 4 12.6 11.2 8.9
## 2 Darl 35-2382 41CV… 22/62 31.2 15.6 5.1 16.1 12.8 10
## 3 Darl 36-3619 IF 17/63 32 16 5.4 13.7 12 15.7
## 4 Darl 36-3520 41CV… 16/62 32.4 14.5 5.2 11.2 11.4 11.7
## 5 Darl 36-4247 41CV… 12/54 33.1 17.4 7 15.9 16.3 8.7
## 6 Darl 41-0257 41BL… 16/33 33.5 16.6 4.9 12.4 12.9 10.5
## 7 Darl 40-0847 41CV… 05/48 33.6 15.8 5.1 NA 12.5 11.5
## 8 Darl 35-3026 41CV… 24/62 34.5 15.9 4.8 15.9 13.9 7.2
## 9 Ensor 35-2645 41CV… 24/62 34.9 21.4 7 21.2 12.8 10
## 10 Pedernal… 44-0643 41CV… 08/63 35.4 18.5 6.4 NA 17.1 16.8
## # ℹ 81 more rows
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>On peut trier selon plusieurs colonnes. Par exemple selon la longeur, puis selon le largeur :
## # A tibble: 91 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 36-3321 41CV… 12/58 30.6 17.1 4 12.6 11.2 8.9
## 2 Darl 35-2382 41CV… 22/62 31.2 15.6 5.1 16.1 12.8 10
## 3 Darl 36-3619 IF 17/63 32 16 5.4 13.7 12 15.7
## 4 Darl 36-3520 41CV… 16/62 32.4 14.5 5.2 11.2 11.4 11.7
## 5 Darl 36-4247 41CV… 12/54 33.1 17.4 7 15.9 16.3 8.7
## 6 Darl 41-0257 41BL… 16/33 33.5 16.6 4.9 12.4 12.9 10.5
## 7 Darl 40-0847 41CV… 05/48 33.6 15.8 5.1 NA 12.5 11.5
## 8 Darl 35-3026 41CV… 24/62 34.5 15.9 4.8 15.9 13.9 7.2
## 9 Ensor 35-2645 41CV… 24/62 34.9 21.4 7 21.2 12.8 10
## 10 Pedernal… 44-0643 41CV… 08/63 35.4 18.5 6.4 NA 17.1 16.8
## # ℹ 81 more rows
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>Si on veut trier selon une colonne par ordre décroissant, on lui
applique la fonction desc() :
## # A tibble: 91 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Pedernal… 35-2855 41CV… 24/65 110. 49.3 7.5 12.9 20.9 16.4
## 2 Pedernal… 36-3879 41CV… 14/62 84 21.2 10.2 16.9 18 11.9
## 3 Pedernal… 35-0173 41CV… 22/66 78.3 28.1 8.5 10.5 15.5 21.2
## 4 Pedernal… 38-0098 41BL… 39/45 70.4 30.4 6.6 12.5 16.1 19.2
## 5 Travis 43-0112 41CV… 15/70 69 20.9 7.8 16.4 12.8 13.8
## 6 Pedernal… 41-0239 41CV… 16/62 67.2 27.1 10.2 NA 15.9 10.3
## 7 Pedernal… 35-2391 41CV… 22/62 66 27.2 8 10 16.7 16.9
## 8 Wells 36-3088 41CV… 17/65 65.4 25.1 8.6 7.1 15.1 16.1
## 9 Pedernal… 43-0110 41CV… 15/70 65 31.6 10.1 10.9 17.7 23
## 10 Travis 36-0006 41CV… 29/55 64.6 21.5 9.6 11.2 13.7 11.3
## # ℹ 81 more rows
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>## # A tibble: 91 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Pedernal… 35-2855 41CV… 24/65 110. 49.3 7.5 12.9 20.9 16.4
## 2 Pedernal… 36-3879 41CV… 14/62 84 21.2 10.2 16.9 18 11.9
## 3 Pedernal… 35-0173 41CV… 22/66 78.3 28.1 8.5 10.5 15.5 21.2
## 4 Pedernal… 38-0098 41BL… 39/45 70.4 30.4 6.6 12.5 16.1 19.2
## 5 Travis 43-0112 41CV… 15/70 69 20.9 7.8 16.4 12.8 13.8
## 6 Pedernal… 41-0239 41CV… 16/62 67.2 27.1 10.2 NA 15.9 10.3
## 7 Pedernal… 35-2391 41CV… 22/62 66 27.2 8 10 16.7 16.9
## 8 Wells 36-3088 41CV… 17/65 65.4 25.1 8.6 7.1 15.1 16.1
## 9 Pedernal… 43-0110 41CV… 15/70 65 31.6 10.1 10.9 17.7 23
## 10 Travis 36-0006 41CV… 29/55 64.6 21.5 9.6 11.2 13.7 11.3
## # ℹ 81 more rows
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>Combiné avec slice, arrange permet par
exemple de sélectionner les 5 pointes les plus longues :
## # A tibble: 5 × 18
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Pedernales 35-2855 41CV… 24/65 110. 49.3 7.5 12.9 20.9 16.4
## 2 Pedernales 36-3879 41CV… 14/62 84 21.2 10.2 16.9 18 11.9
## 3 Pedernales 35-0173 41CV… 22/66 78.3 28.1 8.5 10.5 15.5 21.2
## 4 Pedernales 38-0098 41BL… 39/45 70.4 30.4 6.6 12.5 16.1 19.2
## 5 Travis 43-0112 41CV… 15/70 69 20.9 7.8 16.4 12.8 13.8
## # ℹ 8 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>Mutate mutate
mutate permet de créer de nouvelles colonnes dans le
tableau de données, en général à partir de variables existantes.
Par exemple, la table DartPoints contient la variable
Length en millimétre. Si on veut créer une nouvelle variable
Longeure avec comme unité le CM on peut faire :
## # A tibble: 91 × 2
## Length Longueur_CM
## <dbl> <dbl>
## 1 42.8 4.28
## 2 40.5 4.05
## 3 37.5 3.75
## 4 40.3 4.03
## 5 30.6 3.06
## 6 41.8 4.18
## 7 40.3 4.03
## 8 48.5 4.85
## 9 47.7 4.77
## 10 33.6 3.36
## # ℹ 81 more rowsOn peut créer plusieurs nouvelles colonnes en une seule commande, et les expressions successives peuvent prendre en compte les résultats des calculs précédents. Ici on souhaite :
- recoder la variable forme de la lame
Blade.Shet la forme de la base Base.Sh` - transformer la variable longeur en classe : grandes, moyennes, petites
DartPoints <- mutate(DartPoints,
"Forme_lame" = case_when(
Blade.Sh=="E"~ "Excurvée",
Blade.Sh=="I"~ "Incurvée",
Blade.Sh=="R"~ "Recurvée",
Blade.Sh=="S"~ "Droite"
),
"Base_lame"= case_when(
Base.Sh=="E"~ "Excurvée",
Base.Sh=="I"~ "Incurvée",
Base.Sh=="R"~ "Recurvée",
Base.Sh=="S"~ "Droite"
),
"longeur_classe"=case_when(
Length >= 50 & Length<= 110 ~ "[50-110]",
Length >= 47 & Length <50 ~ "]47-50]",
Length >= 30 & Length <47 ~ "[30-47]",
)
)Enchaîner les opérations avec le pipe
%>%
Quand on manipule un tableau de données, il est très fréquent
d’enchaîner plusieurs opérations. On va par exemple extraire une
sous-population avec filter, sélectionner des colonnes avec
select puis trier selon une variable avec
arrange, etc.
Quand on veut enchaîner des opérations, on peut le faire de différentes manières. La première est d’effectuer toutes les opérations en une fois en les “emboîtant” :
## # A tibble: 28 × 3
## Name Length Width
## <chr> <dbl> <dbl>
## 1 Darl 30.6 17.1
## 2 Darl 31.2 15.6
## 3 Darl 32 16
## 4 Darl 32.4 14.5
## 5 Darl 33.1 17.4
## 6 Darl 33.5 16.6
## 7 Darl 33.6 15.8
## 8 Darl 34.5 15.9
## 9 Darl 35.5 16.3
## 10 Darl 37.5 16.3
## # ℹ 18 more rowsCette notation a plusieurs inconvénients :
- elle est peu lisible
- les opérations apparaissent dans l’ordre inverse de leur
réalisation. Ici on effectue d’abord le
filter, puis leselect, puis learrange, alors qu’à la lecture du code c’est learrangequi apparaît en premier. - Il est difficile de voir quel paramètre se rapporte à quelle fonction
Une autre manière de faire est d’effectuer les opérations les unes après les autres, en stockant les résultats intermédiaires dans un objet temporaire :
tmp <- filter(DartPoints, Name == "Darl")
tmp <- select(tmp,Name, Length, Width)
arrange(tmp, Length)## # A tibble: 28 × 3
## Name Length Width
## <chr> <dbl> <dbl>
## 1 Darl 30.6 17.1
## 2 Darl 31.2 15.6
## 3 Darl 32 16
## 4 Darl 32.4 14.5
## 5 Darl 33.1 17.4
## 6 Darl 33.5 16.6
## 7 Darl 33.6 15.8
## 8 Darl 34.5 15.9
## 9 Darl 35.5 16.3
## 10 Darl 37.5 16.3
## # ℹ 18 more rowsC’est plus lisible, l’ordre des opérations est le bon, et les
paramètres sont bien rattachés à leur fonction. Par contre on crée un
objet temporaire tmp dont on n’a pas réellement besoin.
Pour simplifier et améliorer encore la lisibilité du code, on va
utiliser un nouvel opérateur, baptisé pipe. Le pipe se
note %>%, et son fonctionnement est le suivant : si
j’exécute expr %>% f, alors le résultat de l’expression
expr, à gauche du pipe, sera passé comme premier
argument à la fonction f.
Ainsi les deux expressions suivantes sont équivalentes :
tmp <- filter(DartPoints, Name == "Darl")
tmp <- select(tmp,Name, Length, Width)
arrange(tmp, Length)## # A tibble: 28 × 3
## Name Length Width
## <chr> <dbl> <dbl>
## 1 Darl 30.6 17.1
## 2 Darl 31.2 15.6
## 3 Darl 32 16
## 4 Darl 32.4 14.5
## 5 Darl 33.1 17.4
## 6 Darl 33.5 16.6
## 7 Darl 33.6 15.8
## 8 Darl 34.5 15.9
## 9 Darl 35.5 16.3
## 10 Darl 37.5 16.3
## # ℹ 18 more rows## # A tibble: 28 × 3
## Name Length Width
## <chr> <dbl> <dbl>
## 1 Darl 30.6 17.1
## 2 Darl 31.2 15.6
## 3 Darl 32 16
## 4 Darl 32.4 14.5
## 5 Darl 33.1 17.4
## 6 Darl 33.5 16.6
## 7 Darl 33.6 15.8
## 8 Darl 34.5 15.9
## 9 Darl 35.5 16.3
## 10 Darl 37.5 16.3
## # ℹ 18 more rowsOn appelle une suite d’instructions de ce type un pipeline.
Il est naturel de vouloir récupérer le résultat final d’un pipeline pour le stocker dans un objet. On peut stocker le résultat du pipeline ci-dessus dans un nouveau tableau.
Opérations Group by
La fonction group_by permet de définir des groupes de lignes à partir des valeurs d’une ou plusieurs colonnes. Par exemple, on peut grouper les pointes selon le :
## # A tibble: 91 × 22
## # Groups: Name [5]
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 41-0322 41CV0536 26/59 42.8 15.8 5.8 11.3 10.6 11.6
## 2 Darl 35-2946 41CV0235 21/63 40.5 17.4 5.8 NA 13.7 12.9
## 3 Darl 35-2921 41CV0132 20/63 37.5 16.3 6.1 12.1 11.3 8.2
## 4 Darl 36-3487 41CV0594 10/54 40.3 16.1 6.3 13.5 11.7 8.3
## 5 Darl 36-3321 41CV1023 12/58 30.6 17.1 4 12.6 11.2 8.9
## 6 Darl 35-2959 41CV0235 21/63 41.8 16.8 4.1 12.7 11.5 11
## 7 Darl 35-2866 41CV0855 25/65 40.3 20.7 5.9 11.7 11.4 7.6
## 8 Darl 41-0323 41CV0536 26/59 48.5 18.7 6.9 14.7 13.4 9.2
## 9 Darl 35-2325 41CV0795 20/48 47.7 17.5 7.2 14.3 11.8 8.9
## 10 Darl 40-0847 41CV1287 05/48 33.6 15.8 5.1 NA 12.5 11.5
## # ℹ 81 more rows
## # ℹ 12 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>, Longueur_CM <dbl>, Forme_lame <chr>, Base_lame <chr>,
## # longeur_classe <chr>les verbes comme mutate ou summarise vont en tenir compte lors de leurs opérations. - mutate : les opérations appliquées lors du calcul des valeurs des nouvelles colonnes sont appliquées groupe de lignes par groupe de lignes. Dans l’exemple suivant, on ajoute une nouvelle colonne qui contient la longueur moyenne pour chaque type de pointe Cette valeur est donc différente d’un type à une autre, mais identique pour toutes les pointes d’une même type :
data_mean_longeur<-DartPoints %>%
group_by(Name) %>%
mutate(mean_Lenght = mean(Length, na.rm = TRUE)) %>%
select(Name, Length, mean_Lenght)Ceci peut permettre, par exemple, de déterminer si une la longeur d’une pointe donné est supérieur ou inférieur au la longueur médiane :
DartPoints %>%
group_by(Name) %>%
mutate(
median_Length = median(Length, na.rm = TRUE),
testmed_pointe = ifelse(
Length > median_Length,
"Supérieur",
"Inférieur ou égal"
)
) %>%
select(Name,Length, median_Length, testmed_pointe)## # A tibble: 91 × 4
## # Groups: Name [5]
## Name Length median_Length testmed_pointe
## <chr> <dbl> <dbl> <chr>
## 1 Darl 42.8 40.2 Supérieur
## 2 Darl 40.5 40.2 Supérieur
## 3 Darl 37.5 40.2 Inférieur ou égal
## 4 Darl 40.3 40.2 Supérieur
## 5 Darl 30.6 40.2 Inférieur ou égal
## 6 Darl 41.8 40.2 Supérieur
## 7 Darl 40.3 40.2 Supérieur
## 8 Darl 48.5 40.2 Supérieur
## 9 Darl 47.7 40.2 Supérieur
## 10 Darl 33.6 40.2 Inférieur ou égal
## # ℹ 81 more rowsgroup_by peut aussi être utile avec filter, par exemple pour sélectionner pour chaque type les pointes avec un poids plus élevé que le poids moyen du même type.
## # A tibble: 42 × 22
## # Groups: Name [5]
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 35-2946 41CV0235 21/63 40.5 17.4 5.8 NA 13.7 12.9
## 2 Darl 41-0323 41CV0536 26/59 48.5 18.7 6.9 14.7 13.4 9.2
## 3 Darl 35-2325 41CV0795 20/48 47.7 17.5 7.2 14.3 11.8 8.9
## 4 Darl 38-0736 41BL0866 28/45 42.2 14.6 6.6 NA 13.2 12.5
## 5 Darl 36-3898 41CV1093 10/60 38 16.5 5.4 14.5 15.2 13.7
## 6 Darl 35-2004 41CV0187 24/62 47.6 20.3 8.1 17 14.7 12.3
## 7 Darl 35-0164 41CV0869 22/66 42.3 19.2 7.7 NA 11.6 11.5
## 8 Darl 36-3059 41CV0595 12/59 38.3 20.4 7.2 14.8 12.6 10.9
## 9 Darl 35-2960 41CV0235 21/63 50.6 20.3 6.8 15.1 14.1 9.1
## 10 Darl 41-0237 41CV0493 16/62 54.2 21 8 17.2 13.1 11.5
## # ℹ 32 more rows
## # ℹ 12 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>, Longueur_CM <dbl>, Forme_lame <chr>, Base_lame <chr>,
## # longeur_classe <chr>Attention : la clause group_by marche pour les verbes déjà vus précédemment, sauf pour arrange, qui par défaut trie la table sans tenir compte des groupes. Pour obtenir un tri par groupe, il faut lui ajouter l’argument .by_group = TRUE.
## # A tibble: 91 × 22
## # Groups: Name [5]
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Pedernal… 35-2855 41CV… 24/65 110. 49.3 7.5 12.9 20.9 16.4
## 2 Pedernal… 36-3879 41CV… 14/62 84 21.2 10.2 16.9 18 11.9
## 3 Pedernal… 35-0173 41CV… 22/66 78.3 28.1 8.5 10.5 15.5 21.2
## 4 Pedernal… 38-0098 41BL… 39/45 70.4 30.4 6.6 12.5 16.1 19.2
## 5 Travis 43-0112 41CV… 15/70 69 20.9 7.8 16.4 12.8 13.8
## 6 Pedernal… 41-0239 41CV… 16/62 67.2 27.1 10.2 NA 15.9 10.3
## 7 Pedernal… 35-2391 41CV… 22/62 66 27.2 8 10 16.7 16.9
## 8 Wells 36-3088 41CV… 17/65 65.4 25.1 8.6 7.1 15.1 16.1
## 9 Pedernal… 43-0110 41CV… 15/70 65 31.6 10.1 10.9 17.7 23
## 10 Travis 36-0006 41CV… 29/55 64.6 21.5 9.6 11.2 13.7 11.3
## # ℹ 81 more rows
## # ℹ 12 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>, Longueur_CM <dbl>, Forme_lame <chr>, Base_lame <chr>,
## # longeur_classe <chr>## # A tibble: 91 × 22
## # Groups: Name [5]
## Name Catalog TARL Quad Length Width Thickness B.Width J.Width H.Length
## <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 41-0237 41CV0493 16/62 54.2 21 8 17.2 13.1 11.5
## 2 Darl 35-2960 41CV0235 21/63 50.6 20.3 6.8 15.1 14.1 9.1
## 3 Darl 41-0323 41CV0536 26/59 48.5 18.7 6.9 14.7 13.4 9.2
## 4 Darl 35-2325 41CV0795 20/48 47.7 17.5 7.2 14.3 11.8 8.9
## 5 Darl 35-2004 41CV0187 24/62 47.6 20.3 8.1 17 14.7 12.3
## 6 Darl 35-3043 IF 20/63 44.2 23.3 7.2 15.3 12.1 12.2
## 7 Darl 41-0322 41CV0536 26/59 42.8 15.8 5.8 11.3 10.6 11.6
## 8 Darl 35-0164 41CV0869 22/66 42.3 19.2 7.7 NA 11.6 11.5
## 9 Darl 38-0736 41BL0866 28/45 42.2 14.6 6.6 NA 13.2 12.5
## 10 Darl 35-2959 41CV0235 21/63 41.8 16.8 4.1 12.7 11.5 11
## # ℹ 81 more rows
## # ℹ 12 more variables: Weight <dbl>, Blade.Sh <chr>, Base.Sh <chr>,
## # Should.Sh <chr>, Should.Or <chr>, Haft.Sh <chr>, Haft.Or <chr>,
## # Ratio_LW <dbl>, Longueur_CM <dbl>, Forme_lame <chr>, Base_lame <chr>,
## # longeur_classe <chr>summarise() avec group_by()
summarise() : calculer des statistiques par groupe C’est la combinaison group_by() + summarise() qui est la plus puissante
stats_par_type <- DartPoints %>%
group_by(Name) %>%
summarise(
n = n(), # effectif
long_moy = mean(Length, na.rm = TRUE), # longueur moyenne
long_sd = sd(Length, na.rm = TRUE), # écart-type
poids_med = median(Weight, na.rm = TRUE), # poids médian
poids_max = max(Weight, na.rm = TRUE) # poids maximal
)
stats_par_type## # A tibble: 5 × 6
## Name n long_moy long_sd poids_med poids_max
## <chr> <int> <dbl> <dbl> <dbl> <dbl>
## 1 Darl 28 39.8 6.18 4.1 9.2
## 2 Ensor 10 42.7 5.79 4.9 7.2
## 3 Pedernales 32 57.9 14.1 10.6 28.8
## 4 Travis 11 51.4 9.90 7.5 15
## 5 Wells 10 53.1 7.94 8.3 16.3Visualiser avec ggplot2
Qu’est-ce que ggplot2 ?
ggplot2 est un package R développé par Hadley Wickham, basé sur la grammaire des graphiques de Leland Wilkinson. Il permet de créer des visualisations complexes à partir de composants simples et modulaires, facilitant ainsi la compréhension, la personnalisation et l’extension des graphiques.
Les 7 composants essentiels d’un graphique ggplot2
Un graphique ggplot2 est construit à partir de sept éléments principaux :
Données : Le jeu de données utilisé pour la visualisation. Il est recommandé d’utiliser un format de données “tidy”, où chaque variable est une colonne et chaque observation est une ligne.
Mapping esthétique (aesthetics) : La correspondance entre les variables du jeu de données et les attributs visuels du graphique (par exemple, les axes, la couleur, la taille, la forme).
Couches (layers) : Les éléments visuels du graphique, tels que les points (geom_point()), les lignes (geom_line()), les barres (geom_bar()), etc. Chaque couche peut inclure :
Géométrie : La forme des objets graphiques.
Transformation statistique : Des calculs statistiques appliqués aux données.
Ajustement de position : La manière dont les objets sont positionnés sur le graphique.
Échelles (scales) : La gestion des axes et des légendes, permettant de contrôler la façon dont les données sont transformées en éléments visuels.
Facettes (facets) : La division du graphique en sous-graphes, facilitant la comparaison de sous-ensembles de données.
Coordonnées (coordinates) : Le système de coordonnées utilisé pour positionner les éléments graphiques (par exemple, coordonnées cartésiennes, polaires).
Thème (theme) : La personnalisation de l’apparence du graphique, incluant les éléments non liés aux données, tels que les titres, les couleurs de fond, les polices, etc.
library(ggplot2)
#Données
graphique1<-ggplot(DartPoints) +
#mapping : On relie les colonnes du tableau aux éléments graphiques.
aes(x = Length, y = Weight, color = Name) +
# On choisit la forme du graphique :
#ici un nuage de points avec une taille à 2 et une transparence de 0.7
geom_point(size = 2, alpha = 0.7) +
# geom_smooth(method = "lm", se = FALSE) + # On peut ajouter une courbe de tendance
# Pour séparer les graphiques selon un facteur (ex. : Blade.Sh)
facet_wrap(~ Name) +
# Permet de personnaliser les couleurs, tailles, axes...
scale_color_brewer(palette = "Set1") +
labs(title = "Longueur vs Poids des pointes selon la forme de lame",
x = "Longueur (mm)",
y = "Poids (g)",
color = "Type de pointe") +
#Pour personnaliser l’apparence
theme_minimal()
#install.packages("svglite")
library(svglite)
# Sauvegarder le graphique stocké dans l'objet graphique1 en format .svg
# l'extension voulue est prisée dans le nom du ficher
ggsave("graphique1.svg",
units = "cm",
width = 40,
height = 20,
dpi=700)Excercie d’application
On souhaite visualiser la répartition des longueurs (Length) selon le type de pointe
# Histogramme des longueurs par type de pointe
DartPoints %>%
ggplot(aes(x = Length, fill = Name)) +
geom_histogram(binwidth = 20, color = "white") +
labs(title = "Distribution des longueurs par type de pointe",
x = "Longueur (mm)",
y = "Nombre de pointes") +
theme_minimal()
Ce que fait ce code : - DartPoints %>% : on passe le jeu de données directement à ggplot() grâce au pipe. - aes(x = Length, fill = Name) : on affiche les longueurs, colorées selon le type de pointe. - geom_histogram() : trace l’histogramme. - binwidth = 20 : définit la largeur des barres. - labs() : ajoute un titre et les étiquettes des axes. - theme_minimal() : rend le graphique plus lisible
Box plot
DartPoints %>%
ggplot(aes(x = Name, y = Weight, fill = Name)) +
geom_boxplot() +
labs(title = "Poids des pointes par type",
x = "Type de pointe",
y = "Poids (g)") +
theme_minimal() +
theme(legend.position = "none")
#Boxplot + moyenne par groupe
DartPoints %>%
ggplot(aes(x = Name, y = Weight, fill = Name)) +
geom_boxplot(alpha = 0.6, varwidth = TRUE) +
stat_summary(fun = mean, geom = "point", shape = 20, size = 3, color = "black") +
labs(title = "Poids des pointes par type (moyenne en noir)",
x = "Type de pointe",
y = "Poids (g)") +
theme_minimal() +
theme(legend.position = "none")
## Violin plot Pour visualiser la forme de la distribution
DartPoints %>%
ggplot(aes(x = Name, y = Weight, fill = Name)) +
geom_violin(trim = FALSE) +
labs(title = "Distribution du poids (violin plot)",
x = "Type de pointe",
y = "Poids (g)") +
theme_minimal() +
theme(legend.position = "none")
Graphique combiné (violin + boxplot + moyenne)
DartPoints %>%
ggplot(aes(x = Name, y = Weight, fill = Name)) +
geom_violin(trim = FALSE, alpha = 0.4, color = NA) + # forme de la distribution
#geom_boxplot(width = 0.2, outlier.shape = NA, alpha = 0.6, color = "grey30") + # résumé statistique
stat_summary(fun = mean, geom = "point", shape = 20, size = 3, color = "black") + # moyenne
labs(title = "Distribution du poids par type de pointe",
x = "Type de pointe",
y = "Poids (g)") +
theme_minimal() +
theme(legend.position = "none")
Comparer le poids en fonction de la longueur →
Nuage de points
ggplot(DartPoints) +
geom_point(aes(x = Length, y = Weight, color = Name),size = 2, alpha = 0.7) +
labs(title = "Relation entre longueur et poids",
x = "Longueur (mm)",
y = "Poids (g)") +
theme_minimal()
##
ggplot(DartPoints)+
aes(x = Length, y =Width , color = Name, size = Thickness, alpha = Weight)+
geom_point() +
labs(title = "Relation entre longueur et poids",
x = "Longueur (mm)",
y = "Poids (g)") +
theme_minimal()
# Répartition d’une variable qualitatif # Diagramme en barres
ggplot(DartPoints) +
geom_bar(aes(x = Base_lame, fill = Base_lame)) +
labs(title = "Formes de lames (Base_lame)",
x = "Forme de lame",
y = "Nombre de pointes") +
theme_minimal() +
theme(legend.position = "none")
# Faceting
Le faceting permet d’effectuer plusieurs fois le même graphique selon les valeurs d’une ou plusieurs variables qualitatives.
ggplot(DartPoints) +
geom_boxplot(aes(x = Length, col=Name)) +
theme_minimal() +
theme(legend.position = "none")+
facet_wrap(vars(Name))
ggplot(DartPoints) +
geom_boxplot(aes(x = Length, col=Name)) +
theme_minimal() +
theme(legend.position = "left")+
facet_grid(vars(Name))
# Exercice – Visualisation des caractéristiques des pointes de
projectile Vous travaillez sur des pointes de projectile issues du site
archéologique de Fort Hood. Vous allez explorer graphiquement leur
morphologie (longueur, poids, largeur…) et chercher à identifier des
différences selon leur type (Name) et la forme de lame (Blade.Sh). -
Visualisez la relation entre la longueur (Length) et le poids (Weight)
des pointes. Colorez les points selon le type de pointe (Name). -
Ajoutez une droite de régression linéaire pour chaque type. - Créez un
graphique par forme de lame (Blade.Sh), en utilisant facet_wrap(). -
Ajoutez un titre, des noms d’axes, et un thème plus lisible. - Créez une
nouvelle variable représentant le ratio longueur / largeur, et comparez
ce ratio par type de pointe avec un boxplot.
Analyse spatiale d’un campement paléolithique
Imaginez que vous fouillez un campement préhistorique. À chaque fois que vous trouvez un objet, vous notez ses coordonnées X et Y en mètres sur votre carroyage. L’objectif n’est plus de faire des moyennes, mais de comprendre l’organisation de l’espace : où se trouvait l’atelier de taille de silex ? Où se trouvait la zone de boucherie (ossements) ?
Pour cette démonstration, nous allons générer un jeu de données de 300 objets directement dans R, puis créer une carte de concentration.
# Chargement de l'extension graphique
library(ggplot2)
# Simulation des données archéologiques (Génération aléatoire pour l'exemple)
# On simule 200 silex concentrés autour du point X=10, Y=15 (L'atelier de taille)
x_silex <- rnorm(200, mean = 10, sd = 2)
y_silex <- rnorm(200, mean = 15, sd = 2)
type_silex <- rep("Silex", 200)
# On simule 100 ossements concentrés autour du point X=18, Y=8 (Zone de rejet/boucherie)
x_os <- rnorm(100, mean = 18, sd = 3)
y_os <- rnorm(100, mean = 8, sd = 2)
type_os <- rep("Ossement", 100)
# Regroupement dans un Data Frame
fouilles_spatiales <- data.frame(
X_metre = c(x_silex, x_os),
Y_metre = c(y_silex, y_os),
Type = c(type_silex, type_os)
)
# ÉTAPE 1 : Le plan de répartition classique (Nuage de points)
graphique_points <- ggplot(fouilles_spatiales, aes(x = X_metre, y = Y_metre, color = Type)) +
geom_point(size = 2, alpha = 0.7) +
theme_minimal() +
labs(title = "Plan de répartition des vestiges",
subtitle = "Chaque point représente un objet",
x = "Coordonnée X (m)",
y = "Coordonnée Y (m)")
# Afficher le premier graphique
print(graphique_points)
# 5. ÉTAPE 2 : L'analyse de concentration (Carte de densité / Heatmap)
graphique_concentration <- ggplot(fouilles_spatiales, aes(x = X_metre, y = Y_metre)) +
geom_density_2d_filled(alpha = 0.8) + # Crée les zones de chaleur
geom_point(color = "white", size = 0.5) + # Rajoute les objets par-dessus en tout petit
theme_minimal() +
labs(title = "Analyse spatiale : Zones de concentration",
subtitle = "Mise en évidence des « hotspots » d'activité humaine",
x = "Coordonnée X (m)",
y = "Coordonnée Y (m)",
fill = "Niveau de densité")
# Afficher le second graphiquei)
print(graphique_concentration)
##
## Attaching package: 'maps'## The following object is masked from 'package:purrr':
##
## map# 2. On garde nos données de base (fragments et profondeurs)
sites <- c("Site1", "Site2", "Site3", "Site4", "Site5")
fragments <- c(23, 17, 34, 28, 12)
profondeur_cm <- c(120, 135, 110, 125, 140)
# 3. NOUVEAUTÉ : Coordonnées GPS situées en Irak
# (Ex : région de Mossoul, Erbil, Bagdad, Nassiriya/Ur, Bassorah)
longitude <- c(43.15, 44.01, 44.36, 46.25, 47.78)
latitude <- c(36.34, 36.19, 33.31, 31.04, 30.50)
# 4. On recrée notre Data Frame
bilan_fouilles <- data.frame(sites, fragments, profondeur_cm, longitude, latitude)
# 5. NOUVEAUTÉ : Récupération du fond de carte de l'Irak
# On prend la carte du monde et on filtre sur "Iraq" (en anglais dans la base de données)
carte_irak <- map_data("world", region = "Iraq")
#map_data("world", region = c("Iraq", "Syria")) (Astuce : vous pouvez même afficher plusieurs pays d'un coup pour une carte régionale !)
#unique(map_data("world")$region)
# 6. Création de la carte archéologique
carte_archeo <- ggplot() +
# A. Le fond de carte (couleur sable)
geom_polygon(data = carte_irak, aes(x = long, y = lat, group = group),
fill = "#e8d8c3", color = "white") +
# B. L'ajout de nos 5 sites mésopotamiens
geom_point(data = bilan_fouilles,
aes(x = longitude, y = latitude, size = fragments, color = profondeur_cm),
alpha = 0.9) +
# C. L'ajout des étiquettes
geom_text(data = bilan_fouilles,
aes(x = longitude, y = latitude, label = sites),
vjust = -1.5, fontface = "bold") +
# D. Les finitions esthétiques
scale_size_continuous(range = c(4, 10)) +
scale_color_gradient(low = "royalblue", high = "firebrick") +
coord_quickmap() +
theme_void() +
labs(title = "Cartographie de la campagne en Mésopotamie",
subtitle = "Répartition des sites fouillés en Irak",
size = "Nb de fragments",
color = "Profondeur (cm)")
# 7. Affichage de la carte
print(carte_archeo)
Remarque
La limite de library(maps) en archéologie maps dessine des frontières politiques. C’est parfait pour des cartes de répartition simples. Cependant, en archéologie, on a souvent besoin de topographie (les montagnes, les fleuves) ou de fonds de carte type OpenStreetMap / Satellite
Cartographie interactive en Irak avec OpenStreetMap
Les polygones colorés, c’est bien pour les statistiques. Mais sur le terrain, vous avez besoin de voir la topographie, les fleuves environnants ou les villes modernes proches de vos fouilles. Nous allons donc utiliser leaflet pour projeter nos 5 sites irakiens sur un vrai fond de carte OpenStreetMap. Et cerise sur le gâteau : la carte sera interactive !”
# 1. Chargement du package pour les cartes interactives
library(leaflet)
# 2. Notre jeu de données irakien (toujours le même !)
sites <- c("Site1", "Site2", "Site3", "Site4", "Site5")
fragments <- c(23, 17, 34, 28, 12)
profondeur_cm <- c(120, 135, 110, 125, 140)
longitude <- c(43.15, 44.01, 44.36, 46.25, 47.78)
latitude <- c(36.34, 36.19, 33.31, 31.04, 30.50)
# On rassemble tout dans le data frame
bilan_fouilles <- data.frame(sites, fragments, profondeur_cm, longitude, latitude)
# --- FIN DE LA PRÉPARATION DES DONNÉES ---
# 3. Création de la carte interactive
carte_interactive <- leaflet(data = bilan_fouilles) %>%
# A. Ajout du fond de carte "OpenStreetMap" (Réseau routier, villes, fleuves)
addTiles() %>%
# B. Ajout de nos sites archéologiques sous forme de cercles
addCircleMarkers(
lng = ~longitude, # Le ~ indique à R de chercher la colonne dans le data.frame
lat = ~latitude,
# La taille du cercle dépend du nombre de fragments (on divise par 2 pour l'esthétique)
radius = ~fragments / 2,
# Couleur et opacité
color = "darkred",
fillOpacity = 0.7,
# L'interactivité : ce qui s'affiche quand on clique sur le site !
popup = ~paste("<b>", sites, "</b><br>",
"Fragments trouvés : ", fragments, "<br>",
"Profondeur moyenne : ", profondeur_cm, " cm")
)
# 4. Affichage de la carte (Elle s'ouvrira dans l'onglet "Viewer" en bas à droite de RStudio)
carte_interactive# 3. Création de la carte interactive avec sélecteur de fonds
carte_multi <- leaflet(data = bilan_fouilles) %>%
# --- LES FONDS DE CARTE ---
# Fond 1 : Plan routier classique (OpenStreetMap)
addTiles(group = "Plan (OSM)") %>%
# Fond 2 : Vue Satellite (Très utile pour repérer les sites de fouilles)
addProviderTiles(providers$Esri.WorldImagery, group = "Satellite (ESRI)") %>%
# Fond 3 : Carte Topographique (Reliefs et courbes de niveau)
addProviderTiles(providers$OpenTopoMap, group = "Topographie") %>%
# --- LES SITES ARCHÉOLOGIQUES ---
addCircleMarkers(
lng = ~longitude,
lat = ~latitude,
radius = ~fragments / 2,
color = "darkred",
fillOpacity = 0.8,
popup = ~paste("<b>", sites, "</b><br>",
"Fragments : ", fragments, "<br>",
"Profondeur : ", profondeur_cm, " cm")
) %>%
# --- LE MENU DE CONTRÔLE ---
addLayersControl(
baseGroups = c("Plan (OSM)", "Satellite (ESRI)", "Topographie"),
options = layersControlOptions(collapsed = FALSE) # Le menu reste ouvert
)
# 4. Affichage de la carte
carte_multiIl est possible d’avoir une vue satellite (très demandée en archéologie pour voir les traces dans le paysage), iet il suffit de remplacer addTiles() par addProviderTiles(providers$Esri.WorldImagery). La carte passera instantanément en vue spatiale !
Jointure de tables
Une jointure de tables en R consiste à combiner deux tables (data frames) en fonction d’une ou plusieurs colonnes communes, comme Catalog, ou toute autre variable qui permet d’identifier de manière unique les lignes dans les deux tables.
Types de jointures dans dplyr
Inner Join (jointure interne) : Elle garde uniquement les lignes ayant des correspondances dans les deux tables.
Left Join (jointure à gauche) : Elle garde toutes les lignes de la première table et ajoute les données correspondantes de la deuxième table. Les lignes sans correspondance auront des NA dans les colonnes de la deuxième table.
Right Join (jointure à droite) : Elle garde toutes les lignes de la deuxième table et ajoute les données correspondantes de la première table. Les lignes sans correspondance auront des NA dans les colonnes de la première table.
Full Join (jointure complète) : Elle garde toutes les lignes des deux tables, avec des NA pour les données manquantes de l’une ou l’autre des tables.
Exemple
Importer le fichier catalog_info.csv.
Effectuer la la jointure avec DartPoints sur le numéro Catalog
## New names:
## Rows: 10 Columns: 4
## ── Column specification
## ──────────────────────────────────────────────────────── Delimiter: "," chr
## (2): Catalog, Archeologue dbl (1): ...1 date (1): Date_fouille
## ℹ Use `spec()` to retrieve the full column specification for this data. ℹ
## Specify the column types or set `show_col_types = FALSE` to quiet this message.
## • `` -> `...1`View(catalog_info)
DartPoints_joined <- merge(DartPoints, catalog_info, by = "Catalog")
head(DartPoints_joined[, c("Catalog", "Name", "Date_fouille", "Archeologue")])## Catalog Name Date_fouille Archeologue
## 1 35-2325 Darl 2023-04-09 Dr. Lopez
## 2 35-2866 Darl 2023-04-07 Dr. Smith
## 3 35-2921 Darl 2023-04-03 Dr. Chen
## 4 35-2946 Darl 2023-04-02 Dr. Lee
## 5 35-2959 Darl 2023-04-06 Dr. Martin
## 6 36-3321 Darl 2023-04-05 Dr. LeeRemplacement de valeurs manquantes
Il existe plusieurs manières de remplir (ou remplacer) les données manquantes (valeurs NA) dans un jeu de données en R, en fonction de la méthode que vous souhaitez utiliser. Voici quelques-unes des approches les plus courantes :
# Exemple : Remplacer les NAs par 0 dans une colonne spécifique
DartPoints_NA_55555 <- DartPoints %>%
mutate(Length = ifelse(is.na(Length), 0, Length),
B.Width_No_NA =ifelse(is.na(B.Width), 55555,B.Width)) %>%
select(B.Width,B.Width_No_NA)
#remplacement par la moyenne
DartPoints_NA_mean <- DartPoints %>%
mutate(Length = ifelse(is.na(Length), 0, Length),
B.Width_No_NA =ifelse(is.na(B.Width),mean(B.Width,na.rm=TRUE),B.Width))%>%
select(B.Width,B.Width_No_NA)Export de données
Export de tableaux de données
On peut avoir besoin d’exporter un tableau de données dans R vers un fichier dans différents formats. La plupart des fonctions d’import disposent d’un équivalent permettant l’export de données. On citera notamment :
write_csv,write_csv2,write_tsvpermettent d’enregistrer un data frame ou un tibble dans un fichier au format texte délimité
Il n’existe par contre pas de fonctions permettant d’enregistrer
directement au format xls ou xlsx. On peut
dans ce cas passer par un fichier CSV.
Sauvegarder des objets
Une autre manière de sauvegarder des données est de les enregistrer
au format RData. Ce format propre à R est compact, rapide,
et permet d’enregistrer plusieurs objets R, quel que soit leur type,
dans un même fichier.
Pour enregistrer des objets, il suffit d’utiliser la fonction
save et de lui fournir la liste des objets à sauvegarder et
le nom du fichier :
Pour charger des objets préalablement enregistrés, utiliser
load :
Les objets DartPoints, DartPoints_xlsx
etDartpoints_sep_virgule devraient alors apparaître dans
votre environnement.
Attention, quand on utilise load, les objets chargés
sont importés directement dans l’environnement en cours avec leur nom
d’origine. Si d’autres objets du même nom existent déjà, ils sont
écrasés sans avertissement.
Une alternative est d’utiliser les fonctions saveRDS et
readRDS, qui permettent d’enregistrer un unique objet, et
de le charger dans notre session avec le nom que l’on souhaite.
Références
🌐 Références en ligne utiles pour R
Voici une sélection de ressources fiables pour apprendre et approfondir vos connaissances en R.
📘 Documentation officielle et tutoriels
- CRAN – R Project : Site officiel du langage R (documentation, manuels, téléchargements).
- R for Data
Science : Livre en ligne gratuit, idéal pour apprendre
tidyverse,ggplot2,dplyr, etc. - Tidyverse.org : Documentation et actualité des packages modernes en R.
📊 Visualisation de données
- ggplot2 (site officiel) : Documentation complète, articles et exemples.
- R Graph
Gallery : Exemples visuels de graphiques avec
ggplot2,base R,plotly, etc.
🎓 Apprentissage en ligne
- Coursera – Data Science with R (Johns Hopkins) : Série de cours pratiques avec exercices.
- Swirl : Apprendre R directement dans la console.
- Stats and R : Tutoriels accessibles en français et anglais.
🧠 Aide et documentation rapide
- Cheat
Sheets RStudio : Fiches mémo (
ggplot2,dplyr,tidyr, etc.). - Stack Overflow – R : Forum d’entraide pour résoudre les erreurs ou problèmes.
🔍 Recherche de fonctions et packages
- RDocumentation.org : Moteur de recherche pour la documentation R.
- R Bloggers : Articles quotidiens, tutoriels, et actualités autour de R.
Comment installer R et RStudio
Les deux logiciels libres et gratuits sont téléchargeables en ligne et fonctionnant sous PC, Mac et Linux. Pour installer R, il suffit de se rendre sur une des pages suivantes :
Pour installer RStudio, rendez-vous sur la page de téléchargement du logiciel et installez la version adaptée à votre système.
La console
Au premier lancement de RStudio, l’interface est organisée en trois grandes zones.
Console.Consoleaffiche des informations sur la session, suivi par la ligne del'invite de commande(ouprompten anglais) : le caractère>avec votre curseur|. Elle signifie que R est disponible et en attente de votre prochaine instruction.Nous pouvons tout de suite commencer à interagir et saisir des exemples de calculs simples, en saisissant les lignes suivantes puis en appuyant sur
Entrée:Remarque
les espaces autour des opérateurs n’ont pas d’importance.