3. Chapitre 3 : Les fondamentaux de R

R est un langage de programmation et un environnement logiciel pour le calcul statistique et les graphiques. Conçu spécifiquement pour l’analyse de données, R offre une grande variété de techniques statistiques et graphiques.

3.1. Notes théoriques

3.1.1. “Hello World”

Le programme “Hello World” en R est un script simple qui affiche “Hello, World!” à l’écran. C’est communément utilisé comme première étape dans l’apprentissage d’un nouveau langage de programmation.

Syntaxe : print("Hello, World!")

Exemple :

print("Hello, World!")
# Résultat : [1] "Hello, World!"

3.1.2. Variables en R

Les variables R stockent des valeurs de données. Sur la base de la valeur assignée, R détermine automatiquement le type de données de la variable.

Syntaxe : variable_name <- value

Exemple :

x <- 5
name <- "Alice"
print(x)
print(name)
# Résultat :
# [1] 5
# [1] "Alice"

Note

Il est possible d’utiliser le symbole = également, mais <- est la convention recommandée en R.

Règles de nommage :

1. Doivent commencer par une lettre ou un point (mais un point ne peut pas être suivi d’un nombre)

2. Peuvent contenir des lettres, des nombres, des points et des caractères underscore

3. Sensibles à la casse (age, Age et AGE sont des variables différentes)

Exemples valides et invalides :

# Valides
variable1 <- 10
var.name <- "test"
.hidden <- TRUE
mon_age <- 25

# Invalides (ces lignes causeraient des erreurs)
# 2variable <- 10  # Ne peut pas commencer par un chiffre
# .2var <- 5       # Point ne peut pas être suivi d'un chiffre
# var-name <- 3    # Le tiret n'est pas autorisé

3.1.3. Types de données R

Les types de données en R représentent le type de données que vous pouvez stocker dans une variable.

Types principaux :

• Numeric (numérique)

• Integer (entier)

• Complex (complexe)

• Logical (logique)

• Character (caractère)

Exemples

• Numeric : Tout nombre avec ou sans décimale

x <- 5
y <- 12.5
class(x)  # "numeric"
class(y)  # "numeric"

• Integer : Nombres entiers

x <- 5L  # Le L indique à R de stocker comme entier
class(x)  # "integer"

# Vérification
is.integer(x)  # TRUE
is.numeric(x)  # TRUE (les entiers sont aussi numériques)

• Complex : Nombres complexes

z <- 1 + 4i
class(z)  # "complex"

# Parties réelle et imaginaire
Re(z)  # 1
Im(z)  # 4

• Logical : Valeurs booléennes

vrai <- TRUE   # ou T
faux <- FALSE  # ou F
class(vrai)    # "logical"

# Opérations logiques
resultat <- 5 > 3
print(resultat)  # TRUE

• Character : Données texte/chaîne

texte <- "Hello"
phrase <- 'Bonjour le monde'
class(texte)  # "character"

# Longueur de la chaîne
nchar(texte)  # 5

3.1.4. Opérateurs R

Les opérateurs sont des symboles qui indiquent à R d’effectuer des manipulations mathématiques ou logiques spécifiques.

Types d’opérateurs :

• Arithmétiques

• Relationnels

• Logiques

• D’assignation

Exemples

• Opérateurs Arithmétiques : +, -, *, /, ^ ou **, %%, %/%

a <- 10
b <- 3

# Opérations de base
a + b   # Addition : 13
a - b   # Soustraction : 7
a * b   # Multiplication : 30
a / b   # Division : 3.333...

# Puissance
a ^ b   # 1000
a ** b  # 1000 (alternative)

# Modulo (reste de la division)
a %% b  # 1

# Division entière
a %/% b # 3

• Opérateurs Relationnels : ==, !=, >, <, >=, <=

x <- 5
y <- 10

x == y   # Égal à : FALSE
x != y   # Différent de : TRUE
x > y    # Plus grand que : FALSE
x < y    # Plus petit que : TRUE
x >= y   # Plus grand ou égal : FALSE
x <= y   # Plus petit ou égal : TRUE

• Opérateurs Logiques : &, |, !, &&, ||

a <- TRUE
b <- FALSE

# Opérateurs vectorisés (travaillent sur des vecteurs)
a & b    # ET : FALSE
a | b    # OU : TRUE
!a       # NON : FALSE

# Exemple avec vecteurs
v1 <- c(TRUE, FALSE, TRUE)
v2 <- c(TRUE, TRUE, FALSE)
v1 & v2  # [1] TRUE FALSE FALSE
v1 | v2  # [1] TRUE TRUE TRUE

# Opérateurs scalaires (évaluent seulement le premier élément)
v1 && v2  # TRUE (seulement le premier élément)
v1 || v2  # TRUE (seulement le premier élément)

• Opérateurs d’assignation : <-, =, ->

# Assignation standard (recommandée)
x <- 5

# Assignation avec = (valide mais moins conventionnelle)
y = 10

# Assignation vers la droite (rare)
15 -> z

print(c(x, y, z))  # [1]  5 10 15

3.1.5. Instruction de sortie: print()

La fonction print en R est utilisée pour afficher la valeur d’une variable ou le résultat d’un calcul.

Syntaxe : print(object)

Note

En R, l’affichage sans print() fonctionne automatiquement dans la console interactive, mais il est recommandé de l’utiliser explicitement pour la clarté.

Exemples :

# Affichage simple
print("Hello, R!")
# [1] "Hello, R!"

# Affichage de variables
x <- 42
print(x)
# [1] 42

# Affichage de vecteurs
vec <- c(1, 2, 3, 4, 5)
print(vec)
# [1] 1 2 3 4 5

# Sans print() dans la console interactive
x  # Affiche aussi la valeur

# cat() pour un affichage sans indices
cat("Bonjour", "le", "monde", "\n")
# Bonjour le monde

3.1.6. Instruction d’entrée

La lecture de l’entrée utilisateur en R se fait avec la fonction readline.

Syntaxe : input <- readline(prompt)

Exemples :

# Lecture d'une chaîne
nom <- readline("Entrez votre nom : ")
print(paste("Bonjour", nom))

# Lecture d'un nombre (nécessite conversion)
age_str <- readline("Entrez votre âge : ")
age <- as.numeric(age_str)
print(paste("Dans 10 ans, vous aurez", age + 10, "ans"))

# Fonction scan() pour lire des nombres directement
# nombre <- scan(n = 1)  # Lit un nombre

3.1.7. Conversion de types (Casting)

Le casting en R implique la conversion du type d’une variable d’un type à un autre.

Fonctions de conversion :

# Conversion vers numérique
x <- "123"
x_num <- as.numeric(x)
class(x_num)  # "numeric"

# Conversion vers entier
y <- 3.14
y_int <- as.integer(y)
print(y_int)  # 3

# Conversion vers caractère
z <- 42
z_char <- as.character(z)
class(z_char)  # "character"

# Conversion vers logique
a <- 1
a_log <- as.logical(a)
print(a_log)  # TRUE (0 devient FALSE, tout autre nombre devient TRUE)

# Vérification de type
is.numeric(x_num)    # TRUE
is.character(z_char)  # TRUE
is.logical(a_log)     # TRUE

3.1.8. Structures de contrôle: conditions if/else

# Structure if simple
age <- 18
if (age >= 18) {
  print("Majeur")
}

# Structure if/else
note <- 15
if (note >= 10) {
  print("Admis")
} else {
  print("Échec")
}

# Structure if/else if/else
score <- 85
if (score >= 90) {
  grade <- "A"
} else if (score >= 80) {
  grade <- "B"
} else if (score >= 70) {
  grade <- "C"
} else {
  grade <- "F"
}
print(paste("Note:", grade))

# Opérateur conditionnel ifelse() (vectorisé)
ages <- c(15, 18, 21, 16)
statut <- ifelse(ages >= 18, "Majeur", "Mineur")
print(statut)  # [1] "Mineur" "Majeur" "Majeur" "Mineur"

3.1.9. Structures de contrôle: les boucles

Boucle for :

# Boucle sur une séquence
for (i in 1:5) {
  print(i)
}

# Boucle sur un vecteur
fruits <- c("pomme", "banane", "orange")
for (fruit in fruits) {
  print(paste("J'aime les", fruit))
}

# Boucle avec indices
vec <- c(10, 20, 30, 40, 50)
for (i in seq_along(vec)) {
  print(paste("Element", i, ":", vec[i]))
}

Boucle while :

# Boucle while simple
compteur <- 0
while (compteur < 5) {
  print(compteur)
  compteur <- compteur + 1
}

# Boucle avec condition complexe
x <- 100
while (x > 10) {
  print(x)
  x <- x / 2
}

Boucle repeat (spécifique à R) :

# Boucle repeat avec break
x <- 1
repeat {
  print(x)
  x <- x + 1
  if (x > 5) {
    break
  }
}

Contrôle de flux :

# break : sort de la boucle
for (i in 1:10) {
  if (i == 5) break
  print(i)
}

# next : passe à l'itération suivante
for (i in 1:5) {
  if (i == 3) next
  print(i)
}
# Affiche : 1 2 4 5

3.1.10. Fonctions

# Fonction simple
saluer <- function() {
  print("Bonjour!")
}
saluer()  # Appel de la fonction

# Fonction avec paramètres
addition <- function(a, b) {
  return(a + b)
}
resultat <- addition(5, 3)
print(resultat)  # 8

# Fonction avec valeurs par défaut
puissance <- function(base, exposant = 2) {
  return(base ^ exposant)
}
print(puissance(3))     # 9 (3^2)
print(puissance(3, 3))  # 27 (3^3)

# Retour implicite (dernière expression évaluée)
multiplication <- function(x, y) {
  x * y  # Pas besoin de return()
}

# Fonction avec plusieurs valeurs de retour
stats <- function(vec) {
  list(
    moyenne = mean(vec),
    mediane = median(vec),
    ecart_type = sd(vec)
  )
}

donnees <- c(1, 2, 3, 4, 5)
resultats <- stats(donnees)
print(resultats$moyenne)  # 3