0Pricing
R Academy · Lección

El operador dos puntos para rangos de enteros

Use el operador dos puntos para crear rápidamente secuencias de enteros.

El operador dos puntos para rangos de enteros es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

El operador de dos puntos

El operador : genera una secuencia de enteros desde un valor inicial hasta un valor final, con incrementos de 1 (o de -1 en orden descendente). Es la forma más rápida y concisa de crear un intervalo en 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, '
')

Uso de : en bucles for

El operador de dos puntos se utiliza sobre todo en los contadores de los bucles for. Crea la secuencia directamente, sin necesidad de una variable independiente, y mantiene el código conciso.

# 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, '
')

Intervalos negativos y decimales

El operador : funciona con números negativos e incluso con decimales, aunque el paso siempre es 1 o -1. Si el inicio y el final son iguales, devuelve un único valor.

# 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() para secuencias de longitud segura

seq_len(n) genera la secuencia 1, 2, ..., n. A diferencia de 1:n, es más segura: cuando n = 0, devuelve un vector vacío en lugar de c(1, 0), lo que evita errores en los bucles.

# 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() para secuencias de índices

seq_along(x) genera la secuencia 1:length(x): un índice por cada elemento de x. Es la forma más segura de recorrer un vector mediante índices, ya que gestiona correctamente los vectores de longitud cero.

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], '
')
}

Intervalos con dos puntos para indexar vectores

El operador : se utiliza con frecuencia para extraer un segmento de un vector o una matriz. Esto proporciona una subsecuencia contigua de elementos.

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], '
')

Invertir un vector con dos puntos

Combinar length() con el operador : ofrece una forma sencilla de invertir un vector. Usar rev() es más idiomático, pero el enfoque con dos puntos muestra cómo funcionan los intervalos.

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), '
')

Uso de : para crear datos de prueba

El operador de dos puntos resulta práctico para crear rápidamente vectores y matrices de prueba con los que explorar. Puede combinarlo con operaciones aritméticas para generar datos de prueba no 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), '
')

Advertencia sobre la precedencia de los dos puntos

Recuerde que : tiene mayor precedencia que + y -. Por tanto, 1:n-1 significa (1:n) - 1, no 1:(n-1). Use siempre paréntesis alrededor de las operaciones aritméticas en los límites de las secuencias.

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)], '
')

Combinar intervalos

Puede combinar varios intervalos mediante c(). Esto crea un vector de índices no contiguos, útil para seleccionar partes específicas de un vector más grande.

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, '
')

Intervalos de enteros: resumen

El operador de dos puntos y sus funciones relacionadas son herramientas esenciales de R:

  • a:b — secuencia de enteros de a a b (paso 1 o -1)
  • seq_len(n) — versión segura de 1:n (gestiona n=0)
  • seq_along(x) — secuencia segura de índices para el vector x
  • Use paréntesis: 1:(n+1), no 1:n+1
  • Es muy útil para contadores de bucles, extracción de segmentos y datos de prueba rápidos
# 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], '
')

Comprobación rápida

¿Qué produce 1:n + 1 cuando n = 4?

Recapitulación: operador de dos puntos

¡Muy bien! Estas son las ideas clave de esta lección:

  • a:b crea una secuencia de enteros de a a b, con incrementos de 1 (o de -1 si es descendente)
  • Use seq_len(n) en lugar de 1:n cuando n pueda ser 0
  • Use seq_along(x) para recorrer de forma segura los índices de un vector en los bucles
  • Los dos puntos : tienen mayor precedencia que +/-; use siempre paréntesis en los límites aritméticos
  • Los intervalos se pueden combinar con c() para extraer segmentos no contiguos
# 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
')
}

Preguntas frecuentes

¿La lección «El operador dos puntos para rangos de enteros» es gratis?

Sí — el texto completo de «El operador dos puntos para rangos de enteros» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «El operador dos puntos para rangos de enteros»?

Use el operador dos puntos para crear rápidamente secuencias de enteros. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «El operador dos puntos para rangos de enteros»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. El operador dos puntos para rangos de enteros
  2. seq() para secuencias personalizadas
  3. rep() para repetir valores
  4. Vectores y secuencias con nombre
← Volver a R Academy