- Numpy'nin temel amacı
- Neden numpy kullanmalıyız?
- Numpy'nin Özellikleri
- Python listeleri ile numpy dizileri arasındaki farklar
- Numpy Arrayleri Nedir?
- Array Oluşturma
- Array Özellikleri: Şekil, Boyut
- Dizilerin Veri Tipleri
- Dizilerin İndekslenmesi ve Dilimlenmesi
- Broadcasting (Yayılma)
- Dizi Yineleme (Repeating)
- İç Çarpım (dot product)
- İşlem fonksiyonları (np.sum(), np.prod(), np.mean() vs.)
Numpy, Python programlama dili için temel bir kütüphanedir ve bilimsel hesaplama ve veri işleme için kullanılır. Numpy'nin temel amacı, Python'da veri işlemesi ve hesaplamaları yapmak için hızlı ve etkili bir şekilde çalışabilecek yüksek performanslı çok boyutlu diziler ve matematiksel işlevler sunmaktır.
Numpy'nin kullanılmasının bazı avantajları şunlardır:
- Hızlı ve Verimli İşlemler: Numpy, C ve Fortran dilinde yazılmış alt seviye optimizasyonlar kullanır, bu da Python'da yavaş olan bazı işlemleri hızlandırır.
- Diziler Üzerinde Hızlı İşlemler: Numpy dizileri, Python listelerine göre daha hızlı ve verimli işlemler yapmak için optimize edilmiştir.
- Geniş Fonksiyonellik: Numpy, matematiksel işlevler, rastgele sayı üretimi, lineer cebir işlemleri gibi birçok faydalı fonksiyon ve işlev içerir.
- Veri Analizi ve Bilimsel Hesaplama: Numpy, veri analizi, bilimsel hesaplama, simülasyonlar ve modeller gibi çeşitli alanlarda yaygın olarak kullanılır.
Numpy'nin bazı temel özellikleri şunlardır:
- Çok Boyutlu Diziler (Arrays): Numpy, çok boyutlu dizileri destekler. Bu, tek boyutlu vektörlerden çok boyutlu matrislere kadar geniş bir veri yelpazesini kapsar.
- Matematiksel İşlevler: Numpy, temel matematiksel işlevler (sin, cos, exp vb.) ve işlemler (toplama, çıkarma, çarpma, bölme vb.) için fonksiyonlar içerir.
- Yüksek Performanslı Hesaplama: Numpy, vektörize edilmiş işlemler ve alt seviye optimizasyonlar kullanarak yüksek performanslı hesaplamalar sağlar.
- Geniş Kullanım Alanı: Numpy, veri analizi, bilimsel hesaplama, makine öğrenmesi, görüntü işleme gibi birçok alanda kullanılır.
Numpy dizileri ile Python listeleri arasındaki temel farklar şunlardır:
- Performans: Numpy dizileri, Python listelerine göre daha hızlı ve verimli işlemler yapar. Bu, özellikle büyük veri kümeleri üzerinde çalışırken belirgin hale gelir.
- Veri Tipi ve Boyut Kontrolü: Numpy dizileri, elemanları aynı veri tipinde tutar ve sabit bir boyuta sahiptir. Bu, veri kümeleri üzerinde homojen işlemler yapmayı kolaylaştırır.
- Matematiksel İşlemler: Numpy dizileri, matematiksel işlemler için optimize edilmiş vektörize edilmiş işlemleri destekler. Bu, Python listelerinden daha hızlı ve daha kolay matematiksel işlemler yapmayı sağlar.
- Bellek Yönetimi: Numpy dizileri, veriyi daha etkin bir şekilde bellekte depolar ve işler. Bu, bellek kullanımını optimize eder ve verimliliği artırır.
| Numpy Dizileri | Python Listeleri |
|---|---|
| Numpy dizileri aynı türde verileri içerir. | Python listeleri farklı türde verileri içerebilir. |
| Numpy dizileri boyutları sabittir. | Python listeleri dinamik boyutlara sahiptir. |
| Numpy dizilerinde vektörleştirilmiş işlemler yapılabilir, bu da performansı artırır. | Python listelerinde döngüler kullanılarak işlemler yapılır, bu performansı düşürebilir. |
Numpy, Python'da bilimsel hesaplamalar yapmak için kullanılan temel bir kütüphanedir. En önemli özelliklerinden biri, çok boyutlu (çok boyutlu) dizilerle çalışabilme yeteneğidir. Bu çok boyutlu dizilere "Numpy array" denir.
Numpy array, homojen veri tiplerinden oluşan bir grid yapısıdır. Bir numpy array, aynı türde veriler içerir ve boyutları sabittir. Numpy array'leri, Python listelerine benzerdir ancak daha etkin ve hızlıdır.
-
Homojen Veri Tipi:
- Numpy array'leri, aynı türde verileri içerir. Bu, veri işleme ve matematiksel operasyonlar için çok önemlidir çünkü her eleman aynı veri türüne sahiptir.
-
Sabit Boyut:
- Numpy array'lerinin boyutları oluşturulduktan sonra değiştirilemez. Bu, bellek kullanımını optimize eder ve hızlı işlemler sağlar.
-
Hızlı ve Verimli:
- Numpy, C altında derlenmiş bir kütüphanedir, bu da işlemlerin hızlı ve verimli bir şekilde yapılmasını sağlar. Büyük veri kümeleriyle çalışırken performans avantajı sağlar.
-
Çok Boyutlu Yetenek:
- Numpy array'leri, tek boyutlu, iki boyutlu ve daha fazla boyutta olabilir. Bu, matematiksel ve bilimsel hesaplamalarda çok yönlü kullanım sağlar.
Numpy array'leri ve Python listeleri arasındaki ana farklar şunlardır:
-
Performans:
- Numpy array'leri, vektörleştirilmiş operasyonlar ve optimize edilmiş bellek kullanımı sayesinde Python listelerinden daha hızlıdır.
-
Veri Tipi Kontrolü:
- Numpy array'leri homojen veri tipleri içerirken, Python listeleri heterojen veri tipleri içerebilir.
-
Boyut Değiştirme:
- Numpy array'lerinin boyutları oluşturulduktan sonra değiştirilemezken, Python listelerinin boyutu dinamik olarak değiştirilebilir.
-
Matematiksel İşlemler:
- Numpy array'leri, matematiksel işlemleri vektörleştirme yeteneği ile desteklerken, Python listeleri bunu doğrudan desteklemez.
Bu farklar, Numpy'nin Python listelerine tercih edilmesinin temel nedenlerindendir. Numpy array'leri, bilimsel hesaplamalar, veri analizi ve makine öğrenimi gibi uygulamalarda yaygın olarak kullanılmaktadır.
Numpy kütüphanesi, çeşitli yöntemlerle array oluşturmayı sağlar. Bu yöntemler, farklı ihtiyaçlara göre farklı türde arrayler oluşturmanıza olanak tanır.
Bu fonksiyonlar, belirli bir şekilde sıfırlar, birler veya boş değerler içeren arrayler oluşturur. Temel kullanımı aşağıdaki gibidir:
np.zeros(shape): Belirtilen boyutta sıfırlardan oluşan bir array oluşturur.np.ones(shape): Belirtilen boyutta birlerden oluşan bir array oluşturur.np.empty(shape): Belirtilen boyutta boş değerler içeren bir array oluşturur. Bu array'in değerleri, bellekteki mevcut duruma bağlı olarak değişkenlik gösterebilir.
import numpy as np
zeros_array = np.zeros((2, 3)) # 2x3 boyutunda sıfırlardan oluşan array
print(zeros_array, "\n")
# Çıktı:
# [[0. 0. 0.]
# [0. 0. 0.]]
ones_array = np.ones((3, 2)) # 3x2 boyutunda birlerden oluşan array
print(ones_array,"\n")
# Çıktı:
# [[1. 1.]
# [1. 1.]
# [1. 1.]]
empty_array = np.empty((2, 2)) # 2x2 boyutunda boş değerler içeren array
print(empty_array)
# Çıktı:
# [[4.67296746e-307 1.69121096e-306]
# [8.34441742e-308 1.24611470e-306]][[0. 0. 0.]
[0. 0. 0.]]
[[1. 1.]
[1. 1.]
[1. 1.]]
[[2. 1. ]
[1.5 0.5]]
Bu fonksiyonlar, belirli bir aralıktaki sayılarla dolu arrayler oluşturur.
np.arange(start, stop, step): Belirli bir aralıktaki sayıları belirtilen adımlarla içeren bir array oluşturur.np.linspace(start, stop, num): Belirli bir aralıktaki belirli sayıda eşit aralıklı sayıları içeren bir array oluşturur.
import numpy as np
range_array = np.arange(0, 10, 2) # 0'dan 10'a kadar 2'şer artan sayılar
print(range_array, "\n")
# Çıktı: [0 2 4 6 8]
linspace_array = np.linspace(0, 10, 5) # 0'dan 10'a kadar 5 eşit aralıklı sayılar
print(linspace_array)
# Çıktı: [ 0. 2.5 5. 7.5 10. ][0 2 4 6 8]
[ 0. 2.5 5. 7.5 10. ]
Bu fonksiyonlar, belirli bir boyutta rastgele sayılar içeren arrayler oluşturur.
np.random.rand(d0, d1, ..., dn): 0 ile 1 arasında uniform dağılımlı rastgele sayılar içeren bir array oluşturur.np.random.randn(d0, d1, ..., dn): Ortalaması 0 ve standart sapması 1 olan normal dağılımlı rastgele sayılar içeren bir array oluşturur.
import numpy as np
random_array_uniform = np.random.rand(2, 2) # 2x2 boyutunda uniform dağılımlı rastgele sayılar
print(random_array_uniform,"\n")
random_array_normal = np.random.randn(2, 2) # 2x2 boyutunda normal dağılımlı rastgele sayılar
print(random_array_normal)[[0.66083539 0.07326587]
[0.11192756 0.91149177]]
[[ 0.14298326 1.20668909]
[-0.69041712 0.67672093]]
Numpy array'lerinin şekli ve boyutu, array'in yapısını ve içerdiği veri miktarını tanımlar. Bu özellikler, array üzerinde işlem yaparken ve verileri manipüle ederken oldukça önemlidir.
Bir array'in şekli, her boyuttaki eleman sayısını içeren bir tuple'dır. Örneğin, bir 2x3 boyutundaki array'in şekli (2, 3) şeklinde ifade edilir.
Bir array'in boyutu, içerdiği boyut sayısını ifade eder. Örneğin, 2x3 boyutundaki bir array 2 boyutlu (2D) olarak kabul edilir.
import numpy as np
# 2x3 boyutunda bir array oluşturalım
my_array = np.array([[1, 2, 3],
[4, 5, 6]])
print("Array Şekli (Shape):", my_array.shape) # Çıktı: (2, 3)
print("Array Boyutu (Dimension):", my_array.ndim) # Çıktı: 2Array Şekli (Shape): (2, 3)
Array Boyutu (Dimension): 2
Numpy, reshape() fonksiyonu aracılığıyla mevcut bir array'in şeklini değiştirmenize olanak tanır. Bu işlem, array'in boyutunu değiştirmez, sadece şeklini yeniden düzenler.
import numpy as np
# 2x3 boyutunda bir array oluşturalım
my_array = np.array([[1, 2, 3],
[4, 5, 6]])
# Array'in şeklini (2, 3)ten (3, 2)'ye çevirelim
reshaped_array = my_array.reshape((3, 2))
print("Yeniden Şekillendirilmiş Array:")
print(reshaped_array)Yeniden Şekillendirilmiş Array:
[[1 2]
[3 4]
[5 6]]
- Yukarıdaki örnekte,
reshape()fonksiyonu kullanılarakmy_arrayadlı array'in şekli (2, 3)'ten (3, 2)'ye çevrildi.
Numpy, reshape() fonksiyonu dışında array'in boyutunu değiştiren resize() fonksiyonunu da sağlar. Bu fonksiyon, mevcut array'i değiştirir ve istenen boyuta uyacak şekilde genişletir veya kısaltır.
import numpy as np
# 2x3 boyutunda bir array oluşturalım
my_array = np.array([[1, 2, 3],
[4, 5, 6]])
# Array'in boyutunu (3, 4)'e değiştirelim
resized_array = np.resize(my_array, (3, 4))
print("Yeniden Boyutlandırılmış Array:")
print(resized_array)Yeniden Boyutlandırılmış Array:
[[1 2 3 4]
[5 6 1 2]
[3 4 5 6]]
- Yukarıdaki örnekte,
resize()fonksiyonu kullanılarakmy_arrayadlı array'in boyutu (3, 4)'e değiştirildi.
Numpy dizileri, homojen veri tipleriyle (aynı tipte verileri içerir) çalışır. Bu, her bir öğenin aynı veri tipine sahip olması gerektiği anlamına gelir. Numpy, farklı türlerde veri tiplerini destekler ve her bir veri tipi farklı boyut ve işlemlere izin verir.
- int: Tam sayılar.
- float: Ondalık sayılar.
- complex: Karmaşık sayılar.
- bool: Mantıksal (Boolean) değerler.
- string: Karakter dizileri.
- object: Python nesneleri için genel veri tipi.
- datetime: Tarih ve saat veri tipleri.
Numpy, bir dizi oluştururken veya bir diziye dönüştürürken veri tipini belirlemenize izin verir. Bu, bellek kullanımını optimize etmenize ve beklenmeyen sonuçlardan kaçınmanıza olanak tanır.
import numpy as np
# Diziyi oluştururken veri tipini belirleme
my_array = np.array([1, 2, 3], dtype=float)
print("Float tipinde dizi:", my_array)
# Dönüştürme işlemi sırasında veri tipini belirleme
converted_array = np.array([1, 2, 3], dtype=float)
print("Dönüştürülen dizi:", converted_array)Float tipinde dizi: [1. 2. 3.]
Dönüştürülen dizi: [1. 2. 3.]
Numpy dizileri, Python listelerine benzer şekilde indekslenir ve dilimlenir. Bu işlemler, belirli bir elemana erişmek veya belirli bir alt küme oluşturmak için kullanılır. Numpy, çok boyutlu dizilerle çalışırken bu işlemleri daha da güçlendirir.
Numpy dizileri, 0'dan başlayarak indekslenir. Bir dizinin belirli bir elemanına erişmek için indeks numarasını kullanırız.
import numpy as np
# 1D dizinin oluşturulması
arr = np.array([1, 2, 3, 4, 5])
# İndeksleme
print(arr[0]) # Çıktı: 1
print(arr[2]) # Çıktı: 31
3
Dilimleme, bir dizinin belirli bir alt kümesini seçmek için kullanılır. Numpy dizilerinde dilimleme, Python listelerinden çok benzer şekilde çalışır. [start:stop:step] formülü kullanılır. Herhangi bir parametre belirtilmezse, varsayılan değerler kullanılır (başlangıç: 0, durdurma: son, adım: 1).
import numpy as np
# 1D dizinin oluşturulması
arr = np.array([1, 2, 3, 4, 5])
# Dilimleme
print(arr[1:4]) # Çıktı: [2 3 4]
print(arr[:3]) # Çıktı: [1 2 3]
print(arr[::2]) # Çıktı: [1 3 5][2 3 4]
[1 2 3]
[1 3 5]
Çok boyutlu dizilerde, her boyuta ait bir indeks veya dilimleme kullanabiliriz. Her boyut için indeksleme ve dilimleme işlemleri virgülle ayrılır.
import numpy as np
# 2D dizinin oluşturulması
arr = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# İndeksleme ve Dilimleme
print(arr[0, 0]) # Çıktı: 1 (1. satırın 1. sütunu)
print(arr[1, 2]) # Çıktı: 6 (2. satırın 3. sütunu)
print(arr[:2, 1:]) # Çıktı: [[2 3]
# [5 6]]1
6
[[2 3]
[5 6]]
Numpy dizilerinde, belirli elemanlara erişmek için çeşitli yöntemler bulunmaktadır. Bu yöntemler, tek bir elemana, belirli bir alt kümeye veya belirli bir koşulu sağlayan elemanlara erişmek için kullanılır. İşte farklı yöntemler ve örnekler:
Tek bir elemana erişmek için, dizinin indeksini belirtiriz. Numpy dizileri, 0'dan başlayarak indekslenir.
import numpy as np
# 1D dizi oluşturma
arr = np.array([1, 2, 3, 4, 5])
# Birinci elemana erişim
print("Birinci eleman:", arr[0]) # Çıktı: 1
# Beşinci elemana erişim
print("Beşinci eleman:", arr[4]) # Çıktı: 5Birinci eleman: 1
Beşinci eleman: 5
Dilimleme, belirli bir alt kümenin seçilmesini sağlar. Başlangıç ve bitiş indeksleriyle belirtilen dilimler kullanılarak erişim yapılır.
import numpy as np
# 1D dizi oluşturma
arr = np.array([1, 2, 3, 4, 5])
# İkinci ve üçüncü elemanlara erişim
print("İkinci ve üçüncü elemanlar:", arr[1:3]) # Çıktı: [2 3]
# Tüm elemanlara erişim
print("Tüm elemanlar:", arr[:]) # Çıktı: [1 2 3 4 5]İkinci ve üçüncü elemanlar: [2 3]
Tüm elemanlar: [1 2 3 4 5]
Koşullu indeksleme, belirli bir koşulu sağlayan elemanları seçmek için kullanılır.
import numpy as np
# 1D dizi oluşturma
arr = np.array([1, 2, 3, 4, 5])
# 3'ten büyük elemanlara erişim
print("3'ten büyük elemanlar:", arr[arr > 3]) # Çıktı: [4 5]3'ten büyük elemanlar: [4 5]
Çok boyutlu dizilerde, her boyuta ait bir indeks veya dilimleme kullanılır.
import numpy as np
# 2D dizi oluşturma
arr = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# İkinci satırın üçüncü elemanına erişim
print("İkinci satırın üçüncü elemanı:", arr[1, 2]) # Çıktı: 6
# İlk iki satırın tüm elemanlarına erişim
print("İlk iki satırın tüm elemanları:", arr[:2, :]) # Çıktı: [[1 2 3]
# [4 5 6]]İkinci satırın üçüncü elemanı: 6
İlk iki satırın tüm elemanları: [[1 2 3]
[4 5 6]]
Numpy dizileri, matematiksel işlemleri gerçekleştirmek için kullanılabilir. Bu işlemler, dizinin her elemanı üzerinde tek tek uygulanır veya iki dizinin karşılıklı elemanları arasında gerçekleştirilir. Numpy, bu işlemleri vektörize edilmiş hızlı işlemler olarak gerçekleştirir, bu da büyük veri setleri üzerinde verimliliği artırır.
- Toplama: İki dizinin karşılıklı elemanlarını toplar.
- Çıkarma: İki dizinin karşılıklı elemanlarını çıkarır.
- Çarpma: İki dizinin karşılıklı elemanlarını çarpar.
- Bölme: İki dizinin karşılıklı elemanlarını böler.
import numpy as np
# İki dizi oluşturma
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
# Toplama
result_addition = arr1 + arr2
print("Toplama:", result_addition) # Çıktı: [5 7 9]
# Çıkarma
result_subtraction = arr1 - arr2
print("Çıkarma:", result_subtraction) # Çıktı: [-3 -3 -3]
# Çarpma
result_multiplication = arr1 * arr2
print("Çarpma:", result_multiplication) # Çıktı: [ 4 10 18]
# Bölme
result_division = arr1 / arr2
print("Bölme:", result_division) # Çıktı: [0.25 0.4 0.5 ]Toplama: [5 7 9]
Çıkarma: [-3 -3 -3]
Çarpma: [ 4 10 18]
Bölme: [0.25 0.4 0.5 ]
Numpy, diziler üzerinde üstel ve logaritmik işlemleri gerçekleştirmek için de fonksiyonlar sağlar.
-
Üs Alma:
np.power()fonksiyonu kullanılarak her elemanın bir üs alınır. -
Logaritma:
np.log()venp.log10()fonksiyonları kullanılarak logaritmalar hesaplanır.
import numpy as np
# Dizi oluşturma
arr = np.array([1, 2, 3])
# Üs alma (2^x)
result_power = np.power(arr, 2)
print("Üs alma (2^x):", result_power) # Çıktı: [1 4 9]
# Logaritma (doğal logaritma)
result_log = np.log(arr)
print("Logaritma (doğal logaritma):", result_log) # Çıktı: [0. 0.69314718 1.09861229]
# Logaritma (10 tabanında)
result_log10 = np.log10(arr)
print("Logaritma (10 tabanında):", result_log10) # Çıktı: [0. 0.30103 0.47712125]Üs alma (2^x): [1 4 9]
Logaritma (doğal logaritma): [0. 0.69314718 1.09861229]
Logaritma (10 tabanında): [0. 0.30103 0.47712125]
Numpy, dizilerde yaygın olarak kullanılan diğer matematiksel fonksiyonları da destekler, örneğin trigonometrik, hiperbolik, ters trigonometrik ve diğer özel fonksiyonlar.
import numpy as np
# Dizi oluşturma
arr = np.array([0, np.pi/2, np.pi])
# Sinüs
result_sin = np.sin(arr)
print("Sinüs:", result_sin) # Çıktı: [0.0000000e+00 1.0000000e+00 1.2246468e-16]
# Cosinüs
result_cos = np.cos(arr)
print("Cosinüs:", result_cos) # Çıktı: [ 1.000000e+00 6.123234e-17 -1.000000e+00]
# Tanjant
result_tan = np.tan(arr)
print("Tanjant:", result_tan) # Çıktı: [ 0.00000000e+00 1.63312394e+16 -1.22464680e-16]Sinüs: [0.0000000e+00 1.0000000e+00 1.2246468e-16]
Cosinüs: [ 1.000000e+00 6.123234e-17 -1.000000e+00]
Tanjant: [ 0.00000000e+00 1.63312394e+16 -1.22464680e-16]
Numpy, rastgele sayılar üretmek için numpy.random modülünü sağlar. Bu modül, farklı dağılımlara sahip rastgele sayılar üretmek için çeşitli fonksiyonlar içerir. Ayrıca, rastgele sayıların tekrar üretilebilir olmasını sağlamak için seed() fonksiyonu kullanılabilir.
np.random.rand() fonksiyonu, 0 ile 1 arasında uniform (eşit olasılıklı) dağılıma sahip rastgele sayılar üretir.
# 0 ile 1 arasında uniform dağılıma sahip 3 rastgele sayı üretme
random_numbers = np.random.rand(3)
print(random_numbers) # Örnek Çıktı: [0.891773 0.03942688 0.16983042][0.80726368 0.1899492 0.98928982]
np.random.seed() fonksiyonu, rastgele sayı üretiminde kullanılan rastgele sayı üretecinin başlangıç durumunu belirler. Bu, aynı seed değeri kullanıldığında, aynı rastgele sayılar üretileceği anlamına gelir. Bu, rastgele sayılarla çalışırken tekrarlanabilirlik gerektiğinde yararlıdır.
import numpy as np
# seed() fonksiyonu kullanarak başlangıç durumunu belirleme
np.random.seed(42)
# Aynı seed değeri kullanıldığında aynı rastgele sayılar üretilir
print(np.random.rand(3)) # Çıktı: [0.37454012 0.95071431 0.73199394]
# Farklı bir seed değeri kullanıldığında farklı rastgele sayılar üretilir
np.random.seed(123)
print(np.random.rand(3)) # Çıktı: [0.69646919 0.28613933 0.22685145][0.37454012 0.95071431 0.73199394]
[0.69646919 0.28613933 0.22685145]
np.random.randint() fonksiyonu, belirli bir aralıktan rastgele tam sayılar üretir.
# 1 ile 10 arasında rastgele tam sayı üretme
random_integers = np.random.randint(1, 11, size=5)
print(random_integers) # Örnek Çıktı: [6 3 3 7 4][ 7 2 4 10 7]
np.random.randn() fonksiyonu, standart normal dağılıma (ortalaması 0, standart sapması 1) sahip rastgele sayılar üretir.
# Standart normal dağılıma sahip 3 rastgele sayı üretme
random_normal_numbers = np.random.randn(3)
print(random_normal_numbers) # Örnek Çıktı: [-0.987502 -0.55895427 0.77606027][ 1.59530112 -1.78309431 -0.28645147]
np.random.choice() fonksiyonu, bir diziden rastgele örnekleme yapar.
# Verilen bir diziden rastgele örnekleme yapma
arr = np.array([1, 2, 3, 4, 5])
random_sample = np.random.choice(arr, size=3, replace=False)
print(random_sample) # Örnek Çıktı: [4 2 5][5 3 2]
reshape() fonksiyonu, bir dizinin şeklini belirli bir şekilde değiştirmek için kullanılır. Yeni şekil, orijinal dizinin eleman sayısına uygun olmalıdır.
import numpy as np
# 1D diziyi 2x3 2D dizisine dönüştürme
arr1d = np.array([1, 2, 3, 4, 5, 6])
print("1d Dizi:", arr1d, "\n")
arr2d = arr1d.reshape(2, 3)
print("2D Dizi:\n", arr2d)1d Dizi: [1 2 3 4 5 6]
2D Dizi:
[[1 2 3]
[4 5 6]]
resize() fonksiyonu, bir diziyi belirtilen şekilde değiştirir, ancak orijinal diziyi değiştirir.
arr1d_ornek = np.array([1, 2, 3, 4, 5, 6])
print(arr1d_ornek, "\n")
# Orijinal diziyi değiştirerek yeniden boyutlandırma
arr1d_ornek.resize(2, 3)
print("Yeniden Boyutlandırılmış Dizi:\n", arr1d_ornek)[1 2 3 4 5 6]
Yeniden Boyutlandırılmış Dizi:
[[1 2 3]
[4 5 6]]
reshape() fonksiyonunda bir boyut için -1 kullanarak, o boyutun boyutunu otomatik olarak belirtebiliriz.
print(arr1d, "\n")
# Orijinal diziyi 2D dizisine dönüştürme, -1 ile otomatik boyut belirleme
arr2d_auto = arr1d.reshape(2, -1)
print("Otomatik Boyutlandırılmış Dizi:\n", arr2d_auto)[1 2 3 4 5 6]
Otomatik Boyutlandırılmış Dizi:
[[1 2 3]
[4 5 6]]
flatten() fonksiyonu, çok boyutlu bir diziyi düzleştirerek 1D diziye dönüştürür.
print(arr2d, "\n")
# 2D diziyi düzleştirme
arr_flattened = arr2d.flatten()
print("Düzleştirilmiş Dizi:\n", arr_flattened)[[1 2 3]
[4 5 6]]
Düzleştirilmiş Dizi:
[1 2 3 4 5 6]
ravel() fonksiyonu da düzleştirme işlemi yapar, ancak orijinal dizideki verilere bir referans sağlar.
# 2D diziyi düzleştirme (ravel)
arr_raveled = arr2d.ravel()
print("Düzleştirilmiş Dizi (ravel):\n", arr_raveled)Düzleştirilmiş Dizi (ravel):
[1 2 3 4 5 6]
Numpy, dizileri birleştirme ve ayırma işlemleri için çeşitli yöntemler sunar. Bu yöntemler, dizileri birleştirmek için concatenate() ve stack() gibi fonksiyonları içerirken, ayırma işlemleri için split() fonksiyonu kullanılır.
concatenate() fonksiyonu, belirtilen eksen boyunca iki veya daha fazla diziyi birleştirir.
import numpy as np
# İki diziyi birleştirme
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
result_concatenate = np.concatenate((arr1, arr2))
print("Birleştirilmiş Dizi:", result_concatenate) # Çıktı: [1 2 3 4 5 6]Birleştirilmiş Dizi: [1 2 3 4 5 6]
stack() fonksiyonu, belirtilen eksen boyunca dizileri birleştirirken, yeni bir boyut ekler.
# İki diziyi yığma (stacking)
result_stack = np.stack((arr1, arr2))
print("Yığılmış Dizi:\n", result_stack)Yığılmış Dizi:
[[1 2 3]
[4 5 6]]
vstack() fonksiyonu, dikey olarak (satır bazında) dizileri birleştirirken, hstack() fonksiyonu, yatay olarak (sütun bazında) birleştirir.
# Dikey olarak dizileri birleştirme (vstack)
result_vstack = np.vstack((arr1, arr2))
print("Dikey Birleştirilmiş Dizi:\n", result_vstack)
# Yatay olarak dizileri birleştirme (hstack)
result_hstack = np.hstack((arr1, arr2))
print("Yatay Birleştirilmiş Dizi:", result_hstack)Dikey Birleştirilmiş Dizi:
[[1 2 3]
[4 5 6]]
Yatay Birleştirilmiş Dizi: [1 2 3 4 5 6]
split() fonksiyonu, belirtilen bir diziyi verilen bir pozisyonda ayırır.
arr = np.array([1, 2, 3, 4, 5, 6])
result_split = np.split(arr, [2, 4])
print("Ayrılmış Dizi:", result_split) # Çıktı: [array([1, 2]), array([3, 4]), array([5, 6])]Ayrılmış Dizi: [array([1, 2]), array([3, 4]), array([5, 6])]
vsplit() fonksiyonu, dikey olarak (satır bazında), hsplit() fonksiyonu ise yatay olarak (sütun bazında) bir diziyi ayırır.
# Dikey olarak diziyi ayırma (vsplit)
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
result_vsplit = np.vsplit(arr_2d, 2)
print("Dikey Ayrılmış Dizi:\n", result_vsplit)
# Yatay olarak diziyi ayırma (hsplit)
result_hsplit = np.hsplit(arr_2d, 3)
print("Yatay Ayrılmış Dizi:", result_hsplit)Dikey Ayrılmış Dizi:
[array([[1, 2, 3]]), array([[4, 5, 6]])]
Yatay Ayrılmış Dizi: [array([[1],
[4]]), array([[2],
[5]]), array([[3],
[6]])]
Numpy, farklı veri tipleri arasında dönüşümler yapmak için çeşitli fonksiyonlar sağlar. Bu dönüşümler, bir veri tipini başka bir veri tipine dönüştürmek için kullanılır.
astype() fonksiyonu, bir dizinin veri tipini belirtilen bir veri tipine dönüştürür.
import numpy as np
# İlk olarak, bir float veri tipine sahip bir dizi oluşturalım
arr_float = np.array([1.1, 2.2, 3.3, 4.4])
# Dizinin veri tipini integer olarak dönüştürelim
arr_int = arr_float.astype(int)
print("Dönüştürülmüş Dizi (integer):\n", arr_int)
# Dizinin veri tipini string olarak dönüştürelim
arr_str = arr_float.astype(str)
print("Dönüştürülmüş Dizi (string):\n", arr_str)Dönüştürülmüş Dizi (integer):
[1 2 3 4]
Dönüştürülmüş Dizi (string):
['1.1' '2.2' '3.3' '4.4']
asarray() fonksiyonu, bir nesneyi diziye dönüştürür. Bu fonksiyon, belirtilen bir veri tipini de kabul eder.
# Listeyi diziye dönüştürme ve veri tipini belirtme
arr_list = [1, 2, 3, 4, 5]
arr_array = np.asarray(arr_list, dtype=float)
print("Dönüştürülmüş Dizi:\n", arr_array)Dönüştürülmüş Dizi:
[1. 2. 3. 4. 5.]
Numpy'de veri tipleri, hesaplama sırasında önemli bir rol oynar. Farklı veri tipleri, bellek kullanımı, performans ve sonuçların doğruluğu açısından farklı avantajlar ve sınırlamalar sunar. Bu nedenle, veri tiplerini doğru bir şekilde seçmek önemlidir.
Numpy'de yaygın olarak kullanılan bazı veri tipleri şunlardır:
int8,int16,int32,int64: İşaretli tam sayılar.uint8,uint16,uint32,uint64: İşaretsiz tam sayılar.float16,float32,float64,float128: Ondalıklı sayılar.bool: Mantıksal (boolean) değerler.complex64,complex128,complex256: Karmaşık sayılar.
Her veri tipinin sınırlamaları vardır. Örneğin, daha küçük bir veri tipi daha az bellek kullanırken, daha büyük bir veri tipi daha büyük değerleri temsil edebilir ancak daha fazla bellek kullanır. Ayrıca, veri tipleri arasında dönüşüm yaparken, veri kaybına yol açabilirsiniz.
-
Veri Tipi Seçimi: Veri tipi seçerken, kullanılacak değerlerin aralığını ve hassasiyetini göz önünde bulundurmak önemlidir. Örneğin, integer yerine float veri tipini tercih etmek, daha geniş bir aralığı ve hassasiyeti sağlar, ancak daha fazla bellek kullanır.
-
İşlem Hızı ve Bellek Kullanımı: Büyük veri kümeleriyle çalışırken, veri tipi seçiminin işlem hızı ve bellek kullanımı üzerinde büyük bir etkisi olabilir. Daha küçük veri tipleri daha az bellek kullanırken, işlemler daha hızlı olabilir. Ancak, veri kaybı riski daha yüksektir.
-
Veri Dönüşümleri: İşlem sırasında, veri tipleri arasında dönüşümler yapılabilir. Ancak, bu dönüşümler veri kaybına yol açabilir. Bu nedenle, mümkünse, işlem yapmadan önce veri tiplerini dikkatlice seçmek önemlidir.
import numpy as np
# Veri tiplerinin sınırlamaları
print("int16 Sınırları:", np.iinfo(np.int16))
print("float32 Sınırları:", np.finfo(np.float32))
# Veri tipi dönüşümleri ve işlem önerileri
arr_float32 = np.array([1.5, 2.5, 3.5], dtype=np.float32)
arr_int32 = arr_float32.astype(np.int32)
print("Dönüştürülmüş Dizi (int32):\n", arr_int32)Bu örnekte, np.iinfo() ve np.finfo() fonksiyonları ile farklı veri tiplerinin sınırları gösterilmiş ve astype() fonksiyonu ile veri tipi dönüşümü yapılmıştır. Bu, veri tipi seçimi ve dönüşümleri konusunda dikkatli olmanın önemini vurgular.
Fancy indexing, Numpy dizilerini dilimlemek veya dizinin belirli elemanlarına erişmek için dizileri kullanma yöntemidir. Bu yöntemde, bir dizi veya liste kullanılarak dizinin belirli elemanlarına erişilir. Fancy indexing, basit indeksleme ve dilimleme yöntemlerine ek olarak daha esnek ve güçlü bir seçenektir.
Tek boyutlu dizilerde, fancy indexing bir dizi veya liste kullanarak belirli elemanlara erişmek için kullanılır.
import numpy as np
arr = np.array([10, 20, 30, 40, 50])
# Fancy indexing kullanarak belirli elemanlara erişme
indices = [0, 2, 4]
result = arr[indices]
print("Fancy Indexing Sonucu:", result) # Çıktı: [10 30 50]Fancy Indexing Sonucu: [10 30 50]
İki boyutlu dizilerde, fancy indexing her boyut için ayrı bir dizi veya liste kullanılarak belirli elemanlara erişmek için kullanılır.
# İki boyutlu dizide fancy indexing kullanma
arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# Belirli satır ve sütunları seçme
row_indices = [0, 2]
col_indices = [0, 2]
result_2d = arr_2d[row_indices][:, col_indices]
print("Fancy Indexing İle Seçilmiş Dizi:\n", result_2d)Fancy Indexing İle Seçilmiş Dizi:
[[1 3]
[7 9]]
Maskelerle indexleme, bir koşula bağlı olarak dizinin belirli elemanlarına erişmek için kullanılır. Bu, koşula uyan veya uymayan elemanlara erişmek için kullanışlı bir yöntemdir.
Boolean maskeler, bir koşula bağlı olarak dizinin elemanlarını seçmek için kullanılır.
# Boolean maskelerle indexleme
arr = np.array([1, 2, 3, 4, 5])
mask = arr > 2
result_masked = arr[mask]
print("Maskelenmiş Dizi:", result_masked) # Çıktı: [3 4 5]Maskelenmiş Dizi: [3 4 5]
Koşul ifadeleri, belirli bir koşula uyan dizinin elemanlarına erişmek için kullanılır.
# Koşul ifadeleri ile indexleme
arr = np.array([1, 2, 3, 4, 5])
result_condition = arr[arr > 2]
print("Koşula Uyan Elemanlar:", result_condition) # Çıktı: [3 4 5]Koşula Uyan Elemanlar: [3 4 5]
Numpy'nin yayılma (broadcasting) kavramı, farklı şekillere sahip diziler arasında element-wise işlemleri gerçekleştirmek için kullanılan bir özelliktir. Bu özellik, boyutları uygun hale getirerek, daha az boyuta sahip bir dizi ile daha büyük bir dizi arasındaki işlemleri gerçekleştirmeyi mümkün kılar.
Yayılma, Numpy'deki vektörize edilmiş işlemleri yaparken çok yaygın olarak kullanılır. Bir dizi ile skaler değerler arasında veya iki farklı şekle sahip diziler arasında işlem yapmak istendiğinde yayılma devreye girer. Bu durumda, Numpy, uygun boyutları otomatik olarak eşleştirir ve işlemi gerçekleştirir.
Örneğin, iki farklı boyuta sahip diziler arasında toplama işlemi yapmak istendiğinde, küçük boyuttaki dizi, büyük boyuttaki diziye yayılabilir ve işlem gerçekleştirilebilir.
Yayılmanın kullanımı, kodun daha temiz ve daha az karmaşık olmasını sağlar. Ayrıca, Python'un yaygın işlemlerini vektörize etmek için yaygın olarak kullanılır, bu da işlemlerin daha hızlı ve daha verimli olmasını sağlar.
Özetlemek gerekirse, Numpy'nin yayılma kavramı, farklı boyutlara sahip diziler arasında işlemleri kolaylaştıran ve vektörize etmeye olanak tanıyan bir özelliktir.
Numpy'de, broadcasting işlemlerinin gerçekleştirilmesi için belirli kurallar vardır. Bu kurallar, farklı şekillere sahip diziler arasında yayılma işlemlerini tanımlar ve uygun boyutları eşleştirmek için gereken adımları belirler.
Broadcasting işlemleri yaparken, dizilerin boyutları karşılaştırılır. Her boyutta, iki dizi ya aynı boyuta sahip olmalıdır ya da biri boyutsuz olmalıdır. Eğer boyutlardan biri 1 ise, bu boyut, diğer diziye uyumlu hale getirilebilir.
import numpy as np
# 3x3 boyutunda bir dizi
arr1 = np.ones((3, 3))
# 1 boyutunda bir dizi
arr2 = np.array([1, 2, 3])
# Broadcasting ile işlem
result = arr1 + arr2
print("Broadcasting Sonucu:\n", result)Broadcasting Sonucu:
[[2. 3. 4.]
[2. 3. 4.]
[2. 3. 4.]]
Eğer broadcasting işlemi için uygun boyut eşleşmeleri sağlanamıyorsa, Numpy hata verecektir. Bu durumda, dizilerin boyutlarını uyumlu hale getirmek veya işlemi gerçekleştirmek için başka bir yöntem kullanmak gerekir.
import numpy as np
# 3x3 boyutunda bir dizi
arr1 = np.ones((3, 3))
# 2 boyutunda bir dizi
arr2 = np.array([1, 2])
# Broadcasting ile işlem (Hata alınır)
result = arr1 + arr2---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Cell In[50], line 10
7 arr2 = np.array([1, 2])
9 # Broadcasting ile işlem (Hata alınır)
---> 10 result = arr1 + arr2
ValueError: operands could not be broadcast together with shapes (3,3) (2,)
Broadcasting işlemi sırasında, boyut ekleme adımı gerçekleştirilir. Diziler arasındaki boyut farkı, eksik olan boyutlara 1 eklenerek tamamlanır.
import numpy as np
# 3x3 boyutunda bir dizi
arr1 = np.ones((3, 3))
# 3 boyutunda bir dizi
arr2 = np.array([1, 2, 3])
# Broadcasting ile işlem
result = arr1 + arr2[:, np.newaxis]
print("Broadcasting Sonucu:\n", result)Numpy'de yayılma (broadcasting) özelliği, farklı şekillere sahip diziler arasında element-wise işlemleri gerçekleştirmek için kullanılır. Bu özellik, boyutları uygun hale getirerek, daha az boyuta sahip bir dizi ile daha büyük bir dizi arasındaki işlemleri gerçekleştirmeyi mümkün kılar. İşte farklı yöntemlerle kullanılan yayılma örnekleri:
Temel yayılma, iki dizinin boyutları aynı veya biri boyutsuzsa gerçekleşir. Bu durumda, element-wise işlem doğrudan uygulanabilir.
import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([10, 20, 30])
# Temel yayılma ile işlem
result = arr1 + arr2
print("Temel Yayılma Sonucu:\n", result)Boyut ekleme ile yayılma, boyutları uyumlu hale getirerek işlem yapılmasını sağlar. Bu durumda, boyutları farklı olan diziler arasında yayılma işlemi gerçekleştirilebilir.
# Boyut ekleme ile yayılma
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([10, 20, 30])
# Boyut ekleme ile işlem
result = arr1 + arr2[:, np.newaxis]
print("Boyut Ekleme ile Yayılma Sonucu:\n", result)Broadcasting kuralı, dizilerin uyumlu hale getirilmesi için gereken boyut eşleşmelerini belirler. Bu kuralı kullanarak, farklı boyutlara sahip diziler arasında yayılma işlemi gerçekleştirilebilir.
# Broadcasting kuralı ile yayılma
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([1, 2])
# Broadcasting kuralı ile işlem
result = arr1 + arr2[:, np.newaxis]
print("Broadcasting Kuralı ile Yayılma Sonucu:\n", result)Numpy'de dizi yineleme, bir diziyi belirli bir eksen boyunca tekrarlayarak yeni bir dizi oluşturmayı sağlayan bir işlemdir. Bu işlem, dizinin belirli boyutlarındaki tekrarlarını oluşturur. Numpy'nin repeat() fonksiyonu veya tile() fonksiyonu ile gerçekleştirilir.
Numpy'de repeat() fonksiyonu, bir diziyi belirli sayıda tekrarlayarak yeni bir dizi oluşturur. Bu fonksiyon, belirtilen eksen boyunca tekrar sayısını ve tekrar edilecek diziyi alır.
import numpy as np
# Bir dizi oluşturalım
arr = np.array([1, 2, 3])
# Diziyi tekrarlayalım
result = np.repeat(arr, 3) # Her elemanı 3 kez tekrarla
print("repeat() Fonksiyonu ile Yineleme Sonucu:", result) # Çıktı: [1 1 1 2 2 2 3 3 3]repeat() Fonksiyonu ile Yineleme Sonucu: [1 1 1 2 2 2 3 3 3]
tile() fonksiyonu, bir dizinin belirli bir şekilde yinelemesini sağlar. Bu fonksiyon, belirtilen şekil boyunca diziyi kopyalar ve yeni bir dizi oluşturur.
# Diziyi belirli bir şekilde yineleyelim
result_tile = np.tile(arr, 3) # Diziyi 3 kez yatayda yinele
print("tile() Fonksiyonu ile Yineleme Sonucu:", result_tile) # Çıktı: [1 2 3 1 2 3 1 2 3]tile() Fonksiyonu ile Yineleme Sonucu: [1 2 3 1 2 3 1 2 3]
Numpy'de iç çarpım (dot product), iki vektör arasında veya bir matris ile bir vektör veya iki matris arasında yapılan matematiksel bir işlemdir. İç çarpım, vektörlerin veya matrislerin elemanlarının çarpılması ve toplanmasıyla hesaplanır.
İki vektör arasındaki iç çarpım, vektörlerin elemanları arasında yapılan çarpma işlemlerinin toplanmasıyla hesaplanır.
import numpy as np
# İki vektör oluşturalım
vec1 = np.array([1, 2, 3])
vec2 = np.array([4, 5, 6])
# İki vektör arasındaki iç çarpımı hesaplayalım
dot_product = np.dot(vec1, vec2)
print("İki Vektör Arasındaki İç Çarpım:", dot_product) # Çıktı: 32İki Vektör Arasındaki İç Çarpım: 32
Bir matris ile bir vektör arasındaki iç çarpım, matrisin satırlarıyla vektörün sütunlarının elemanları arasında yapılan çarpma işlemlerinin toplanmasıyla hesaplanır.
# Bir matris ve bir vektör oluşturalım
matrix = np.array([[1, 2], [3, 4], [5, 6]])
vector = np.array([2, 3])
# Matris ve vektör arasındaki iç çarpımı hesaplayalım
dot_product_matrix_vector = np.dot(matrix, vector)
print("Matris ve Vektör Arasındaki İç Çarpım:", dot_product_matrix_vector) # Çıktı: [ 8 18 28]Matris ve Vektör Arasındaki İç Çarpım: [ 8 18 28]
İki matris arasındaki iç çarpım, matrislerin satırlarıyla sütunlarının elemanları arasında yapılan çarpma işlemlerinin toplanmasıyla hesaplanır.
# İki matris oluşturalım
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
# İki matris arasındaki iç çarpımı hesaplayalım
dot_product_matrices = np.dot(matrix1, matrix2)
print("İki Matris Arasındaki İç Çarpım:\n", dot_product_matrices)İki Matris Arasındaki İç Çarpım:
[[19 22]
[43 50]]
Numpy'de, çeşitli işlem fonksiyonları mevcuttur. Bu fonksiyonlar, dizilerdeki elemanların toplamını, çarpımını, ortalama değerini ve diğer istatistiksel hesaplamaları gerçekleştirmek için kullanılır. En yaygın kullanılan işlem fonksiyonları arasında np.sum(), np.prod(), np.mean() ve benzerleri bulunur.
np.sum() fonksiyonu, bir dizinin elemanlarının toplamını hesaplamak için kullanılır.
import numpy as np
# Bir dizi oluşturalım
arr = np.array([1, 2, 3, 4, 5])
# Dizinin elemanlarının toplamını hesaplayalım
total_sum = np.sum(arr)
print("Dizinin Toplamı:", total_sum) # Çıktı: 15np.prod() fonksiyonu, bir dizinin elemanlarının çarpımını hesaplamak için kullanılır.
# Dizinin elemanlarının çarpımını hesaplayalım
total_product = np.prod(arr)
print("Dizinin Çarpımı:", total_product) # Çıktı: 120np.mean() fonksiyonu, bir dizinin elemanlarının ortalama değerini hesaplamak için kullanılır.
# Dizinin elemanlarının ortalama değerini hesaplayalım
mean_value = np.mean(arr)
print("Dizinin Ortalaması:", mean_value) # Çıktı: 3.0Numpy'de birçok işlem fonksiyonu bulunur ve bu fonksiyonlar çeşitli istatistiksel hesaplamaları yapmak için kullanılır. Bazı diğer yaygın işlem fonksiyonları şunlardır:
np.min(): Dizinin minimum değerini bulur.np.max(): Dizinin maksimum değerini bulur.np.std(): Dizinin standart sapmasını hesaplar.np.median(): Dizinin ortanca değerini bulur.
Bu işlem fonksiyonları, Numpy'de veri analizi ve işlemlerinde sıkça kullanılır ve dizilerdeki verilerin çeşitli istatistiksel özelliklerini hesaplamak için önemlidir.
Numpy'de matris çarpımı, iki matris arasındaki çarpma işlemidir. Matris çarpımı, lineer cebirde ve matris işlemlerinde sıkça kullanılan önemli bir işlemdir. Numpy'nin np.dot() fonksiyonu veya @ operatörü ile matris çarpımı gerçekleştirilir.
@ operatörü, Numpy'de matris çarpımı için kullanılabilir. Bu operatör, iki matrisin çarpımını daha okunabilir bir şekilde ifade etmek için kullanılır.
# @ operatörü ile matris çarpımını hesaplayalım
matrix_product_operator = matrix1 @ matrix2
print("Matris Çarpımı (@ operatörü ile):\n", matrix_product_operator)Numpy'de, bir matrisin determinantı ve ters matrisi hesaplanabilir. Determinant, bir kare matrisin bir tür ölçüsüdür ve matrisin nasıl davrandığını anlamak için önemlidir. Ters matris ise, bir matrisin tersine çarpıldığında birim matrisi veren bir matristir.
Numpy'de, bir matrisin determinantını hesaplamak için np.linalg.det() fonksiyonu kullanılır.
import numpy as np
# Bir kare matris oluşturalım
matrix = np.array([[1, 2], [3, 4]])
# Matrisin determinantını hesaplayalım
determinant = np.linalg.det(matrix)
print("Matrisin Determinantı:", determinant)Matrisin Determinantı: -2.0000000000000004
Numpy'de, bir matrisin tersini hesaplamak için np.linalg.inv() fonksiyonu kullanılır.
# Matrisin tersini hesaplayalım
inverse_matrix = np.linalg.inv(matrix)
print("Matrisin Tersi:\n", inverse_matrix)Matrisin Tersi:
[[-2. 1. ]
[ 1.5 -0.5]]
ufuncs (universal functions), Numpy'de evrensel işlevler olarak bilinen, dizi elemanlarında element-wise (eleman bazlı) işlemler gerçekleştiren işlevlerdir. Bu işlevler, Numpy dizilerindeki her bir elemana aynı işlemi uygulayarak hızlı ve verimli bir şekilde çalışır.
ufuncs'ler, matematiksel operasyonlar, trigonometrik fonksiyonlar, mantıksal operasyonlar ve diğer birçok işlem için kullanılabilir.
Numpy'deki birçok matematiksel işlem, ufuncs kullanılarak gerçekleştirilir. Örneğin, toplama, çıkarma, çarpma, bölme gibi işlemler ufuncs aracılığıyla eleman bazlı olarak uygulanır.
import numpy as np
# İki dizi oluşturalım
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([5, 6, 7, 8])
# Toplama işlemi
result_addition = np.add(arr1, arr2)
# Çarpma işlemi
result_multiplication = np.multiply(arr1, arr2)
print("Toplama İşlemi Sonucu:", result_addition)
print("Çarpma İşlemi Sonucu:", result_multiplication)ufuncs, trigonometrik fonksiyonlar gibi matematiksel fonksiyonlar için de kullanılır.
# Sinüs fonksiyonu
result_sin = np.sin(arr1)
# Kosinüs fonksiyonu
result_cos = np.cos(arr2)
print("Sinüs Fonksiyonu Sonucu:", result_sin)
print("Kosinüs Fonksiyonu Sonucu:", result_cos)Mantıksal işlemler de ufuncs aracılığıyla gerçekleştirilir.
# Mantıksal ve işlemi
result_and = np.logical_and(arr1 > 2, arr2 < 7)
# Mantıksal veya işlemi
result_or = np.logical_or(arr1 > 2, arr2 < 7)
print("Mantıksal 've' İşlemi Sonucu:", result_and)
print("Mantıksal 'veya' İşlemi Sonucu:", result_or)