Tất tần tật về toán tử trong Python

Toán tử trong Python là các ký hiệu đặc biệt thực hiện các phép toán trên một hoặc nhiều biến. Toán tử đóng vai trò quan trọng, cho phép chúng ta xây dựng các biểu thức phức tạp để xử lý dữ liệu. Ví dụ, chúng ta có thể dùng các toán tử số học để thực hiện phép cộng, trừ, nhân, chia; hoặc toán tử so sánh để kiểm tra các mối quan hệ giữa các giá trị. Trong bài viết này mình sẽ giúp bạn hiểu rõ hơn về vai trò và ứng dụng của các toán tử trong Python.

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

Toán tử trong Python là các ký hiệu đặc biệt dùng để thực hiện các phép toán cụ thể trên một hoặc nhiều toán hạng. Các toán hạng này có thể là biến, giá trị hoặc biểu thức. Ví dụ, toán tử cộng + trong Python được dùng để thực hiện phép cộng giữa hai biến, hai giá trị, hoặc hai biểu thức.

Để hiểu rõ hơn về toán tử, chúng ta cùng làm quen với một vài khái niệm liên quan:

• Toán hạng (Operands): Là các biến, giá trị, hoặc biểu thức được dùng cùng với toán tử để thực hiện một phép toán nào đó.
• Toán tử một ngôi (Unary operators): Đây là các toán tử yêu cầu một toán hạng để thực hiện phép toán.
• Toán tử hai ngôi (Binary operators): Các toán tử này cần hai toán hạng để thực hiện phép toán.

Các loại toán tử trong Python

Các toán tử trong Python được chia thành các nhóm sau, dựa trên chức năng mà các toán tử đó thực hiện:

• Toán tử số học (Arithmetic Operators): Dùng để thực hiện các phép tính toán học cơ bản như cộng, trừ, nhân, chia, và các phép toán liên quan khác.
• Toán tử so sánh (Comparison/Relational Operators): Được sử dụng để so sánh hai toán hạng. Kết quả của phép so sánh này thường là True (đúng) hoặc False (sai). Ví dụ: kiểm tra xem một số có lớn hơn, nhỏ hơn, hay bằng một số khác.
• Toán tử gán (Assignment Operators): Dùng để gán giá trị cho biến. Toán tử gán cơ bản nhất là dấu bằng (=). Ngoài ra còn có các toán tử gán kết hợp (ví dụ: +=, -=, *=,…)
• Toán tử logic (Logical Operators): Dùng để kết hợp các biểu thức điều kiện. Ví dụ như phép “và”, “hoặc”, “phủ định” ( and, or, not ).
• Toán tử bitwise (Bitwise Operators): Thực hiện các thao tác trên từng bit của các số nguyên. Thường được dùng trong các tác vụ liên quan đến việc thao tác trực tiếp với bit ở mức thấp.
• Toán tử thành viên (Membership Operators): Dùng để kiểm tra xem một giá trị có nằm trong một chuỗi, list, tuple hay set hay không (ví dụ: in, not in).
• Toán tử nhận dạng (Identity Operators): So sánh các đối tượng có giống nhau về địa chỉ bộ nhớ hay không (ví dụ: is, is not).

Tác động của các toán tử số học trong Python

Toán tử số học trong Python được dùng để thực hiện các phép toán cơ bản, quen thuộc như cộng, trừ, nhân, chia… Các toán tử này là nền tảng cho việc thực hiện các tính toán trong chương trình.

Bảng dưới đây liệt kê tất cả các toán tử số học trong Python, kèm theo ký hiệu, tên gọi và ví dụ minh họa (giả sử biến a có giá trị 10 và biến b có giá trị 20):

Ví dụ về các toán tử số học trong Python

Để giúp bạn hiểu rõ hơn về các toán tử số học trong Python, hãy xem ví dụ dưới đây:

a = 21
b = 10
c = 0

c = a + b
print ("a: {} b: {} a+b: {}".format(a,b,c))

c = a - b
print ("a: {} b: {} a-b: {}".format(a,b,c) )

c = a * b
print ("a: {} b: {} a*b: {}".format(a,b,c))

c = a / b
print ("a: {} b: {} a/b: {}".format(a,b,c))

c = a % b
print ("a: {} b: {} a%b: {}".format(a,b,c))

a = 2
b = 3
c = a**b 
print ("a: {} b: {} a**b: {}".format(a,b,c))

a = 10
b = 5
c = a//b 
print ("a: {} b: {} a//b: {}".format(a,b,c))

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

Toán tử so sánh trong Python

Toán tử so sánh trong Python (còn được gọi là toán tử quan hệ) dùng để so sánh giá trị giữa hai vế và xác định mối quan hệ giữa chúng. Kết quả của một phép so sánh sẽ luôn là True (đúng) hoặc False (sai).

Các toán tử so sánh trong Python bao gồm:

Ví dụ về toán tử so sánh trong Python

Để bạn hình dung rõ hơn về cách các toán tử so sánh hoạt động trong thực tế, hãy xem xét đoạn code Python sau:

diem_thi_Lan = 8
diem_thi_Huong = 7

if diem_thi_Lan == diem_thi_Huong:
   print("Điểm của Lan và Hương bằng nhau")
else:
   print("Điểm của Lan và Hương khác nhau")

if diem_thi_Lan != diem_thi_Huong:
  print ("Điểm của Lan và Hương không bằng nhau")
else:
  print ("Điểm của Lan và Hương bằng nhau")


if diem_thi_Lan < diem_thi_Huong:
  print ("Điểm của Lan bé hơn Hương")
else:
  print("Điểm của Lan không bé hơn Hương")

if diem_thi_Lan > diem_thi_Huong:
  print("Điểm của Lan lớn hơn Hương")
else:
  print("Điểm của Lan không lớn hơn Hương")
  
diem_thi_Lan, diem_thi_Huong = diem_thi_Huong, diem_thi_Lan  # Đổi giá trị của 2 biến
#Lúc này diem_thi_Lan = 7, diem_thi_Huong = 8

if diem_thi_Lan <= diem_thi_Huong:
   print ("Điểm của Lan bé hơn hoặc bằng điểm của Hương")
else:
  print ("Điểm của Lan không bé hơn và không bằng điểm của Hương")


if diem_thi_Huong >= diem_thi_Lan:
   print ("Điểm của Hương lớn hơn hoặc bằng điểm của Lan")
else:
    print("Điểm của Hương không lớn hơn hoặc bằng điểm của Lan")

Kết quả khi chạy đoạn code trên:

Toán tử gán trong Python

Toán tử gán trong Python được sử dụng để gán giá trị cho biến. Toán tử gán cơ bản nhất là dấu bằng (=). Ngoài ra, Python cũng cung cấp các toán tử gán kết hợp, giúp bạn vừa thực hiện phép tính vừa gán kết quả vào biến một cách gọn gàng.

Dưới đây là bảng liệt kê các toán tử gán phổ biến trong Python:

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

Để hiểu rõ hơn cách các toán tử gán này hoạt động, hãy xem ví dụ sau:

a = 20
b = 5
c = 0
print ("a: {} b: {} c : {}".format(a,b,c))

c = a + b # c = 20 + 5 = 25
print ("a: {}  c = a + b: {}".format(a,c))

c += a # c = 25 + 20 = 45
print ("a: {} c += a: {}".format(a,c))

c *= a  # c = 45 * 20 = 900
print ("a: {} c *= a: {}".format(a,c))

c /= a # c = 900 / 20 = 45.0
print ("a: {} c /= a : {}".format(a,c))

c  = 2 # gán lại c = 2
print ("a: {} b: {} c : {}".format(a,b,c))
c %= a  # c = 2 % 20 = 2
print ("a: {} c %= a: {}".format(a,c))

c **= a # c = 2 ** 20 = 1048576
print ("a: {} c **= a: {}".format(a,c))

c //= a # c = 1048576 // 20 = 52428
print ("a: {} c //= a: {}".format(a,c))

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

Toán tử Bitwise trong Python

Toán tử Bitwise trong Python thực hiện các phép toán trên từng bit của số nhị phân. Các toán tử này thường được dùng để so sánh và thao tác trực tiếp trên các số nhị phân.

Dưới đây là bảng liệt kê các toán tử Bitwise cùng với ký hiệu, tên gọi và ví dụ minh họa:

Ví dụ cụ thể về các toán tử Bitwise trong Python

Để hiểu rõ hơn cách hoạt động của các toán tử này, chúng ta sẽ xét ví dụ sau. Trong đó, ta có hai số nguyên a và b và thực hiện các phép toán Bitwise:

a = 20            
b = 10            

print ('a=',a,':',bin(a),'b=',b,':',bin(b))
c = 0

c = a & b;        
print ("Kết quả của phép AND là ", c,':',bin(c))

c = a | b;     
print ("Kết quả của phép OR là ", c,':',bin(c))

c = a ^ b;        
print ("Kết quả của phép XOR là ", c,':',bin(c))

c = ~a;           
print ("Kết quả của phép NOT là ", c,':',bin(c))

c = a << 2;       
print ("Kết quả của phép DỊCH TRÁI là ", c,':',bin(c))

c = a >> 2;      
print ("Kết quả của phép DỊCH PHẢI là ", c,':',bin(c)) 

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

Toán tử logic trong Python

Toán tử logic trong Python được sử dụng để kết hợp hai hay nhiều điều kiện và kiểm tra kết quả cuối cùng của sự kết hợp đó. Python hỗ trợ một số toán tử logic cơ bản, chúng ta hãy cùng tìm hiểu.

Để dễ hình dung, chúng ta giả sử có hai biến a và b, với giá trị lần lượt là a = 10 và b = 20. Các toán tử logic sẽ hoạt động như sau:

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

Bây giờ chúng ta cùng xem một ví dụ cụ thể. Giả sử bạn có một biến diem_so đang giữ giá trị là 5:

diem_so = 5
print(diem_so > 3 and diem_so < 10) # Kiểm tra xem điểm_so có lớn hơn 3 và nhỏ hơn 10 hay không
print(diem_so > 3 or diem_so < 4) # Kiểm tra xem điểm_so có lớn hơn 3 hoặc nhỏ hơn 4 hay không
print(not (diem_so > 3 and diem_so < 10)) # Kiểm tra phủ định của biểu thức (điểm_so > 3 and điểm_so < 10)

Khi thực thi đoạn code trên, kết quả sẽ như sau:

True
True
False

Toán tử membership trong Python

Toán tử membership trong Python được dùng để kiểm tra xem một giá trị có nằm trong một chuỗi (sequence) hay không. Chuỗi ở đây có thể là các kiểu dữ liệu như chuỗi ký tự (string), danh sách (list), hoặc bộ (tuple).

Có hai toán tử membership chính trong Python:

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

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

danh_sach_hoc_sinh = ["Nam", "Lan", "Huy", "Mai"]
hoc_sinh_can_kiem_tra_1 = "Huy"
hoc_sinh_can_kiem_tra_2 = "An"

print("Danh sách học sinh:", danh_sach_hoc_sinh)

if hoc_sinh_can_kiem_tra_1 in danh_sach_hoc_sinh:
    print(f"{hoc_sinh_can_kiem_tra_1} có trong danh sách học sinh")
else:
    print(f"{hoc_sinh_can_kiem_tra_1} không có trong danh sách học sinh")

if hoc_sinh_can_kiem_tra_2 not in danh_sach_hoc_sinh:
    print(f"{hoc_sinh_can_kiem_tra_2} không có trong danh sách học sinh")
else:
     print(f"{hoc_sinh_can_kiem_tra_2} có trong danh sách học sinh")

diem_trung_binh_mon_toan = 7
if diem_trung_binh_mon_toan in danh_sach_hoc_sinh:
   print(f"Điểm trung bình {diem_trung_binh_mon_toan} có trong danh sách")
else:
   print (f"Điểm trung bình {diem_trung_binh_mon_toan} không có trong danh sách")

Khi chạy code này sẽ có kết quả như sau:

Toán tử Identity trong Python

Toán tử Identity trong Python dùng để so sánh vị trí bộ nhớ của hai đối tượng. Không giống như việc so sánh giá trị, các toán tử này xem xét liệu hai biến có đang tham chiếu đến cùng một đối tượng trong bộ nhớ hay không.

Có hai toán tử Identity, được mô tả chi tiết như sau:

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

Để làm rõ hơn cách các toán tử này hoạt động, ta xem xét ví dụ sau:

#Tạo một list (danh sách)
list_a = ["máy tính", "điện thoại", "máy tính bảng"]

# Tạo một list mới nhưng có các phần tử giống list_a
list_b = ["máy tính", "điện thoại", "máy tính bảng"]

#gán list_c cho list_a tức 2 biến cùng tham chiếu tới 1 vùng nhớ
list_c = list_a

print(list_a is list_c)
print(list_a is list_b)

print(list_a is not list_c)
print(list_a is not list_b)

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

Thứ tự ưu tiên của các toán tử trong Python

Trong Python, thứ tự ưu tiên của toán tử quyết định thứ tự mà các phép toán sẽ được thực hiện trong một biểu thức. Các toán tử khác nhau sẽ có mức độ ưu tiên khác nhau. Toán tử có độ ưu tiên cao hơn sẽ được thực hiện trước, toán tử có độ ưu tiên thấp hơn sẽ được thực hiện sau.

Ví dụ, khi gặp biểu thức 2 + 3 * 4, toán tử nhân (*) sẽ được thực hiện trước toán tử cộng (+) vì toán tử nhân có độ ưu tiên cao hơn. Do đó, kết quả của biểu thức trên sẽ là 2 + (3 * 4) = 2 + 12 = 14, chứ không phải là (2 + 3) * 4 = 5 * 4 = 20.

Lời kết

Chúng ta vừa cùng nhau khám phá chi tiết về các toán tử trong Python, từ toán tử số học, so sánh, gán, đến các toán tử bitwise, logic, membership và identity. Hiểu rõ cách thức hoạt động cũng như thứ tự ưu tiên của chúng sẽ giúp bạn viết code Python hiệu quả và chính xác hơn.