Số nguyên và số thực (float)

Python có hai kiểu số

Python có hai kiểu số chính để làm việc với số: int cho số nguyên và float cho số thập phân.

Cả hai đều là số, nên bạn có thể làm mọi phép tính cơ bản — cộng, trừ, nhân, chia và chia dư — với cái nào cũng được.

Nhưng cú pháp và độ chính xác khác nhau, nên bạn chọn cái phù hợp cho mỗi tình huống.

Dù giá trị trông giống số nguyên, thêm .0 như 3.0 biến nó thành float. Ngược lại, chỉ viết 175 thì nó là int.

Số âm cũng làm việc tương tự — -5 là int, -5.5 là float.

# int (số nguyên)
age = 25
print(type(age))      # <class 'int'>

# float (số thập phân)
weight = 175.5
print(type(weight))   # <class 'float'>

# Cùng "3" nhưng kiểu khác nhau tùy cách viết
print(type(3))        # <class 'int'>
print(type(3.0))      # <class 'float'>

# Số âm cũng vậy
print(type(-10))      # <class 'int'>
print(type(-10.5))    # <class 'float'>

Kiểm tra khác biệt giữa int và float trong terminal.

① Tạo count = 7 và pi = 3.14, rồi in cả giá trị lẫn kiểu bằng print().

② Viết print(type(3.0)) để tận mắt thấy 3 và 3.0 có kiểu khác nhau.

Dạo qua các toán tử

Có 7 toán tử bạn dùng cho phép tính số. Bốn toán tử cơ bản + - * / hoạt động giống như ngôn ngữ khác, nhưng // (chia lấy nguyên), % (chia dư) và ** (lũy thừa) xuất hiện rất nhiều trong Python, nên đáng học kỹ.

/ trả về float kể cả giữa các int

10 / 2 là 5.0 (float), không phải 5.

/ của Python được thiết kế để luôn trả về float, nên kết quả là float ngay cả khi cả hai toán hạng là int.

Nếu bạn muốn kết quả là số nguyên, dùng //.

# Phép tính cơ bản
print(10 + 3)    # 13
print(10 - 3)    # 7
print(10 * 3)    # 30

# Chia luôn trả về float
print(10 / 3)    # 3.3333333333333335
print(10 / 2)    # 5.0  (vẫn là float dù chia hết)

# Chia lấy nguyên (cắt) và chia dư
print(10 // 3)   # 3
print(10 % 3)    # 1

# Lũy thừa: a ** b nghĩa là "a mũ b"
print(2 ** 10)   # 1024
print(3 ** 2)    # 9
print(2 ** 0.5)  # 1.4142135623730951  (dùng như căn bậc hai)

Tính xem seconds = 365 là bao nhiêu phút và bao nhiêu giây.

① Dùng // để in "bao nhiêu phút".

② Dùng % để in "còn dư bao nhiêu giây".

③ Dùng `** để in 2 mũ 8 (256).

④ In 10 / 2 và xác nhận kết quả là float (5.0) dù phép chia hết.

Toán tử gán gộp (+= / -= v.v.)

Mẫu kiểu "x = x + 1" — nơi bạn làm gì đó với một biến rồi ghi kết quả trở lại vào chính nó — xuất hiện suốt.

Bạn có thể rút gọn thành "x += 1", và các dạng rút gọn này gọi là toán tử gán gộp.

Mỗi toán tử `+ - / // % * đều có dạng gộp.

score = 10

score += 5      # 10 + 5 -> 15
print(score)    # 15

score *= 2      # 15 * 2 -> 30
print(score)    # 30

score -= 7      # 30 - 7 -> 23
print(score)    # 23

# Cũng hoạt động với float
weight = 60.0
weight += 1.5
print(weight)   # 61.5

Cập nhật HP của một nhân vật bắt đầu từ hp = 100, dùng gán gộp.

① Giảm hp đi 30 và in.

② Sau đó nhân đôi hp và in.

③ Sau đó thay hp bằng phần dư của hp chia 5, và in.

Trộn int và float trong phép toán

Khi bạn trộn int và float, kết quả luôn là float. Đó là vì Python tự động nâng lên kiểu có độ chính xác cao hơn.

Như đã nói ở trên, / (chia) trả về float ngay cả giữa các int, còn // (chia lấy nguyên) trả về int khi cả hai toán hạng là int.

# int với int vẫn là int
print(10 + 3)        # 13   -> int
print(type(10 + 3))  # <class 'int'>

# Nếu vế nào đó là float, kết quả là float
print(10 + 3.0)         # 13.0
print(type(10 + 3.0))   # <class 'float'>

# / trả về float ngay cả giữa các int
print(10 / 2)           # 5.0
print(type(10 / 2))     # <class 'float'>

# // vẫn là int khi cả hai là int
print(10 // 3)          # 3
print(type(10 // 3))    # <class 'int'>

# // thành float nếu có vế nào là float
print(10 // 3.0)        # 3.0
print(type(10 // 3.0))  # <class 'float'>

Thử đoán kiểu kết quả, rồi kiểm tra.

① In kết quả và kiểu của 7 + 2.

② In kết quả và kiểu của 7 + 2.0.

③ In kết quả và kiểu của 10 / 5 (để ý là float dù phép chia hết).

float có độ chính xác giới hạn

Máy tính lưu float dưới dạng xấp xỉ nhị phân. Vì vậy ngay cả các phép tính trông đơn giản cũng có thể cho sai số nhỏ.

Ví dụ dưới đây là một "cái bẫy float" kinh điển — mọi người mới bắt đầu đều vấp phải vào lúc nào đó.

Tận mắt thấy sai số.

① In 0.1 + 0.2 (xác nhận nó không ra 0.3).

② In 0.1 + 0.1 + 0.1.

③ In 0.1 + 0.2 == 0.3 (sẽ không là True).

Dùng Decimal khi cần toán chính xác

Trong các tình huống mà ngay cả sai số nhỏ cũng không chấp nhận được — như tính tiền — bạn có thể làm toán thập phân chính xác bằng kiểu Decimal trong thư viện chuẩn. Ta sẽ không đề cập trong bài này, nhưng hãy nhớ: "float là xấp xỉ" và "có công cụ khác cho toán chính xác".

Đổi kiểu bằng int() và float()

Để chuyển giữa các kiểu số, dùng các hàm có sẵn int() và float().

Một điều cần để ý: int() cắt phần thập phân — nó không làm tròn. Nên truyền 3.9 vào int() được 3, không phải 4. Với giá trị âm, nó làm tròn về phía 0, nên -3.9 thành -3, không phải -4.

# float -> int là "cắt" (KHÔNG làm tròn!)
print(int(3.9))     # 3
print(int(3.1))     # 3
print(int(-3.9))    # -3   (làm tròn về phía 0)

# int -> float chỉ thêm .0
print(float(5))     # 5.0
print(float(-2))    # -2.0

# Dùng chuyển đổi qua biến
a = 3.9
a = int(a)
print(a, type(a))       # 3 <class 'int'>

b = 5
b = float(b)
print(b, type(b))       # 5.0 <class 'float'>

Xem int() hoạt động thế nào.

① In kết quả của int(7.8) (nó không làm tròn).

② In kết quả của int(-7.8) (xem nó làm tròn về hướng nào ở phía âm).

③ In kết quả và kiểu của float(10).

Trong bài này, bạn đã học:

• Khác biệt giữa int và float
• Lũy thừa với "**" và gán gộp (+= và đồng bọn)
• Khác biệt kiểu trả về giữa "/" (chia) và "//" (chia lấy nguyên)
• Vấn đề độ chính xác của float
• Chuyển kiểu bằng int() / float()