0Pricing
R Academy · Ders

R'nin Tür Sistemine Genel Bakış

double, integer, character, logical ve complex türlerini anlayın.

R'nin Tür Sistemine Genel Bakış, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, R Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. R Academy kursu toplamda 4 dersten oluşur.

R'nin Tür Sistemi

R zengin bir tür sistemine sahiptir. Her nesnenin bir class'ı (üst düzey kategori) ve bir tür'ü (düşük düzey depolama modu) vardır. Her ikisini de anlamak, doğru ve verimli kod yazmanıza ve türle ilgili hataları ayıklamanıza yardımcı olur.

# Check class and type of various objects
cat('class(42L)    :', class(42L), '
')
cat('typeof(42L)   :', typeof(42L), '
')
cat('class(3.14)   :', class(3.14), '
')
cat('typeof(3.14)  :', typeof(3.14), '
')
cat('class(TRUE)   :', class(TRUE), '
')
cat('class("hello"):', class('hello'), '
')

class() ve typeof() Karşılaştırması

class(x), R'nin nesne yönelimli sistemi tarafından kullanılan üst düzey kategoriyi (ör. 'integer', 'numeric', 'matrix') döndürür. typeof(x) ise düşük düzeyli C depolama türünü (ör. 'integer', 'double', 'closure') döndürür.

m <- matrix(1:4, nrow = 2)
cat('class(matrix)  :', class(m), '
')   # matrix array
cat('typeof(matrix) :', typeof(m), '
')  # integer

f <- factor(c('a', 'b', 'a'))
cat('class(factor)  :', class(f), '
')   # factor
cat('typeof(factor) :', typeof(f), '
')  # integer (stored as int!)

cat('class(list)    :', class(list()), '
')  # list
cat('typeof(list)   :', typeof(list()), '
') # list

is.numeric() — Sayısal Değer Kontrolü

is.numeric(x), hem integer hem de double değerleri (ve sayısal matrisleri) için TRUE döndürür. Belirli depolama modunu değil, sayısal üst türü kontrol eder.

cat('is.numeric(3.14):', is.numeric(3.14), '
')    # TRUE (double)
cat('is.numeric(3L):  ', is.numeric(3L), '
')      # TRUE (integer)
cat('is.numeric(TRUE):', is.numeric(TRUE), '
')    # FALSE
cat('is.numeric("3"): ', is.numeric('3'), '
')     # FALSE
cat('is.numeric(NA):  ', is.numeric(NA), '
')      # FALSE (NA is logical)

is.integer() ve is.double() Karşılaştırması

is.integer(), özellikle tamsayı depolamasını (L son eki veya as.integer() ile oluşturulan) sınar. is.double() ise kayan noktalı (double) depolamayı sınar. Her ikisi de numeric alt kümeleridir.

x_int <- 5L
x_dbl <- 5.0

cat('--- x_int = 5L ---
')
cat('is.integer:', is.integer(x_int), '
')  # TRUE
cat('is.double: ', is.double(x_int), '
')   # FALSE
cat('is.numeric:', is.numeric(x_int), '
')  # TRUE

cat('--- x_dbl = 5.0 ---
')
cat('is.integer:', is.integer(x_dbl), '
')  # FALSE
cat('is.double: ', is.double(x_dbl), '
')   # TRUE
cat('is.numeric:', is.numeric(x_dbl), '
')  # TRUE

is.character() — Dize Kontrolü

is.character(x), x bir karakter (dize) vektörü ise TRUE döndürür. Metin olması gereken girdileri doğrulamak veya sayısal NA türlerini karakter NA türlerinden ayırmak için bunu kullanın.

greetings <- c('hello', 'world', 'R')
numbers <- c(1, 2, 3)
numeric_string <- '42'

cat('is.character(greetings):      ', is.character(greetings), '
')
cat('is.character(numbers):        ', is.character(numbers), '
')
cat('is.character(numeric_string): ', is.character(numeric_string), '
')
cat('is.character(NA_character_):  ', is.character(NA_character_), '
')

is.logical() — Mantıksal Değer Kontrolü

is.logical(x), x mantıksal (Boolean) değerler içeriyorsa TRUE döndürür. Türü belirtilmemiş NA değerinin varsayılan olarak mantıksal bir değer olduğunu unutmayın.

flags <- c(TRUE, FALSE, TRUE, NA)
cat('is.logical(flags): ', is.logical(flags), '
')   # TRUE
cat('is.logical(NA):    ', is.logical(NA), '
')      # TRUE (default NA is logical)
cat('is.logical(1):     ', is.logical(1), '
')       # FALSE
cat('is.logical("TRUE"):', is.logical('TRUE'), '
')  # FALSE
cat('typeof(NA):        ', typeof(NA), '
')          # logical

R'nin Tür Hiyerarşisi

R'nin atomik türleri basitten karmaşığa doğru bir hiyerarşi oluşturur: logical < integer < double < complex < character. Bir vektörde türler karıştırıldığında R, tüm öğeleri mevcut en karmaşık türe dönüştürür.

# Type hierarchy in action
cat('c(TRUE, 1L) type:     ', typeof(c(TRUE, 1L)), '
')   # integer
cat('c(1L, 1.5) type:      ', typeof(c(1L, 1.5)), '
')   # double
cat('c(1.5, 1+0i) type:    ', typeof(c(1.5, 1+0i)), '
') # complex
cat('c(1+0i, "a") type:   ', typeof(c(1+0i, 'a')), '
')  # character
cat('c(TRUE, "x") type:    ', typeof(c(TRUE, 'x')), '
') # character

Türleri Programatik Olarak İnceleme

Bir nesne listesini denetlemek için tür inceleme işlevleri yazabilirsiniz. class(), typeof() ve length() işlevlerini birleştirmek, herhangi bir nesnenin yapısına ilişkin kapsamlı bir özet sağlar.

describe_type <- function(x, label) {
  cat(label, ': class =', class(x), ', typeof =', typeof(x),
      ', length =', length(x), '
')
}

describe_type(42L,         'integer literal')
describe_type(3.14,        'double literal')
describe_type(TRUE,        'logical')
describe_type('hello',     'character')
describe_type(c(1,2,3),    'numeric vector')
describe_type(list(1,'a'), 'list')

storage.mode() ve mode()

storage.mode(x), S3 adlandırma kuralını kullanması dışında typeof(x) işlevine benzer (ör. 'double' yerine 'double' döndürür). mode(x) ise integer ve double türlerini 'numeric' olarak birlikte gruplandıran, biraz daha kaba bir sınıflandırma döndürür.

x_int <- 5L
x_dbl <- 5.0

cat('mode(5L):         ', mode(x_int), '
')          # numeric
cat('mode(5.0):        ', mode(x_dbl), '
')          # numeric
cat('storage.mode(5L): ', storage.mode(x_int), '
')  # integer
cat('storage.mode(5.0):', storage.mode(x_dbl), '
')  # double
# mode() lumps int+dbl; storage.mode() / typeof() distinguish them

Listeler ve Veri Çerçeveleri için Tür İncelemesi

Listeler ve veri çerçeveleri gibi daha karmaşık nesnelerde sapply(df, class), class() işlevini her sütuna uygular ve sütun türlerini içeren adlandırılmış bir vektör verir. Bu, bir veri çerçevesinin şemasını hızlıca denetlemenin bir yoludur.

df <- data.frame(
  id      = 1:3,
  name    = c('Alice', 'Bob', 'Carol'),
  score   = c(88.5, 79.0, 92.3),
  passed  = c(TRUE, TRUE, TRUE)
)
cat('Column types:
')
print(sapply(df, class))
cat('Column typeof:
')
print(sapply(df, typeof))

Tür Sisteminin Özeti

R'nin tür inceleme araçları için hızlı başvuru:

  • class(x) — üst düzey S3 tür adı
  • typeof(x) — düşük düzeyli C depolama türü
  • is.numeric(x) — integer veya double için TRUE
  • is.integer(x) — yalnızca integer depolaması için TRUE
  • is.double(x) — yalnızca double (kayan noktalı) değerler için TRUE
  • is.character(x) — dizeler için TRUE
  • is.logical(x) — TRUE/FALSE/NA için TRUE
x <- 42L
cat('class(42L):       ', class(x), '
')
cat('typeof(42L):      ', typeof(x), '
')
cat('is.numeric(42L):  ', is.numeric(x), '
')
cat('is.integer(42L):  ', is.integer(x), '
')
cat('is.double(42L):   ', is.double(x), '
')
cat('is.character(42L):', is.character(x), '
')

Hızlı Kontrol

is.numeric(5L) R'de ne döndürür?

Özet: R'nin Tür Sistemi

Harika iş! Bu dersten çıkarılacak temel sonuçlar:

  • class(x) üst düzey türü, typeof(x) ise düşük düzeyli depolama türünü döndürür
  • is.numeric(), hem integer hem de double için TRUE'dur
  • is.integer() ve is.double(), iki sayısal alt türü birbirinden ayırır
  • R'nin tür hiyerarşisi (düşükten yükseğe): logical → integer → double → complex → character
  • Bir vektörde türlerin karıştırılması, en yüksek türe otomatik dönüştürmeyi başlatır
  • sapply(df, class), bir veri çerçevesindeki tüm sütun türlerini denetler
# Type audit function
audit_types <- function(x, name = 'x') {
  cat(name, ': class=', class(x), ', typeof=', typeof(x),
      ', is.numeric=', is.numeric(x), '
')
}
audit_types(1L,      'integer')
audit_types(1.0,     'double')
audit_types(TRUE,    'logical')
audit_types('hello', 'character')
audit_types(1+2i,    'complex')

Sıkça Sorulan Sorular

“R'nin Tür Sistemine Genel Bakış” dersi ücretsiz mi?

Evet — “R'nin Tür Sistemine Genel Bakış” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve R Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. R Academy kursu toplamda 4 dersten oluşur.

“R'nin Tür Sistemine Genel Bakış” dersinde ne öğreneceğim?

double, integer, character, logical ve complex türlerini anlayın. R Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

R Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te R Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“R'nin Tür Sistemine Genel Bakış” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu R Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her R Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. R'nin Tür Sistemine Genel Bakış
  2. Sayısal Türler Arasında Dönüştürme
  3. Mantıksal ve Karakter Dönüşümü
  4. Dönüştürme Tuzakları ve En İyi Uygulamalar
← R Academy Sayfasına Dön