NumPy पायथन भाषा का एक विस्तार है जो इन सरणियों के साथ संचालन के लिए उच्च-स्तरीय गणितीय कार्यों के एक बड़े पुस्तकालय के साथ-साथ बड़े बहुआयामी सरणियों और मैट्रिसेस के लिए समर्थन जोड़ता है।

ट्यूटोरियल का पहला भाग NumPy के साथ काम करने की मूल बातें के बारे में बात करता है: सरणियों, उनकी विशेषताओं, बुनियादी संचालन, कार्यों के तत्व-वार अनुप्रयोग, अनुक्रमित, स्लाइस, पुनरावृत्ति का निर्माण करना। एक सरणी के आकार को बदलने के लिए कई जोड़तोड़, कई के सरणियों के संयोजन और इसके विपरीत - एक को कई छोटे लोगों में विभाजित करना माना जाता है। अंत में, हम सतह और गहरी नकल पर चर्चा करेंगे।

मूल बातें

यदि आपने अभी तक NumPy स्थापित नहीं किया है, तो आप इसे यहां प्राप्त कर सकते हैं । इस्तेमाल किया गया पायथन का संस्करण 2.6 है।

NumPy का मुख्य उद्देश्य एक सजातीय बहुआयामी सरणी है। यह तत्वों की एक तालिका है (आमतौर पर संख्या), एक ही प्रकार के सभी, प्राकृतिक संख्याओं के अनुक्रमों द्वारा अनुक्रमित।

एक सरणी के "बहुआयामी" से हमारा मतलब है कि इसमें कई आयाम या कुल्हाड़ी हो सकती हैं । चूंकि "माप" शब्द अस्पष्ट है, इसके बजाय हम "अक्ष" और "अक्ष" शब्दों का अधिक बार उपयोग करेंगे। कुल्हाड़ियों की संख्या को रैंक कहा जाता है।

उदाहरण के लिए, त्रि-आयामी अंतरिक्ष में एक बिंदु के निर्देशांक [1, 2, 1] रैंक 1 की एक सरणी है, इसमें केवल एक अक्ष है। इस अक्ष की लंबाई है 3. एक और उदाहरण, एक सरणी

[[ 1., 0., 0.],
[ 0., 1., 2.]]

एक रैंक 2 सरणी का प्रतिनिधित्व करता है (यानी, यह एक दो आयामी सरणी है)। पहले आयाम की लंबाई (अक्ष) 2 है, दूसरी धुरी की लंबाई है 3. अधिक जानकारी के लिए Numpy Glossary देखें।

बहुआयामी सरणी वर्ग को ndarray कहा जाता है। ध्यान दें कि यह पायथन मानक पुस्तकालय के array वर्ग के समान नहीं है, जिसका उपयोग केवल एक-आयामी सरणियों के लिए किया जाता है। ndarray वस्तुओं की सबसे महत्वपूर्ण विशेषताएं ndarray :

ndarray.ndim - सरणी के अक्षों (आयामों) की संख्या। जैसा कि पहले ही उल्लेख किया गया है, पायथन दुनिया में, आयामों की संख्या को अक्सर एक रैंक कहा जाता है।

ndarray.shape - सरणी आयाम, इसका आकार। यह प्राकृतिक संख्याओं का एक समूह है, जो प्रत्येक अक्ष के साथ सरणी की लंबाई दिखाती है। N पंक्तियों और m स्तंभों के एक मैट्रिक्स के लिए, shape होगा (n,m) । shape टपल में तत्वों की संख्या सरणी के रैंक के बराबर है, अर्थात ndim ।

ndarray.size सरणी में सभी तत्वों की संख्या है। shape विशेषता के सभी तत्वों के उत्पाद के बराबर होती है।

ndarray.dtype - एक ऑब्जेक्ट जो सरणी तत्वों के प्रकार का वर्णन करता है। आप मानक पायथन डेटा प्रकारों का उपयोग करके dtype को परिभाषित कर सकते हैं। NumPy यहां सुविधाओं का एक पूरा गुच्छा प्रदान करता है, उदाहरण के लिए:

bool_, character, int_, int8, int16, int32, int64, float_, float8, float16, float32, float64, complex_, complex64, object_

।

ndarray.itemsize - बाइट्स में प्रत्येक एरे तत्व का आकार। उदाहरण के लिए, प्रकार float64 के तत्वों की एक सरणी के लिए, float64 मान 8 (= itemsize ) है, और complex32 यह विशेषता 4 (= complex32 ) है।

ndarray.data - सरणी के वास्तविक तत्वों से युक्त एक बफर। आमतौर पर हमें इस विशेषता का उपयोग करने की आवश्यकता नहीं होगी, क्योंकि हम अनुक्रमित का उपयोग करके सरणी के तत्वों तक पहुंचेंगे।

उदाहरण

निम्नलिखित सरणी को परिभाषित करें:

Copy Source | Copy HTML >>> from numpy import * >>> a = arange( 10 ).reshape( 2 , 5 ) >>> a array ([[ 0 , 1 , 2 , 3 , 4 ], [ 5 , 6 , 7 , 8 , 9 ]]) 

हमने अभी एक सरणी ऑब्जेक्ट बनाया है जिसका नाम a है । Array में कई विशेषताएँ या गुण हैं। पायथन में, एक व्यक्तिगत ऑब्जेक्ट की विशेषताओं को name_of_object.attribute रूप में संदर्भित किया जाता है। हमारे मामले में:

a.shape है (2,5)
a.ndim 2 है (जो a.shape की लंबाई के a.shape )
a.size 10 है
a.dtype.name int32 है
a.itemsize 4 है, जिसका अर्थ है कि int32 मेमोरी के 4 बाइट्स लेता है।

आप इन सभी विशेषताओं को केवल अंतःक्रियात्मक रूप से टाइप करके देख सकते हैं:

Copy Source | Copy HTML >>> a.shape ( 2 , 5 ) >>> a.dtype.name 'int32' 

और इसी तरह।

ऐरे बनाना

एक सरणी बनाने के कई तरीके हैं। उदाहरण के लिए, आप array() फ़ंक्शन का उपयोग करके नियमित पायथन सूचियों या ट्यूपल्स से एक सरणी बना सकते हैं:

Copy Source | Copy HTML >>> from numpy import * >>> a = array ( [ 2 , 3 , 4 ] ) >>> a array ([ 2 , 3 , 4 ]) >>> type (a) <type 'numpy.ndarray' > 

array() फ़ंक्शन नेस्टेड दृश्यों को बहुआयामी सरणियों में बदल देता है। सरणी का प्रकार मूल अनुक्रम में तत्वों के प्रकार पर निर्भर करता है।

Copy Source | Copy HTML >>> b = array ( [ ( 1 . 5 , 2 , 3 ), ( 4 , 5 , 6 ) ] ) # float >>> b array ([[ 1 . 5 , 2 . , 3 . ], [ 4 . , 5 . , 6 . ]]) 

एक बार हमारे पास एक सरणी होने पर, हम उसकी विशेषताओं पर एक नज़र डाल सकते हैं:

Copy Source | Copy HTML >>> b.ndim # 2 >>> b.shape # ( 2 , 3 ) >>> b.dtype # (8- float) dtype( 'float64' ) >>> b.itemsize # 8 

सृजन के समय सरणी के प्रकार को स्पष्ट रूप से निर्दिष्ट किया जा सकता है:

Copy Source | Copy HTML >>> c = array ( [ [ 1 , 2 ], [ 3 , 4 ] ], dtype=complex ) >>> c array ([[ 1 .+ 0 .j, 2 .+ 0 .j], [ 3 .+ 0 .j, 4 .+ 0 .j]]) 

संख्याओं की सूची के रूप में कथित एकल तर्क के बजाय बहुत से संख्यात्मक तर्कों के साथ array() फ़ंक्शन को कॉल करना एक सामान्य गलती है:

Copy Source | Copy HTML >>> a = array ( 1 , 2 , 3 , 4 ) # WRONG >>> a = array ([ 1 , 2 , 3 , 4 ]) # RIGHT 

array() फ़ंक्शन सरणियाँ बनाने के लिए केवल फ़ंक्शन नहीं है। आमतौर पर सरणी के तत्व शुरू में अज्ञात होते हैं, और जिस सरणी में उन्हें संग्रहीत किया जाएगा वह पहले से ही आवश्यक है। इसलिए, कुछ प्रकार के स्रोत सामग्री के साथ सरणियों को बनाने के लिए कई कार्य हैं। डिफ़ॉल्ट रूप से, निर्मित सरणी का प्रकार float64 ।

zeros() फ़ंक्शन शून्य का एक सरणी बनाता है, और ones() फ़ंक्शन का एक सरणी बनाता है:

Copy Source | Copy HTML >>> zeros( ( 3 , 4 ) ) # array ([[ 0 ., 0 ., 0 ., 0 .], [ 0 ., 0 ., 0 ., 0 .], [ 0 ., 0 ., 0 ., 0 .]]) >>> ones( ( 2 , 3 , 4 ), dtype=int16 ) # dtype array ([[[ 1 , 1 , 1 , 1 ], [ 1 , 1 , 1 , 1 ], [ 1 , 1 , 1 , 1 ]], [[ 1 , 1 , 1 , 1 ], [ 1 , 1 , 1 , 1 ], [ 1 , 1 , 1 , 1 ]]], dtype=int16) 

empty() फ़ंक्शन पॉप्युलेट किए बिना एक सरणी बनाता है। मूल सामग्री यादृच्छिक है और उस समय मेमोरी की स्थिति पर निर्भर करती है जब सरणी बनाई गई थी (जो उस कचरे पर है जो उसमें संग्रहीत है):

Copy Source | Copy HTML >>> empty( ( 2 , 3 ) ) array ([[ 3 .73603959e- 262 , 6 .02658058e- 154 , 6 .55490914e- 260 ], [ 5 .30498948e- 313 , 3 .14673309e- 307 , 1 .00000000e+ 000 ]]) >>> empty( ( 2 , 3 ) ) # array ([[ 3 .14678735e- 307 , 6 .02658058e- 154 , 6 .55490914e- 260 ], [ 5 .30498948e- 313 , 3 .73603967e- 262 , 8 .70018275e- 313 ]]) 

संख्याओं के अनुक्रम बनाने के लिए, NumPy में range() समान फ़ंक्शन होता है, लेकिन सूचियों के बजाय, यह सरणियाँ देता है:

Copy Source | Copy HTML >> arange( 10 , 30 , 5 ) array ([ 10 , 15 , 20 , 25 ]) >>> arange( 0 , 2 , 0 . 3 ) array ([ 0 . , 0 . 3 , 0 . 6 , 0 . 9 , 1 . 2 , 1 . 5 , 1 . 8 ]) 

टाइप float तर्कों के साथ arange() का उपयोग करते समय, यह सुनिश्चित करना मुश्किल है कि कितने तत्व प्राप्त होंगे (फ्लोटिंग-पॉइंट नंबरों की सीमित शुद्धता के कारण)। इसलिए, ऐसे मामलों में आमतौर पर linspace() फ़ंक्शन का उपयोग करना बेहतर होता है, जो एक कदम के बजाय, उन तर्कों में से एक के रूप में लेता है जो आवश्यक तत्वों की संख्या के बराबर संख्या है:

Copy Source | Copy HTML >>> linspace( 0 , 2 , 9 ) # 9 0 2 array ([ 0 . , 0 . 25 , 0 . 5 , 0 . 75 , 1 . , 1 . 25 , 1 . 5 , 1 . 75 , 2 . ]) >>> x = linspace( 0 , 2 *pi, 100 ) # >>> f = sin(x) 

मुद्रण मुद्रण

जब आप एक सरणी प्रिंट करते हैं, तो NumPy उन्हें नेस्टेड सूचियों के समान तरीके से प्रदर्शित करता है, लेकिन यह उन्हें थोड़ा अलग तरीके से रखता है:

अंतिम अक्ष बाईं ओर से दाईं ओर मुद्रित होता है,
प्रायद्वीप - ऊपर से नीचे तक,
और बाकी - ऊपर से नीचे तक, खाली स्ट्रिंग को विभाजित करना।

एक आयामी सरणियों को स्ट्रिंग के रूप में प्रदर्शित किया जाता है, दो आयामी सरणियों को मैट्रिस के रूप में और तीन आयामी सरणियों को मैट्रिसेस की सूची के रूप में प्रदर्शित किया जाता है।

Copy Source | Copy HTML >>> a = arange( 6 ) # 1d array >>> print a [ 0 1 2 3 4 5 ] >>> >>> b = arange( 12 ).reshape( 4 , 3 ) # 2d array >>> print b [[ 0 1 2 ] [ 3 4 5 ] [ 6 7 8 ] [ 9 10 11 ]] >>> >>> c = arange( 24 ).reshape( 2 , 3 , 4 ) # 3d array >>> print c [[[ 0 1 2 3 ] [ 4 5 6 7 ] [ 8 9 10 11 ]] [[ 12 13 14 15 ] [ 16 17 18 19 ] [ 20 21 22 23 ]]] 

यदि सरणी प्रिंट करने के लिए बहुत बड़ी है, तो NumPy स्वचालित रूप से सरणी के केंद्र को छुपाता है और केवल इसके कोनों को प्रदर्शित करता है:

Copy Source | Copy HTML >>> print arange( 10000 ) [ 0 1 2 ..., 9997 9998 9999 ] >>> >>> print arange( 10000 ).reshape( 100 , 100 ) [[ 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 ]] 

यदि आपको वास्तव में एक बड़े सरणी में होने वाली सभी चीज़ों को देखना है, तो इसे पूरी तरह से set_printoptions() करते हुए, set_printoptions() प्रिंट सेटअप फ़ंक्शन का उपयोग करें:

Copy Source | Copy HTML >>> set_printoptions(threshold=nan) 

मूल संचालन

ऐरे पर अंकगणित संचालन तत्व द्वारा तत्व का प्रदर्शन किया जाता है । एक नया सरणी बनाया जाता है, जो ऑपरेटर कार्रवाई के परिणामों के साथ आबादी है।

Copy Source | Copy HTML >>> a = array ( [ 20 , 30 , 40 , 50 ] ) >>> b = arange( 4 ) >>> c = ab >>> c array ([ 20 , 29 , 38 , 47 ]) >>> b** 2 array ([ 0 , 1 , 4 , 9 ]) >>> 10 *sin(a) array ([ 9 . 12945251 , - 9 . 88031624 , 7 . 4511316 , - 2 . 62374854 ]) >>> a< 35 array ([True, True, False, False], dtype=bool) 

मैट्रिक्स दृष्टिकोण के विपरीत, NumPy सरणियों में उत्पाद * ऑपरेटर भी मूल रूप से काम करता है। मैट्रिक्स उत्पाद को dot() फ़ंक्शन द्वारा या मैट्रिक्स ऑब्जेक्ट बनाने के द्वारा लागू किया जा सकता है, जिसे बाद में (मैनुअल के दूसरे भाग में) माना जाएगा।

Copy Source | Copy HTML >>> A = array ( [[ 1 , 1 ], ... [ 0 , 1 ]] ) >>> B = array ( [[ 2 , 0 ], ... [ 3 , 4 ]] ) >>> A*B # array ([[ 2 , 0 ], [ 0 , 4 ]]) >>> dot(A,B) # array ([[ 5 , 4 ], [ 3 , 4 ]]) 

कुछ ऑपरेशन "जगह में" किए जाते हैं, एक नया सरणी बनाए बिना।

Copy Source | Copy HTML >>> a = ones(( 2 , 3 ), dtype=int) >>> b = random . random (( 2 , 3 )) >>> a *= 3 >>> a array ([[ 3 , 3 , 3 ], [ 3 , 3 , 3 ]]) >>> b += a >>> b array ([[ 3 . 69092703 , 3 . 8324276 , 3 . 0114541 ], [ 3 . 18679111 , 3 . 3039349 , 3 . 37600289 ]]) >>> a += b # b int >>> a array ([[ 6 , 6 , 6 ], [ 6 , 6 , 6 ]]) 

विभिन्न प्रकार के सरणियों के साथ काम करते समय, परिणामी सरणी का प्रकार अधिक सामान्य या अधिक सटीक प्रकार से मेल खाता है।

Copy Source | Copy HTML >>> a = ones( 3 , dtype=int32) >>> b = linspace( 0 ,pi, 3 ) >>> b.dtype.name 'float64' >>> c = a+b >>> c array ([ 1 . , 2 . 57079633 , 4 . 14159265 ]) >>> c.dtype.name 'float64' >>> d = exp(c*1j) >>> d array ([ 0 . 54030231 + 0 .84147098j, - 0 . 84147098 + 0 .54030231j, - 0 . 54030231 - 0 .84147098j]) >>> d.dtype.name 'complex128' 

कई यूनिरी ऑपरेशंस, जैसे किसी एरे के सभी तत्वों के योग की गणना करना, ndarray क्लास के तरीकों के रूप में दर्शाए जाते हैं।

Copy Source | Copy HTML >>> a = random . random (( 2 , 3 )) >>> a array ([[ 0 . 6903007 , 0 . 39168346 , 0 . 16524769 ], [ 0 . 48819875 , 0 . 77188505 , 0 . 94792155 ]]) >>> a. sum () 3 . 4552372100521485 >>> a. min () 0 . 16524768654743593 >>> a. max () 0 . 9479215542670073 

डिफ़ॉल्ट रूप से, ये ऑपरेशन सरणी पर लागू होते हैं जैसे कि यह संख्या की एक सूची थी, इसके आकार की परवाह किए बिना। हालांकि, axis पैरामीटर निर्दिष्ट करके, आप सरणी के निर्दिष्ट अक्ष पर ऑपरेशन को लागू कर सकते हैं:

Copy Source | Copy HTML >>> b = arange( 12 ).reshape( 3 , 4 ) >>> b array ([[ 0 , 1 , 2 , 3 ], [ 4 , 5 , 6 , 7 ], [ 8 , 9 , 10 , 11 ]]) >>> >>> b. sum (axis= 0 ) # array ([ 12 , 15 , 18 , 21 ]) >>> >>> b. min (axis= 1 ) # array ([ 0 , 4 , 8 ]) >>> >>> b.cumsum(axis= 1 ) # array ([[ 0 , 1 , 3 , 6 ], [ 4 , 9 , 15 , 22 ], [ 8 , 17 , 27 , 38 ]]) 

सार्वभौमिक कार्य

NumPy जाने-माने गणितीय कार्यों पाप, कॉस, ऍक्स्प और इतने पर काम प्रदान करता है। लेकिन NumPy में, इन कार्यों को सार्वभौमिक ( ufunc ) कहा जाता है। इस तरह के नाम को असाइन करने का कारण इस तथ्य में निहित है कि NumPy में ये फ़ंक्शन एरे के साथ भी तत्व-वार काम करते हैं, और आउटपुट मूल्यों की एक सरणी है।

Copy Source | Copy HTML >>> B = arange( 3 ) >>> B array ([ 0 , 1 , 2 ]) >>> exp(B) array ([ 1 . , 2 . 71828183 , 7 . 3890561 ]) >>> sqrt(B) array ([ 0 . , 1 . , 1 . 41421356 ]) >>> C = array ([ 2 ., - 1 ., 4 .]) >>> add(B, C) array ([ 2 ., 0 ., 6 .]) 

सूचकांक, स्लाइस, Iterations

एक आयामी सरणियों नियमित सूचियों और अन्य पायथन दृश्यों के लिए बहुत समान फैशन में अनुक्रमण, स्लाइसिंग और पुनरावृति संचालन करते हैं।

Copy Source | Copy HTML >>> a = arange( 10 )** 3 >>> a array ([ 0 , 1 , 8 , 27 , 64 , 125 , 216 , 343 , 512 , 729 ]) >>> a[ 2 ] 8 >>> a[ 2 : 5 ] array ([ 8 , 27 , 64 ]) >>> a[: 6 : 2 ] = - 1000 # a >>> a array ([- 1000 , 1 , - 1000 , 27 . - 1000 , 125 , 216 , 343 , 512 , 729 ]) >>> a[::- 1 ] # a array ([ 729 , 512 , 343 , 216 , 125 , - 1000 , 27 , - 1000 , 1 , - 1000 ]) >>> for i in a: ... print i**( 1 / 3 .), ... nan 1 . 0 nan 3 . 0 nan 5 . 0 6 . 0 7 . 0 8 . 0 9 . 0

बहुआयामी सरणियों की धुरी प्रति एक सूचकांक है। अनुक्रमित संख्याओं के अनुक्रम के रूप में प्रेषित होते हैं, जिन्हें अल्पविराम द्वारा अलग किया जाता है:

Copy Source | Copy HTML >>> def f (x,y): ... return 10 *x+y ... >>> b = fromfunction( f ,( 5 , 4 ),dtype=int) >>> b array ([[ 0 , 1 , 2 , 3 ], [ 10 , 11 , 12 , 13 ], [ 20 , 21 , 22 , 23 ], [ 30 , 31 , 32 , 33 ], [ 40 , 41 , 42 , 43 ]]) >>> b[ 2 , 3 ] 23 >>> b[:, 1 ] # b array ([ 1 , 11 , 21 , 31 , 41 ]) >>> b[ 1 : 3 ,:] # b array ([[ 10 , 11 , 12 , 13 ], [ 20 , 21 , 22 , 23 ]]) 

जब कुल्हाड़ियों की तुलना में कम सूचकांक होते हैं, तो लापता सूचकांक को टुकड़ा करके पूरक माना जाता है:

Copy Source | Copy HTML >>> b[- 1 ] # . b[-1,:] array ([ 40 , 41 , 42 , 43 ]) 

b[i] को b[i, < ':', >] पढ़ा जा सकता है b[i, < ':', >] । NumPy में, यह डॉट्स, जैसे b[i, ...] का उपयोग करके भी लिखा जा सकता है।

उदाहरण के लिए, यदि x की रैंक 5 है (यानी, इसमें 5 अक्ष हैं), तब

x[1, 2, ...] x[1, 2, :, :, :] समतुल्य है
x[... , 3] x[:, :, :, :, 3] और के समान है
x[4, ... , 5, :] x[4, :, :, 5, :] ।

Copy Source | Copy HTML >>> c = array ( [ [[ 0 , 1 , 2 ], # 3d array ... [ 10 , 12 , 13 ]], ... ... [[ 100 , 101 , 102 ], ... [ 110 , 112 , 113 ]] ] ) >>> c.shape ( 2 , 2 , 3 ) >>> c[ 1 ,...] # , c[1,:,:] c[1] array ([[ 100 , 101 , 102 ], [ 110 , 112 , 113 ]]) >>> c[..., 2 ] # , c[:,:,2] array ([[ 2 , 13 ], [ 102 , 113 ]]) 

बहुआयामी सरणियों का परिवर्तन पहले अक्ष से शुरू होता है:

Copy Source | Copy HTML >>> for row in b: ... print row ... [ 0 1 2 3 ] [ 10 11 12 13 ] [ 20 21 22 23 ] [ 30 31 32 33 ] [ 40 41 42 43 ] 

हालांकि, यदि आपको तत्व द्वारा संपूर्ण सरणी तत्व के माध्यम से सॉर्ट करने की आवश्यकता है, जैसे कि यह एक-आयामी था, तो आप इसके लिए flat विशेषता का उपयोग कर सकते हैं:

Copy Source | Copy HTML >>> for element in b.flat: ... print element, ... 0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43 

रूप के साथ हेरफेर

जैसा कि पहले ही उल्लेख किया गया है, एक सरणी में प्रत्येक अक्ष के साथ तत्वों की संख्या द्वारा निर्धारित आकृति होती है:

Copy Source | Copy HTML >>> a = floor( 10 * random . random (( 3 , 4 ))) >>> a array ([[ 7 ., 5 ., 9 ., 3 .], [ 7 ., 2 ., 7 ., 8 .], [ 6 ., 8 ., 3 ., 2 .]]) >>> a.shape ( 3 , 4 ) 

विभिन्न कमांड का उपयोग करके सरणी का आकार बदला जा सकता है:

Copy Source | Copy HTML >>> a.ravel() # array ([ 7 ., 5 ., 9 ., 3 ., 7 ., 2 ., 7 ., 8 ., 6 ., 8 ., 3 ., 2 .]) >>> a.shape = ( 6 , 2 ) >>> a.transpose() array ([[ 7 ., 9 ., 7 ., 7 ., 6 ., 3 .], [ 5 ., 3 ., 2 ., 8 ., 8 ., 2 .]]) 

ravel() फ़ंक्शन के परिणामस्वरूप एरे में तत्वों का क्रम सामान्य "सी-स्टाइल" से मेल खाता है, ravel() , सही सूचकांक के लिए जितना अधिक है, "तेजी से यह बदलता है": तत्व a[0,0] a[0,1] अनुसरण करता a[0,1] । यदि सरणी का एक आकार दूसरे में बदल दिया गया है, तो सरणी फिर से "सी-स्टाइल" में भी बनाई जाती है। इस क्रम में, NumPy आमतौर पर सरणियाँ बनाता है, इसलिए ravel() फ़ंक्शन को आमतौर पर तर्क की प्रतिलिपि बनाने की आवश्यकता नहीं होती है, लेकिन यदि सरणी दूसरे सरणी के स्लाइस से बनाई गई थी, तो प्रतिलिपि की आवश्यकता हो सकती है। फ़ोरट्रान शैली में ravel() और reshape() फ़ंक्शन भी (अतिरिक्त तर्क का उपयोग करते समय reshape() काम कर सकते हैं, जिसमें अधिक बायीं अनुक्रमणिका तेजी से बदलती है।

reshape() फ़ंक्शन अपने तर्क को एक संशोधित रूप के साथ लौटाता है, जबकि resize() विधि सरणी को ही संशोधित करता है:

Copy Source | Copy HTML >>> a array ([[ 7 ., 5 .], [ 9 ., 3 .], [ 7 ., 2 .], [ 7 ., 8 .], [ 6 ., 8 .], [ 3 ., 2 .]]) >>> a.resize(( 2 , 6 )) >>> a array ([[ 7 ., 5 ., 9 ., 3 ., 7 ., 2 .], [ 7 ., 8 ., 6 ., 8 ., 3 ., 2 .]]) 

यदि इस तरह के पुनर्गठन के संचालन के दौरान किसी एक तर्क को -1 के रूप में निर्दिष्ट किया जाता है, तो यह स्वचालित रूप से दिए गए शेष के अनुसार गणना की जाती है:

Copy Source | Copy HTML >>> a.reshape( 3 ,- 1 ) array ([[ 7 ., 5 ., 9 ., 3 .], [ 7 ., 2 ., 7 ., 8 .], [ 6 ., 8 ., 3 ., 2 .]]) 

ज्वाइनिंग ऐरे

कई अक्षों को अलग-अलग अक्षों के साथ जोड़ा जा सकता है:

Copy Source | Copy HTML >>> a = floor( 10 * random . random (( 2 , 2 ))) >>> a array ([[ 1 ., 1 .], [ 5 ., 8 .]]) >>> b = floor( 10 * random . random (( 2 , 2 ))) >>> b array ([[ 3 ., 3 .], [ 6 ., 0 .]]) >>> vstack((a,b)) array ([[ 1 ., 1 .], [ 5 ., 8 .], [ 3 ., 3 .], [ 6 ., 0 .]]) >>> hstack((a,b)) array ([[ 1 ., 1 ., 3 ., 3 .], [ 5 ., 8 ., 6 ., 0 .]]) 

column_stack() फ़ंक्शन column_stack() -आयामी सरणी के कॉलम के रूप में एक आयामी सरणियों को जोड़ता है:

Copy Source | Copy HTML >>> column_stack((a,b)) array ([[ 1 ., 1 ., 3 ., 3 .], [ 5 ., 8 ., 6 ., 0 .]]) >>> a= array ([ 4 ., 2 .]) >>> b= array ([ 2 ., 8 .]) >>> a[:,newaxis] # 2D- array ([[ 4 .], [ 2 .]]) >>> column_stack((a[:,newaxis],b[:,newaxis])) array ([[ 4 ., 2 .], [ 2 ., 8 .]]) >>> vstack((a[:,newaxis],b[:,newaxis])) # vstack array ([[ 4 .], [ 2 .], [ 2 .], [ 8 .]]) 

इसी तरह, पंक्तियों के लिए एक row_stack() फ़ंक्शन है। दो से अधिक कुल्हाड़ियों के साथ सरणियों के लिए, vstack() पहले अक्षों के साथ सरणियों को जोड़ती है, vstack() - अंतिम कुल्हाड़ियों के साथ, अतिरिक्त तर्क आपको उन कुल्हाड़ियों की संख्या निर्दिष्ट करने की अनुमति देते हैं जिनके साथ संघ होना चाहिए।

मुश्किल मामलों में, _[] r_[] और _[] उपयोगी हो सकते हैं, जिससे आप एक अक्ष के साथ संख्याओं के अनुक्रमों का उपयोग करके एक आयामी सरणियों का निर्माण कर सकते हैं। उनके पास "श्रेणी:" का उपयोग करने की क्षमता भी है:

Copy Source | Copy HTML >>> r_[ 1 : 4 , 0 , 4 ] array ([ 1 , 2 , 3 , 0 , 4 ]) 

कई छोटे में एक सरणी का विभाजन

hsplit() का उपयोग करके आप क्षैतिज अक्ष के साथ सरणी को विभाजित कर सकते हैं, या तो उसी आकार के लौटे हुए सरणियों की संख्या निर्दिष्ट कर सकते हैं, या स्तंभ संख्या, जिसके बाद सरणी कैंची से कट जाती है:

Copy Source | Copy HTML >>> a = floor( 10 * random . random (( 2 , 12 ))) >>> a array ([[ 8 ., 8 ., 3 ., 9 ., 0 ., 4 ., 3 ., 0 ., 0 ., 6 ., 4 ., 4 .], [ 0 ., 3 ., 2 ., 9 ., 6 ., 0 ., 4 ., 5 ., 7 ., 5 ., 1 ., 4 .]]) >>> hsplit(a, 3 ) # 3 [ array ([[ 8 ., 8 ., 3 ., 9 .], [ 0 ., 3 ., 2 ., 9 .]]), array ([[ 0 ., 4 ., 3 ., 0 .], [ 6 ., 0 ., 4 ., 5 .]]), array ([[ 0 ., 6 ., 4 ., 4 .], [ 7 ., 5 ., 1 ., 4 .]])] >>> hsplit(a,( 3 , 4 )) # a [ array ([[ 8 ., 8 ., 3 .], [ 0 ., 3 ., 2 .]]), array ([[ 9 .], [ 9 .]]), array ([[ 0 ., 4 ., 3 ., 0 ., 0 ., 6 ., 4 ., 4 .], [ 6 ., 0 ., 4 ., 5 ., 7 ., 5 ., 1 ., 4 .]])]

vsplit() फ़ंक्शन ऊर्ध्वाधर अक्ष के साथ सरणी को विभाजित करता है, और array_split() आपको उन अक्षों को निर्दिष्ट करने की अनुमति देता है जिनके साथ विभाजन होगा।

प्रतियां और प्रस्तुतियाँ

सरणियों के साथ काम करते समय, उनके डेटा को कभी-कभी दूसरे सरणी में कॉपी करने की आवश्यकता होती है, और कभी-कभी नहीं। यह अक्सर शुरुआती लोगों के बीच भ्रम का स्रोत होता है। शायद केवल तीन मामले:

कोई कॉपी नहीं

साधारण असाइनमेंट या तो एरे की कॉपी या उसके डेटा की कॉपी नहीं बनाता है:

Copy Source | Copy HTML >>> a = arange( 12 ) >>> b = a # >>> b is a # a b ndarray True >>> b.shape = 3 , 4 # a >>> a.shape ( 3 , 4 ) 

पाइथन लिंक के रूप में उत्परिवर्तित वस्तुओं को पास करता है, इसलिए फ़ंक्शन कॉल भी प्रतियां नहीं बनाते हैं:

Copy Source | Copy HTML >>> def f (x): ... print id (x) ... >>> id (a) 148293216 >>> f (a) 148293216 

देखें या सतह की नकल

विभिन्न सरणी ऑब्जेक्ट एक ही डेटा का उपयोग कर सकते हैं। view() विधि एक नई सरणी ऑब्जेक्ट बनाता है, जो उसी डेटा का प्रतिनिधित्व है।

Copy Source | Copy HTML >>> c = a.view() >>> c is a False >>> c.base is a # c , a True >>> c.flags.owndata False >>> >>> c.shape = 2 , 6 # >>> a.shape ( 3 , 4 ) >>> c[ 0 , 4 ] = 1234 # >>> a array ([[ 0 , 1 , 2 , 3 ], [ 1234 , 5 , 6 , 7 ], [ 8 , 9 , 10 , 11 ]]) 

एक सरणी टुकड़ा एक प्रतिनिधित्व है:

Copy Source | Copy HTML >>> s = a[:, 1 : 3 ] >>> s[:] = 10 # s[:] s. s=10 s[:]=10 >>> a array ([[ 0 , 10 , 10 , 3 ], [ 1234 , 10 , 10 , 7 ], [ 8 , 10 , 10 , 11 ]]) 

गहरी नकल

copy() विधि सरणी और उसके डेटा की एक वास्तविक प्रतिलिपि बनाती है:

Copy Source | Copy HTML >>> d = a. copy () # >>> d is a False >>> d.base is a # d False >>> d[ 0 , 0 ] = 9999 >>> a array ([[ 0 , 10 , 10 , 3 ], [ 1234 , 10 , 10 , 7 ], [ 8 , 10 , 10 , 11 ]]) 

निष्कर्ष में

इसलिए, पहले भाग में हमने सरणियों के साथ काम करने के सबसे महत्वपूर्ण बुनियादी कार्यों की जांच की। इस भाग के अलावा, मैं एक अच्छा धोखा पत्र की सिफारिश करता हूं। दूसरे भाग में, हम अधिक विशिष्ट चीजों के बारे में बात करेंगे: सूचकांकों या बूलियन चर के सरणियों का उपयोग करके अनुक्रमण करना, रैखिक बीजगणित संचालन और matrix वर्ग को लागू करना, और विभिन्न उपयोगी चालें।

न्यूपी, शुरुआती के लिए एक गाइड। भाग 1