Các kiểu số nguyên, số thực và số phức trong Python

Python Tutorial | 12/07/2025 by Hoc Python

Trong lập trình, việc xử lý và tính toán với số liệu là một phần không thể thiếu của hầu hết mọi ứng dụng, từ những phép tính đơn giản như tổng giá tiền hay số lượng người, cho đến các bài toán khoa học phức tạp.

Giống như trong toán học, không phải tất cả các con số đều giống nhau. Python cung cấp cho chúng ta các kiểu dữ liệu số khác nhau để phù hợp với từng loại thông tin và yêu cầu tính toán cụ thể. Việc hiểu rõ sự khác biệt giữa chúng sẽ giúp bạn chọn đúng công cụ cho công việc, đảm bảo chương trình của bạn hoạt động chính xác và hiệu quả.

Trong bài viết này, chúng ta sẽ cùng nhau tìm hiểu ba kiểu số cơ bản trong Python: số nguyên, số thực và số phức. Bạn sẽ tìm hiểu về đặc điểm, cách sử dụng và các phép toán cơ bản có thể áp dụng cho từng loại. Hãy cùng bắt đầu hành trình tìm hiểu thế giới số đầy thú vị này nhé!

Tại sao số lại quan trọng?

Số là nền tảng của mọi chương trình

Hãy thử nghĩ mà xem, dù là một ứng dụng di động đơn giản hay một hệ thống phức tạp, số luôn xuất hiện ở khắp mọi nơi. Nó là ngôn ngữ mà máy tính "hiểu" và xử lý để thực hiện các tác vụ.

Tuổi của một người: 25 tuổi, 30 tuổi.
Giá tiền của sản phẩm: 15000 VNĐ, 99.99 USD.
Khoảng cách địa lý: 10.5 km, 200 mét.
Điểm số trong game: 1000 điểm, 50 mạng.
Tính toán khoa học: Nhiệt độ 37.5 độ C, tốc độ 300000 km/s.
Số lượng hàng hóa: 500 sản phẩm trong kho.
Ngày, tháng, năm: Ngày 12, Tháng 7, Năm 2025.

Hầu hết mọi chương trình bạn viết đều sẽ cần đến khả năng lưu trữ, xử lý, và thực hiện các phép toán với những con số này. Nếu không có số, chương trình sẽ không thể thực hiện các chức năng cơ bản như tính toán hóa đơn, thống kê dữ liệu, hay điều khiển các thiết bị.

Python có các kiểu số riêng biệt để phù hợp với từng loại dữ liệu và phép tính khác nhau

Trong đời sống, chúng ta có số nguyên (1, 2, 3), số thập phân (1.5, 2.75) hay thậm chí là số phức trong toán học cao cấp. Trong Python cũng vậy, máy tính cần biết rõ "loại" của con số để xử lý nó một cách chính xác và hiệu quả nhất.

Ví dụ, phép cộng hai số nguyên sẽ khác với việc cộng hai số thập phân về mặt xử lý nội bộ của máy tính, và sẽ rất khác khi bạn muốn thực hiện các phép toán phức tạp với số phức trong các lĩnh vực chuyên biệt.

So sánh phép chia:

# Chia số nguyên (kết quả có thể là số thực)
ket_qua_chia_int = 10 / 3
print(f"10 / 3 (số nguyên): {ket_qua_chia_int}") # Kết quả: 3.3333333333333335 (float)

# Chia lấy phần nguyên (kết quả là số nguyên)
ket_qua_chia_lay_nguyen = 10 // 3
print(f"10 // 3 (chia lấy nguyên): {ket_qua_chia_lay_nguyen}") # Kết quả: 3 (int)

Như bạn thấy, cùng là phép chia nhưng kết quả và cách xử lý lại khác nhau tùy thuộc vào loại toán tử và mong muốn của bạn.

Việc Python cung cấp các kiểu số riêng biệt (int, float, complex) giúp chúng ta:

Lưu trữ dữ liệu chính xác: Không phải mọi số đều giống nhau về bản chất. Một số lượng sản phẩm phải là số nguyên, trong khi giá tiền có thể có phần thập phân.
Thực hiện các phép toán phù hợp: Đảm bảo các phép tính cho ra kết quả mong muốn mà không bị sai lệch do kiểu dữ liệu.
Tối ưu hóa hiệu suất và bộ nhớ: Máy tính có thể xử lý các loại số khác nhau theo những cách tối ưu riêng.

Số nguyên (Integer - `int`) trong Python

Số nguyên, hay int (viết tắt của integer), là một trong những kiểu dữ liệu số cơ bản và được sử dụng rộng rãi nhất trong Python. Đúng như tên gọi, chúng dùng để biểu diễn các con số không có phần thập phân.

Khái niệm: Các số không có phần thập phân

Khi bạn nghĩ đến các số như 1, 100, -5, hoặc 0, bạn đang nghĩ đến các số nguyên. Chúng là những con số "tròn", không có bất kỳ giá trị nào sau dấu phẩy.

Đặc điểm nổi bật của kiểu `int` trong Python:

Có thể là số dương, số âm hoặc số 0: Giống như trong toán học, số nguyên có thể mang dấu dương (10), dấu âm (-5), hoặc là số 0.

Python tự động quản lý kích thước (rất lớn hoặc rất nhỏ cũng được): Đây là một điểm mạnh đáng kể của Python so với nhiều ngôn ngữ lập trình khác. Bạn không cần lo lắng về việc số nguyên của mình quá lớn hay quá nhỏ để được lưu trữ. Python sẽ tự động điều chỉnh bộ nhớ cần thiết để chứa giá trị số nguyên đó, cho phép bạn làm việc với những con số khổng lồ mà không gặp giới hạn về tràn số.

Ví dụ về kích thước:

so_nguyen_lon = 123456789012345678901234567890
print(f"Số nguyên lớn: {so_nguyen_lon}")
print(f"Kiểu dữ liệu: {type(so_nguyen_lon)}") # Vẫn là <class 'int'>

Dù là một số lớn đến vậy, Python vẫn xử lý nó một cách trơn tru như một int bình thường.

Khi nào dùng kiểu `int`?

Bạn nên sử dụng kiểu int khi dữ liệu của bạn tự nhiên là một số đếm hoặc một đại lượng không có phần lẻ. Một số trường hợp phổ biến bao gồm:

Đếm số lượng: Số học sinh, số sản phẩm trong kho, số lần lặp.
Tuổi tác: Tuổi của một người.
Năm: Năm hiện tại, năm sinh.
Điểm số không có lẻ: Điểm của một bài kiểm tra không có phần thập phân.
Mã định danh: ID khách hàng, số thứ tự.

Ví dụ code minh họa:

Hãy xem cách chúng ta khai báo và sử dụng các biến kiểu số nguyên trong Python:

# Số lượng người trong một sự kiện
so_nguoi = 100
print(f"Số người tham dự: {so_nguoi} người.")
print(f"Kiểu dữ liệu của 'so_nguoi': {type(so_nguoi)}") # Kết quả: <class 'int'>

# Năm hiện tại
nam_hien_tai = 2024
print(f"Năm hiện tại: {nam_hien_tai}.")

# Điểm số tối thiểu có thể là số âm (ví dụ trong thang điểm đặc biệt)
diem_toi_thieu = -5
print(f"Điểm tối thiểu đạt được: {diem_toi_thieu}.")

# Phép toán với số nguyên
so_ban_dau = 15
so_tang_them = 7
tong_so = so_ban_dau + so_tang_them
print(f"Tổng số sau khi tăng: {tong_so}.")

Như bạn thấy, việc sử dụng int rất trực quan và phù hợp cho đa số các trường hợp cần xử lý số đếm hoặc số nguyên trong lập trình.

Số thực (Float - `float`) trong Python

Số thực, hay float (viết tắt của floating-point number), là kiểu dữ liệu dùng để biểu diễn các con số có phần thập phân. Trong Python, và hầu hết các ngôn ngữ lập trình khác, dấu chấm (.) được sử dụng làm dấu phân cách giữa phần nguyên và phần thập phân.

Khái niệm: Các số có phần thập phân (dùng dấu chấm `.`)

Khi bạn cần biểu diễn những giá trị không "tròn" mà có các chữ số sau dấu phẩy, đó chính là lúc float phát huy tác dụng.

Ví dụ: 3.14, 0.0, -2.5, 100.0 (ngay cả số nguyên viết với .0 cũng là float).

Đặc điểm nổi bật của kiểu `float` trong Python:

Được dùng cho các giá trị cần độ chính xác lẻ: float lý tưởng cho những tình huống đòi hỏi tính toán với các giá trị không phải là số nguyên, như phép đo lường, tính toán tài chính, hay khoa học.

Có thể biểu diễn số rất lớn hoặc rất nhỏ bằng ký hiệu khoa học (e hoặc E): Đối với những con số cực kỳ lớn hoặc cực kỳ nhỏ, Python cho phép bạn sử dụng ký hiệu khoa học.

Ví dụ về ký hiệu khoa học:

e hoặc E đại diện cho "nhân với 10 mũ".
Ví dụ: 1.23e5 có nghĩa là $1.23 t im es 1 0^{5} = 123000.0$ .
Ví dụ: 4.5e-3 có nghĩa là $4.5 t im es 1 0^{- 3} = 0.0045$ .

toc_do_anh_sang = 3.0e8    # Tức là 3.0 * 10^8 = 300000000.0 (mét/giây)
khoi_luong_electron = 9.109e-31 # Tức là 9.109 * 10^-31 (kg)
print(f"Tốc độ ánh sáng: {toc_do_anh_sang} m/s")
print(f"Khối lượng electron: {khoi_luong_electron} kg")

Khi nào dùng kiểu `float`?

Bạn nên sử dụng kiểu float khi dữ liệu của bạn có thể chứa giá trị thập phân hoặc cần độ chính xác cao. Một số trường hợp phổ biến bao gồm:

Giá tiền: 19.99 USD, 50000.5 VNĐ.
Cân nặng, chiều cao: 70.5 kg, 1.80 mét.
Nhiệt độ: 28.3 độ C, -7.5 độ F.
Các phép đo lường: Khoảng cách, thể tích, diện tích.
Tính toán khoa học: Các công thức vật lý, hóa học, kỹ thuật.

Ví dụ code minh họa:

Hãy xem cách chúng ta khai báo và sử dụng các biến kiểu số thực trong Python:

# Giá tiền của một món hàng
gia_tien = 99.99
print(f"Giá tiền sản phẩm: {gia_tien} USD.")
print(f"Kiểu dữ liệu của 'gia_tien': {type(gia_tien)}") # Kết quả: <class 'float'>

# Nhiệt độ hiện tại
nhiet_do = 25.5
print(f"Nhiệt độ hiện tại: {nhiet_do} độ C.")

# Khoảng cách lớn dùng ký hiệu khoa học
khoang_cach_lon = 1.23e5 # Tức là 123000.0
print(f"Khoảng cách lớn: {khoang_cach_lon} km.")

# Phép toán với số thực
chieu_rong = 3.5
chieu_dai = 7.0
dien_tich = chieu_dai * chieu_rong
print(f"Diện tích hình chữ nhật: {dien_tich}.")

Mặc dù float cung cấp độ chính xác cao, điều quan trọng cần lưu ý là do cách máy tính lưu trữ các số thập phân (sử dụng biểu diễn nhị phân), đôi khi có thể xảy ra các sai số nhỏ (ví dụ: 0.1 + 0.2 có thể không hoàn toàn bằng 0.3). Tuy nhiên, với hầu hết các ứng dụng thông thường, điều này không gây ra vấn đề đáng kể.

Số phức (Complex - `complex`) trong Python

Kiểu dữ liệu số phức, hay complex, là một kiểu số nâng cao hơn trong Python, ít gặp trong lập trình thông thường nhưng lại cực kỳ quan trọng trong các lĩnh vực khoa học và kỹ thuật.

Khái niệm: Là một số có hai phần: phần thực và phần ảo

Một số phức được cấu tạo từ hai thành phần:

Phần thực: Là một số thông thường (kiểu int hoặc float).
Phần ảo: Là một số thực nhân với đơn vị ảo j (hoặc J).

Cú pháp: `phần_thực + phần_ảo j`

Trong Python, đơn vị ảo được biểu diễn bằng chữ j (hoặc J) đặt ngay sau phần số của nó. Đây là điểm khác biệt so với toán học truyền thống thường dùng i để ký hiệu đơn vị ảo.

Ví dụ:

3 + 4j: Phần thực là 3, phần ảo là 4j.
2 - 1.5j: Phần thực là 2, phần ảo là -1.5j.
5j: Đây là một số phức với phần thực bằng 0.
7: Đây cũng có thể coi là một số phức với phần ảo bằng 0.

Đặc điểm nổi bật của kiểu `complex` trong Python:

j là căn bậc hai của -1: Trong toán học, đơn vị ảo i (imaginary unit) được định nghĩa là $s q r t - 1$ . Trong Python, chúng ta sử dụng j (hoặc J) để đại diện cho giá trị này. Điều này cho phép Python thực hiện các phép tính với số âm dưới căn bậc hai.
Ít dùng trong lập trình thông thường: Đối với các ứng dụng hàng ngày như quản lý thông tin khách hàng, website, hay trò chơi đơn giản, bạn sẽ hiếm khi cần đến số phức.
Chủ yếu trong các lĩnh vực khoa học, kỹ thuật, điện tử: Số phức là công cụ không thể thiếu trong nhiều ngành chuyên biệt, nơi chúng đơn giản hóa việc biểu diễn và giải quyết các bài toán liên quan đến dao động, sóng, dòng điện xoay chiều, và các hiện tượng vật lý khác.

Khi nào dùng kiểu `complex`?

Kiểu complex được sử dụng khi bạn làm việc trong các lĩnh vực đòi hỏi toán học nâng cao:

Xử lý tín hiệu: Phân tích và xử lý các tín hiệu âm thanh, hình ảnh.
Vật lý lượng tử: Mô tả các trạng thái lượng tử.
Kỹ thuật điện và điện tử: Phân tích mạch điện xoay chiều (AC), xử lý các khái niệm như trở kháng (impedance).
Toán học cao cấp: Các bài toán liên quan đến giải tích phức.

Ví dụ code minh họa:

Hãy xem cách chúng ta khai báo và thao tác với các biến kiểu số phức trong Python:

# Khai báo số phức 'so_phuc_a'
so_phuc_a = 3 + 4j
print(f"Số phức a: {so_phuc_a}")
print(f"Kiểu dữ liệu của 'so_phuc_a': {type(so_phuc_a)}") # Kết quả: <class 'complex'>

# Lấy phần thực và phần ảo
print(f"Phần thực của a: {so_phuc_a.real}") # Sử dụng .real để lấy phần thực
print(f"Phần ảo của a: {so_phuc_a.imag}")  # Sử dụng .imag để lấy phần ảo

# Khai báo số phức 'so_phuc_b' với phần ảo âm
so_phuc_b = 2 - 1.5j
print(f"Số phức b: {so_phuc_b}")

# Thực hiện phép cộng số phức
tong_so_phuc = so_phuc_a + so_phuc_b
print(f"Tổng của a và b: {tong_so_phuc}") # (3+2) + (4-1.5)j = 5 + 2.5j

# Thực hiện phép nhân số phức
tich_so_phuc = so_phuc_a * so_phuc_b
print(f"Tích của a và b: {tich_so_phuc}") # (3*2 - 4*(-1.5)) + (3*(-1.5) + 4*2)j = (6 + 6) + (-4.5 + 8)j = 12 + 3.5j

# Một số phức chỉ có phần ảo
so_phuc_c = 5j
print(f"Số phức c: {so_phuc_c}, Phần thực: {so_phuc_c.real}, Phần ảo: {so_phuc_c.imag}")

Dù không phổ biến như int hay float, khả năng làm việc với số phức của Python là một minh chứng cho sự mạnh mẽ và linh hoạt của ngôn ngữ này trong việc hỗ trợ các tính toán khoa học và kỹ thuật chuyên sâu.

Các phép toán cơ bản với số trong Python

Python cung cấp các toán tử số học quen thuộc để bạn có thể dễ dàng thực hiện các phép tính với số nguyên (int), số thực (float), và cả số phức (complex).

Cộng (+), Trừ (-), Nhân (*), Chia (/)

Đây là bốn phép toán cơ bản nhất và có thể áp dụng cho tất cả các kiểu số: int, float, và complex.

Cộng (+): Tổng của hai số.
Trừ (-): Hiệu của hai số.
Nhân (*): Tích của hai số.
Chia (/): Thương của hai số. Kết quả của phép chia \ luôn là một số thực (float), ngay cả khi cả hai số hạng là số nguyên và kết quả là một số nguyên "chẵn".

Ví dụ code:

# Ví dụ với số nguyên
so_a = 10
so_b = 3
print(f"--- Với số nguyên ({so_a}, {so_b}) ---")
print(f"Cộng: {so_a} + {so_b} = {so_a + so_b}")     # Kết quả: 13
print(f"Trừ: {so_a} - {so_b} = {so_a - so_b}")      # Kết quả: 7
print(f"Nhân: {so_a} * {so_b} = {so_a * so_b}")     # Kết quả: 30
print(f"Chia: {so_a} / {so_b} = {so_a / so_b}")     # Kết quả: 3.333... (float)

# Ví dụ với số thực
so_c = 7.5
so_d = 2.5
print(f"\n--- Với số thực ({so_c}, {so_d}) ---")
print(f"Cộng: {so_c} + {so_d} = {so_c + so_d}")     # Kết quả: 10.0
print(f"Trừ: {so_c} - {so_d} = {so_c - so_d}")      # Kết quả: 5.0
print(f"Nhân: {so_c} * {so_d} = {so_c * so_d}")     # Kết quả: 18.75
print(f"Chia: {so_c} / {so_d} = {so_c / so_d}")     # Kết quả: 3.0

# Ví dụ với số phức
so_e = 1 + 2j
so_f = 3 - 4j
print(f"\n--- Với số phức ({so_e}, {so_f}) ---")
print(f"Cộng: {so_e} + {so_f} = {so_e + so_f}")     # Kết quả: (4-2j)
print(f"Trừ: {so_e} - {so_f} = {so_e - so_f}")      # Kết quả: (-2+6j)
print(f"Nhân: {so_e} * {so_f} = {so_e * so_f}")     # Kết quả: (11+2j)
print(f"Chia: {so_e} / {so_f} = {so_e / so_f}")     # Kết quả: (-0.2+0.8j)

Chia lấy phần nguyên (`//`)

Toán tử chia lấy phần nguyên (//) sẽ thực hiện phép chia và chỉ trả về phần nguyên của kết quả, loại bỏ phần thập phân. Kết quả sẽ là một số nguyên nếu cả hai số hạng là số nguyên, hoặc là một số thực nếu có ít nhất một số hạng là số thực. Toán tử này chỉ áp dụng cho int và float, không dùng cho số phức.

Ví dụ code:

# Chia lấy phần nguyên với số nguyên
ket_qua_int = 10 // 3
print(f"10 // 3 = {ket_qua_int}") # Kết quả: 3

# Chia lấy phần nguyên với số thực (kết quả vẫn là float)
ket_qua_float = 10.0 // 3
print(f"10.0 // 3 = {ket_qua_float}") # Kết quả: 3.0

# Trường hợp số âm: kết quả sẽ làm tròn xuống số nguyên nhỏ hơn hoặc bằng
print(f"-10 // 3 = {-10 // 3}")   # Kết quả: -4 (không phải -3)
print(f"-10.0 // 3 = {-10.0 // 3}") # Kết quả: -4.0

Chia lấy số dư (`%`)

Toán tử chia lấy số dư (%) hay còn gọi là toán tử "modulo", trả về phần dư của phép chia. Toán tử này chỉ áp dụng cho int và float, không dùng cho số phức.

Ví dụ code:

# Chia lấy số dư với số nguyên
so_banh = 10
so_nguoi = 3
banh_con_lai = so_banh % so_nguoi
print(f"10 % 3 = {banh_con_lai} (Số bánh còn lại sau khi chia đều cho 3 người)") # Kết quả: 1

# Chia lấy số dư với số thực
print(f"10.5 % 3 = {10.5 % 3}") # Kết quả: 1.5

Lũy thừa (`**`)

Toán tử lũy thừa (**) dùng để tính "số mũ". Nó có nghĩa là số bên trái được nâng lên lũy thừa của số bên phải. Toán tử này có thể áp dụng cho tất cả các kiểu số: int, float, và complex.

Ví dụ code:

# Lũy thừa với số nguyên
canh = 10
dien_tich_vuong = canh ** 2 # 10 mũ 2
print(f"10 ** 2 = {dien_tich_vuong}") # Kết quả: 100

# Lũy thừa với số thực
co_so = 2.5
mu = 3
ket_qua_luy_thua = co_so ** mu # 2.5 mũ 3
print(f"2.5 ** 3 = {ket_qua_luy_thua}") # Kết quả: 15.625

# Lũy thừa với số phức
so_phuc_g = 1 + 1j
ket_qua_phuc = so_phuc_g ** 2 # (1 + j) ^ 2 = 1 + 2j + j^2 = 1 + 2j - 1 = 2j
print(f"(1 + 1j) ** 2 = {ket_qua_phuc}") # Kết quả: (2j)

Việc thành thạo các phép toán cơ bản này là rất quan trọng vì chúng là khối xây dựng cho mọi tính toán phức tạp hơn trong các chương trình Python của bạn!

Kết bài

Bạn đã hoàn thành việc tìm hiểu về ba kiểu số cơ bản trong Python: số nguyên (int), số thực (float), và số phức (complex). Nắm vững những kiểu này là yếu tố then chốt để bạn có thể thực hiện mọi phép tính toán trong các chương trình của mình.

Hãy luôn ghi nhớ những điểm cốt lõi sau:

Python tự động nhận diện kiểu số khi bạn gán giá trị, điều này giúp việc lập trình trở nên đơn giản và linh hoạt hơn.
Sử dụng số nguyên (int) cho các giá trị không có phần lẻ, như đếm số lượng hoặc tuổi tác.
Số thực (float) là lựa chọn lý tưởng cho các phép đo lường, giá tiền, hay bất kỳ đại lượng nào cần độ chính xác sau dấu phẩy.
Số phức (complex) phục vụ các nhu cầu chuyên biệt trong khoa học và kỹ thuật, nơi các bài toán cần đến cả phần thực và phần ảo.
Đừng quên sử dụng hàm type() bất cứ khi nào bạn muốn kiểm tra kiểu dữ liệu của một biến – đó là một công cụ hữu ích để gỡ lỗi và hiểu rõ hơn về chương trình của bạn.

Việc chọn đúng kiểu số không chỉ đảm bảo kết quả tính toán chính xác mà còn giúp chương trình của bạn hoạt động hiệu quả hơn. Hãy tiếp tục thực hành với các phép toán và các kiểu số này để củng cố kiến thức nhé!