R'de Vektörler: c(), seq(), İndeksleme ve Vektörleştirilmiş Matematik

R'de Her Şey Bir Vektördür

Çoğu dilde skalerler - tek değerler - ve sonra birkaçını tutmak için bir kap türü vardır. R skaleri atlar. Vektör, hepsi tek bir türü paylaşan sıralı bir değerler topluluğudur ve diğer her şeyin üzerine inşa edildiği birimdir. Tek başına duran bir sayı gibi görünen şey bile uzunluğu 1 olan bir vektördür:

scores <- c(70, 85, 92)
print(scores)
print(length(scores))

print(is.vector(5))
print(length(5))

c() - combine kelimesinin kısaltması - elle bir vektör kurma yolunuzdur. length() kaç eleman tuttuğunu söyler. Ve tek başına 5, is.vector için TRUE ve uzunluk için 1 bildirir: R vektörlerle çalışmayı hiç bırakmaz, sadece bazen çok kısa olanlarla çalışır.

R kodunun Python ya da JavaScript'ten farklı görünmesinin nedeni bu tasarımdır: başka yerlerde döngü yazacağınız işlemler burada bütün vektörlere tek bir ifadeyle uygulanır. Buna aşağıda geliyoruz.

Şimdi içselleştirilecek bir kural: bir vektörün tüm elemanları aynı türdedir. c() fonksiyonuna karışık bir küme verirseniz şikâyet etmez - her şeyi sessizce mevcut en esnek türe dönüştürür:

mixed <- c(1, "two", TRUE)
print(mixed)
print(class(mixed))

numish <- c(1, TRUE, FALSE)
print(numish)
print(class(numish))

Karışımdaki bir metin her şeyi metne dönüştürür ("1", "TRUE"). Sayılar arasındaki mantıksal değerler 1 ve 0 olur. Bu zorlama, sabit bir hiyerarşiyi izler - logical → integer → double → character - ve uyarısız gerçekleşir; sayılardan oluşan bir sütundaki başıboş bir "7" bu yüzden tüm veri kümenizi sessizce metne çevirebilir. Tam hiyerarşi veri türleri sayfasında ele alınıyor; gerçekten karışık değerler tutmanız gerekiyorsa listeler bunun içindir.

Dizi Üretme: :, seq() ve rep()

Her elemanı c() içine yazmak çabuk sıkıcı olur. R'nin düzenli desenler için üç kısayolu vardır:

print(1:10)
print(seq(0, 1, by = 0.25))
print(seq(2, 20, length.out = 4))
print(seq_len(5))

print(rep("ha", 3))
print(rep(c(1, 2), times = 3))
print(rep(c(1, 2), each = 3))

• 1:10 gündelik olandır: bir sınırdan diğerine, 1'er adımlarla tam sayılar.
• seq() bunu genelleştirir: adımı by = ile seçin ya da length.out = ile kaç eleman istediğinizi söyleyip aralığı R'nin hesaplamasına bırakın.
• seq_len(n), 1'den n'e üretir ve döngü indeksleri kurmanın güvenli yoludur - 1:n'in aksine n 0 olduğunda geriye doğru 1 0 saymak yerine doğru biçimde boş bir vektör verir.
• rep() tekrarlar: times = tüm vektörü uç uca tekrarlar (1 2 1 2 1 2), each = her elemanı yerinde tekrarlar (1 1 1 2 2 2). İkisini karıştırmak kolaydır; parçacığı çalıştırıp karşılaştırın.

İndeksleme: R 1'den Sayar

Köşeli parantezler elemanları dışarı çeker. İlk eleman [1]'dir - [0] değil. Python ya da JavaScript'ten geliyorsanız bu en yaygın erken tökezlemedir:

fruits <- c("apple", "banana", "cherry", "date")

print(fruits[1])
print(fruits[c(2, 4)])
print(fruits[-1])
print(fruits[-c(1, 2)])

Burada durup düşünmeye değer üç şey var:

• Konumlardan oluşan bir vektörle indeksleyebilirsiniz - fruits[c(2, 4)] ikinciyi ve dördüncüyü tek seferde alır.
• Negatif indeksler "bunun dışındaki her şey" demektir. fruits[-1], ilk elemanı olmayan vektördür. Bu, -1'in son eleman anlamına geldiği Python'dan tamamen farklıdır. Aynı çağrıda pozitif ve negatif indeksleri karıştıramazsınız.
• fruits[0] bir hata değildir - boş bir character(0) döndürür. R'de bir-eksik hatası genellikle çökme yerine sessiz boş sonuçlar üretir; bu yüzden aşağı akıştaki bir şey gizemli biçimde boş göründüğünde length() kontrol etmek işe yarar.

Elemanlar ayrıca isim taşıyabilir; bu da size üçüncü bir indeksleme yolu verir - etikete göre:

prices <- c(coffee = 3.5, tea = 2.8, juice = 4.2)
print(prices["tea"])
print(prices[c("coffee", "juice")])
print(names(prices))

İsimli vektörler hafif bir arama tablosu gibi çalışır ve kodu okunabilir tutar: prices["tea"] ne demek istediğini söyler, prices[2] söylemez.

Mantıksal Maskeler ve which()

İndekslemenin en güçlü yolu bir logical vektörledir - veriyle aynı uzunlukta TRUE/FALSE değerlerinden oluşan bir maske. Bir vektör üzerindeki her karşılaştırma tam olarak bunu üretir:

temps <- c(18, 25, 31, 22, 35)

hot <- temps > 24
print(hot)
print(temps[hot])

print(temps[temps > 24 & temps < 33])
print(which(temps > 24))

temps > 24 tek bir yanıt vermez - eleman başına bir tane olmak üzere beş yanıt verir. O maskeyi [ ] içine koymak, maskenin TRUE olduğu elemanları tutar. Koşulları & (ve) ve | (veya) ile birleştirin; bunlar diğer operatörlerle birlikte ele alınıyor.

which() bir maskeyi konumlara çevirir: burada sıcak ölçümlerin indeksleri olan 2 3 5. Eşleşmelerin nerede olduğunu bilmeniz gerektiğinde - onları raporlamak ya da aynı noktalarda farklı bir vektörü indekslemek için - buna uzanın. Düz filtreleme için temps[temps > 24], temps[which(temps > 24)] ifadesinden daha doğrudandır.

Bu maskeyle-filtreleme kalıbı, R'deki neredeyse tüm veri işinin belkemiğidir - bir veri çerçevesinin satırlarını filtrelediğinizde doğrudan geri gelir.

Vektörleştirilmiş Matematik ve Geri Dönüşüm Kuralı

R'de aritmetik, bütün vektörler boyunca eleman eleman uygulanır - döngü gerekmez:

prices <- c(10, 20, 30)

print(prices * 2)
print(prices + c(1, 2, 3))
print(c(1, 2, 3, 4) + c(10, 20))

İlk satır ana özelliktir: prices * 2 her elemanı ikiye katlar. Diğer dillerin bir for döngüsüne ihtiyacı olduğu yerde R'nin bir operatöre ihtiyacı vardır - ve vektörleştirilmiş biçim hem daha kısa hem daha hızlıdır, çünkü döngü altta optimize edilmiş C içinde gerçekleşir. Her adım bir öncekine bağlı olduğunda bir for döngüsü yazın; eleman bazlı matematik için vektörleştirin.

Üçüncü satır geri dönüşüm kuralını gösterir: vektörlerin uzunlukları farklı olduğunda R kısa olanı eşleşene kadar tekrarlar. c(10, 20), 10 20 10 20 olarak geri dönüştürülür ve 11 22 13 24 verir. 2 sayısının 3 uzunluğundaki bir vektör boyunca geri dönüştürülmesi tam da prices * 2 ifadesini çalıştıran şeydir - bir skaler, geri dönüştürülen 1 uzunluğunda bir vektörden ibarettir.

Uzun uzunluk kısa olanın tam katı olduğunda geri dönüşüm temizdir. Olmadığında R yine bir yanıt hesaplar - ve bir uyarı yayar:

print(c(1, 2, 3) + c(10, 20))

11 22 13 sonucunu ve uzun nesne uzunluğunun kısa nesne uzunluğunun katı olmadığına dair bir uyarı alırsınız. O uyarıyı bir hata raporu olarak görün: kısmi geri dönüşüm neredeyse hiçbir zaman kastettiğiniz şey değildir ve genellikle aynı uzunlukta olması gereken iki vektörün öyle olmadığı anlamına gelir.

Sıralama, Ters Çevirme, Yinelenenleri Ayıklama

Sürekli kullanacağınız üç küçük yardımcı:

x <- c(3, 1, 4, 1, 5)

print(sort(x))
print(sort(x, decreasing = TRUE))
print(rev(x))
print(unique(x))

sort() değerleri sıralar, rev() mevcut sırayı sıralamadan ters çevirir ve unique() ilk görünüşleri koruyarak yinelenenleri atar. Hiçbiri x değişkenini değiştirmez - R'deki neredeyse her şey gibi yeni bir vektör döndürür ve orijinali olduğu gibi bırakırlar.

Buradan Ne Çıkarıyorsunuz

• Vektör R'nin temel birimidir: sıralı, baştan sona tek türlü ve tek değerler bile 1 uzunluğunda vektörlerdir.
• c() ile kurun, desenleri :, seq() ve rep() ile üretin - ve c() fonksiyonunun karışık türleri sessizce zorladığını unutmayın.
• İndeksleme 1'den başlar; negatif indeksler eleman düşürür; isimler etiketle indekslemenizi sağlar.
• Mantıksal maskeler (x[x > 5]) tüm dilin filtreleme deyimidir; which() bir maskeyi konumlara çevirir.
• Matematik vektörleştirilmiştir, kısa vektörler geri dönüştürülür ve kısmi geri dönüşüm uyarısı bir hatanız olduğu anlamına gelir.

Sırada: listeler - değerlerinizin hepsi tek bir türü paylaşmadığında kullanılan kap.