Dans cette introduction, nous allons découvrir les bases du langage de programmation R.
Tout d’abord, tout le texte précédé par le signe # est ce qu’on appelle un commentaire.
# commentaireCe sont des lignes qui ne seront pas exécutées par le code et qui nous permettrons de décrire les étapes du script. Bien commenter son code est très important car cela nous permet de le comprendre facilement même après des mois et des années sans y avoir travaillé (en théorie !). Cela nous permet aussi de le partager avec d’autres personnes, pour qu’elles comprennent tout de suite notre démarche.
Un point important qu’il faut comprendre est que le language R dit “de base” permet de faire beaucoup de choses, mais qu’il existe aussi des extensions de fonctionnalité qui sont très largement utilisée: celle du tidyverse - contraction de tidy (“bien rangé”) et de universe. Il s’agit d’une collection de bibliothèques/extensions conçues dans une philosophie commune. Elles abordent un très grand nombre d’opérations courantes dans R dont :
- l’import/export de données
- la manipulation des tableaux de données
- la manipulation de variables
- la visualisation
- l’extraction de données du web
- la programmation
L’un des objectifs de ces extensions est de fournir des fonctions avec une syntaxe cohérente, qui fonctionnent bien ensemble, et qui retournent des résultats prévisibles. Elles sont en grande partie issues du travail d’Hadley Wickham.
Nous allons travailler ici avec un jeu de données fictif appelé Data_exemple.
Il s’agit d’un tableau décrivant plusieurs données qualitatives, quantitatives et spatiales de l’industrie lithique d’une collection.
Les jeux de données utilisés dans le cadre de ce workshop sont stockés dans le dossier data du répertoire cloné (“téléchargé”) depuis github R-pour-archeologues. Nous avons ouvert le fichier R-pour-archeologues.Rproj afin de travailler au sein d’un environnement commun à tou-te-s, ce qui nous permet d’avoir un même dossier actif au démarrage de R. Cela sera utile pour charger les jeux de données et sauvegarder les résultats de nos productions dans cet espace.
Il existe deux manières d’ouvrir un jeu de données:
- en utilisant le pointer-cliquer
- en utilisant des commandes.
Nous allons commencer par ouvrir le jeu de données Data_exemple en utilisant le bouton Import dataset dans l’onglet Environnement en haut à droite:
1- Choisir le fichier dans le répertoire avec le bouton browse:
…/R-pour-archeologues/data/Data_exemple.xlsx
2- Dans cette même fenêtre dans la section import options il est possible de spécifier le nom du jeu de données qui sera stocké dans R: appelez le “jdd”.
Cette procédure permet d’importer un tableau excel.
Préférez l’utilisation du code afin de rendre l’ensemble de la procédure reproductible.
Dans l’idéal il convient d’importer un tableau depuis excel (ou autre programme) à partir de CSVs (comma-separated-values), qui est un format simple, non-propriétaire (qui ne nécessite pas d’être lu par un logiciel particulier (et la plupart du temps payant), en texte simple (“plain-text”), qui permet à la fois d’être lu par l’humain, traité par la machine, et convient au stockage de données organisées en colonnes/lignes).
Point important : dans les tableaux, éviter les espaces ( ) et les parenthèses ( ( ou ) ), car R va interpréter ces blancs et automatiquement les remplacer par des signes (essentiellement .).
Dans R on peut charger et lire un jeu de données avec la fonction de base read.csv()
jdd <- read.csv("data/data_exemple.csv")
# attention à bien vérifier quel séparateur est utilisé : "," ";" ou "tab"
# par défaut read.csv() va estimer que le séparateur est un ",".
# si ce n'est pas le cas préciser avec la commande "sep =" comme suit:
jdd <- read.csv("data/data_exemple.csv", sep = ",")
# si l'on développe:
# on peut préciser :
jdd <- read.csv( # ouverture de la fonction read.csv()
"data/data_exemple.csv", # le chemin du fichier
header = TRUE, # si la première ligne contient le titre des col
sep=",", # le séparateur (, ou ; ou autre, c'est selon..)
) # fermeture de la fonction read.csv()Des données dans d’autres format peuvent être lues avec la fonction read.table()
# par défaut read.table() va estimer que le séparateur est une tabulation.
# il convient donc de préciser que le séparateur est une virgule avec sep = ""
# avec read.table() préciser également header = TRUE pour indiquer que la première
# ligne correspond au nom des colonnes
jdd <- read.table("data/data_exemple.txt", sep = ",", header = TRUE)Pour ouvrir des fichiers au format Microsoft Excel on peut utiliser les fonctions de la bibliothèque readxl: read_excel(),read_xls(), read_xlsx(), par exemple :
#install.packages("readxl")
library(readxl)
jdd <- read_xlsx("data/data_exemple.xlsx")Des tables enregistrées au format OpenDocument peuvent être lues grace à la fonction readODS().
Bien vérifier que la classe des variables correspond à la réalité des informations:
jdd## # A tibble: 33 × 8
## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## <dbl> <chr> <dbl> <dbl> <chr> <chr> <chr> <dbl>
## 1 1 gravette 10 60 5 1.5 type A NA
## 2 2 gravette 30 50 5.9 1.8 type C NA
## 3 3 picardie 50 80 3.2 1.2 type B 1
## 4 4 percoir 260 100 4.7 2.1 type B NA
## 5 5 burin 240 120 6 2.4 type B 2
## 6 6 burin diedre 280 150 8 3.5 type A NA
## 7 7 percoir 250 130 5.6 3.8 type A NA
## 8 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 9 9 chute de burin 230 280 2 0.5 type A 2
## 10 10 nucleus a lames 180 290 10.2 6.9 type A NA
## # … with 23 more rows# changeons la classe des colonnes "x_cm", "y_cm", "longueur_cm" et "largeur_cm"
# car elles contiennent des données numériques.
# pour cela utilisons lq fonction lapply() qui qpplique une boucle sur une
# structure de type liste (d'où le "l" devant apply).
# associons-y la fonction as.numeric()
jdd[,3:6] <- lapply(jdd[,3:6], as.numeric)# On peut aussi spécifier la classe des différentes colonnes dès l'importation
# avec la fonction colClasses() :
jdd <- read.table("data/data_exemple.txt", sep = ",", header = TRUE,
colClasses = c(numero = "numeric",
type = "character",
x_cm = "numeric",
y_cm = "numeric",
longueur_cm = "numeric",
largeur_cm = "numeric",
silex = "character",
raccord = "numeric"
))
# A noter qu'en utilisant le format .csv le problème d'attribution de classe
# n'existe pas,
# et que la fonction colClasses() n'est pas compatible avec read_xlsx() !Vous venez d’ouvrir le tableau dans R et il a été stocké dans un objet que l’on a appelé jdd.
Pour explorer ce jeu de données il est possible d’utiliser le pointer-cliquer en cliquant sur la ligne jdd, située la section Data du panneau en haut à droite (onglet Environment).
Mais préférez là aussi le code: soit avec la commande view(jdd) (même résultat que précédemment avec le pointer-cliquer)
view(jdd)ou simplement en utilisant la commande jdd (nom du jeu de données) pour afficher le contenu du tableau dans la console
jdd## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 1 1 gravette 10 60 5.0 1.5 type A NA
## 2 2 gravette 30 50 5.9 1.8 type C NA
## 3 3 picardie 50 80 3.2 1.2 type B 1
## 4 4 percoir 260 100 4.7 2.1 type B NA
## 5 5 burin 240 120 6.0 2.4 type B 2
## 6 6 burin diedre 280 150 8.0 3.5 type A NA
## 7 7 percoir 250 130 5.6 3.8 type A NA
## 8 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 9 9 chute de burin 230 280 2.0 0.5 type A 2
## 10 10 nucleus a lames 180 290 10.2 6.9 type A NA
## 11 11 lame 80 90 10.0 2.8 type A NA
## 12 12 lame 50 70 8.5 2.7 type A NA
## 13 13 lame 20 50 9.2 3.1 type A NA
## 14 14 lame 10 90 7.4 2.4 type A NA
## 15 15 lame 30 80 6.9 1.4 type A NA
## 16 16 lame 40 50 9.8 3.1 type A NA
## 17 17 lame 50 60 6.7 1.4 type A NA
## 18 18 lame 80 100 7.4 1.9 type A NA
## 19 19 eclat 190 250 2.3 2.0 type A NA
## 20 20 eclat 200 300 5.9 3.4 type A NA
## 21 21 eclat 280 350 8.4 5.9 type A NA
## 22 22 eclat 250 360 6.2 6.1 type A NA
## 23 23 eclat 260 390 4.5 3.6 type A NA
## 24 24 eclat 210 340 9.5 7.1 type A NA
## 25 25 eclat 230 370 5.8 4.2 type A NA
## 26 26 eclat 270 330 6.1 3.9 type A NA
## 27 27 eclat 240 350 4.8 3.7 type A NA
## 28 28 eclat 290 360 2.5 2.0 type A NA
## 29 29 eclat 250 390 3.4 2.8 type A NA
## 30 30 eclat 280 370 1.9 1.2 type A NA
## 31 31 eclat 260 300 4.6 2.8 type A NA
## 32 32 eclat 210 290 1.4 1.0 type A NA
## 33 33 eclat 200 280 2.3 2.2 type A NAAfin de ne pas encombrer la console, il est aussi possible de n’afficher que les 6 premières lignes du tableau avec la commande head()
head(jdd)## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 1 1 gravette 10 60 5.0 1.5 type A NA
## 2 2 gravette 30 50 5.9 1.8 type C NA
## 3 3 picardie 50 80 3.2 1.2 type B 1
## 4 4 percoir 260 100 4.7 2.1 type B NA
## 5 5 burin 240 120 6.0 2.4 type B 2
## 6 6 burin diedre 280 150 8.0 3.5 type A NAUn data frame est un type d’objet R correspondant à un tableau. Il existe plusieurs classes que nous découvrirons au fur et à mesure.
On peut vérifier la classe d’objet de jdd avec la commande class(jdd). class() est une fonction. C’est une opération qui sera appliquée à un objet. La fonction class() permet d’afficher la classe de l’objet auquel on applique cette fonction.
class(jdd)## [1] "data.frame"Lorsque l’on ne comprends pas l’objectif d’une fonction ou que l’on a oublié, on peut demander de l’aide avec la fonction help() ou plus simplement ?class.
?class
help(class) # notez que ces deux commandes ont le même résultat.Si l’on souhaite obtenir des informations statistiques générales sur les différentes dimensions du tableau. On utilise la fonction summary() pour obtenir des informations basiques telles que le min/max/moyenne etc de chaque variable de classe numérique.
summary(jdd)## numero type x_cm y_cm longueur_cm
## Min. : 1 Length:33 Min. : 10.0 Min. : 50.0 Min. : 1.4
## 1st Qu.: 9 Class :character 1st Qu.: 50.0 1st Qu.: 90.0 1st Qu.: 4.5
## Median :17 Mode :character Median :210.0 Median :280.0 Median : 5.9
## Mean :17 Mean :174.8 Mean :217.6 Mean : 5.8
## 3rd Qu.:25 3rd Qu.:260.0 3rd Qu.:340.0 3rd Qu.: 7.4
## Max. :33 Max. :290.0 Max. :390.0 Max. :10.2
##
## largeur_cm silex raccord
## Min. :0.500 Length:33 Min. :1.0
## 1st Qu.:1.900 Class :character 1st Qu.:1.0
## Median :2.800 Mode :character Median :1.5
## Mean :2.976 Mean :1.5
## 3rd Qu.:3.700 3rd Qu.:2.0
## Max. :7.100 Max. :2.0
## NA's :29On peut aussi afficher certaines informations sur les dimensions du tableau, comme le nombre de colonnes et de lignes par exemple
nrow(jdd) # nb de lignes## [1] 33ncol(jdd) # nb de colonnes ## [1] 8Pour vérifier le type de variable dans un tableau (ce sera important car certaines fonctions qui nécessitent un type spécifique de variable), on peut appliquer la fonction class() sur chaque variable que l’on associe au jeu de données avec l’opérateur $
class(jdd$type)## [1] "character"class(jdd$longueur)## [1] "numeric"La variable longueur est de classe numérique tandis que la variable type est de classe character. Or, pour que R traite des variables catégorielles, il faut utiliser le format factor. Nous allons donc convertir la variable type en un facteur avec la fonction factor().
jdd$type <- factor(jdd$type) # cette commande signifie au pied de la lettre :
# dans la colonne "type" du data frame "jdd", je
# mets la colonne "type" du data frame "jdd"
# au format "facteur"On vérifie que le code a bien fonctionné avec class()
class(jdd$type)## [1] "factor"Lorsque l’on modifie les données primaires, il est parfois préférable de créer une nouvelle colonne afin de garder une trace des données brutes
jdd$type_fac <- as.factor(jdd$type)
class(jdd$type_fac) # notez: même résultat que précédemment## [1] "factor"Nous pouvons à présent vérifier les différentes valeurs que peut prendre une variable catégorielle, par la fonction levels()
levels(jdd$type)## [1] "burin" "burin diedre" "burin du Raysse" "chute de burin"
## [5] "eclat" "gravette" "lame" "nucleus a lames"
## [9] "percoir" "picardie"Ces quelques fonctions sont utiles pour explorer les données et se rendre compte d’erreurs à un stade préliminaire.
https://gitlab.com/linogaliana/bigr/-/blob/master/04-datatable.Rmd
Tout d’abord voici quelques éléments de code de base dans le language R :
- <- est un “opérateurs d’assignation”, et s’utilise de telle manière que l’objet nommé à la gauche de ce signe correspond au résultat (output) du code à sa droite. C’est dans ce sens que l’on vient de l’utiliser plus haut avec par exemple jdd <- read.csv("data/data_exemple.csv")
- & signifie ET (AND) dans
- les opérateurs de base de la logique booléenne (logique à deux états, 0 et 1, qui permet d’analyser des décisions et de trier des jeux de données) sont “ET” &, “OU” |, et “NON” !
- les contenus de classe “character” (texte ou date) doivent être entrés en utilisant les guillements " ".
- les contenus de classe “numeric” ne sont pas entre guillemets.
- comme dans les formules d’excel, un ensemble de valeurs peut être défini en formant un vecteur en utilisant les deux points : au sein de la fonction c().
- les opérateurs logiques les plus communs:
+ ajouter
- soustraire
* multiplier
/ diviser
> et < pour plus grand/plus petit que
>= et <= pour plus grand ou égal à / plus petit ou égal à
!= pas égal à
== voir le/les objet(s) égal(aux) à… souvent utiliser pour sélectionner/filter des données
= fait qu’un objet est égal à une valeur donnée. fonctionne comme <-, mais à l’intérieur d’une fonction.
Il existe des fonctions très utiles dans le language R de base que l’on peut également passer avec les fonctions des bibliothèques data.table() et dplyr() du tydiverse.
#les lignes 3 à 5:
jdd[3:5, ]## numero type x_cm y_cm longueur_cm largeur_cm silex raccord type_fac
## 3 3 picardie 50 80 3.2 1.2 type B 1 picardie
## 4 4 percoir 260 100 4.7 2.1 type B NA percoir
## 5 5 burin 240 120 6.0 2.4 type B 2 burin#les colonnes 1 à 4 (ne montre que les 10 premières lignes):
jdd[ , 1:4]## numero type x_cm y_cm
## 1 1 gravette 10 60
## 2 2 gravette 30 50
## 3 3 picardie 50 80
## 4 4 percoir 260 100
## 5 5 burin 240 120
## 6 6 burin diedre 280 150
## 7 7 percoir 250 130
## 8 8 burin du Raysse 260 300
## 9 9 chute de burin 230 280
## 10 10 nucleus a lames 180 290
## 11 11 lame 80 90
## 12 12 lame 50 70
## 13 13 lame 20 50
## 14 14 lame 10 90
## 15 15 lame 30 80
## 16 16 lame 40 50
## 17 17 lame 50 60
## 18 18 lame 80 100
## 19 19 eclat 190 250
## 20 20 eclat 200 300
## 21 21 eclat 280 350
## 22 22 eclat 250 360
## 23 23 eclat 260 390
## 24 24 eclat 210 340
## 25 25 eclat 230 370
## 26 26 eclat 270 330
## 27 27 eclat 240 350
## 28 28 eclat 290 360
## 29 29 eclat 250 390
## 30 30 eclat 280 370
## 31 31 eclat 260 300
## 32 32 eclat 210 290
## 33 33 eclat 200 280#les cellules en 3e ligne, des colonnes 1 à 4:
jdd[3, 1:4]## numero type x_cm y_cm
## 3 3 picardie 50 80#les lignes pour lesquelles le contenu de la colonne "type" correspond exactement à "burin":
jdd[jdd$type == "burin", ]## numero type x_cm y_cm longueur_cm largeur_cm silex raccord type_fac
## 5 5 burin 240 120 6 2.4 type B 2 burin#toutes les lignes qui contiennent le mot "burin" dans la colonne "type":
jdd[grep("burin", jdd$type), ]## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 5 5 burin 240 120 6.0 2.4 type B 2
## 6 6 burin diedre 280 150 8.0 3.5 type A NA
## 8 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 9 9 chute de burin 230 280 2.0 0.5 type A 2
## type_fac
## 5 burin
## 6 burin diedre
## 8 burin du Raysse
## 9 chute de burin#toutes les lignes qui contiennent "burin" ou "lam" dans la colonne "type":
jdd[grep("burin|lam", jdd$type), ]## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 5 5 burin 240 120 6.0 2.4 type B 2
## 6 6 burin diedre 280 150 8.0 3.5 type A NA
## 8 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 9 9 chute de burin 230 280 2.0 0.5 type A 2
## 10 10 nucleus a lames 180 290 10.2 6.9 type A NA
## 11 11 lame 80 90 10.0 2.8 type A NA
## 12 12 lame 50 70 8.5 2.7 type A NA
## 13 13 lame 20 50 9.2 3.1 type A NA
## 14 14 lame 10 90 7.4 2.4 type A NA
## 15 15 lame 30 80 6.9 1.4 type A NA
## 16 16 lame 40 50 9.8 3.1 type A NA
## 17 17 lame 50 60 6.7 1.4 type A NA
## 18 18 lame 80 100 7.4 1.9 type A NA
## type_fac
## 5 burin
## 6 burin diedre
## 8 burin du Raysse
## 9 chute de burin
## 10 nucleus a lames
## 11 lame
## 12 lame
## 13 lame
## 14 lame
## 15 lame
## 16 lame
## 17 lame
## 18 lame#toutes les lignes qui contiennent des valeurs de longueur_cm inférieures à 2
subset(jdd, longueur_cm < 2)## numero type x_cm y_cm longueur_cm largeur_cm silex raccord type_fac
## 30 30 eclat 280 370 1.9 1.2 type A NA eclat
## 32 32 eclat 210 290 1.4 1.0 type A NA eclatdata.table()#install.packages("data.table")
library(data.table)##
## Attaching package: 'data.table'## The following objects are masked from 'package:dplyr':
##
## between, first, last## The following object is masked from 'package:purrr':
##
## transpose#toutes les lignes qui contiennent le mot "burin" dans la colonne "type":
jdd[jdd$type %like% "burin", ]## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 5 5 burin 240 120 6.0 2.4 type B 2
## 6 6 burin diedre 280 150 8.0 3.5 type A NA
## 8 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 9 9 chute de burin 230 280 2.0 0.5 type A 2
## type_fac
## 5 burin
## 6 burin diedre
## 8 burin du Raysse
## 9 chute de burin#toutes les lignes qui contiennent "burin" ou "lam" dans la colonne "type":
jdd[jdd$type %like% "burin|lam", ]## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 5 5 burin 240 120 6.0 2.4 type B 2
## 6 6 burin diedre 280 150 8.0 3.5 type A NA
## 8 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 9 9 chute de burin 230 280 2.0 0.5 type A 2
## 10 10 nucleus a lames 180 290 10.2 6.9 type A NA
## 11 11 lame 80 90 10.0 2.8 type A NA
## 12 12 lame 50 70 8.5 2.7 type A NA
## 13 13 lame 20 50 9.2 3.1 type A NA
## 14 14 lame 10 90 7.4 2.4 type A NA
## 15 15 lame 30 80 6.9 1.4 type A NA
## 16 16 lame 40 50 9.8 3.1 type A NA
## 17 17 lame 50 60 6.7 1.4 type A NA
## 18 18 lame 80 100 7.4 1.9 type A NA
## type_fac
## 5 burin
## 6 burin diedre
## 8 burin du Raysse
## 9 chute de burin
## 10 nucleus a lames
## 11 lame
## 12 lame
## 13 lame
## 14 lame
## 15 lame
## 16 lame
## 17 lame
## 18 lame#toutes les lignes qui contiennent des valeurs de longueur_cm inférieures à 2:
jdd[jdd$longueur_cm < 2, ]## numero type x_cm y_cm longueur_cm largeur_cm silex raccord type_fac
## 30 30 eclat 280 370 1.9 1.2 type A NA eclat
## 32 32 eclat 210 290 1.4 1.0 type A NA eclatdplyr() (bibliothèque du tidyverse)Téléchargeons et chargons l’ensemble des bibliothèques du tidyverse avec les commandes suivantes :
#install.packages("tidyverse")
#library(tidyverse)L’opérateur %>% est appelé pipe (anglais) et est issu de la bibliothèque magrittr. Il permet d’enchainer les fonctions sans les inclure les une dans les autres.
#les lignes pour lesquelles le contenu de la colonne "type" correspond exactement à "burin":
dplyr::filter(jdd, type == "burin")## numero type x_cm y_cm longueur_cm largeur_cm silex raccord type_fac
## 1 5 burin 240 120 6 2.4 type B 2 burin# ou avec le 'pipe':
jdd %>% dplyr::filter(type == "burin")## numero type x_cm y_cm longueur_cm largeur_cm silex raccord type_fac
## 1 5 burin 240 120 6 2.4 type B 2 burin#toutes les lignes qui contiennent le mot "burin" dans la colonne "type":
dplyr::filter(jdd, grepl("burin", type))## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 1 5 burin 240 120 6.0 2.4 type B 2
## 2 6 burin diedre 280 150 8.0 3.5 type A NA
## 3 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 4 9 chute de burin 230 280 2.0 0.5 type A 2
## type_fac
## 1 burin
## 2 burin diedre
## 3 burin du Raysse
## 4 chute de burin# ou avec le 'pipe':
jdd %>% dplyr::filter(grepl("burin", type))## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 1 5 burin 240 120 6.0 2.4 type B 2
## 2 6 burin diedre 280 150 8.0 3.5 type A NA
## 3 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 4 9 chute de burin 230 280 2.0 0.5 type A 2
## type_fac
## 1 burin
## 2 burin diedre
## 3 burin du Raysse
## 4 chute de burin#toutes les lignes qui contiennent "burin" ou "lam" dans la colonne "type":
dplyr::filter(jdd, grepl("burin|lam", type))## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 1 5 burin 240 120 6.0 2.4 type B 2
## 2 6 burin diedre 280 150 8.0 3.5 type A NA
## 3 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 4 9 chute de burin 230 280 2.0 0.5 type A 2
## 5 10 nucleus a lames 180 290 10.2 6.9 type A NA
## 6 11 lame 80 90 10.0 2.8 type A NA
## 7 12 lame 50 70 8.5 2.7 type A NA
## 8 13 lame 20 50 9.2 3.1 type A NA
## 9 14 lame 10 90 7.4 2.4 type A NA
## 10 15 lame 30 80 6.9 1.4 type A NA
## 11 16 lame 40 50 9.8 3.1 type A NA
## 12 17 lame 50 60 6.7 1.4 type A NA
## 13 18 lame 80 100 7.4 1.9 type A NA
## type_fac
## 1 burin
## 2 burin diedre
## 3 burin du Raysse
## 4 chute de burin
## 5 nucleus a lames
## 6 lame
## 7 lame
## 8 lame
## 9 lame
## 10 lame
## 11 lame
## 12 lame
## 13 lame# ou avec le 'pipe':
jdd %>% dplyr::filter(grepl("burin|lam", type))## numero type x_cm y_cm longueur_cm largeur_cm silex raccord
## 1 5 burin 240 120 6.0 2.4 type B 2
## 2 6 burin diedre 280 150 8.0 3.5 type A NA
## 3 8 burin du Raysse 260 300 5.3 3.8 type B 1
## 4 9 chute de burin 230 280 2.0 0.5 type A 2
## 5 10 nucleus a lames 180 290 10.2 6.9 type A NA
## 6 11 lame 80 90 10.0 2.8 type A NA
## 7 12 lame 50 70 8.5 2.7 type A NA
## 8 13 lame 20 50 9.2 3.1 type A NA
## 9 14 lame 10 90 7.4 2.4 type A NA
## 10 15 lame 30 80 6.9 1.4 type A NA
## 11 16 lame 40 50 9.8 3.1 type A NA
## 12 17 lame 50 60 6.7 1.4 type A NA
## 13 18 lame 80 100 7.4 1.9 type A NA
## type_fac
## 1 burin
## 2 burin diedre
## 3 burin du Raysse
## 4 chute de burin
## 5 nucleus a lames
## 6 lame
## 7 lame
## 8 lame
## 9 lame
## 10 lame
## 11 lame
## 12 lame
## 13 lame#toutes les lignes qui contiennent des valeurs de longueur_cm inférieures à 2:
dplyr::filter(jdd, longueur_cm < 2)## numero type x_cm y_cm longueur_cm largeur_cm silex raccord type_fac
## 1 30 eclat 280 370 1.9 1.2 type A NA eclat
## 2 32 eclat 210 290 1.4 1.0 type A NA eclat# avec les fonctions de base R :
aggregate(data = (subset(jdd, longueur_cm < 5)), largeur_cm ~ silex, FUN = mean)## silex largeur_cm
## 1 type A 2.18
## 2 type B 1.65# ou avec les fonctions de dplyr() et des 'pipes' :
jdd %>%
dplyr::filter(longueur_cm < 5) %>%
dplyr::group_by(silex) %>%
dplyr::summarise(mean(largeur_cm))## # A tibble: 2 × 2
## silex `mean(largeur_cm)`
## <chr> <dbl>
## 1 type A 2.18
## 2 type B 1.65FELICITATIONS ! Vous avez fait vos premiers pas sur R !!