पाइथन में मैट्रिक्स का संक्रमण

Question

मैं अजगर के लिए एक मैट्रिक्स ट्रांज़ोज़ फ़ंक्शन बनाने की कोशिश कर रहा हूं, लेकिन मैं इसे काम नहीं कर सकता। बोलो मेरे पास है

theArray = [['a','b','c'],['d','e','f'],['g','h','i']]

और मैं चाहता हूं कि मेरा फंक्शन साथ आए

newArray = [['a','d','g'],['b','e','h'],['c', 'f', 'i']]

तो दूसरे शब्दों में, अगर मैं इस 2D सरणी को कॉलम और पंक्तियों के रूप में प्रिंट करना चाहता था, तो मैं चाहूंगा कि पंक्तियों को स्तंभों और स्तंभों में बदल दिया जाए।

मैंने इसे अभी तक बनाया है लेकिन यह काम नहीं करता है

def matrixTranspose(anArray):
    transposed = [None]*len(anArray[0])
    for t in range(len(anArray)):
        for tt in range(len(anArray[t])):
            transposed[t] = [None]*len(anArray)
            transposed[t][tt] = anArray[tt][t]
    print transposed

Answer 1

अजगर 2:

>>> theArray = [['a','b','c'],['d','e','f'],['g','h','i']]
>>> zip(*theArray)
[('a', 'd', 'g'), ('b', 'e', 'h'), ('c', 'f', 'i')]

अजगर 3:

>>> [*zip(*theArray)]
[('a', 'd', 'g'), ('b', 'e', 'h'), ('c', 'f', 'i')]

Comments

यदि आप परिणामों के माध्यम से पुनरावृति करने जा रहे हैं, izipसे itertoolsबड़े सरणियों के लिए स्मृति बचा सकता है।

— एंटनी हैचकिंस

आपके पास उप सूची के लिए सूची कैसे लौटाएगा? के [['a', 'b', 'g'], ['d', 'e', 'h'], ['c', 'f', 'i']]बजाय की तरह [('a', 'd', 'g'), ('b', 'e', 'h'), ('c', 'f', 'i')]?

— acollection_

@acollection_: map(list, zip(*theArray))।

— JFS

@AntonyHatchkins यह पायथन 3.0 और इसके बाद के संस्करण की जरूरत नहीं है। वहां, zipपहले से ही एक पुनरावर्तक लौटाता है: docs.python.org/3.0/whatsnew/…

— xuiqzy

@xuiqzy ऐसा नहीं है कि मुझे इसकी जानकारी नहीं है, लेकिन यह सच है।

— एंटनी हैचकिंस

Answer 2

>>> theArray = [['a','b','c'],['d','e','f'],['g','h','i']]
>>> [list(i) for i in zip(*theArray)]
[['a', 'd', 'g'], ['b', 'e', 'h'], ['c', 'f', 'i']]

सूची जनरेटर tuples के बजाय सूची आइटम के साथ एक नया 2d सरणी बनाता है।

Comments

यह वह तरीका है जब आप परिणाम को एक चर के रूप में निर्दिष्ट करना चाहते हैं (जैसा कि इसके विपरीत, उदाहरण के लिए, सीधे उस पर पुनरावृत्ति करना) - यह मानते हुए कि आप ट्यूपल्स के बजाय सूची चाहते हैं, जैसा कि उल्लेख किया गया है।

— एएसएल

एक अन्य विकल्प (जैसा कि स्वीकृत उत्तर में टिप्पणियों द्वारा दिया गया है) होगा:list(map(list, zip(*theArray)))

— एएसएल

Answer 3

यदि आपकी पंक्तियाँ समान नहीं हैं, तो आप भी उपयोग कर सकते हैं map:

>>> uneven = [['a','b','c'],['d','e'],['g','h','i']]
>>> map(None,*uneven)
[('a', 'd', 'g'), ('b', 'e', 'h'), ('c', None, 'i')]

संपादित करें: पायथन 3 की कार्यक्षमता में map परिवर्तित , itertools.zip_longestइसके बजाय इस्तेमाल किया जा सकता है:
स्रोत: पायथन 3.0 में नया क्या है

>>> import itertools
>>> uneven = [['a','b','c'],['d','e'],['g','h','i']]
>>> list(itertools.zip_longest(*uneven))
[('a', 'd', 'g'), ('b', 'e', 'h'), ('c', None, 'i')]

Answer 4

बहुत आसान है:

>>> arr = np.array([[1,2,3],[4,5,6],[7,8,9]])
>>> arr
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> arr.T
array([[1, 4, 7],
       [2, 5, 8],
       [3, 6, 9]])
>>> theArray = np.array([['a','b','c'],['d','e','f'],['g','h','i']])
>>> theArray 
array([['a', 'b', 'c'],
       ['d', 'e', 'f'],
       ['g', 'h', 'i']], 
      dtype='|S1')
>>> theArray.T
array([['a', 'd', 'g'],
       ['b', 'e', 'h'],
       ['c', 'f', 'i']], 
      dtype='|S1')

Answer 5

आपके मूल कोड के साथ समस्या यह थी कि आपने transpose[t]हर तत्व पर आरंभीकरण किया था , न कि केवल एक बार प्रति पंक्ति में:

def matrixTranspose(anArray):
    transposed = [None]*len(anArray[0])
    for t in range(len(anArray)):
        transposed[t] = [None]*len(anArray)
        for tt in range(len(anArray[t])):
            transposed[t][tt] = anArray[tt][t]
    print transposed

यह काम करता है, हालांकि @ JF के zipआवेदन सहित समान चीजों को पूरा करने के लिए अधिक पायथोनिक तरीके हैं ।

Comments

ध्यान दें कि यह कार्यान्वयन उन मैट्रिक्स के साथ काम नहीं करता है जिनकी कॉलम और पंक्तियों की अलग-अलग संख्याएँ हैं

— वेक्टर

Answer 6

JF सेबेस्टियन के उत्तर को पूरा करने के लिए, यदि आपके पास अलग-अलग लंबाई वाली सूचियों की सूची है, तो ActiveState की इस शानदार पोस्ट को देखें । संक्षेप में:

अंतर्निहित फ़ंक्शन ज़िप एक समान काम करता है, लेकिन परिणाम को सबसे छोटी सूची की लंबाई तक काट देता है, इसलिए मूल डेटा से कुछ तत्व बाद में खो सकते हैं।

विभिन्न लंबाई के साथ सूचियों की सूची को संभालने के लिए, उपयोग करें:

def transposed(lists):
   if not lists: return []
   return map(lambda *row: list(row), *lists)

def transposed2(lists, defval=0):
   if not lists: return []
   return map(lambda *row: [elem or defval for elem in row], *lists)

Comments

यह अच्छी पकड़ है। हालाँकि, मैट्रिसेस में अलग-अलग लंबाई वाली सूचियाँ नहीं होती हैं।

— ओली

यह निर्भर करता है कि वे कैसे संग्रहीत हैं।

— फ्रेंक डर्नोनकोर्ट

Answer 7

"सबसे अच्छा" उत्तर पहले ही प्रस्तुत किया जा चुका है, लेकिन मुझे लगा कि मैं जोड़ूंगा कि आप नेस्टेड सूची समझ का उपयोग कर सकते हैं, जैसा कि पायथन ट्यूटोरियल में देखा गया है ।

यहां बताया गया है कि आप एक ट्रांसपोज़्ड सरणी कैसे प्राप्त कर सकते हैं:

def matrixTranspose( matrix ):
    if not matrix: return []
    return [ [ row[ i ] for row in matrix ] for i in range( len( matrix[ 0 ] ) ) ]

Answer 8

यह एक आयताकार आकार को संरक्षित करेगा, ताकि बाद के संक्रमणों को सही परिणाम मिल सके:

import itertools
def transpose(list_of_lists):
  return list(itertools.izip_longest(*list_of_lists,fillvalue=' '))

Answer 9

आप निम्न की तरह सूची समझ के साथ यह कोशिश कर सकते हैं

matrix = [['a','b','c'],['d','e','f'],['g','h','i']] n = len(matrix) transpose = [[row[i] for row in matrix] for i in range(n)] print (transpose)

Answer 10

यदि आप A = np.array ([[1,2], [3,4]]] जैसे मैट्रिक्स को स्थानांतरित करना चाहते हैं, तो आप बस AT का उपयोग कर सकते हैं, लेकिन जैसे वेक्टर के लिए a = [1,2], aT एक संक्रमण वापस नहीं करता है! और आपको नीचे दिए अनुसार a.reshape (-1, 1) का उपयोग करने की आवश्यकता है

import numpy as np
a = np.array([1,2])
print('a.T not transposing Python!\n','a = ',a,'\n','a.T = ', a.T)
print('Transpose of vector a is: \n',a.reshape(-1, 1))

A = np.array([[1,2],[3,4]])
print('Transpose of matrix A is: \n',A.T)

Answer 11

आप इसे बस अजगर समझ का उपयोग कर सकते हैं।

arr = [
    ['a', 'b', 'c'], 
    ['d', 'e', 'f'], 
    ['g', 'h', 'i']
]
transpose = [[arr[y][x] for y in range(len(arr))] for x in range(len(arr[0]))]

Comments

हालांकि यह एक सही जवाब हो सकता है। मूल प्रश्न को क्या और कैसे हल करता है, इसकी व्याख्या के बिना कोड की दो पंक्तियाँ बहुत उपयोगी नहीं हैं। कृपया अपने उत्तर का विवरण दें।

— रयाननर्ड

जब एक पुराने प्रश्न का नया उत्तर पोस्ट करते हैं, तो उम्मीदें अधिक होती हैं। कृपया पहले से ही पोस्ट किए गए लोगों के लिए एक हीन समाधान न करें

— जीन-फ्रांकोइस फैबरे

Answer 12

def matrixTranspose(anArray):
  transposed = [None]*len(anArray[0])

  for i in range(len(transposed)):
    transposed[i] = [None]*len(transposed)

  for t in range(len(anArray)):
    for tt in range(len(anArray[t])):            
        transposed[t][tt] = anArray[tt][t]
  return transposed

theArray = [['a','b','c'],['d','e','f'],['g','h','i']]

print matrixTranspose(theArray)

Answer 13

#generate matrix
matrix=[]
m=input('enter number of rows, m = ')
n=input('enter number of columns, n = ')
for i in range(m):
    matrix.append([])
    for j in range(n):
        elem=input('enter element: ')
        matrix[i].append(elem)

#print matrix
for i in range(m):
    for j in range(n):
        print matrix[i][j],
    print '\n'

#generate transpose
transpose=[]
for j in range(n):
    transpose.append([])
    for i in range (m):
        ent=matrix[i][j]
        transpose[j].append(ent)

#print transpose
for i in range (n):
    for j in range (m):
        print transpose[i][j],
    print '\n'

Answer 14

a=[]
def showmatrix (a,m,n):
    for i in range (m):
        for j in range (n):
            k=int(input("enter the number")
            a.append(k)      
print (a[i][j]),

print('\t')


def showtranspose(a,m,n):
    for j in range(n):
        for i in range(m):
            print(a[i][j]),
        print('\t')

a=((89,45,50),(130,120,40),(69,79,57),(78,4,8))
print("given matrix of order 4x3 is :")
showmatrix(a,4,3)


print("Transpose matrix is:")
showtranspose(a,4,3)

Answer 15

def transpose(matrix):
   x=0
   trans=[]
   b=len(matrix[0])
   while b!=0:
       trans.append([])
       b-=1
   for list in matrix:
       for element in list:
          trans[x].append(element)
          x+=1
       x=0
   return trans

Answer 16

def transpose(matrix):
    listOfLists = []
    for row in range(len(matrix[0])):
        colList = []
        for col in range(len(matrix)):
            colList.append(matrix[col][row])
    listOfLists.append(colList)

    return listOfLists

Comments

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

— रवनीत सिंह

Answer 17

`

def transpose(m):
    return(list(map(list,list(zip(*m)))))

`यह फ़ंक्शन परिवर्तन लौटाएगा

Answer 18

मैट्रिक्स को स्थानांतरित करने के लिए पायथन कार्यक्रम:

row,col = map(int,input().split())
matrix = list()

for i in range(row):
    r = list(map(int,input().split()))
    matrix.append(r)

trans = [[0 for y in range(row)]for x in range(col)]

for i in range(len(matrix[0])):
    for j in range(len(matrix)):
        trans[i][j] = matrix[j][i]     

for i in range(len(trans)):
    for j in range(len(trans[0])):
        print(trans[i][j],end=' ')
    print(' ')

Comments

यह उपयोगी नहीं है!

— ट्रिपुलस