Python'da Matris Devri

Python için bir matris transpoze işlevi oluşturmaya çalışıyorum ama çalışmasını sağlayamıyorum. Söyle bende

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

ve fonksiyonumun ortaya çıkmasını istiyorum

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

Başka bir deyişle, bu 2D diziyi sütunlar ve satırlar olarak basacak olsaydım, satırların sütunlara ve sütunlara satırlara dönüşmesini isterdim.

Bunu şimdiye kadar yaptım ama işe yaramıyor

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

Python 2:

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

Python 3:

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

>>> 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']]

liste oluşturucu, tuples yerine liste öğelerini içeren yeni bir 2d dizisi oluşturur.

Satırlarınız eşit değilse şunları da kullanabilirsiniz map:

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

Düzenleme: Python 3'te mapdeğiştirilen işlevselliği, itertools.zip_longestbunun yerine kullanılabilir:
Kaynak: Python 3.0'daki Yenilikler

>>> 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')]

Numpy ile çok daha kolay:

>>> 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')

Orijinal kodunuzdaki sorun, transpose[t]satır başına yalnızca bir kez değil, her öğede başlatmanızdı :

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'nin zipuygulaması da dahil olmak üzere aynı şeyleri başarmanın daha fazla Pythonic yolu olsa da, bu işe yarar .

JF Sebastian'ın cevabını tamamlamak için, farklı uzunluklarda listeleriniz varsa, bu harika gönderiyi ActiveState'den kontrol edin . Kısacası:

Yerleşik işlev zip'i benzer bir iş yapar, ancak sonucu en kısa listenin uzunluğuna indirir, bu nedenle orijinal verilerden bazı öğeler daha sonra kaybolabilir.

Farklı uzunluklardaki listelerin listesini işlemek için şunu kullanın:

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)

"En iyi" cevap zaten gönderildi, ama ben Python Eğitimi'nde görüldüğü gibi iç içe liste kavrayışları kullanabilirsiniz eklemek olacağını düşündüm .

Aktarılmış bir diziyi şu şekilde alabilirsiniz:

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

Bu dikdörtgen şeklini koruyacaktır, böylece sonraki aktarımlar doğru sonucu alacaktır:

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

bunu aşağıdaki gibi liste kavrayışıyla deneyebilirsiniz

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)

A = np.array ([[1,2], [3,4]]) gibi bir matris transpoze etmek istiyorsanız, AT kullanabilirsiniz, ancak a = [1,2], aT gibi bir vektör için bir devrik döndürmez! ve aşağıdaki gibi a. reshape (-1, 1) kullanmanız gerekir

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)

Bunu sadece python anlama kullanarak yapabilirsiniz.

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]))]

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)

#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'

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)

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

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

'

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

`Bu işlev devrik dönecektir

Matriks transpoze etmek için Python Programı:

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(' ')