Numpy İle Veri Bilimine Giriş
Hoş geldiniz. Bu yazıda Numpy kullanarak veriler üzerinde çalışacağız. Numpy, dizilerle çalışmak için kullanılan bir Python kütüphanesidir. Python programlama dili için çok büyük, çok boyutlu dizileri ve matrisleri destekleyen, bu diziler üzerinde çalışacak üst düzey matematiksel işlevler ekleyen bir kütüphanedir.
Numpy Array'leri İle Python Listeleri Arasında Ne Fark Var ?
Python listeleri içerisinde birden fazla veri tipi olabilir. Liste içerisinde ki her bir eleman bellek 'de yer kaplar. Bu da büyük bir liste ile çalışırken performans kaybı yaşanması anlamına gelir. Aşağıdaki kod satırında gördüğünüz üzere bir listenin içerisinde 3 farklı veri yapısı var. Ve çıktı olarak listenin yapısı bozulmadan olduğu gibi kalıyor.
my_list = [1,2,3,4, 'murat', 'numpy', 25.09, 255.57]
# Çıktı: [1,2,3,4, 'murat', 'numpy', 25.09, 255.57]
Numpy Array'leri, verileri tek tip olmaya zorlar. Ne demek istiyorum ?
Bir array 'in içerisinde ya sadece integer (tam sayı) değer olabilir, ya sadece float (ondalıklı sayı) değer olabilir ya da sadece string (harfler öbeği) değer olabilir. Örnek üzerinde gösterecek olursam;
import numpy as np
my_array = np.array([1, 2, 3.10, 'murat'])
print(my_array)
# Çıktı: ['1' '2' '3.1' 'murat']
Array içerisinde integer, float ve string değerler tanımladık. Fakat çıktı olarak array içerisinde ki tüm değerleri string olarak aldık.
import numpy as np
my_array = np.array([1, 2, 3, 5.19, 12.67])
# Çıktı: array([ 1. , 2. , 3. , 5.19, 12.67])
Bu örnekte array içerisinde integer ve float veri türünde veriler tanımladık. Fakat çıktı olarak float veri tipinde bir array aldık.
Kısaca biz içerisinde binlerce veri olan bir veritabanı üzerinde çalışırken bellekte 1 birim yer kaplayacak. Bu sayede Numpy Array 'lerini kullanarak çok büyük veri setleri üzerinde yüksek performanslı çalışmalar yapabileceğiz.
1) Numpy Array 'i Oluşturmak
Tek boyulu array 'in karşılığı vektördür.
İki boyutlu array 'in karşılığı matrisdir.
1.1) Integer Veri Tipinde Array (Vektör) Oluşturalım
Aşağıda tek boyutlu bir Numpy Array oluşturalım.
import numpy as np
array1 = np.array([1, 2, 3, 4, 5])
# Çıktı: array([1, 2, 3, 4, 5])
1.2) Float Veri Tipinde Array (Vektör) Oluşturalım
Aşağıda array içerisinde 2 ve 3 tamsayısı da olmasına rağmen tüm elemanları float olan bir array oluştu.
array2 = np.array([2, 3, 5.5, 28.71, 93.16])
print(array2)
# Çıktı: array([ 2. , 3. , 5.5 , 28.71, 93.16])
1.3) String Veri Tipinde Array (Vektör) Oluşturalım
Aşağıda array içerisinde (1 ve 2 = integer), (3.14 = float) yapılı verilerde olmasına rağmen çıktı olarak içerisinde string veriler olan bir dizi aldık.
array3 = np.array([1, 2, 3.14, 'murat', 'cengiz'])
print(array3)
# Çıktı: array(['1', '2', '3.14', 'murat', 'cengiz'], dtype='<U32')
1.4) İki Boyutlu Dizi (Matris) Oluşturma
Aşağıda üç satır iki kolondan oluşan bir matris tanımladık.
array1 = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print(array1)
# Çıktı: array([[1, 2, 3],
# [4, 5, 6],
# [7, 8, 9]])
Aşağıda dört satır beş sütundan oluşan bir matris tanımladık.
array2 = np.array([[1,2,3,4,5],
[6,7,8,8,10],
[11,12,13,14,15],
[16,17,18,19,20]])
print(array2)
# Çıktı: np.array([[1,2,3,4,5],
# [6,7,8,8,10],
# [11,12,13,14,15],
# [16,17,18,19,20]])
2) Array Özellikleri
♦ ndim: Boyut sayısı
♦ shape: Boyut bilgisi
♦ size: Toplam eleman sayısı
♦ dtype: Dizi veri tipi
Aşağıda array1 dizisi hakkında yararlı bilgiler edindik..
array1 = np.array([1, 2, 3, 4, 5])
array1.ndim
# Çıktı: 1
array1.shape
# Çıktı: (5,)
array1.size
# Çıktı: 5
array1.dtype
# Çıktı: dtype('int32')
Aşağıda iki boyutlu array1 matrisi hakkında yararlı bilgiler edindik.
array1 = np.array([[1, 2, 3, 4, 5],
[10, 11, 12, 13, 14]])
array1.ndim
# Çıktı: 2
array1.shape
# Çıktı: (2, 5)
array1.size
# Çıktı: 10
array1.dtype
# Çıktı: dtype('int32')
3) Methodlar İle Numpy Array 'i Oluşturmak
3.1) np.random.randint(x, y, size)
x = başlangıç değeri (zorunlu parametre değildir!)
y = bitiş değeri (dahil değil)
size = dizi boyutu (zorunlu parametre değildir!)
Şuana kadar dizileri array methodunu kullanarak oluşturduk. Daha kolay ve hızlı şekilde oluşturmak da mümkün.
np.random.randint(0, 10) # 0 ile 10 arasında (10 dahil değil) rastgele integer (tam sayı) oluşturduk.
# Çıktı: 5
np.random.randint(0, 10)
# Çıktı: 2
np.random.randint(0, 10)
# Çıktı: 8
Yukarıda Numpy 'ın random methodunu kullanarak 0 ile 10 arasında (10 dahil değil) rastgele sayı üretmiş olduk.
Aşağıda ise size parametresini kullanarak tek boyutlu dizi oluşturmuş olduk. size parametresine verdiğimiz sayı dizinin kaç elemandan oluşacağını belirliyor.
np.random.randint(0, 10, size=5) # 0 ile 10 aralığında (10 dahil değil) 5 elemandan oluşan bir vektör oluşturduk.
# Çıktı: array([3, 3, 0, 1, 2])
np.random.randint(0, 10, size=5) # 0 ile 10 aralığında (10 dahil değil) 5 elemandan oluşan bir vektör oluşturduk.
# Çıktı: array([4, 2, 4, 3, 8])
np.random.randint(0, 10, size=15) # 0 ile 10 aralığında (10 dahil değil) 15 elemandan oluşan bir vektör oluşturduk.
# Çıktı: array([0, 9, 1, 6, 6, 9, 1, 9, 8, 9, 7, 0, 4, 4, 0])
Şimdi ise Numpy 'ın random methodunu kullanarak iki boyutlu dizi oluşturalım.
array1 = np.random.randint(0, 10, size=(3,3)) # 0 ile 10 aralığında (10 dahil değil) 3 satır, 3 sütundan oluşan bir matris oluşturduk.
# Çıktı: array([[4, 3, 9],
# [0, 9, 7],
# [5, 2, 8]])
array1 = np.random.randint(0, 20, size=(4,5)) # 0 ile 20 aralığında (20 dahil değil) 4 satır, 5 sütundan oluşan bir matris oluşturduk.
# Çıktı: array([[ 9, 19, 5, 7, 15],
# [ 7, 0, 9, 5, 15],
# [13, 9, 14, 12, 18],
# [ 1, 14, 4, 19, 16]])
3.2) np.arange(x, y, z)
x = başlangıç değeri, (zorunlu parametre değildir!)
y = bitiş değeri (dahil değil),
z = artış miktarı (zorunlu parametre değildir!)
array = np.arange(10)
print(array)
# Çıktı: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
array = np.arange(5, 15)
print(array)
# Çıktı: array([ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
array = np.arange(3, 14, 2)
print(array)
# Çıktı: array([ 3, 5, 7, 9, 11, 13])
3.2) np.linspace(x, y, num=integer)
x = başlangıç değeri
y = bitiş değeri
num = x ve y arasında oluşturulmak istenen değer sayısı
Linspace methodu ile belirli aralıkta aralarında eşit uzaklık olan sayılar üretebiliriz. Standart Sapma hesaplaması pratiği için gayet kullanışlı bir method.
array = np.linspace(0, 10, num=5) # 0 ile 10 arasında her değerin arasında aynı uzaklık bulunan bir vektör oluşturduk.
print(array)
# Çıktı: array([ 0. , 2.5, 5. , 7.5, 10. ])
array = np.linspace(10, 25, num=4)
print(array)
# Çıktı: array([10., 15., 20., 25.])
3.3) np.random.normal(x, y, z)
x = dizi ortalaması
y = dizinin standart sapması
z = dizi boyut bilgisi
normal methodunu kullanarak istediğimiz ortalama ve standart sapma değerlerine sahip bir dizi oluşturabiliriz.
array = np.random.normal(5, 9, 6)
print(array)
# Çıktı: array([17.70637929, 16.0143569 , -5.34283001, 10.15076685, -3.67344302, 1.65470334])
array = np.random.normal(15, 3, 5)
print(array)
# Çıktı: array([18.95842161, 11.55751684, 16.71489801, 10.2747914 , 16.15396354])
Yukarıda dizi ortalaması ve standart sapma oranını kendimiz belirlediğimiz vektörler oluşturduk. Şimdi ise matrisler oluşturacağız.
array = np.random.normal(20, 2, (3,3)) # Dizi ortalaması 20, dizi standart sapması 2 olan, 3 satır ve 3 kolondan oluşan bir matris oluşturduk.
print(array)
# Çıktı: array([[15.99121379, 22.80463999, 19.58436833],
# [22.90576212, 22.3260228 , 17.17371529],
# [19.11183664, 18.36465783, 20.39289076]])
array = np.random.normal(50, 1, (5,4)) # Dizi ortalaması 50, dizi standart sapması 1 olan, 5 satır ve 4 kolondan oluşan bir matris oluşturduk.
print(array)
# Çıktı: array([[50.63202119, 50.04383106, 50.12998563, 48.43389233],
# [49.6019993 , 50.11913894, 52.16539002, 51.31828991],
# [49.51203729, 49.51415368, 49.10896316, 49.89871892],
# [49.60497147, 50.28490652, 50.20928382, 50.93104973],
# [48.42471591, 50.49699723, 51.71287431, 52.13586113]])
3.4) Bir Matris 'i Yeniden Boyutlandırmak
shape = np.random.randint(20, size=(5,4)) # 5 satır 4 sütundan oluşan bir matris oluşturduk.
print(shape)
# Çıktı: array([[ 8, 16, 4, 13],
# [15, 18, 13, 16],
# [ 0, 1, 12, 15],
# [ 4, 14, 8, 18],
# [12, 17, 19, 7]])
shape.size
# Çıktı: 20
shape.reshape((4,5)) # shape isimli matris 'i 4 satır 5 sütundan oluşan bir matris 'e çevirdik.
# Çıktı: array([[ 8, 16, 4, 13, 15],
# [18, 13, 16, 0, 1],
# [12, 15, 4, 14, 8],
# [18, 12, 17, 19, 7]])
shape.reshape((2,10)) # shape isimli matris 'i 2 satır 10 sütundan oluşan bir matris 'e çevirdik
# Çıktı: array([[ 8, 16, 4, 13, 15, 18, 13, 16, 0, 1],
# [12, 15, 4, 14, 8, 18, 12, 17, 19, 7]])
shape.reshape((10,2)) # shape isimli matris 'i 10 satır 2 sütundan oluşan bir matris 'e çevirdik.
# Çıktı: array([[ 8, 16],
# [ 4, 13],
# [15, 18],
# [13, 16],
# [ 0, 1],
# [12, 15],
# [ 4, 14],
# [ 8, 18],
# [12, 17],
# [19, 7]])
Yukarıda shape isminde 5 satır, 4 sütundan oluşan bir matris oluşturduk. size bilgisine bakacak olursanız bu matris içerisinde 20 tane eleman var. Bir matris 'i yeniden boyutlandırırken dikkat etmemiz gereken şey, matris 'in satır ve sütun sayılarının çarpımı, matris 'in eleman sayısına eşit olmalı. Eğer olmazsa hata ile karşılaşırız.
4) İndex İle Dizi Elemanlarına Erişmek
4.1) İndex İle Vektör Elemanlarına Erişmek
Bir veritabanı üzerinde veya Numpy Array 'leri üzerinde çalışırken veri kümesi içerisinden index numarasına göre veri çekip bu veri üzerinde çalışma ihtiyacı duyabiliriz. İndex sayımı 0 'dan başlar. Bu yüzden n-1 formülü uygulanır. Bir listenin içerisinde 8 eleman var ise bu listenin maksimum index değeri 7'dir. İndex mantığını hemen aşağıda anlamaya başlayalım.
my_list = [10, 15, 37, 58, 65, 102] # my_list listesi içerisinde 6 eleman olmasına rağmen listenin sonuncu elemanı 5 index değeri aldı.
print(my_list[0])
# Çıktı: 10
print(my_list[1])
# Çıktı: 15
print(my_list[2])
# Çıktı: 37
print(my_list[3])
# Çıktı: 58
print(my_list[4])
# Çıktı: 65
print(my_list[5])
# Çıktı: 102
Saymaya 1 'den başlamaya alışkın olduğumuz için, eğer index kavramı ile ilk defa karşılaşıyorsanız veya henüz kafanızda tam oturmamışsa, bol bol pratik yapmanızı öneririm. Veri ile uğraştığınız her alanda index kavramı karşınıza çıkacaktır. Aşağıda bir örnek daha yapalım.
my_list = ["elma", "armut", "çilek", "şeftali"]
print(my_list[0])
# Çıktı: 'elma'
print(my_list[1])
# Çıktı: 'armut'
print(my_list[2])
# Çıktı: 'çilek'
print(my_list[3])
# Çıktı: 'şeftali'
Sadece listelerin değil, string veri tipindeki değişkenlerin de elemanlarına index ile erişebiliriz. Şimdi ise veri tipi string olan bir değişkenin index ile elemanlarına erişelim.
string = "murat"
print(string[0])
# Çıktı: 'm'
print(string[1])
# Çıktı: 'u'
print(string[2])
# Çıktı: 'r'
print(string[3])
# Çıktı: 'a'
print(string[4])
# Çıktı: 't'
4.2) İndex İle Matris Elemanlarına Erişmek
index = np.random.randint(20, size=(3,3)) # 0 ile 20 arasında 3 satır, 3 kolondan oluşan bir matris oluştur.
print(index)
# Çıktı: array([[ 7, 0, 13],
[11, 13, 2],
[ 2, 11, 3]])
print(index[0, 1]) # index matrisinde 1. satır, 2. kolonda ki değeri getir.
# Çıktı: 0
print(index[1, 2]) # index matrisinde 2. satır, 3. kolonda ki değeri getir.
# Çıktı: 2
print(index[2, 2]) # index matrisinde 3. satır, 3. kolonda ki değeri getir.
# Çıktı: 3
index = np.random.randint(20, size=(4,5)) # 0 ile 20 arasında 4 satır, 5 kolondan oluşan bir matris oluştur.
print(index)
# Çıktı: array([[ 3, 14, 8, 3, 17],
[15, 3, 11, 19, 5],
[19, 14, 3, 8, 19],
[ 0, 11, 0, 18, 4]])
print(index[0, 4]) # index matrisinde 1.satır, 5.kolonda ki değeri getir.
# Çıktı: 17
print(index[2, 1]) # index matrisinde 3.satır, 2.kolonda ki değeri getir.
# Çıktı: 14
print(index[3, 3]) # index matrisinde 4.satır, 4.kolonda ki değeri getir.
# Çıktı: 18
print(index[2, 3]) # index matrisinde 3.satır, 4.kolonda ki değeri getir.
# Çıktı: 8
4.3) İndex İle Geriye Doğru Giderek Elemanlara Erişmek
İndex sisteminde 0 'dan n-1. sayıya doğru gittiğimiz gibi geriye doğru da gidebiliriz.
index = [1, 2, 3, 4, 5, 6, 7]
print(index[-1])
# Çıktı: 7
print(index[-2])
# Çıktı: 6
print(index[-3])
# Çıktı: 5
print[index[-4]]
# Çıktı: 4
İndex sisteminde geriye doğru gitme kuralı 2 boyutlu dizilerde de geçerli.
index = np.random.randint(20, size=(4,5)) # 0 ile 20 arasında 4 satır, 5 kolondan oluşan bir matris oluştur.
print(index)
# Çıktı: array([[ 0, 4, 7, 7, 9],
[ 6, 12, 5, 1, 7],
[ 3, 9, 12, 16, 4],
[14, 9, 5, 6, 12]])
print(index[-1, 0])
# Çıktı: 3
print(index[-2, -1])
# Çıktı: 7
print(index[-2, -4])
# Çıktı: 12
4.4) Slicing İle Elemanlara Erişmek
Slicing, dilimize dilimlemek şeklinde çevrilebilir. Bir dizi içerisinde birden fazla elemanı slicing yöntemi ile alabilir, üzerinde işlem yapabiliriz.
import numpy as np
slicing = [1,2,3,4,5,6,7,8]
print(slicing[0:4]) # 0. index 'den 4. index 'e kadar (4. index dahil değil) elemanları getir.
# Çıktı: [1, 2, 3, 4]
print(slicing[2:5]) # 2. index 'den 5. index 'e kadar (5. index dahil değil) elemanları getir.
# Çıktı: [3, 4, 5]
print(slicing[4:6]) # 4. index 'den 6. index 'e kadar (6. index dahil değil) elemanları getir.
# Çıktı: [5, 6]
slicing = [1, 2, 3, 4, 5, 6]
print(slicing[:]) # Tüm diziyi listelemek istiyorsak
# Çıktı: [1, 2, 3, 4, 5, 6]
print(slicing[2:]) # 2. index 'den sonraki (2. index dahil) elemanları listelemek istiyorsak
# Çıktı: [3, 4, 5, 6]
print(slicing[:5]) # 5. index 'den önceki (5. index dahil değil) elemanları listelemek istiyorsak
# Çıktı: [1, 2, 3, 4, 5]
4.5) Slicing İle İki Boyutlu Dizilerde Elemanlara Erişmek
Aşağıdaki slicing isimli matris'de 2, 17 ve hemen altındaki satırda 8 ve 10 değerlerine erişmeye çalışalım.
slicing = np.random.randint(20, size=(5, 4))
print(slicing)
# Çıktı: array([[ 5, 19, 0, 11],
# [10, 2, 17, 3],
# [ 9, 8, 10, 12],
# [ 6, 12, 10, 1],
# [14, 5, 17, 13]])
print(slicing[1:3, 1:3])
# Çıktı: array([[ 2, 17],
# [ 8, 10]])
Aşağıdaki slicing isimli matris'de 3 satırda bulunan 12, 10 ve 1 değerlerine erişmeye çalışalım.
slicing = np.random.randint(20, size=(5, 4))
print(slicing)
# Çıktı: array([[ 5, 19, 0, 11],
# [10, 2, 17, 3],
# [ 9, 8, 4, 12],
# [ 6, 12, 10, 1],
# [14, 5, 17, 13]])
print(slicing[3, 1:4])
# Çıktı: array([12, 10, 1])
Aşağıda daha önce çalıştığımız matrislere nazaran daha büyük bir matris üzerinde çalışalım.
slicing = np.random.randint(100, size=(10,10))
print(slicing)
#Çıktı: array([[ 2, 36, 91, 91, 43, 66, 2, 12, 96, 22],
# [43, 78, 79, 35, 70, 68, 90, 84, 90, 42],
# [40, 2, 7, 64, 80, 37, 14, 16, 64, 95],
# [46, 43, 58, 17, 60, 46, 95, 77, 29, 76],
# [61, 61, 30, 5, 95, 53, 11, 43, 4, 76],
# [42, 12, 40, 44, 33, 4, 60, 27, 98, 68],
# [ 9, 78, 44, 95, 93, 19, 94, 77, 84, 11],
# [60, 26, 45, 95, 95, 52, 57, 16, 42, 43],
# [74, 84, 33, 84, 3, 68, 60, 34, 48, 59],
# [81, 22, 32, 14, 31, 69, 52, 1, 37, 30]])
print(slicing[1:3]) # 1. ve 2. satırdaki tüm elemanları getir.
# Çıktı: array([[43, 78, 79, 35, 70, 68, 90, 84, 90, 42],
[40, 2, 7, 64, 80, 37, 14, 16, 64, 95]])
print(slicing[1:5, 2:4]) # 1, 2, 3, 4. satırlar, 2, 3. kolonların kesişimindeki değerleri getir.
# Çıktı: array([[79, 35],
# [ 7, 64],
# [58, 17],
# [30, 5]])
print(slicing[6:9,6:9]) # 6, 7, 8. satırlar, 6, 7, 8. kolonların kesişimindeki değerleri getir.
# Çıktı: array([[94, 77, 84],
# [57, 16, 42],
# [60, 34, 48]])
4.6) Fancy İndex İle Elemanlara Erişmek
Şimdi elimizde binlerce veriden oluşan bir veritabanı hayal edelim. Ve bu veritabanı içerisinde ihtiyacımız olan verilerin index numalarına sahip olduğumuzu düşünelim. Fancy methodu sayesinde bu verileri tek satırda elde edebiliyoruz.
import numpy as np
fancy = np.arange(0, 30, 3) # 0 'dan 30'a kadar (30 dahil değil) 3 'e bölünen değerleri getir.
print(fancy)
# Çıktı: array([ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27])
print([fancy[1], fancy[2], fancy[5], fancy[7]])
# Çıktı: [3, 6, 15, 21]
Gördüğünüz üzere fancy vektörü içerisinde index numarasına göre elemanları bir liste içerisinde, toplu şekilde çağırabiliyoruz. Ve bunu tek satırda yapabiliyoruz.
x = np.arange(20, 50, 5) # 20 ile 50 arasındaki (50 dahil değil) 5 'e bölünebilen değerleri getir.
print(x)
# Çıktı: array([20, 25, 30, 35, 40, 45])
print([x[0], x[2], x[5]]) # x vektörünün 0., 2. ve 5. indexlerini bir liste içerisinde getir.
# Çıktı: array([20, 30, 45])
4.7) Fancy İndex İle Matris Elemanlarına Erişmek
Bir veritabanında ulaşmak istediğimiz verilerin index numaralarını biliyorsak rahatlıkla ulaşabiliriz.
fancy = np.random.randint(40, size=(4,4))
print(fancy)
# Çıktı: array([[ 5, 20, 22, 15],
# [29, 12, 36, 18],
# [30, 26, 2, 25],
# [ 0, 18, 19, 24]])
satir = [1, 3]
sutun = [2, 3]
print(fancy[satir, sutun])
# Çıktı: array([36, 24])
satir = 3
sutun = [0,3]
print(fancy[satir, sutun])
# Çıktı: array([ 0, 24])
fancy = np.random.randint(30, size=(5,5))
print(fancy)
# Çıktı: array([[32, 9, 10, 0, 26],
# [34, 27, 0, 14, 16],
# [ 4, 24, 18, 17, 17],
# [15, 35, 25, 10, 38],
# [13, 21, 26, 31, 12]])
print(fancy[1:4, 2:5])
# Çıktı: array([[ 0, 14, 16],
# [18, 17, 17],
# [25, 10, 38]])
print(fancy[[2,3], 2:])
# Çıktı: array([[18, 17, 17],
# [25, 10, 38]])
print(fancy[1:, 2:])
# Çıktı: array([[ 0, 14, 16],
# [18, 17, 17],
# [25, 10, 38],
# [26, 31, 12]])
5) Array İçerisinde İndex Tespiti, Array Ayırma, Array Birleştirme, Array Sıralama İşlemleri
5.1) Array İçerisinde İndex Tespiti (np.where())
Şuana kadar array 'ler üzerinde index numalarını belirterek birçok işlem yaptık. Fakat gerçek dünyada, gerçek veriler üzerinde çalışırken, üzerinde çalışmak istediğimiz verilerin index numalarını bilmiyor olacağız. Fakat Numpy içerisinde bir verinin index numarasını bulabilmemiz bir fonksiyon mevcut. Dilerseniz nasıl kullanıldığını inceleyelim.
import numpy as np
array = np.random.randint(20, size= 10)
print(array)
# Çıktı: array([18, 1, 16, 3, 9, 16, 17, 12, 15, 4])
np.where(array == 18)
# Çıktı: (array([0], dtype=int64),) # Array içerisinde 18 değerine sahip eleman 0. index 'de, veri tipi ise integer bilgilerine ulaştık.
np.where(array == 3)
# Çıktı: (array([3], dtype=int64),)
np.where(array == 15)
# Çıktı: (array([8], dtype=int64),)
Peki bir vektör içerisinde aynı elemandan birden fazla var ise çıktı ne olacak ?
array = np.random.randint(10, size=10)
print(array)
# Çıktı: array([6, 4, 2, 8, 3, 3, 5, 1, 7, 8])
np.where(array == 3)
# Çıktı: (array([4, 5], dtype=int64),) # 4. ve 5. indexlerde 3 değerine sahip elemanlar var.
np.where(array == 8)
# Çıktı: (array([3, 9], dtype=int64),)
Şimdi ise matris üzerinde where methodunu kullanarak arama işlemi yapalım.
array = np.random.randint(20, size=(3,3))
print(array)
# Çıktı: array([[ 6, 3, 0],
# [ 6, 1, 18],
# [ 6, 12, 1]])
np.where(array == 1)
# Çıktı: (array([1, 2], dtype=int64), array([1, 2], dtype=int64)) # Çıktıda ki 1. parametre satırları, 2. parametre ise sütunları temsil ediyor.
np.where(array == 6)
# Çıktı: (array([0, 1, 2], dtype=int64), array([0, 0, 0], dtype=int64))
np.where(array == 12)
# Çıktı: (array([2], dtype=int64), array([1], dtype=int64))
5.2) Array Birleştirme (np.concatenate())
Bazı durumlarda üzerinde çalıştığımız Array 'leri birleştirmemiz gerekebilir. Bu ihtiyacımızı karşılamak için concatenate methodunu inceleyelim.
import numpy as np
x = np.arange(1, 8)
y = np.arange(5, 15, 2)
my_array = np.concatenate([x, y])
# Çıktı: array([ 1, 2, 3, 4, 5, 6, 7, 5, 7, 9, 11, 13])
z = [100, 200, 300, 400, 500]
np.concatenate([my_array, z])
# Çıktı: array([ 1, 2, 3, 4, 5, 6, 7, 5, 7, 9, 11, 13, 100,
#200, 300, 400, 500])
Yukarıda gördüğünüz üzere birden fazla Array 'i birleştirebiliriz. Şimdi ise bu birleştirme işlemini matrisler üzerinde test edelim.
array1 = np.random.randint(20, size=(4,4))
print(array1)
# Çıktı: array([[18, 8, 13, 11],
# [ 2, 3, 5, 5],
# [ 6, 6, 1, 14],
# [ 6, 5, 7, 0]])
array2 = np.random.randint(10, size=(4,4))
print(array2)
# Çıktı: array([[9, 3, 0, 9],
# [9, 6, 7, 0],
# [8, 2, 5, 3],
# [1, 6, 0, 6]])
np.concatenate([array1, array2], axis=0)
# Çıktı: array([[18, 8, 13, 11],
# [ 2, 3, 5, 5],
# [ 6, 6, 1, 14],
# [ 6, 5, 7, 0],
# [ 9, 3, 0, 9],
# [ 9, 6, 7, 0],
# [ 8, 2, 5, 3],
# [ 1, 6, 0, 6]])
np.concatenate([array1, array2], axis=1)
# Çıktı: array([[18, 8, 13, 11, 9, 3, 0, 9],
# [ 2, 3, 5, 5, 9, 6, 7, 0],
# [ 6, 6, 1, 14, 8, 2, 5, 3],
# [ 6, 5, 7, 0, 1, 6, 0, 6]])
Yukarıda array1 ve array2 matrisleri üzerinde iki farklı birleştirme işlemi yaptık. concatenate methoduna axis=0 parametresini verdiğimizde, ikinci matrisi, birinci matrisin satır sayısına ekleme yaptı. Fakat concatenate methoduna axis=1 parametresini verdiğimizde ikinci matrisi, birinci matrisin sütun sayısına ekledi. concatenate methodunun default axis değeri 0 'dır. Yani biz axis parametresini vermeseydik bile ikinci matrisi satır sayısına ekleyecekti. Hemen deneyelim.
my_array1 = np.random.randint(40, size=(4,4))
my_array2 = np.random.randint(60, size=(4,4))
np.concatenate([my_array1, my_array2])
# Çıktı: array([[ 1, 26, 13, 6],
# [10, 21, 36, 3],
# [18, 10, 36, 32],
# [ 1, 27, 36, 16],
# [40, 12, 24, 21],
# [17, 58, 23, 36],
# [39, 36, 27, 46],
# [20, 37, 58, 38]])
Yukarıdaki örneklerde farkettiyseniz oluşturduğumuz matrislerin satır ve sütun sayıları birbirlerine eşitti. Peki biz satır ve sütun sayıları birbirine eşit olmayan iki matrisi birleştirmeye çalışırsak ne olur ?
Yukarıda gördüğünüz gibi değer hatası aldık. Birleştirmek istediğimiz Array 'lerin boyut bilgileri birbirlerine eşit olmak zorunda.
5.3) Array Ayırma np.split()
Üzerinde Çalıştığımız Array 'i parçalara ayırabiliriz. Birnevi alt kümeler oluşturabiliriz.
import numpy as np
x = [1, 2, 3, 55, 66, 77, 88, 99]
np.split(x, [3,5]) # 3. index 'e kadar (3. index dahil değil) ayır. Daha sonra 5. index 'e kadar ayır.
# Çıktı: [array([1, 2, 3]), array([55, 66]), array([77, 88, 99])]
np.split(x, [1, 2])
# Çıktı: [array([1]), array([2]), array([ 3, 55, 66, 77, 88, 99])] # 1. index'e kadar (1.index dahil değil) ayır. 2. index'e kadar ayır.
Burada kafanız biraz karışmış olabilir. Daha iyi analiz edebilmek için bir özelliği daha kullanalım. Biz bir diziyi 2 index noktasından böldüğümüz zaman ortaya 3 tane alt küme çıkıyor. Ortaya çıkan 3 alt kümeyi aşağıdaki gibi değişkenlere eşitleyebilir ve gözlemleyebiliriz.
list = [1, 2, 3, 55, 66, 77, 88, 99]
x, y, z = np.split(list, [1, 2])
print(x)
# Çıktı: array([1])
print(y)
# Çıktı: array([2])
print(z)
# Çıktı: array([ 3, 55, 66, 77, 88, 99])
vektor = np.array([4,4,4,5,5,5,6,6,6,6,7,7,7,7,7])
np.split(vektor, [3, 6, 10])
# Çıktı: [array([4, 4, 4]),
# array([5, 5, 5]),
# array([6, 6, 6, 6]),
# array([7, 7, 7, 7, 7])]
a,b,c,d = np.split(vektor, [3, 6, 10])
print(a)
# Çıktı: array([4, 4, 4])
print(b)
# Çıktı: array([5, 5, 5])
print(c)
# Çıktı: array([6, 6, 6, 6])
print(d)
# Çıktı: array([7, 7, 7, 7, 7])
Şimdi ise iki boyutlu matris üzerinde ayırma işlemi yapalım.
split = np.arange(16).reshape(4,4)
print(split)
# Çıktı: array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11],
# [12, 13, 14, 15]])
np.vsplit(split, [2])
# Çıktı: [array([[0, 1, 2, 3],
# [4, 5, 6, 7]]),
# array([[ 8, 9, 10, 11],
# [12, 13, 14, 15]])]
Yukarıda gördüğünüz üzere vsplit methodunu kullanarak yatay düzlemde bölme işlemi yaptık. 2. index 'e karşılık gelen değer ve ondan sonra gelenleri ayrı bir array içerisine koyduk.
split = np.arange(20).reshape(5,4)
print(split)
# Çıktı: array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11],
# [12, 13, 14, 15],
# [16, 17, 18, 19]])
np.vsplit(split, [2])
# Çıktı: [array([[0, 1, 2, 3],
# [4, 5, 6, 7]]),
# array([[ 8, 9, 10, 11],
# [12, 13, 14, 15],
# [16, 17, 18, 19]])]
ust, alt = np.vsplit(split, [2])
print(ust)
# Çıktı: array([[0, 1, 2, 3],
# [4, 5, 6, 7]])
print(alt)
# Çıktı: array([[ 8, 9, 10, 11],
# [12, 13, 14, 15],
# [16, 17, 18, 19]])
Şimdi ise dikey düzlemde bölme işlemi yapalım.
split = np.random.randint(20, size=(4,4))
print(split)
# Çıktı: array([[ 6, 6, 8, 16],
# [13, 8, 1, 6],
[ 7, 17, 12, 9],
[ 8, 9, 8, 6]])
np.hsplit(split, [2])
# Çıktı: [array([[ 6, 6],
# [13, 8],
# [ 7, 17],
# [ 8, 9]]),
# array([[ 8, 16],
# [ 1, 6],
# [12, 9],
# [ 8, 6]])]
Yukarıda gördüğünüz gibi hsplit methodunu kullanarak dikey düzlemde bölme işlemi gerçekleştirdik.
split = np.random.randint(20, size=(4, 4))
print(split)
# Çıktı: array([[17, 18, 4, 5],
# [ 0, 3, 11, 3],
# [ 7, 18, 0, 8],
# [ 0, 12, 7, 10]])
sol, sag = np.hsplit(split, [2])
print(sol)
# Çıktı: array([[17, 18],
# [ 0, 3],
# [ 7, 18],
# [ 0, 12]])
print(sag)
# Çıktı: array([[ 4, 5],
# [11, 3],
# [ 0, 8],
# [ 7, 10]])
5.4) Array Sıralama np.sort()
Üzerinde çalıştığımız diziyi küçükten büyüğe veya büyükten küçüğe sıralamak isteyebiliriz. Bu işlemi sort methodunu kullanarak yapabiliriz.
import numpy as np
array = np.random.randint(20, size=8)
print(array)
# Çıktı: array([18, 7, 16, 9, 9, 4, 9, 10])
np.sort(array)
# Çıktı: array([ 4, 7, 9, 9, 9, 10, 16, 18])
Aşağıda ise bir matris üzerinde sıralama işlemi yapalım.
array = np.random.randint(30, size=(4,4))
print(array)
# Çıktı: array([[ 4, 18, 6, 6],
# [29, 0, 8, 7],
# [19, 13, 29, 2],
# [18, 25, 5, 4]])
np.sort(array, sort=1)
# Çıktı: array([[ 4, 6, 6, 18],
# [ 0, 7, 8, 29],
# [ 2, 13, 19, 29],
# [ 4, 5, 18, 25]])
np.sort(array, sort=0)
# Çıktı: array([[ 4, 0, 5, 2],
# [18, 13, 6, 4],
# [19, 18, 8, 6],
# [29, 25, 29, 7]])
Yukarıda gördüğünüz gibi axis değerini 0 olarak belirlediğimizde, matrisin sütunları üzerinde sıralama işlemi yapılıyor. Axis değeri 1 olduğunda ise satırlar üzerinde sıralama yapılıyor.
5.5) Alt Küme Üzerinde İşlem Yapmak
Bir veritabanı üzerinde çalıştığımızı varsayalım. Bu veritabanında üzerinde çalışıcağımız verileri tespit edip öğrendiğimiz bilgilerle alt küme haline getirip o verilerin üzerinde çalışmak isteyebiliriz.
import numpy as np
array = np.random.randint(60, size=(5,5))
print(array)
# Çıktı: array([[47, 30, 57, 58, 21],
# [44, 5, 9, 27, 53],
# [27, 49, 27, 47, 26],
# [14, 55, 29, 3, 47],
# [ 3, 26, 59, 15, 0]])
alt_kume = array[1:4, 1:4]
print(alt_kume)
# Çıktı: array([[ 5, 9, 27],
# [49, 27, 47],
# [55, 29, 3]])
alt_kume[1, 1] = 555
# Çıktı: array([[ 5, 9, 27],
# [ 49, 555, 47],
# [ 55, 29, 3]])
alt_kume[2,2] = 999
# Çıktı: array([[ 5, 9, 27],
# [ 49, 555, 47],
# [ 55, 29, 999]])
print(array)
# Çıktı: array([[ 47, 30, 57, 58, 21],
# [ 44, 5, 9, 27, 53],
# [ 27, 49, 555, 47, 26],
# [ 14, 55, 29, 999, 47],
# [ 3, 26, 59, 15, 0]])
Yukarıda bir matris oluşturduk ve bu matrisin bir bölümünü slicing yöntemi ile parçalayıp alt_kume isimli değişkene eşitledik. Bu alt küme üzerinde yaptığımız değişiklikler ana matris 'e de uygulanmış oldu. Fakat bazı koşullarda alt kümede uyguladığımız değişikliklerin ana kümeye işlenmesini istemeyebiliriz. Mesela deneme amacıyla alt küme oluşturduğumuzda bu durum geçerlidir. Yaptığımız değişikliklerin alt kümede kalmasını isteriz. Bunun içinde copy methodunu kullanarak ana kümenin bir kopyasını oluşturacağız.
array = np.random.randint(30, size=(4,5))
print(array)
# Çıktı: array([[28, 15, 9, 19, 18],
# [ 2, 18, 15, 5, 29],
# [ 3, 0, 28, 25, 11],
# [24, 27, 10, 1, 12]])
alt_kume = array[1:3, 1:4].copy()
print(alt_kume)
# Çıktı: array([[18, 15, 5],
# [ 0, 28, 25]])
alt_kume[1,1] = 255
# Çıktı: array([[ 18, 15, 5],
# [ 0, 255, 25]])
alt_kume[0, 2] = 120
# Çıktı: array([[18, 15, 120],
[ 0, 255, 25]])
print(array)
# Çıktı: # Çıktı: array([[28, 15, 9, 19, 18],
# [ 2, 18, 15, 5, 29],
# [ 3, 0, 28, 25, 11],
# [24, 27, 10, 1, 12]])
Yukarıda gördüğünnüz gibi matris'in bir kopyasını oluşturduk. Kopyanın üzerinde yaptığımız işlemler ana kümeyi etkilemedi.
Kaynakça