0Pricing
R Academy · Leçon

Affectation et opérateurs spéciaux

Découvrez >, %in% et l’opérateur pipeline dans R.

Affectation et opérateurs spéciaux est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Affectation dans R

R propose plusieurs façons d’affecter des valeurs à des variables. La plus idiomatique est <-, qui constitue le style recommandé. Vous rencontrerez également = pour l’affectation, même si son comportement diffère légèrement dans certains contextes.

# Both assign a value, <- is preferred
name <- 'Alice'
age = 30
cat('Name:', name, '
')
cat('Age:', age, '
')

Flèche gauche <- ou signe égal =

<- crée toujours une variable dans l’environnement actuel. = peut également effectuer une affectation, mais dans les appels de fonctions, il définit des arguments nommés au lieu de créer une variable. Cette distinction est importante.

# <- creates a variable outside function calls
x <- 42

# = inside function call sets argument, does NOT create x
mean(x = c(1, 2, 3))  # x is an arg here, not a variable

# But <- inside a function call DOES create a variable
mean(y <- c(1, 2, 3))  # y is now also in workspace
cat('y was created:', y, '
')

Opérateur d’affectation vers la droite →

R prend également en charge l’affectation de droite à gauche avec ->. Cela affecte la partie gauche au nom situé à droite. Bien que cet opérateur soit valide, il est rarement utilisé en pratique, car il réduit la lisibilité.

# Right assignment operator
100 -> max_score
'R Programming' -> course_name
cat('Max score:', max_score, '
')
cat('Course:', course_name, '
')

# Same as:
# max_score <- 100
# course_name <- 'R Programming'

Affectation globale avec <<-

<<- affecte une valeur à une variable dans l’environnement parent (englobant), et non dans l’environnement local de la fonction. Il s’utilise à l’intérieur des fonctions pour modifier une variable qui existe en dehors de la fonction.

counter <- 0

increment <- function() {
  counter <<- counter + 1  # modifies the global counter
}

increment()
increment()
increment()
cat('Counter after 3 increments:', counter, '
')

L’opérateur d’appartenance %in%

%in% vérifie si chaque élément de gauche apparaît dans le vecteur de droite. Il renvoie un vecteur logique de même longueur que l’opérande de gauche. C’est la manière la plus claire de tester l’appartenance à un ensemble dans R.

fruits <- c('apple', 'banana', 'cherry', 'date', 'elderberry')

# Check membership
cat('Is mango in fruits?', 'mango' %in% fruits, '
')
cat('Is cherry in fruits?', 'cherry' %in% fruits, '
')

# Check multiple values at once
search <- c('banana', 'mango', 'date')
cat('Which are in fruits:', search %in% fruits, '
')

Filtrage avec %in%

%in% est particulièrement puissant lorsqu’il sert à filtrer des vecteurs ou des lignes de cadres de données. Il vous permet de sélectionner les éléments qui appartiennent à un ensemble prédéfini de valeurs autorisées.

countries <- c('USA', 'UK', 'Canada', 'Germany', 'France', 'Japan')
populations <- c(331, 67, 38, 83, 67, 126)  # millions

# Keep only G7 European members
g7_europe <- c('UK', 'Germany', 'France', 'Italy')
mask <- countries %in% g7_europe
cat('G7 Europe countries:', countries[mask], '
')
cat('Populations:', populations[mask], '
')

Multiplication matricielle avec %*%

%*% effectue une véritable multiplication matricielle (produit scalaire), contrairement à *, qui multiplie les éléments un par un. Pour deux matrices A (m x n) et B (n x p), le résultat est une matrice (m x p).

A <- matrix(c(1, 2, 3, 4), nrow = 2, ncol = 2)
B <- matrix(c(5, 6, 7, 8), nrow = 2, ncol = 2)

cat('Matrix A:
')
print(A)
cat('Matrix B:
')
print(B)
cat('A %*% B (matrix mult):
')
print(A %*% B)
cat('A * B (element-wise):
')
print(A * B)

Le pipeline natif |&gt;

Introduit dans R 4.1, le pipeline natif |> transmet le résultat de l’expression de gauche comme premier argument de la fonction de droite. Il rend les chaînes d’opérations beaucoup plus lisibles.

# Without pipe
result1 <- round(sqrt(abs(-16)), 2)
cat('Without pipe:', result1, '
')

# With native pipe |>
result2 <- -16 |> abs() |> sqrt() |> round(2)
cat('With pipe:', result2, '
')

# Reading left to right: take -16, get abs, sqrt, then round

Pipeline avec des vecteurs

Le pipeline natif |> est particulièrement utile avec les vecteurs et les opérations numériques. Vous pouvez enchaîner les transformations sans créer de variables intermédiaires, ce qui rend votre code plus clair et plus facile à suivre.

scores <- c(88, 45, 92, 61, 73, 55, 84, 79)

# Chain: keep passing scores, then compute mean
passing_mean <- scores |> \(x) x[x >= 60] |> mean()
cat('Mean of passing scores:', round(passing_mean, 2), '
')

# Another chain: sort, reverse, take top 3
top3 <- scores |> sort(decreasing = TRUE) |> head(3)
cat('Top 3 scores:', top3, '
')

Opérateurs infixes personnalisés

R vous permet de définir des opérateurs infixes personnalisés à l’aide de la syntaxe %name%. C’est ainsi que des paquets comme dplyr définissent le pipeline %>%. Vous pouvez créer vos propres opérateurs pour des opérations propres à un domaine.

# Define a custom infix operator for 'not in'
'%notin%' <- function(x, table) !(x %in% table)

cities <- c('Paris', 'London', 'Berlin', 'Tokyo', 'Sydney')
exclude <- c('Tokyo', 'Sydney')

cat('Cities not in exclude list:', cities[cities %notin% exclude], '
')

Référence rapide des opérateurs

Voici un résumé des opérateurs spéciaux présentés dans cette leçon :

  • <- — affectation standard (à privilégier)
  • = — affectation (également utilisé pour les arguments de fonctions)
  • <<- — affectation dans l’environnement global ou parent
  • %in% — test d’appartenance
  • %*% — multiplication matricielle
  • |> — pipeline natif (R 4.1+)
  • %name% — syntaxe d’opérateur infixe personnalisé
# Demonstrate %in% as a filter
all_nums <- 1:20
special <- c(3, 6, 9, 12, 15, 18)
cat('Multiples of 3 up to 20:', all_nums[all_nums %in% special], '
')

# Demonstrate pipe
1:10 |> mean() |> cat('
')

Vérification rapide

Que renvoie l’opérateur %in% lorsqu’il est utilisé comme dans c(2, 4, 6) %in% c(1, 2, 3) ?

Récapitulatif&nbsp;: opérateurs spéciaux

Bravo ! Voici les points essentiels à retenir de cette leçon :

  • Utilisez <- pour les affectations — c’est la convention de R
  • = fonctionne pour les affectations, mais son rôle est ambigu dans les appels de fonctions
  • <<- modifie, depuis l’intérieur d’une fonction, une variable de l’environnement parent (global)
  • %in% est la manière la plus claire de tester l’appartenance à un ensemble dans R
  • %*% effectue une multiplication matricielle (et non élément par élément)
  • Le pipeline natif |> (R 4.1+) enchaîne les appels de fonctions de gauche à droite pour produire un code lisible
  • Les opérateurs personnalisés suivent le modèle %name%
# Pipe + %in% combined
data <- c(5, 12, 3, 8, 15, 7, 20, 1)
valid_range <- 5:15

result <- data |> \(x) x[x %in% valid_range] |> sort()
cat('Values in range 5-15:', result, '
')

Questions Fréquemment Posées

La leçon « Affectation et opérateurs spéciaux » est-elle gratuite ?

Oui — le texte complet de « Affectation et opérateurs spéciaux » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Affectation et opérateurs spéciaux » ?

Découvrez >, %in% et l’opérateur pipeline dans R. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Affectation et opérateurs spéciaux » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Opérateurs arithmétiques et de comparaison
  2. Opérateurs logiques et logique booléenne
  3. Affectation et opérateurs spéciaux
  4. Priorité des opérateurs et expressions complexes
← Retour à R Academy