Ma trận trong Python

Ma trận trong Python là một khái niệm mà mọi lập trình viên đều cần biết. Dưới đây là những kiến thức cơ bản về cách dùng ma trận trong Python.

Python là một ngôn ngữ lập trình hướng đối tượng, được thông dịch, cấp cao, với ngữ nghĩa động. Cấu trúc dữ liệu tích hợp cấp cao, kết hợp với kiểu dữ liệu động và ràng buộc động, khiến Python trở nên rất hấp dẫn cho phát triển ứng dụng nhanh, cũng như sử dụng như một ngôn ngữ kịch bản hoặc ngôn ngữ kết dính để kết nối các thành phần hiện có với nhau. Cú pháp đơn giản, dễ học của Python nhấn mạnh vào khả năng đọc hiểu và do đó giảm chi phí bảo trì chương trình. Python hỗ trợ các mô-đun và gói, khuyến khích tính mô-đun của chương trình và tái sử dụng mã. Trình thông dịch Python và thư viện chuẩn mở rộng có sẵn ở dạng mã nguồn hoặc nhị phân miễn phí cho tất cả các nền tảng chính và có thể được phân phối miễn phí.

Ma trận là một trong những đối tượng cơ bản trong toán học. Chúng cho phép bạn biểu diễn và thao tác dữ liệu dưới dạng bảng gồm các hàng và cột. Chúng được sử dụng để giải hệ phương trình tuyến tính, xác định hành động của ma trận, biến đổi tọa độ và nhiều hơn nữa.

Ma trận trong Python là gì?

Ma trận trong Python là một mảng Numpy hình chữ nhật. Mảng này phải là hai chiều. Nó chứa dữ liệu đã lưu trong hàng & cột của mảng. Ở một ma trận Python, các chuỗi mục nằm ngang được gọi là “hàng”, còn chuỗi mục nằm dọc gọi là “cột”. Hàng và cột được xếp chồng lên nhau giống như một danh sách lồng nhau. Nếu ma trận chứa số hàng “r” và số cột “c”, trong đó r và c là số nguyên dương, còn r x c quyết định thứ tự của đối tượng ma trận này.

Bạn có thể lưu trữ các chuỗi và đối tượng của kiểu dữ liệu khác trong ma trận. Dữ liệu được lưu trong chồng hàng & cột ở một ma trận. Ma trận là một cấu trúc dữ liệu quan trọng cho việc tính toán toán trong toán học và khoa học.

Đây là ma trận 3x4 vì nó có 3 hàng và 4 cột.

Python không có kiểu xây dựng riêng dành cho ma trận, vậy nên chúng ta có thể biểu diễn ma trận dưới dạng một nested list.

Vậy nested list là gì?

Nested list là dạng danh sách lồng ghép, nghĩa là một list xuất hiện với vai trò là phần tử của một list khác. Ví dụ:

A = [ 1, 4, 5, [8, 9]]

Ở ví dụ này, nếu in ra A[3] ta được output là [8, 9].

Nested list thường được dùng để trình bày ma trận trong Python. Biểu diễn như sau:

A = [[1, 4, 5],     [-5, 8, 9]]

Chúng ta có thể coi danh sách này là một ma trận gồm 2 hàng và 3 cột.

Để kết xuất phần tử từ ma trận, ta có thể chọn cả một hàng của ma trận theo cách thông thường hoặc dùng dạng chỉ số kép, chỉ số thứ nhất để chọn hàng, còn chỉ số thứ hai chọn cột. Cùng xem ví dụ sau:

A = [[1, 4, 5, 12],  [-5, 8, 9, 0], [-6, 7, 11, 19]]print("A =", A) print("A[1] =", A[1]) # Hàng thứ 2 của ma trânprint("A[1][2] =", A[1][2]) # Phần tử thứ 3 của hàng thứ 2print("A[0][-1] =", A[0][-1]) # Phần tử cuối cùng của hàng 1column = []; for row in A: column.append(row[2])print("Cột thứ 3 =", column)

Chạy chương trình, output được trả về là:

A = [[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]]A[1] = [-5, 8, 9, 0]A[1][2] = 9A[0][-1] = 12Cột thứ 3 = [5, 9, 11]

Dùng nested list để biểu diễn ma trận là một cách thông dụng và thường dùng trong các tính toán đơn giản. Tuy nhiên có một cách hay hơn đó là sử dụng thư viện NumPy.

Sử dụng NumPy cho ma trận

NumPy là thư viện được viết bằng Python nhằm phục vụ cho việc tính toán khoa học, hỗ trợ nhiều kiểu dữ liệu đa chiều giúp cho việc tính toán, lập trình, làm việc với các hệ cơ sở dữ liệu cực kì thuận tiện.

Để tạo một ma trận ta có thể sử dụng ndarray (viết gọn là array) của NumPy

Array này là một đối tượng mảng đa chiều thuần nhất tức là mọi phần tử đều cùng 1 kiểu.

Hãy thử với một ví dụ:

import numpy as npa = np.array([1, 2, 3])print(a) # Output: [1, 2, 3]print(type(a)) # Output: <class 'numpy.ndarray'>

Cách tạo array của NumPy

Mảng số nguyên, số thực, số phức (integer, float, complex)

import numpy as npA = np.array([[1, 2, 3], [3, 4, 5]])print(A)A = np.array([[1.1, 2, 3], [3, 4, 5]]) # mảng số thựcprint(A)A = np.array([[1, 2, 3], [3, 4, 5]], dtype = complex) # mảng số phứcprint(A)

Chương trình trả về kết quả:

[[1 2 3] [3 4 5]][[1.1 2. 3. ] [3. 4. 5. ]][[1.+0.j 2.+0.j 3.+0.j] [3.+0.j 4.+0.j 5.+0.j]]

Mảng giá trị mặc định (0 và 1)

import numpy as np# Mọi phần tử đều là 0A = np.zeros( (2, 3) )print(A)# Output: [[0. 0. 0.] [0. 0. 0.]]# Mọi phần tử đều là 1B = np.ones( (1, 5) )print(B)# Output: [[1 1 1 1 1]]

Sử dụng arange() và shape()

import numpy as npA = np.arange(4)print('A =', A)B = np.arange(12).reshape(2, 6)print('B =', B)# Output:A = [0 1 2 3]B = [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]]

Các phép toán với ma trận

Các phép toán trên ma trận là những tính toán cơ bản khi làm việc. Trong phần này, Quantrimang chỉ đề cập tới 3 phép toán cơ bản thường được sử dụng là cộng ma trận, nhân ma trận và chuyển vị ma trận.

Các phép toán ở đây sử dụng cả nested list và thư viện NumPy.

Cộng 2 ma trận

Để cộng hai ma trận, ta cộng từng phần tử tương ứng của 2 ma trận cùng cấp với nhau.

import numpy as npA = np.array([[2, 4], [5, -6]])B = np.array([[9, -3], [3, 6]])C = A + B print(C)''' Output:[[11 1] [ 8 0]] '''

Nhân 2 ma trận

Nhân 2 ma trận là phép lấy tổng của tích từng phần tử của hàng tương ứng với cột tương ứng.

Chú ý: Nhân ma trận chỉ xảy ra khi số cột của ma trận A bằng với số hàng của ma trận B. Ví dụ cho 2 ma trận [A]mp và [B]pn, tích chúng theo thứ tự đó sẽ được kết quả là ma trận [AB]mn.

Biểu diễn với NumPy như sau:

import numpy as npA = np.array([[3, 6, 7], [5, -3, 0]])B = np.array([[1, 1], [2, 1], [3, -3]])C = a.dot(B)print(C)# Output:[[ 36 -12] [ -1 2]]

Chuyển vị ma trận

Chuyển vị là phép biến cột thành hàng và hàng thành cột của một ma trận.

import numpy as npA = np.array([[1, 1], [2, 1], [3, -3]])print(A.transpose())#Output:[[ 1 2 3] [ 1 1 -3]]

Xuất các phần tử, cột, dòng của ma trận

Xuất các phần tử của ma trận

Tương tự với cách kết xuất bằng list, chúng ta có thể sử dụng bằng NumPy. Trước tiên, hãy thử với mảng một chiều:

import numpy as npA = np.array([12, 14, 16, 18, 20])print("A[0] =", A[0]) # phần tử đầu tiên print("A[2] =", A[2]) # phần tử thứ 3print("A[-1] =", A[-1]) # phần tử cuối cùng

Output được trả về ở đây là:

A[0] = 12A[2] = 16A[-1] = 20

Ví dụ về mảng hai chiều:

import numpy as npA = np.array([[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]])# Phần tử đầu tiên của hàng đầu tiênprint("A[0][0] =", A[0][0])# Phần tử thứ 3 của hàng thứ 2print("A[1][2] =", A[1][2])# Phần tử cuối cùng của hàng cuối cùngprint("A[-1][-1] =", A[-1][-1])

Chạy chương trình, kết quả được trả về là:

A[0][0] = 1A[1][2] = 9A[-1][-1] = 19

Xuất các dòng của ma trận

import numpy as npA = np.array([[1, 4, 5, 12],  [-2, 8, 6, 14], [-1, 5, 10, 22]])print("A[0] =", A[0]) # Dòng đầu tiênprint("A[2] =", A[2]) # Dòng thứ 3print("A[-1] =", A[-1]) # Dòng cuối cùng (dòng thứ 3)

Output được trả về ở đây là:

A[0] = [1, 4, 5, 12]A[2] = [-1, 5, 10, 22]A[-1] = [-1, 5, 10, 22]

Xuất các cột của ma trận

import numpy as npA = np.array([[1, 4, 5, 12],  [-2, 8, 6, 14], [-1, 5, 10, 22]])print("A[:,0] =",A[:,0]) # Cột đầu tiênprint("A[:,3] =", A[:,3]) # Cột thứ 4print("A[:,-1] =", A[:,-1]) # Cột cuối cùng (Cột thứ 4)

Output được trả về:

A[:,0] = [ 1 -2 -1]A[:,3] = [12 14 22]A[:,-1] = [12 14 22]

Lát cắt của Ma trận

Lát cắt của mảng một chiều trong NumPy được biểu diễn tương tự như list.

import numpy as npA = np.array([1, 3, 5, 7, 9, 7, 5])# Phần tử thứ tự từ 3 đến 5print(A[2:5]) # Output: [5, 7, 9]# Phần tử thứ tự từ 1 đến 4print(A[:-5]) # Output: [1, 3]# Phần tử thứ 6 trở điprint(A[5:]) # Output:[7, 5]# Lấy cả mảngprint(A[:]) # Output:[1, 3, 5, 7, 9, 7, 5]# đổi chiều mảngprint(A[::-1]) # Output:[5, 7, 9, 7, 5, 3, 1]

Vậy để cắt ma trận, ta có ví dụ sau:

import numpy as npA = np.array([[1, 4, 5, 12, 14],  [-5, 8, 9, 0, 17], [-6, 7, 11, 19, 21]])print(A[:2, :4]) # 2 hàng, 4 cột''' Output:[[ 1 4 5 12] [-5 8 9 0]]'''print(A[:1,]) # hàng đầu tiên, tất cả cột''' Output:[[ 1 4 5 12 14]]'''print(A[:,2]) # tất cả các hàng, cột 2''' Output:[ 5 9 11]'''print(A[:, 2:5]) # tất cả các hàng, cột 3 đến 5'''Output:[[ 5 12 14] [ 9 0 17] [11 19 21]]'''

Chuyển đổi ma trận Python sang mảng

Bạn có thể dùng các hàm ravel và flatten để chuyển đổi ma trận Python sang mảng.

Code:

# Chương trình Python chuyển đổi ma trận sang một mảng

# nhập mô đun được yêu cầu
import numpy as np

# Tạo ma trận bằng numpy
matrix = np.matrix("[4, 6, 7; 5, 2, 6; 6, 3, 6]")

# Dùng hàm ravel() để chuyển đổi ma trận sang mảng
array = matrix.ravel()
print(array)

# Dùng hàm flatten() để chuyển đổi ma trận sang mảng
array = np.asarray(matrix).flatten()
print(array)

# Dùng hàm reshape() để chuyển đổi ma trận sang mảng
array = (np.asarray(matrix)).reshape(-1)
print(array)

Kết quả:

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

Tóm lại những điều cần ghi nhớ về ma trận Python:

• Ma trận Python là một mảng hình chữ nhật hai chiều chuyên biệt của dữ liệu được lưu trữ trong hàng và cột. Dữ liệu trong một ma trận có thể là số, chuỗi, biểu thức, biểu tượng… Ma trận là một trong số cấu trúc dữ liệu quan trọng có thể được dùng ở các phép tính toán học và khoa học.
• Python không có cách đơn giản để triển khai một kiểu dữ liệu ma trận. Khai báo ma trận trong Python có thể được tạo bằng một kiểu dữ liệu danh sách được lồng và bằng việc dùng thư viện numpy.
• Thư viện Python Numby giúp xử lý các vấn đề liên quan tới mảng. Numpy xử lý một mảng nhỏ nhanh hơn so với dạng danh sách.
• Những toán tử ma trận có thể được thực hiện là cộng, trừ, nhân, hoán vị, đọc hàng, cột của ma trận, cắt ma trận, v.v.
• Để thêm hai ma trận, bạn có thể sử dụng numpy.array() và thêm chúng bằng toán tử +.
• Để nhân chúng, bạn có thể dùng phương thức numpy dot(). Numpy.dot() là sản phẩm dot của ma trận M1 và M2. Numpy.dot() xử lý mảng 2D và thực hiện phép nhân ma trận.

Những câu hỏi thường gặp về ma trận trong Python

Ma trận là gì?

Ma trận là một mảng số hình chữ nhật được sắp xếp theo hàng và cột. Mỗi phần tử được xác định theo vị trí của nó trong lưới, được lập chỉ mục theo số hàng và số cột. Trong Python, ma trận thường được biểu diễn bằng danh sách lồng nhau, trong đó mỗi danh sách bên trong tương ứng với một hàng.

Làm thế nào tạo một ma trận rất lớn, như 1000x1000?

Bạn có thể sử dụng NumPy để tạo ma trận rất lớn một cách hiệu quả. Ví dụ, để tạo ma trận 1000x1000 chứa đầy số không, bạn có thể sử dụng:

large_matrix = np.zeros((1000, 1000))

NumPy xử lý ma trận lớn hiệu quả hơn nhiều so với danh sách lồng nhau, khiến nó trở thành lựa chọn lý tưởng cho những loại tác vụ này.

Làm thế nào để thực hiện phép nhân từng phần tử?

Bạn có thể chỉ cần sử dụng toán tử * với mảng NumPy để nhân từng phần tử:

elementwise_product = matrix1 * matrix2
print(elementwise_product)

Điều này sẽ nhân từng phần tử của matrix1 với phần tử tương ứng trong matrix2.

Làm thế nào để tạo và thao tác ma trận trong Python?

Trong Python, ma trận có thể được tạo và thao tác bằng cách sử dụng danh sách các list hoặc sử dụng các thư viện như NumPy để vận hành ma trận hiệu quả và thuận tiện hơn.

Tạo ma trận với Lists

# Tạo ma trận bằng danh sách lồng nhau
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

Vận hành ma trận

# Truy cập các thành phần
element = matrix[1][2] # Truy cậ thành phần ở hàng 1, cột 2 (6)

# Chỉnh sửa thành phần
matrix[2][1] = 10 # Đặt thành phần ở hàng 2, cột 1 tới 10

Công cụ Python nào dùng để nhân ma trận?

Đối với phép nhân ma trận, thư viện NumPy thường được sử dụng vì tính hiệu quả và đơn giản của nó.

Dùng NumPy để nhân ma trận

import numpy as np

# Tạo ma trận bằng mảng NumPy
matrix1 = np.array([
    [1, 2],
    [3, 4]
])

matrix2 = np.array([
    [5, 6],
    [7, 8]
])

# Thực hiện phép nhân ma trận
result = np.dot(matrix1, matrix2)
print(result)

Kết quả:

[[19 22]
 [43 50]]

Vậy như bạn thấy, sử dụng thư viện NumPy thay vì nested list làm cho các phép toán với ma trận dễ dàng hơn rất nhiều. Quantrimang khuyên bạn nên tìm hiểu và học cách sử dụng thư viện NumPy thật kĩ đặc biệt khi sử dụng Python để áp dụng cho việc tính toán khoa học hay phân tích dữ liệu.

Chúc các bạn thành công!