במדריך זה נלמד על מטריצות Python. ב- Python, אובייקט מטריצה דומה לרשימות מקוננות מכיוון שהן רב-ממדיות. נראה כיצד ליצור מטריצה באמצעות מערכי Numpy. בעקבות זאת, נראה שיטות ודוגמאות שונות של פעולות מטריצות להבנה טובה יותר.
מהי מטריקס בפייתון?
מטריצה ב-Python היא מערך Numpy מלבני. מערך זה חייב להיות דו מימדי. הוא מכיל נתונים המאוחסנים בשורות ובעמודות של המערך. במטריצת Python, סדרת הפריטים האופקית מכונה 'שורות', בעוד שסדרת הפריטים האנכית מכונה 'עמודות'. השורות והעמודות מוערמות זו על זו בדיוק כמו רשימה מקוננת. אם מטריצה מכילה מספר r של שורות ומספר c של עמודות, כאשר r ו-c הם מספרים שלמים חיוביים, אז r x c קובע את הסדר של אובייקט מטריצה זה.
אנו יכולים לאחסן מחרוזות, מספרים שלמים ואובייקטים מסוגי נתונים אחרים במטריצה. הנתונים מאוחסנים בערימות של שורות ועמודות במטריצה. המטריצה היא מבנה נתונים מכריע לחישובים במתמטיקה ומדעים. ב-Python, אנו מחשיבים רשימה של רשימות או רשימה מקוננת כמטריצה מכיוון ש-Python אינו כולל שום סוג מובנה עבור אובייקט מטריצה.
במהלך הדרכה זו, נעבור על הרשימה הבאה של שיטות פעולת מטריצה.
- תוספת מטריקס
- כפל מטריצה
- אופרטור כפל מטריצה
- כפל מטריצה ללא Numpy
- מטריקס הפוך
- טרנספוזיציה של מטריקס
- מטריצה למערך
כיצד פועלות מטריצות בפייתון?
אנו כותבים נתונים במערך דו מימדי כדי ליצור מטריצה. זה נעשה באופן הבא:
דוגמא
[ 2 3 5 7 6 3 2 6 7 2 5 7 2 6 1 ]
הוא מציג מטריצה בעלת 3 שורות ו-5 עמודות, כך שהממד שלה הוא 3×5. אובייקטים מסוג נתונים שלמים מרכיבים את הנתונים במטריצה זו. לשורה 1, השורה הראשונה, יש ערכים (2, 3, 5, 7, 6), בעוד שלשורה 2 יש ערכים (3, 2, 6, 7, 2) ולשורה 3 יש ערכים 5, 7, 2, 6, 1. לגבי עמודות, ל-Column1 יש ערכים (2, 3, 5), ל-Column2 יש ערכים (3, 2, 7) וכן הלאה.
דוגמא
[ 0, 0, 1 0, 1, 0 1, 0, 0 ]
הוא מציג מטריצה בעלת 3 שורות ו-3 עמודות, כך שהממד שלה הוא 3×3. מטריצות כאלה שיש להן שורות ועמודות שוות נקראות מטריצות מרובעות.
באופן דומה, Python מאפשר למשתמשים לאחסן את הנתונים שלהם בתוך מטריצה ממדית m x n. אנו יכולים לבצע חיבור של מטריצות, כפל, טרנספוזיציה ופעולות אחרות על מבנה דמוי מטריצה.
היישום של אובייקט מטריצה ב-Python אינו פשוט. אנו יכולים ליצור מטריצת Python באמצעות מערכים ובדומה להשתמש בהם.
מערך NumPy
תוכנת המחשוב המדעי NumPy תומכת באובייקט מערך N-ממדי חזק. התקנת NumPy היא תנאי מוקדם לשימוש בו בתוכנית שלנו.
כתב כתיבה לפני
ניתן להשתמש ולייבא NumPy לאחר ההתקנה. הכרת היסודות של Numpy Array יועיל בהבנת מטריצות.
מערכים בעלי מימדים מרובים של פריטים מסופקים על ידי NumPy. הנה המחשה:
קוד
# Python program to show how to create a Numpy array # Importing numpy import numpy as np # Creating a numpy array array = np.array([4, 6, 'Harry']) print(array) print('Data type of array object: ', type(array))
תְפוּקָה:
['4' '6' 'Harry'] Data type of array object:
כפי שאנו יכולים לראות, מערכי Numpy שייכים למחלקת ndarray.
דוגמה ליצירת מטריצה באמצעות מערך Numpy
חשבו על התרחיש שבו אנו יוצרים תיעוד של ציוני התלמידים. נרשום את שם התלמיד וציוניו בשני מקצועות, תכנות פייתון ומטריקס. ניצור מטריצה דו מימדית באמצעות מערך numpy ולאחר מכן נעצב אותה מחדש.
קוד
# Python program to create a matrix using numpy array # Importing numpy import numpy as np # Creating the matrix record = np.array( [['Itika', 89, 91], ['Aditi', 96, 82], ['Harry', 91, 81], ['Andrew', 87, 91], ['Peter', 72, 79]]) matrix = np.reshape(record, (5,3)) print('The matrix is: ', matrix)
תְפוּקָה:
The matrix is: [['Itika' '89' '91'] ['Aditi' '96' '82'] ['Harry' '91' '81'] ['Andrew' '87' '91'] ['Peter' '72' '79']]
דוגמה ליצירת מטריקס בשיטת Numpy Matrix
אנו יכולים להשתמש ב-numpy.matrix כדי ליצור מטריצה דו-ממדית.
int למחרוזת c++
קוד
# Python program to show how to create a matrix using the matrix method # importing numpy import numpy as np # Creating a matrix matrix = np.matrix('3,4;5,6') print(matrix)
תְפוּקָה:
[[3 4] [5 6]]
גישה לערכים של מטריקס
ניתן להשתמש במדדים של מטריצה כדי לגשת לאלמנטים המאוחסנים בה. ניתן לגשת לנתונים המאוחסנים במטריצה באמצעות אותה גישה בה אנו משתמשים עבור מערך דו מימדי.
קוד
# Python program to access elements of a matrix # Importing numpy import numpy as np # Creating the matrix record = np.array( [['Itika', 89, 91], ['Aditi', 96, 82], ['Harry', 91, 81], ['Andrew', 87, 91], ['Peter', 72, 79]]) matrix = np.reshape(record, (5,3)) # Accessing record of Itika print( matrix[0] ) # Accessing marks in the matrix subject of Andrew print( 'Andrew's marks in Matrix subject: ', matrix[3][2] )
תְפוּקָה:
['Itika' '89' '91'] Andrew's marks in Matrix subject: 91
שיטות ליצירת מערך Numpy דו-ממדי או מטריקס
ישנן מספר שיטות ליצירת מערך NumPy דו מימדי ומכאן מטריצה. מתן ערכים עבור השורות והעמודות
אנחנו יכולים לספק מספרים שלמים, צפים, או אפילו מספרים מרוכבים. באמצעות תכונת dtype של שיטת המערך, נוכל לציין את סוג הנתונים שאנו רוצים.
קוד
# Python program to show how to create a Numpy array # Importing numpy import numpy as np # Creating numpy arrays array1 = np.array([[4, 2, 7, 3], [2, 8, 5, 2]]) print('Array of data type integers: ', array1) array2 = np.array([[1.5, 2.2, 3.1], [3, 4.4, 2]], dtype = 'float') print('Array of data type float: ', array2) array3 = np.array([[5, 3, 6], [2, 5, 7]], dtype = 'complex') print('Array of data type complex numbers: ', array3)
תְפוּקָה:
Array of data type integers: [[4 2 7 3] [2 8 5 2]] Array of data type float: [[1.5 2.2 3.1] [3. 4.4 2. ]] Array of data type complex numbers: [[5.+0.j 3.+0.j 6.+0.j] [2.+0.j 5.+0.j 7.+0.j]]
מערך בעל אפסים ואחדים
קוד
# Python program to show how to create a Numpy array having zeroes and ones # Importing numpy import numpy as np # Creating numpy arrays zeores_array = np.zeros( (3, 2) ) print(zeores_array) ones_array = np.ones( (2, 4), dtype=np.int64 ) print(ones_array)
תְפוּקָה:
[[0. 0.] [0. 0.] [0. 0.]] [[1 1 1 1] [1 1 1 1]]
כאן, ציינו את dtype ל-64 סיביות.
שימוש בשיטות arange() ו-shape().
קוד
# Python program to show how to create Numpy array using arrange() and shape() methods # Importing numpy import numpy as np # Creating numpy arrays array1 = np.arange( 5 ) print(array1) array2 = np.arange( 6 ).reshape( 2, 3 ) print(array2)
תְפוּקָה:
דומה ל-java
[0 1 2 3 4] [[0 1 2] [3 4 5]]
פעולות מטריצת פייתון
תוספת מטריצת פייתון
נוסיף את שתי המטריצות ונשתמש בלולאה המקוננת דרך המטריצות הנתונות.
קוד
# Python program to add two matrices without using numpy # Creating matrices in the form of nested lists matrix1 = [[23, 43, 12], [43, 13, 55], [23, 12, 13]] matrix2 = [[4, 2, -1], [5, 4, -34], [0, -4, 3]] matrix3 = [[0,1,0], [1,0,0], [0,0,1]] matrix4 = [[0,0,0], [0,0,0], [0,0,0]] matrices_length = len(matrix1) #Adding the three matrices using nested loops for row in range(len(matrix1)): for column in range(len(matrix2[0])): matrix4[row][column] = matrix1[row][column] + matrix2[row][column] + matrix3[row][column] #Printing the final matrix print('The sum of the matrices is = ', matrix4)
תְפוּקָה:
The sum of the matrices is = [[27, 46, 11], [49, 17, 21], [23, 8, 17]]
כפל מטריצת פייתון
מפעיל מטריצת פייתון
ב- Python @ ידוע בתור אופרטור הכפל. הבה נראה דוגמה שבה נשתמש באופרטור זה כדי להכפיל שתי מטריצות.
קוד
# Python program to show how to create a matrix using the matrix method. # importing numpy import numpy as np # Creating the matrices matrix1 = np.matrix('3,4;5,6') matrix2 = np.matrix('4,6;8,2') # Usng multiplication operator to multiply two matrices print(matrix1 @ matrix2)
תְפוּקָה:
[[44 26] [68 42]]
פייתון מטריצת כפל ללא שימוש ב-Numpy
דרך נוספת להכפיל שתי מטריצות היא שימוש בלולאות מקוננות. הנה דוגמה להצגה.
קוד
# Python program to show how to create a matrix using the matrix method # importing numpy import numpy as np # Creating two matrices matrix1 = [[4, 6, 2], [7, 4, 8], [6, 2, 7]] matrix2 = [[4, 6, 8, 2], [6, 5, 3, 7], [7, 3, 7, 6]] # Result will be a 3x4 matrix output = [[0,0,0,0], [0,0,0,0], [0,0,0,0]] # Iterating through the rows of matrix1 for i in range(len(matrix1)): # iterating through the columns of matrix2 for j in range(len(matrix2[0])): # iterating through the rows of matrix2 for k in range(len(matrix2)): output[i][j] += matrix1[i][k] * matrix2[k][j] for row in output: print(row)
תְפוּקָה:
[66, 60, 64, 62] [108, 86, 124, 90] [85, 67, 103, 68]
Python Matrix Inverse
כאשר צריך לפתור משוואה כדי לקבל את הערך של משתנה לא ידוע שעומד במשוואות, מחושב היפוך של מטריצה, שהוא רק ההדדיות של המטריצה כפי שהיינו במתמטיקה רגילה. היפוך של מטריצה הוא המטריצה שנותנת את מטריצת הזהות כאשר אנו מכפילים עם המטריצה המקורית. רק למטריצה שאינה יחידה יכולה להיות הפוך. למטריצה לא יחידה יש דטרמיננט שאינו אפס.
קוד
# Python program to show how to calculate the inverse of a matrix # Importing the required library import numpy as np # Creating a matrix A = np.matrix('3, 4, 6; 6, 2, 7; 6, 4, 6') # Calculating the inverse of A print(np.linalg.inv(A))
תְפוּקָה:
[[-3.33333333e-01 -7.40148683e-17 3.33333333e-01] [ 1.25000000e-01 -3.75000000e-01 3.12500000e-01] [ 2.50000000e-01 2.50000000e-01 -3.75000000e-01]]
Transpose של פייתון מטריקס
Transpose של Python Matrix ללא Numpy
טרנספוזיציה של מטריצה כוללת החלפת השורות והעמודות. יש לו את הסמל X'. נשים את האובייקט בשורה i ועמודה j של מטריצה X בשורה j ועמודה i של מטריצה X'. כתוצאה מכך, X' יהפוך למטריצה 4x3 אם המטריצה המקורית X היא מטריצה 3x4.
קוד
# Python program to find the transpose of a matrix using nested loops # Creating a matrix matrix = [[4, 6, 7, 8], [3, 7, 2, 7], [7, 3, 7, 5]] result = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] # iterating through the rows for i in range(len(matrix)): # iterating through the columns for j in range(len(matrix[0])): result[j][i] = matrix[i][j] for row in result: print(row)
תְפוּקָה:
[4, 3, 7] [6, 7, 3] [7, 2, 7] [8, 7, 5]
Transpose של Python Matrix באמצעות Numpy
אנו יכולים להשתמש בשיטת matrix.transpose() ב-Numpy כדי לקבל את הטרנספוזיה של המטריצה.
קוד
# Python program to find the transpose of a matrix # importing the required module import numpy as np # Creating a matrix using matrix method matrix = np.matrix('[5, 7, 6; 4, 2, 4]') #finding transpose using matrix.transpose method transpose = matrix.transpose() print(transpose)
תְפוּקָה:
קובץ הרחבה java
[[5 4] [7 2] [6 4]]
המרת Python Matrix למערך
אנו יכולים להשתמש בפונקציות ravel ו- flatten כדי להמיר מטריצת Python למערך Python.
קוד
# Python program to convert a matrix to an array # importing the required module import numpy as np # Creating a matrix using numpy matrix = np.matrix('[4, 6, 7; 5, 2, 6; 6, 3, 6]') # Using ravel() function to covert matrix to array array = matrix.ravel() print(array) # Using flatten() function to covert matrix to array array = np.asarray(matrix).flatten() print(array) # Using reshape() function to covert matrix to array array = (np.asarray(matrix)).reshape(-1) print(array)
תְפוּקָה:
[[4 6 7 5 2 6 6 3 6]] [4 6 7 5 2 6 6 3 6] [4 6 7 5 2 6 6 3 6]