242 lines
10 KiB
R
242 lines
10 KiB
R
# ==============================================================================
|
|
# TD5 : boite a outils
|
|
# Table fictive unites ; chaque outil en dplyr / ggplot2, puis en R base (sans package)
|
|
# ==============================================================================
|
|
|
|
library(dplyr)
|
|
library(tidyr)
|
|
library(ggplot2)
|
|
|
|
|
|
# Outil 0 : importer en precisant le type des colonnes, compter les NA ----
|
|
# colClasses impose le type : un code "01001" reste du texte (sinon il devient 1001)
|
|
codes <- read.csv(text = "
|
|
code,valeur
|
|
01001,3
|
|
2A004,5
|
|
", colClasses = c(code = "character"))
|
|
str(codes)
|
|
|
|
# La table fictive de la seance (tiree au hasard, toujours la meme grace a set.seed)
|
|
set.seed(1)
|
|
n <- 400
|
|
unites <- data.frame(code = sprintf("%03d", 1:n),
|
|
type = sample(c("petit", "moyen", "grand", "très grand"), n, replace = TRUE,
|
|
prob = c(0.5, 0.25, 0.15, 0.10)),
|
|
x = round(rlnorm(n, 3, 0.4), 1),
|
|
total = round(runif(n, 20, 2000)))
|
|
taux_a <- pmin(pmax(0.40 - 0.006 * unites$x + ifelse(unites$type == "très grand", 0.08, 0) +
|
|
rnorm(n, 0, 0.05), 0.02), 0.90)
|
|
unites$a <- round(unites$total * taux_a)
|
|
unites$b <- round(unites$total * (0.15 + 0.004 * unites$x + rnorm(n, 0, 0.03)))
|
|
unites$x[c(10, 77)] <- NA # deux mesures manquantes
|
|
unites$total[c(5, 120)] <- 0 # deux unites sans aucun total
|
|
unites$a[c(5, 120)] <- 0
|
|
unites$b[c(5, 120)] <- 0
|
|
head(unites)
|
|
|
|
# La part de NA dans chaque colonne : la moyenne des TRUE
|
|
colMeans(is.na(unites))
|
|
sum(unites$total == 0) # combien d'unites sans total
|
|
|
|
|
|
# Outil 1 : garder les lignes qui verifient plusieurs conditions ----
|
|
# & : les deux conditions ; ! : le contraire ; un total nul donnerait 0 / 0 = NaN
|
|
100 * 0 / 0 # NaN
|
|
is.na(NaN) # TRUE : is.na() repere aussi les NaN
|
|
|
|
# dplyr : filter() garde les lignes ou toutes les conditions sont vraies
|
|
utiles <- unites |> filter(!is.na(x), total > 0)
|
|
nrow(utiles)
|
|
|
|
# R base : df[condition, ] ; !is.na() evite des lignes de NA
|
|
garder <- !is.na(unites$x) & unites$total > 0
|
|
utiles_base <- unites[garder, ]
|
|
nrow(utiles_base)
|
|
|
|
|
|
# Outil 2 : creer des colonnes ----
|
|
utiles <- utiles |> mutate(taux_a = 100 * a / total,
|
|
taux_b = 100 * b / total)
|
|
|
|
# R base
|
|
utiles_base$taux_a <- 100 * utiles_base$a / utiles_base$total
|
|
utiles_base$taux_b <- 100 * utiles_base$b / utiles_base$total
|
|
|
|
|
|
# Outil 3 : cinq groupes de meme poids, avec order(), cumsum() et cut() ----
|
|
# Trier selon x, cumuler le poids (ici total), couper la part cumulee tous les 0,2
|
|
cumsum(c(5, 3, 2)) # 5 8 10 : la somme cumulee
|
|
# dplyr : arrange() range les lignes ; include.lowest = TRUE : 0 tombe dans le groupe 1
|
|
utiles <- utiles |>
|
|
arrange(x) |>
|
|
mutate(part_cumulee = cumsum(total) / sum(total),
|
|
niveau = cut(part_cumulee, breaks = seq(0, 1, by = 0.2), include.lowest = TRUE, labels = 1:5))
|
|
utiles |> group_by(niveau) |> summarise(unites = n(), poids = sum(total))
|
|
|
|
# R base : order() donne l'ordre des lignes, df[order(...), ] les range
|
|
utiles_base <- utiles_base[order(utiles_base$x), ]
|
|
part_cumulee <- cumsum(utiles_base$total) / sum(utiles_base$total)
|
|
utiles_base$niveau <- cut(part_cumulee, breaks = seq(0, 1, by = 0.2), include.lowest = TRUE, labels = 1:5)
|
|
table(utiles_base$niveau) # le nombre d'unites varie
|
|
tapply(utiles_base$total, utiles_base$niveau, sum) # le poids est le meme a peu pres
|
|
|
|
# Variante : cinq groupes de meme nombre d'unites (quintiles), avec quantile()
|
|
bornes <- quantile(utiles_base$x, probs = seq(0, 1, by = 0.2))
|
|
table(cut(utiles_base$x, breaks = bornes, include.lowest = TRUE, labels = 1:5))
|
|
|
|
|
|
# Outil 4 : ranger les modalites dans un ordre qui a un sens ----
|
|
sort(unique(utiles_base$type)) # sans factor() : ordre alphabetique
|
|
ordre <- c("petit", "moyen", "grand", "très grand")
|
|
|
|
# dplyr
|
|
utiles <- utiles |> mutate(type = factor(type, levels = ordre))
|
|
|
|
# R base
|
|
utiles_base$type <- factor(utiles_base$type, levels = ordre)
|
|
levels(utiles_base$type)
|
|
|
|
|
|
# Outil 5 : compter les unites par case : un tableau croise ----
|
|
# dplyr : count() de deux colonnes, puis pivot_wider() met un type par colonne
|
|
utiles |> count(niveau, type) |> pivot_wider(names_from = type, values_from = n)
|
|
|
|
# R base : table() de deux variables
|
|
table(utiles_base$niveau, utiles_base$type)
|
|
|
|
|
|
# Outil 6 : le taux d'un groupe = total sur total ----
|
|
# dplyr
|
|
utiles |> group_by(niveau) |> summarise(taux_a = 100 * sum(a) / sum(total))
|
|
|
|
# R base : tapply(x, groupe, fonction) applique la fonction (ici sum) dans chaque groupe
|
|
a_niveau <- tapply(utiles_base$a, utiles_base$niveau, sum)
|
|
total_niveau <- tapply(utiles_base$total, utiles_base$niveau, sum)
|
|
taux_niveau <- 100 * a_niveau / total_niveau
|
|
taux_niveau
|
|
|
|
# Un graphique en barres
|
|
ggplot(utiles |> group_by(niveau) |> summarise(taux_a = 100 * sum(a) / sum(total)),
|
|
aes(x = niveau, y = taux_a)) +
|
|
geom_col()
|
|
barplot(taux_niveau)
|
|
|
|
# A ne pas confondre : la moyenne des taux des unites (NA : mean, na.rm = TRUE)
|
|
utiles |> group_by(niveau) |> summarise(taux_a = mean(taux_a))
|
|
tapply(utiles_base$taux_a, utiles_base$niveau, mean)
|
|
|
|
|
|
# Outil 7 : un taux par deux groupes a la fois ----
|
|
# dplyr : group_by() avec deux colonnes, puis pivot_wider() pour un tableau
|
|
moyennes <- utiles |>
|
|
group_by(niveau, type) |>
|
|
summarise(taux_a = 100 * sum(a) / sum(total), .groups = "drop")
|
|
moyennes |> mutate(taux_a = round(taux_a, 1)) |> pivot_wider(names_from = type, values_from = taux_a)
|
|
|
|
# R base : list() donne les deux groupes ; une matrice divisee par l'autre, case par case
|
|
a_cases <- tapply(utiles_base$a, list(utiles_base$niveau, utiles_base$type), sum)
|
|
total_cases <- tapply(utiles_base$total, list(utiles_base$niveau, utiles_base$type), sum)
|
|
matrice <- 100 * a_cases / total_cases
|
|
round(matrice, 1)
|
|
|
|
|
|
# Outil 8 : une courbe par groupe ----
|
|
# ggplot2 : colour = type, et group = type pour relier les points d'un meme type
|
|
ggplot(moyennes, aes(x = niveau, y = taux_a, colour = type, group = type)) +
|
|
geom_line() +
|
|
geom_point()
|
|
|
|
# R base : matplot(), une courbe par colonne ; type = "b" : points relies ; xaxt = "n" puis axis()
|
|
couleurs <- c("#27ae60", "#2980b9", "#e67e22", "#c0392b")
|
|
matplot(1:5, matrice, type = "b", pch = 16, lty = 1, lwd = 2, col = couleurs, xaxt = "n",
|
|
xlab = "Niveau", ylab = "Taux (%)")
|
|
axis(1, at = 1:5)
|
|
legend("topright", legend = colnames(matrice), col = couleurs, lty = 1, pch = 16, lwd = 2)
|
|
|
|
|
|
# Outil 9 : une boite a moustaches par groupe ----
|
|
# ggplot2
|
|
ggplot(utiles, aes(x = type, y = taux_a)) +
|
|
geom_boxplot()
|
|
|
|
# R base : boxplot(y ~ groupe, data)
|
|
boxplot(taux_a ~ type, data = utiles_base)
|
|
|
|
# Sans les points extremes
|
|
ggplot(utiles, aes(x = type, y = taux_a)) +
|
|
geom_boxplot(outliers = FALSE) # ggplot2 3.5 ou plus recent
|
|
boxplot(taux_a ~ type, data = utiles_base, outline = FALSE)
|
|
|
|
# Les medianes, en chiffres
|
|
utiles |> group_by(type) |> summarise(mediane = median(taux_a))
|
|
tapply(utiles_base$taux_a, utiles_base$type, median)
|
|
|
|
|
|
# Outil 10 : plusieurs graphiques cote a cote ----
|
|
# ggplot2 : format long (TD3), puis facet_wrap() fait un graphique par variable
|
|
long <- utiles |>
|
|
pivot_longer(cols = c(a, b), names_to = "variable", values_to = "compte") |>
|
|
group_by(variable, niveau, type) |>
|
|
summarise(taux = 100 * sum(compte) / sum(total), .groups = "drop")
|
|
ggplot(long, aes(x = niveau, y = taux, colour = type, group = type)) +
|
|
geom_line() +
|
|
facet_wrap(~ variable)
|
|
|
|
# R base : par(mfrow = c(lignes, colonnes)), puis une boucle ; utiles_base[[v]] : la colonne nommee v
|
|
par(mfrow = c(1, 2))
|
|
for (v in c("a", "b")) {
|
|
m <- 100 * tapply(utiles_base[[v]], list(utiles_base$niveau, utiles_base$type), sum) / total_cases
|
|
matplot(1:5, m, type = "b", pch = 16, lty = 1, col = couleurs, main = v, xlab = "Niveau", ylab = "Taux (%)")
|
|
}
|
|
par(mfrow = c(1, 1)) # revenir a un seul graphique
|
|
|
|
|
|
# Outil 11 : un nuage de points avec un axe logarithmique, et une droite (optionnel) ----
|
|
# ggplot2 : scale_x_log10() ; geom_smooth() calcule la droite sur le log
|
|
ggplot(utiles, aes(x = x, y = taux_a)) +
|
|
geom_point() +
|
|
geom_smooth(method = "lm", formula = y ~ x, se = FALSE) +
|
|
scale_x_log10()
|
|
|
|
# R base : log = "x" ; lm() ajuste la droite sur log10(x), abline() la trace
|
|
plot(utiles_base$x, utiles_base$taux_a, pch = 16, log = "x")
|
|
droite <- lm(taux_a ~ log10(x), data = utiles_base)
|
|
abline(droite, lwd = 2)
|
|
coef(droite) # la constante, puis la pente : de combien taux_a change quand x est multiplie par 10
|
|
cor(log10(utiles_base$x), utiles_base$taux_a) # un nombre entre -1 et 1 : la force du lien
|
|
|
|
|
|
# Outil 12 : une carte de chaleur (facultatif) ----
|
|
# ggplot2
|
|
ggplot(moyennes, aes(x = niveau, y = type, fill = taux_a)) +
|
|
geom_tile() +
|
|
geom_text(aes(label = round(taux_a, 1)))
|
|
|
|
# R base : image() colore une matrice ; axis() ecrit les noms ; text() les valeurs
|
|
image(1:5, 1:4, matrice, axes = FALSE, xlab = "Niveau", ylab = "")
|
|
axis(1, at = 1:5)
|
|
axis(2, at = 1:4, labels = colnames(matrice), las = 1)
|
|
text(rep(1:5, 4), rep(1:4, each = 5), round(matrice, 1))
|
|
|
|
|
|
# Outil 13 : habiller et exporter ----
|
|
figure <- ggplot(moyennes, aes(x = niveau, y = taux_a, colour = type, group = type)) +
|
|
geom_line() +
|
|
geom_point() +
|
|
labs(title = "Taux selon le niveau et le type",
|
|
x = "Niveau (1 : le plus bas, 5 : le plus haut)", y = "Taux (%)", colour = NULL,
|
|
caption = "Lecture : au niveau 1, le taux des unités petites est de X %.\nSource : données fictives.") +
|
|
theme_minimal()
|
|
figure
|
|
# ggsave(file.path(chemin, "figure_exemple.png"), figure, width = 8, height = 5, dpi = 150)
|
|
|
|
# R base : main, xlab, ylab, sub ; png() avant, dev.off() apres
|
|
matplot(1:5, matrice, type = "b", pch = 16, lty = 1, lwd = 2, col = couleurs, xaxt = "n",
|
|
main = "Taux selon le niveau et le type",
|
|
xlab = "Niveau (1 : le plus bas, 5 : le plus haut)", ylab = "Taux (%)",
|
|
sub = "Source : données fictives.")
|
|
axis(1, at = 1:5)
|
|
legend("topright", legend = colnames(matrice), col = couleurs, lty = 1, pch = 16, lwd = 2)
|
|
# png(file.path(chemin, "figure_exemple.png"), width = 900, height = 600) ; la figure ; dev.off()
|