İÇERİK:

  1. NumPy Nedir?√
  2. Ön Şartlar√
  3. Temel Özellikler√
    1. Dizi Oluşturma√
    2. Dizileri Ekrana Basma√
    3. Basit İşlemler√
    4. Evrensel Fonksiyonlar√
    5. İndeksleme, Dilimleme, Yineleme√
  4. Şekil Manipülasyonu√
    1. Bir Dizinin Şeklini Değiştirme√
    2. Farklı Dizileri Bir Araya Yığmak√
    3. Bir Diziyi Daha Küçük Dizilere Bölmek√ 
  5. Kopyalar ve Görünümler√
    1. Hepsi Kopyalanmıyor√
    2. View veya Shallow Kopya√
    3. Deep Kopya√
  6. Fonksiyon ve Metotlara Genel Bakış√

Numpy Nedir?

Numpy, Python ile bilimsel hesaplama için temel bir programlama paketidir.

Ana özellikleri şu şekildedir ;

  • Güçlü bir N-boyutlu dizi nesnesi
  • Sofistike fonksiyonlar
  • C / C ++ ve Fortran kodunu bütünleştirme araçları
  • Kullanışlı doğrusal cebir, Fourier dönüşümü ve rastgele sayı yetenekleri

Açık bilimsel kullanımlarının yanı sıra, NumPy,  genel verilerin verimli, çok boyutlu bir deposu olarak da kullanılabilir. Keyfi veri türleri tanımlanabilir. Bu, NumPy’nin çok çeşitli veritabanlarıyla kesintisiz ve hızlı bir şekilde entegre olmasını sağlar.

Ön Şartlar

Bu öğretici başlangıçı okumadan önce biraz Python bilmelisin. Hatırlamak isterseniz, Python Tutorial ‘ına bir göz atın.

Bu öğretici başlangıçtaki örneklerle çalışmak isterseniz, bilgisayarınızda da bazı yazılımların yüklü olması gerekir.

Temel Özellikler

Numpy’da dizi, aynı türde bir değerler tablosudur ve negatif olmayan tamsayılar dizisiyle dizinlenmiştir. Boyut sayısı dizi sıralamasıdır; bir dizinin şekli, her eksen boyunca dizinin boyutunu veren tamsayı dizisidir.

NumPy’nin dizi sınıfına ndarray adı verilir. Ayrıca takma ad dizisi ile de bilinir. Numpy.array, yalnızca bir boyutlu dizileri işleyen ve daha az işlevsellik sunan Standart Python Library sınıfı array.array ile aynı değildir. Bir ndarray nesnesinin daha önemli özellikleri şunlardır:

Ndarray.ndim: Dizinin eksenlerinin (boyutları) sayısı. Python dünyasında, boyutların sayısına rank denir.

Ndarray.shape: Dizinin boyutları. Bu, her boyutta dizinin boyutunu belirten bir tamsayı yığınıdır. N sıralı ve m sütunlu bir matris için A(n, m) olacaktır. Bu nedenle, A dizesinin uzunluğu sırası veya boyut sayısıdır, ndim.

Ndarray.size: Dizinin elemanlarının toplam sayısı.

Ndarray.dtype: Dizideki öğelerin türünü açıklayan bir nesne. Standart python türlerini kullanarak dtype’leri yaratabilir veya belirtebilirsiniz. Buna ek olarak NumPy kendi türlerini sunar. Numpy.int32, numpy.int16 ve numpy.float64 bazı örneklerdir.

Ndarray.itemsize:  Dizinin her öğemsize 8 (= 64/8) bulunurken, complex32 türlerinden biri itemsize 4 (= 32/8) öğesine sahiptir. Ndarray.dtype.itemsize ile eşdeğerdir.

Ndarray.data: Arabellek, dizinin gerçek öğelerini içerir. Normalde, bu özniteliği kullanmamız gerekmez çünkü dizin oluşturma olanakları kullanarak bir dizideki öğelere erişiriz.

Basit Bir Örnek:

import numpy as np

a = np.arange(15).reshape(3, 5)

print a
print a.shape
print a.ndim
print a.dtype.name
print a.itemsize
print a.size
print type(a)


b = np.array([6, 7, 8])
print b
print type(b)

Çıktısı:

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
(3, 5)
2
int64
8
15
<type 'numpy.ndarray'>
[6 7 8]
<type 'numpy.ndarray'>

Dizi Oluşturma

Dizi oluşturmanın birkaç yolu vardır. Örneğin, dizi işlevini kullanarak normal bir Python listesinden veya tuple’den bir dizi oluşturabilirsiniz. Oluşan dizinin türü, dizideki öğelerin türüne göre çıkarılır.

import numpy as np

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

b = np.array([1.2, 3.5, 5.1])
print b.dtype

Çıktısı:

[2 3 4]
int64
float64

Sık karşılaşılan bir hata, dizi için bağımsız değişken olarak tek bir liste sunmak yerine, birden çok sayısal bağımsız değişkeni içeren bir dizi çağrılmasını içerir.

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

Dizi, dizilerin dizilerini iki boyutlu dizilere, dizilerin dizilerinin dizilerini üç boyutlu dizilere dönüştürür ve böyle devam eder.

b = np.array([(1.5, 2, 3), (4, 5, 6)])
print b

Çıktısı:

[[ 1.5  2.   3. ]
 [ 4.   5.   6. ]]

Dizinin türü, oluşturulma sırasında açıkça belirtilebilir:

c = np.array( [ [1,2], [3,4] ], dtype=complex )

Çoğu zaman, bir dizinin elemanları başlangıçta bilinmiyor, ancak boyutu biliniyor. Dolayısıyla, NumPy, başlangıçtaki yer tutucu içeriği olan diziler oluşturmak için çeşitli işlevler sunar. Bu, artan dizilerin gerekliliğini en aza indirgemektedir ve pahalı bir işlemdir.

ones foksiyonu, sıfırlarla dolu bir dizi oluşturur;  ones fonksiyonu sıfırlarla dolu bir dizi oluşturur ve empty, başlangıç içeriği rasgele olan ve bellek durumuna bağlı olan bir dizi oluşturur. Varsayılan olarak, oluşturulan dizinin dtype’si float64’tür.

np.zeros((3, 4))

print np.ones((2, 3, 4), dtype=np.int16)  # dtype can also be specified

print np.empty((2, 3))  # uninitialized, output may vary

Çıktısı:

[[[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]

 [[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]]
[[  1.39069238e-309   1.39069238e-309   1.39069238e-309]
 [  1.39069238e-309   1.39069238e-309   1.39069238e-309]]

Sayı dizileri oluşturmak için NumPy, diziler yerine dizileri döndüren range benzeri bir işlev sunar.

print np.arange(10, 30, 5)
print np.arange(0, 2, 0.3)  # it accepts float arguments

Çıktısı:

[10 15 20 25]
[ 0.   0.3  0.6  0.9  1.2  1.5  1.8]

arange kayan nokta bağımsız değişkenleriyle birlikte kullanıldığında, sonlu kayan nokta hassasiyete bağlı olarak elde edilen öğe sayısını tahmin etmek genellikle mümkün değildir. Bu nedenle, adım yerine, istediğimiz öğe sayısını argüman olarak alan linspace fonksiyonunu kullanmak daha iyi olur:

from numpy import pi

print np.linspace(0, 2, 9)  # 9 numbers from 0 to 2
x = np.linspace(0, 2 * pi, 100)  # useful to evaluate function at lots of points
f = np.sin(x)

Çıktısı:

[ 0.    0.25  0.5   0.75  1.    1.25  1.5   1.75  2.  ]

Ayrıca Bkz.

array, zeroszeros_likeonesones_likeemptyempty_likearange,

 linspacenumpy.random.rand, numpy.random.randn,fromfunctionfromfile

Dizileri Ekrana Basma

Bir diziyi yazdırdığınızda, NumPy onu iç içe geçmiş listelere benzer şekilde, ancak şu düzende görüntüler:

  • Son eksen soldan sağa,
  • Sonuncudan sonuncusuna yukarıdan aşağıya,
  • Geri kalanlar da üstten alta doğru basılır, her dilim boş bir çizgi ile birbirinden ayrılır.
  • Tek boyutlu diziler daha sonra sıralar, matrisler olarak iki boyutlu olarak ve matrislerin listeleri olarak üç boyutlu olarak yazdırılır.
a = np.arange(6)  # 1d array
print a

b = np.arange(12).reshape(4, 3)  # 2d array
print b

c = np.arange(24).reshape(2, 3, 4)  # 3d array
print c

Çıktısı:

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

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

Bir dizi yazdırılamayacak kadar büyükse, NumPy otomatik olarak dizinin orta bölümünü atlar ve yalnızca köşeleri yazdırır:

print(np.arange(10000))

print(np.arange(10000).reshape(100,100))

Çıktısı:

[   0    1    2 ..., 9997 9998 9999]
[[   0    1    2 ...,   97   98   99]
 [ 100  101  102 ...,  197  198  199]
 [ 200  201  202 ...,  297  298  299]
 ..., 
 [9700 9701 9702 ..., 9797 9798 9799]
 [9800 9801 9802 ..., 9897 9898 9899]
 [9900 9901 9902 ..., 9997 9998 9999]]

Bu davranışı devre dışı bırakmak ve NumPy’yi tüm diziyi yazdırmaya zorlamak için, yazdırma seçeneklerini set_printoptions‘ları kullanarak değiştirebilirsiniz.

np.set_printoptions(threshold='nan')

Basit İşlemler

Dizilerdeki aritmetik işleçler öğeler halinde uygulanır. Yeni bir dizi oluşturulur ve sonuçla doldurulur.

a = np.array( [20,30,40,50] )
b = np.arange( 4 )
print b
c = a-b
print c
print  b**2
print  10*np.sin(a)
print  a<35

Çıktısı:

[0 1 2 3]
[20 29 38 47]
[0 1 4 9]
[ 9.12945251 -9.88031624 7.4511316 -2.62374854]
[ True True False False]

Birçok matris dilinin aksine, the product operator *  NumPy dizilerinde elemanı akıllıca çalıştırır. Matris çarpımı, nokta işlevi veya yöntemi kullanılarak gerçekleştirilebilir:

A = np.array([[1, 1], [0, 1]])
B = np.array([[2, 0], [3, 4]])

print A * B  # elementwise product
print A.dot(B)  # matrix product
print np.dot(A, B)  # another matrix product

Çıktısı:

[[2 0]
 [0 4]]
[[5 4]
 [3 4]]
[[5 4]
 [3 4]]

+ = Ve * = gibi bazı işlemler, varolan bir diziyi yenisi oluşturmak yerine değiştirmek için çalışır.

a = np.ones((2, 3), dtype=int)
b = np.random.random((2, 3))
a *= 3
print a
b += a
print b
a += b  # b is not automatically converted to integer type

Çıktısı:

[[3 3 3]
 [3 3 3]]
[[ 3.6046253 3.05222869 3.09586971]
 [ 3.27263595 3.86837768 3.50729883]]
Traceback (most recent call last):
 File "/home/biznet/sanal/MachineLearningPOC/data_leakage_detection/NumPy/ex1.py", line 9, in 
 a += b # b is not automatically converted to integer type

Farklı türdeki dizilerle çalışırken, elde edilen dizinin türü, daha genel veya kesin olan dizilime karşılık gelir (bu upcasting olarak bilinir).

a = np.ones(3, dtype=np.int32)
b = np.linspace(0, np.pi, 3)
print b.dtype.name
c = a+b
print c
print c.dtype.name
d = np.exp(c*1j)
print d
print d.dtype.name

Çıktısı:

float64
[ 1. 2.57079633 4.14159265]
float64
[ 0.54030231+0.84147098j -0.84147098+0.54030231j -0.54030231-0.84147098j]
complex128

Dizideki tüm öğelerin toplamını hesaplama gibi birçok tekli işlem, ndarray sınıfının metodları olarak uygulanır.

a = np.random.random((2,3))
print a
print a.sum()
print a.min()
print a.max()

Çıktısı:

[[ 0.92625608 0.02977903 0.45768631]
 [ 0.38660952 0.99507857 0.12006857]]
2.91547808214
0.0297790321507
0.995078572948

Varsayılan olarak, bu işlemler dizinin şekline bakılmaksızın sayıların bir listesi olduğu şekilde diziye uygulanır. Bununla birlikte, eksen parametresini belirterek, bir dizinin belirtilen ekseni boyunca bir işlem uygulayabilirsiniz:

b = np.arange(12).reshape(3, 4)
print  b
print
print  b.sum(axis=0)  # sum of each column
print
print  b.min(axis=1)  # min of each row
print
print  b.cumsum(axis=1)  # cumulative sum along each row

Çıktısı:

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

[12 15 18 21]

[0 4 8]

[[ 0 1 3 6]
 [ 4 9 15 22]
 [ 8 17 27 38]]

Evrensel Fonksiyonlar

NumPy, sin, cos ve exp gibi tanıdık matematiksel fonksiyonları sağlar. NumPy’de bunlar “evrensel fonksiyonlar” (ufunc) olarak adlandırılır. NumPy içinde bu işlevler elemanlarda bir dizi üzerinde çalışır ve çıktı olarak bir dizi üretir.

B = np.arange(3)
print  B
print  np.exp(B)
print  np.sqrt(B)
C = np.array([2., -1., 4.])
print  np.add(B, C)

Çıktısı:

[0 1 2]
[ 1. 2.71828183 7.3890561 ]
[ 0. 1. 1.41421356]
[ 2. 0. 6.]

Ayrıca Bkz.

allanyapply_along_axisargmaxargminargsortaveragebincountceilclip

conjcorrcoefcovcrosscumprodcumsum,diffdotfloorinnerinvlexsortmax,

 maximummeanmedianminminimumnonzeroouterprodreroundsortstdsum

,tracetransposevarvdotvectorizewhere

İndeksleme, Dilimleme, Yineleme

Tek boyutlu diziler, listeler ve diğer Python dizilerinde olduğu gibi dizine eklenebilir, dilimlenebilir ve yinelenebilir.

a = np.arange(10) ** 3
print  a
print  a[2]

print  a[2:5]
a[:6:2] = -1000  # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
print  a
print  a[::-1]  # reversed a
for i in a:
    print(i ** (1 / 3.))

Çıktısı:

[ 0 1 8 27 64 125 216 343 512 729]
8
[ 8 27 64]
[-1000 1 -1000 27 -1000 125 216 343 512 729]
[ 729 512 343 216 125 -1000 27 -1000 1 -1000]
nan
1.0
nan
3.0
nan
5.0
6.0
7.0
8.0
9.0

Çok boyutlu diziler, eksen başına bir dizin içerebilir. Bu indisler virgüllerle ayrılmış bir grup halinde verilir:

def f(x, y):
    return 10 * x + y

b = np.fromfunction(f, (5, 4), dtype=int)
print  b
print  b[2, 3]
print  b[0:5, 1]  # each row in the second column of b
print  b[:, 1]  # equivalent to the previous example
print  b[1:3, :]  # each column in the second and third row of b

Çıktısı:

[[ 0 1 2 3]
 [10 11 12 13]
 [20 21 22 23]
 [30 31 32 33]
 [40 41 42 43]]
23
[ 1 11 21 31 41]
[ 1 11 21 31 41]
[[10 11 12 13]
 [20 21 22 23]]

Eksen sayısından daha az endeks sağlandığında, eksik endeksler tam dilimler olarak kabul edilir:

b[-1]                                  # the last row. Equivalent to b[-1,:]

Çıktısı:

[40, 41, 42, 43]

B [i] ‘de köşeli parantez içerisindeki ifade bir i olarak, ardından kalan eksenleri temsil etmek için gerekli olduğu kadar çok sayıda örnek olarak ele alınır. NumPy ayrıca, noktaları b [i, …] olarak yazmanıza izin verir.

Noktalar (…), tam bir dizin oluşturma grubu oluşturmak için gereken iki nokta üst üste çizgiyi temsil eder. Örneğin, x, in rank i 5 dizisi ise (yani, 5 eksene sahipse), o zaman

x[1,2,...] is equivalent to x[1,2,:,:,:],
x[...,3] to x[:,:,:,:,3] and
x[4,...,5,:] to x[4,:,:,5,:].
c = np.array( [[[  0,  1,  2],               # a 3D array (two stacked 2D arrays)
                 [ 10, 12, 13]],
                [[100,101,102],
                 [110,112,113]]])
print c.shape
print c[1,...]                                   # same as c[1,:,:] or c[1]F
print c[...,2]                                   # same as c[:,:,2]

Çıktısı:

(2, 2, 3)
[[100 101 102]
 [110 112 113]]
[[ 2 13]
 [102 113]]

Çok boyutlu diziler üzerinde yineleme, ilk eksene göre yapılır:

for row in b:
    print(row)

Çıktısı:

[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]

Ancak, dizideki her öğe üzerinde bir işlem gerçekleştirmek istiyorsa, dizinin tüm öğeleri üzerinde yineleyici olan düz özniteliği kullanabilirsiniz:

for element in b.flat:
     print(element)

Çıktısı:

0
1
2
3
10
11
12
13
20
21
22
23
30
31
32
33
40
41
42
43

Ayrıca Bkz.

IndexingIndexing (reference), newaxisndenumerateindices

Şekil Manipülasyonu

Bir Dizinin Şeklini Değiştirme

Bir dizinin her bir eksendeki öğe sayısı tarafından verilen bir şekli(shape) vardır:

a = np.floor(10*np.random.random((3,4)))
print a
print a.shape

Çıktısı:

array([[ 2.,  8.,  0.,  6.],
       [ 4.,  5.,  1.,  1.],
       [ 8.,  9.,  3.,  6.]])
(3, 4)

Bir dizinin şekli çeşitli komutlarla değiştirilebilir. Aşağıdaki üç komutun tümü değiştirilmiş bir diziyi döndürür ancak orijinal diziyi değiştirmeyin:

print a.ravel()  # returns the array, flattened
print a.reshape(6,2)  # returns the array with a modified shape
print a.T  # returns the array, transposed
print a.T.shape
print a.shape

Çıktısı:

array([ 2.,  8.,  0.,  6.,  4.,  5.,  1.,  1.,  8.,  9.,  3.,  6.])
array([[ 2.,  8.],
       [ 0.,  6.],
       [ 4.,  5.],
       [ 1.,  1.],
       [ 8.,  9.],
       [ 3.,  6.]])
array([[ 2.,  4.,  8.],
       [ 8.,  5.,  9.],
       [ 0.,  1.,  3.],
       [ 6.,  1.,  6.]])
(4, 3)
(3, 4)

Dizi içindeki elemanların sırası, ravel() sonucu “C stili”, yani en sağdaki dizin “en hızlı şekilde değişir”, dolayısıyla a [0,0] ‘dan sonraki öğe bir [0,1] . Dizi başka bir şekle dönüştürüldüyse, dizi yine “C-stili” olarak değerlendirilir. NumPy normalde bu sırayla saklanan dizileri oluşturur, bu nedenle ravel() genellikle argümanını kopyalamaya gerek duymaz ancak dizi başka bir dizinin dilimleri kullanılarak yapılırsa veya alışılmadık seçeneklerle oluşturulmuşsa, kopyalanması gerekebilir. En soldaki dizin en hızlı değişen FORTRAN stilindeki dizileri kullanmak için, isteğe bağlı bir bağımsız değişken kullanarak ravel() ve reshape() fonksiyonları da kullanılabilir.

Çıktısı:

Reshape fonksiyonu argümanını değiştirilmiş bir şekil ile döndürürken, ndarray.resize yöntemi dizinin kendisini değiştirir:

Çıktısı:

Yeniden şekillendirme işleminde bir boyut -1 olarak verilirse, diğer boyutlar otomatik olarak hesaplanır:

Çıktısı:

Ayrıca Bkz:

ndarray.shapereshaperesizeravel

Farklı Dizileri Bir Araya Yığmak

Çeşitli eksenler boyunca çeşitli diziler bir araya getirilebilir:

a = np.floor(10*np.random.random((2,2)))
print a
b = np.floor(10*np.random.random((2,2)))
print b
print np.vstack((a,b))
print np.hstack((a,b))

Çıktısı:

array([[ 8.,  8.],
       [ 0.,  0.]])
array([[ 1.,  8.],
       [ 0.,  4.]])
array([[ 8.,  8.],
       [ 0.,  0.],
       [ 1.,  8.],
       [ 0.,  4.]])
array([[ 8.,  8.,  1.,  8.],
       [ 0.,  0.,  0.,  4.]])

column_stack fonksiyonu 1D dizilerini 2D bir diziye sütun olarak yığar. vstack’e yalnızca 1D dizileriyle eşdeğerdir:

from numpy import newaxis
print np.column_stack((a,b))   # With 2D arrays
a = np.array([4.,2.])
b = np.array([2.,8.])
print a[:,newaxis]  # This allows to have a 2D columns vector
print np.column_stack((a[:,newaxis],b[:,newaxis]))
print np.vstack((a[:,newaxis],b[:,newaxis])) # The behavior of vstack is different

Çıktısı:

array([[ 8.,  8.,  1.,  8.],
       [ 0.,  0.,  0.,  4.]])
array([[ 4.],
       [ 2.]])
array([[ 4.,  2.],
       [ 2.,  8.]])
array([[ 4.],
       [ 2.],
       [ 2.],
       [ 8.]])

İki boyuttan daha büyük boyutlu diziler için hstack, ikinci eksenlerinde yığınlar, ilk eksenleri boyunca vstack yığınları ve concatenate eklemenin gerçekleşmesi gereken eksenin sayısını veren isteğe bağlı bağımsız değişkenler sağlar.

Not: Karmaşık durumlarda, r_ ve c_, bir eksende sayıları istifleyerek diziler oluşturmak için kullanışlıdır. Aralık bildirimlerinin kullanılmasına izin veriyorlar (“:”)

print np.r_[1:4,0,4]

Çıktısı:

array([1, 2, 3, 0, 4])

Bağımsız olarak dizilerle birlikte kullanıldığında, r_ ve c_ varsayılan davranışlarında vstack ve hstack’e benzer ancak, eklenecek eksenin sayısını veren isteğe bağlı bir bağımsız değişkene izin verir.

Ayrıca Bkz

hstackvstackcolumn_stackconcatenatec_r_

Bir Diziyi Daha Küçük Dizilere Bölmek

hsplit‘i kullanarak, bir diziyi yatay ekseni boyunca bölebilirsiniz, ya döndürmek için eşit şekilde şekillendirilmiş dizilerin sayısını belirleyerek veya bölümün hangi bölümden sonra oluşacağı sütunlar belirleyerek:

a = np.floor(10*np.random.random((2,12)))
print a
print np.hsplit(a,3)   # Split a into 3
print np.hsplit(a,(3,4))   # Split a after the third and the fourth column

Çıktısı:

array([[ 9.,  5.,  6.,  3.,  6.,  8.,  0.,  7.,  9.,  7.,  2.,  7.],
       [ 1.,  4.,  9.,  2.,  2.,  1.,  0.,  6.,  2.,  2.,  4.,  0.]])
[array([[ 9.,  5.,  6.,  3.],
       [ 1.,  4.,  9.,  2.]]), array([[ 6.,  8.,  0.,  7.],
       [ 2.,  1.,  0.,  6.]]), array([[ 9.,  7.,  2.,  7.],
       [ 2.,  2.,  4.,  0.]])]
[array([[ 9.,  5.,  6.],
       [ 1.,  4.,  9.]]), array([[ 3.],
       [ 2.]]), array([[ 6.,  8.,  0.,  7.,  9.,  7.,  2.,  7.],
       [ 2.,  1.,  0.,  6.,  2.,  2.,  4.,  0.]])]

vsplit dikey eksende bölünür ve array_split, hangi eksende bölünebileceğini belirtir.

Kopyalar ve Görünümler

Dizileri çalıştırırken ve işlerken, verileri bazen yeni bir diziye kopyalar ve bazen koparılır. Bu genellikle yeni başlayanlar için bir karışıklık kaynağıdır. Üç durum vardır:

Hepsi Kopyalanmıyor

Basit atamalar, dizi nesnelerinin veya verilerin hiçbir kopyasını oluşturmaz.

a = np.arange(12)
b = a            # no new object is created
print b is a           # a and b are two names for the same ndarray object
b.shape = 3,4    # changes the shape of a
print a.shape

Çıktısı:

True
(3, 4)

Python mutable nesneleri referans olarak gönderir, böylece işlev çağrıları kopya oluşturmaz.

def f(x):
     print(id(x))
print id(a)                           # id is a unique identifier of an object
print f(a)

Çıktısı:

148293216
148293216

View veya Shallow Kopya

Farklı dizi nesneleri aynı verileri paylaşabilir. view yöntemi, aynı veriye bakan yeni bir dizi nesnesi oluşturur.

c = a.view()
print c is a
print c.base is a                        # c is a view of the data owned by a
print c.flags.owndata
c.shape = 2,6                      # a's shape doesn't change
print a.shape
c[0,4] = 1234                      # a's data changes
print a

Çıktısı:

False
True
False
(3, 4)
array([[   0,    1,    2,    3],
       [1234,    5,    6,    7],
       [   8,    9,   10,   11]])

Bir dizinin dilimlenmesi onun bir görünümünü döndürür:

s = a[ : , 1:3]     # spaces added for clarity; could also be written "s = a[:,1:3]"
s[:] = 10           # s[:] is a view of s. Note the difference between s=10 and s[:]=10
print a

Çıktısı:

array([[   0,   10,   10,    3],
       [1234,   10,   10,    7],
       [   8,   10,   10,   11]])

Deep Kopya

copy fonksiyonu, dizinin ve verisinin tam bir kopyasını yapar.

d = a.copy()                          # a new array object with new data is created
print d is a
print d.base is a                           # d doesn't share anything with a
d[0,0] = 9999
print a

Çıktısı:

False
False
array([[   0,   10,   10,    3],
       [1234,   10,   10,    7],
       [   8,   10,   10,   11]])

Fonksiyon ve Metotlara Genel Bakış

İşte bazı faydalı NumPy işlevleri ve yöntem adları kategoriler halinde sıralanmıştır. Tam liste için Routines ‘leri  inceleyin.

IDE: PyCharm

version: python2.7

packages: numpy 1.12.1,  scipy 0.19.0 

Referans:

http://www.numpy.org/