R Academy · Leçon

L’opérateur deux-points pour les intervalles d’entiers

Utilisez l’opérateur deux-points pour créer rapidement des suites d’entiers.

Leçon 1 sur 413 étapes

L’opérateur deux-points pour les intervalles d’entiers est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

L’opérateur deux-points

L’opérateur : génère une séquence d’entiers allant d’une valeur de départ à une valeur de fin, avec un incrément de 1 (ou de -1 dans l’ordre décroissant). C’est la manière la plus rapide et la plus concise de créer un intervalle dans R.

# Basic integer range
ones_to_ten <- 1:10
cat('1 to 10:', ones_to_ten, '
')

# Descending range
ten_to_one <- 10:1
cat('10 to 1:', ten_to_one, '
')

Utiliser : dans les boucles for

L’opérateur deux-points s’utilise le plus souvent dans les compteurs de boucles for. Il crée la séquence directement, sans nécessiter de variable distincte, ce qui permet de conserver un code concis.

# Classic for loop with colon range
total <- 0
for (i in 1:5) {
  total <- total + i
  cat('i =', i, ', running total =', total, '
')
}
cat('Sum of 1 to 5:', total, '
')

Intervalles négatifs et décimaux

L’opérateur : fonctionne avec les nombres négatifs et même avec les nombres décimaux (bien que le pas soit toujours de 1 ou de -1). Si le début est égal à la fin, il renvoie une seule valeur.

# Negative range
neg_range <- -3:3
cat('-3 to 3:', neg_range, '
')

# Range crossing zero
cross_zero <- -5:5
cat('-5 to 5:', cross_zero, '
')

# Single value
cat('5:5 =', 5:5, '
')

# Decimal start (step is still 1)
cat('1.5:5.5 =', 1.5:5.5, '
')

seq_len() pour des séquences de longueur sûre

seq_len(n) génère la séquence 1, 2, ..., n. Contrairement à 1:n, cette fonction est plus sûre : lorsque n = 0, elle renvoie un vecteur vide au lieu de c(1, 0), ce qui évite des erreurs dans les boucles.

# Compare 1:n vs seq_len(n) when n = 0
n <- 0
cat('1:0 produces:', 1:n, '(length', length(1:n), ') -- DANGEROUS
')
cat('seq_len(0):', seq_len(n), '(length', length(seq_len(n)), ') -- SAFE
')

# Correct use in a loop
my_vector <- c()  # empty
for (i in seq_len(length(my_vector))) {
  cat('This will not execute
')
}
cat('Loop over empty vector is safe with seq_len
')

seq_along() pour les séquences d’indices

seq_along(x) génère la séquence 1:length(x) — un indice par élément de x. C’est la manière la plus sûre d’itérer sur un vecteur par indice, car cette fonction gère correctement les vecteurs de longueur nulle.

cities <- c('Tokyo', 'Delhi', 'Shanghai', 'Dhaka', 'Cairo')

# seq_along gives indices 1 to length
cat('Indices:', seq_along(cities), '
')

# Use in loop to access both index and value
for (i in seq_along(cities)) {
  cat(i, ':', cities[i], '
')
}

Intervalle avec deux-points pour l’indexation des vecteurs

L’opérateur : est souvent utilisé pour extraire une tranche d’un vecteur ou d’une matrice. Vous obtenez ainsi une sous-séquence contiguë d’éléments.

temperatures <- c(18.5, 21.0, 23.4, 19.8, 25.1, 22.7, 17.3, 20.0)

# Extract a slice (elements 3 to 6)
midweek <- temperatures[3:6]
cat('Midweek temps:', midweek, '
')

# Last 3 elements
n <- length(temperatures)
cat('Last 3:', temperatures[(n-2):n], '
')

Inverser un vecteur avec deux-points

La combinaison de length() et de l’opérateur : offre une manière simple d’inverser un vecteur. L’utilisation de rev() est plus idiomatique, mais l’approche avec deux-points montre le fonctionnement des intervalles.

words <- c('data', 'science', 'with', 'R')
n <- length(words)

# Manual reverse using colon
reversed_idx <- n:1
reversed_words <- words[reversed_idx]
cat('Original:', words, '
')
cat('Reversed:', reversed_words, '
')

# Or simply:
cat('Using rev():', rev(words), '
')

Utiliser : pour créer des données de test

L’opérateur deux-points est pratique pour créer rapidement des vecteurs et des matrices de test à des fins d’exploration. Vous pouvez le combiner avec des opérations arithmétiques pour générer des données de test non triviales.

# Create a simple test dataset
student_ids <- 101:110
exam_scores <- (1:10) * 8 + 20  # scores: 28, 36, 44, ...

cat('Student IDs:', student_ids, '
')
cat('Exam scores:', exam_scores, '
')
cat('Mean score:', mean(exam_scores), '
')
cat('Passing count:', sum(exam_scores >= 60), '
')

Avertissement sur la priorité des deux-points

Rappelez-vous que : a une priorité supérieure à celle de + et -. Ainsi, 1:n-1 signifie (1:n) - 1, et non 1:(n-1). Utilisez toujours des parenthèses autour des opérations arithmétiques dans les bornes des séquences.

n <- 5

# These look similar but produce different results
cat('1:n-1 =', 1:n - 1, '
')   # (1:5)-1 = 0 1 2 3 4
cat('1:(n-1) =', 1:(n - 1), '
') # 1:4 = 1 2 3 4

# Practical: skip last element
v <- c(10, 20, 30, 40, 50)
cat('All but last:', v[1:(length(v) - 1)], '
')

Combiner des intervalles

Vous pouvez combiner plusieurs intervalles à l’aide de c(). Cela crée un vecteur d’indices non contigus, utile pour sélectionner des parties précises d’un vecteur plus grand.

data_vals <- c(5, 12, 3, 8, 15, 7, 20, 1, 9, 11)

# Select first 3 and last 3
first_and_last <- data_vals[c(1:3, 8:10)]
cat('First 3 and last 3:', first_and_last, '
')

# Skip middle: take 1:3 and 7:10
outer <- data_vals[c(1:3, 7:10)]
cat('Outer elements:', outer, '
')

Intervalles d’entiers : résumé

L’opérateur deux-points et les fonctions qui lui sont associées sont des outils essentiels de R :

a:b — séquence d’entiers de a à b (pas de 1 ou de -1)
seq_len(n) — version sûre de 1:n (gère n=0)
seq_along(x) — séquence d’indices sûre pour le vecteur x
Utilisez des parenthèses : 1:(n+1) et non 1:n+1
Très utile pour les compteurs de boucles, l’extraction de tranches et la création rapide de données de test

# All three in action
x <- c(100, 200, 300, 400, 500)
cat('1:5         :', 1:5, '
')
cat('seq_len(5)  :', seq_len(5), '
')
cat('seq_along(x):', seq_along(x), '
')
cat('x[2:4]      :', x[2:4], '
')

Vérification rapide

Que produit 1:n + 1 lorsque n = 4 ?

Réponds-y dans la leçon interactive

Récapitulatif : opérateur deux-points

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

a:b crée une séquence d’entiers de a à b, avec un pas de 1 (ou de -1 dans l’ordre décroissant)
Utilisez seq_len(n) plutôt que 1:n lorsque n peut être égal à 0
Utilisez seq_along(x) pour parcourir en toute sécurité les indices d’un vecteur dans les boucles
Les deux-points : ont une priorité supérieure à celle de +/- — placez toujours les bornes arithmétiques entre parenthèses
Les intervalles peuvent être combinés avec c() pour effectuer une extraction non contiguë

# Safe loop pattern with seq_along
months <- c('Jan', 'Feb', 'Mar', 'Apr', 'May')
days <- c(31, 28, 31, 30, 31)

for (i in seq_along(months)) {
  cat(months[i], ':', days[i], 'days
')
}

Gratuit pour commencer

Apprends R avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 43
Leçons: 159

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « L’opérateur deux-points pour les intervalles d’entiers » est-elle gratuite ?

Oui — le texte complet de « L’opérateur deux-points pour les intervalles d’entiers » 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 « L’opérateur deux-points pour les intervalles d’entiers » ?

Utilisez l’opérateur deux-points pour créer rapidement des suites d’entiers. 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 1 sur 4.

Combien de temps prend la leçon « L’opérateur deux-points pour les intervalles d’entiers » ?

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

L’opérateur deux-points pour les intervalles d’entiers
seq() pour les suites personnalisées
rep() pour répéter des valeurs
Vecteurs et suites nommés

← Retour à R Academy