खोज…
परिचय
एन-डायमेंशनल सरणियाँ या ndarrays एक ही डेटा प्रकार की वस्तुओं को संग्रहीत करने के लिए उपयोग की जाने वाली numpy की मुख्य वस्तु है। वे एक कुशल डेटा संरचना प्रदान करते हैं जो सामान्य पायथन के सरणियों से बेहतर है।
टिप्पणियों
जब भी एरे और वेक्टर ऑपरेशन के संदर्भ में डेटा पर संभव एक्सप्रेस संचालन। वेक्टर ऑपरेशन लूप के लिए समकक्ष की तुलना में बहुत तेजी से निष्पादित होते हैं
एक सरणी बनाएँ
खाली सरणी
np.empty((2,3))
ध्यान दें कि इस स्थिति में, इस सरणी में मान सेट नहीं हैं। सरणी बनाने का यह तरीका केवल इसलिए उपयोगी होता है यदि सरणी कोड में बाद में भरी जाती है।
एक सूची से
np.array([0,1,2,3])
# Out: array([0, 1, 2, 3])
एक सीमा बनाएँ
np.arange(4)
# Out: array([0, 1, 2, 3])
शून्य बनाएं
np.zeros((3,2))
# Out:
# array([[ 0., 0.],
# [ 0., 0.],
# [ 0., 0.]])
प्याज बनाएँ
np.ones((3,2))
# Out:
# array([[ 1., 1.],
# [ 1., 1.],
# [ 1., 1.]])
रैखिक-स्थान सरणी आइटम बनाएँ
np.linspace(0,1,21)
# Out:
# array([ 0. , 0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 ,
# 0.45, 0.5 , 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85,
# 0.9 , 0.95, 1. ])
लॉग-स्पेस सरणी आइटम बनाएँ
np.logspace(-2,2,5)
# Out:
# array([ 1.00000000e-02, 1.00000000e-01, 1.00000000e+00,
# 1.00000000e+01, 1.00000000e+02])
किसी दिए गए फ़ंक्शन से सरणी बनाएं
np.fromfunction(lambda i: i**2, (5,))
# Out:
# array([ 0., 1., 4., 9., 16.])
np.fromfunction(lambda i,j: i**2, (3,3))
# Out:
# array([[ 0., 0., 0.],
# [ 1., 1., 1.],
# [ 4., 4., 4.]])
ऐरे ऑपरेटरों
x = np.arange(4)
x
#Out:array([0, 1, 2, 3])
अदिश जोड़ तत्व वार है
x+10
#Out: array([10, 11, 12, 13])
अदिश गुणन तत्व वार है
x*2
#Out: array([0, 2, 4, 6])
ऐरे जोड़ तत्व वार है
x+x
#Out: array([0, 2, 4, 6])
सरणी गुणा तत्व वार है
x*x
#Out: array([0, 1, 4, 9])
डॉट उत्पाद (या अधिक सामान्यतः मैट्रिक्स गुणा) एक फ़ंक्शन के साथ किया जाता है
x.dot(x)
#Out: 14
पायथन 3.5 में, मैट्रिक्स गुणा के लिए infix ऑपरेटर के रूप में @ ऑपरेटर जोड़ा गया था
x = np.diag(np.arange(4))
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 3]])
'''
print(x@x)
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 9]])
'''
अपेंड करें । संलग्न मूल्यों के साथ प्रति कॉपी। जगह में नहीं।
#np.append(array, values_to_append, axis=None)
x = np.array([0,1,2,3,4])
np.append(x, [5,6,7,8,9])
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x
# Out: array([0, 1, 2, 3, 4])
y = np.append(x, [5,6,7,8,9])
y
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
हस्टैक । क्षैतिज ढेर। (कॉलम स्टैक)
वीथिका । ऊर्ध्वाधर ढेर। (पंक्ति ढेर)
# np.hstack(tup), np.vstack(tup)
x = np.array([0,0,0])
y = np.array([1,1,1])
z = np.array([2,2,2])
np.hstack(x,y,z)
# Out: array([0, 0, 0, 1, 1, 1, 2, 2, 2])
np.vstack(x,y,z)
# Out: array([[0, 0, 0],
# [1, 1, 1],
# [2, 2, 2]])
ऐरे एक्सेस
स्लाइस सिंटैक्स i:j:k जहाँ i शुरुआती इंडेक्स (समावेशी) है, j स्टॉपिंग इंडेक्स (अनन्य) है और k स्टेप साइज़ है। अन्य अजगर डेटा संरचनाओं की तरह, पहले तत्व में 0 का सूचकांक है:
x = np.arange(10)
x[0]
# Out: 0
x[0:4]
# Out: array([0, 1, 2, 3])
x[0:4:2]
# Out:array([0, 2])
सरणी के अंत से नकारात्मक मानों की गणना होती है। -1 इसलिए एक सरणी में अंतिम तत्व तक पहुँचता है:
x[-1]
# Out: 9
x[-1:0:-1]
# Out: array([9, 8, 7, 6, 5, 4, 3, 2, 1])
बहु-आयामी सरणियों को कॉमा द्वारा अलग किए गए प्रत्येक आयाम को निर्दिष्ट करके पहुँचा जा सकता है। पिछले सभी नियम लागू होते हैं।
x = np.arange(16).reshape((4,4))
x
# Out:
# array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11],
# [12, 13, 14, 15]])
x[1,1]
# Out: 5
x[0:3,0]
# Out: array([0, 4, 8])
x[0:3, 0:3]
# Out:
# array([[ 0, 1, 2],
# [ 4, 5, 6],
# [ 8, 9, 10]])
x[0:3:2, 0:3:2]
# Out:
# array([[ 0, 2],
# [ 8, 10]])
किसी सरणी को स्थानांतरित करना
arr = np.arange(10).reshape(2, 5)
.transpose विधि का उपयोग करना:
arr.transpose()
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
.T विधि:
arr.T
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
या np.transpose :
np.transpose(arr)
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
2-आयामी सरणी के मामले में, यह एक मानक मैट्रिक्स ट्रांज़ोज़ (जैसा कि ऊपर दर्शाया गया है) के बराबर है। एन-आयामी मामले में, आप सरणी अक्षों के एक क्रमांकन को निर्दिष्ट कर सकते हैं। डिफ़ॉल्ट रूप से, यह array.shape उलट array.shape :
a = np.arange(12).reshape((3,2,2))
a.transpose() # equivalent to a.transpose(2,1,0)
# Out:
# array([[[ 0, 4, 8],
# [ 2, 6, 10]],
#
# [[ 1, 5, 9],
# [ 3, 7, 11]]])
लेकिन अक्ष सूचकांक के किसी भी क्रमपरिवर्तन संभव है:
a.transpose(2,0,1)
# Out:
# array([[[ 0, 2],
# [ 4, 6],
# [ 8, 10]],
#
# [[ 1, 3],
# [ 5, 7],
# [ 9, 11]]])
a = np.arange(24).reshape((2,3,4)) # shape (2,3,4)
a.transpose(2,0,1).shape
# Out:
# (4, 2, 3)
बूलियन अनुक्रमण
arr = np.arange(7)
print(arr)
# Out: array([0, 1, 2, 3, 4, 5, 6])
एक स्केलर के साथ तुलना एक बूलियन सरणी देता है:
arr > 4
# Out: array([False, False, False, False, False, True, True], dtype=bool)
इस सरणी का उपयोग केवल 4 से अधिक संख्या का चयन करने के लिए अनुक्रमण में किया जा सकता है:
arr[arr>4]
# Out: array([5, 6])
बूलियन इंडेक्सिंग का उपयोग विभिन्न सरणियों (जैसे संबंधित समानांतर सरणियों) के बीच किया जा सकता है:
# Two related arrays of same length, i.e. parallel arrays
idxs = np.arange(10)
sqrs = idxs**2
# Retrieve elements from one array using a condition on the other
my_sqrs = sqrs[idxs % 2 == 0]
print(my_sqrs)
# Out: array([0, 4, 16, 36, 64])
सरणी को पुन: आकार देना
numpy.reshape (के रूप में ही numpy.ndarray.reshape ) विधि एक ही कुल आकार की एक सरणी देता है, लेकिन एक नए आकार में:
print(np.arange(10).reshape((2, 5)))
# [[0 1 2 3 4]
# [5 6 7 8 9]]
यह एक नया सरणी देता है, और जगह में काम नहीं करता है:
a = np.arange(12)
a.reshape((3, 4))
print(a)
# [ 0 1 2 3 4 5 6 7 8 9 10 11]
हालांकि, यह अधिलेखित करने के लिए संभव है shape एक की विशेषता ndarray :
a = np.arange(12)
a.shape = (3, 4)
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
यह व्यवहार पहली बार में आश्चर्यचकित कर सकता है, लेकिन ndarray s को मेमोरी के सन्निहित ब्लॉक में संग्रहीत किया जाता है, और उनका shape केवल यह निर्दिष्ट करता है कि डेटा की इस धारा को एक बहुआयामी वस्तु के रूप में कैसे समझा जाना चाहिए।
shape में एक धुरी तक टपल का मान -1 । numpy तब आपके लिए इस अक्ष की लंबाई का अनुमान numpy :
a = np.arange(12)
print(a.reshape((3, -1)))
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
या:
a = np.arange(12)
print(a.reshape((3, 2, -1)))
# [[[ 0 1]
# [ 2 3]]
# [[ 4 5]
# [ 6 7]]
# [[ 8 9]
# [10 11]]]
एकाधिक अनिर्दिष्ट आयाम, उदाहरण के लिए। a.reshape((3, -1, -1)) की अनुमति नहीं है और एक ValueError फेंक देंगे।
प्रसारण सरणी संचालन
Numpy सरणियों पर अंकगणित संचालन को मूल रूप से किया जाता है। समान आकृति के सरणियों के लिए, इसका मतलब है कि ऑपरेशन को संबंधित सूचकांकों में तत्वों के बीच निष्पादित किया जाता है।
# Create two arrays of the same size
a = np.arange(6).reshape(2, 3)
b = np.ones(6).reshape(2, 3)
a
# array([0, 1, 2],
# [3, 4, 5])
b
# array([1, 1, 1],
# [1, 1, 1])
# a + b: a and b are added elementwise
a + b
# array([1, 2, 3],
# [4, 5, 6])
Numpy प्रसारण के माध्यम से विभिन्न आकृतियों के सरणियों पर अंकगणित संचालन भी निष्पादित किया जा सकता है। सामान्य तौर पर, एक सरणी को दूसरे पर "प्रसारित" किया जाता है ताकि अनुरूप आकार के उप-सरणियों पर तत्व-संचालन किया जाता है।
# Create arrays of shapes (1, 5) and (13, 1) respectively
a = np.arange(5).reshape(1, 5)
a
# array([[0, 1, 2, 3, 4]])
b = np.arange(4).reshape(4, 1)
b
# array([0],
# [1],
# [2],
# [3])
# When multiplying a * b, slices with the same dimensions are multiplied
# elementwise. In the case of a * b, the one and only row of a is multiplied
# with each scalar down the one and only column of b.
a*b
# array([[ 0, 0, 0, 0, 0],
# [ 0, 1, 2, 3, 4],
# [ 0, 2, 4, 6, 8],
# [ 0, 3, 6, 9, 12]])
इसे और स्पष्ट करने के लिए, बधाई उप-आयामों के साथ 2 डी और 3 डी सरणियों के गुणन पर विचार करें।
# Create arrays of shapes (2, 2, 3) and (2, 3) respectively
a = np.arange(12).reshape(2, 2, 3)
a
# array([[[ 0 1 2]
# [ 3 4 5]]
#
# [[ 6 7 8]
# [ 9 10 11]]])
b = np.arange(6).reshape(2, 3)
# array([[0, 1, 2],
# [3, 4, 5]])
# Executing a*b broadcasts b to each (2, 3) slice of a,
# multiplying elementwise.
a*b
# array([[[ 0, 1, 4],
# [ 9, 16, 25]],
#
# [[ 0, 7, 16],
# [27, 40, 55]]])
# Executing b*a gives the same result, i.e. the smaller
# array is broadcast over the other.
सरणी प्रसारण कब लागू किया जाता है?
प्रसारण तब होता है जब दो सरणियों के संगत आकार होते हैं।
आकृतियों की तुलना घटक-वार से होती है, जो अनुगामी से शुरू होती है। दो आयाम संगत हैं यदि या तो वे समान हैं या उनमें से एक 1 । यदि एक आकार में दूसरे की तुलना में अधिक आयाम हैं, तो अधिक से अधिक घटकों की तुलना नहीं की जाती है।
संगत आकृतियों के कुछ उदाहरण:
(7, 5, 3) # compatible because dimensions are the same
(7, 5, 3)
(7, 5, 3) # compatible because second dimension is 1
(7, 1, 3)
(7, 5, 3, 5) # compatible because exceeding dimensions are not compared
(3, 5)
(3, 4, 5) # incompatible
(5, 5)
(3, 4, 5) # compatible
(1, 5)
यहाँ सरणी प्रसारण पर आधिकारिक प्रलेखन है।
एक CSV फ़ाइल की सामग्री के साथ एक सरणी पॉप्युलेट करें
filePath = "file.csv"
data = np.genfromtxt(filePath)
कई विकल्प समर्थित हैं, पूरी सूची के लिए आधिकारिक दस्तावेज देखें:
data = np.genfromtxt(filePath, dtype='float', delimiter=';', skip_header=1, usecols=(0,1,3) )
नम्पी n- आयामी सरणी: ndarray
Numpy में कोर डेटा संरचना है ndarray (एन आयामी सरणी का संक्षिप्त रूप)। ndarray s हैं
- सजातीय (अर्थात वे एक ही डेटा-प्रकार के आइटम होते हैं)
- (कि प्रत्येक आयाम के आकारों का उल्लेख एक आकार, के एक टपल n धनात्मक पूर्णांक द्वारा दिए गए) तय आकार की मदों को शामिल करना
एक आयामी सरणी:
x = np.arange(15)
# array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
x.shape
# (15,)
दो आयामी सरणी:
x = np.asarray([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
x
# array([[ 0, 1, 2, 3, 4],
# [ 5, 6, 7, 8, 9],
# [10, 11, 12, 13, 14]])
x.shape
# (3, 5)
तीन आयामी:
np.arange(12).reshape([2,3,2])
अपनी सामग्री के उपयोग को निर्दिष्ट किए बिना किसी सरणी को आरंभ करने के लिए:
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
डेटाटाइप अनुमान लगाने और स्वचालित कास्टिंग
डेटा-प्रकार डिफ़ॉल्ट रूप से फ्लोट करने के लिए सेट किया गया है
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
x.dtype
# dtype('float64')
यदि कुछ डेटा प्रदान किया जाता है, तो डेटा का अनुमान लगाने के लिए numpy होगा:
x = np.asarray([[1, 2], [3, 4]])
x.dtype
# dtype('int32')
ध्यान दें कि जब कार्य कर रही है स्वचालित रूप से डाली मूल्यों करने का प्रयास करेंगे Numpy सूट करने के लिए ndarray के डेटाप्रकार
x[1, 1] = 1.5 # assign a float value
x[1, 1]
# 1
# value has been casted to int
x[1, 1] = 'z' # value cannot be casted, resulting in a ValueError
प्रसारण प्रसारित करना
प्रसारण सरणी ऑपरेशन भी देखें।
x = np.asarray([[1, 2], [3, 4]])
# array([[1, 2],
[3, 4]])
y = np.asarray([[5, 6]])
# array([[5, 6]])
मैट्रिक्स शब्दावली में, हमारे पास 2x2 मैट्रिक्स और 1x2 पंक्ति वेक्टर होगा। फिर भी हम योग करने में सक्षम हैं
# x + y
array([[ 6, 8],
[ 8, 10]])
इसका कारण यह है कि सरणी y को " बढ़ाया गया ":
array([[5, 6],
[5, 6]])
x के आकार के अनुरूप होना।
संसाधन:
- आधिकारिक दस्तावेज से ndarray का परिचय: N- आयामी सरणी (ndarray)
- वर्ग संदर्भ: ndarray ।