Hướng dẫn how is matrix multiplication done in python? - phép nhân ma trận được thực hiện như thế nào trong python?

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

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."

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

Bước 2: Đi trước và xác định chức năng

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."

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."

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."

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."

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."

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."

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."

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."

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

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."

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."

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

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."

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."

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."

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

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."

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."

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."

multiply_matrix(A,B)

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

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ử 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

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

▶ 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

multiply_matrix(A,B)

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

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:

[ for  in ]

where,
: what you'd like to do—expression or operation
: each item you'd like to perform the operation on
: 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

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

multiply_matrix(A,B)

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

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ế

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

  9 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ế

  [ for  in ]
  
  where,
  : what you'd like to do—expression or operation
  : each item you'd like to perform the operation on
  : the iterable (list, tuple, etc.) that you're looping through

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

  [ for  in ]
  
  where,
  : what you'd like to do—expression or operation
  : each item you'd like to perform the operation on
  : the iterable (list, tuple, etc.) that you're looping through

  2 bằng ________ 33 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ế

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

  9 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ộ hàng trong bước trước.
• Bây giờ, hãy thay thế

  [ for  in ]
  
  where,
  : what you'd like to do—expression or operation
  : each item you'd like to perform the operation on
  : the iterable (list, tuple, etc.) that you're looping through

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

  [ for  in ]
  
  where,
  : what you'd like to do—expression or operation
  : each item you'd like to perform the operation on
  : the iterable (list, tuple, etc.) that you're looping through

  2 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ả! ✔

# cast into NumPy array using np.array()
C = np.array([[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 
    for A_row in A])

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

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

[ for  in ]

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

C = np.matmul(A,B)
print(C)

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

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ì

[ for  in ]

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

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

Trong Python,

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ó 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ử

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

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

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

0 operator.

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

C = A@B
print(C)

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

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

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

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ạn có thể thấy rằng

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

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

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

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

[ for  in ]

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

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

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 để phép nhân ma trận hoạt động trong Python?

Làm thế nào là nhân ma trận được thực hiện?

Làm thế nào để bạn thực hiện một hoạt động ma trận trong Python?