Post

01- Numpy Kutuphanesi

Numpy kutuphanesi matematiksel nesneler olustururken kullandigimiz temel kutuphanedir.

Posted Updated
By Muhammet Öztürk
35 min read
01- Numpy Kutuphanesi

NumPy Kılavuzu

NumPy’ye yeni başlayanlar için mutlak kılavuza hoş geldiniz!

NumPy (Numerical Python), bilim ve mühendislikte yaygın olarak kullanılan açık kaynaklı bir Python kütüphanesidir. NumPy kütüphanesi, homojen, N boyutlu ndarray gibi çok boyutlu dizi veri yapıları ve bu veri yapıları üzerinde verimli bir şekilde çalışan geniş bir fonksiyon kütüphanesi içerir. NumPy NumPy Nedir sayfasını hakkında daha fazla bilgi edinmek için ziyaret edebilir, yorum ve önerileriniz varsa lütfen bizimle iletişime geçebilirsiniz!

NumPy nasıl içe aktarılır

NumPy yüklendikten sonra, Python koduna şu şekilde aktarılabilir:

Bu yaygın kural, NumPy özelliklerine kısa, tanınabilir bir ön ek (np.) ile erişim sağlarken NumPy özelliklerini aynı ada sahip diğerlerinden ayırır.

Örnek kodu okuma

NumPy dokümantasyonu boyunca, aşağıdaki gibi görünen bloklar bulacaksınız:

1
2
3
4
5
6
7
8

# NumPy ile bir dizi oluşturma
a = np.array([[1, 2, 3],  
              [4, 5, 6]])

# Dizinin şekli
a.shape
# Çıktı: (2, 3)

Neden NumPy kullanılmalı?

Python listeleri mükemmel, genel amaçlı kaplardır. “Heterojen” olabilirler, yani çeşitli türlerde öğeler içerebilirler ve bir avuç öğe üzerinde bireysel işlemler gerçekleştirmek için kullanıldıklarında oldukça hızlıdırlar.

Verilerin özelliklerine ve gerçekleştirilmesi gereken işlem türlerine bağlı olarak, diğer kapsayıcılar daha uygun olabilir; bu özelliklerden yararlanarak hızı artırabilir, bellek tüketimini azaltabilir ve çeşitli yaygın işleme görevlerini gerçekleştirmek için üst düzey bir sözdizimi sunabiliriz. NumPy, CPU üzerinde işlenecek büyük miktarlarda “homojen” (aynı tip) veri olduğunda parlar.

“Dizi” nedir?

Bilgisayar programlamada dizi, veri depolamak ve almak için kullanılan bir yapıdır. Bir dizi hakkında genellikle uzayda bir ızgara gibi konuşuruz, her hücre verinin bir öğesini depolar. Örneğin, verinin her bir öğesi bir sayı olsaydı, “tek boyutlu” bir diziyi bir liste gibi görselleştirebilirdik:

İki boyutlu bir dizi bir tablo gibi olacaktır:

Üç boyutlu bir dizi, belki de ayrı sayfalara basılmış gibi istiflenmiş bir dizi tablo gibi olacaktır. NumPy’de bu fikir rastgele sayıda boyuta genelleştirilmiştir ve bu nedenle temel dizi sınıfına ndarray adı verilir: “N boyutlu bir diziyi” temsil eder.

Çoğu NumPy dizisinin bazı kısıtlamaları vardır. Örneğin:

  • Dizinin tüm elemanları aynı veri türünde olmalıdır.

  • Oluşturulduktan sonra dizinin toplam boyutu değişemez.

  • Şekil “pürüzlü” değil “dikdörtgen” olmalıdır; örneğin, iki boyutlu bir dizinin her satırı aynı sayıda sütuna sahip olmalıdır.

Bu koşullar karşılandığında NumPy, diziyi daha hızlı, bellek açısından daha verimli ve daha az kısıtlayıcı veri yapılarına göre kullanımı daha kolay hale getirmek için bu özelliklerden yararlanır.

Bu belgenin geri kalanında, bir ndarray örneğini ifade etmek için “dizi” kelimesini kullanacağız.

Dizi temelleri

Bir diziyi başlatmanın bir yolu, liste gibi bir Python dizisi kullanmaktır. Örneğin:

1
2
3
4
5
6
7

# NumPy ile bir dizi oluşturma
a = np.array([1, 2, 3, 4, 5, 6])

# Dizinin içeriğini görüntüleme
a
# Çıktı: array([1, 2, 3, 4, 5, 6])

Bir dizinin elemanlarına çeşitli şekillerde erişilebilir. Örneğin, bu dizinin tek bir elemanına orijinal listedeki bir elemana eriştiğimiz gibi erişebiliriz: köşeli parantez içindeki elemanın tamsayı indeksini kullanarak.

Not

Yerleşik Python dizilerinde olduğu gibi, NumPy dizileri “0 indekslidir”: dizinin ilk elemanına 1 değil 0 indeksi kullanılarak erişilir.

Orijinal liste gibi, dizi de değiştirilebilir.

1
2
3
4
5
6
7

# Dizinin ilk elemanını güncelleme
a[0] = 10

# Güncellenmiş diziyi görüntüleme
a
# Çıktı: array([10, 2, 3, 4, 5, 6])

Ayrıca orijinal listede olduğu gibi, Python dilim gösterimi indeksleme için kullanılabilir.

1
2
3
4

# Dizinin ilk üç elemanını dilimleme
a[:3]
# Çıktı: array([10, 2, 3])

Önemli bir fark, bir listenin dilim indekslemesinin öğeleri yeni bir listeye kopyalamasıdır, ancak bir diziyi dilimlemek bir görünüm döndürür: orijinal dizideki verilere atıfta bulunan bir nesne. Orijinal dizi, görünüm kullanılarak değiştirilebilir.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# Dizinin 3. elemanından itibaren bir alt dizi oluşturma
b = a[3:]

# Alt diziyi görüntüleme
b
# Çıktı: array([4, 5, 6])

# Alt dizinin ilk elemanını değiştirme
b[0] = 40

# Orijinal diziyi görüntüleme (alt dizi değiştiği için orijinali de etkiler)
a
# Çıktı: array([10, 2, 3, 40, 5, 6])

c = [[1,2],
	 [2,3]]

c[0,:] = 2

#cikti = [[2,2],
#		  [2,3]]

Dizi işlemlerinin ne zaman kopya yerine görünüm döndürdüğüne ilişkin daha kapsamlı bir açıklama için Kopyalar ve görünümler bölümüne bakın.

İki ve daha yüksek boyutlu diziler iç içe geçmiş Python dizilerinden başlatılabilir:

1
2
3
4
5
6
7
8
9
10
11
12

# 2D bir dizi oluşturma
a = np.array([[1, 2, 3, 4],  
              [5, 6, 7, 8],  
              [9, 10, 11, 12]])

# Diziyi görüntüleme
a
# Çıktı:
# array([[ 1,  2,  3,  4],
#        [ 5,  6,  7,  8],
#        [ 9, 10, 11, 12]])

NumPy’de, bir dizinin boyutu bazen “eksen” olarak adlandırılır. Bu terminoloji, bir dizinin boyutluluğu ile dizi tarafından temsil edilen verilerin boyutluluğu arasındaki farkı ayırt etmek için yararlı olabilir. Örneğin, a dizisi, her biri dört boyutlu bir uzayda yer alan üç noktayı temsil edebilir, ancak a’nın yalnızca iki “ekseni” vardır.

Dizi ile liste arasındaki bir diğer fark, dizinin bir elemanına, virgülle ayrılmış tek bir köşeli parantez kümesi içinde her bir eksen boyunca indeks belirtilerek erişilebilmesidir. Örneğin, 8 öğesi satır 1 ve sütun 3’:

Not: Matematikte bir matrisin elemanlarına önce satır indeksi, sonra sütun indeksi ile atıfta bulunmak bilinen bir uygulamadır. Bu, iki boyutlu diziler için doğrudur, ancak daha iyi bir zihinsel model, sütun indeksini en son gelen ve satır indeksini sondan ikinci olarak düşünmektir. Bu, herhangi bir sayıda boyuta sahip diziler için genelleştirilebilir.

Not: 0-D (sıfır boyutlu) bir diziden “skaler”, 1-D (tek boyutlu) bir diziden “vektör”, 2-D (iki boyutlu) bir diziden “matris” veya N-D (N boyutlu, burada “N” tipik olarak 2’den büyük bir tam sayıdır) bir diziden “tensör” olarak bahsedildiğini duyabilirsiniz. Anlaşılır olması için, bir diziden bahsederken matematiksel terimlerden kaçınmak en iyisidir çünkü bu isimlere sahip matematiksel nesneler dizilerden farklı davranır (örneğin, “matris” çarpımı temelde “dizi” çarpımından farklıdır) ve bilimsel Python ekosisteminde bu isimlere sahip başka nesneler de vardır (örneğin, PyTorch’un temel veri yapısı “tensör “dür).

Dizi nitelikleri

Bu bölüm, bir dizinin ndim, shape, size ve dtype niteliklerini kapsar.

Bir dizinin boyut sayısı ndim niteliğinde bulunur.

Bir dizinin şekli, her bir boyut boyunca eleman sayısını belirten negatif olmayan tam sayılardan oluşan bir çifttir.

1
2
3
4
5
6
7
8
9

# Dizinin şekli
a.shape  
Çıktı: (3, 4)

# Boyut sayısını kontrol etme
len(a.shape) == a.ndim  
Çıktı: True

Dizideki sabit, toplam eleman sayısı size niteliğinde bulunur.

1
2
3
4
5
6
7
8
9
10
11
12

# Dizideki toplam eleman sayısını öğrenme
a.size
# Çıktı: 12

# Matematik modülünü içe aktarma
import math

# Toplam eleman sayısının şeklinin çarpımına eşit olup olmadığını kontrol etme
a.size == math.prod(a.shape)
# Çıktı: True

Diziler tipik olarak “homojendir”, yani yalnızca bir “veri türünde” öğeler içerirler. Veri türü dtype niteliğinde kaydedilir.

1
2
3
4

# Dizinin veri tipini öğrenme
a.dtype  
# Çıktı: dtype('int64')  # tamsayı için "int", 64 bit için "64"

Temel bir dizi nasıl oluşturulur

Bu bölümde np.zeros(), np.ones(), np.empty(), np.arange(), np.linspace()

Bir dizi elemandan bir dizi oluşturmanın yanı sıra, 0’larla dolu bir diziyi de kolayca oluşturabilirsiniz:

1
2
3

# 2 elemanlı sıfırlarla dolu bir dizi oluşturma
np.zeros(2)  
# Çıktı: array([0., 0.])

Ya da 1’lerle dolu bir dizi:

1
2
3
4

# 2 elemanlı sıfırlarla dolu bir dizi oluşturma
np.ones(2)  
# Çıktı: array([1., 1.])

Hatta boş bir dizi bile! empty işlevi, başlangıç içeriği rastgele olan ve belleğin durumuna bağlı olan bir dizi oluşturur. Sıfır (veya benzer bir şey) yerine empty kullanmanın nedeni hızdır - sadece daha sonra her elemanı doldurduğunuzdan emin olun!

1
2
3

# 2 elemanlı boş bir dizi oluşturma
np.empty(2)  
# Çıktı: array([3.14, 42.])  # değişebilir

Eleman aralığı içeren bir dizi oluşturabilirsiniz:

1
2

np.arange(4)  
array([0, 1, 2, 3])

Ve hatta eşit aralıklı aralıklar içeren bir dizi. Bunu yapmak için, ilk sayıyı, son sayıyı ve adım boyutunu belirleyeceksiniz.

1
2
3
4

# 2 ile 9 arasındaki sayılardan 2'şer artan bir dizi oluşturma
np.arange(2, 9, 2)  
# Çıktı: array([2, 4, 6, 8])

Belirli bir aralıkta doğrusal olarak yerleştirilmiş değerler içeren bir dizi oluşturmak için np.linspace() işlevini de kullanabilirsiniz:

1
2
3

np.linspace(0, 10, num=5)  
array([ 0. , 2.5, 5. , 7.5, 10. ])

Veri türünüzü belirleme

Varsayılan veri türü kayan nokta (np.float64) olsa da, dtype anahtar sözcüğünü kullanarak hangi veri türünü istediğinizi açıkça belirtebilirsiniz.

1
2
3
4
5
6
7

# 2 elemanlı bir dizi oluşturma, tüm elemanlar 1 olacak şekilde ve veri tipi int64 olarak ayarlanmış
x = np.ones(2, dtype=np.int64)

# Diziyi görüntüleme
x
# Çıktı: array([1, 1])

Dizi oluşturma hakkında daha fazla bilgiyi buradan edinebilirsiniz

Öğeleri ekleme, kaldırma ve sıralama

Bu bölüm np.sort(), np.concatenate() işlevlerini kapsamaktadır.

Bir diziyi sıralamak np.sort() ile basittir. Fonksiyonu çağırdığınızda ekseni, türü ve sırayı belirtebilirsiniz.

Bu diziyle başlarsanız:

1
2
3

# Bir dizi oluşturma
arr = np.array([2, 1, 5, 3,

ile sayıları hızlı bir şekilde artan sırada sıralayabilirsiniz:

1
2
3
4

# Diziyi artan sırayla sıralama
np.sort(arr)  
# Çıktı: array([1, 2, 3, 4, 5, 6, 7, 8])

Bir dizinin sıralanmış bir kopyasını döndüren sort öğesine ek olarak şunu da kullanabilirsiniz:

  • argsort, belirtilen bir eksen boyunca dolaylı bir sıralamadır,

  • lexsort, birden fazla anahtar üzerinde dolaylı bir kararlı sıralamadır,

  • searchsorted, sıralanmış bir dizideki elemanları bulacak ve

  • kısmi bir sıralama olan bölüm.

Bir diziyi sıralama hakkında daha fazla bilgi edinmek için bkz.

Bu dizilerle başlarsanız:

1
2
3
4
5

# İki dizi oluşturma
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

Bunları np.concatenate() ile birleştirebilirsiniz.

1
2
3

# İki diziyi birleştirme
np.concatenate((a, b))  
# Çıktı: array([1, 2, 3, 4, 5, 6, 7, 8])

Ya da bu dizilerle başlarsanız:

1
2
3
4

# İki 2D diziyi oluşturma
x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6]])

ile birleştirebilirsiniz:

1
2
3
4
5

# İki 2D diziyi axis=0 boyunca birleştirme
np.concatenate((x, y), axis=0)  
# Çıktı: array([[1, 2],
#                [3, 4],
#                [5, 6]])

Bir diziden eleman çıkarmak için, tutmak istediğiniz elemanları seçmek üzere indeksleme kullanmak kolaydır.

Concatenate hakkında daha fazla bilgi için bkz: concatenate.

Bir dizinin şeklini ve boyutunu nasıl bilirsiniz?

Bu bölümde ndarray.ndim, .size, ndarray.shape

ndarray.ndim size dizinin eksen veya boyut sayısını söyleyecektir.

ndarray.size size dizinin toplam eleman sayısını söyleyecektir. Bu, dizinin şeklinin elemanlarının çarpımıdır.

ndarray.shape, dizinin her bir boyutunda depolanan öğe sayısını gösteren bir tamsayı çiftini görüntüler. Örneğin, 2 satırlı ve 3 sütunlu 2 boyutlu bir diziniz varsa, dizinizin şekli (2, 3) olur.

Örneğin, bu diziyi oluşturursanız:

1
2
3
4
5
6
7
8

# 3D bir dizi oluşturma
dizi_ornek = np.array([[[0, 1, 2, 3],  
                        [4, 5, 6, 7]],  
                       [[0, 1, 2, 3],  
                        [4, 5, 6, 7]],  
                       [[0, 1, 2, 3],  
                        [4, 5, 6, 7]]])

Dizinin boyut sayısını bulmak için çalıştırın:

Dizideki toplam eleman sayısını bulmak için çalıştırın:

1
2
3
4

# Dizinin toplam eleman sayısını öğrenme
array_example.size  
# Çıktı: 24

Ve dizinizin şeklini bulmak için çalıştırın:

1
2
3
4

# Dizinin şeklini öğrenme
array_example.shape  
# Çıktı: (3, 2, 4)

Bir diziyi yeniden şekillendirebilir misiniz?

Bu bölüm arr.reshape() işlevini kapsamaktadır

Evet!

arr.reshape() yöntemini kullanmak, verileri değiştirmeden bir diziye yeni bir şekil verecektir. Sadece, reshape yöntemini kullandığınızda, üretmek istediğiniz dizinin orijinal diziyle aynı sayıda elemana sahip olması gerektiğini unutmayın. Eğer 12 elemanlı bir diziyle başlıyorsanız, yeni dizinizin de toplam 12 elemanlı olduğundan emin olmanız gerekir.

Bu diziyle başlarsanız:

1
2
3

a = np.arange(6)  
print(a)  
# Çıktı: [0 1 2 3 4 5]

Dizinizi yeniden şekillendirmek için reshape() işlevini kullanabilirsiniz. Örneğin, bu diziyi üç satırlı ve iki sütunlu bir dizi olarak yeniden şekillendirebilirsiniz:

1
2
3
4
5
6

b = a.reshape(3, 2)  
print(b)  
# Çıktı:
# [[0 1]  
#  [2 3]  
#  [4 5]]

np.reshape ile birkaç isteğe bağlı parametre belirtebilirsiniz:

1
2

np.reshape(a, shape=(1, 6), order='C')  
# Çıktı: array([[0, 1, 2, 3, 4, 5]])

a, yeniden şekillendirilecek dizidir.

  • shape: İstediğiniz yeni şekildir. Bir tamsayı veya tamsayılardan oluşan bir çift belirtebilirsiniz. Bir tamsayı belirtirseniz, sonuç o uzunlukta bir dizi olacaktır. Şekil, orijinal şekil ile uyumlu olmalıdır.

  • sırası: C, C benzeri dizin sırası kullanarak öğeleri okumak/yazmak, F, Fortran benzeri dizin sırası kullanarak öğeleri okumak/yazmak, A, bellekte Fortran bitişik ise Fortran benzeri dizin sırası, aksi takdirde C benzeri sıralama ile öğeleri okumak/yazmak anlamına gelir. (Bu isteğe bağlı bir parametredir ve belirtilmesi gerekmez).

C ve Fortran sıralaması hakkında daha fazla bilgi edinmek istiyorsanız, NumPy dizilerinin iç organizasyonu hakkında daha fazla bilgiyi buradan okuyabilirsiniz. Esasen, C ve Fortran sıralamaları, dizinin bellekte saklanma sırasına indislerin nasıl karşılık geldiği ile ilgilidir. Fortran’da, bellekte depolandığı şekliyle iki boyutlu bir dizinin elemanları arasında hareket ederken, ilk indeks en hızlı değişen indekstir. İlk indeks değiştikçe bir sonraki satıra geçerken, matris her seferinde bir sütun olarak saklanır. Fortran’ın ağırlıklı bir dil olarak düşünülmesinin nedeni budur. Öte yandan C’de son indeks en hızlı değişendir. Matris satırlara göre saklanır, bu da onu ağırlıklı bir dil yapar. C veya Fortran için ne yapacağınız, indeksleme kuralını korumanın mı yoksa verileri yeniden sıralamamanın mı daha önemli olduğuna bağlıdır.

Şekil manipülasyonu hakkında daha fazla bilgiyi buradan edinebilirsiniz.

1 boyutlu bir dizi nasıl 2 boyutlu bir diziye dönüştürülür (bir diziye yeni bir eksen nasıl eklenir)

Bu bölüm np.newaxis, np.expand_dims

Mevcut dizinizin boyutlarını artırmak için np.newaxis ve np.expand_dims kullanabilirsiniz.

np.newaxis kullanımı, bir kez kullanıldığında dizinizin boyutlarını bir boyut artıracaktır. Bu,1 boyutlu bir dizinin 2 boyutlu bir dizi olacağı, 2 boyutlu bir dizinin 3 boyutlu bir dizi olacağı ve bu şekilde devam edeceği anlamına gelir.

Örneğin, bu diziyle başlarsanız:

1
2
3

a = np.array([1, 2, 3, 4, 5, 6])  
a.shape  
# Çıktı: (6,)

Yeni bir eksen eklemek için np.newaxis kullanabilirsiniz:

1
2
3

a2 = a[np.newaxis, :]  
a2.shape  
# Çıktı: (1, 6)

Bir 1D dizisini np.newaxis kullanarak açıkça bir satır vektörüne veya bir sütun vektörüne dönüştürebilirsiniz. Örneğin, ilk boyut boyunca bir eksen ekleyerek bir 1D dizisini bir satır vektörüne dönüştürebilirsiniz:

1
2
3

row_vector = a[np.newaxis, :]  
row_vector.shape  
# Çıktı: (1, 6)

Veya bir sütun vektörü için ikinci boyut boyunca bir eksen ekleyebilirsiniz:

1
2
3

col_vector = a[:, np.newaxis]  
col_vector.shape  
# Çıktı: (6, 1)

Ayrıca np.expand_dims ile belirtilen bir konuma yeni bir eksen ekleyerek bir diziyi genişletebilirsiniz. Örneğin, bu diziyle başlarsanız:

1
2
3

a = np.array([1, 2, 3, 4, 5, 6])  
a.shape  
(6,)

ile indeks konumu 1’e bir eksen eklemek için np.expand_dims kullanabilirsiniz:

1
2
3
4

```python
b = np.expand_dims(a, axis=1)  
b.shape  
# Çıktı: (6, 1)

İle indeks konumu 0’a bir eksen ekleyebilirsiniz:

1
2
3

c = np.expand_dims(a, axis=0)  
c.shape  
# Çıktı: (1, 6)

newaxis burada hakkında daha fazla bilgiyi ve expand_dims hakkında daha fazla bilgiyi expand_dims adresinde bulabilirsiniz.

İndeksleme ve dilimleme

NumPy dizilerini Python listelerini dilimlediğiniz şekilde indeksleyebilir ve dilimleyebilirsiniz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# Dizi oluşturma
veri = np.array([1, 2, 3])

# İndeksleme
veri[1]  
# Çıktı: 2

# Dilimleme
veri[0:2]  
# Çıktı: array([1, 2])

# Dilimleme
veri[1:]  
# Çıktı: array([2, 3])

# Negatif indeksle dilimleme
veri[-2:]  
# Çıktı: array([2, 3])

Bu şekilde görselleştirebilirsiniz:

../_images/np_indexing.png

Daha fazla analiz veya ek işlemlerde kullanmak için dizinizin bir bölümünü veya belirli dizi öğelerini almak isteyebilirsiniz. Bunu yapmak için, dizilerinizi alt kümelere ayırmanız, dilimlemeniz ve/veya dizinlemeniz gerekir.

Dizinizden belirli koşulları yerine getiren değerleri seçmek istiyorsanız, NumPy ile bunu kolayca yapabilirsiniz.

Örneğin, bu diziyle başlarsanız:

1

a = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Dizideki 5’ten küçük olan tüm değerleri kolayca yazdırabilirsiniz:

1
2

print(a[a < 5])  
# Çıktı: [1 2 3 4]

Ayrıca, örneğin 5’e eşit veya 5’ten büyük olan sayıları seçebilir ve bu koşulu bir diziyi indekslemek için kullanabilirsiniz:

1
2
3

beş_yukarı = (a >= 5)  
print(a[beş_yukarı])  
# Çıktı: [ 5  6  7  8  9 10 11 12]

2’ye bölünebilen öğeleri seçebilirsiniz:

1
2
3

bölünebilir_by_2 = a[a % 2 == 0]  
print(bölünebilir_by_2)  
# Çıktı: [ 2  4  6  8 10 12]

Veya & ve | operatörlerini kullanarak iki koşulu sağlayan öğeleri seçebilirsiniz:

1
2
3

c = a[(a > 2) & (a < 11)]  
print(c)  
# Çıktı: [ 3  4  5  6  7  8  9 10]

Bir dizideki değerlerin belirli bir koşulu karşılayıp karşılamadığını belirten boolean değerleri döndürmek için & ve | mantıksal operatörlerini de kullanabilirsiniz. Bu, adlar veya diğer kategorik değerler içeren dizilerde yararlı olabilir.

1
2
3
4
5
6

beş_yukarı = (a > 5) | (a == 5)  
print(beş_yukarı)  
# Çıktı:
# [[False False False False]
#  [ True  True  True  True]
#  [ True  True  True  True]]

Bir diziden eleman veya indis seçmek için np.nonzero() işlevini de kullanabilirsiniz.

Bu diziyle başlıyoruz:

1

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Örneğin 5’ten küçük olan elemanların indislerini yazdırmak için np.nonzero() kullanabilirsiniz:

1
2
3

b = np.nonzero(a < 5)  
print(b)  
# Çıktı: (array([0, 0, 0, 0]), array([0, 1, 2, 3]))

Bu örnekte, her boyut için bir tane olmak üzere bir dizi demeti döndürülmüştür. İlk dizi, bu değerlerin bulunduğu satır indislerini ve ikinci dizi, değerlerin bulunduğu sütun indislerini temsil eder.

Elemanların bulunduğu koordinatların bir listesini oluşturmak istiyorsanız, dizileri sıkıştırabilir, koordinat listesi üzerinde yineleyebilir ve bunları yazdırabilirsiniz. Örneğin:

1
2
3
4
5
6
7
8
9

list_of_coordinates = list(zip(b[0], b[1]))

for coord in list_of_coordinates:  
    print(coord)  
# Çıktı:
# (np.int64(0), np.int64(0))
# (np.int64(0), np.int64(1))
# (np.int64(0), np.int64(2))
# (np.int64(0), np.int64(3))

Bir dizideki 5’ten küçük olan elemanları np.nonzero() ile yazdırmak için de kullanabilirsiniz:

1
2

print(a[b])  
# Çıktı: [1 2 3 4]

Aradığınız eleman dizide yoksa, döndürülen indis dizisi boş olacaktır. Örneğin:

1
2
3

not_there = np.nonzero(a == 42)  
print(not_there)  
# Çıktı: (array([], dtype=int64), array([], dtype=int64))

İndeksleme ve dilimleme hakkında daha fazla bilgiyi buradan edinebilirsiniz ve buradan edinebilirsiniz.

Nonzero fonksiyonunu kullanma hakkında daha fazla bilgi için: nonzero.

Mevcut verilerden bir dizi oluşturma

Bu bölümde dilimleme ve dizinleme, np.vstack(), np.hstack(), np.hsplit(), .view(), copy() fonksiyonları hakkında bilgi bulunmaktadır.

Mevcut bir dizinin bir bölümünden kolayca yeni bir dizi oluşturabilirsiniz.

Diyelim ki bu diziye sahipsiniz:

1

a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Dizinizi dilimlemek istediğiniz yeri belirterek istediğiniz zaman dizinizin bir bölümünden yeni bir dizi oluşturabilirsiniz.

1
2
3

arr1 = a[3:8]  
print(arr1)  
# Çıktı: array([4, 5, 6, 7, 8])

Burada, dizinizin 3. dizin konumundan 8. dizin konumuna kadar olan ancak 8. konumun kendisini içermeyen bir bölümünü yakaladınız.

Hatırlatma: Dizi indeksleri 0’dan başlar. Bu, dizinin ilk elemanının indeks 0’da, ikinci elemanının indeks 1’de olduğu ve bu şekilde devam ettiği anlamına gelir.

Ayrıca mevcut iki diziyi hem dikey hem de yatay olarak istifleyebilirsiniz. Diyelim ki a1 ve a2 olmak üzere iki diziniz var:

1
2
3
4
5

a1 = np.array([[1, 1],  
               [2, 2]])

a2 = np.array([[3, 3],  
               [4, 4]])

Bunları vstack ile dikey olarak istifleyebilirsiniz:

1
2
3
4
5

np.vstack((a1, a2))  
# Çıktı: array([[1, 1],
#                [2, 2],
#                [3, 3],
#                [4, 4]])

Ya da hstack ile yatay olarak istifleyin:

1
2
3

np.hstack((a1, a2))  
# Çıktı: array([[1, 1, 3, 3],
#                [2, 2, 4, 4]])

hsplit kullanarak bir diziyi birkaç küçük diziye bölebilirsiniz. Döndürülecek eşit şekilli dizilerin sayısını veya bölünmenin hangi sütunlardan sonra gerçekleşeceğini belirtebilirsiniz.

Diyelim ki bu diziye sahipsiniz:

1
2
3
4

x = np.arange(1, 25).reshape(2, 12)  
print(x)  
# Çıktı: array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12],
#                [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]])

Bu diziyi eşit şekilli üç diziye bölmek isterseniz, şu komutu çalıştırırsınız:

1
2
3
4
5
6
7

np.hsplit(x, 3)  
# Çıktı: [array([[ 1,  2,  3,  4],
#                  [13, 14, 15, 16]]),
#         array([[ 5,  6,  7,  8],
#                  [17, 18, 19, 20]]),
#         array([[ 9, 10, 11, 12],
#                  [21, 22, 23, 24]])]

Dizinizi üçüncü ve dördüncü sütundan sonra bölmek isterseniz, çalıştırırsınız:

1
2
3
4
5
6
7

np.hsplit(x, (3, 4))  
# Çıktı: [array([[ 1,  2,  3],
#                  [13, 14, 15]]),
#         array([[ 4],
#                  [16]]),
#         array([[ 5,  6,  7,  8,  9, 10, 11, 12],
#                  [17, 18, 19, 20, 21, 22, 23, 24]])]

Dizileri yığma ve bölme hakkında daha fazla bilgiyi buradan edinebilirsiniz.

Orijinal diziyle aynı verilere bakan yeni bir dizi nesnesi oluşturmak için view yöntemini kullanabilirsiniz (sığ bir kopya).

Görünümler önemli bir NumPy kavramıdır! NumPy fonksiyonlarının yanı sıra indeksleme ve dilimleme gibi işlemler mümkün olduğunda görünümleri döndürür. Bu bellek tasarrufu sağlar ve daha hızlıdır (verilerin kopyalanması gerekmez). Ancak şunun farkında olmak önemlidir: bir görünümdeki veriyi değiştirmek orijinal diziyi de değiştirir!

Diyelim ki bu diziyi oluşturdunuz:

1

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Şimdi a‘yı dilimleyerek bir b1 dizisi oluşturuyoruz ve b1‘in ilk elemanını değiştiriyoruz. Bu, a‘daki ilgili elemanı değiştirecektir!

1
2
3
4
5
6
7
8
9
10
11
12

b1 = a[0, :]  
print(b1)  
# Çıktı: array([1, 2, 3, 4])

b1[0] = 99  
print(b1)  
# Çıktı: array([99, 2, 3, 4])

print(a)  
# Çıktı: array([[99,  2,  3,  4],
#                [ 5,  6,  7,  8],
#                [ 9, 10, 11, 12]])

Kopyalama yöntemini kullanmak, dizinin ve verilerinin tam bir kopyasını (derin bir kopya) oluşturacaktır. Bunu dizinizde kullanmak için şunu çalıştırabilirsiniz:

Kopyalar ve görünümler hakkında daha fazla bilgiyi buradan edinebilirsiniz.

Temel dizi işlemleri

Bu bölüm toplama, çıkarma, çarpma, bölme ve daha fazlasını kapsar

Dizilerinizi oluşturduktan sonra, onlarla çalışmaya başlayabilirsiniz. Örneğin, biri “data” ve diğeri “ones” adında iki dizi oluşturduğunuzu varsayalım

../_images/np_array_dataones.png

Dizileri artı işaretiyle birlikte ekleyebilirsiniz.

1
2
3
4
5

veri = np.array([1, 2])  
ones = np.ones(2, dtype=int)  

veri + ones  
# Çıktı: array([2, 3])

../_images/np_data_plus_ones.png Elbette toplama işleminden daha fazlasını yapabilirsiniz!

1
2
3
4
5
6
7
8

veri - ones  
# Çıktı: array([0, 1])

veri * veri  
# Çıktı: array([1, 4])

veri / veri  
# Çıktı: array([1., 1.])

../_images/np_sub_mult_divide.png NumPy ile temel işlemler basittir. Bir dizideki öğelerin toplamını bulmak istiyorsanız sum() işlevini kullanırsınız. Bu, 1D diziler, 2D diziler ve daha yüksek boyutlardaki diziler için çalışır.

1
2
3
4
5
6

```python
a = np.array([1, 2, 3, 4])

# Dizinin toplamını hesaplama
a.sum()  
# Çıktı: 10

Satırları veya sütunları 2B bir diziye eklemek için ekseni belirtirsiniz.

Bu diziyle başlarsanız:

1

b = np.array([[1, 1], [2, 2]])

Satır ekseni üzerinde toplama yapabilirsiniz:

1
2

b.sum(axis=0)  
# Çıktı: array([3, 3])

Sütun ekseni üzerinde toplama yapabilirsiniz:

1
2

b.sum(axis=1)  
# Çıktı: array([2, 4])

Temel işlemler hakkında daha fazla bilgiyi buradan edinebilirsiniz.

Yayınlama

Bir dizi ile tek sayı arasında (vektör ile skaler arasında da denir) veya iki farklı boyuttaki diziler arasında işlem yapmak istediğiniz zamanlar olabilir. Örneğin, diziniz (biz buna “data” diyeceğiz) mil cinsinden mesafe bilgisi içeriyor olabilir, ancak siz bu bilgiyi kilometreye dönüştürmek istiyor olabilirsiniz. Bu işlemi şu şekilde gerçekleştirebilirsiniz:

1
2
3

veri = np.array([1.0, 2.0])  
veri * 1.6  
# Çıktı: array([1.6, 3.2])

../_images/np_multiply_broadcasting.png

NumPy, çarpma işleminin her hücrede gerçekleşmesi gerektiğini anlar. Bu kavrama yayınlama denir. Broadcasting, NumPy’nin farklı şekillerdeki diziler üzerinde işlem yapmasını sağlayan bir mekanizmadır. Dizinizin boyutları uyumlu olmalıdır, örneğin, her iki dizinin boyutları eşit olduğunda veya bunlardan biri 1 olduğunda. Boyutlar uyumlu değilse, bir ValueError alırsınız.

Buradan yayıncılık hakkında daha fazla bilgi edinin.

Daha kullanışlı dizi işlemleri

Bu bölüm maksimum, minimum, toplam, ortalama, çarpım, standart sapma ve daha fazlasını kapsar

NumPy ayrıca toplama işlevleri de gerçekleştirir. Min, max ve sum’a ek olarak, ortalamayı almak için mean‘i, elemanların çarpımının sonucunu almak için prod‘yi, standart sapmayı almak için std‘yi ve daha fazlasını kolayca çalıştırabilirsiniz.

1
2
3
4
5
6
7
8
9
10
11

# Maksimum değeri bulma
data.max()  
# Çıktı: 2.0

# Minimum değeri bulma
data.min()  
# Çıktı: 1.0

# Toplam değeri hesaplama
data.sum()  
# Çıktı: 3.0

../_images/np_aggregation.png

“a” adlı bu dizi ile başlayalım:

1
2
3

a = np.array([[0.45053314, 0.17296777, 0.34376245, 0.5510652],  
              [0.54627315, 0.05093587, 0.40067661, 0.55645993],  
              [0.12697628, 0.82485143, 0.26590556, 0.56917101]])

Bir satır veya sütun boyunca toplama yapmak istemek çok yaygındır. Varsayılan olarak, her NumPy toplama fonksiyonu tüm dizinin toplamını döndürür. Dizinizdeki elemanların toplamını veya minimumunu bulmak için, çalıştırın:

Ya da:

Toplama fonksiyonunun hangi eksende hesaplanmasını istediğinizi belirtebilirsiniz. Örneğin, axis=0 olarak belirterek her sütundaki minimum değeri bulabilirsiniz:

1
2

a.min(axis=0)  
# Çıktı: array([0.12697628, 0.05093587, 0.26590556, 0.5510652])

Yukarıda listelenen dört değer, dizinizdeki sütun sayısına karşılık gelir. Dört sütunlu bir dizide, sonuç olarak dört değer elde edersiniz.

Dizi yöntemleri hakkında daha fazla bilgi için buraya tıklayın.

Matrisler oluşturma

NumPy’de temsil etmek üzere 2 boyutlu bir dizi (veya “matris”) oluşturmak için Python listelerini listeler halinde iletebilirsiniz:

1
2
3
4
5
6

veri = np.array([[1, 2], [3, 4], [5, 6]])  
print(veri)  
# Çıktı: 
# array([[1, 2],
#        [3, 4],
#        [5, 6]])

../_images/np_create_matrix.png İndeksleme ve dilimleme işlemleri matrisleri işlerken kullanışlıdır:

1
2
3
4
5
6
7
8
9
10
11
12

# Belirli bir elemanı seçme
veri[0, 1]  
# Çıktı: 2

# Dilimleme - 1. ve 2. satırları seçme
veri[1:3]  
# Çıktı: array([[3, 4],
#                [5, 6]])

# Dilimleme - İlk iki satırın ilk sütununu seçme
veri[0:2, 0]  
# Çıktı: array([1, 3])

../_images/np_matrix_indexing.png Vektörleri topladığınız gibi matrisleri de toplayabilirsiniz:

data dizisiyle başlayalım:

1
2
3
4
5
6
7
8

data.max()  
# Çıktı: 6

data.min()  
# Çıktı: 1

data.sum()  
# Çıktı: 21

np_matrix_aggregation

Bir matristeki tüm değerleri toplayabilir ve axis parametresini kullanarak bunları sütunlar veya satırlar arasında toplayabilirsiniz. Bu noktayı açıklamak için, biraz değiştirilmiş bir veri kümesine bakalım:

1
2
3
4
5
6

veri = np.array([[1, 2], [5, 3], [4, 6]])
print(veri)
# Çıktı:
# array([[1, 2],
#        [5, 3],
#        [4, 6]])

Sütunlarda maksimum değeri bulmak için:

1
2

data.max(axis=0)  
# Çıktı: array([5, 6])

Satırlarda maksimum değeri bulmak için:

1
2

data.max(axis=1)  
# Çıktı: array([2, 5, 6])

np_matrix_aggregation_row

Matrislerinizi oluşturduktan sonra, aynı boyutta iki matrisiniz varsa aritmetik operatörleri kullanarak bunları toplayabilir ve çarpabilirsiniz:

1
2
3
4
5
6
7

veri = np.array([[1, 2], [3, 4]])
ones = np.array([[1, 1], [1, 1]])

veri + ones  
# Çıktı:
# array([[2, 3],
#        [4, 5]])

np_matrix_arithmetic

Bu aritmetik işlemleri farklı boyutlardaki matrisler üzerinde yapabilirsiniz, ancak yalnızca bir matrisin yalnızca bir sütunu veya bir satırı varsa. Bu durumda, NumPy işlem için kendi yayınlama (broadcasting) kurallarını kullanacaktır:

1
2
3
4
5
6
7
8

veri = np.array([[1, 2], [3, 4], [5, 6]])
ones_row = np.array([[1, 1]])

veri + ones_row  
# Çıktı:
# array([[2, 3],
#        [4, 5],
#        [6, 7]])

np_matrix_broadcasting

NumPy N boyutlu dizileri yazdırırken, ilk eksen en yavaşken son eksenin en hızlı şekilde döngüye girdiğini unutmayın. Örneğin:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

np.ones((4, 3, 2))  
# Çıktı:
# array([[[1., 1.],
#         [1., 1.],
#         [1., 1.]],
#        
#        [[1., 1.],
#         [1., 1.],
#         [1., 1.]],
#        
#        [[1., 1.],
#         [1., 1.],
#         [1., 1.]],
#        
#        [[1., 1.],
#         [1., 1.],
#         [1., 1.]]])

NumPy’nin bir dizinin değerlerini başlatmasını istediğimiz durumlar vardır. NumPy bunun için ones() ve zeros() gibi fonksiyonlar ve rastgele sayı üretimi için random.Generator sınıfı sunar. Tek yapmanız gereken, üretmesini istediğiniz eleman sayısını girmektir:

1
2
3
4
5
6
7
8
9

np.ones(3)  
# Çıktı: array([1., 1., 1.])

np.zeros(3)  
# Çıktı: array([0., 0., 0.])

rng = np.random.default_rng()  # Rastgele sayı üretmenin en basit yolu  
rng.random(3)  
# Çıktı: array([0.63696169, 0.26978671, 0.04097352])  # Değişebilir

np_ones_zeros_random

Ayrıca ones(), zeros() ve random() işlevlerini, matrisin boyutlarını tanımlayan bir tuple verirseniz 2D bir dizi oluşturmak için kullanabilirsiniz:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

np.ones((3, 2))  
# Çıktı:
# array([[1., 1.],
#        [1., 1.],
#        [1., 1.]])

np.zeros((3, 2))  
# Çıktı:
# array([[0., 0.],
#        [0., 0.],
#        [0., 0.]])

rng.random((3, 2))  
# Çıktı:
# array([[0.01652764, 0.81327024],
#        [0.91275558, 0.60663578],
#        [0.72949656, 0.54362499]])  # Değişebilir

np_ones_zeros_matrix

0’larla, 1’lerle, diğer değerlerle dolu veya başlatılmamış diziler oluşturma hakkında daha fazla bilgiyi oluşturma rutinlerinde bulabilirsiniz.

Rastgele sayı üretme

Rastgele sayı üretiminin kullanımı, birçok sayısal ve makine öğrenimi algoritmasının yapılandırılması ve değerlendirilmesinin önemli bir parçasıdır. İster bir yapay sinir ağında ağırlıkları rastgele başlatmanız, ister verileri rastgele kümelere ayırmanız veya veri kümenizi rastgele karıştırmanız gereksin, rastgele sayılar (aslında tekrarlanabilir sözde rastgele sayılar) üretebilmek çok önemlidir.

Generator.integers ile, düşükten (NumPy ile bunun kapsayıcı olduğunu unutmayın) yükseğe (özel) rastgele tam sayılar üretebilirsiniz. Yüksek sayıyı kapsayıcı yapmak için endpoint=True olarak ayarlayabilirsiniz.

ile 0 ile 4 arasında rastgele tamsayılardan oluşan 2 x 4’lük bir dizi oluşturabilirsiniz:

Rastgele Sayı Üretimi

1
2
3
4

rng = np.random.default_rng()  # Rastgele sayı üreticisi
rng.integers(5, size=(2, 4))  
# Çıktı: array([[2, 1, 1, 0],
#               [0, 0, 0, 4]])  # Değişebilir

Rastgele sayı üretimi hakkında daha fazla bilgi için tıklayın.

Benzersiz Öğeler ve Sayılar Nasıl Elde Edilir

Bu bölüm np.unique() işlevini kapsar.

Bir dizideki benzersiz elemanları np.unique ile kolayca bulabilirsiniz.

Örneğin, bu diziyle başlarsanız:

1

a = np.array([11, 11, 12, 13, 14, 15, 16, 17, 12, 13, 11, 14, 18, 19, 20])

Dizinizdeki benzersiz değerleri yazdırmak için:

1
2
3

unique_values = np.unique(a)  
print(unique_values)  
# Çıktı: [11 12 13 14 15 16 17 18 19 20]

Benzersiz değerlerin indislerini almak için return_index argümanını kullanabilirsiniz:

1
2
3

unique_values, indices_list = np.unique(a, return_index=True)  
print(indices_list)  
# Çıktı: [ 0  2  3  4  5  6  7 12 13 14]

Benzersiz değerlerin frekans sayılarını almak için return_counts argümanını kullanabilirsiniz:

1
2
3

unique_values, occurrence_count = np.unique(a, return_counts=True)  
print(occurrence_count)  
# Çıktı: [3 2 2 2 1 1 1 1 1 1]

Bu işlem 2D dizilerle de çalışır. Örneğin:

1
2
3
4

a_2d = np.array([[1, 2, 3, 4],  
                 [5, 6, 7, 8],  
                 [9, 10, 11, 12],  
                 [1, 2, 3, 4]])

Benzersiz değerleri bulmak için:

1
2
3

unique_values = np.unique(a_2d)  
print(unique_values)  
# Çıktı: [ 1  2  3  4  5  6  7  8  9 10 11 12]

Eksen bağımsız değişkeni geçilmezse, 2D dizi düzleştirilir.

Benzersiz Satırları veya Sütunları Bulma

Benzersiz satırları bulmak için axis=0 belirtin:

1
2
3
4
5
6

unique_rows = np.unique(a_2d, axis=0)  
print(unique_rows)  
# Çıktı:
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]

Benzersiz satırları, indis konumlarını ve oluşum sayılarını almak için:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

unique_rows, indices, occurrence_count = np.unique(
    a_2d, axis=0, return_counts=True, return_index=True
)  
print(unique_rows)  
# Çıktı:
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]

print(indices)  
# Çıktı: [0 1 2]

print(occurrence_count)  
# Çıktı: [2 1 1]

Bir dizideki benzersiz öğeler hakkında daha fazla bilgi için buraya tıklayın.

Bir Matrisin Aktarılması ve Yeniden Şekillendirilmesi

Bu bölüm arr.reshape(), arr.transpose(), arr.T işlevlerini kapsar.

Matrislerinizi transpoze etmeniz yaygın bir ihtiyaçtır. NumPy dizileri, bir matrisi transpoze etmenizi sağlayan T özelliğine sahiptir.

np_transposing_reshaping

Bir matrisin boyutlarını değiştirmeniz de gerekebilir. Bu durum, örneğin, veri kümenizden farklı olan belirli bir girdi şekli bekleyen bir modeliniz olduğunda ortaya çıkabilir. İşte bu noktada reshape() yöntemi faydalı olabilir. Tek yapmanız gereken matris için istediğiniz yeni boyutları girmektir.

1
2
3
4
5
6
7
8
9
10
11
12

data = np.array([1, 2, 3, 4, 5, 6])

data.reshape(2, 3)  
# Çıktı:
# array([[1, 2, 3],
#        [4, 5, 6]])

data.reshape(3, 2)  
# Çıktı:
# array([[1, 2],
#        [3, 4],
#        [5, 6]])

np_reshape

Bir dizinin eksenlerini belirttiğiniz değerlere göre tersine çevirmek veya değiştirmek için .transpose() işlevini kullanabilirsiniz.

Bu diziyle başlarsanız:

1
2
3
4
5

arr = np.arange(6).reshape((2, 3))  
print(arr)  
# Çıktı:
# array([[0, 1, 2],
#        [3, 4, 5]])

Dizinizi arr.transpose() ile transpoze edebilirsiniz:

1
2
3
4
5

arr.transpose()  
# Çıktı:
# array([[0, 3],
#        [1, 4],
#        [2, 5]])

arr.T‘yi de kullanabilirsiniz:

1
2
3
4
5

arr.T  
# Çıktı:
# array([[0, 3],
#        [1, 4],
#        [2, 5]])

Dizilerin aktarılması ve yeniden şekillendirilmesi hakkında daha fazla bilgi edinebilirsiniz.

Bir Dizi Nasıl Tersine Çevrilir

Bu bölüm np.flip() işlevini kapsar.

NumPy’nin np.flip() fonksiyonu, bir dizinin içeriğini bir eksen boyunca tersine çevirmenize olanak tanır. np.flip() fonksiyonunu kullanırken, tersine çevirmek istediğiniz diziyi ve ekseni belirtirsiniz. Ekseni belirtmezseniz, NumPy giriş dizinizin tüm eksenleri boyunca içeriği tersine çevirecektir.

1 Boyutlu Bir Diziyi Tersine Çevirme

Bunun gibi 1 boyutlu bir dizi ile başlarsanız:

1
2
3
4
5

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

ters_arr = np.flip(arr)
print("Tersine Çevrilmiş Dizi:", ters_arr)
# Çıktı: Tersine Çevrilmiş Dizi: [8 7 6 5 4 3 2 1]

2B Diziyi Tersine Çevirme

2 boyutlu bir dizi de aynı şekilde çalışır. Bu diziyle başlarsanız:

1
2
3

arr_2d = np.array([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12]])

Tüm satırlardaki ve sütunlardaki içeriği tersine çevirebilirsiniz:

1
2
3
4
5
6

reversed_arr = np.flip(arr_2d)
print(reversed_arr)
# Çıktı:
# [[12 11 10  9]
#  [ 8  7  6  5]
#  [ 4  3  2  1]]

Sadece satırları tersine çevirmek için:

1
2
3
4
5
6

reversed_arr_rows = np.flip(arr_2d, axis=0)
print(reversed_arr_rows)
# Çıktı:
# [[ 9 10 11 12]
#  [ 5  6  7  8]
#  [ 1  2  3  4]]

Sadece sütunları tersine çevirmek için:

1
2
3
4
5
6

reversed_arr_columns = np.flip(arr_2d, axis=1)
print(reversed_arr_columns)
# Çıktı:
# [[ 4  3  2  1]
#  [ 8  7  6  5]
#  [12 11 10  9]]

Dizin konumu 1’deki (ikinci satır) satırın içeriğini tersine çevirebilirsiniz:

1
2
3
4
5
6

arr_2d[1] = np.flip(arr_2d[1])
print(arr_2d)
# Çıktı:
# [[ 1  2  3  4]
#  [ 8  7  6  5]
#  [ 9 10 11 12]]

Dizin konumu 1’deki (ikinci sütun) sütunu tersine çevirmek için:

1
2
3
4
5
6

arr_2d[:, 1] = np.flip(arr_2d[:, 1])
print(arr_2d)
# Çıktı:
# [[ 1 10  3  4]
#  [ 8  7  6  5]
#  [ 9  2 11 12]]

Dizileri ters çevirme hakkında daha fazla bilgi edinebilirsiniz.

Çok Boyutlu Dizileri Yeniden Şekillendirme ve Düzleştirme

Bu bölüm .flatten() ve ravel() işlevlerini kapsar.

Bir diziyi düzleştirmenin iki popüler yolu vardır: .flatten() ve .ravel(). İkisi arasındaki temel fark:

  • ravel() kullanılarak oluşturulan yeni dizi ana diziye referans (görünüm) olur. Bu nedenle, değişiklikler ana diziyi etkiler.
  • flatten() ise kopya oluşturur. Yeni dizi üzerinde yapılan değişiklikler ana diziyi etkilemez.

Örnek: Düzleştirme İşlemi

Bu diziyle başlarsanız:

1
2
3

x = np.array([[1, 2, 3, 4],
              [5, 6, 7, 8],
              [9, 10, 11, 12]])

flatten() kullanarak:

1
2

x.flatten()
# Çıktı: array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

Yeni dizide değişiklikler ana diziyi etkilemez:

1
2
3
4
5
6
7
8
9
10

a1 = x.flatten()
a1[0] = 99
print(x)  # Orijinal dizi
# Çıktı:
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]

print(a1)  # Yeni dizi
# Çıktı: [99  2  3  4  5  6  7  8  9 10 11 12]

ravel() kullanarak:

1
2
3
4
5
6
7
8
9
10

a2 = x.ravel()
a2[0] = 98
print(x)  # Orijinal dizi
# Çıktı:
# [[98  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]

print(a2)  # Yeni dizi
# Çıktı: [98  2  3  4  5  6  7  8  9 10 11 12]

flatten hakkında daha fazla bilgi için tıklayın
ravel hakkında daha fazla bilgi için tıklayın.

Matematiksel formüllerle çalışma

Diziler üzerinde çalışan matematiksel formülleri uygulama kolaylığı, NumPy’nin bilimsel Python topluluğunda bu kadar yaygın olarak kullanılmasını sağlayan şeylerden biridir.

Örneğin, bu ortalama kare hata formülüdür (regresyonla ilgilenen denetimli makine öğrenimi modellerinde kullanılan merkezi bir formül):

../_images/np_MSE_formula.png

Bu formülü uygulamak NumPy’de basit ve anlaşılırdır:

../_images/np_MSE_implementation.png Bunun bu kadar iyi çalışmasını sağlayan şey, tahminlerin ve etiketlerin bir veya bin değer içerebilmesidir. Sadece aynı boyutta olmaları gerekir.

Bu şekilde görselleştirebilirsiniz:

../_images/np_mse_viz1.png Bu örnekte, hem tahminler hem de etiketler vektörleri üç değer içerir, yani n üç değerine sahiptir. Çıkarma işlemlerini gerçekleştirdikten sonra vektördeki değerlerin karesi alınır. Daha sonra NumPy değerleri toplar ve sonuç, bu tahmin için hata değeri ve modelin kalitesi için bir puandır.

../_images/np_mse_viz2.png ../_images/np_MSE_explanation2.png

NumPy nesneleri nasıl kaydedilir ve yüklenir

Bu bölüm np.save, np.savez, np.savetxt, np.load, np.loadtxt dosyalarını kapsamaktadır.

Bir noktada, dizilerinizi diske kaydetmek ve kodu yeniden çalıştırmak zorunda kalmadan geri yüklemek isteyeceksiniz. Neyse ki, NumPy ile nesneleri kaydetmenin ve yüklemenin birkaç yolu vardır. ndarray nesneleri, normal metin dosyalarını işleyen loadtxt ve savetxt fonksiyonları, .npy dosya uzantılı NumPy ikili dosyalarını işleyen load ve save fonksiyonları ve .npz uzantılı NumPy dosyalarını işleyen savez fonksiyonu ile disk dosyalarına kaydedilebilir ve bu dosyalardan yüklenebilir.

.npy ve .npz dosyaları, dosya farklı mimariye sahip başka bir makinede olsa bile dizinin doğru şekilde alınmasını sağlayacak şekilde ndarray’i yeniden yapılandırmak için gereken verileri, şekli, d türünü ve diğer bilgileri depolar.

Tek bir ndarray nesnesini saklamak istiyorsanız, np.save kullanarak .npy dosyası olarak saklayın. Birden fazla ndarray nesnesini tek bir dosyada saklamak istiyorsanız, np.savez kullanarak .npz dosyası olarak kaydedin. Ayrıca savez_compressed ile birkaç diziyi sıkıştırılmış npz formatında tek bir dosyaya kaydedebilirsiniz.

Bir diziyi np.save() ile kaydetmek ve yüklemek kolaydır. Sadece kaydetmek istediğiniz diziyi ve bir dosya adı belirttiğinizden emin olun. Örneğin, bu diziyi oluşturursanız:

NumPy Dizilerini Kaydetme ve Yükleme

Bir NumPy dizisini .npy formatında kaydedebilirsiniz. Örneğin:

1
2
3
4

a = np.array([1, 2, 3, 4, 5, 6])

# Diziyi "dosyaadı.npy" olarak kaydetme
np.save('dosyaadı', a)

Diziyi yeniden oluşturmak için np.load() kullanabilirsiniz:

1
2
3

b = np.load('dosyaadı.npy')
print(b)
# Çıktı: [1 2 3 4 5 6]

Diziyi Düz Metin Dosyası Olarak Kaydetme

Bir NumPy dizisini .csv veya .txt gibi düz metin dosyası olarak np.savetxt() kullanarak kaydedebilirsiniz.

Örneğin, bu diziyi oluşturursanız:

1

csv_arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

Diziyi kolayca bir .csv dosyası olarak kaydedebilirsiniz:

1

np.savetxt('new_file.csv', csv_arr)

Kaydedilmiş dosyanızı np.loadtxt() kullanarak yükleyebilirsiniz:

1
2

np.loadtxt('new_file.csv')
# Çıktı: array([1., 2., 3., 4., 5., 6., 7., 8.])

savetxt() ve loadtxt() işlevleri üstbilgi, altbilgi ve sınırlayıcı gibi isteğe bağlı parametreler kabul eder. Ancak .npy ve .npz dosyaları daha küçüktür ve daha hızlı yüklenir.

Giriş ve çıkış rutinleri hakkında daha fazla bilgi için buraya tıklayın.

CSV Dosyalarını İçe ve Dışa Aktarma

Mevcut bir CSV dosyasını okumak için Pandas kullanmak en iyi ve en kolay yoldur:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import pandas as pd

# Tüm sütunları okuma
x = pd.read_csv('music.csv', header=0).values
print(x)
# Çıktı:
# [['Billie Holiday' 'Jazz' 1300000 27000000]
#  ['Jimmie Hendrix' 'Rock' 2700000 70000000]
#  ['Miles Davis' 'Jazz' 1500000 48000000]
#  ['SIA' 'Pop' 2000000 74000000]]

# Belirli sütunları seçme
x = pd.read_csv('music.csv', usecols=['Artist', 'Plays']).values
print(x)
# Çıktı:
# [['Billie Holiday' 27000000]
#  ['Jimmie Hendrix' 70000000]
#  ['Miles Davis' 48000000]
#  ['SIA' 74000000]]

np_pandas

Diziyi Pandas kullanarak CSV’ye dışa aktarmak da kolaydır. Örneğin:

1
2
3
4
5
6
7
8

a = np.array([[-2.58289208, 0.43014843, -1.24082018, 1.59572603],
              [ 0.99027828, 1.17150989, 0.94125714, -0.14692469],
              [ 0.76989341, 0.81299683, -0.95068423, 0.11769564],
              [ 0.20484034, 0.34784527, 1.96979195, 0.51992837]])

# Pandas DataFrame oluşturma
df = pd.DataFrame(a)
print(df)

Çıktı:

 0123
0-2.582890.430148-1.240821.595726
10.9902781.171510.941257-0.146925
20.7698930.812997-0.9506840.117696
30.204840.3478451.9697920.519928

CSV’ye dışa aktarma:

1

df.to_csv('data.csv', index=False)

Pandas hakkında daha fazla bilgi için resmi Pandas belgelerine göz atın.

Matplotlib ile Dizileri Çizme

Değerlerinizi görselleştirmeniz gerekiyorsa Matplotlib kullanabilirsiniz. Örneğin:

1
2
3
4
5
6
7
8
9
10

import matplotlib.pyplot as plt

# Bir NumPy dizisi oluşturma
a = np.array([2, 1, 5, 7, 4, 6, 8, 14, 10, 9, 18, 20, 22])

# Diziyi çizme
plt.plot(a)

# Komut satırında çalıştırıyorsanız:
plt.show()

matplotlib1

Çoklu Görselleştirme

1D bir diziyi çizmek:

1
2
3
4
5
6
7
8
9

x = np.linspace(0, 5, 20)
y = np.linspace(0, 10, 20)

# Çizgi grafiği
plt.plot(x, y, 'purple')  # Mor çizgi

# Noktalar
plt.plot(x, y, 'o')  # Nokta grafiği
plt.show()

matplotlib2

3D Yüzey Grafikleri

1
2
3
4
5
6
7
8
9
10
11

fig = plt.figure()
ax = fig.add_subplot(projection='3d')

X = np.arange(-5, 5, 0.15)
Y = np.arange(-5, 5, 0.15)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='viridis')
plt.show()

matplotlib3

SORULAR

  1. Numpy modülü kullanılarak sezar şifreleme uygulaması yapınız.
Veri Analizi
numpy,matrix,vector,tensor
This post is licensed under CC BY 4.0 by the author.