2.3. Phép toán số học

Python hoạt động như một máy tính ngay từ đầu. Trang này đề cập đến các toán tử bạn sẽ sử dụng thường xuyên nhất: số học trên các số, so sánh tạo ra giá trị boolean, toán tử logic kết hợp các điều kiện, và toán tử bitwise cho công việc ở mức phần cứng.

2.3.1. Số học

Các toán tử số học chuẩn trên giá trị int và float:

  • + -- phép cộng

  • - -- phép trừ (hoặc phủ định, dùng làm tiền tố: -x)

  • * -- phép nhân

  • / -- phép chia. Luôn trả về float, ngay cả khi cả hai toán hạng đều là số nguyên.

  • // -- phép chia lấy phần nguyên. Trả về thương số nguyên làm tròn về phía âm vô cực.

  • % -- phép chia lấy dư (số dư).

  • ** -- lũy thừa (2 ** 10 bằng 1024).

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> -7 // 2
-4
>>> 7 % 2
1
>>> 2 ** 16
65536

Phép tính số học kiểu hỗn hợp tự động nâng cấp số nguyên thành số thực:

>>> 3 + 0.5
3.5

Phép gán tăng cường kết hợp toán tử với = để cập nhật tại chỗ một cách gọn gàng:

counter = 0
counter += 1                # equivalent to counter = counter + 1
counter *= 2                # works for *= /= //= %= **= too

Thứ tự ưu tiên toán tử tuân theo quy ước thông thường: ** trước, rồi - đơn nguyên, tiếp theo là *, /, // và %, rồi đến + và -. Hãy dùng dấu ngoặc đơn khi bạn không chắc chắn -- chúng không tốn chi phí gì khi chạy.

2.3.2. So sánh

Toán tử so sánh trả về bool (True hoặc False):

  • == và != -- bằng / không bằng.

  • <, <=, >, >= -- thứ tự.

>>> 3 == 3
True
>>> 3 == 3.0
True
>>> 3 < 5 <= 5
True

Ví dụ cuối là so sánh dạng chuỗi và hoàn toàn tương đương với 3 < 5 and 5 <= 5.

Cảnh báo

= gán giá trị; == so sánh. Biểu thức if x = 5: là lỗi cú pháp chính xác vì Python từ chối nhầm lẫn cả hai một cách im lặng.

2.3.3. Logic boolean

Ba toán tử kết hợp các giá trị boolean:

  • and -- True chỉ khi cả hai vế đều đúng.

  • or -- True khi một trong hai vế đúng.

  • not -- đảo ngược một giá trị boolean đơn.

and và or ngắn mạch: chúng ngừng đánh giá ngay khi kết quả đã biết. False and slow_check() không bao giờ gọi slow_check.

and và or cũng trả về một trong các toán hạng của chúng thay vì True hoặc False theo nghĩa đen, điều này cho phép bạn viết giá trị mặc định một cách gọn gàng:

name = user_name or "anonymous"   # "" / 0 / None are falsy

2.3.4. Toán tử bitwise

Cho công việc phần cứng -- đóng gói các trường trong thanh ghi, che giấu các bit, phân tích cú pháp tiêu đề giao thức -- bạn sẽ dùng đến các toán tử bitwise. Chúng hoạt động trên biểu diễn nhị phân của int:

  • & -- bitwise AND

  • | -- bitwise OR

  • ^ -- bitwise XOR

  • ~ -- bitwise NOT (bù một)

  • << -- dịch trái

  • >> -- dịch phải

Dạng hex và nhị phân literal rất tiện lợi khi đọc và viết các phép toán này:

>>> 0b1100 & 0b1010
8                              # 0b1000
>>> 0b1100 | 0b1010
14                             # 0b1110
>>> 0xFF ^ 0x0F
240                            # 0xF0
>>> 1 << 8
256
>>> (0xABCD >> 8) & 0xFF
171                            # extract the high byte

Dạng tăng cường tồn tại cho mỗi toán tử: |=, &=, ^=, <<=, >>=.

Ghi chú

and / or hoạt động trên boolean (hoặc trên tính đúng sai); & / | hoạt động trên các bit. Đừng nhầm lẫn chúng. 0b1100 and 0b1010 trả về 0b1010 vì cả hai toán hạng đều là truthy -- không phải điều bạn thường muốn khi thao tác với các bit.

2.3.5. Các hàm dựng sẵn hữu ích cho số

Một số hàm dựng sẵn bao gồm các phép toán số phổ biến mà các toán tử đơn thuần không cung cấp:

  • round() -- số nguyên gần nhất, hoặc ndigits chữ số thập phân gần nhất khi đối số thứ hai được cho. Trả về int cho round(x), float cho round(x, n). Các trường hợp cân bằng (0.5, 1.5, ...) làm tròn đến số chẵn gần nhất, không phải luôn làm tròn lên.

  • divmod() -- trả về (quotient, remainder) trong một lần gọi. Tiện lợi để phân tách một đại lượng thành các đơn vị (giây thành phút-và-giây, byte thành trang-và-offset).

  • pow() -- tương tự ** ở dạng hai đối số. Dạng ba đối số pow(base, exp, mod) tính (base ** exp) % mod mà không bao giờ tạo ra giá trị trung gian khổng lồ, đây là cách thực tế duy nhất để thực hiện lũy thừa modular cho các số mũ lớn.

>>> round(3.7)
4
>>> round(3.14159, 2)
3.14
>>> round(0.5)               # ties go to even, not always up
0
>>> round(1.5)
2

>>> divmod(125, 60)          # 125 seconds = 2 min, 5 sec
(2, 5)
>>> minutes, seconds = divmod(125, 60)

>>> pow(3, 4)                # same as 3 ** 4
81
>>> pow(3, 100, 7)           # (3 ** 100) mod 7, efficient
4

Chuyển đổi số nguyên sang chuỗi theo cơ số (bin, oct, hex) được đề cập trong Phương thức chuỗi và định dạng.

2.3.6. Mô-đun math

Các hàm toán học phổ biến nằm trong mô-đun math. Nhập nó một lần và gọi các hàm của nó qua tên có dấu chấm:

import math

print(math.sqrt(2))              # 1.4142135
print(math.sin(math.pi / 2))     # 1.0
print(math.floor(3.7))           # 3
print(math.log(100, 10))         # 2.0

Mô-đun math của MicroPython bao gồm các hàm quen thuộc (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, ...). Đối với số ngẫu nhiên, xem mô-đun random; đối với thao tác bit dấu phẩy tĩnh, các toán tử ở trên thường đủ dùng.

2.3.7. Số phức

Đối với các phép tính số học cần thành phần ảo, Python có kiểu complex với hậu tố j trong literal (1 + 2j). Mô-đun cmath phản chiếu math cho các đầu vào phức. Cả hai đều có mặt trên hầu hết các bản build MicroPython nhưng hiếm khi cần cho công việc với camera; đề cập đến chúng chủ yếu để bạn không ngạc nhiên nếu bạn chuyển mã có sử dụng chúng.