Ma trận trong Python: Tạo, tìm hiểu và áp dụng

Ma trận trong Python là gì? Cách tạo ma trận trong Python như thế nào? Hãy cùng tìm hiểu qua bài viết này!

Python là một trong những ngôn ngữ lập trình phổ biến nhất hiện nay, và nhu cầu học Python ngày càng tăng cao. Sử dụng ngôn ngữ này không quá khó khăn, và ta có thể bắt đầu từ những hàm và đối tượng cơ bản nhất, trong số đó ma trận là một khái niệm quan trọng.

Ma trận trong Python là gì?

Ma trận trong Python là một mảng numpy hình chữ nhật, phải có hai chiều. Nó chứa dữ liệu được lưu trữ theo hàng và cột. Trong một ma trận, các hàng được gọi là “hàng” và các cột được gọi là “cột”. Ma trận có thể định nghĩa bởi số hàng “r” và số cột “c” (trong đó r và c là số nguyên dương) và r x c xác định thứ tự của ma trận.

Ta có thể lưu trữ các chuỗi và đối tượng của kiểu dữ liệu khác nhau trong ma trận. Ma trận là một cấu trúc dữ liệu quan trọng trong toán học và khoa học.

Dưới đây là một ví dụ ma trận 3×4:

Ma trận

Python không có kiểu dữ liệu ma trận riêng, do đó ta có thể biểu diễn ma trận bằng một danh sách lồng nhau. Có thể hiểu danh sách lồng nhau như một nested list, nghĩa là một list xuất hiện dưới dạng 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 kết quả là [8, 9]. Nested list thường được sử dụng để biểu diễn ma trận trong Python.

Ví dụ: A = [[1, 4, 5], [-5, 8, 9]]

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

Để truy xuất các phần tử từ ma trận, ta có thể chọn 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, trước tiên là chỉ số của hàng, sau đó là chỉ số của cột. Ví dụ:

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ân
print("A[1][2] =", A[1][2]) # Phần tử thứ 3 của hàng thứ 2
print("A[0][-1] =", A[0][-1]) # Phần tử cuối cùng của hàng 1
column = []
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] = 9
A[0][-1] = 12
Cột thứ 3 = [5, 9, 11]

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

Sử dụng NumPy cho ma trận

NumPy là một thư viện được viết bằng Python nhằm phục vụ tính toán khoa học. Nó hỗ trợ nhiều dạng dữ liệu đa chiều và giúp ta thực hiện các phép tính và làm việc với cơ sở dữ liệu một cách 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à tất cả các phần tử có cùng một kiểu dữ liệu.

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

import numpy as np
a = 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 np
A = np.array([[1, 2, 3], [3, 4, 5]])
print(A)
A = np.array([[1.1, 2, 3], [3, 4, 5]]) # mảng số thực
print(A)
A = np.array([[1, 2, 3], [3, 4, 5]], dtype = complex) # mảng số phức
print(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à 0
A = np.zeros((2, 3))
print(A)
# Output: [[0. 0. 0.]
# [0. 0. 0.]]
# Mọi phần tử đều là 1
B = np.ones((1, 5))
print(B)
# Output: [[1 1 1 1 1]]
  • Sử dụng arange()shape():
import numpy as np
A = 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 phép toán cơ bản khi làm việc với ma trận. Trong phần này, chúng ta chỉ đề cập đến 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 này có thể được thực hiện 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 np
A = 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 np
A = 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 np
A = 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ự như việc xuất các phần tử của list, ta có thể sử dụng numpy.

Đầu tiên, hãy thử với mảng một chiều:

import numpy as np
A = 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ứ 3
print("A[-1] =", A[-1]) # phần tử cuối cùng

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

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

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

import numpy as np
A = 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ên
print("A[0][0] =", A[0][0])
# Phần tử thứ 3 của hàng thứ 2
print("A[1][2] =", A[1][2])
# Phần tử cuối cùng của hàng cuối cùng
print("A[-1][-1] =", A[-1][-1])

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

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

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

import numpy as np
A = np.array([[1, 4, 5, 12], [-2, 8, 6, 14], [-1, 5, 10, 22]])
print("A[0] =", A[0]) # Dòng đầu tiên
print("A[2] =", A[2]) # Dòng thứ 3
print("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 np
A = np.array([[1, 4, 5, 12], [-2, 8, 6, 14], [-1, 5, 10, 22]])
print("A[:,0] =", A[:,0]) # Cột đầu tiên
print("A[:,3] =", A[:,3]) # Cột thứ 4
print("A[:,-1] =", A[:,-1]) # Cột cuối cùng (Cột thứ 4)

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

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 np
A = np.array([1, 3, 5, 7, 9, 7, 5])
# Phần tử thứ tự từ 3 đến 5
print(A[2:5]) # Output: [5, 7, 9]
# Phần tử thứ tự từ 1 đến 4
print(A[:-5]) # Output: [1, 3]
# Phần tử thứ 6 trở đi
print(A[5:]) # Output: [7, 5]
# Lấy cả mảng
print(A[:]) # Output: [1, 3, 5, 7, 9, 7, 5]
# Đảo ngược mảng
print(A[::-1]) # Output: [5, 7, 9, 7, 5, 3, 1]

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

import numpy as np
A = 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 ravelflatten để chuyển đổi ma trận Python sang mảng.

import numpy as np

# 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

# 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 chứa dữ liệu được lưu trữ theo hàng và cột. Dữ liệu trong ma trận có thể là số, chuỗi, biểu thức, biểu tượng…
  • Python không có cách đơn giản để triển khai một kiểu dữ liệu ma trận. Ta có thể khai báo ma trận bằng nested list hoặc sử dụng thư viện NumPy.
  • Thư viện NumPy giúp xử lý các vấn đề liên quan đến mảng. NumPy xử lý một mảng nhỏ nhanh hơn so với danh sách.
  • Các phép toán trên ma trận bao gồm cộng, trừ, nhân, chuyển vị, đọc hàng, đọc cột của ma trận, cắt ma trận, v.v.
  • Để thêm hai ma trận, ta có thể sử dụng numpy.array() và thêm chúng bằng toán tử ‘+’. Để nhân chúng, ta có thể sử dụng phương thức numpy.dot(). Numpy.dot() xử lý mảng 2D và thực hiện phép nhân ma trận.

Việc 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. Chúng ta nên tìm hiểu và học cách sử dụng thư viện NumPy, đặc biệt khi sử dụng Python để áp dụng cho việc tính toán khoa học hoặc phân tích dữ liệu.

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

Xem thêm:

  • Mảng trong Python
  • Các hàm trong Python
  • Hơn 100 bài tập Python có lời giải (code mẫu)