एक NumPy सरणी ट्रांसपोज़ करना

Question

मैं पायथन और न्यूमपी का उपयोग करता हूं और "संक्रमण" के साथ कुछ समस्याएं हैं:

import numpy as np
a = np.array([5,4])
print(a)
print(a.T)

इनवॉइस a.Tसरणी स्थानांतरित नहीं कर रहा है। यदि aउदाहरण के लिए है [[],[]]तो यह सही ढंग से स्थानांतरित होता है, लेकिन मुझे इसके हस्तांतरण की आवश्यकता है [...,...,...]।

Comments

भी करने की कोशिश की "प्रिंट a.transpose" जो एक ही है, लेकिन सफलता के बिना, पक्षांतरित नहीं ... है

— thaking

Answer 1

यह ठीक वैसे ही काम कर रहा है जैसा कि यह माना जाता है। 1D सरणी का संक्रमण अभी भी 1D सरणी है! (यदि आप matlab के लिए उपयोग किए जाते हैं, तो यह मौलिक रूप से 1D सरणी की अवधारणा नहीं है। Matlab की "1D" सरणियाँ 2D हैं।)

यदि आप अपने 1 डी वेक्टर को 2 डी सरणी में बदलना चाहते हैं और फिर इसे स्थानांतरित करते हैं, तो बस इसे np.newaxis(या None, वे एक ही हैं, newaxisबस अधिक पठनीय है) के साथ स्लाइस करें ।

import numpy as np
a = np.array([5,4])[np.newaxis]
print(a)
print(a.T)

आम तौर पर बोल रहा हूँ, आप इस बारे में चिंता करने की जरूरत नहीं है। अतिरिक्त आयाम जोड़ना आमतौर पर वह नहीं है जो आप चाहते हैं, यदि आप इसे आदत से बाहर कर रहे हैं। विभिन्न गणनाएँ करते समय Numpy स्वचालित रूप से 1D सरणी प्रसारित करेगा। आमतौर पर पंक्ति वेक्टर और कॉलम वेक्टर के बीच अंतर करने की कोई आवश्यकता नहीं है (जिनमें से कोई भी वैक्टर नहीं हैं । वे दोनों 2D हैं!) जब आप बस एक वेक्टर चाहते हैं।

Comments

@ टॉकिंग - मैं बस np.arangeजल्दी से एक 1D सरणी बनाने के लिए इस्तेमाल किया । यह ठीक उसी के लिए काम करता है a = np.array([5,4])।

— जो किंगटन

@ थेकिंग यदि आप नए नए हैं - ध्यान रखें कि गोल कोष्ठक ()सुन्न में एक अतिरिक्त आयाम का संकेत नहीं देते हैं। यदि a = np.arange(10)तब aके array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])रूप में द्वारा उत्पादित है a.__repr__()। यह एक 1-आयामी (यानी a.ndim --> 1) वेक्टर है जैसा कि वर्ग कोष्ठक द्वारा इंगित किया गया है []। array( ... )नहीं देखा जाता है जब आप या तो करना print(a)या a.__str__()।

— dtlussier

@ जोकिंगटन एक ऐसी स्थिति है जो 1 डी सरणी का प्रसारण उपयोगी है। किसी सरणी में सभी 1D बिंदुओं के बीच की दूरी की गणना करना। आपके समाधान के लिए धन्यवाद x - x [np.newaxis] .T कर सकता है जो दूरी मैट्रिक्स देता है

— JuanPi

व्यक्तिगत रूप से, मुझे np.vstack()ऑपरेशन अधिक स्पष्ट होना चाहिए print np.vstack(a):।

— अलेक्जेंडर पॉज़्निवेव

यह सिर्फ मैटलैब नहीं है, बल्कि रैखिक बीजगणित में एक पंक्ति / स्तंभ वेक्टर की अवधारणा है। Numpy बहुत सारे स्थानों से आने वाले लोगों के लिए उदासीन है, न कि सिर्फ matlab।

— eric

Answer 2

एक के बजाय दो ब्रैकेट जोड़े का उपयोग करें। यह एक 2D सरणी बनाता है, जिसे ट्रांसपोज़ किया जा सकता है, यदि आप एक ब्रैकेट जोड़ी का उपयोग करते हैं तो 1D सरणी के विपरीत।

import numpy as np    
a = np.array([[5, 4]])
a.T

अधिक गहन उदाहरण:

>>> a = [3,6,9]
>>> b = np.array(a)
>>> b.T
array([3, 6, 9])         #Here it didn't transpose because 'a' is 1 dimensional
>>> b = np.array([a])
>>> b.T
array([[3],              #Here it did transpose because a is 2 dimensional
       [6],
       [9]])

shapeयहाँ क्या हो रहा है यह देखने के लिए numpy विधि का उपयोग करें:

>>> b = np.array([10,20,30])
>>> b.shape
(3,)
>>> b = np.array([[10,20,30]])
>>> b.shape
(1, 3)

Comments

मैं [np.newaxis] एक के लिए इस समाधान को पसंद करता हूं, यह अधिक सुरुचिपूर्ण इमो दिखता है।

— फिलमकेय

मशीनें उतनी बुद्धिमान नहीं हैं। यहां तक ​​कि अगर आपके पास केवल एक पत्नी है, तो इसे आपकी पहली पत्नी के रूप में घोषित किया जाना चाहिए।

— श्रीरंग एआर

यह चयनित उत्तर होना चाहिए

— ब्रुने

Answer 3

1D सरणियों के लिए :

a = np.array([1, 2, 3, 4])
a = a.reshape((-1, 1)) # <--- THIS IS IT

print a
array([[1],
       [2],
       [3],
       [4]])

एक बार जब आप समझते हैं कि -1 का अर्थ है "जितनी आवश्यक हो उतनी पंक्तियाँ", मुझे यह एक सरणी के "ट्रांसपोज़िंग" का सबसे पठनीय तरीका लगता है। यदि आपका सरणी उच्च आयामीता का है तो बस उपयोग करें a.T।

Comments

ध्यान दें कि यह केवल वैक्टर के साथ काम करता है। यदि आपके पास 2-आयामी सरणी है transposeऔर reshapeविभिन्न तरीकों से सरणी को संशोधित करें (परिणामस्वरूप छवि का आकार समान है, लेकिन तत्वों को अलग तरीके से रखा गया है)।

— जॉन्डोडो

आपकी टिप्पणी के लिए धन्यवाद। मैं आपकी बात देख रहा हूं, लेकिन मुझे लगता है कि यह मेरे जवाब को साफ करने से ज्यादा विचलित करता है क्योंकि मैं सटीक प्रश्न का एक सरल एक-लाइन समाधान देता हूं जो @ फ्रेमिंग फ्रेम को कहते हैं। यह 2-डी सरणियों के बारे में नहीं है, यह 1-डी सरणियों के बारे में है। यहां सेब और नाशपाती।

— उल्फ असलाक

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

— जॉन्डोडो

@ यूफ्लाएस्लाक, अपने उत्तर को अपडेट करें कि आपका दृष्टिकोण एनडी सरणी के लिए सामान्य नहीं है, यह हमेशा अच्छा है कि सामने वाले को स्पष्ट कर दिया जाए! जॉन्डोडो, ताकि कोई भी आपकी तकनीक का गलत तरीके से उपयोग न करे !, यहाँ सवाल सही उत्तर के लिए है। और एक लाइनर नहीं!

— अनु

Answer 4

आप एक मौजूदा वेक्टर को एक चौकोर कोष्ठक के अतिरिक्त सेट में लपेटकर मैट्रिक्स में बदल सकते हैं ...

from numpy import *
v=array([5,4]) ## create a numpy vector
array([v]).T ## transpose a vector into a matrix

numpy में एक matrixवर्ग भी है ( सरणी बनाम मैट्रिक्स देखें ) ...

matrix(v).T ## transpose a vector into a matrix

Answer 5

सुन्न 1D सरणी -> स्तंभ / पंक्ति मैट्रिक्स:

>>> a=np.array([1,2,4])
>>> a[:, None]    # col
array([[1],
       [2],
       [4]])
>>> a[None, :]    # row, or faster `a[None]`
array([[1, 2, 4]])

और जैसा कि @ जो-किंगटन ने कहा, आप पठनीयता के Noneसाथ बदल सकते हैं np.newaxis।

Answer 6

2d कॉलम के लिए 1d सरणी को 'स्थानांतरित करने' के लिए, आप इसका उपयोग कर सकते हैं numpy.vstack:

>>> numpy.vstack(numpy.array([1,2,3]))
array([[1],
       [2],
       [3]])

यह वेनिला सूचियों के लिए भी काम करता है:

>>> numpy.vstack([1,2,3])
array([[1],
       [2],
       [3]])

Comments

@sandroscodelller, क्या आपने अंतर्निहित कोड को देखा है vstack? np.concatenate([atleast_2d(_m) for _m in tup], 0)। यह सरणी को (1,1) सरणियों में विभाजित करता है, और उन को समेटता है! इस प्रक्रिया में यह एक प्रतिलिपि बनाता है, जबकि सभी रिशेप्स एक दृश्य बनाते हैं।

— हंपुलज

Answer 7

आप केवल 2 डी सरणी को स्थानांतरित कर सकते हैं। आप numpy.matrixएक 2D सरणी बनाने के लिए उपयोग कर सकते हैं । यह तीन साल की देर है, लेकिन मैं अभी समाधान के संभावित सेट में जोड़ रहा हूं:

import numpy as np
m = np.matrix([2, 3])
m.T

Comments

उपयोग की np.matrixआवश्यकता नहीं है, और आमतौर पर हतोत्साहित किया जा रहा है।

— हंपुलज

Answer 8

इसके बजाय arr[:,None]कॉलम वेक्टर बनाने के लिए उपयोग करें

Answer 9

का पारगमन

x = [[0 1],
     [2 3]]

है

xT = [[0 2],
      [1 3]]

अच्छी तरह से कोड है:

x = array([[0, 1],[2, 3]]);
np.transpose(x)        

अधिक जानकारी के लिए यह एक लिंक है:

http://docs.scipy.org/doc/numpy/reference/generated/numpy.transpose.html

Answer 10

एक और समाधान.... :-)

import numpy as np

a = [1,2,4]

[१, २, ४]

b = np.array([a]).T

सरणी ([[१], [२], [४]])

Comments

इस समाधान के साथ समस्या क्या है ?!

— omotto

Answer 11

मैं सिर्फ उपरोक्त पोस्ट को मजबूत कर रहा हूं, आशा है कि यह दूसरों को कुछ समय बचाने में मदद करेगा:

नीचे के सरणी में (2, )आयाम है, यह 1-D सरणी है,

b_new = np.array([2j, 3j])  

1-डी सरणी को स्थानांतरित करने के दो तरीके हैं:

---

"np.newaxis" या कोई नहीं के साथ इसे स्लाइस करें!

print(b_new[np.newaxis].T.shape)
print(b_new[None].T.shape)

लेखन के अन्य तरीके, बिना Tऑपरेशन के ऊपर ।

print(b_new[:, np.newaxis].shape)
print(b_new[:, None].shape)

रैपिंग [] या np.matrix का उपयोग कर, एक नया आयाम जोड़ने का मतलब है।

print(np.array([b_new]).T.shape)
print(np.matrix(b_new).T.shape)

Answer 12

जैसा कि ऊपर टिप्पणी में से कुछ, 1D सरणियों के पारगमन 1D सरणियों हैं, इसलिए 1D सरणी को स्थानांतरित करने का एक तरीका सरणी को मैट्रिक्स में बदलना होगा जैसे:

np.transpose(a.reshape(len(a), 1))

Answer 13

में समारोह का नाम numpyहै column_stack ।

>>>a=np.array([5,4])
>>>np.column_stack(a)
array([[5, 4]])

Answer 14

उत्तर में वर्णित विधि नहीं है, लेकिन विधि के लिए प्रलेखन में वर्णित है numpy.ndarray.transpose:

1-डी सरणी के लिए इसका कोई प्रभाव नहीं है, क्योंकि एक ट्रांसपोज़्ड वेक्टर बस एक ही वेक्टर है। 1-डी सरणी को 2 डी कॉलम वेक्टर में बदलने के लिए, एक अतिरिक्त आयाम जोड़ा जाना चाहिए। np.atleast2d (a) .T यह हासिल करता है, जैसा कि [:, np.newaxis] करता है।

एक कर सकते हैं:

import numpy as np
a = np.array([5,4])
print(a)
print(np.atleast_2d(a).T)

जो (imo) उपयोग करने की तुलना में अच्छा है newaxis।

Answer 15

मूल रूप से ट्रांज़ोज़ फ़ंक्शन क्या होता है, यह सरणी के आकार और प्रगति को स्वैप करना है:

>>> a = np.ones((1,2,3))

>>> a.shape
(1, 2, 3)

>>> a.T.shape
(3, 2, 1)

>>> a.strides
(48, 24, 8)

>>> a.T.strides
(8, 24, 48)

1 डी के बराबर सरणी (रैंक -1 एरे) के मामले में आकृति और स्ट्राइड्स 1-तत्व ट्यूपल्स हैं और इन्हें स्वैप नहीं किया जा सकता है, और इस तरह के 1 डी सरणी के ट्रांसफ़र से यह अपरिवर्तित हो जाता है। इसके बजाय, आप एक "पंक्ति-वेक्टर" (आकार की संख्यात्मक सारणी (1, n)) को "कॉलम-वेक्टर" ( आकार के संख्यात्मक आकार ) में स्थानांतरित कर सकते हैं (n, 1)। इसे प्राप्त करने के लिए आपको पहले अपने 1D के खसरे को पंक्ति-वेक्टर में बदलना होगा और फिर आकार और स्ट्रैड को स्वैप करना होगा (इसे स्थानांतरित करें)। नीचे एक फ़ंक्शन है जो इसे करता है:

from numpy.lib.stride_tricks import as_strided

def transpose(a):
    a = np.atleast_2d(a)
    return as_strided(a, shape=a.shape[::-1], strides=a.strides[::-1])

उदाहरण:

>>> a = np.arange(3)
>>> a
array([0, 1, 2])

>>> transpose(a)
array([[0],
       [1],
       [2]])

>>> a = np.arange(1, 7).reshape(2,3)
>>> a     
array([[1, 2, 3],
       [4, 5, 6]])

>>> transpose(a)
array([[1, 4],
       [2, 5],
       [3, 6]])

बेशक आपको इसे इस तरह से करने की ज़रूरत नहीं है क्योंकि आपके पास 1D सरणी है और आप इसे सीधे (n, 1)सरणी में a.reshape((-1, 1))या उसके द्वारा पुनः आकार दे सकते हैं a[:, None]। मैं सिर्फ यह दर्शाना चाहता था कि एक सरणी कैसे काम करती है।

Answer 16

जिस तरह से मैंने 1-डी सरणियों के लिए इसे कॉम्पैक्ट और पठनीय तरीके से लागू करना सीखा है, अब तक:

h = np.array([1,2,3,4,5])

v1 = np.vstack(h)
v2 = np.c_[h]

h1 = np.hstack(v1)
h2 = np.r_[v2[:,0]]

numpy.r_ और numpy.c_ क्रमश: पहली और दूसरी धुरी के साथ टुकड़ा वस्तुओं का अनुवाद करें। इसलिए स्लाइसिंग v2 [:, 0] क्षैतिज सरणी h2 में वर्टिकल ऐरे v2 को वापस ट्रांसप्लांट करने में

numpy.vstack आकृति के 1-D सरणियों (N,) को (1, N) पर फिर से आकार देने के बाद पहली धुरी के साथ समवर्ती के बराबर है। Vsplit से विभाजित arrays के पुनर्निर्माण ।