R Academy · Pelajaran

Memahami NA dalam R

Pelajari maksud NA, sebab NA tersebar dan perbezaannya daripada NULL.

Pelajaran 1 daripada 413 langkah

Memahami NA dalam R ialah pelajaran R Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran R Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus R Academy merangkumi sejumlah 4 pelajaran.

Apakah NA dalam R?

NA bermaksud Not Available — ia mewakili nilai yang hilang atau tidak diketahui. Tidak seperti NULL (ketiadaan objek) atau NaN (bukan nombor), NA ialah ruang letak untuk data yang wujud tetapi tidak diketahui.

# NA represents a missing value
height_cm <- c(175, NA, 162, 188, NA, 170)
cat('Heights:', height_cm, '
')
cat('Length:', length(height_cm), '
')  # NA counts as an element
cat('Sum:', sum(height_cm), '
')        # NA propagates

NA berbanding NULL

NA ialah nilai yang hilang di dalam vector — slot itu wujud tetapi tiada nilai yang diketahui. NULL ialah ketiadaan keseluruhan objek — panjangnya 0 dan ia tidak boleh disimpan di dalam vector.

# NA: element exists, value unknown
vec_with_na <- c(1, NA, 3)
cat('Vector with NA, length:', length(vec_with_na), '
')  # 3

# NULL: nothing there at all
vec_with_null <- c(1, NULL, 3)
cat('Vector with NULL, length:', length(vec_with_null), '
')  # 2!

# NULL gets dropped; NA is kept
cat('vec_with_na:', vec_with_na, '
')
cat('vec_with_null:', vec_with_null, '
')

NA berbanding NaN

NaN (Not a Number) terhasil daripada operasi yang tidak ditakrifkan secara matematik seperti 0/0 atau sqrt(-1). Ia ialah nilai angka khas, manakala NA ialah penanda nilai hilang umum yang boleh digunakan untuk sebarang jenis.

# NaN from undefined operations
cat('0/0 =', 0/0, '
')          # NaN
cat('sqrt(-1) =', sqrt(-1), '
') # NaN (with warning)
cat('Inf - Inf =', Inf - Inf, '
') # NaN

# NaN IS also NA (a special case)
cat('is.nan(NaN):', is.nan(NaN), '
')
cat('is.na(NaN): ', is.na(NaN), '
')  # TRUE!
cat('is.nan(NA): ', is.nan(NA), '
')  # FALSE

NA berbanding Inf

Inf dan -Inf mewakili infiniti positif dan negatif — kedua-duanya terhasil daripada operasi seperti 1/0. Tidak seperti NA, Inf ialah nilai numerik yang diketahui (walaupun ekstrem) dan mengambil bahagian dalam perbandingan seperti biasa.

cat('1/0 =', 1/0, '
')         # Inf
cat('-1/0 =', -1/0, '
')       # -Inf
cat('Inf + 1 =', Inf + 1, '
') # Inf
cat('Inf > 1000:', Inf > 1000, '
')  # TRUE
cat('is.infinite(Inf):', is.infinite(Inf), '
')
cat('is.na(Inf):       ', is.na(Inf), '
')  # FALSE

Penyebaran NA dalam Aritmetik

NA bersifat berjangkit dalam aritmetik: sebarang operasi yang melibatkan NA akan mengembalikan NA. Hal ini disengajakan — jika satu nilai dalam pengiraan tidak diketahui, hasilnya juga tidak diketahui.

x <- NA
cat('NA + 5:  ', x + 5, '
')      # NA
cat('NA * 0:  ', x * 0, '
')      # NA (not 0!)
cat('NA == NA:', x == NA, '
')     # NA (not TRUE!)
cat('NA > 5:  ', x > 5, '
')      # NA
cat('sum(1,NA):', sum(1, NA), '
') # NA

typeof(NA) — NA Bertip

NA lalai mempunyai jenis logical. R menyediakan varian NA bertip untuk setiap jenis atomik. Varian ini penting apabila anda bekerja dengan vektor bertip bagi mengelakkan penukaran jenis yang tidak disengajakan.

cat('typeof(NA):            ', typeof(NA), '
')           # logical
cat('typeof(NA_integer_):  ', typeof(NA_integer_), '
')   # integer
cat('typeof(NA_real_):     ', typeof(NA_real_), '
')      # double
cat('typeof(NA_complex_):  ', typeof(NA_complex_), '
')   # complex
cat('typeof(NA_character_):', typeof(NA_character_), '
') # character

NA_integer_ dalam Amalan

Apabila mencipta vektor integer dengan nilai yang hilang, gunakan NA_integer_ untuk mengekalkan jenis vektor yang konsisten. Menggunakan NA biasa menyebabkan penukaran jenis secara tersirat kepada double dalam sesetengah konteks.

# Using plain NA in an integer vector
v1 <- c(1L, 2L, NA, 4L)
cat('typeof with NA:         ', typeof(v1), '
')  # integer (OK here)

# Explicit typed NA is safer in functions
v2 <- c(1L, 2L, NA_integer_, 4L)
cat('typeof with NA_integer_:', typeof(v2), '
')  # integer

# Check they behave the same
cat('Same?', identical(v1, v2), '
')

NA_real_ dan NA_character_

NA_real_ digunakan untuk nilai yang hilang dalam vektor double (numerik), manakala NA_character_ digunakan untuk rentetan yang hilang. Kedua-duanya amat penting apabila membina vektor dalam fungsi yang memerlukan konsistensi jenis.

# Character vector with missing
names_vec <- c('Alice', 'Bob', NA_character_, 'Dave')
cat('Names:', names_vec, '
')
cat('typeof:', typeof(names_vec), '
')

# Numeric with missing
readings <- c(22.5, NA_real_, 21.3, NA_real_, 24.1)
cat('Readings:', readings, '
')
cat('Non-NA count:', sum(!is.na(readings)), '
')

NA dalam Operasi Logik

NA dalam operasi logik mengikut logik tiga nilai: TRUE | NA ialah TRUE (kerana TRUE OR apa-apa sahaja ialah TRUE), tetapi FALSE | NA ialah NA (kita tidak dapat menentukan hasilnya tanpa mengetahui nilai NA).

cat('TRUE  | NA:', TRUE | NA, '
')   # TRUE
cat('FALSE | NA:', FALSE | NA, '
')  # NA
cat('TRUE  & NA:', TRUE & NA, '
')   # NA
cat('FALSE & NA:', FALSE & NA, '
')  # FALSE

# Never use == to test for NA!
cat('NA == NA:', NA == NA, '
')    # NA (not TRUE!)
cat('is.na(NA):', is.na(NA), '
')  # TRUE (correct way)

NA dalam Vektor dan Bingkai Data

Nilai yang hilang kerap muncul dalam data dunia sebenar. Memahami tingkah laku NA membantu anda mentafsir ringkasan dengan betul, mengesan isu kualiti data dan memilih strategi pengendalian yang sesuai.

ages <- c(25, NA, 32, NA, 29, 41, NA, 35)
cat('Ages:', ages, '
')
cat('Length:', length(ages), '
')
cat('Missing count:', sum(is.na(ages)), '
')
cat('Present count:', sum(!is.na(ages)), '
')
cat('Mean (fails):', mean(ages), '
')           # NA
cat('Mean (works):', mean(ages, na.rm = TRUE), '
') # 32.4

Jenis NA: Gambaran Lengkap

Berikut ialah ringkasan nilai khas yang berkaitan dengan NA dalam R:

NA — nilai generik yang hilang (jenis logik)
NA_integer_, NA_real_, NA_complex_, NA_character_ — NA bertip
NaN — nombor tidak ditakrifkan (hasil daripada 0/0, sqrt(-1))
Inf, -Inf — nilai infiniti (hasil daripada 1/0)
NULL — ketiadaan objek (panjang 0)

# Test functions for special values
x <- c(1, NA, NaN, Inf, -Inf, 0)
cat('Values:         ', x, '
')
cat('is.na():        ', is.na(x), '
')        # TRUE for NA and NaN
cat('is.nan():       ', is.nan(x), '
')       # TRUE only for NaN
cat('is.infinite():  ', is.infinite(x), '
')  # TRUE for Inf and -Inf
cat('is.finite():    ', is.finite(x), '
')    # TRUE only for normal numbers

Semakan Pantas

Apakah hasil penilaian NA == NA dalam R?

Jawab dalam pelajaran interaktif

Imbas Kembali: Memahami NA

Cemerlang! Perkara utama daripada pelajaran ini:

NA = nilai yang hilang (diketahui wujud tetapi nilainya tidak diketahui)
NULL = ketiadaan objek (dikeluarkan daripada vektor)
NaN = hasil aritmetik yang tidak ditakrifkan (juga merupakan NA)
Inf / -Inf = nilai infiniti (BUKAN NA)
NA bersifat berjangkit dalam aritmetik — operasi terhadap NA mengembalikan NA
Gunakan NA bertip (NA_integer_, dll.) untuk kod yang selamat dari segi jenis
Sentiasa uji NA dengan is.na(), jangan gunakan == NA

# Key tests side by side
special_vals <- list(NA=NA, NaN=NaN, Inf=Inf, 'NULL-in-vec'=c(1,NULL,3)[2])
for (name in names(special_vals)) {
  v <- special_vals[[name]]
  cat(name, '| is.na:', is.na(v), '| is.nan:', is.nan(v[!is.infinite(v)]), '
')
}

Percuma untuk bermula

Pelajari R dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 43
Pelajaran: 159

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Memahami NA dalam R” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran R Academy, termasuk “Memahami NA dalam R”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus R Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Memahami NA dalam R”?

Pelajari maksud NA, sebab NA tersebar dan perbezaannya daripada NULL. Anda berlatih R Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan R Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran R Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Memahami NA dalam R” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke R Academy