کتابخانه NumPy پایتون – راهنمای جامع — بخش دوم

1>>> a = arange(12)**2 # نخستین 12 عدد مربع
2>>> i = array( [ 1,1,3,8,5 ] ) # آرایه‌ای از اندیس‌ها
3>>> a[i] # i در موقعیت‌های a عناصر
4array([ 1, 1, 9, 64, 25])
5>>>
6>>> j = array( [ [ 3, 4], [ 9, 7 ] ] ) # یک آرایه دوبعدی از اندیس‌ها
7>>> a[j] # jهمان شکل
8array([[ 9, 16],
9[81, 49]])

1>>> palette = array( [ [0,0,0], # مشکی
2... [255,0,0], # قرمز
3... [0,255,0], # سبز
4... [0,0,255], # آبی
5... [255,255,255] ] ) # سفید
6>>> image = array( [ [ 0, 1, 2, 0 ], # هر مقدار متناظر با یک رنگ در پالت است
7... [ 0, 3, 4, 0 ] ] )
8>>> palette[image] # (2,4,3) تصویر رنگی
9array([[[ 0, 0, 0],
10[255, 0, 0],
11[ 0, 255, 0],
12[ 0, 0, 0]],
13[[ 0, 0, 0],
14[ 0, 0, 255],
15[255, 255, 255],
16[ 0, 0, 0]]])

1>>> a = arange(12).reshape(3,4)
2>>> a
3array([[ 0, 1, 2, 3],
4[ 4, 5, 6, 7],
5[ 8, 9, 10, 11]])
6>>> i = array( [ [0,1], # aاندیس‌های بعد نخست
7... [1,2] ] )
8>>> j = array( [ [2,1], # اندیس‌های بعد دوم
9... [3,3] ] )
10>>>
11>>> a[i,j] # باید ابعاد یکسانی داشته باشندj و i
12array([[ 2, 5],
13[ 7, 11]])
14>>>
15>>> a[i,2]
16array([[ 2, 6],
17[ 6, 10]])
18>>>
19>>> a[:,j] # i.e., a[: , j]
20array([[[ 2, 1],
21[ 3, 3]],
22[[ 6, 5],
23[ 7, 7]],
24[[10, 9],
25[11, 11]]])

1>>> l = [i,j]
2>>> a[l] # a[i,j]معادل
3array([[ 2, 5],
4[ 7, 11]])

1>>> s = array( [i,j] )
2>>> a[s] # همان چیزی که می‌خواستیم
3Traceback (most recent call last):
4File "<stdin>", line 1, in ?
5IndexError: index (3) out of range (0<=index<=2) in dimension 0
6>>>
7>>> a[tuple(s)] # a[i,j]همانند
8array([[ 2, 5],
9[ 7, 11]])

1>>> time = linspace(20, 145, 5) # مقیاس زمانی
2>>> data = sin(arange(20)).reshape(5,4) # 4 سری وابسته به زمان
3>>> time
4array([ 20. , 51.25, 82.5 , 113.75, 145. ])
5>>> data
6array([[ 0. , 0.84147098, 0.90929743, 0.14112001],
7[-0.7568025 , -0.95892427, -0.2794155 , 0.6569866 ],
8[ 0.98935825, 0.41211849, -0.54402111, -0.99999021],
9[-0.53657292, 0.42016704, 0.99060736, 0.65028784],
10[-0.28790332, -0.96139749, -0.75098725, 0.14987721]])
11>>>
12>>> ind = data.argmax(axis=0) # اندیس ماتریس برای هر سری
13>>> ind
14array([2, 0, 3, 1])
15>>>
16>>> time_max = time[ ind] # maxima زمان متناظر با هر
17>>>
18>>> data_max = data[ind, xrange(data.shape[1])] # => data[ind[0],0], data[ind[1],1]...
19>>>
20>>> time_max
21array([ 82.5 , 20. , 113.75, 51.25])
22>>> data_max
23array([ 0.98935825, 0.84147098, 0.99060736, 0.6569866 ])
24>>>
25>>> all(data_max == data.max(axis=0))
26True

1>>> a = arange(5)
2>>> a
3array([0, 1, 2, 3, 4])
4>>> a[[1,3,4]] = 0
5>>> a
6array([0, 0, 2, 0, 0])

1>>> a = arange(5)
2>>> a[[0,0,2]]=[1,2,3]
3>>> a
4array([2, 1, 3, 3, 4])

1>>> a = arange(5)
2>>> a[[0,0,2]]+=1
3>>> a
4array([1, 1, 3, 3, 4])

1>>> a = arange(12).reshape(3,4)
2>>> b = a > 4
3>>> b #است a بولی و با شکل b
4array([[False, False, False, False],
5[False, True, True, True],
6[True, True, True, True]], dtype=bool)
7>>> a[b] # آرایه 1 بعدی با عناصر منتخب
8array([ 5, 6, 7, 8, 9, 10, 11])

1>>> a[b] = 0 # که بالاتر از 4 هستند به 0 تبدیل می‌شوند'a' همه عناصر
2>>> a
3array([[0, 1, 2, 3],
4[4, 0, 0, 0],
5[0, 0, 0, 0]])

1>>> a = arange(12).reshape(3,4)
2>>> b1 = array([False,True,True]) # انتخاب بعد نخست
3>>> b2 = array([True,False,True,False]) # انتخاب بعد دوم
4>>>
5>>> a[b1,:] # انتخاب ردیف‌ها
6array([[ 4, 5, 6, 7],
7[ 8, 9, 10, 11]])
8>>>
9>>> a[b1] # همان
10array([[ 4, 5, 6, 7],
11[ 8, 9, 10, 11]])
12>>>
13>>> a[:,b2] # انتخاب ستون‌ها
14array([[ 0, 2],
15[ 4, 6],
16[ 8, 10]])
17>>>
18>>> a[b1,b2] # یک کار عجیب!
19array([ 4, 10])

1>>> a = array([2,3,4,5])
2>>> b = array([8,5,4])
3>>> c = array([5,4,6,8,3])
4>>> ax,bx,cx = ix_(a,b,c)
5>>> ax
6array([[[2]],
7[[3]],
8[[4]],
9[[5]]])
10>>> bx
11array([[[8],
12[5],
13[4]]])
14>>> cx
15array([[[5, 4, 6, 8, 3]]])
16>>> ax.shape, bx.shape, cx.shape
17((4, 1, 1), (1, 3, 1), (1, 1, 5))
18>>> result = ax+bx*cx
19>>> result
20array([[[42, 34, 50, 66, 26],
21[27, 22, 32, 42, 17],
22[22, 18, 26, 34, 14]],
23[[43, 35, 51, 67, 27],
24[28, 23, 33, 43, 18],
25[23, 19, 27, 35, 15]],
26[[44, 36, 52, 68, 28],
27[29, 24, 34, 44, 19],
28[24, 20, 28, 36, 16]],
29[[45, 37, 53, 69, 29],
30[30, 25, 35, 45, 20],
31[25, 21, 29, 37, 17]]])
32>>> result[3,2,4]
3317
34>>> a[3]+b[2]*c[4]
3517

1def ufunc_reduce(ufct, *vectors):
2vs = ix_(*vectors)
3r = ufct.identity
4for v in vs:
5r = ufct(r,v)
6return r

1>>> ufunc_reduce(add,a,b,c)
2array([[[15, 14, 16, 18, 13],
3[12, 11, 13, 15, 10],
4[11, 10, 12, 14, 9]],
5[[16, 15, 17, 19, 14],
6[13, 12, 14, 16, 11],
7[12, 11, 13, 15, 10]],
8[[17, 16, 18, 20, 15],
9[14, 13, 15, 17, 12],
10[13, 12, 14, 16, 11]],
11[[18, 17, 19, 21, 16],
12[15, 14, 16, 18, 13],
13[14, 13, 15, 17, 12]]])

1>>> from numpy import *
2>>> from numpy.linalg import *
3>>> a = array([[1.0, 2.0], [3.0, 4.0]])
4>>> print a
5[[ 1. 2.]
6[ 3. 4.]]
7>>> a.transpose()
8array([[ 1., 3.],
9[ 2., 4.]])
10>>> inv(a)
11array([[-2. , 1. ],
12[ 1.5, -0.5]])
13>>> u = eye(2) # واحد 2x2 ماتریس; "I"معادل "eye"
14>>> u
15array([[ 1., 0.],
16[ 0., 1.]])
17>>> j = array([[0.0, -1.0], [1.0, 0.0]])
18>>> dot (j, j) # ضرب ماتریس
19array([[-1., 0.],
20[ 0., -1.]])
21>>> trace(u) # trace
222.0
23>>> y = array([[5.], [7.]])
24>>> solve(a, y)
25array([[-3.],
26[ 4.]])
27>>> eig(j)
28(array([ 0.+1.j, 0.-1.j]),
29array([[ 0.70710678+0.j, 0.70710678+0.j],
30[ 0.00000000-0.70710678j, 0.00000000+0.70710678j]]))
31Parameters:
32square matrix
33Returns
34The eigenvalues, each repeated according to its multiplicity.
35The normalized (unit "length") eigenvectors, such that the
36column ``v[:,i]`` is the eigenvector corresponding to the
37eigenvalue ``w[i]`` .

1>>> A = matrix('1.0 2.0; 3.0 4.0')
2>>> A
3[[ 1. 2.]
4[ 3. 4.]]
5>>> type(A) # تعیین محل ذخیره‌سازی ماتریس
6<class 'numpy.matrixlib.defmatrix.matrix'>
7>>> A.T # transpose
8[[ 1. 3.]
9[ 2. 4.]]
10>>> X = matrix('5.0 7.0')
11>>> Y = X.T
12>>> Y
13[[5.]
14[7.]]
15>>> print A*Y # ضرب ماتریس
16[[19.]
17[43.]]
18>>> print A.I # معکوس سازی
19[[-2. 1. ]
20[ 1.5 -0.5]]
21>>> solve(A, Y) #حل معادله جبری
22matrix([[-3.],
23[ 4.]])

1>>> A = arange(12)
2>>> A
3array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
4>>> A.shape = (3,4)
5>>> M = mat(A.copy())
6>>> print type(A)," ",type(M)
7<type 'numpy.ndarray'> <class 'numpy.core.defmatrix.matrix'>
8>>> print A
9[[ 0 1 2 3]
10[ 4 5 6 7]
11[ 8 9 10 11]]
12>>> print M
13[[ 0 1 2 3]
14[ 4 5 6 7]
15[ 8 9 10 11]]

1>>> print A[:]; print A[:].shape
2[[ 0 1 2 3]
3[ 4 5 6 7]
4[ 8 9 10 11]]
5(3, 4)
6>>> print M[:]; print M[:].shape
7[[ 0 1 2 3]
8[ 4 5 6 7]
9[ 8 9 10 11]]
10(3, 4)

1>>> print A[:,1]; print A[:,1].shape
2[1 5 9]
3(3,)
4>>> print M[:,1]; print M[:,1].shape
5[[1]
6[5]
7[9]]
8(3, 1)

1>>> A[:,[1,3]]
2array([[ 1, 3],
3[ 5, 7],
4[ 9, 11]])
5یک روش اندکی پیچیده‌تر این است که از متد take() استفاده کنیم:
6>>> A[:,].take([1,3],axis=1)
7array([[ 1, 3],
8[ 5, 7],
9[ 9, 11]])

1>>> A[1:,].take([1,3],axis=1)
2array([[ 5, 7],
3[ 9, 11]])

1>>> A[ix_((1,2),(1,3))]
2array([[ 5, 7],
3[ 9, 11]])

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

1>>> A[0,:]>1
2array([False, False, True, True], dtype=bool)
3>>> A[:,A[0,:]>1]
4array([[ 2, 3],
5[ 6, 7],
6[10, 11]])

1>>> M[0,:]>1
2matrix([[False, False, True, True]], dtype=bool)
3>>> M[:,M[0,:]>1]
4matrix([[2, 3]])

1>>> M[:,M.A[0,:]>1]
2matrix([[ 2, 3],
3[ 6, 7],
4[10, 11]])

1>>> A[A[:,0]>2,A[0,:]>1]
2array([ 6, 11])
3>>> M[M.A[:,0]>2,M.A[0,:]>1]
4matrix([[ 6, 11]])

1>>> A[numpy.ix_(A[:,0]>2,A[0,:]>1)]
2array([[ 6, 7],
3[10, 11]])
4>>> M[numpy.ix_(M.A[:,0]>2,M.A[0,:]>1)]
5matrix([[ 6, 7],
6[10, 11]])

1>>> a = arange(30)
2>>> a.shape = 2,-1,3 # به معنی آن چیزی که نیاز است-1
3>>> a.shape
4(2, 5, 3)
5>>> a
6array([[[ 0, 1, 2],
7[ 3, 4, 5],
8[ 6, 7, 8],
9[ 9, 10, 11],
10[12, 13, 14]],
11[[15, 16, 17],
12[18, 19, 20],
13[21, 22, 23],
14[24, 25, 26],
15[27, 28, 29]]])

1x = arange(0,10,2) # x=([0,2,4,6,8])
2y = arange(5) # y=([0,1,2,3,4])
3m = vstack([x,y]) # m=([[0,2,4,6,8],
4# [0,1,2,3,4]])
5xy = hstack([x,y]) # xy =([0,2,4,6,8,0,1,2,3,4])

1import numpy
2import pylab
3#یک بردار از 1000 متغیر نرمال با واریانس 2^0.5 و میانگین 2 ایجاد می‌کند
4mu, sigma = 2, 0.5
5v = numpy.random.normal(mu,sigma,10000)
6# یک هیستوگرام نرمال شده با 50 bin رسم می‌کند.
7pylab.hist(v, bins=50, normed=1) # matplotlib version (plot)
8pylab.show()
9# محاسبه و سپس رسم می‌کند numpy هیستوگرام را با
10(n, bins) = numpy.histogram(v, bins=50, normed=True) # NumPy version (no plot)
11pylab.plot(.5*(bins[1:]+bins[:-1]), n)
12pylab.show()