0Pricing
R Academy · Ders

Sayısal Türler Arasında Dönüştürme

as.integer(), as.double() ve as.numeric() işlevlerini güvenle kullanın.

Sayısal Türler Arasında Dönüştürme, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 2. 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'de Integer ve Double Karşılaştırması

R'de iki sayısal tür vardır: integer (L son ekiyle oluşturulan tam sayılar) ve double (kayan noktalı değerler; sayısal sabitlerde varsayılan tür). R çoğu zaman double kullanır, ancak bu türleri ayırt etmek tür güvenliği ve bellek verimliliği açısından önemlidir.

x_dbl <- 5        # double by default
x_int <- 5L       # integer (L suffix)

cat('typeof(5):  ', typeof(x_dbl), '
')  # double
cat('typeof(5L): ', typeof(x_int), '
')  # integer
cat('5 == 5L:    ', x_dbl == x_int, '
') # TRUE (values equal)
cat('identical:  ', identical(x_dbl, x_int), '
')  # FALSE (types differ)

as.integer() — Integer'a Dönüştürme

as.integer(x), ondalık kısmı keserek (yuvarlamadan) bir değeri integer'a dönüştürür. Yani 3.9, 4 değil 3 olur. L son eki, integer sabitleri için söz dizimi kolaylığıdır.

cat('as.integer(3.7):  ', as.integer(3.7), '
')   # 3 (truncated, not 4)
cat('as.integer(3.2):  ', as.integer(3.2), '
')   # 3
cat('as.integer(-2.9): ', as.integer(-2.9), '
')  # -2 (toward zero)
cat('as.integer(10.9): ', as.integer(10.9), '
')  # 10

# Compare with round
cat('round(3.7):        ', round(3.7), '
')       # 4

as.double() ve as.numeric()

as.double(x) ve as.numeric(x) eşdeğerdir; her ikisi de değeri double (kayan noktalı) türe dönüştürür. Kesirli hassasiyete ihtiyaç duyduğunuzda integer değerleri double'a dönüştürmek için bunları kullanın.

count <- 7L  # integer
cat('typeof(count):         ', typeof(count), '
')

dbl_count <- as.double(count)
cat('typeof(as.double(7L)): ', typeof(dbl_count), '
')  # double
cat('Value:                 ', dbl_count, '
')           # 7

# Division automatically promotes to double
cat('7L / 2L:              ', 7L / 2L, '
')            # 3.5 (double)
cat('typeof(7L / 2L):      ', typeof(7L / 2L), '
')    # double

Integer Aritmetiği

R'de integer aritmetiği +, - ve * işlemleri için integer değerler üretir, ancak / işlemi için her zaman double döndürür. Tamsayı bölmesinin integer olarak kalmasını bekliyorsanız bu durum şaşırtıcı olabilir.

a <- 6L
b <- 3L

cat('6L + 3L =', a + b, '| typeof:', typeof(a + b), '
')  # 9 integer
cat('6L - 3L =', a - b, '| typeof:', typeof(a - b), '
')  # 3 integer
cat('6L * 3L =', a * b, '| typeof:', typeof(a * b), '
')  # 18 integer
cat('6L / 3L =', a / b, '| typeof:', typeof(a / b), '
')  # 2 DOUBLE!
cat('6L %/% 3L =', a %/% b, '| typeof:', typeof(a %/% b), '
') # 2 integer

Kesme ve Yuvarlama Karşılaştırması

Kritik bir ayrım vardır: as.integer() ondalıkları keser, round() ise en yakın tam sayıya yuvarlar. Hangi davranışı istediğinizi her zaman açıkça belirtin.

values <- c(2.1, 2.5, 2.9, -2.1, -2.5, -2.9)

cat('Original:     ', values, '
')
cat('as.integer():  ', as.integer(values), '
')  # truncate toward 0
cat('round():       ', round(values), '
')       # banker rounding
cat('floor():       ', floor(values), '
')       # round down
cat('ceiling():     ', ceiling(values), '
')     # round up

Integer Taşması Riski

R'deki integer değerleri 32 bit'tir ve yaklaşık ±2,1 milyara kadar değerleri tutabilir. Bu aralığın aşılması, bir uyarıyla birlikte NA oluşmasına neden olur. Double değerleri çok daha büyük değerleri tutabilir (yaklaşık 1,8 × 10^308'e kadar).

max_int <- .Machine$integer.max
cat('Max integer:', max_int, '
')  # 2147483647

# Overflow produces NA
cat('max_int + 1L:', max_int + 1L, '
')  # NA with warning

# Double handles it fine
cat('as.double(max_int) + 1:', as.double(max_int) + 1, '
')  # 2147483648

Vektörlerdeki L Son Eki

Her öğede L son ekini kullanarak veya bir diziye as.integer() uygulayarak integer vektörleri oluşturabilirsiniz. İki nokta operatörü : otomatik olarak integer değerler üretir.

# Colon produces integers
seq_int <- 1:5
cat('1:5 typeof:', typeof(seq_int), '
')  # integer

# Explicit integer vector
vec_int <- c(10L, 20L, 30L, 40L)
cat('c(10L,...) typeof:', typeof(vec_int), '
')  # integer

# as.integer on a vector
vec_dbl <- c(1.1, 2.9, 3.5, 4.7)
cat('as.integer(c(1.1,...)):', as.integer(vec_dbl), '
')  # 1 2 3 4

Bellek ve Performans

Integer değerleri öğe başına 4 bayt, double değerleri ise 8 bayt kullanır. Çok büyük tam sayı vektörlerinde integer kullanmak bellek kullanımını yarıya indirebilir. Ancak farklı türler arasındaki aritmetik işlemler otomatik olarak double'a dönüştürülür.

n <- 1000000L

vec_int <- 1:n          # integer: 4 bytes each
vec_dbl <- as.double(1:n)  # double: 8 bytes each

cat('Integer vector size:', object.size(vec_int), 'bytes
')
cat('Double vector size: ', object.size(vec_dbl), 'bytes
')
cat('Ratio:', as.numeric(object.size(vec_dbl)) / as.numeric(object.size(vec_int)), '
')

is.integer() ile Integer Depolamasını Kontrol Etme

Özellikle integer depolamasını doğrulamanız gerektiğinde is.numeric() yerine her zaman is.integer() kullanın. L son eki olmayan bir sayı, tam sayı gibi görünse bile double'dır.

a <- 5    # looks like integer, but it is double
b <- 5L   # true integer

cat('is.integer(5):  ', is.integer(a), '
')   # FALSE!
cat('is.integer(5L): ', is.integer(b), '
')   # TRUE
cat('is.numeric(5):  ', is.numeric(a), '
')   # TRUE
cat('is.numeric(5L): ', is.numeric(b), '
')   # TRUE
cat('class(5):       ', class(a), '
')        # numeric
cat('class(5L):      ', class(b), '
')        # integer

Dönüştürme İş Akışı Örneği

Uygulanabilir bir iş akışı şöyledir: verileri double olarak okuyun (varsayılan), hesaplamaları yapın ve ardından tam sayıların gerekli olduğu yerlerde (ör. sayımlar, dizinler ve kimlikler) sonuçları açıkça integer'a dönüştürün.

# Simulated: reading counts as doubles (common from CSV)
counts_raw <- c(12.0, 8.0, 15.0, 3.0, 22.0)
cat('typeof raw:', typeof(counts_raw), '
')  # double

# Convert to integer for proper storage
counts_int <- as.integer(counts_raw)
cat('typeof converted:', typeof(counts_int), '
')  # integer
cat('Counts:', counts_int, '
')
cat('Total:', sum(counts_int), '
')

Sayısal Dönüştürme Özeti

Sayısal türler için temel dönüştürme işlevleri:

  • as.integer(x) — integer'a keser (ondalıkları sıfıra doğru atar)
  • as.double(x) / as.numeric(x) — double'a dönüştürür
  • round(x) — en yakına yuvarlar (integer benzeri değerler için kullanılır)
  • floor(x) / ceiling(x) — aşağı / yukarı yuvarlar
  • 5L söz dizimi — integer sabiti (dönüştürme gerekmez)
  • 1:n — her zaman integer değerler üretir
x <- 7.8
cat('as.integer(7.8):', as.integer(x), '
')  # 7 (truncate)
cat('round(7.8):     ', round(x), '
')       # 8
cat('floor(7.8):     ', floor(x), '
')       # 7
cat('ceiling(7.8):   ', ceiling(x), '
')     # 8

Hızlı Kontrol

as.integer(3.9) R'de ne döndürür?

Özet: Sayısal Tür Dönüştürme

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

  • R'de iki sayısal tür vardır: integer (L son eki, 4 bayt) ve double (varsayılan, 8 bayt)
  • as.integer(x), sıfıra doğru keser — yuvarlama yapmaz
  • as.double() ve as.numeric() aynıdır — double'a dönüştürür
  • /, integer işlenenlerde bile her zaman double döndürür
  • 1:n integer dizileri oluşturur; L içermeyen sayısal sabitler double'dır
  • Yaklaşık 2,1 milyarda integer taşması oluşur → çok büyük tam sayılar için double kullanın
# Demonstrate truncation vs rounding
test_vals <- c(0.1, 0.5, 0.9, 1.5, 2.5, 3.7)
cat('Values:      ', test_vals, '
')
cat('as.integer(): ', as.integer(test_vals), '
')  # truncation
cat('round():      ', round(test_vals), '
')       # nearest (banker)

Sıkça Sorulan Sorular

“Sayısal Türler Arasında Dönüştürme” dersi ücretsiz mi?

Evet — “Sayısal Türler Arasında Dönüştürme” 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.

“Sayısal Türler Arasında Dönüştürme” dersinde ne öğreneceğim?

as.integer(), as.double() ve as.numeric() işlevlerini güvenle kullanı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 2. dersidir.

“Sayısal Türler Arasında Dönüştürme” 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