0Pricing
R Academy · Lección

Operadores de asignación y especiales

Explore >, %in% y el operador pipe en R.

Operadores de asignación y especiales es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 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.

Asignación en R

R ofrece varias formas de asignar valores a variables. La más idiomática es <-, que es el estilo preferido. También encontrará = para la asignación, aunque se comporta de forma ligeramente diferente en algunos contextos.

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

Flecha izquierda <- frente a igual =

<- siempre crea una variable en el entorno actual. = también puede asignar valores, pero dentro de las llamadas a funciones establece argumentos con nombre en lugar de crear una variable. Esta distinción es 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, '
')

Operador de asignación a la derecha ->

R también admite la asignación de derecha a izquierda mediante ->. Esto asigna el lado izquierdo al nombre situado a la derecha. Aunque es válido, rara vez se utiliza en la práctica porque reduce la legibilidad.

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

Asignación global con <<-

<<- asigna un valor a una variable del entorno padre (envolvente), no del entorno local de la función. Se utiliza dentro de las funciones para modificar una variable que existe fuera de ellas.

counter <- 0

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

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

El operador de pertenencia %in%

%in% comprueba si cada elemento del lado izquierdo aparece en el vector del lado derecho. Devuelve un vector lógico con la misma longitud que el operando izquierdo. Es la forma más clara de comprobar la pertenencia a un conjunto en 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, '
')

Filtrado con %in%

%in% resulta especialmente útil al filtrar vectores o filas de marcos de datos. Permite seleccionar los elementos que pertenecen a un conjunto predefinido de valores permitidos.

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

Multiplicación de matrices con %*%

%*% realiza una verdadera multiplicación de matrices (producto escalar), a diferencia de *, que multiplica elemento a elemento. Para dos matrices A (m x n) y B (n x p), el resultado es una matriz (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)

El pipe nativo |>

Introducido en R 4.1, el pipe nativo |> pasa el resultado de la expresión de la izquierda como el primer argumento de la función de la derecha. Hace que las cadenas de operaciones sean mucho más legibles.

# 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

Pipe con vectores

El pipe nativo |> resulta especialmente útil con vectores y operaciones numéricas. Puede encadenar transformaciones sin crear variables intermedias, lo que hace que el código sea más limpio y fácil de seguir.

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

Operadores infijos personalizados

R permite definir operadores infijos personalizados mediante la sintaxis %name%. Así es como paquetes como dplyr definen el pipe %>%. Puede crear sus propios operadores para operaciones específicas de un dominio.

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

Referencia rápida de operadores

A continuación se resumen los operadores especiales tratados en esta lección:

  • <- — asignación estándar (preferida)
  • = — asignación (también se utiliza para argumentos de funciones)
  • <<- — asignación en el entorno global o padre
  • %in% — comprobación de pertenencia
  • %*% — multiplicación de matrices
  • |> — pipe nativo (R 4.1 o posterior)
  • %name% — sintaxis de operador infijo personalizado
# 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('
')

Comprobación rápida

¿Qué devuelve el operador %in% cuando se utiliza como c(2, 4, 6) %in% c(1, 2, 3)?

Recapitulación: operadores especiales

¡Bien hecho! Estas son las ideas clave de esta lección:

  • Use <- para asignar valores: es la convención de R
  • = funciona para asignar valores, pero es ambiguo dentro de las llamadas a funciones
  • <<- modifica desde dentro de una función una variable del entorno padre (global)
  • %in% es la forma más clara de comprobar la pertenencia a un conjunto en R
  • %*% realiza una multiplicación de matrices (no elemento a elemento)
  • El pipe nativo |> (R 4.1 o posterior) encadena llamadas a funciones de izquierda a derecha para lograr un código legible
  • Los operadores personalizados siguen el patrón %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, '
')

Preguntas frecuentes

¿La lección «Operadores de asignación y especiales» es gratis?

Sí — el texto completo de «Operadores de asignación y especiales» 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 «Operadores de asignación y especiales»?

Explore >, %in% y el operador pipe en R. 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 3 de 4.

¿Cuánto tiempo toma la lección «Operadores de asignación y especiales»?

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. Operadores aritméticos y de comparación
  2. Operadores lógicos y lógica booleana
  3. Operadores de asignación y especiales
  4. Precedencia de operadores y expresiones complejas
← Volver a R Academy