Tìm hiểu về toán tử gán trong Python

Trong ngôn ngữ lập trình Python, toán tử gán đóng vai trò quan trọng trong việc lưu trữ và thao tác dữ liệu. Bài viết này mình sẽ giúp bạn khám phá khái niệm cơ bản về toán tử gán, cách thức hoạt động và đưa ra các ví dụ minh họa giúp bạn nắm bắt rõ hơn về toán tử này. 

Toán tử gán trong Python là gì?

Trong Python, ký hiệu = (dấu bằng) được định nghĩa là toán tử gán. Toán tử này có vai trò gán giá trị của biểu thức ở bên phải cho một biến duy nhất ở bên trái. Cần đặc biệt lưu ý rằng, ký hiệu = trong lập trình (và Python nói riêng) không giống với cách sử dụng của nó trong toán học. Trong toán học, dấu = thể hiện sự bằng nhau giữa hai biểu thức ở hai vế, còn trong lập trình, = là lệnh gán giá trị.

Ví dụ về toán tử gán trong Python

Chúng ta cùng xem qua đoạn code Python sau đây:

a = 10
b = 5
a = a + b
print (a)

Có lẽ ban đầu, với người mới làm quen với lập trình, nhưng đã quen thuộc với toán học, câu lệnh a = a + b có vẻ hơi lạ. Làm sao a có thể bằng a + b được? Tuy nhiên, cần nhấn mạnh rằng, ký hiệu = ở đây là một toán tử gán chứ không phải để thể hiện sự bằng nhau của hai vế.

Vì đây là một phép gán, biểu thức bên phải được tính toán (trong trường hợp này a + b là 10 + 5 = 15). Kết quả là 15, và giá trị này được gán cho biến a. Sau khi thực hiện gán, biến a sẽ mang giá trị 15.

Trong câu lệnh a += b, hai toán tử + và = được kết hợp lại thành một toán tử +=. Toán tử này được gọi là “toán tử cộng và gán”. Trong một câu lệnh, toán tử += sẽ thực hiện phép cộng giữa hai toán hạng a và b, và gán kết quả trở lại cho toán hạng bên trái, tức là a. Điều này tương đương với câu lệnh a = a + b.

Toán tử gán kết hợp trong Python

Ngoài toán tử gán đơn giản (=), Python còn cung cấp thêm một số toán tử gán khác phục vụ cho những mục đích nâng cao hơn. Các toán tử này còn được gọi là toán tử gán lũy tiến hoặc toán tử gán kết hợp. Trong phần này, chúng ta sẽ cùng nhau tìm hiểu cách sử dụng những toán tử gán kết hợp được định nghĩa trong Python.

Các toán tử gán kết hợp trong Python kết hợp việc thực hiện phép tính và phép gán vào cùng một câu lệnh. Vì Python hỗ trợ tính toán với các kiểu dữ liệu khác nhau, nên hai toán hạng có thể có kiểu dữ liệu không giống nhau. Tuy nhiên, kiểu dữ liệu của toán hạng bên trái có thể sẽ thay đổi theo kiểu của toán hạng bên phải nếu kiểu dữ liệu đó “rộng hơn” (ví dụ từ kiểu số nguyên sang kiểu số thực).

Dưới đây là danh sách các toán tử gán kết hợp trong Python:

• Toán tử gán kết hợp cộng
• Toán tử gán kết hợp trừ
• Toán tử gán kết hợp nhân
• Toán tử gán kết hợp chia
• Toán tử gán kết hợp chia lấy dư
• Toán tử gán kết hợp lũy thừa
• Toán tử gán kết hợp chia lấy phần nguyên

Augmented Addition Operator (+=)

Toán tử += là một toán tử đặc biệt trong Python, được gọi là toán tử cộng tăng cường. Toán tử này kết hợp phép cộng và phép gán trong cùng một thao tác. Cụ thể, a += b tương đương với việc thực hiện a = a + b. Toán tử này không chỉ làm code ngắn gọn hơn mà còn giúp code chạy hiệu quả hơn trong một số trường hợp.

Chúng ta hãy cùng xem các ví dụ sau để hiểu rõ hơn về cách += hoạt động:

Giả sử bạn đang quản lý số lượng sản phẩm trong kho hàng của một cửa hàng trực tuyến. Ban đầu, cửa hàng có một số lượng sản phẩm nhất định, và sau đó có thêm các sản phẩm nhập về:

# Số lượng sản phẩm loại A ban đầu
so_luong_san_pham_A = 20

# Nhập thêm sản phẩm loại A
so_luong_nhap_them = 15

print ("Ví dụ: Cộng thêm sản phẩm số nguyên vào số nguyên")
# Tăng số lượng sản phẩm loại A
so_luong_san_pham_A += so_luong_nhap_them  # Tương đương so_luong_san_pham_A = so_luong_san_pham_A + so_luong_nhap_them
print ("Số lượng sản phẩm A:", so_luong_san_pham_A, "Kiểu dữ liệu:", type(so_luong_san_pham_A))

#Ví dụ về sản phẩm bị lỗi có cân nặng dạng số thập phân
print ("Ví dụ: Cộng số thập phân vào số nguyên")
so_luong_san_pham_A += 0.5 # có thêm 1 nửa sản phẩm
print ("Số lượng sản phẩm A:", so_luong_san_pham_A, "Kiểu dữ liệu:", type(so_luong_san_pham_A))


#Ví dụ nhập thêm lô hàng lỗi để phân loại 
so_luong_loi = 5 + 2j #tưởng trưng 5 sản phẩm và 2 bộ phận hư hỏng cần được sữa chữa 
print ("Ví dụ: Cộng số phức vào số thập phân")
so_luong_san_pham_A += so_luong_loi # Nhập thêm lô hàng bị lỗi
print ("Số lượng sản phẩm A:", so_luong_san_pham_A, "Kiểu dữ liệu:", type(so_luong_san_pham_A))

Khi chạy đoạn code trên, ta nhận được kết quả:

Augmented Subtraction Operator (-=)

Toán tử -= (trừ và gán) là một cách viết ngắn gọn trong Python, giúp bạn thực hiện đồng thời hai thao tác: trừ và gán giá trị mới cho biến. Thay vì phải viết a = a - b, bạn có thể viết ngắn gọn là a -= b. Hai cách viết này hoàn toàn tương đương nhau về mặt kết quả.

Các toán hạng tham gia vào phép toán có thể là số nguyên, số thực hoặc số phức. Trong quá trình tính toán, Python sẽ tự động chuyển kiểu dữ liệu nếu cần, ưu tiên các kiểu có kích thước lớn hơn.

Để hiểu rõ hơn, chúng ta hãy xem xét ví dụ tính toán chi phí còn lại sau khi mua một vài món hàng:

chi_phi_ban_dau = 100000 #Ví dụ 100,000 VNĐ
chi_phi_mua_hang_1 = 25000 #Ví dụ 25,000 VNĐ
chi_phi_mua_hang_2 = 35000.50 #Ví dụ 35,000.50 VNĐ

print ("Chi phí còn lại sau các lần mua hàng: ")

chi_phi_ban_dau -= chi_phi_mua_hang_1 #Tương đương chi_phi_ban_dau = chi_phi_ban_dau - chi_phi_mua_hang_1
print ("Lần 1, chi phí còn lại:",chi_phi_ban_dau," ,Loại dữ liệu:", type(chi_phi_ban_dau))

chi_phi_ban_dau -= chi_phi_mua_hang_2 #Tương đương chi_phi_ban_dau = chi_phi_ban_dau - chi_phi_mua_hang_2
print ("Lần 2, chi phí còn lại:",chi_phi_ban_dau," ,Loại dữ liệu:", type(chi_phi_ban_dau))

so_tien_con_thua_o_dang_so_phuc=5000 + 3000j #số tiền còn dư ( ví dụ )
chi_phi_ban_dau-=so_tien_con_thua_o_dang_so_phuc
print ("Chi phí còn lại, khi trừ 1 số phức", chi_phi_ban_dau," ,Loại dữ liệu:", type(chi_phi_ban_dau))

Khi chạy đoạn code trên, kết quả sẽ như sau:

Augmented Multiplication Operator (*=)

Toán tử *=, hay còn gọi là toán tử nhân kết hợp, hoạt động dựa trên nguyên tắc tương tự như các toán tử kết hợp khác. Biểu thức a *= b thực hiện phép nhân và gán giá trị, tương đương với a = a * b.

Hiểu một cách đơn giản, a *= b sẽ lấy giá trị hiện tại của a, nhân với giá trị của b, rồi gán kết quả lại cho biến a.

Dưới đây là một số vị dụ có sử dụng toán tử *=, tương ứng với các kiểu dữ liệu khác nhau:

a = 10
b = 5
print ("Phép nhân kết hợp giữa số nguyên và số nguyên")
a *= b  # Tương đương với a = a * b
print ("a =", a, "type(a):", type(a))

a = 10
b = 5.5
print ("Phép nhân kết hợp giữa số nguyên và số thực")
a *= b  # Tương đương với a = a * b
print ("a =", a, "type(a):", type(a))

a = 6 + 4j
b = 3 + 2j
print ("Phép nhân kết hợp giữa số phức và số phức")
a *= b  # Tương đương với a = a * b
print ("a =", a, "type(a):", type(a))

Đoạn code trên sẽ in ra kết quả như sau:

Augmented Division Operator (/=)

Ký hiệu kết hợp /= đóng vai trò vừa là toán tử chia, vừa là toán tử gán. Vì vậy, biểu thức a /= b tương đương với a = a / b. Phép chia giữa các toán hạng là số nguyên (int) hoặc số thực (float) sẽ cho kết quả là số thực (float). Phép chia hai số phức sẽ cho kết quả là một số phức. Dưới đây là các ví dụ về toán tử chia kết hợp gán.

Dưới đây là ví dụ đế giúp bạn hiểu rõ hơn về toán tử /= trong Python

a = 10
b = 5
print ("Phép chia kết hợp gán giữa số nguyên và số nguyên")
a /= b  # tương đương với a = a / b
print ("a =", a, ", type(a):", type(a))

a = 10
b = 5.5
print ("Phép chia kết hợp gán giữa số nguyên và số thực")
a /= b  # tương đương với a = a / b
print ("a =", a, ", type(a):", type(a))

a = 6 + 4j
b = 3 + 2j
print ("Phép chia kết hợp gán giữa số phức và số phức")
a /= b  # tương đương với a = a / b
print ("a =", a, ", type(a):", type(a))

Khi chạy đoạn code trên, kết quả sẽ như sau:

Augmented Module Operator (%=)

Để thực hiện cả phép chia lấy phần dư (Module) và phép gán trong một câu lệnh duy nhất, ta có thể sử dụng toán tử %=. Tương tự như toán tử module %, phiên bản kết hợp này cũng không được hỗ trợ cho số phức.

Toán tử %= là một dạng toán tử rút gọn, giúp chúng ta viết code ngắn gọn và hiệu quả hơn. Khi bạn sử dụng a %= b, điều đó tương đương với việc bạn viết a = a % b. Tức là, giá trị của a sẽ được gán bằng phần dư của phép chia a cho b.

Để hiểu rõ hơn về cách toán tử %= hoạt động, chúng ta hãy cùng xem xét các ví dụ sau:

a = 10
b = 5
print("Toán tử mô-đun kết hợp với số nguyên và số nguyên")
a %= b  # tương đương với a = a % b
print("a =", a, "type(a):", type(a))

a = 10
b = 5.5
print("Toán tử mô-đun kết hợp với số nguyên và số thực")
a %= b  # tương đương với a = a % b
print("a =", a, "type(a):", type(a))

Đoạn code trên sẽ cho ra kết quả:

Augmented Exponent Operator (**=)

Toán tử lũy thừa gán **= thực hiện phép tính “a lũy thừa b” (tức là a<sup>b</sup>), sau đó gán kết quả vừa tính được trở lại cho biến a. Bạn có thể hiểu đơn giản toán tử này là viết gọn của a = a ** b. Dưới đây là một vài ví dụ để bạn dễ hình dung hơn:

Giả sử, bạn muốn tính diện tích của một hình vuông sau mỗi lần bạn tăng độ dài cạnh của hình vuông đó theo một lũy thừa nào đó.

canh_hinh_vuong = 2 # Khởi tạo độ dài cạnh hình vuông
luy_thua = 3 # Số mũ
print("Toán tử lũy thừa gán với số nguyên")
canh_hinh_vuong **= luy_thua # Tương đương canh_hinh_vuong = canh_hinh_vuong ** luy_thua
print ("Độ dài cạnh mới =",canh_hinh_vuong, "Kiểu dữ liệu:", type(canh_hinh_vuong))


canh_hinh_vuong = 4
luy_thua = 2.5 #Số mũ thập phân
print ("\nToán tử lũy thừa gán với số nguyên và số thực")
canh_hinh_vuong **= luy_thua # Tương đương canh_hinh_vuong = canh_hinh_vuong ** luy_thua
print ("Độ dài cạnh mới =", canh_hinh_vuong, "Kiểu dữ liệu:", type(canh_hinh_vuong))

# Ví dụ với số phức, khá hiếm gặp nhưng tôi vẫn cung cấp cho bạn để tham khảo:
canh_hinh_vuong = 1 + 1j #Khởi tạo cạnh hình vuông dạng số phức
luy_thua = 2 + 1j
print ("\nToán tử lũy thừa gán với số phức")
canh_hinh_vuong **= luy_thua # Tương đương canh_hinh_vuong = canh_hinh_vuong ** luy_thua
print ("Độ dài cạnh mới =", canh_hinh_vuong, "Kiểu dữ liệu:", type(canh_hinh_vuong))

Kết quả khi chạy chương trình:

Augmented Floor division Operator (//=)

Để thực hiện phép chia lấy phần nguyên đồng thời gán kết quả cho biến trong cùng một lệnh, bạn sử dụng toán tử //=. Cụ thể, a //= b tương đương với a = a // b. Lưu ý rằng toán tử này không dùng được với số phức.

Hãy tưởng tượng bạn đang quản lý một trang trại và cần chia đều số lượng trứng gà thu hoạch được vào các hộp. Giả sử bạn có 25 quả trứng và mỗi hộp có thể chứa tối đa 6 quả. Để xác định số hộp cần dùng và số trứng còn lại, bạn có thể dùng toán tử //= như sau:

so_trung_ga = 25
so_trung_moi_hop = 6

print ("Sử dụng toán tử //= với số nguyên")
so_trung_ga //= so_trung_moi_hop # Tương đương với so_trung_ga = so_trung_ga // so_trung_moi_hop
print("Số hộp cần dùng:", so_trung_ga, ", kiểu dữ liệu:", type(so_trung_ga))


so_lit_nuoc = 11
so_lit_moi_chai = 3.5
print ("Sử dụng toán tử //= với số nguyên và số thực")
so_lit_nuoc //= so_lit_moi_chai
print ("Số chai cần:", so_lit_nuoc, ", kiểu dữ liệu:", type(so_lit_nuoc))

Khi chạy đoạn code này, bạn sẽ thấy kết quả như sau:

Lời kết

Chúng ta vừa cùng nhau khám phá chi tiết về toán tử gán trong Python, từ khái niệm cơ bản đến các toán tử gán kết hợp. Hy vọng những kiến thức này sẽ giúp bạn hiểu rõ hơn cách gán giá trị cho biến và sử dụng chúng một cách hiệu quả trong quá trình lập trình. Việc nắm vững các toán tử gán sẽ là nền tảng vững chắc để bạn có thể xử lý dữ liệu một cách linh hoạt và chính xác hơn.