Python Numpy Array Eğitimi

Python Wheels ile Kurulum

Öncelikle Python’un kurulu olduğundan emin olun. Bunu hâlâ yapmanız gerekiyorsa Python nasıl kurulur rehberimize göz atabilirsiniz :)

Windows’ta çalışıyorsanız, Python’u PATH ortam değişkenine eklediğinizden emin olun. Ardından, Python’un açık kaynak kütüphanelerini kullanabilmenizi sağlayacak pip gibi bir paket yöneticisi kurmayı unutmayın.

Python 3’ün yeni sürümlerinin pip ile geldiğini unutmayın; bu yüzden pip’iniz olup olmadığını iki kez kontrol edin ve varsa, NumPy’yi kurmadan önce yükseltin:

pip install pip --upgrade
pip --version

pip install numpy-<version>-<architecture>.whl

import numpy

Anaconda Python Dağıtımı ile Kurulum

NumPy edinmek için Anaconda Python dağıtımını da indirebilirsiniz. Bu yöntem kolaydır ve hızlı başlamanızı sağlar! Henüz indirmediyseniz resmi sayfaya giderek edinin. Kurulum talimatlarını izleyin ve hazırsınız!

Neden bunun daha kolay olabileceğini merak ediyor musunuz?

Bu Python dağıtımını edinmenin güzel yanı, veri analizlerinizde kullanacağınız NumPy veya pandas, scikit-learn vb. büyük paketleri ayrıca kurma konusunda fazla endişelenmenize gerek olmamasıdır.

Özellikle Python’a, programlamaya veya terminallere çok yeniyseniz, Anaconda’nın veri bilimi için en popüler 100 Python, R ve Scala paketini zaten içermesi gerçekten rahatlatıcı olabilir. Ancak daha deneyimli veri bilimciler için de veri bilimi problemlerine hızla başlamak istiyorsanız Anaconda doğru yoldur.

Dahası, Anaconda Jupyter ve Spyder gibi çeşitli açık kaynak geliştirme ortamlarını da içerir. Bu eğitimden sonra Jupyter Notebook ile çalışmaya başlamak isterseniz, Jupyter notebook eğitimimize gidin.

Kısacası, NumPy ve veri bilimiyle ilgili diğer paketlerle çalışmaya başlamak için Anaconda’yı indirmeyi düşünün!

“Boş” NumPy Dizisi Nasıl Yapılır

İnsanlar “boş” diziler oluşturduklarını söylediklerinde genellikle kastettikleri, sonradan doldurabileceğiniz başlangıç yer tutucularını kullanmaktır. Dizileri 1’lerle veya 0’larla başlatabilirsiniz; ayrıca eşit aralıklı değerlerle, sabit veya rastgele değerlerle doldurulan diziler de oluşturabilirsiniz.

Yine de tamamen boş bir dizi de yapabilirsiniz.

Neyse ki bunun için epey işlev var.

Aşağıda hepsini deneyin!

import numpy as np

# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()

# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()

# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()

# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()

# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()

# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()

# Create an array of evenly-spaced values
np.linspace(0,2,9)

İpucu: Yukarıdaki işlevlerle oynayarak nasıl çalıştıklarını anlayın!

• np.ones(), np.random.random(), np.empty(), np.full() veya np.zeros() gibi bazıları için, 1’lerle veya 0’larla diziler oluşturmak için yapmanız gereken tek şey, oluşturmak istediğiniz dizinin şeklini geçmektir. np.ones() ve np.zeros() için seçenek olarak veri türünü de belirtebilirsiniz. np.full() durumunda, diziye yerleştirmek istediğiniz sabit değeri de belirtmeniz gerekir.
• np.linspace() ve np.arange() ile eşit aralıklı değerlerden oluşan diziler yapabilirsiniz. Bu iki işlev arasındaki fark, yukarıdaki kod parçasında geçirilen üç değerden sonuncusunun np.linspace() için örnek sayısını, np.arange() için ise adım değerini belirtmesidir. İlkinde, örneğin 0 ile 2 arasında yer alan 9 değerlik bir dizi istersiniz. İkincisinde ise 10’dan başlayan ve 5’er adımlarla oluşturulan değerlerden oluşan bir dizi istersiniz.

NumPy’nin ayrıca np.eye() ve np.identity() ile birim dizi veya matris oluşturmanıza izin verdiğini unutmayın. Birim matris, ana köşegenindeki tüm öğelerin 1, diğer tüm öğelerin 0 olduğu kare bir matristir. Bir matrisi birim matrisle çarptığınızda, verilen matris değişmeden kalır.

Başka bir deyişle, bir matrisi birim matrisle çarparsanız, matris çarpımının standart kurallarına göre ortaya çıkan çarpım yine aynı matris olacaktır.

Bu eğitimin odağı birim matrislerin nasıl çalıştığını göstermek olmasa da, matris hesaplamalarına başladığınızda birim matrislerin yararlı olduğunu söylemek yeterlidir: matematiksel denklemleri basitleştirerek hesaplamalarınızı daha verimli ve sağlam hale getirebilirler.

Metinden NumPy Dizileri Nasıl Yüklenir

Başlangıç yer tutucularından yararlanarak veya bazı örnek verilerle diziler oluşturmak, numpy ile çalışmaya başlamak için harika bir yoldur. Ancak veri analizine başlamak istediğinizde, verileri metin dosyalarından yüklemeniz gerekecektir.

Şimdiye kadar gördüklerinizle çok fazla bir şey yapamazsınız. Dosyalarınızdaki verileri yüklemek için loadtxt() veya genfromtxt() gibi belirli işlevlerden yararlanın.

Diyelim ki aşağıdaki gibi veriler içeren metin dosyalarınız var; aşağıdaki kodda yorum satırlarında yer alan değerleri kopyalayıp bir metin dosyasına yapıştırın ve “data.txt” olarak kaydedin. Ardından aşağıdaki kodu kullanabilirsiniz:

# This is your data in the text file
# Value1  Value2  Value3
# 0.2536  0.1008  0.3857
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  0.5929
# 0.1781  0.3049  0.8928
# 0.6253  0.3486  0.8791

# Import your data
x, y, z = np.loadtxt('data.txt',
                    skiprows=1,
                    unpack=True)

Yukarıdaki kodda verileri ortamınıza yüklemek için loadtxt() kullanırsınız. Her iki işlevin de aldığı ilk argümanın data.txt metin dosyası olduğunu görüyorsunuz. Sonra her biri için bazı belirli argümanlar vardır: ilk ifadede ilk satırı atlar ve sütunları ayrı diziler olarak döndürmek için unpack=TRUE kullanırsınız. Bu, Value1 sütunundaki değerlerin x’e konulacağı anlamına gelir, vb.

Virgülle ayrılmış verileriniz varsa veya veri türünü belirtmek istiyorsanız, loadtxt() argümanlarına ekleyebileceğiniz delimiter ve dtype argümanlarının da olduğunu unutmayın.

Kolay ve anlaşılır, değil mi?

İkinci veri dosyanıza bakalım:

# Your data in the text file
# Value1  Value2  Value3
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  MISSING
# 0.1781  0.3049  0.8928
# MISSING 0.5801  0.2038
# 0.5993  0.4357  0.7410

my_array2 = np.genfromtxt('data2.txt',
                      skip_header=1,
                      filling_values=-999)

Burada verileri yüklemek için genfromtxt()’ye başvurduğunuzu görüyorsunuz. Bu durumda, 'MISSING' dizgileriyle belirtilen bazı eksik değerlerle başa çıkmanız gerekir.

genfromtxt() işlevi, sayısal sütunlardaki karakter dizgilerini nan’a dönüştürdüğünden, filling_values argümanını belirterek bu değerleri başka değerlere çevirebilirsiniz. Bu durumda, bu eksik değerlerin değerini -999 olarak ayarlamayı seçiyorsunuz.

Her ne sebeple olursa olsun, genfromtxt() tarafından nan’a dönüştürülmeyen değerleriniz varsa, verilerinizdeki eksik değerlerin tam olarak ne olduğunu belirtmenize olanak tanıyan missing_values argümanı her zaman vardır.

Ancak hepsi bu değil.

İpucu: Verilerinizi başarıyla içe aktarmak için başka hangi argümanları ekleyebileceğinizi görmek için bu numpy.genfromtxt sayfasına göz atın.

Şimdi bu iki işlev arasındaki gerçek farkın ne olduğunu merak ediyor olabilirsiniz.

Örnekler bunu belki örtük olarak gösterdi; ancak genel olarak genfromtxt() size biraz daha fazla esneklik sağlar; loadtxt()’den daha sağlamdır.

Bu farkı biraz daha pratik hale getirelim: loadtxt(), yalnızca metin dosyasındaki her satır aynı sayıda değer içerdiğinde çalışır; bu nedenle eksik değerleri kolayca ele almak istediğinizde, genellikle genfromtxt() kullanmanın daha kolay olduğunu göreceksiniz.

Ancak bu kesinlikle tek neden değil.

genfromtxt()’nin sunduğu argümanların sayısına kısaca bakmak, içe aktarmada gerçekten belirtilebilecek çok daha fazla şey olduğunu gösterecektir; örneğin okunacak maksimum satır sayısı veya değişkenlerden boşlukları otomatik olarak kırpma seçeneği gibi.

NumPy Dizileri Nasıl Kaydedilir

Dizilerinizle yapmanız gereken her şeyi yaptıktan sonra, onları bir dosyaya da kaydedebilirsiniz. Diziyi bir metin dosyasına kaydetmek istiyorsanız bunu yapmak için savetxt() işlevini kullanabilirsiniz:

import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')

np.arange()’ın eşit aralıklı değerlerden oluşan bir NumPy dizisi oluşturduğunu unutmayın. Bu işleve verdiğiniz üçüncü değer adım değeridir.

Elbette NumPy dizilerinizi metin dosyalarına kaydetmenin başka yolları da vardır. Verilerinizi ikili dosyalara veya arşivlere almak istiyorsanız aşağıdaki tablodaki işlevlere göz atın:

Yukarıdaki işlevleri verilerinizi kaydetmek için nasıl kullanabileceğiniz hakkında daha fazla bilgi veya örnek için şu NumPy başvuru sayfasına göz atın veya daha hızlı bilgi edinmek için NumPy’nin sunduğu yardım işlevlerinden birini kullanın!

Bu NumPy yardım işlevlerinin ne olduğundan emin değil misiniz?

Merak etmeyin! Bunlar hakkında bir sonraki bölümlerde daha fazla şey öğreneceksiniz!

NumPy Dizilerinizi Nasıl İncelersiniz

Yukarıda bahsedilen data, shape, dtype ve strides gibi dizi özniteliklerine ek olarak, dizileriniz hakkında daha fazla bilgi edinmek için kolayca kullanabileceğiniz başka öznitelikler de vardır. Yeni başlarken kullanışlı bulabileceğiniz bazıları şunlardır:

import numpy as np

# Create a numpy array with shape (2,4) and dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the number of dimensions of `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()

# Print the number of elements in `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()

# Print information about the memory layout of `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()

# Print the length of one array element in bytes
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()

# Print the total consumed bytes by `my_array`'s elements
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()

Bunlar, bir dizinin sahip olabileceği özniteliklerin neredeyse tamamıdır.

Bu noktada hepsinin sizin için faydalı olmadığını hissediyorsanız endişelenmeyin. Bu oldukça normaldir; çünkü, önceki bölümde okuduğunuz gibi, yalnızca büyük veri kümeleriyle çalışırken bellek konusunda endişelenmeye başlarsınız.

Ayrıca özniteliklerin yanı sıra, diziniz hakkında daha fazla bilgi edinmenin ve hatta onu biraz ayarlamanın başka yolları da olduğunu unutmayın:

import numpy as np
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the length of `my_array`
print(len(my_array))

# Change the data type of `my_array`
my_array.astype(float)

Artık dizinizi, ya np.array() ile ya da başlangıç yer tutucu işlevlerinden biriyle kendiniz oluşturarak ya da loadtxt() veya genfromtxt() işlevleriyle verilerinizi yükleyerek oluşturduğunuza göre, NumPy kütüphanesini gerçekten tanımlayan ikinci temel unsura daha yakından bakmanın zamanı geldi: bilimsel hesaplama.

Dizilerinizi Nasıl Transpoze Edersiniz

Dizilerinizi transpoze etmek aslında onun boyutlarını permütasyonlamaktır. Başka bir deyişle, dizinin şeklini değiştirirsiniz. Transpozisyonun etkisini göstermek için küçük bir örnek alalım:

import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array`
print(my_2d_array)

# Transpose `my_2d_array`
print(np.transpose(my_2d_array))

# Or use `T` to transpose `my_2d_array`
print(my_2d_array.T)

İpucu: Dizi ile onun transpoze edilmiş sürümünün görsel karşılaştırması tam olarak net değilse, boyutların neden permütasyonlandığını anlamak için her iki dizinin şeklini inceleyin.

İki transpoze işlevi olduğunu unutmayın. Her ikisi de aynı şeyi yapar; aralarında çok fazla fark yoktur. T’nin daha çok bir kolaylık işlevi olduğunu, np.transpose() ile ise çok daha fazla esnekliğe sahip olduğunuzu hesaba katmanız gerekir. Daha fazla argüman kullanmak istiyorsanız bu işlevi kullanmanız önerilir.

Bir boyuttan büyük dizileri transpoze ederken her şey yolundadır; ama yalnızca 1B bir diziniz olduğunda ne olur? Sizce bir etkisi olur mu?

Kendiniz deneyin. 1B diziniz zaten yüklendi:

import numpy as np
my_array = np.array([1,2,3,4])

# Print `my_2d_array
print(my_array)

# Transpose `my_2d_array
print(np.transpose(my_array))

# Or use `T` to transpose `my_2d_array
print(my_array.T)

Tamamen haklısınız! 1B bir diziyi transpoze ettiğinizde hiçbir etki yoktur!

Dizilerinizi Yeniden Şekillendirme (Reshape) ve Yeniden Boyutlandırma (Resize)

Yayınlama bölümünde, aritmetik işlemler için iyi aday olmalarını istiyorsanız dizilerinizin boyutlarının uyumlu olması gerektiğini okumuş olabilirsiniz. Ancak bu böyle olmadığında ne yapmanız gerektiği sorusu henüz yanıtlanmamıştı.

İşte yanıt burada!

Diziler aynı boyutlarda değilse yapabileceğiniz şey, dizinizi yeniden boyutlandırmaktır (resize). O zaman np.resize() işlevine verdiğiniz şekle sahip yeni bir dizi döner. Orijinal dizinizi yeni boyutlarla birlikte geçirirseniz ve bu yeni dizi, orijinalinizden daha büyükse, yeni dizi, ihtiyaç duyulduğu kadar tekrarlanan orijinal dizinin kopyalarıyla doldurulur.

Ancak, yalnızca np.resize()’ı diziye uygular ve ona yeni şekli verirseniz, yeni dizi sıfırlarla doldurulur.

Bir örnekle bunu deneyelim:

import numpy as np
x = np.ones((3,4))

# Print the shape of `x`
print(x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x`
print(x)

Yeniden boyutlandırmanın (resize) yanı sıra, dizinizi yeniden şekillendirebilirsiniz (reshape). Bu, verilerini değiştirmeden bir diziye yeni bir şekil vermeniz anlamına gelir. Yeniden şekillendirmenin anahtarı, yeni dizinin toplam boyutunun değişmeden kalmasını sağlamaktır. Yukarıda kullanılan x dizisi örneğini ele alırsanız, boyutu 3 X 4 yani 12’dir; yeni dizinin boyutunun da 12 olduğundan emin olmanız gerekir.

Psst… Bir dizinin boyutunu kodla hesaplamak isterseniz size özniteliğini kullanın: x.size veya x.reshape((2,6)).size:

import numpy as np

# Initialize array with shape (3,4) containing all ones
x = np.ones((3,4))

# Print the shape of `x`
print("Shape of x:", x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x` before and after resizing
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)

# Transpose `x`
x = x.T

# Print out `x` after transposing
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)

Çıktı: 

Shape of x: (3, 4)
Array before transposing:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
 [[1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)

Hepsi başarısız olursa, boyutlarınızın hesaplamalarda kullanmak istediğiniz diğer diziyle uyumlu olduğundan emin olmak için orijinal dizinize bir dizi ekleyebilir veya dizi öğeleri ekleyip silebilirsiniz.

Dizilerin şeklini değiştirirken elinizin altında bulundurabileceğiniz bir diğer işlem ravel()’dır. Bu işlev, dizilerinizi düzleştirmenize olanak tanır. Bu, 2B, 3B veya nB dizileriniz olduğunda hepsini 1B bir diziye düzleştirmek için bu işlevi kullanabileceğiniz anlamına gelir.

Epey kullanışlı, değil mi?

Diziler Nasıl Eklenir (Append)

Dizileri orijinal dizinize eklediğinizde, orijinal dizinin sonuna “yapıştırılırlar”. Eklediklerinizin dizinin sonunda olmasını istemiyorsanız, eklemeyi (insert) düşünebilirsiniz. Daha fazla bilgi için bir sonraki bölüme gidin.

NumPy kütüphanesi sayesinde ekleme yapmak oldukça kolaydır; sadece np.append()’i kullanabilirsiniz.

Aşağıdaki kod parçasında nasıl yapıldığını kontrol edin. IPython kabuğunda örneğin my_array yazarak ve ENTER’a basarak hangi dizilerin yüklü olduğunu her zaman kontrol edebileceğinizi unutmayın.

import numpy as np

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

# Print `my_array` before appending
print("my_array before appending:", my_array)

# Append a 1D array to `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])

# Print `new_array`
print("new_array:", new_array)

# Print `my_array` after appending
print("my_array after appending:", my_array)

Çıktı:

my_array before appending: [1 2 3 4]
new_array: [ 1  2  3  4  7  8  9 10]
my_array after appending: [1 2 3 4]

np.append() yerinde (in-place) olarak orijinal diziyi değiştirmek yerine yeni bir dizi döndürdüğü için, eklemeden sonra my_array’in değişmeden kaldığına dikkat edin.

my_2d_array’e ekleme:

import numpy as np

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

# Print `my_2d_array` before appending
print("my_2d_array before appending:\n", my_2d_array)

# Append an extra column to `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)

# Print `new_2d_array`
print("new_2d_array:\n", new_2d_array)

# Print `my_2d_array` after appending
print("my_2d_array after appending:\n", my_2d_array)

Çıktı: 

my_2d_array before appending:
 [[1 2 3 4]
  [5 6 7 8]]
new_2d_array:
 [[1 2 3 4 7]
  [5 6 7 8 8]]
my_2d_array after appending:
 [[1 2 3 4]
  [5 6 7 8]]

my_2d_array’e ekstra bir sütun eklediğinizde eksenin belirtildiğine dikkat edin. 2B dizilerde eksen 1 sütunları, eksen 0 ise satırları belirtir.

Dizi Öğeleri Nasıl Eklenir (Insert) ve Silinir (Delete)

Eklemeye ek olarak, dizi öğeleri ekleyip silebilirsiniz. Muhtemelen artık tahmin ettiğiniz gibi, bu işlemleri yapmanızı sağlayacak işlevler np.insert() ve np.delete()’tir:

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Insert `5` at index 1
np.insert(my_array, 1, 5)

# Delete the value at index 1
np.delete(my_array,[1])

Diziler Nasıl Birleştirilir (Join) ve Bölünür (Split)

Dizilerinizi ‘birleştirebilir’ veya ekleyebilirsiniz. Bu amaçla kullanabileceğiniz bir dizi işlev vardır ve çoğu aşağıda listelenmiştir.

Bunları deneyin, ancak IPython kabuğunda dizilerin şeklini de test ettiğinizden emin olun. Yüklenen diziler x, my_array, my_resized_array ve my_2d_array’dir.

import numpy as np 
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Concatentate `my_array` and `x`
print(np.concatenate((my_array,x)))

# Stack arrays row-wise
print(np.vstack((my_array, my_2d_array)))

# Stack arrays row-wise
print(np.r_[my_resized_array, my_2d_array])

# Stack arrays horizontally
print(np.hstack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.column_stack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.c_[my_resized_array, my_2d_array])

İşlevleri incelerken birkaç şey fark edeceksiniz:

• İki diziyi np.concatenate() ile birleştirmek istiyorsanız boyut sayısının aynı olması gerekir. Dolayısıyla 1B olan my_array ile birleştirmek istiyorsanız, ikinci dizinizin de 1B olduğundan emin olmalısınız.
• np.vstack() ile my_array’i my_2d_array ile zahmetsizce birleştirirsiniz. Dizileri satır bazında yığdığınız için her iki dizideki sütun sayısının aynı olduğundan emin olmanız yeterlidir. Bu nedenle, sütun sayısı eşleştiği sürece my_2d_array’e (2,4) veya (3,4) şekline sahip bir dizi de ekleyebilirsiniz. Başka bir ifadeyle, diziler ilk eksen dışındaki tüm eksenlerde aynı şekle sahip olmalıdır. Bu, np.r[] kullanmak istediğinizde de geçerlidir.
• np.hstack() için boyut sayısının aynı olmasını ve her iki dizideki satır sayısının da aynı olmasını sağlamanız gerekir. Bu, şekli (2,4) olan my_2d_array’e (2,3) veya (2,4) gibi dizileri yığabileceğiniz anlamına gelir. Satır sayısı eşleştiği sürece her şey mümkündür. Bu işlev NumPy tarafından hâlâ desteklenmektedir; ancak np.concatenate() veya np.stack() tercih edilmelidir.
• np.column_stack() ile girdiğiniz dizilerin ilk boyutunun aynı olduğundan emin olmanız gerekir. Bu durumda her iki şekil de aynıdır; ancak my_resized_array (2,1) veya (2,) olsaydı da diziler yine yığılırdı.
• np.c_[] başka bir birleştirme yoludur. Burada da her iki dizinin ilk boyutunun eşleşmesi gerekir.

Dizileri birleştirdiğinizde, bir noktada onları bölmek de isteyebilirsiniz. Tıpkı yatay olarak yığabildiğiniz gibi, aynı şeyi dikey olarak da yapabilirsiniz. Sırasıyla np.hsplit() ve np.vsplit() kullanırsınız:

import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))

# Split `my_stacked_array` horizontally at the 2nd index
print(np.hsplit(my_stacked_array, 2))

# Split `my_stacked_array` vertically at the 2nd index
print(np.vsplit(my_stacked_array, 2))

Her iki bölme işlevini kullanırken aklınızda tutmanız gereken muhtemelen dizinizin şeklidir. Yukarıdaki durumu örnek alalım: my_stacked_array’in şekli (2,8)’dir. Bölmenin gerçekleşmesini istediğiniz indeksi seçmek istiyorsanız şekli aklınızda tutmalısınız.

np.histogram() ile

İşlevin çağrıştırabileceğinin aksine, np.histogram() işlevi histogramı çizmez; ancak dizinin her bir bölmeye (bin) düşen oluşumlarını hesaplar; Bu, histogramınızdaki her çubuğun kaplayacağı alanı belirleyecektir.

np.histogram() işlevine önce girdi verilerini veya üzerinde çalıştığınız diziyi geçirirsiniz. Histogram hesaplanırken dizi düzleştirilir.

# Import `numpy` as `np`
import numpy as np

# Initialize your array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Pass the array to `np.histogram()`
print(np.histogram(my_3d_array))

# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0,13)))

Sonuç olarak histogramın hesaplanacağını göreceksiniz: İlk dizi, dizinizdeki tüm öğelerin frekanslarını listeler; ikinci dizi ise herhangi bir bin belirtmezseniz kullanılacak bin’leri listeler.

Bir bin sayısı belirtirseniz, hesaplamanın sonucu farklı olacaktır: kayan noktalar (float) kaybolacak ve bin’ler için tüm tamsayıları göreceksiniz.

Hesaplanan histogramı etkileyebilecek, belirtebileceğiniz başka argümanlar da vardır. Hepsini burada bulabilirsiniz.

Peki, görselleştiremeyecekseniz böyle bir histogramı hesaplamanın anlamı nedir?

Görselleştirme, Matplotlib’in yardımıyla çocuk oyuncağıdır; ancak histogramı hesaplamak için np.histogram()’a ihtiyacınız yoktur. plt.hist(), (düzleştirilmiş) verileri ve bin’leri geçirdiğinizde bunu kendisi yapar:

# Import numpy and matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Construct the histogram with a flattened 3d array and a range of bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))

# Add a title to the plot
plt.title('Frequency of My 3D Array Elements')

# Show the plot
plt.show()

Yukarıdaki kod size aşağıdaki (temel) histogramı verir:

np.meshgrid() Kullanımı

Dizilerinizi (dolaylı olarak) görselleştirmenin bir başka yolu da np.meshgrid() kullanmaktır. Dizilerle ilgili karşılaştığınız sorun, x ve y koordinat değerlerinin 2B dizilerine ihtiyaç duymasıdır. Yukarıdaki işlevle, x değerlerinden oluşan bir dizi ve y değerlerinden oluşan bir diziden dikdörtgen bir ızgara oluşturabilirsiniz: np.meshgrid() işlevi iki 1B dizi alır ve iki dizi içindeki tüm (x, y) çiftlerine karşılık gelen iki 2B matris üretir. Daha sonra bu matrisleri her türlü grafiği oluşturmak için kullanabilirsiniz.

np.meshgrid(), özellikle aşağıdaki kodun gösterdiği gibi, bir ızgara üzerinde işlevleri değerlendirmek istiyorsanız kullanışlıdır:

# Import NumPy and Matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Create an array
points = np.arange(-5, 5, 0.01)

# Make a meshgrid
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)

# Display the image on the axes
plt.imshow(z, cmap=plt.cm.gray)

# Draw a color bar
plt.colorbar()

# Show the plot
plt.show()

Yukarıdaki kod şu sonucu verir: