Hướng dẫn how do you multiply matrices in python? - làm thế nào để bạn nhân ma trận trong python?

Trong Python, chúng ta có thể triển khai một ma trận dưới dạng danh sách lồng nhau (danh sách bên trong danh sách).

Chúng ta có thể coi từng phần tử như một hàng của ma trận.

Ví dụ

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

Hàng đầu tiên có thể được chọn là

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

Sự nhân của hai ma trận x và y chỉ được xác định nếu số lượng cột trong x bằng số lượng hàng y.

Nếu x là ma trận

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

Mã nguồn: phép nhân ma trận bằng cách sử dụng vòng lặp lồng nhau

# Program to multiply two matrices using nested loops

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]
# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]
# result is 3x4
result = [[0,0,0,0],
         [0,0,0,0],
         [0,0,0,0]]

# iterate through rows of X
for i in range(len(X)):
   # iterate through columns of Y
   for j in range(len(Y[0])):
       # iterate through rows of Y
       for k in range(len(Y)):
           result[i][j] += X[i][k] * Y[k][j]

for r in result:
   print(r)

Đầu ra

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

Trong chương trình này, chúng tôi đã sử dụng các vòng lặp

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

Kỹ thuật này đơn giản nhưng tốn kém về mặt tính toán khi chúng tôi tăng thứ tự của ma trận.

Đối với các hoạt động ma trận lớn hơn, chúng tôi khuyên bạn nên sử dụng các gói phần mềm được tối ưu hóa như Numpy, theo thứ tự (theo thứ tự 1000) lần so với mã trên.

Mã nguồn: phép nhân ma trận bằng cách sử dụng danh sách lồng nhau

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

Đầu ra của chương trình này giống như trên. Để hiểu mã trên, trước tiên chúng ta phải biết về chức năng tích hợp

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

Chúng tôi đã sử dụng sự hiểu biết danh sách lồng nhau để lặp qua từng phần tử trong ma trận. Mã trông phức tạp và không thể đọc được lúc đầu. Nhưng một khi bạn hiểu được sự hiểu biết danh sách, có lẽ bạn sẽ không quay lại các vòng lặp lồng nhau.

Trong hướng dẫn này, bạn sẽ học cách nhân hai ma trận trong Python.multiply two matrices in Python.

Bạn sẽ bắt đầu bằng cách tìm hiểu điều kiện cho phép nhân ma trận hợp lệ và viết hàm Python tùy chỉnh thành nhân ma trận. Tiếp theo, bạn sẽ thấy làm thế nào bạn có thể đạt được kết quả tương tự bằng cách sử dụng danh sách lồng nhau.

Cuối cùng, bạn sẽ tiến hành sử dụng Numpy và các chức năng tích hợp của nó để thực hiện phép nhân ma trận hiệu quả hơn.

Cách kiểm tra xem phép nhân ma trận có hợp lệ không

Trước khi viết mã python cho phép nhân ma trận, hãy để xem lại các điều cơ bản của phép nhân ma trận.

Sự nhân ma trận giữa hai ma trận A và B chỉ hợp lệ nếu số lượng cột trong ma trận A bằng số lượng hàng trong ma trận B.number of columns in matrix A is equal to the number of rows in matrix B.

Bạn có thể đã bắt gặp điều kiện này để nhân ma trận trước đó. Tuy nhiên, bạn đã bao giờ tự hỏi tại sao đây là trường hợp?

Chà, nó vì cách nhân số nhân Ma trận hoạt động. Hãy xem hình ảnh dưới đây.

Trong ví dụ chung của chúng tôi, Matrix A có các hàng m và các cột N. Và Matrix B có n hàng n và cột P.m rows and n columns. And matrix B has n rows and p columns.

Hình dạng của ma trận sản phẩm là gì?

Phần tử tại Index (I, J) trong ma trận kết quả C là sản phẩm chấm của hàng I của ma trận A và cột J của ma trận B.

Vì vậy, để có được một phần tử ở một chỉ mục cụ thể trong ma trận kết quả C, bạn sẽ phải tính toán sản phẩm chấm của hàng và cột tương ứng trong ma trận A và B, tương ứng.

Lặp lại quá trình ở trên, bạn sẽ nhận được ma trận sản phẩm C của hình dạng m x p, với các hàng m và cột P, như hình bên dưới.m x p—with m rows and p columns, as shown below.

Và sản phẩm DOT hoặc sản phẩm bên trong giữa hai vectơ A và B được đưa ra bởi phương trình sau.a and b is given by the following equation.

Hãy để tóm tắt ngay bây giờ:

• Nó rõ ràng là sản phẩm DOT chỉ được xác định giữa các vectơ có độ dài bằng nhau.
• Vì vậy, đối với sản phẩm DOT giữa một hàng và một cột có giá trị khi nhân lên hai ma trận, bạn cần cả hai để có cùng một số phần tử.
• Trong ví dụ chung ở trên, mỗi hàng trong ma trận A có n phần tử. Và mỗi cột trong ma trận B cũng có n phần tử.n elements. And every column in matrix B has n elements too.

Nếu bạn xem xét kỹ hơn, n là số cột trong ma trận A và đó cũng là số lượng hàng trong ma trận B. và đây chính xác là lý do tại sao bạn cần số cột trong ma trận A bằng số của các hàng trong ma trận B.n is the number of columns in matrix A, and it’s also the number of rows in matrix B. And this is precisely the reason why you need the number of columns in matrix A to be equal to the number of rows in matrix B.

Tôi hy vọng bạn hiểu điều kiện cho phép nhân ma trận có hiệu lực và làm thế nào để có được từng phần tử trong ma trận sản phẩm.

Hãy để tiến hành viết một số mã Python để nhân hai ma trận.

Viết chức năng Python tùy chỉnh để nhân ma trận

Bước đầu tiên, chúng ta hãy viết một chức năng tùy chỉnh để nhân ma trận.

Chức năng này nên làm như sau:

• Chấp nhận hai ma trận, A và B, làm đầu vào.
• Kiểm tra xem phép nhân Ma trận giữa A và B có hợp lệ không.
• Nếu hợp lệ, nhân hai ma trận A và B và trả lại ma trận sản phẩm C.
• Khác, trả về một thông báo lỗi mà ma trận A và B không thể được nhân lên.

Bước 1: Tạo hai ma trận số nguyên sử dụng hàm Numpy

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

Bước 2: Đi trước và xác định hàm

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

Phân tích định nghĩa chức năng

Hãy để tiến hành phân tích định nghĩa chức năng.

Khai báo C là một biến toàn cầu: Theo mặc định, tất cả các biến bên trong hàm Python có phạm vi cục bộ. Và bạn không thể truy cập chúng từ bên ngoài chức năng. Để làm cho ma trận sản phẩm C có thể truy cập từ bên ngoài, chúng tôi sẽ phải tuyên bố nó là một biến toàn cầu. Chỉ cần thêm vòng loại

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

Kiểm tra xem phép nhân ma trận có hợp lệ không: Sử dụng thuộc tính

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

Sử dụng các vòng lặp lồng nhau để tính toán các giá trị: Để tính toán các phần tử của ma trận kết quả, chúng ta phải lặp qua các hàng của ma trận A và vòng lặp

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

# Program to multiply two matrices using list comprehension

# 3x3 matrix
X = [[12,7,3],
    [4 ,5,6],
    [7 ,8,9]]

# 3x4 matrix
Y = [[5,8,1,2],
    [6,7,3,0],
    [4,5,9,1]]

# result is 3x4
result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

for r in result:
   print(r)

▶ Bây giờ, chúng tôi đã học được cách chức năng Python để nhân ma trận hoạt động, hãy để gọi chức năng với các ma trận A và B mà chúng tôi đã tạo trước đó.

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Vì phép nhân ma trận giữa A và B là hợp lệ, hàm

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

Sử dụng danh sách lồng nhau của Python để nhân vào ma trận nhân

Trong phần trước, bạn đã viết một chức năng Python để nhân ma trận. Bây giờ, bạn sẽ thấy cách bạn có thể sử dụng toàn bộ danh sách lồng nhau để làm điều tương tự.

Ở đây, danh sách lồng nhau hiểu được vào ma trận nhân.

Lúc đầu, điều này có thể trông phức tạp. Nhưng chúng tôi sẽ phân tích từng bước hiểu danh sách lồng nhau.

Hãy cùng tập trung vào một danh sách hiểu biết tại một thời điểm và xác định những gì nó làm.

Chúng tôi sẽ sử dụng mẫu chung sau đây để hiểu danh sách:

[<do-this> for <item> in <iterable>]

where,
<do-this>: what you'd like to do—expression or operation
<item>: each item you'd like to perform the operation on
<iterable>: the iterable (list, tuple, etc.) that you're looping through

▶ Kiểm tra danh sách hướng dẫn của chúng tôi trong Python-với các ví dụ để có được sự hiểu biết sâu sắc.

Trước khi đi trước, xin lưu ý rằng chúng tôi muốn xây dựng Matrix C kết quả một hàng cùng một lúc.

Danh sách lồng nhau được giải thích

Bước 1: Tính toán một giá trị duy nhất trong ma trận C Compute a single value in the matrix C

Cho hàng I của ma trận A và cột J của ma trận B, biểu thức dưới đây cho mục nhập tại Index (I, J) trong ma trận C.

sum(a*b for a,b in zip(A_row, B_col)

# zip(A_row, B_col) returns an iterator of tuples
# If A_row = [a1, a2, a3] & B_col = [b1, b2, b3]
# zip(A_row, B_col) returns (a1, b1), (a2, b2), and so on

Nếu

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

Bước 2: Xây dựng một hàng trong ma trận C Build one row in the matrix C

Mục tiêu tiếp theo của chúng tôi là xây dựng toàn bộ hàng.

Đối với hàng 1 trong ma trận A, bạn đã lặp qua tất cả các cột trong ma trận B để có một hàng hoàn chỉnh trong ma trận C.

Quay trở lại mẫu danh sách hiểu.

• Thay thế

  def multiply_matrix(A,B):
    global C
    if  A.shape[1] == B.shape[0]:
      C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
      for row in range(rows): 
          for col in range(cols):
              for elt in range(len(B)):
                C[row, col] += A[row, elt] * B[elt, col]
      return C
    else:
      return "Sorry, cannot multiply A and B."

  1 bằng biểu thức từ bước 1, bởi vì đó là những gì bạn muốn làm.
• Tiếp theo, hãy thay thế

  def multiply_matrix(A,B):
    global C
    if  A.shape[1] == B.shape[0]:
      C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
      for row in range(rows): 
          for col in range(cols):
              for elt in range(len(B)):
                C[row, col] += A[row, elt] * B[elt, col]
      return C
    else:
      return "Sorry, cannot multiply A and B."

  2 bằng cột ____ 43 trong Ma trận B.
• Cuối cùng, thay thế

  def multiply_matrix(A,B):
    global C
    if  A.shape[1] == B.shape[0]:
      C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
      for row in range(rows): 
          for col in range(cols):
              for elt in range(len(B)):
                C[row, col] += A[row, elt] * B[elt, col]
      return C
    else:
      return "Sorry, cannot multiply A and B."

  4 bằng ________ 45, danh sách chứa tất cả các cột trong Ma trận B.

Và đây là sự hiểu biết danh sách đầu tiên.

[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 

# zip(*B): * is the unzipping operator
# zip(*B) returns a list of columns in matrix B

Bước 3: Xây dựng tất cả các hàng và có được ma trận C Build all rows and obtain the matrix C

Tiếp theo, bạn sẽ phải điền vào ma trận sản phẩm C bằng cách tính toán phần còn lại của các hàng.

Và đối với điều này, bạn đã lặp qua tất cả các hàng trong Ma trận A.

Quay trở lại danh sách hiểu một lần nữa, và làm như sau.

• Thay thế

  def multiply_matrix(A,B):
    global C
    if  A.shape[1] == B.shape[0]:
      C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
      for row in range(rows): 
          for col in range(cols):
              for elt in range(len(B)):
                C[row, col] += A[row, elt] * B[elt, col]
      return C
    else:
      return "Sorry, cannot multiply A and B."

  1 bằng danh sách hiểu từ bước 2. Nhớ lại rằng chúng tôi đã tính toán toàn bộ một hàng trong bước trước.
• Bây giờ, hãy thay thế

  def multiply_matrix(A,B):
    global C
    if  A.shape[1] == B.shape[0]:
      C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
      for row in range(rows): 
          for col in range(cols):
              for elt in range(len(B)):
                C[row, col] += A[row, elt] * B[elt, col]
      return C
    else:
      return "Sorry, cannot multiply A and B."

  2 bằng ________ 48, mọi hàng trong Ma trận A.
• Và

  def multiply_matrix(A,B):
    global C
    if  A.shape[1] == B.shape[0]:
      C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
      for row in range(rows): 
          for col in range(cols):
              for elt in range(len(B)):
                C[row, col] += A[row, elt] * B[elt, col]
      return C
    else:
      return "Sorry, cannot multiply A and B."

  4 của bạn là ma trận A, khi bạn đang lặp qua các hàng của nó.

Và ở đây, bạn có thể hiểu danh sách lồng nhau cuối cùng của chúng tôi.🎊

[[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 
    for A_row in A]

Nó thời gian để xác minh kết quả! ✔

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

Nếu bạn xem xét kỹ hơn, điều này tương đương với các vòng được lồng cho các vòng lặp mà chúng tôi đã có trước đó chỉ là điều đó thật ngắn gọn hơn.

Bạn cũng có thể làm điều này tất cả các chức năng tích hợp hiệu quả hơn. Hãy cùng tìm hiểu về họ trong phần tiếp theo.

Sử dụng numpy matmul () để nhân ma trận trong python

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

Lưu ý cách phương pháp này đơn giản hơn hai phương pháp chúng tôi đã học trước đó. Trên thực tế, thay vì

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Cách sử dụng Toán tử @ trong Python để nhân ma trận

Trong Python,

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Nó hoạt động trên hai ma trận và nói chung, các mảng numpy n-chiều và trả về ma trận sản phẩm.

Lưu ý: Bạn cần phải có Python 3.5 và sau đó để sử dụng toán tử

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

2. You need to have Python 3.5 and later to use the

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

2 operator.

Đây là cách bạn có thể sử dụng nó.

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

Lưu ý rằng ma trận sản phẩm C giống như loại chúng tôi thu được trước đó.

Bạn có thể sử dụng np.dot () để nhân ma trận không?

Nếu bạn đã từng bắt gặp mã sử dụng

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

[114, 160, 60, 27]
[74, 97, 73, 14]
[119, 157, 112, 23]

Bạn có thể thấy rằng

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Tuy nhiên, theo tài liệu numpy, bạn chỉ nên sử dụng

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Nhớ lại từ phần trước, phần tử tại INDEX (I, J) của ma trận sản phẩm C là sản phẩm chấm của hàng I của ma trận A và cột J của ma trận B.

Khi Numpy hoàn toàn phát sóng hoạt động sản phẩm chấm này đến tất cả các hàng và tất cả các cột, bạn sẽ nhận được ma trận sản phẩm kết quả. Nhưng để giữ cho mã của bạn có thể đọc được và tránh sự mơ hồ, hãy sử dụng

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Sự kết luận

Trong hướng dẫn này, bạn đã học được như sau.

• Điều kiện cho phép nhân ma trận có giá trị: Số lượng cột trong ma trận A = số lượng hàng trong ma trận B.columns in matrix A = number of rows in matrix B.
• Cách viết hàm Python tùy chỉnh để kiểm tra xem phép nhân Matrix có hợp lệ và trả về ma trận sản phẩm không. Cơ thể của chức năng sử dụng lồng nhau cho các vòng.
• Tiếp theo, bạn đã học cách sử dụng các toàn bộ danh sách lồng nhau để nhân ma trận. Họ ngắn gọn hơn so với các vòng lặp nhưng dễ bị các vấn đề về khả năng đọc.
• Cuối cùng, bạn đã học cách sử dụng chức năng tích hợp NP.Matmul () để nhân vào ma trận và làm thế nào đây là hiệu quả nhất về tốc độ.
• Bạn cũng đã tìm hiểu về toán tử @ để nhân hai ma trận trong Python.@ operator to multiply two matrices in Python.

Và điều đó kết thúc cuộc thảo luận của chúng tôi về phép nhân ma trận trong Python. Như một bước tiếp theo, hãy tìm hiểu cách kiểm tra xem một số là chính trong Python. Hoặc giải quyết các vấn đề thú vị trên chuỗi Python.

Học hỏi hạnh phúc! 🎉

Làm thế nào để chúng ta nhân trong Python?

Làm thế nào để bạn nhân ma trận?

Làm thế nào để bạn nhân hai ma trận trong Python mà không bị numpy?