0Pricing
R Academy · Lezione

Conversione tra logical e character

Converta tra logical, character e numeric con as.logical() e as.character().

Conversione tra logical e character è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Conversione tra tipi

R fornisce funzioni as.*() per convertire tutti i tipi di base. Questa lezione tratta le conversioni tra i tipi logical, character e numeric, ovvero le conversioni più comuni che incontrerà nella pulizia dei dati.

# Quick overview of as.*() functions
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.numeric(TRUE): ', as.numeric(TRUE), '
')  # 1
cat('as.character(3.14):', as.character(3.14), '
') # "3.14"
cat('as.logical("TRUE"):', as.logical('TRUE'), '
') # TRUE

Da numerico a logico

Quando si converte un numero in logico: 0 diventa FALSE, mentre qualsiasi numero diverso da zero diventa TRUE. Questa regola si applica sia agli interi sia ai double.

cat('as.logical(0):    ', as.logical(0), '
')     # FALSE
cat('as.logical(1):    ', as.logical(1), '
')     # TRUE
cat('as.logical(-5):   ', as.logical(-5), '
')    # TRUE (non-zero)
cat('as.logical(0.001):', as.logical(0.001), '
') # TRUE (non-zero)
cat('as.logical(0L):   ', as.logical(0L), '
')    # FALSE
cat('as.logical(3L):   ', as.logical(3L), '
')    # TRUE

Da logico a numerico

TRUE viene convertito in 1 e FALSE in 0. Questa conversione è alla base di molti idiomi di R, ad esempio l'uso di sum() per contare i valori TRUE o di mean() per calcolare proporzioni.

cat('as.numeric(TRUE):  ', as.numeric(TRUE), '
')   # 1
cat('as.numeric(FALSE): ', as.numeric(FALSE), '
')  # 0
cat('as.integer(TRUE):  ', as.integer(TRUE), '
')   # 1L

# Practical use: count TRUEs by summing
passed <- c(TRUE, FALSE, TRUE, TRUE, FALSE, TRUE)
cat('Passed count:', sum(as.numeric(passed)), '
')  # 4
cat('Pass rate:   ', mean(passed) * 100, '%
')      # 66.67%

as.logical() dalle stringhe

as.logical('TRUE') e as.logical('FALSE') convertono le rappresentazioni sotto forma di stringa. R accetta anche 'T' e 'F' come abbreviazioni. Qualsiasi altro valore (incluso 'true' in minuscolo) restituisce NA.

cat('as.logical("TRUE"):  ', as.logical('TRUE'), '
')   # TRUE
cat('as.logical("FALSE"): ', as.logical('FALSE'), '
')  # FALSE
cat('as.logical("T"):     ', as.logical('T'), '
')      # TRUE
cat('as.logical("F"):     ', as.logical('F'), '
')      # FALSE
cat('as.logical("yes"):   ', as.logical('yes'), '
')    # NA (not recognised)
cat('as.logical("true"):  ', as.logical('true'), '
')   # NA (case-sensitive!)

Da numerico a carattere

as.character(x) converte un numero nella relativa rappresentazione sotto forma di stringa. È utile per creare etichette e ID o quando deve inserire numeri in stringhe.

num_val <- 3.14159
char_val <- as.character(num_val)
cat('as.character(3.14159):', char_val, '
')  # '3.14159'
cat('class:', class(char_val), '
')           # character

# Building labels
ids <- 1:5
labels <- paste0('Item_', as.character(ids))
cat('Labels:', labels, '
')

Da carattere a numerico

as.numeric('3.14') analizza una stringa e la converte in un double. Se la stringa non può essere interpretata come numero, R restituisce NA con un avviso. Convalidi sempre l'input prima della conversione nel codice di produzione.

cat('as.numeric("3.14"):  ', as.numeric('3.14'), '
')   # 3.14
cat('as.numeric("100"):   ', as.numeric('100'), '
')    # 100
cat('as.numeric("-5.5"):  ', as.numeric('-5.5'), '
')   # -5.5
cat('as.numeric("abc"):   ', as.numeric('abc'), '
')    # NA with warning
cat('as.numeric("1e3"):   ', as.numeric('1e3'), '
')    # 1000 (sci notation OK)

Da logico a carattere

as.character(TRUE) produce la stringa 'TRUE'. È utile quando deve includere valori logici nell'output testuale, nelle esportazioni di file o nelle concatenazioni di stringhe.

flag_t <- TRUE
flag_f <- FALSE

cat('as.character(TRUE): ', as.character(flag_t), '
')  # 'TRUE'
cat('as.character(FALSE):', as.character(flag_f), '
')  # 'FALSE'
cat('class:', class(as.character(flag_t)), '
')         # character

# In paste()
message <- paste('System status:', as.character(flag_t))
cat(message, '
')

Conversione andata e ritorno

La maggior parte delle conversioni è reversibile (andata e ritorno), ma può comportare una certa perdita: numeric -> character -> numeric può perdere precisione a seconda di come il numero viene formattato come stringa.

original <- 3.141592653589793
char_version <- as.character(original)
back_to_num <- as.numeric(char_version)

cat('Original:  ', original, '
')
cat('As string: ', char_version, '
')
cat('Back:      ', back_to_num, '
')
cat('Identical?:', identical(original, back_to_num), '
')
cat('Equal?:    ', original == back_to_num, '
')

Conversione di vettori di diversa origine

Quando applica as.numeric() a un vettore di caratteri, ogni elemento viene convertito indipendentemente. Gli elementi che non possono essere analizzati diventano NA. Questo è il metodo standard per pulire i dati apparentemente numerici letti da file CSV.

# Simulated data from CSV (all read as character)
raw_data <- c('42', '37.5', 'N/A', '55', '', '28.0')
cat('Raw character data:', raw_data, '
')

numeric_data <- suppressWarnings(as.numeric(raw_data))
cat('Converted:         ', numeric_data, '
')  # 42 37.5 NA 55 NA 28
cat('NA count:          ', sum(is.na(numeric_data)), '
')

Conversione logica in ifelse()

La combinazione di as.numeric() con ifelse() o la moltiplicazione diretta per un vettore logico è un idioma comune per assegnare punteggi condizionali o creare feature nell'analisi dei dati.

# Score: 1 for correct, 0 for incorrect
quiz_answers <- c('A', 'C', 'B', 'D', 'B')
correct      <- c('A', 'B', 'B', 'D', 'C')

is_correct <- quiz_answers == correct
cat('Correct:  ', is_correct, '
')
cat('As 0/1:   ', as.numeric(is_correct), '
')
cat('Score:    ', sum(is_correct), '/', length(is_correct), '
')

Riepilogo delle conversioni

Ecco un riepilogo delle principali conversioni logiche e di caratteri:

  • as.logical(0) → FALSE; qualsiasi valore diverso da zero → TRUE
  • as.logical('TRUE'/'T') → TRUE; distingue maiuscole e minuscole; gli altri valori → NA
  • as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
  • as.character(x) → rappresentazione di x sotto forma di stringa
  • as.numeric('3.14') → 3.14; le stringhe non numeriche → NA con un avviso
# All conversions in one snippet
cat('logical->num:  ', as.numeric(c(TRUE, FALSE)), '
')
cat('num->logical:  ', as.logical(c(0, 1, -1, 0.5)), '
')
cat('char->num:     ', suppressWarnings(as.numeric(c('5', 'abc', '3.1'))), '
')
cat('char->logical: ', as.logical(c('TRUE', 'FALSE', 'yes')), '
')
cat('logical->char: ', as.character(c(TRUE, FALSE)), '
')

Verifica rapida

A quale valore viene valutato as.numeric(TRUE) + as.numeric(FALSE) in R?

Riepilogo: conversione logica e di caratteri

Ottimo! Concetti chiave di questa lezione:

  • as.logical(0) → FALSE; un valore diverso da zero → TRUE; 'TRUE'/'T' → TRUE
  • as.numeric(TRUE) → 1; as.numeric(FALSE) → 0
  • as.character(x) converte qualsiasi valore nella relativa forma stringa
  • as.numeric('3.14') analizza una stringa numerica; le stringhe non valide → NA
  • as.logical('true') è NA: la corrispondenza distingue maiuscole e minuscole ('TRUE' funziona)
  • Le conversioni sono per lo più reversibili; utilizzi suppressWarnings() quando converte colonne con valori che prevedibilmente producono NA
# Practical: parse a messy survey score column
raw_scores <- c('8', '7', 'N/A', '9', 'skip', '6')
numeric_scores <- suppressWarnings(as.numeric(raw_scores))
cat('Parsed:', numeric_scores, '
')
cat('Valid responses:', sum(!is.na(numeric_scores)), '
')
cat('Average score:  ', round(mean(numeric_scores, na.rm = TRUE), 2), '
')

Domande Frequenti

La lezione «Conversione tra logical e character» è gratuita?

Sì — il testo completo di «Conversione tra logical e character» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Conversione tra logical e character»?

Converta tra logical, character e numeric con as.logical() e as.character(). Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Conversione tra logical e character»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Panoramica del sistema dei tipi di R
  2. Conversione tra tipi numerici
  3. Conversione tra logical e character
  4. Problemi e buone pratiche nella coercizione
← Torna a R Academy