העברת מטריצה ​​בפייתון פירושה להעיף אותה על האלכסון שלה להפוך את כל השורות לעמודים ולכל העמודים לשורות. למבחן E מטריצה ​​כמו [[1 2] [3 4] [5 6]] שיש לה 3 שורות ו -2 עמודות הופכת [[1 3 5] [2 4 6]] שיש לה 2 שורות ו -3 עמודות לאחר העברתם. בואו נבין שיטות שונות לעשות זאת ביעילות.

באמצעות הבנת רשימה

הבנת הרשימה משמשת לאיזור דרך כל אלמנט במטריקס. בדוגמה הנתונה אנו חוזרים על פני כל אלמנט של מטריצה ​​(M) באופן עמוד-עמוד-עמוד ומקצות את התוצאה למטריצת REZ שהיא העברת M.

תכונות של java

m = [[1 2] [3 4] [5 6]] res = [[m[j][i] for j in range(len(m))] for i in range(len(m[0]))] for row in res: print(row) 

[1 3 5] [2 4 6] 

הֶסבֵּר: ביטוי זה יוצר מטריצה ​​חדשה על ידי לקיחת כל טור מהמקור כשורה בזו החדשה. זה מחליף שורות עם עמודות.

ב לשיר רוכסן

Zip Python מחזיר איטרטור של טופלים שבהם ה- i-tuple מכיל את האלמנט i-th מכל אחד מרצפי הארגומנט או iTerables. בדוגמה זו אנו מפרקים את המערך שלנו באמצעות * ואז רוכסן אותו כדי לקבל את הטרנספוזז.

m = [(1 2 3) (4 5 6) (7 8 9) (10 11 12)] t_m = zip(*m) for row in t_m: print(row) 

(1 4 7 10) (2 5 8 11) (3 6 9 12) 

הֶסבֵּר: קוד זה מעביר את המטריצה מ ' באמצעות מיקוד (*מ) ו * מפרק את השורות ו רוֹכְסָן() קבוצות אלמנטים בחכמה בעמודה. כל טופל פלט מייצג עמודה מהמטריצה ​​המקורית מחליפה ביעילות שורות ועמודות.

באמצעות numpy

Python Numpy היא חבילה לעיבוד מערך כללי לשימוש כללי שנועדה לתפעל ביעילות מערכים רב-ממדיים גדולים.

דוגמא 1: שיטת Transpose מחזירה מבט מועבר של המטריצה ​​הרב-ממדית שהועברה.

import numpy m = [[1 2 3] [4 5 6]] print(numpy.transpose(m)) 

[[1 4] [2 5] [3 6]] 

הסבר: numpy.transpose () החלף שורות ועמודות של המטריצה ​​m. זה ממיר את המטריצה ​​המקורית של 2 שורות ו -3 עמודות לאחת עם 3 שורות ו -2 עמודות מעבירות אותה ביעילות.

דוגמא 2: באמצעות '.T' לאחר המשתנה

import numpy as np m = np.array([[1 2 3] [4 5 6]]) print(m.T) 

[[1 4] [2 5] [3 6]] 

הֶסבֵּר: קוד זה משתמש ב- NUMPY כדי ליצור מערך דו -ממדי M ואז מדפיס את העברתו באמצעות .T ו THE .T תכונה מחליפה שורות ועמודות המרות את המטריצה ​​2x3 המקורית למטריצה ​​שהועברה 3x2.

באמצעות iTertools

Python Itertools הוא מודול המספק פונקציות שונות הפועלות על איטרטורים לייצור איטרטורים מורכבים. שרשרת () היא פונקציה שלוקחת סדרה של Iterables ומחזירה אחת ניתנת להחלפה.

from itertools import chain import time import numpy as np def transpose2(M): M = M.tolist() n = len(M[0]) L = list(chain(*M)) return [L[i::n] for i in range(n)] m = np.array([[1 2 3] [4 5 6]]) start = time.time_ns() res = transpose2(m) end = time.time_ns() print(res) print('Time taken' end - start 'ns') 

[[1 4] [2 5] [3 6]] Time taken 9813 ns 

הֶסבֵּר: תחילה הוא ממיר את המטריצה ​​לרשימה של רשימות משטחת אותה לרשימה יחידה באמצעות שרשרת (*מ ') ואז בונה מחדש את המטריצה ​​המועברת על ידי חתך כל אלמנט n-th.

בונה מחרוזות

מאמרים קשורים:

• הבנת רשימה
• Python Itertools
• Zip Python
• שַׁרשֶׁרֶת()
• טופלים
• פייתון נומפי