0Pricing
R Academy · Aula

O operador de dois-pontos para intervalos de inteiros

Use o operador de dois-pontos para criar sequências de inteiros rapidamente.

O operador de dois-pontos para intervalos de inteiros é uma aula grátis de R Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

O operador de dois-pontos

O operador : gera uma sequência de inteiros de um valor inicial até um valor final, incrementando em 1 (ou em -1, no sentido decrescente). É a maneira mais rápida e concisa de criar um intervalo em 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, '
')

Usando : em laços for

O operador de dois-pontos é usado com mais frequência nos contadores de laços for. Ele cria a sequência diretamente, sem exigir uma variável separada, mantendo o 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 e decimais

O operador : funciona com números negativos e até mesmo com decimais (embora o passo seja sempre 1 ou -1). Se o início for igual ao fim, ele retornará um ú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 sequências de comprimento seguro

seq_len(n) gera a sequência 1, 2, ..., n. Ao contrário de 1:n, ele é mais seguro: quando n = 0, retorna um vetor vazio em vez de c(1, 0), evitando erros em laços.

# 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 sequências de índices

seq_along(x) gera a sequência 1:length(x) — um índice para cada elemento de x. É a maneira mais segura de percorrer um vetor por índice, pois lida corretamente com vetores de comprimento zero.

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 com dois-pontos na indexação de vetores

O operador : é usado com frequência para extrair uma fatia de um vetor ou matriz. Isso fornece uma subsequência contígua 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], '
')

Invertendo um vetor com dois-pontos

Combinar length() com o operador : oferece uma maneira simples de inverter um vetor. Usar rev() é mais idiomático, mas a abordagem com dois-pontos mostra como os intervalos funcionam.

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

Usando : para criar dados de teste

O operador de dois-pontos é útil para criar rapidamente vetores e matrizes de teste para exploração. Você pode combiná-lo com aritmética para gerar dados de teste não triviais.

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

Aviso sobre a precedência de dois-pontos

Lembre-se: : tem precedência maior que + e -. Portanto, 1:n-1 significa (1:n) - 1, e não 1:(n-1). Sempre use parênteses ao redor da aritmética nos limites de sequências.

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

Combinando intervalos

Você pode combinar vários intervalos usando c(). Isso cria um vetor de índices não contíguo, útil para selecionar partes específicas de um vetor maior.

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 inteiros: resumo

O operador de dois-pontos e seus complementos são ferramentas essenciais do R:

  • a:b — sequência de inteiros de a até b (passo 1 ou -1)
  • seq_len(n) — versão segura de 1:n (lida com n=0)
  • seq_along(x) — sequência segura de índices para o vetor x
  • Use parênteses: 1:(n+1), e não 1:n+1
  • Excelente para contadores de laços, extração de fatias e dados de teste 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], '
')

Verificação rápida

O que 1:n + 1 produz quando n = 4?

Revisão: operador de dois-pontos

Ótimo trabalho! Veja os principais aprendizados desta lição:

  • a:b cria uma sequência de inteiros de a até b, avançando em 1 (ou em -1 no sentido decrescente)
  • Use seq_len(n) em vez de 1:n quando n puder ser 0
  • Use seq_along(x) para percorrer com segurança os índices de vetores em laços
  • O operador de dois-pontos : tem precedência maior que +/- — sempre coloque entre parênteses os limites aritméticos
  • Os intervalos podem ser combinados com c() para extração de fatias não contíguas
# 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
')
}

Perguntas Frequentes

A aula “O operador de dois-pontos para intervalos de inteiros” é grátis?

Sim — o texto completo de “O operador de dois-pontos para intervalos de inteiros” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “O operador de dois-pontos para intervalos de inteiros”?

Use o operador de dois-pontos para criar sequências de inteiros rapidamente. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “O operador de dois-pontos para intervalos de inteiros”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. O operador de dois-pontos para intervalos de inteiros
  2. seq() para sequências personalizadas
  3. rep() para valores repetidos
  4. Vetores e sequências nomeados
← Voltar para R Academy