Sau khi hoàn thành hướng dẫn trước đây của chúng tôi về các biến Python trong loạt bài này, giờ đây bạn nên nắm bắt tốt việc tạo và đặt tên các đối tượng Python thuộc các loại khác nhau. Hãy để một số công việc với họ!
Ở đây, những gì bạn sẽ học được trong hướng dẫn này: Bạn sẽ thấy cách tính toán có thể được thực hiện trên các đối tượng trong Python. Đến cuối hướng dẫn này, bạn sẽ có thể tạo các biểu thức phức tạp bằng cách kết hợp các đối tượng và toán tử. You’ll see how calculations can be performed on objects in Python. By the end of this tutorial, you will be able to create complex expressions by combining objects and operators.
Trong Python, các nhà khai thác là các biểu tượng đặc biệt chỉ định rằng một số loại tính toán nên được thực hiện. Các giá trị mà một toán tử hoạt động được gọi là toán hạng.operands.
Đây là một ví dụ:
>>>
>>> a = 10
>>> b = 20
>>> a + b
30
Trong trường hợp này, toán tử
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
2 thêm các toán hạng >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 và >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4 cùng nhau. Một toán hạng có thể là một giá trị theo nghĩa đen hoặc một biến tham chiếu một đối tượng:>>>
>>> a = 10
>>> b = 20
>>> a + b - 5
25
Trong trường hợp này, toán tử
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
2 thêm các toán hạng >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 và >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4 cùng nhau. Một toán hạng có thể là một giá trị theo nghĩa đen hoặc một biến tham chiếu một đối tượng:Một chuỗi các toán hạng và toán tử, như >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
5, được gọi là một biểu thức. Python hỗ trợ nhiều toán tử để kết hợp các đối tượng dữ liệu thành các biểu thức. Chúng được khám phá dưới đây.
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
Toán tử số học
Kết quả | ________ 42 & nbsp; [Unary] | 7
| Không tích cực In other words, it doesn’t really do anything. It mostly exists for the sake of completeness, to complement Unary Negation. |
3 Trong các từ khác, nó không thực sự làm bất cứ điều gì. Nó chủ yếu tồn tại vì lợi ích của sự hoàn chỉnh, để bổ sung cho sự phủ định không. | ________ 42 & nbsp; [nhị phân] | 0
| Phép cộng |
Tổng của 3 và 4 | ________ 53 & nbsp; [Unary] | 4
| Không phủ định |
Giá trị bằng 3 nhưng đối diện trong dấu hiệu | ________ 53 & nbsp; [nhị phân] | 7
| Phép trừ |
4 bị trừ khỏi 3 | 0 | 1
| Phép nhân |
Sản phẩm của 3 và 4 | 4 | 5
| Phân công The result always has type 8.
|
Chỉ số khi 3 được chia cho 4. Kết quả luôn có loại 8. | 9 | 0
| Modulo |
Còn lại khi 3 được chia cho 4 | 3 | 4 [also called Integer Division]
| Phân chia sàn [còn được gọi là phân chia số nguyên] |
Chỉ số khi 3 được chia cho 4, được làm tròn vào số tổng thể nhỏ nhất tiếp theo | 7 | 8
| Số mũ |
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 được nâng lên đến sức mạnh của >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
Dưới đây là một số ví dụ về các nhà khai thác này đang sử dụng:
>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
Kết quả của sự phân chia tiêu chuẩn [
>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
4] luôn là >>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
8, ngay cả khi cổ tức chia đều cho các ước số:>>>
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
Khi kết quả của sự phân chia sàn [
>>> x = 1.1 + 2.2
>>> x == 3.3
False
3] là dương, như thể phần phân số bị cắt bỏ, chỉ để lại phần nguyên. Khi kết quả là âm, kết quả được làm tròn xuống số nguyên nhỏ nhất [âm hơn] tiếp theo:>>>
>>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106
Lưu ý, nhân tiện, trong một phiên thay thế, bạn có thể hiển thị giá trị của một biểu thức bằng cách nhập nó vào dấu nhắc >>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
7
Không tích cực
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 Trong các từ khác, nó không thực sự làm bất cứ điều gì. Nó chủ yếu tồn tại vì lợi ích của sự hoàn chỉnh, để bổ sung cho sự phủ định không.________ 42 & nbsp; [nhị phân] >>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106
0
Phép cộng
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
Tổng của >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 và >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4 ________ 53 & nbsp; [Unary] >>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106
4
Không phủ định
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
Giá trị bằng >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 nhưng đối diện trong dấu hiệu ________ 53 & nbsp; [nhị phân] >>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106
7
Phép trừ
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4 bị trừ khỏi >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
0>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
1
Phép nhân
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
Sản phẩm của >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 và >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4 >>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
4>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
5
Phân công
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 Trong các từ khác, nó không thực sự làm bất cứ điều gì. Nó chủ yếu tồn tại vì lợi ích của sự hoàn chỉnh, để bổ sung cho sự phủ định không.>>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106
0
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 và >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4>>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106
4
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 nhưng đối diện trong dấu hiệu>>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106
7
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4 bị trừ khỏi >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
0>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
1
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 và >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
4>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
5
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 otherwise
Chỉ số khi
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 được chia cho >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4. Kết quả luôn có loại >>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
8.>>>
>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
9>>> x = 1.1 + 2.2
>>> x == 3.3
False
0
>>> x = 1.1 + 2.2
>>> x == 3.3
False
Modulo
>>>
>>> x = 1.1 + 2.2
>>> x == 3.3
False
Còn lại khi
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 được chia cho >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4>>> x = 1.1 + 2.2
>>> x == 3.3
False
3>>>
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> x = 1.1 + 2.2
>>> x == 3.3
False
4Toán tử logic
Các toán tử logic
>>> a = 10
>>> b = 20
>>> a + b - 5
25
28, >>> a = 10
>>> b = 20
>>> a + b - 5
25
29 và >>> a = 10
>>> b = 20
>>> a + b - 5
25
30 sửa đổi và kết hợp các biểu thức với nhau được đánh giá trong bối cảnh Boolean để tạo ra các điều kiện phức tạp hơn.Biểu thức logic liên quan đến toán hạng boolean
Như bạn đã thấy, một số đối tượng và biểu thức trong Python thực sự thuộc loại Boolean. Đó là, chúng bằng một trong các đối tượng Python
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1. Xem xét các ví dụ sau:>>>
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
Trong các ví dụ trên,
>>> a = 10
>>> b = 20
>>> a + b - 5
25
33, >>> a = 10
>>> b = 20
>>> a + b - 5
25
34 và >>> a = 10
>>> b = 20
>>> a + b - 5
25
35 đều là các đối tượng hoặc biểu thức boolean.Giải thích các biểu thức logic liên quan đến
>>> a = 10
>>> b = 20
>>> a + b - 5
25
28, >>> a = 10
>>> b = 20
>>> a + b - 5
25
29 và >>> a = 10
>>> b = 20
>>> a + b - 5
25
30 rất đơn giản khi các vở opera được boolean:
28 | 40 | 25 là 1 1 nếu 25 là ________ 88 [đảo ngược về mặt logic về ý nghĩa của 25] 1 if 25 is 25]
|
29 | 49 | 25 hoặc 52 là 1 khác 1 otherwise
|
30 | 56 | 25 và 52 là 1 khác 1 otherwise
|
Hãy xem cách họ làm việc trong thực tế dưới đây.
Cấm >>> a = 10
>>> b = 20
>>> a + b - 5
25
28 và các hoạt động boolean
>>> a = 10
>>> b = 20
>>> a + b - 5
25
>>> a = 10
>>> b = 20
>>> a + b - 5
25
0
Biểu thức logic | 33 | 65 | |
1 | 65 | 1 | 33 |
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> a = 10
>>> b = 20
>>> a + b - 5
25
1
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> a = 10
>>> b = 20
>>> a + b - 5
25
Biểu thức logic | 33 | 1 | 65 | 1 | 33 |
65 | 1 | 65 | 1 | 65 |
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
>>> a = 10
>>> b = 20
>>> a + b - 5
25
2
Biểu thức logic | 33 | 1 | 65 | 1 | 65 |
Biểu thức logic | 33 | 33 | 33 |
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> a = 10
>>> b = 20
>>> a + b - 5
25
65
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> a = 10
>>> b = 20
>>> a + b - 5
25
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1>>> a = 10
>>> b = 20
>>> a + b - 5
25
34
69>>> a = 10 >>> b = 20 >>> a + b - 5 25
- “
29 và các hoạt động boolean>>> a = 10 >>> b = 20 >>> a + b - 5 25
76>>> a = 10 >>> b = 20 >>> a + b - 5 25
78>>> a = 10 >>> b = 20 >>> a + b - 5 25
82>>> a = 10 >>> b = 20 >>> a + b - 5 25
“
>>> a = 10
>>> b = 20
>>> a + b - 5
25
30 và các hoạt động boolean>>> a = 10
>>> b = 20
>>> a + b - 5
25
89>>> a = 10
>>> b = 20
>>> a + b - 5
25
93
>>> a = 10
>>> b = 20
>>> a + b - 5
25
95>>> a = 10 >>> b = 20 >>> a + b - 5 25
A non-zero value is true.
>>>
>>> a = 10
>>> b = 20
>>> a + b - 5
25
3Đánh giá các giá trị phi Boolean trong bối cảnh Boolean
Nhiều đối tượng và biểu thức không bằng
1. Tuy nhiên, chúng vẫn có thể được đánh giá trong bối cảnh Boolean và được xác định là sự thật của người Hồi giáo hay giả tưởng.>>> tolerance = 0.00001 >>> x = 1.1 + 2.2 >>> abs[x - 3.3] >> x = 5 >>> x >> type[x >> t = x > 10 >>> t False >>> type[t] >>> callable[x] False >>> type[callable[x]] >>> t = callable[len] >>> t True >>> type[t]
A non-empty string is true.
>>>
>>> a = 10
>>> b = 20
>>> a + b - 5
25
4Vậy điều gì là đúng và cái gì là? Như một câu hỏi triết học, nằm ngoài phạm vi của hướng dẫn này!
Nhưng trong Python, nó được xác định rõ. Tất cả những điều sau đây được coi là sai khi được đánh giá trong bối cảnh Boolean:
Giá trị boolean
1>>> x = 5 >>> x >> type[x >> t = x > 10 >>> t False >>> type[t] >>> callable[x] False >>> type[callable[x]] >>> t = callable[len] >>> t True >>> type[t]
Bất kỳ giá trị nào bằng số 0 [
00,>>> a = 4 >>> b = 3 >>> +a 4 >>> -b -3 >>> a + b 7 >>> a - b 1 >>> a * b 12 >>> a / b 1.3333333333333333 >>> a % b 1 >>> a ** b 64
01,>>> a = 4 >>> b = 3 >>> +a 4 >>> -b -3 >>> a + b 7 >>> a - b 1 >>> a * b 12 >>> a / b 1.3333333333333333 >>> a % b 1 >>> a ** b 64
02]>>> a = 4 >>> b = 3 >>> +a 4 >>> -b -3 >>> a + b 7 >>> a - b 1 >>> a * b 12 >>> a / b 1.3333333333333333 >>> a % b 1 >>> a ** b 64
>>>
>>> a = 10
>>> b = 20
>>> a + b - 5
25
5Một chuỗi trống
Một đối tượng của một kiểu dữ liệu tổng hợp tích hợp trống [xem bên dưới]
Giá trị đặc biệt được ký hiệu là từ khóa Python >>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
03
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
Hầu như bất kỳ đối tượng nào khác được xây dựng vào Python đều được coi là đúng.
Bạn có thể xác định độ thật của người Viking về một đối tượng hoặc biểu thức với chức năng >>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
04 tích hợp. >>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
04 trả về >>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1 nếu nó là giả.
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
Giá trị số
Một chuỗi trống là sai. Một chuỗi không trống là đúng. | 65 |
1 | 33 |
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >>>>> a = 10
>>> b = 20
>>> a + b - 5
25
6
>>> a = 10
>>> b = 20
>>> a + b - 5
25
65
>>> a = 10
>>> b = 20
>>> a + b - 5
25
>>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1
Một chuỗi trống là sai. Một chuỗi không trống là đúng. | Đối tượng dữ liệu tổng hợp tích hợp |
Python cung cấp các loại dữ liệu tổng hợp tích hợp được gọi là 08, 09, 10 và 11. Đây là những loại container của người Viking có chứa các đối tượng khác. Một đối tượng của một trong những loại này được coi là sai nếu nó trống và đúng nếu nó không trống. | Các ví dụ dưới đây chứng minh điều này cho loại 08. [Danh sách được xác định trong Python với dấu ngoặc vuông.] |
Để biết thêm thông tin về các loại
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
08, >>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
09, >>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
10 và >>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
11, hãy xem các hướng dẫn sắp tới.>>>
>>> a = 10
>>> b = 20
>>> a + b - 5
25
7Từ khóa của ____ ____203
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
03 luôn sai:
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
Biểu thức logic liên quan đến toán hạng không phải là Boolean
Một chuỗi trống là sai. Một chuỗi không trống là đúng. | 52 |
"Falsy" | 25 |
>>>
>>> a = 10
>>> b = 20
>>> a + b - 5
25
8Như với
>>> a = 10
>>> b = 20
>>> a + b - 5
25
29, biểu thức >>> a = 10
>>> b = 20
>>> a + b - 5
25
56 không đánh giá thành >>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1, mà thay vào đó là một trong các >>> a = 10
>>> b = 20
>>> a + b - 5
25
25 hoặc >>> a = 10
>>> b = 20
>>> a + b - 5
25
52. >>> a = 10
>>> b = 20
>>> a + b - 5
25
56 sẽ là sự thật nếu cả >>> a = 10
>>> b = 20
>>> a + b - 5
25
25 và >>> a = 10
>>> b = 20
>>> a + b - 5
25
52 đều là sự thật, và những kẻ giả mạo khác.Biểu thức hợp lý và đánh giá ngắn mạch
Cho đến nay, bạn đã thấy các biểu thức chỉ với một toán tử
>>> a = 10
>>> b = 20
>>> a + b - 5
25
29 hoặc >>> a = 10
>>> b = 20
>>> a + b - 5
25
30 và hai toán hạng:Nhiều toán tử logic và toán hạng có thể được xâu chuỗi lại với nhau để tạo thành các biểu thức hợp chất.
Hợp chất “>>> a = 10
>>> b = 20
>>> a + b - 5
25
29”
>>> a = 10
>>> b = 20
>>> a + b - 5
25
Xem xét các biểu thức sau:
x1
29 x2>>> a = 10 >>> b = 20 >>> a + b - 5 25
29 x3>>> a = 10 >>> b = 20 >>> a + b - 5 25
29>>> a = 10 >>> b = 20 >>> a + b - 5 25
29 x2>>> a = 10 >>> b = 20 >>> a + b - 5 25
29 x3>>> a = 10 >>> b = 20 >>> a + b - 5 25
29 … xn>>> a = 10 >>> b = 20 >>> a + b - 5 25
Biểu thức này là đúng nếu bất kỳ XI nào là đúng.xi are true.
Trong một biểu hiện như thế này, Python sử dụng một phương pháp gọi là đánh giá ngắn mạch, còn được gọi là đánh giá McCarthy để vinh danh nhà khoa học máy tính John McCarthy. Các toán hạng XI được đánh giá theo thứ tự từ trái sang phải. Ngay khi một người được tìm thấy là đúng, toàn bộ biểu thức được biết là đúng. Tại thời điểm đó, Python dừng lại và không có điều khoản nào được đánh giá. Giá trị của toàn bộ biểu thức là của XI chấm dứt đánh giá.xi operands are evaluated in order from left to right. As soon as one is found to be true, the entire expression is known to be true. At that point, Python stops and no more terms are evaluated. The value of the entire expression is that of the xi that terminated evaluation.
Để giúp chứng minh đánh giá ngắn mạch, giả sử rằng bạn có chức năng nhận dạng đơn giản trên mạng
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
67 hoạt động như sau:
67 có một đối số duy nhất.>>> a = 4 >>> b = 3 >>> +a 4 >>> -b -3 >>> a + b 7 >>> a - b 1 >>> a * b 12 >>> a / b 1.3333333333333333 >>> a % b 1 >>> a ** b 64
- Nó hiển thị đối số cho bảng điều khiển.
- Nó trả về đối số được chuyển cho nó dưới dạng giá trị trả về của nó.
[Bạn sẽ thấy cách xác định một chức năng như vậy trong hướng dẫn sắp tới về các chức năng.]
Một số cuộc gọi ví dụ đến
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
67 được hiển thị bên dưới:>>>
>>> a = 10
>>> b = 20
>>> a + b - 5
25
9Như với
>>> a = 10
>>> b = 20
>>> a + b - 5
25
29, biểu thức >>> a = 10
>>> b = 20
>>> a + b - 5
25
56 không đánh giá thành >>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1, mà thay vào đó là một trong các >>> a = 10
>>> b = 20
>>> a + b - 5
25
25 hoặc >>> a = 10
>>> b = 20
>>> a + b - 5
25
52. >>> a = 10
>>> b = 20
>>> a + b - 5
25
56 sẽ là sự thật nếu cả >>> a = 10
>>> b = 20
>>> a + b - 5
25
25 và >>> a = 10
>>> b = 20
>>> a + b - 5
25
52 đều là sự thật, và những kẻ giả mạo khác.Biểu thức hợp lý và đánh giá ngắn mạch
>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
0Như với
>>> a = 10
>>> b = 20
>>> a + b - 5
25
29, biểu thức >>> a = 10
>>> b = 20
>>> a + b - 5
25
56 không đánh giá thành >>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1, mà thay vào đó là một trong các >>> a = 10
>>> b = 20
>>> a + b - 5
25
25 hoặc >>> a = 10
>>> b = 20
>>> a + b - 5
25
52. >>> a = 10
>>> b = 20
>>> a + b - 5
25
56 sẽ là sự thật nếu cả >>> a = 10
>>> b = 20
>>> a + b - 5
25
25 và >>> a = 10
>>> b = 20
>>> a + b - 5
25
52 đều là sự thật, và những kẻ giả mạo khác.Biểu thức hợp lý và đánh giá ngắn mạch
Cho đến nay, bạn đã thấy các biểu thức chỉ với một toán tử >>> a = 10
>>> b = 20
>>> a + b - 5
25
29 hoặc >>> a = 10
>>> b = 20
>>> a + b - 5
25
30 và hai toán hạng:
>>> a = 10
>>> b = 20
>>> a + b - 5
25
>>> a = 10
>>> b = 20
>>> a + b - 5
25
Nhiều toán tử logic và toán hạng có thể được xâu chuỗi lại với nhau để tạo thành các biểu thức hợp chất.
Hợp chất “
29”>>> a = 10 >>> b = 20 >>> a + b - 5 25
30 x2>>> a = 10 >>> b = 20 >>> a + b - 5 25
30 x3>>> a = 10 >>> b = 20 >>> a + b - 5 25
30 … xn>>> a = 10 >>> b = 20 >>> a + b - 5 25
Xem xét các biểu thức sau:xi are true.
x1
>>> a = 10
>>> b = 20
>>> a + b - 5
25
29 x2 >>> a = 10
>>> b = 20
>>> a + b - 5
25
29 x3 >>> a = 10
>>> b = 20
>>> a + b - 5
25
29>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
1Như với
>>> a = 10
>>> b = 20
>>> a + b - 5
25
29, biểu thức >>> a = 10
>>> b = 20
>>> a + b - 5
25
56 không đánh giá thành >>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs[x - 3.3] >> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1, mà thay vào đó là một trong các >>> a = 10
>>> b = 20
>>> a + b - 5
25
25 hoặc >>> a = 10
>>> b = 20
>>> a + b - 5
25
52. >>> a = 10
>>> b = 20
>>> a + b - 5
25
56 sẽ là sự thật nếu cả >>> a = 10
>>> b = 20
>>> a + b - 5
25
25 và >>> a = 10
>>> b = 20
>>> a + b - 5
25
52 đều là sự thật, và những kẻ giả mạo khác.Biểu thức hợp lý và đánh giá ngắn mạch
>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
2Cho đến nay, bạn đã thấy các biểu thức chỉ với một toán tử >>> a = 10
>>> b = 20
>>> a + b - 5
25
29 hoặc >>> a = 10
>>> b = 20
>>> a + b - 5
25
30 và hai toán hạng:
>>> a = 10
>>> b = 20
>>> a + b - 5
25
>>> a = 10
>>> b = 20
>>> a + b - 5
25
Nhiều toán tử logic và toán hạng có thể được xâu chuỗi lại với nhau để tạo thành các biểu thức hợp chất.
Hợp chất “>>> a = 10
>>> b = 20
>>> a + b - 5
25
29”
>>> a = 10
>>> b = 20
>>> a + b - 5
25
Xem xét các biểu thức sau:
>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
3x1
>>> a = 10
>>> b = 20
>>> a + b - 5
25
29 x2 >>> a = 10
>>> b = 20
>>> a + b - 5
25
29 x3 >>> a = 10
>>> b = 20
>>> a + b - 5
25
29>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
4Biểu thức này là đúng nếu bất kỳ XI nào là đúng.
>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
5Trong một biểu hiện như thế này, Python sử dụng một phương pháp gọi là đánh giá ngắn mạch, còn được gọi là đánh giá McCarthy để vinh danh nhà khoa học máy tính John McCarthy. Các toán hạng XI được đánh giá theo thứ tự từ trái sang phải. Ngay khi một người được tìm thấy là đúng, toàn bộ biểu thức được biết là đúng. Tại thời điểm đó, Python dừng lại và không có điều khoản nào được đánh giá. Giá trị của toàn bộ biểu thức là của XI chấm dứt đánh giá.
Để giúp chứng minh đánh giá ngắn mạch, giả sử rằng bạn có chức năng nhận dạng đơn giản trên mạng
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
67 hoạt động như sau:>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
6Chọn một giá trị mặc định
Một thành ngữ khác liên quan đến việc chọn giá trị mặc định khi giá trị được chỉ định bằng 0 hoặc trống. Ví dụ: giả sử bạn muốn gán một biến
>>> 10 / 5
2.0
>>> type[10 / 5]
10 cho giá trị có trong một biến khác gọi là >>> 10 / 5
2.0
>>> type[10 / 5]
11. Nhưng nếu >>> 10 / 5
2.0
>>> type[10 / 5]
11 trống, bạn muốn cung cấp một giá trị mặc định.Dưới đây là một cách ngắn gọn để thể hiện điều này bằng cách sử dụng đánh giá ngắn mạch:
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
7Nếu
>>> 10 / 5
2.0
>>> type[10 / 5]
11 là không trống, đó là sự thật và biểu thức >>> 10 / 5
2.0
>>> type[10 / 5]
14 sẽ đúng vào thời điểm đó. Đánh giá dừng và giá trị của >>> 10 / 5
2.0
>>> type[10 / 5]
11 được trả về và được gán cho >>> 10 / 5
2.0
>>> type[10 / 5]
10:>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
8Mặt khác, nếu
>>> 10 / 5
2.0
>>> type[10 / 5]
11 là một chuỗi trống, nó là giả. Đánh giá của >>> 10 / 5
2.0
>>> type[10 / 5]
14 tiếp tục cho toán hạng tiếp theo, >>> 10 / 5
2.0
>>> type[10 / 5]
19, được trả lại và gán cho >>> 10 / 5
2.0
>>> type[10 / 5]
10:>>>
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
9Mặt khác, nếu >>> 10 / 5
2.0
>>> type[10 / 5]
11 là một chuỗi trống, nó là giả. Đánh giá của >>> 10 / 5
2.0
>>> type[10 / 5]
14 tiếp tục cho toán hạng tiếp theo, >>> 10 / 5
2.0
>>> type[10 / 5]
19, được trả lại và gán cho >>> 10 / 5
2.0
>>> type[10 / 5]
10:
>>> 10 / 5
2.0
>>> type[10 / 5]
>>> 10 / 5
2.0
>>> type[10 / 5]
>>> 10 / 5
2.0
>>> type[10 / 5]
>>> 10 / 5
2.0
>>> type[10 / 5]
So sánh chuỗi
>>> 10 / 5
2.0
>>> type[10 / 5]
0Các toán tử so sánh có thể được xích lại với nhau theo chiều dài tùy ý. Ví dụ, các biểu thức sau đây gần như tương đương:
Cả hai sẽ đánh giá theo cùng một giá trị boolean. Sự khác biệt tinh tế giữa hai là trong so sánh chuỗi
>>> 10 / 5
2.0
>>> type[10 / 5]
21, >>> a = 10
>>> b = 20
>>> a + b - 5
25
52 chỉ được đánh giá một lần. Biểu thức dài hơn >>> 10 / 5
2.0
>>> type[10 / 5]
23 sẽ khiến >>> a = 10
>>> b = 20
>>> a + b - 5
25
52 được đánh giá hai lần.op1, op2, …, opn are comparison operators, then the following have the same Boolean value:Tổng quát hơn, nếu op1, op2, thì, opn là các toán tử so sánh, thì sau đây có cùng giá trị boolean:op1 x2 op2 x3 … xn-1 opn xn
x1 op1 x2 op2 x3 xn xn-1 opn xnop1 x2
30 x2 op2 x3>>> a = 10 >>> b = 20 >>> a + b - 5 25
30 … xn-1 opn xn>>> a = 10 >>> b = 20 >>> a + b - 5 25
x1 op1 x2
>>> a = 10
>>> b = 20
>>> a + b - 5
25
30 x2 op2 x3 >>> a = 10
>>> b = 20
>>> a + b - 5
25
30Trong trường hợp trước, mỗi XI chỉ được đánh giá một lần. Trong trường hợp sau, mỗi lần sẽ được đánh giá hai lần ngoại trừ lần đầu tiên và cuối cùng, trừ khi đánh giá ngắn mạch gây ra sự chấm dứt sớm.
Các nhà khai thác bitwise
Kết quả | 27 | 28AND
| bitwise vàAND of the bits in the corresponding position of the operands. [ 80 if both are 80, otherwise 00.]
|
Mỗi vị trí bit trong kết quả là logic và của các bit ở vị trí tương ứng của các toán hạng. [ 80 Nếu cả hai đều là 80, nếu không thì 00.] | 32 | 33OR
| bitwise hoặcOR of the bits in the corresponding position of the operands. [ 80 if either is 80, otherwise 00.]
|
Mỗi vị trí bit trong kết quả là logic hoặc của các bit ở vị trí tương ứng của các toán hạng. [ 80 Nếu là 80, nếu không thì 00.] | 37 | 38negation
| tiêu cực bitwise |
Mỗi vị trí bit trong kết quả là sự phủ định logic của bit ở vị trí tương ứng của toán hạng. [ 80 nếu 00, 00 nếu 80.] | 43 | 44XOR [exclusive OR]
| BitWise XOR [độc quyền hoặc]XOR of the bits in the corresponding position of the operands. [ 80 if the bits in the operands are different, 00 if they are the same.]
|
Mỗi vị trí bit trong kết quả là XOR logic của các bit ở vị trí tương ứng của các toán hạng. [ 80 Nếu các bit trong toán hạng là khác nhau, 00 nếu chúng giống nhau.] | 47 | 48 49 places
| Chuyển đổi đúng 49 vị trí |
Mỗi bit được thay đổi đúng 49 vị trí. | 51 | 52 49 places
| Chuyển sang trái 49 Vị trí |
Mỗi bit được thay đổi bên trái
>>> 10 / 5
2.0
>>> type[10 / 5]
49 vị trí.>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
1Dưới đây là một số ví dụ:
Người vận hành danh tính
Python cung cấp hai toán tử,
>>> 10 / 5
2.0
>>> type[10 / 5]
55 và >>> 10 / 5
2.0
>>> type[10 / 5]
56, xác định xem các toán hạng đã cho có cùng một danh tính hay không, hãy tham khảo cùng một đối tượng. Đây không giống như sự bình đẳng, có nghĩa là hai toán hạng đề cập đến các đối tượng chứa cùng một dữ liệu nhưng không nhất thiết là cùng một đối tượng.>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
2Dưới đây là một ví dụ về hai đối tượng bằng nhau nhưng không giống nhau:
>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
3Ở đây,
>>> a = 10
>>> b = 20
>>> a + b - 5
25
25 và >>> a = 10
>>> b = 20
>>> a + b - 5
25
52 đều đề cập đến các đối tượng có giá trị là >>> 10 / 5
2.0
>>> type[10 / 5]
59. Họ đều bình đẳng. Nhưng họ không tham khảo cùng một đối tượng, như bạn có thể xác minh:>>> a = 10
>>> b = 20
>>> a + b - 5
25
25 và >>> a = 10
>>> b = 20
>>> a + b - 5
25
52 không có cùng danh tính và >>> 10 / 5
2.0
>>> type[10 / 5]
62 trả về >>> x = 5
>>> x >> type[x >> t = x > 10
>>> t
False
>>> type[t]
>>> callable[x]
False
>>> type[callable[x]]
>>> t = callable[len]
>>> t
True
>>> type[t]
1.
>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
4Trước đây, bạn đã thấy rằng khi bạn thực hiện một bài tập như
>>> 10 / 5
2.0
>>> type[10 / 5]
64, Python chỉ tạo ra một tham chiếu thứ hai cho cùng một đối tượng và bạn có thể xác nhận thực tế đó với hàm >>> 10 / 5
2.0
>>> type[10 / 5]
65. Bạn cũng có thể xác nhận nó bằng toán tử >>> 10 / 5
2.0
>>> type[10 / 5]
55:Trong trường hợp này, vì
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 và >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4 tham chiếu cùng một đối tượng, nên lý do là >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
3 và >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
4 cũng sẽ bằng nhau.>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
5Không có gì đáng ngạc nhiên, điều ngược lại với >>> 10 / 5
2.0
>>> type[10 / 5]
55 là >>> 10 / 5
2.0
>>> type[10 / 5]
56:
>>> 10 / 5
2.0
>>> type[10 / 5]
>>> 10 / 5
2.0
>>> type[10 / 5]
ưu tiên điều hành
Xem xét biểu thức này:
Có sự mơ hồ ở đây. Python có nên thực hiện bổ sung
>>> 10 / 5
2.0
>>> type[10 / 5]
73 trước và sau đó nhân tổng số >>> 10 / 5
2.0
>>> type[10 / 5]
74 không? Hoặc phép nhân >>> 10 / 5
2.0
>>> type[10 / 5]
75 nên được thực hiện trước tiên và việc bổ sung >>> 10 / 5
2.0
>>> type[10 / 5]
76 giây?Tất cả các nhà khai thác rằng các hỗ trợ ngôn ngữ được gán ưu tiên. Trong một biểu thức, tất cả các toán tử ưu tiên cao nhất được thực hiện đầu tiên. Khi những kết quả đó thu được, các toán tử của mức ưu tiên cao nhất tiếp theo được thực hiện. Vì vậy, nó tiếp tục, cho đến khi biểu thức được đánh giá đầy đủ. Bất kỳ toán tử nào được ưu tiên bằng nhau đều được thực hiện theo thứ tự từ trái sang phải.
Dưới đây là thứ tự ưu tiên của các nhà khai thác Python mà bạn đã thấy cho đến nay, từ thấp nhất đến cao nhất:
ưu tiên thấp nhất | 29 | Boolean hoặc |
30 | Boolean và | |
28 | Boolean không | |
2, 8, 04, 10, 16, 55, 56 | So sánh, bản sắc | |
32 | bitwise hoặc | |
43 | BitWise XOR | |
27 | bitwise và | |
51, 47 | Bit thay đổi | |
2, 3 | Ngoài ra, trừ | |
0, 4, 3, 9 | phép nhân, phân chia, phân chia sàn, modulo | |
01, 02, 03 | không tích cực, phủ định không, phủ định bitwise | |
ưu tiên cao nhất | 7 | số mũ |
Các nhà khai thác ở đầu bảng có ưu tiên thấp nhất và những người ở dưới cùng của bảng có cao nhất. Bất kỳ toán tử nào trong cùng một hàng của bảng đều có ưu tiên bằng nhau.
Rõ ràng lý do tại sao phép nhân được thực hiện đầu tiên trong ví dụ trên: phép nhân có ưu tiên cao hơn so với bổ sung.
Tương tự, trong ví dụ dưới đây,
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
05 được nâng lên thành công suất của >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
06 trước tiên, tương đương với >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
07, và sau đó các phép nhân được thực hiện theo thứ tự từ trái sang phải [>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
08]:>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
6Tiết kiệm ưu tiên có thể được ghi đè bằng dấu ngoặc đơn. Các biểu thức trong ngoặc đơn luôn được thực hiện trước tiên, trước khi các biểu thức không được đặt dấu ngoặc đơn. Do đó, điều sau đây xảy ra:
>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
7>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
8Tiết kiệm ưu tiên có thể được ghi đè bằng dấu ngoặc đơn. Các biểu thức trong ngoặc đơn luôn được thực hiện trước tiên, trước khi các biểu thức không được đặt dấu ngoặc đơn. Do đó, điều sau đây xảy ra:
Trong ví dụ đầu tiên,
>>> 10 / 5
2.0
>>> type[10 / 5]
73 được tính toán đầu tiên, sau đó kết quả được nhân với >>> 10 / 5
2.0
>>> type[10 / 5]
74. Trong ví dụ thứ hai, >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
11 được tính toán đầu tiên, sau đó >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
05 được nâng lên thành công suất đó, sau đó kết quả được nhân với >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
13.Không có gì sai khi sử dụng dấu ngoặc đơn tự do, ngay cả khi chúng không cần thiết để thay đổi thứ tự đánh giá. Trên thực tế, nó được coi là thực tiễn tốt, bởi vì nó có thể làm cho mã dễ đọc hơn và nó làm giảm người đọc về việc phải nhớ lại sự ưu tiên của toán tử từ bộ nhớ. Xem xét những điều sau:
Ở đây, dấu ngoặc đơn hoàn toàn không cần thiết, vì các nhà khai thác so sánh có quyền ưu tiên cao hơn so với
>>> a = 10
>>> b = 20
>>> a + b - 5
25
30 và sẽ được thực hiện trước tiên. Nhưng một số người có thể xem xét mục đích của phiên bản dấu ngoặc đơn rõ ràng hơn so với phiên bản này mà không có dấu ngoặc đơn:Mặt khác, có lẽ những người sẽ thích cái sau; Nó là một vấn đề sở thích cá nhân. Vấn đề là, bạn luôn có thể sử dụng dấu ngoặc đơn nếu bạn cảm thấy nó làm cho mã dễ đọc hơn, ngay cả khi chúng không cần thiết để thay đổi thứ tự đánh giá.
Các nhà khai thác phân công tăng cường
>>>
>>> 10 / 5
2.0
>>> type[10 / 5]
9Tiết kiệm ưu tiên có thể được ghi đè bằng dấu ngoặc đơn. Các biểu thức trong ngoặc đơn luôn được thực hiện trước tiên, trước khi các biểu thức không được đặt dấu ngoặc đơn. Do đó, điều sau đây xảy ra:
>>>
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
0Tiết kiệm ưu tiên có thể được ghi đè bằng dấu ngoặc đơn. Các biểu thức trong ngoặc đơn luôn được thực hiện trước tiên, trước khi các biểu thức không được đặt dấu ngoặc đơn. Do đó, điều sau đây xảy ra:
Trong ví dụ đầu tiên,
>>> 10 / 5
2.0
>>> type[10 / 5]
73 được tính toán đầu tiên, sau đó kết quả được nhân với >>> 10 / 5
2.0
>>> type[10 / 5]
74. Trong ví dụ thứ hai, >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
11 được tính toán đầu tiên, sau đó >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
05 được nâng lên thành công suất đó, sau đó kết quả được nhân với >>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
13.>>>
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
1Tiết kiệm ưu tiên có thể được ghi đè bằng dấu ngoặc đơn. Các biểu thức trong ngoặc đơn luôn được thực hiện trước tiên, trước khi các biểu thức không được đặt dấu ngoặc đơn. Do đó, điều sau đây xảy ra:
Ở đây, dấu ngoặc đơn hoàn toàn không cần thiết, vì các nhà khai thác so sánh có quyền ưu tiên cao hơn so với 30 và sẽ được thực hiện trước tiên. Nhưng một số người có thể xem xét mục đích của phiên bản dấu ngoặc đơn rõ ràng hơn so với phiên bản này mà không có dấu ngoặc đơn: 3 0 4 9 3 7
| Mặt khác, có lẽ những người sẽ thích cái sau; Nó là một vấn đề sở thích cá nhân. Vấn đề là, bạn luôn có thể sử dụng dấu ngoặc đơn nếu bạn cảm thấy nó làm cho mã dễ đọc hơn, ngay cả khi chúng không cần thiết để thay đổi thứ tự đánh giá. 32 43 47 51
|
Các nhà khai thác phân công tăng cường
Bạn đã thấy rằng một dấu hiệu bằng nhau [
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
15] được sử dụng để gán một giá trị cho một biến. Tất nhiên, nó hoàn toàn khả thi cho giá trị ở bên phải của nhiệm vụ là một biểu thức chứa các biến khác:
Tất nhiên, loại gán này chỉ có ý nghĩa nếu biến trong câu hỏi trước đây đã được gán một giá trị: | Python hỗ trợ một ký hiệu chuyển nhượng tăng tốc cho các toán tử số học và bitwise này: | Môn số học |
Bitwise | Python hỗ trợ một ký hiệu chuyển nhượng tăng tốc cho các toán tử số học và bitwise này: | Môn số học |
Bitwise | Python hỗ trợ một ký hiệu chuyển nhượng tăng tốc cho các toán tử số học và bitwise này: | Môn số học |
Bitwise
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
2>>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106
3>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
0>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a >> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a >> a >= b
True
44 ____63operators Python supports to combine objects into expressions.>>> 10 / 5
2.0
>>> type[10 / 5]
27>>> 10 / 5
2.0
>>> type[10 / 5]
32>>> 10 / 5
2.0
>>> type[10 / 5]
43>>> 10 / 5
2.0
>>> type[10 / 5]
47>>> 10 / 5
2.0
>>> type[10 / 5]
51string data type. The next tutorial will explore string objects in much more detail.