Các toán tử trong Python
Bài viết này giải thích các toán tử trong Python.
YouTube Video
Các toán tử trong Python
Python có nhiều loại toán tử, có thể được phân loại Tổng quát như sau. Chúng tôi sẽ giải thích các toán tử tiêu biểu cho mỗi loại.
Toán tử số học
Toán tử số học là các toán tử được sử dụng để thực hiện các phép tính trên các con số.
Toán tử | Ý nghĩa | Ví dụ |
---|---|---|
+ |
Phép cộng | 3 + 2 → 5 |
- |
Phép trừ | 3 - 2 → 1 |
* |
Phép nhân | 3 * 2 → 6 |
/ |
Phép chia (luôn cho kết quả số thực) | 3 / 2 → 1.5 |
// |
Phép chia lấy phần nguyên | 3 // 2 → 1 |
% |
Phép chia lấy dư (modulo) | 3 % 2 → 1 |
** |
Lũy thừa | 3 ** 2 → 9 |
1a = 10
2b = 3
3
4print(f"{a} + {b} = {a + b}") # Addition
5print(f"{a} - {b} = {a - b}") # Subtraction
6print(f"{a} * {b} = {a * b}") # Multiplication
7print(f"{a} / {b} = {a / b}") # Division (float)
8print(f"6 / 3 = {6 / 3}") # Division (float)
9print(f"{a} // {b} = {a // b}") # Floor Division
10print(f"{a} % {b} = {a % b}") # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}") # Exponentiation
- Ngoài bốn phép toán số học cơ bản, Python còn cung cấp các toán tử cho phép chia (
/
), phép chia lấy phần nguyên (//
), phép chia lấy dư (%
) và phép lũy thừa (**
). Phép chia trả về một số thực ngay cả khi chia hai số nguyên.
Toán tử gán
Các toán tử gán được sử dụng để gán giá trị cho biến.
Toán tử | Ý nghĩa | Ví dụ |
---|---|---|
= |
Gán | x = 5 |
+= |
Cộng rồi gán | x += 2 → x = x + 2 |
-= |
Trừ rồi gán | x -= 2 → x = x - 2 |
*= |
Nhân rồi gán | x *= 2 → x = x * 2 |
/= |
Chia rồi gán | x /= 2 → x = x / 2 |
//= |
Phép chia lấy phần nguyên | x //= 2 → x = x // 2 |
%= |
Gán phần dư | x %= 2 → x = x % 2 |
**= |
Gán lũy thừa | x **= 2 → x = x ** 2 |
&= |
Gán với toán tử AND | x &= 0b1010 → x = x & 0b1010 |
|= |
Gán với toán tử OR | x | = 0b0011 →x = x | 0b0011 |
^= |
Gán với toán tử XOR | x ^= 0b0101 → x = x ^ 0b0101 |
<<= |
Gán sau khi dịch sang trái | x <<= 2 → x = x << 2 |
>>= |
Gán sau khi dịch sang phải | x >>= 1 → x = x >> 1 |
:= |
Biểu thức gán (toán tử walrus) | if (n := len(data)) > 10: → Gán giá trị cho n trong khi đánh giá điều kiện |
1x = 5 # x = 5
2
3x += 3 # x = x + 3
4x -= 2 # x = x - 2
5x *= 4 # x = x * 4
6x /= 3 # x = x / 3
7x //= 2 # x = x // 2
8x %= 5 # x = x % 5
9x **= 3 # x = x ** 3
10
11x = 0b1100 # x = 0b1100 (12)
12
13x &= 0b1010 # x = x & 0b1010
14x |= 0b0011 # x = x | 0b0011
15x ^= 0b0101 # x = x ^ 0b0101
16x <<= 2 # x = x << 2
17x >>= 1 # x = x >> 1
18
19print(bin(x)) # Display in binary
20print(x) # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24 print(f"Length is {n}")
- Các toán tử gán cho phép kết hợp phép gán thông thường với các toán tử khác để gán kết quả.
- Toán tử walrus (
:=
) là một biểu thức gán có trong Python 3.8 trở về sau. - Trong khi phép gán thông thường chỉ có thể dùng như một câu lệnh, toán tử walrus cho phép gán trực tiếp trong một biểu thức.
Toán tử so sánh
Toán tử so sánh so sánh các giá trị và trả về True
hoặc False
.
Toán tử | Ý nghĩa | Ví dụ |
---|---|---|
== |
Bằng | 3 == 3 → True |
!= |
Không bằng | 3 != 4 → True |
> |
Lớn hơn | 5 > 2 |
< |
Nhỏ hơn | 5 < 2 |
>= |
Lớn hơn hoặc bằng | 5 >= 5 |
<= |
Nhỏ hơn hoặc bằng | 3 <= 4 |
1a = 10
2b = 20
3
4# Equal to (==)
5print(f"{a} == {b} -> {a == b}") # False: a and b are not equal
6print(f"3 == 3.0 -> {3 == 3.0}") # True: int and float with the same value are equal
7print(f"3 == '3' -> {3 == '3'}") # False: different types (int vs str)
8print(f"True == 1 -> {True == 1}") # True: True is equivalent to 1
9print(f"False == 0 -> {False == 0}") # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}") # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}") # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}") # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}") # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}") # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}") # True: a is less than or equal to 10
- Các toán tử so sánh dùng để so sánh thứ tự hoặc sự bằng nhau giữa hai giá trị và trả về
True
hoặcFalse
. - Trong Python, bạn nên cẩn thận khi so sánh các kiểu dữ liệu khác nhau. Một số kiểu dữ liệu có thể được so sánh với nhau, nhưng kết quả có thể không trực quan.
Toán tử logic
Toán tử logic được sử dụng để kết hợp các biểu thức logic.
Toán tử | Ý nghĩa | Ví dụ |
---|---|---|
and |
Trả về True nếu cả hai đều là True | True and False → False |
or |
Trả về True nếu một trong hai là True | True or False → True |
not |
Đảo ngược giá trị boolean | not True → False |
1x = 10
2print(x > 5 and x < 20) # True
3print(x < 5 or x > 20) # False
4print(not x == 10) # False
and
là một toán tử logic chỉ trả vềTrue
nếu cả hai điều kiện bên trái và bên phải đều làTrue
.or
là một toán tử logic trả vềTrue
nếu một trong hai điều kiện bên trái hoặc bên phải làTrue
.not
là một toán tử logic đảo ngược giá trị logic của một điều kiện. Nếu là True thì trở thành False, và nếu là False thì trở thành True.
Thứ tự ưu tiên của các toán tử logic
Các toán tử có thứ tự ưu tiên. Đây là quy tắc xác định toán tử nào được đánh giá trước trong một biểu thức. Các toán tử logic được đánh giá theo thứ tự: not
, and
, sau đó là or
.
1result = True or False and False
2print(result) # True
3
4result = (True or False) and False
5print(result) # False
たとえば、
Ở ví dụ đầu tiên, and
được đánh giá trước, nên False and False
trở thành False
, và kết quả là True or False
trở thành True
. Bạn cũng có thể thay đổi thứ tự đánh giá bằng cách sử dụng dấu ngoặc, như minh họa trong ví dụ thứ hai.
Toán tử bit
Toán tử thao tác bit thực hiện các phép toán trên cấp độ bit.
Toán tử | Ý nghĩa | Ví dụ |
---|---|---|
& |
AND theo bit | 5 & 3 → 1 |
| |
OR theo bit | 5 | 3 →7 |
^ |
Phép XOR (hoặc loại trừ) theo bit | 5 ^ 3 → 6 |
~ |
NOT theo bit | ~5 → -6 |
<< |
Dịch trái | 5 << 1 → 10 |
>> |
Dịch phải | 5 >> 1 → 2 |
1# Sample code for bitwise operators
2
3# Define two integers
4a = 5 # Binary: 0101
5b = 3 # Binary: 0011
6
7# Bitwise AND
8result_and = a & b # Binary: 0001 -> Decimal: 1
9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1 # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1 # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")
- Bạn có thể thực hiện các phép toán bit như AND, OR, XOR, NOT, cũng như các phép dịch bit. Bạn cũng có thể kết hợp chúng với các toán tử gán như
&=
.
Toán tử thành viên
Toán tử thuộc tính được sử dụng với các tập hợp như danh sách và từ điển.
1x = [1, 2, 3]
2y = 2
3z = 4
4
5print("y in x : ", y in x) # Result is True
6print("z in x : ", z in x) # Result is False
7
8print("y not in x : ", y not in x) # Result is False
9print("z not in x : ", z not in x) # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ", "world" in text) # True
13print("'python' not in 'hello world' : ", "python" not in text) # True
- Toán tử
in
được sử dụng để xác định liệu một giá trị cụ thể có nằm trong một dãy như danh sách hoặc chuỗi, hoặc một tập hợp như từ điển hay không. - Toán tử
not in
được sử dụng để xác định liệu một giá trị cụ thể không nằm trong một dãy hoặc tập hợp nào đó.
Toán tử danh tính
Toán tử nhận dạng kiểm tra danh tính của các đối tượng.
1x = [1, 2, 3]
2y = x
3z = x.copy()
4
5print("x is y : ", x is y) # Result is True
6print("x is z : ", x is z) # Result is False
7
8print("x is not y : ", x is not y) # Result is False
9print("x is not z : ", x is not z) # Result is True
10
11print("x == y : ", x == y) # Result is True
12print("x == z : ", x == z) # Result is True
- Toán tử
is
kiểm tra hai đối tượng có phải là cùng một đối tượng (tức là tham chiếu cùng một vùng nhớ) hay không. - Toán tử
is not
kiểm tra hai đối tượng có phải là khác nhau hay không. - Ví dụ,
x is y
khác vớix == y
ở chỗ nó kiểm tra định danh đối tượng, không phải sự bằng nhau về giá trị.
Kiểm tra kiểu dữ liệu
Trong Python, bạn sử dụng hàm isinstance()
để kiểm tra xem một giá trị có thuộc kiểu dữ liệu cụ thể không. Bạn cũng có thể sử dụng hàm type()
để kiểm tra chính xác kiểu dữ liệu của một biến. Mặc dù những cái này không phải là toán tử, chúng là các cơ chế cơ bản để kiểm tra kiểu dữ liệu.
1x = 10
2print(isinstance(x, int)) # True
3
4y = "hello"
5print(isinstance(y, str)) # True
6
7z = [1, 2, 3]
8print(isinstance(z, list)) # True
9
10print(type(10)) # <class 'int'>
11print(type("hello")) # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int)) # True
14print("type(3) is int : ", type(3) is int) # True
15print("type(True) is bool : ", type(True) is bool) # True
isinstance()
là một hàm kiểm tra xem một đối tượng có phải là instance của một lớp xác định hoặc lớp con của nó hay không.type()
là một hàm trả về kiểu (class) chính xác của một đối tượng. Nó thường được sử dụng khi bạn muốn so sánh kiểu dữ liệu một cách nghiêm ngặt.isinstance()
tính đến mối quan hệ kế thừa, trong khitype()
kiểm tra sự khớp chính xác.
Tóm tắt
Khi sử dụng từng toán tử, bạn cần chọn phù hợp dựa trên mục đích và kiểu dữ liệu của nó. Vì Python là ngôn ngữ kiểu động, kết quả của một phép toán có thể thay đổi tùy thuộc vào kiểu dữ liệu đang được tính toán.
Bạn có thể làm theo bài viết trên bằng cách sử dụng Visual Studio Code trên kênh YouTube của chúng tôi. Vui lòng ghé thăm kênh YouTube.