NumPy 1.14 - numpy.block()

numpy.block




numpy

numpy.block

numpy.block(arrays) [source]

ब्लॉक की नेस्टेड सूचियों से एक nd-array इकट्ठा करें।

अंतरतम सूचियों के ब्लॉक अंतिम आयाम (-1) के साथ समवर्ती (देखें concatenate ) हैं, फिर इन्हें दूसरे-अंतिम आयाम (-2) के साथ समेटा जाता है, और तब तक जब तक कि सबसे बाहरी सूची नहीं पहुंच जाती।

ब्लॉक किसी भी आयाम के हो सकते हैं, लेकिन सामान्य नियमों का उपयोग करके प्रसारित नहीं किया जाएगा। इसके बजाय, आकार 1 के प्रमुख कुल्हाड़ियों को ब्लॉक करने के लिए डाला जाता है। सभी ब्लॉकों के लिए समान। यह मुख्य रूप से स्केलर के साथ काम करने के लिए उपयोगी है, और इसका मतलब है कि np.block([v, 1]) जैसा कोड मान्य है, जहां v.ndim == 1

जब नेस्टेड सूची दो स्तर गहरी होती है, तो यह ब्लॉक मेट्रिक्स को उनके घटकों से निर्मित करने की अनुमति देता है।

संस्करण 1.13.0 में नया।

पैरामीटर:

सरणियाँ : नेस्टेड सूची की array_like या स्केलर (लेकिन tuples नहीं)

यदि एक एकल ndarray या स्केलर (गहराई की 0 की एक नेस्टेड सूची) पारित किया है, तो यह अनमॉडिफाइड (कॉपी नहीं किया गया) है।

तत्वों की आकृतियों को उपयुक्त अक्षों (प्रसारण के बिना) के साथ मेल खाना चाहिए, लेकिन अग्रणी 1s को आयाम से मेल खाने के लिए आवश्यक रूप से आकार में प्रस्तुत किया जाएगा।

यह दिखाता है:

block_array : ndarray

सरणी दिए गए ब्लॉकों से इकट्ठी हुई।

आउटपुट की आयामीता सबसे बड़ी के बराबर है: * सभी इनपुटों की आयामीता * इनपुट सूची को गहराई तक पहुंचाने के लिए निहित है

जन्म देती है:

ValueError

  • यदि सूची की गहराई को बेमेल कर दिया जाता है - उदाहरण के लिए, [[a, b], c] गैरकानूनी है, और [[a, b], [c]] वर्तनी होना चाहिए।
  • यदि सूचियां खाली हैं - उदाहरण के लिए, [[a, b], []]

यह भी देखें

concatenate
एक साथ सरणियों के अनुक्रम में शामिल हों।
stack
एक नए आयाम के साथ क्रम में ढेर सरणियाँ।
hstack
क्षैतिज रूप से (स्तंभ वार) अनुक्रम में ढेर सरणियाँ।
vstack
क्रम में खड़ी सरणियाँ (पंक्ति वार)।
dstack
स्टैक एरेज़ सीक्वेंस डेप्थ वाइज (तीसरे आयाम के साथ)।
vsplit
ऊर्ध्वाधर रूप से कई उप-सरणियों की सूची में सरणी विभाजित करें।

टिप्पणियाँ

जब केवल स्केलर के साथ कॉल किया जाता है, तो np.block कॉल के बराबर होता है। तो np.block([[1, 2], [3, 4]]) np.array([[1, 2], [3, 4]]) बराबर है।

यह फ़ंक्शन लागू नहीं करता है कि ब्लॉक एक निश्चित ग्रिड पर झूठ बोलते हैं। np.block([[a, b], [c, d]]) प्रपत्र के सरणियों तक सीमित नहीं है:

AAAbb
AAAbb
cccDD

लेकिन कुछ a, b, c, d लिए भी उत्पादन की अनुमति है:

AAAbb
AAAbb
cDDDD

चूँकि अंतिम धुरी के साथ अवक्षेपण पहले होता है, block _not_ निम्नलिखित को सीधे उत्पन्न करने में सक्षम होता है:

AAAbb
cccbb
cccDD

मैटलैब का "स्क्वायर ब्रैकेट स्टैकिंग", [A, B, ...; p, q, ...] [A, B, ...; p, q, ...] , np.block([[A, B, ...], [p, q, ...]]) बराबर है।

उदाहरण

इस फ़ंक्शन का सबसे आम उपयोग ब्लॉक मैट्रिक्स का निर्माण करना है

>>> A = np.eye(2) * 2
>>> B = np.eye(3) * 3
>>> np.block([
...     [A,               np.zeros((2, 3))],
...     [np.ones((3, 2)), B               ]
... ])
array([[ 2.,  0.,  0.,  0.,  0.],
       [ 0.,  2.,  0.,  0.,  0.],
       [ 1.,  1.,  3.,  0.,  0.],
       [ 1.,  1.,  0.,  3.,  0.],
       [ 1.,  1.,  0.,  0.,  3.]])

गहराई 1 की सूची के साथ, block को hstack रूप में इस्तेमाल किया जा सकता है

>>> np.block([1, 2, 3])              # hstack([1, 2, 3])
array([1, 2, 3])
>>> a = np.array([1, 2, 3])
>>> b = np.array([2, 3, 4])
>>> np.block([a, b, 10])             # hstack([a, b, 10])
array([1, 2, 3, 2, 3, 4, 10])
>>> A = np.ones((2, 2), int)
>>> B = 2 * A
>>> np.block([A, B])                 # hstack([A, B])
array([[1, 1, 2, 2],
       [1, 1, 2, 2]])

गहराई 2 की सूची के साथ, block को vstack स्थान पर उपयोग किया जा सकता है:

>>> a = np.array([1, 2, 3])
>>> b = np.array([2, 3, 4])
>>> np.block([[a], [b]])             # vstack([a, b])
array([[1, 2, 3],
       [2, 3, 4]])
>>> A = np.ones((2, 2), int)
>>> B = 2 * A
>>> np.block([[A], [B]])             # vstack([A, B])
array([[1, 1],
       [1, 1],
       [2, 2],
       [2, 2]])

इसका उपयोग atleast_1d और atleast_2d स्थानों में भी किया जा सकता है

>>> a = np.array(0)
>>> b = np.array([1])
>>> np.block([a])                    # atleast_1d(a)
array([0])
>>> np.block([b])                    # atleast_1d(b)
array([1])
>>> np.block([[a]])                  # atleast_2d(a)
array([[0]])
>>> np.block([[b]])                  # atleast_2d(b)
array([[1]])