Python - NumPy Kütüphanesi

NumPy (Numerical Python), dizilerle çalışabilmek için kullanılan bir Python kütüphanesidir.

1. NumPy Kurulumu

Sistemde Python ve PIP kurulu ise, NumPy kütüphanesini aşağıdaki komutlarla yükleyebiliyoruz.

C:\Users\Kullanıcı Adı>pip install numpy

1.1. Projeye NumPy dahil etme ve kullanma (import numpy)

NumPy yüklendikten sonra import anahtar kelimesiyle kütüphaneyi projeye dahil ediyoruz. NumPy kütüphanesi geleneksel olarak aşağıdaki şekilde np takma adıyla kullanılır.

import numpy

import numpy as np

1.2. NumPy sürümünü kontrol etme (numpy version check)

__version__ niteliği (attribute) ile NumPy kütüphanesinin hangi sürümünün sisteme yüklendiğini kontrol edebiliriz.

import numpy as np
print(np.__version__)

2. Dizi Oluşturma (Create Array)

NumPy de oluşturulan diziler ndarray türündedir. En temelde dizi oluştururken array() metodu kullanılır ve söz dizimi aşağıdaki gibidir.

numpy.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, like=None)

• object: skalar bir sayı veya list, tuple vb. bir dizi (gerekli)
• dtype: veri tipi (opsiyonel)

Bu fonksiyonun derayları için NumPy dökümantasyon sayfasını ziyaret edebilirsiniz.

Aşağıdaki örneklerde skalar bir sayıdan, listden ve tupledan NumPy dizisi üretme örnekleri gösterilmiştir. 

import numpy as np

# skalardan numpy dizisi oluşturma
arr1 = np.array(5)
print(arr1) # 5

# list den numpy dizisi oluşturma
arr2 = np.array([1, 2, 3])
print(arr2) # [1 2 3]

# tuple dan numpy dizisi oluşturma
arr3 = np.array((1, 2, 3))
print(arr3) # [1 2 3]

# dtype belirleme
arr4 = np.array([1, 2, 3], dtype=np.int8)
print(arr4) # [1 2 3]

print(type(arr1)) 
# <class 'numpy.ndarray'>

3. Dizilerde Boyutlar (Dimension)

• 0-D Diziler: Tek bir sayıdan veya değerden oluşur. arr = np.array(25)
• 1-D Diziler: Elemanları 0-D diziler olan dizilerdir. arr = np.array([1, 2, 3, 4, 5])
• 2-D Diziler: Elemanları 1-D diziler olan dizilerdir. Genelde matrisler için kullanılır. arr = np.array([[1, 2, 3], [4, 5, 6]])
• 3-D Diziler: Elemanları 2-D diziler(matrisler) olan dizilerdir. arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

ndim ile NumPy dizisinin kaç boyutlu olduğunu öğrenebiliriz.

import numpy as np

arr0 = np.array(25)
arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

print(arr0.ndim) # 0
print(arr1.ndim) # 1
print(arr2.ndim) # 2
print(arr3.ndim) # 3

4. Dizilerin Temel Nitelikleri (Attribute)

Temel NumPy dizi niteliklerini (attributes) ndim, shape, dtype, size, itemsize ve nbytes olarak ifade edebiliriz.

• ndim: Dizinin boyut sayısı veya eksen sayısıdır. 0, 1, 2, 3...
• shape: Dizinin herbir eksendeki boyutunu verir. Örneğin matrisler (2-D) için shape (satır, sütun) şeklinde bir tuple değeridir. 3-D diziler için ise shape (derinlik, satır, sütun) şeklinde oluşur. Yukarıdaki görselde bu durum daha net anlaşılacaktır.
• dtype: Dizideki elemanların veri tipini gösterir. int8, uint8, int32, float64, boolgibi.
• size: Dizideki toplam eleman sayısıdır. => satır * sütun
• itemsize: Dizideki elemanların byte cinsinden boyutudur. Yani tek bir dizi elemanın boyutudur. Örneğin dtype int32 ise itemsize değeri 32/8=4 Byte olur. dtype float64 ise itemsize değeri 64/8=8 Byte olur.
• nbytes: Dizinin harcadığı toplam byte sayısıdır. size * itemsize ile aynı değerdir.

5. Bazı Dizi Oluşturma Yöntemleri

Dizi oluştururken kullanılan bazı fonksiyonlar şunlardır: eye, identity, ones, zeros, full, arange, linspace

• eye: Ana köşegen(main diagonal) elemanlarının 1, diğer bütün elemanların 0 dan oluştuğu 2-D bir dizi üretir. N*M boyutundadır.

# np.eye(N, M=None, k=0, dtype=, order='C', *, like=None)
# N: tam sayı (satır sayısı)
# M: tam sayı (opsiyonel, sütun sayısıdır. Boş bırakılırsa N değerine eşit olur ve kare matris üretir.)

np.eye(3)
# array([[1., 0., 0.],
#        [0., 1., 0.],
#        [0., 0., 1.]])

np.eye(3, 4, dtype=np.float32)
# array([[1., 0., 0., 0.],
#        [0., 1., 0., 0.],
#        [0., 0., 1., 0.]], dtype=float32)

• identity: Birim matrisdir. Ana köşegen(main diagonal) elemanlarının 1, diğer bütün elemanların 0 dan oluştuğu n*n boyutunda 2-D bir kare matris üretir.

# np.identity(n, dtype=None, *, like=None)
# n: tam sayı (satır ve sütun sayısı, n*n boyutlu birim matris oluşur.)

np.identity(4, dtype=np.int8)
# array([[1, 0, 0, 0],
#        [0, 1, 0, 0],
#        [0, 0, 1, 0],
#        [0, 0, 0, 1]], dtype=int8)

• ones: Belirtilen şekil ve tipte, bütün elemanlarının 1 olduğu bir matris üretir.

# np.ones(shape, dtype=None, order='C', *, like=None)
# shape: tam sayı veya tam sayı dizisidir. (Örn: 2 gibi tam sayı veya (2, 3) veya [2, 3] gibi list, tuple şeklinde bir dizi)

np.ones(3, dtype=np.int8)
# array([1, 1, 1], dtype=int8)

np.ones((2, 3)) # tuple kullanarak
# array([[1., 1., 1.],
#        [1., 1., 1.]])

np.ones([2, 3]) # list kullanarak
# array([[1., 1., 1.],
#        [1., 1., 1.]])

• zeros: Belirtilen şekil ve tipte, bütün elemanlarının 0 olduğu bir matris üretir.

# np.zeros(shape, dtype=None, order='C', *, like=None)
# shape: tam sayı veya tam sayı dizisidir. (Örn: 2 gibi tam sayı veya (2, 3) veya [2, 3] gibi list, tuple şeklinde bir dizi)

np.zeros(3, dtype=np.int8)
# array([0, 0, 0], dtype=int8)

np.zeros((2, 3)) # tuple kullanarak
# array([[0., 0., 0.],
#        [0., 0., 0.]])

np.zeros([2, 3]) # list kullanarak
# array([[0., 0., 0.],
#        [0., 0., 0.]])

• full: Belirtilen şekil ve tipte, bütün elemanlarının belirtilen değerle(fill_value) doldurulduğu bir matris üretir.

# np.full(shape, fill_value, dtype=None, order='C', *, like=None)
# shape: tam sayı veya tam sayı dizisidir. (Örn: 2 gibi tam sayı veya (2, 3) veya [2, 3] gibi list, tuple şeklinde bir dizi)
# fill_value: tam sayı veya bir dizi.

np.full(3, fill_value=25)
# array([25, 25, 25])

np.full((2,3), fill_value=5) # tuple kullanarak
# array([[5, 5, 5],
#        [5, 5, 5]])

np.full([2,3], fill_value=5) # list kullanarak
# array([[5, 5, 5],
#        [5, 5, 5]])

• arange: Belirli bir aralıkta eşit aralıklı değerler dizisi üretir.

# np.arange([start, ]stop, [step, ], dtype=None, *, like=None)
# start: tam sayı veya ondalıklı sayı. Opsiyoneldir. Aralığın başlangıcıdır. Aralığa dahildir. Default değeri 0 dır.
# stop: tam sayı veya ondalıklı sayı. Aralığın sonudur. Aralığa dahil değildir.
# step: tam sayı veya ondalıklı sayı. Opsiyoneldir. Aralık boyutunu belirtir.

# ÖRNEKLER

# arange(stop): [0, stop) aralığında 1 er 1 er
np.arange(5)
# array([0, 1, 2, 3, 4])

# arange(start, stop): [start, stop) aralığında 1 er 1 er
np.arange(5, 13)
# array([ 5,  6,  7,  8,  9, 10, 11, 12])

# arange(start, stop, step): [start, stop) aralığında belirtilen adım boyutu ile
np.arange(5, 13, 3)
# array([ 5,  8, 11])

• linspace: Belirli bir aralıkta, belirtilen adet kadar ve eşit aralıklı olacak şekilde değerler dizisi üretir.

# np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
# [start, stop] kapalı aralığında num ile belirtilen kadar eşit aralıklı olacak şekilde sayı üretir.
# Bitiş noktası (stop) aralığa dahildir. İstenirse endpoint parametresi False yapılarak hariç tutulabilir.
# num: tam sayıdır. Üretilecek sayı adedidir. Default olarak 50 dir.

np.linspace(5, 11, num=10, endpoint=True)
# array([ 5.        ,  5.66666667,  6.33333333,  7.        ,  7.66666667,
#         8.33333333,  9.        ,  9.66666667, 10.33333333, 11.        ])

6. İndeksleme (Dizi Elemanlarına Erişim-Indexing)

* NumPy dizilerine erişmek için dizi_adı[index] formatı kullanılır. Köşeli parantez içine erişmek istediğimiz elemanın indeks numarasını yazarız. NumPy dizilerinde indeks numaraları 0 dan başlar. Yani ilk elemanın indeks değeri 0, ikinci elemanın indeks değeri ise 1 dir. Ve bu şekilde devam eder.

* Ayrıca negatif indeksleme de kullanılabilir. Negatif indeksleme mantığı dizi elemanlarına sondan erişim için kullanılır. En son elemanın indeksi -1 dir. Sondan bir önceki elemanın indeksi ise -2 dir.

* 2-D (iki boyutlu) NumPy dizilerinde erişim için dizi_adı[satır, sütun] mantığı kullanılır.

* 3-D (üç boyutlu) NumPy dizilerinde erişim için dizi_adı[derinlik, satır, sütun] mantığı kullanılır.

arr_1d = np.arange(10, 40, 3)
# array([10, 13, 16, 19, 22, 25, 28, 31, 34, 37])

# ÖRNEKLER

# 1-D dizinin ilk elemanına erişim
arr_1d[0] # 10

# 1-D dizinin son elemanına negatif indeksleme ile erişim
arr_1d[-1] # 37

arr_2d = np.random.randint(1, 20, (3,4))
# array([[15, 18, 13,  5],
#        [ 1, 16,  7, 10],
#        [ 5, 11,  7,  7]])

# 2-D dizinin 1. satır, 2. sütundaki elemanına erişim
arr_2d[0, 1] # 18

# 2-D dizinin 2. satır, son sütun elemanına erişim
arr_2d[1, -1] # 10

arr_3d = np.random.randint(1, 20, (2,3,4))
# array([[[16,  9,  8,  2],
#         [19, 18,  5,  3],
#         [15, 11,  8, 15]],

#        [[13,  4, 19, 19],
#         [12,  5,  5,  6],
#         [16,  3, 16,  1]]])

# 3-D dizinin 2. level, 1. satır, 3. sütundaki elemanına erişim
arr_3d[1, 0, 2] # 19

# 3-D dizinin sondan bir önceki level, sondan iki önceki satır, 2. sütundaki elemanına erişim
arr_3d[-2, -3, 1] # 9

6.1. İndeks dizileri ile indeksleme

Bir dizide birden fazla elemanı çekmek istersek dizi_adı[[indeks_listesi]] mantığıyla köşeli parantez içerisine erişmek istediğimiz elemanların indeks numaralarını list, NumPy dizisi gibi bir liste ile yazarız.

arr_1d = np.arange(10, 40, 3)
# array([10, 13, 16, 19, 22, 25, 28, 31, 34, 37])

# list kullanarak 
arr_1d[[-1, 0, 3]] # array([37, 10, 19])

# numpy array kullanarak
arr_1d[np.array([-1, 0, 3])] # array([37, 10, 19])

2-D (iki boyutlu) dizilerde, diziler ile indeksleme yaparken; dizilerin aynı sıralarında ki elemanlar eşleşerek o sıradaya denk gelen eleman seçilir. Aşağıdaki örnekte arr_2d[[0, 1], [2,3]] ile (0, 2) ve (1, 3) şeklinde eşleştirme yapılır ve bu indekslerde ki değerler elde edilmiş olur. 3-D dizilerde yine aynı mantıkla yapılabilir.

* 2-D dizilerde -> dizi_adı[[satır_indeksleri], [sütun_indeksleri]]

* 3-D dizilerde -> dizi_adı[[level_indeksleri], [satır_indeksleri], [sütun_indeksleri]]

# 2-D dizilerde
arr_2d = np.random.randint(1, 20, (3,4))
# array([[15, 18, 13,  5],
#        [ 1, 16,  7, 10],
#        [ 5, 11,  7,  7]])

# (0, 2) ve (1, 3) eşleşmesi olur ve ilgili elemanlar seçilir
arr_2d[[0, 1], [2,3]]
# array([13, 10])

# ---------------------------------------- #

# 3-D dizilerde
arr_3d = np.random.randint(1, 20, (2,3,4))
# array([[[16,  9,  8,  2],
#         [19, 18,  5,  3],
#         [15, 11,  8, 15]],

#        [[13,  4, 19, 19],
#         [12,  5,  5,  6],
#         [16,  3, 16,  1]]])

# (0, 0, 1) ve (1, 2, 3) indeksinde ki elemanlar seçilir.
arr_3d[[0,1],[0,2],[1,3]]
# array([9, 1])

6.2. Boolean indeksleme

dizi_adı[boolean_dizisi] formatıyla bir NumPy dizisi içinde belli bir şarta uyan verileri seçmemize yarar.

1-D Boolean indeksleme

a = np.array([4, 6, 8])
b = np.array([False, True, True])
print(a[b])
# [6, 8]

2-D Boolean indeksleme

# 2D Boolean Indexing
a = np.array([[1, 2, 3],
              [4, 5, 6]])
b = np.array([[True, False, False],
              [False, False, True]])
print(a[b])
# [1 6]

Belli bir şarta uyan verileri aşağıdaki örneklerde olduğu gibi alabiliriz.

# ÖRNEK 1
arr = np.array([1, 2, 3, 4, 5, 6])
bool_ind = (arr % 3 == 0)
bool_ind
# array([False, False,  True, False, False,  True])
arr[bool_ind]
# array([3, 6])

# ÖRNEK 2
arr = np.array([1, 2, 3, 4, 5, 6])
arr[arr > 2]
# array([3, 4, 5, 6])

7. Dilimleme (Slicing)

Dilimleme, bir dizide bir başlangıç indeksi ve bitiş indeksi arasındaki elemanları seçmeye yarar. dizi_adı[start: end: step] formatı kullanılır.

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

# Örnek 1: 1D dizilerde [1, 6) aralığı - 6 dahil değil
arr[1:6] # array([1, 2, 3, 4, 5])

# Örnek 2: 3. indeksden sona kadar
arr[3:] # array([3, 4, 5, 6])

# Örnek 3: Başlangıçtan 5. indekse kadar (5 dahil değil - [0, 5) aralığı)
arr[:5] # array([0, 1, 2, 3, 4])

# Örnek 4: Negatif dilimleme
arr[-4:-1] # array([3, 4, 5])

# Örnek 5: Baştan sona kadar 3 er 3 er
arr[::3] # array([0, 3, 6])

# Örnek 6: 3. indeksden sona kadar 2 şer 2 şer
arr[3::2] # array([3, 5]) 

# Örnek 7: 2D dizilerde dilimleme
arr = np.array([[3, 5, 7, 9, 11],
                [2, 4, 6, 8, 10]])

# 1. satırdan son satıra kadar satırlarda, 1. sütundan 3. sütuna kadar sütunlar (3 dahil değil) 
arr[1:,1:3] # array([[4, 6]])

# Örnek 8: 3D dizilerde dilimleme
arr = np.array([[[3, 5, 7, 9, 11],
                 [2, 4, 6, 8, 10]],
                [[5, 7, 8, 9, 2],
                 [7, 2, 3, 6, 7]]])

# 0 indeksli level, 1 indeksli satır, 0 dan 2 indeksli sütuna kadar (2 dahil değil)
arr[0,1,0:2] # array([2, 4])

8. Veri Tipleri (Data Types)

NumPy da kullanılan veri tipleri:

• i - integer
• b - boolean
• u - unsigned integer
• f - float
• c - complex float
• m - timedelta
• M - datetime
• O - object
• S - string
• U - unicode string
• V - raw data (void)

8.1. Veri tipi kontrolü

NumPy dizilerinin dtype niteliği(attribute) ile dizinin hangi veri tipinden olduğu kontrol edilmektedir.

# ÖRNEK 1
arr = np.array([1, 2, 3, 4])
print(arr.dtype) # int64

# ÖRNEK 2
arr = np.array([1.5, 2.3, 3.7, 4.2])
print(arr.dtype) # float64

# ÖRNEK 3
arr = np.array(['ahmet', 'betül', 'ali'])
print(arr.dtype) # <U5

8.2. Veri tipi belirterek dizi oluşturma

array() metoduyla dizi oluştururken, dtype parametresi ile veri tipini belirtebiliriz.

# integer tipinde 4 byte (32 bit) -> int32
arr1 = np.array([1, 2, 3, 4], dtype='i4')
print(arr1) # [1 2 3 4]
print(arr1.dtype) # int32

# datetime veri tipi
arr2 = np.array(['1453-05-29', '1514-08-23', '1526-08-29'], dtype='M')
# veya
arr3 = np.array(['1453-05-29', '1514-08-23', '1526-08-29'], dtype=np.datetime64)
print(arr2) # ['1453-05-29' '1514-08-23' '1526-08-29']
print(arr3) # ['1453-05-29' '1514-08-23' '1526-08-29']
print(arr2.dtype) # datetime64[D]
print(arr3.dtype) # datetime64[D]

8.3. Veri tipi dönüştürme

astype() metodu dizinin bir kopyasını oluşturur ve bir parametre ile veri tipini belirtmemizi sağlar.

arr = np.array([1.1, 2.1, 3.1])

newarr1 = arr.astype('i')
newarr2 = arr.astype(int)

print(newarr1) # [1 2 3]
print(newarr1.dtype) # int32

print(newarr2) # [1 2 3]
print(newarr2.dtype) # int64

arr = np.array([1, 0, 3])

newarr = arr.astype(bool)

print(newarr) # [True False True]
print(newarr.dtype) # bool

9. Copy vs View

copy yeni bir dizidir. view ise orjinal dizinin bir görünümüdür. copy kendi verisine sahiptir, bu yüzden onda yapılacak bir değişiklik orjinal diziyi etkilemez. view ise veriye sahip değildir, view de yapılacak bir değişiklik orjinal diziyi etkiler. Aynı zamanda orjinal dizide yapılacak bir değişiklik de view i etkiler.

arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()
arr[0] = 0

# orjinal dizide yapılan değişiklik copy i etkilemez. Çünkü o ayrı bir dizi olmuştur.
print(arr) # [0 2 3 4 5]
print(x)   # [1 2 3 4 5]

arr = np.array([1, 2, 3, 4, 5])
x = arr.view()
arr[0] = 0

# orjinal dizide yapılan değişiklik view i etkiler.
print(arr) # [0 2 3 4 5]
print(x)   # [0 2 3 4 5]

Dizinin verilere sahip olup olmadığını yani copy mi view mi olduğunu base niteliği(attribute) ile kontrol edebiliyoruz. Eğer None değeri dönüyorsa dizi veriye sahiptir deriz.

# The copy returns None.
# The view returns the original array.

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

arr_copy = arr.copy()
arr_view = arr.view()

print(arr_copy.base) # None
print(arr_copy.base) # [1 2 3 4 5]

10. Yeniden Boyutlandırma (Reshaping)

Yeniden boyutlandırma, dizinin şeklini değiştirmektir. Boyut değiştirirken dikkat edilmesi gereken nokta toplam eleman sayısına uygun olması gerektiğidir. Örneğin bir boyutlu 8 elemanlı bir diziyi (2, 4) veya (4, 2) yapabiliriz fakat (3, 3) yapamayız. Çünkü (3, 3) bir dizi için 9 eleman gerekir.

numpy.reshape(a, newshape, order='C') veya ndarray.reshape(shape, order='C') formatıyla reshape metodunu kullanırız. Geri dönen dizi orjinal dizinin görünümüdür (view).

# Aşağıdaki üç kullanım denktir.
arr = np.arange(1, 13)
print(arr) # [ 1  2  3  4  5  6  7  8  9 10 11 12]

arr1 = numpy.reshape(arr, (3, 4))
arr2 = arr.reshape(3, 4) 
arr3 = arr.reshape((3, 4))

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

10.1. 1-D yi 2-D yapma

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

newarr = arr.reshape(4, 3)
print(newarr)
# [[ 1  2  3]
#  [ 4  5  6]
#  [ 7  8  9]
#  [10 11 12]]

10.2. 1-D yi 3-D yapma

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

newarr = arr.reshape(2, 3, 2)
print(newarr)
# [[[ 1  2]
#   [ 3  4]
#   [ 5  6]]

#  [[ 7  8]
#   [ 9 10]
#   [11 12]]]

10.3. Çok boyutlu dizileri 1-D yapma (Düzleştirme)

ndarray.reshape(-1): arr.reshape(-1) şeklinde kullanılır. Çok boyutlu bir matrisi 1D yapmaya yarar. Geri dönen değer bir boyutludur (1-D) ve orjinal dizinin görünümüdür (view).

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

x.reshape(-1) # array([1, 2, 3, 4, 5, 6]) 

ndarray.flatten(): Bir matrisi düzleştirmeye yarar. ndarray.flatten(order='C') formatıyla kullanılır. Geri dönen değer bir boyutludur (1-D) ve orjinal dizinin kopyasıdır (copy).

• order: {'C', 'F', 'A', 'K'}
  • 'C': flatten in row-major (C-style) order
  • ‘F’ means to flatten in column-major (Fortran- style) order
  • ‘A’ means to flatten in column-major order if a is Fortran contiguous in memory, row-major order otherwise.
  • ‘K’ means to flatten a in the order the elements occur in memory. The default is ‘C’.

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

a.flatten('C') # array([1, 2, 3, 4])
a.flatten('F') # array([1, 3, 2, 4])

np.ravel(): Bir matrisi düzleştirmeye yarar. numpy.ravel(a, order='C') formatıyla kullanılır. Geri dönen değer bir boyutludur (1-D) ve orjinal dizinin görünümüdür (view).

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

print(a)
# [[1 2 3]
#  [4 5 6]]

print(b)
# [1 2 3 4 5 6]

# b dizisi a'nın görünümü olduğu için herhangi birinde 
# yapılacak değişiklik diğerini de etkileyecektir.

a[0] = 25

print(a)
# [[25 25 25]
#  [ 4  5  6]]

print(b)
# [25 25 25  4  5  6]

10.4. Bilinmeyen boyut

reshape metodunda boyutlardan birinin değerini -1 yaparsak, NumPy o boyutun değerini kendisi otomatik hesaplayacaktır.

# Toplam eleman sayısı 8 dir. Bir boyutun değerini 2 girdiğimiz
# için sütun değeri otomatik olarak 4 olarak hesaplanmıştır. (2, 4)
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

newarr = arr.reshape(2, -1)
print(newarr)
# [[1 2 3 4]
#  [5 6 7 8]]

11. NumPy Dizilerinde İterasyon

11.1. for döngüsü ile iterasyon

NumPy dizilerinin elemanları üzerinde gezinmek için for döngüsü kullanılır.

# 1-D dizilerde döngü kullanımı
arr = np.array([1, 2, 3])

for x in arr:
  print(x)

# 1 2 3

2-D dizilerde tek bir döngü kullanırsak dizi üzerinde satır satır geziniriz. Yani her iterasyonda bir satır ele alınır. Elemanlara tek tek erişmek istiyorsak boyut sayısı kadar iç içe for döngüsü kullanmalıyız.

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

# 2-D dizilerde tek bir döngü kullanırsak, her iterasyonda bir satır elde ederiz.

for row in arr:
  print(row)

# [1 2 3]
# [4 5 6]

# 2-D dizilerde 2 döngü kullanırsak, elemanları tek tek elde ederiz. 
# Dizi 2 boyutlu olduğu için 2 döngü kullanarak elemanlara tek tek erişebiliriz.
arr = np.array([[1, 2, 3], [4, 5, 6]])

for row in arr:
  for ele in row:
    print(ele, end=" ")

# 1 2 3 4 5 6

3-D dizilerde tek bir döngü kullanırsak, her iterasyonda en dıştaki 2-D dizileri (derinlik) elde ederiz. İki döngü kullanırsak her 2-D dizideki satırları sırayla elde ederiz. Boyut sayısı kadar (3) döngü kullanırsak elemanları teker teker elde etmiş oluruz.

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

# ÖRNEK 1:
# 3-D dizilerde tek bir döngü kullanırsak, her iterasyonda 2-D bir dizi elde ederiz.
i=1;
for depth in arr:
  print(f"{i}. iterasyon")
  print(depth)
  print('------------')
  i += 1

# 1. iterasyon
# [[1 2 3]
#  [4 5 6]]
# ------------
# 2. iterasyon
# [[ 7  8  9]
#  [10 11 12]]
# ------------

# ÖRNEK 2:
# 3-D dizilerde iki döngü kullanırsak, her iterasyonda 2-D dizilerdeki satırları sırasıyla alırız.
i=1;
for depth in arr:
  for row in depth:
    print(f"{i}. iterasyon: {row}")
    i += 1

# 1. iterasyon: [1 2 3]
# 2. iterasyon: [4 5 6]
# 3. iterasyon: [7 8 9]
# 4. iterasyon: [10 11 12]

# ÖRNEK 3:
# 3-D dizilerde üç döngü kullanırsak, elemanları sırayla teker teker alırız.
i=1;
for depth in arr:
  for row in depth:
    for ele in row:
      print(f"{i}. iterasyon: {ele}")
      i += 1

# 1. iterasyon: 1
# 2. iterasyon: 2
# 3. iterasyon: 3
# 4. iterasyon: 4
# 5. iterasyon: 5
# 6. iterasyon: 6
# 7. iterasyon: 7
# 8. iterasyon: 8
# 9. iterasyon: 9
# 10. iterasyon: 10
# 11. iterasyon: 11
# 12. iterasyon: 12

11.2. numpy.nditer() fonksiyonu ile iterasyon

for döngüsü kullanırken, elemanları tek tek gezebilmek için boyut sayısı kadar döngü kullanmamız gerekir. Çok boyutlu dizilerde bu zorlayıcı olabilir. nditer() fonksiyonu bizi bu zahmetten kurtarmaktadır.

# ÖRNEK 1: 2-D diziyi döndürme (satır bazlı)
arr = np.array([[1, 2, 3], [4, 5, 6]])

for x in np.nditer(arr, order='C'):
  print(x, end=' ')

# 1 2 3 4 5 6


# ÖRNEK 2: 2-D diziyi döndürme (sütun bazlı - orjinal 2D dizinin transpozu)
for x in np.nditer(arr, order='F'):
  print(x, end=' ')

# 1 4 2 5 3 6


# ÖRNEK 3: Her sütundan ikişer atlayarak
for x in np.nditer(arr[:, ::2]):
  print(x, end=' ')

# 1 3 4 6

11.3. numpy.ndenumerate() fonksiyonu ile iterasyon

Bazen iterasyon sırasında öğenin indeks değerine de ihtiyaç duyabiliriz. Bu durumlar için numpy.ndenumerate() fonksiyonu kullanılabilir.

# ÖRNEK 1: 1-D dizilerde ndenumerate kullanımı
arr = np.array([1, 2, 3])

for idx, x in np.ndenumerate(arr):
  print(f'{idx}: {x}')

# (0,): 1
# (1,): 2
# (2,): 3

# ÖRNEK 2: 2-D dizilerde ndenumerate kullanımı
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])

for idx, x in np.ndenumerate(arr):
  print(f'{idx}: {x}')

# (0, 0): 1
# (0, 1): 2
# (0, 2): 3
# (0, 3): 4
# (1, 0): 5
# (1, 1): 6
# (1, 2): 7
# (1, 3): 8

12. NumPy Dizilerini Birleştirme (Joining)

İki veya daha fazla dizinin içeriğini tek bir diziye koymaya birleşirme işlemi denir. Bu işlemler için concatenate() ve stack() fonksiyonları kullanılır.

12.1. numpy.concatenate()

numpy.concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind")

• a1, a2, ...: Birleştirilecek diziler. Dizilerin birleştirilecek eksen haricinde ki boyutları aynı olmalıdır.
  • Örneğin; 2-D diziler birleştirilirken axis=0 ise sütun (1.boyut) sayıları eşit olmalı. axis=1 ise satır (0.boyut) sayıları eşit olmalı.
  • 3-D diziler birleştirilirken axis=0 (derinlik) ise satır (1.boyut) ve sütun (2.boyut) değerleri eşit olmalı. axis=1 verilirse derinlik (0.boyut) ve sütun (2.boyut) değerleri eşit olmalı. axis=2 verilirse derinlik (0.boyut) ve satır (1.boyut) değerleri eşit olmalı. 
• axis: Dizilerin birleştirileceği eksen. Eğer None olursa, diziler önce düzleştirilir (flatten) sonra birleştirilir. Default olarak değeri 0 dır.

# ÖRNEK 1
# 1.dizinin shape: (3, 3)
# 1.dizinin shape: (2, 3)
# axis=0 da birleştirileceği için sütun sayılarının eşit olması gerekir (3).
arr1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2 = np.array([[10, 11, 12], [13, 14, 15]])

axis_0 = np.concatenate((arr1, arr2), axis=0)
print(axis_0)

# [[ 1  2  3]
#  [ 4  5  6]
#  [ 7  8  9]
#  [10 11 12]
#  [13 14 15]]


# ÖRNEK 2
# 1.dizinin shape: (2, 3)
# 1.dizinin shape: (2, 2)
# axis=1 de birleştirileceği için satır sayılarının eşit olması gerekir (2).
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8], [9, 10]])

axis_1 = np.concatenate((arr1, arr2), axis=1)
print(axis_1)

# [[ 1  2  3  7  8]
#  [ 4  5  6  9 10]]


# ÖRNEK 3
# axis=None ise diziler önce düzleştirilir sonra birleştirilir.
arr1 = np.array([[1, 2], [3, 4], [5, 6]])
arr2 = np.array([[7, 8], [9, 10]])

axis_None = np.concatenate((arr1, arr2), axis=None)
print(axis_None)

# [ 1  2  3  4  5  6  7  8  9 10]

12.2. numpy.stack()

NumPy dizilerini birleştirmek için kullanılır. concatenate fonksiyondan farkı, diziler yeni bir eksen boyunca birleştirilir. stack fonksiyonunun döndürdüğü dizinin boyutu, birleştirilen dizilerin boyutlarının 1 fazlasıdır. Örneğin; 1 boyutlu iki dizi birleştirilecekse, sonuç dizisi 2 boyutlu olur. 2 boyutlu diziler birleştirilirse sonuç dizisi 3 boyutlu olur. 

Dizilerde eksen mantığı için yukarıdaki görseli inceleyebilirsiniz. Boyutlar, son boyut -1, bir önceki boyut -2 vs şeklinde de kullanılabilmektedir. Örneğin 2-D dizilerde eksenler (0, 1) veya (-2, -1) dir. 3-D dizilerde ise eksenler (0, 1, 2) veya (-3, -2, -1) dir.

numpy.stack(arrays, axis=0, out=None)

• arrays: Birleştirilecek diziler. Hepsi aynı şekle (shape) sahip olmalı. Gereklidir.
• axis: Girdi dizilerinin birleştirildiği eksen. Opsiyonel.

# ÖRNEK 1: 1-D dizileri satır bazlı birleştirme
# Diziler 1-D olduğu için sonuç dizisi 2-D olacaktır. axis=0 veya (-2) olduğu için satır bazlı (alt alta) birleştirme yapılacaktır.
# iki dizide aynı şekil ve boyuta sahip olmalıdır. Örnekteki dizilerin shape:(3, )

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
 
c = np.stack((a, b), axis=0)
# veya
c = np.stack((a, b), axis=-2)
print(c)
# [[1 2 3]
#  [4 5 6]]

 
# ÖRNEK 2: 1-D dizileri sütun bazlı birleştirme
# Diziler 1-D olduğu için sonuç dizisi 2-D olacaktır. axis=1 veya (-1) olduğu için sütun bazlı (yan yana) birleştirme yapılacaktır.

c = np.stack((a, b), axis=1)
# veya
c = np.stack((a, b), axis=-1)
print(c)
# [[1 4]
#  [2 5]
#  [3 6]]

# ÖRNEK 3: 2-D dizileri derinlik bazlı birleştirme
# Diziler 2-D olduğu için sonuç dizisi 3-D olacaktır. axis=0 veya (-3) olduğu için derinlik bazlı (arka arkaya) birleştirme yapılacaktır.
# iki dizide aynı şekil ve boyuta sahip olmalıdır. Örnekteki dizilerin shape:(2, 3)

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

c = np.stack((a, b), axis=0)
# veya
c = np.stack((a, b), axis=-3)
print(c)
# [[[ 1  2  3]
#   [ 4  5  6]]
# 
#  [[ 7  8  9]
#   [10 11 12]]]

 
# ÖRNEK 4: 2-D dizileri satır bazlı birleştirme
# Diziler 2-D olduğu için sonuç dizisi 3-D olacaktır. axis=1 veya (-2) olduğu için satır bazlı birleştirme yapılacaktır.
# iki dizide aynı şekil ve boyuta sahip olmalıdır. Örnekteki dizilerin shape:(2, 3)

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

c = np.stack((a, b), axis=1)
# veya
c = np.stack((a, b), axis=-2)
print(c)
# [[[ 1  2  3]
#   [ 7  8  9]]
# 
#  [[ 4  5  6]
#   [10 11 12]]]


# ÖRNEK 5: 2-D dizileri sütun bazlı birleştirme
# Diziler 2-D olduğu için sonuç dizisi 3-D olacaktır. axis=2 veya (-1) olduğu için sütun bazlı birleştirme yapılacaktır.
# iki dizide aynı şekil ve boyuta sahip olmalıdır. Örnekteki dizilerin shape:(2, 3)

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

c = np.stack((a, b), axis=2)
# veya
c = np.stack((a, b), axis=-1)
print(c)
# [[[ 1  7]
#   [ 2  8]
#   [ 3  9]]
#
#  [[ 4 10]
#   [ 5 11]
#   [ 6 12]]]

12.3. numpy.vstack()

Dizileri dikey olarak (vertically) birleştirir.

numpy.vstack(tup)

• tup: Birleştirilecek diziler.

# ÖRNEK 1: 1-D dizilerin vstack() ile birleştirilmesi
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.vstack((arr1, arr2))
print(arr)
# [[1 2 3]
#  [4 5 6]]


# ÖRNEK 2: 2-D dizilerin vstack() ile birleştirilmesi
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[4, 5], [6, 7]])
arr = np.vstack((arr1, arr2))
print(arr)
# [[1 2]
#  [3 4]
#  [4 5]
#  [6 7]]

12.4. numpy.hstack()

Dizileri yatay olarak (horizontally) birleştirir.

numpy.hstack(tup)

• tup: Birleştirilecek diziler.

# ÖRNEK 1: 1-D dizilerin hstack() ile birleştirilmesi
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.hstack((arr1, arr2))
print(arr)
# [1 2 3 4 5 6]


# ÖRNEK 2: 2-D dizilerin hstack() ile birleştirilmesi
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
arr = np.hstack((arr1, arr2))
print(arr)
# [[1 2 5 6]
#  [3 4 7 8]]

13. Dizileri Bölme (Splitting)

Bölme, birleştirme işleminin tersidir. Diziyi istediğimiz kadar parçaya bölmek için array_split() fonksiyonunu kullanırız.

numpy.array_split(ary, indices_or_sections, axis=0)

# 1-D dizileri bölme
arr = np.array([1, 2, 3, 4, 5, 6])

newarr = np.array_split(arr, 3)
print(newarr)
# [array([1, 2]), array([3, 4]), array([5, 6])]

newarr = np.array_split(arr, 4)
print(newarr)
# [array([1, 2]), array([3, 4]), array([5]), array([6])]

print(newarr[0]) # [1 2]


# 2-D dizileri bölme
arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])

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

14. Dizilerde Arama Yapma (Searching)

Dizilerde değer araması yapabiliriz. Bunu için where() fonksiyonu kullanılır.

numpy.where(condition, [x, y, ]/)

• condition doğru olduğunda x'i, aksi takdirde y'yi verir.

# Değeri 4 olan elemanların indeks numaralarını verir.
# 3, 5 ve 6. indeks numaralarında ki elemanların değeri 4 tür.
arr = np.array([1, 2, 3, 4, 5, 4, 4])

x = np.where(arr == 4)

print(x) # (array([3, 5, 6]),)

arr = np.arange(10)
# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.where(arr < 5, arr, 10*arr)
# array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])

15. Dizilerde Sıralama Yapma (Sorting)

sort() fonksiyonu ile dizileri sıralayabiliriz. 

numpy.sort(array, axis=- 1, kind=None, order=None)

• array: Sıralanacak dizi.
• axis: int veya None,opsiyonel. Sıralamanın yapılacağı eksen. Eğer None ise dizi önce düzleştirilir (flatten). Default -1, son eksen manasına gelir.
• kind:{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, opsiyonel.

# 1-D dizilerde sıralama
arr = np.array([5, 3, 0, 2, 1, 4])

np.sort(arr)
# array([0, 1, 2, 3, 4, 5])

# 2-D dizilerde sıralama
arr = np.array([[1,4],[3,1]])

# sort along the last axis
np.sort(arr) 
# array([[1, 4],
#        [1, 3]])

# sort the flattened array
np.sort(a, axis=None)
# array([1, 1, 3, 4])

# sort along the first axis
np.sort(a, axis=0)
# array([[1, 1],
#        [3, 4]])

16. numpy.random modülü

random modülü, rastgele sayı üretmek için kullanılan bir NumPy kütüphanesidir. NumPy projeye dahil edilince random modülü de otomatik dahil edilmiş olur. Eğer sadece random modülünü kullanmak istersek from numpy import random şeklinde kullanabiliriz. random modülünün bazı fonksiyonlarını şöyle listeleyebiliriz.

rand()

Belirtilen şekle ve sürekli düzgün dağılıma (continuous uniform distribution) sahip, [0, 1) aralığında rastgele ondalıklı sayılardan oluşan bir dizi üretir.

• numpy.random.rand(d0, d1, ..., dn)
• d0, d1, ..., dn: Oluşturulacak dizinin boyutları. Boş bırakılırsa tek bir ondalıklı sayı üretilir. Opsiyonel.

rand() - örnekler

# rand()

# [0, 1) aralığıda tek bir tane ondalıklı sayı
np.random.rand() 
# 0.05043515379537111


# [0, 1) aralığıda 4 tane ondalıklı sayı
np.random.rand(4)
# array([0.11617952, 0.49192916, 0.76014205, 0.67353019])


# [0, 1) aralığıda 3*2 boyutunda ondalıklı sayılar dizisi
np.random.rand(3, 2)
# array([[0.5305714 , 0.83598188],
#        [0.3908953 , 0.06214618],
#        [0.2022786 , 0.7020945 ]])

random_sample()

Sürekli düzgün dağılıma (continuous uniform distribution) sahip, [0, 1) aralığında rastgele ondalıklı sayılardan oluşan bir dizi üretir.

• numpy.random.random_sample(size=None)
• size: tam sayı veya tam sayılardan oluşan bir tuple. Default olarak None değeridir, bu durumda tek bir değer üretilir. Opsiyonel.

random_sample() - örnekler

# random_sample()

# [0, 1) aralığıda tek bir rastgele ondalıklı sayı
np.random.random_sample()
# 0.41021097543820995


# [0, 1) aralığıda 4 tane rastgele ondalıklı sayı
np.random.random_sample(4)
# array([0.38412308, 0.239728  , 0.68836284, 0.89742758])


# [0, 1) aralığıda 4 tane rastgele ondalıklı sayı
np.random.random_sample((4,))
# array([0.84616053, 0.9962784 , 0.79535225, 0.56308503])


# [0, 1) aralığıda 2*3 boyutunda rastgele ondalıklı sayılar dizisi
np.random.random_sample((2, 3))
# array([[0.58216232, 0.6338578 , 0.85652196],
#        [0.32142006, 0.46829837, 0.823842  ]])


# [-5, 0) aralığında 2*3 boyutunda rastgele ondalıklı sayılar dizisi
5 * np.random.random_sample((2, 3)) - 5
# array([[-2.40930462, -3.90163201, -4.68239896],
#        [-2.35594419, -4.59796674, -3.14718518]])

uniform()

[low, high) aralığında ve belirtilen şekilde, düzgün dağılıma sahip, rastgele ondalıklı sayılardan oluşan bir dizi üretir.

• numpy.random.uniform(low=0.0, high=1.0, size=None)
• low: Aralığın alt limit değeridir. Ondalıklı sayı. Default olarak 0.0 dır. Opsiyonel.
• high: Aralığın üst limit değeridir. Default olarak 1.0 dır.
• size: tam sayı veya tam sayılardan oluşan bir tuple. Default olarak None değeridir, bu durumda tek bir değer üretilir. Opsiyonel.

uniform() - örnekler

# uniform()

# [0, 1) aralığında tek bir rastgele ondalıklı sayı
np.random.uniform()
# 0.3656777869162626


# [-1, 0) aralığında tek bir rastgele ondalıklı sayı
np.random.uniform(-1, 0)
# -0.932176143148455


# [-1, 0) aralığında düzgün dağılıma sahip 4 tane rastgele ondalıklı sayı
np.random.uniform(-1, 0, size=4)
# array([-0.04101796, -0.08518601, -0.50013478, -0.43940935])


# [-1, 0) aralığında düzgün dağılıma sahip 4 tane rastgele ondalıklı sayı
np.random.uniform(-1, 0, size=(4,))
# array([-0.68120678, -0.00689214, -0.77153866, -0.45072695])


# [-3, 4) aralığında düzgün dağılıma sahip 2*4 boyutunda rastgele ondalıklı sayılar dizisi
np.random.uniform(-3, 4, size=(2, 4))
# array([[ 3.1152228 , -0.59277098, -0.9232111 ,  3.25022653],
#        [ 3.81495063, -2.01636997, -0.81449038, -2.56065622]])

Örnek: 

import matplotlib.pyplot as plt

# [-1, 0) aralığında, 1000 tane veri
s = np.random.uniform(-1, 0, 1000)

np.all(s >= -1) # True
np.all(s < 0)   # True

count, bins, ignored = plt.hist(s, 15, density=True)
plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')
plt.show()

randn()

Belirtilen şekle ve standart normal dağılıma sahip, rastgele ondalıklı sayılardan oluşan bir dizi üretir. Standart normal dağılımda; aritmetik ortalama (μ) 0, standart sapma (σ) ise 1'dir.

• numpy.random.randn(d0, d1, ..., dn)
• d0, d1, ..., dn: Oluşturulacak dizinin boyutları. Boş bırakılırsa tek bir ondalıklı sayı üretilir. Opsiyonel.

randn() - örnekler

# randn()

# Tek bir rastgele ondalıklı sayı
np.random.randn()
# 0.561610376989222


# Standart normal dağılıma sahip 3 tane rastgele ondalıklı sayı
np.random.randn(3)
# array([-0.28163511, -0.26084377, -0.41913984])


# Standart normal dağılıma sahip 2*4 boyutunda rastgele ondalıklı sayılar dizisi
np.random.randn(2, 4)
# array([[-1.6218862 ,  0.4740152 ,  0.58000493, -2.47650131],
#        [ 0.89729436,  0.64176422, -0.23471763, -0.86394103]])


# N(3, 4): ortalaması(μ) 3, varyansı(σ²) 4 olan 2*4 boyutunda rastgele ondalıklı sayılar dizisi 
#  Varyans(σ²) 4 ise standart sapma(σ) 2 dir.
3 + 2 * np.random.randn(2, 4)
# array([[2.6786476 , 3.29732858, 3.1244508 , 3.32196953],
#        [4.2515118 , 1.85619334, 2.92870091, 1.22710913]])


# Yeterli sayıda veriyle sonuçların doğruluğunun tespiti
# ortalama(μ)=3 ve standart sapma(σ)=2 => N(3, 4) <-> N(μ, σ²)
x = 3 + 2 * np.random.randn(100000)
np.mean(x) # 3.007212746099111
np.std(x)  # 2.0030494204372653

standard_normal()

Belirtilen şekle ve standart normal dağılıma sahip, rastgele ondalıklı sayılardan oluşan bir dizi üretir. Standart normal dağılımda; aritmetik ortalama (μ) 0, standart sapma (σ) ise 1'dir. 

• numpy.random.standard_normal(size=None)
• size: tam sayı veya tam sayılardan oluşan bir tuple. Default olarak None değeridir, bu durumda tek bir değer üretilir. Opsiyonel.

standard_normal() - örnekler

# standard_normal()

# Tek bir rastgele ondalıklı sayı
np.random.standard_normal()
# 0.08222799792281507


# Standart normal dağılıma sahip 3 tane rastgele ondalıklı sayı
np.random.standard_normal(3)
# array([0.34061037, 0.83514556, 1.84104586])


# Standart normal dağılıma sahip 3 tane rastgele ondalıklı sayı
np.random.standard_normal((3,))
# array([ 0.34991765,  0.89613225, -0.14976288])


# Standart normal dağılıma sahip 2*3 boyutunda rastgele ondalıklı sayılar dizisi
np.random.standard_normal((2, 3))
# array([[ 0.98287149,  0.28799039,  0.27541633],
#        [-0.19477634, -1.65774483,  0.57047677]])


# Yeterli sayıda veriyle sonuçların doğruluğunun tespiti
# ortalama(μ)=5 ve standart sapma(σ)=2.25 => N(3, 6.25) <-> N(μ, σ²)
x = 5 + 2.5 * np.random.standard_normal(size=100000)
np.mean(x) # 5.005062486301192
np.std(x)  # 2.495932787615626

normal()

Belirtilen şekle ve normal dağılıma sahip, rastgele ondalıklı sayılardan oluşan bir dizi üretir.

• numpy.random.normal(loc=0.0, scale=1.0, size=None)
• loc: Aritmetik ortalama değeri. Ondalıklı sayı. Default olarak 0.0 dır.
• scale: Standart sapma değeri. Negatif değer olmamalı. Default olarak 1.0 dır.
• size: Tam sayı veya tam sayılardan oluşan bir tuple. Default olarak None değeridir, bu durumda tek bir değer üretilir. Opsiyonel.

normal() - örnekler 

mu, sigma = 0, 0.1 # mean and standard deviation

np.random.normal(mu, sigma, size=(2, 4))
# array([[ 0.0521295 ,  0.05371793, -0.06006346, -0.06127266],
#        [-0.06310303,  0.05550344,  0.02537202, -0.10704668]])

Örnek: ortalaması (μ) 4, standart sapması (σ) 1 olan 10,000 verinin gösterimi

import matplotlib.pyplot as plt

mu, sigma = 4, 1
samples = np.random.normal(mu, sigma, 10000)

count, bins, ignored = plt.hist(samples , 30, density=True)

plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *
               np.exp( - (bins - mu)**2 / (2 * sigma**2) ),
         linewidth=2, color='r')

plt.show()

randint()

[low, high) aralığında ve belirtilen şekilde, kesikli (ayrık) düzgün dağılıma sahip, rastgele tam sayılardan oluşan bir dizi üretir. 

• numpy.random.randint(low, high=None, size=None, dtype=int)
• low: Aralığın alt limit değeridir.
• high: Aralığın üst limit değeridir. Default olarak None dır.
• size: Tam sayı veya tam sayılardan oluşan bir tuple. Default olarak None değeridir, bu durumda tek bir değer üretilir. Opsiyonel.

# randint()

# [0, 1) aralığında tek bir tane tam sayı
np.random.randint(2) 
# 1


# [0, 1) aralığında düzgün dağılıma sahip 10 tane tam sayı dizisi
np.random.randint(2, size=10)
# array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0])


# [0, 1) aralığında düzgün dağılıma sahip 10 tane tam sayı dizisi
np.random.randint(2, size=(10,))
# array([1, 1, 0, 0, 0, 0, 0, 1, 0, 1])


# [0, 5) aralığında düzgün dağılıma sahip 2*4 boyutunda tam sayı dizisi
np.random.randint(5, size=(2, 4))
# array([[0, 3, 3, 4],
#        [4, 1, 3, 0]])


# 3 farklı alt limit değeriyle 1*3 boyutunda tam sayı dizisi
# [1, 10), [5, 10) ve [7, 10) aralıklarında 3 tam sayı
np.random.randint([1, 5, 7], 10)
# array([4, 9, 8])


# 3 farklı üst limit değeriyle 1*3 boyutunda tam sayı dizisi
# [1, 3), [1, 5) ve [1, 10) aralıklarında 3 tam sayı
np.random.randint(1, [3, 5, 10])
# array([1, 4, 8])

Örnek: 

import matplotlib.pyplot as plt

data_set = np.random.randint(10, size=(10000))
  
plt.hist(data_set, bins=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
  
plt.title("Kesikli düzgün dağılım örneği")
  
plt.show()

choice()

[low, high) aralığında ve belirtilen şekilde, kesikli (ayrık) düzgün dağılıma sahip, rastgele tam sayılardan oluşan bir dizi üretir. 

• random.choice(a, size=None, replace=True, p=None)​
• a: 1-D dizi veya tam sayı. Eğer dizi ise , elemanları arasından seçim yapılır. Tam sayı ise, np.arange(a) dizisi üretilir ve o diziden seçilir.
• size: Tam sayı veya tam sayılardan oluşan bir tuple. Default olarak None değeridir, bu durumda tek bir değer üretilir. Opsiyonel.
• replace: Default olarak True değeridir, bu durumda a dizisinin bir değeri çok kez seçilebilir. Opsiyonel.
• p: a dizisindeki her veri için olasılıklar. Boş bırakılırsa, düzgün dağılıma sahip bir seçim yapılır. Olasılıklar toplamı 1 olmalıdır. Opsiyonel.

# choice()

# np.arange(5) ile üretilen diziden ([0, 5) aralığı) rastgele 3 eleman seçilir.
# np.random.randint(0,5,3) ile aynı işlevi görür.
np.random.choice(5, 3)
# array([0, 1, 4])


# np.arange(5) ile üretilen diziden ([0, 5) aralığı) düzgün olmayan dağılımlı 3 eleman seçilir.
# Olasılıklar toplamı 1 olmalıdır.
np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])
# array([3, 3, 2])


# Bir diziden rastgele 5 eleman seçme
liste = ['elma', 'armut', 'mandalina', 'portakal']
np.random.choice(liste, size=5, p=[0.5, 0.1, 0.1, 0.3])
# array(['armut', 'armut', 'elma', 'portakal', 'armut'], dtype='<U9')


# replace=False
liste = ['elma', 'armut', 'mandalina', 'portakal']
np.random.choice(liste, size=2, p=[0.5, 0.1, 0.1, 0.3], replace=False)
# array(['armut', 'portakal'], dtype='<U9')