Tính giai thừa trong Python: 2 cách code (For & Đệ quy)

Tính giai thừa là một trong những bài toán kinh điển nhất khi học lập trình, đặc biệt là đối với sinh viên Công nghệ thông tin đang rèn luyện tư duy thuật toán.

Bài viết này sẽ hướng dẫn bạn chi tiết hai phương pháp tính giai thừa phổ biến nhất trong Python: sử dụng vòng lặp (iteration) và đệ quy (recursion), kèm theo phân tích chuyên sâu về độ phức tạp bộ nhớ (Call Stack) để bạn hiểu rõ bản chất vấn đề.

💡 Trả lời nhanh: Để tính giai thừa nhanh nhất trong môi trường thực tế, hãy dùng hàm tích hợp math.factorial(n). Tuy nhiên, nếu bạn đang làm bài tập cấu trúc dữ liệu và giải thuật, bạn cần tự viết hàm bằng vòng lặp for (nhân dồn từ 1 đến n) hoặc dùng hàm đệ quy (gọi lại chính nó với công thức n * (n-1)!).

Đề bài

Viết chương trình Python thực hiện các yêu cầu sau:

Input: Một số nguyên dương n bất kỳ được nhập từ bàn phím.

Output: Kết quả n! (n giai thừa), là một số nguyên.

Ràng buộc: – Cần xử lý trường hợp đặc biệt n = 0 (quy ước 0! = 1).

• Phải kiểm tra (validate) và báo lỗi nếu người dùng nhập số âm (vì giai thừa không xác định cho số âm) hoặc nhập sai kiểu dữ liệu (nhập số thực, chuỗi).

• Yêu cầu viết thành hai hàm riêng biệt: một hàm dùng vòng lặp thông thường và một hàm dùng đệ quy.

Phân tích logic bài toán tính giai thừa

Bài toán tính giai thừa trong Python yêu cầu tính tích của các số nguyên dương liên tiếp từ 1 đến n, có thể thực hiện thông qua vòng lặp, đệ quy, hoặc sử dụng hàm tích hợp sẵn của ngôn ngữ. Về mặt toán học, giai thừa của một số nguyên không âm n, ký hiệu là n!, được định nghĩa là tích của tất cả các số nguyên dương nhỏ hơn hoặc bằng n.

Ví dụ cụ thể: 5! = 5* 4* 3 *2 *1 = 120. Một điểm đặc biệt quan trọng cần lưu ý trong định nghĩa toán học là 0! = 1. Đây là điều kiện cơ sở (base case) tối quan trọng mà các lập trình viên thường vô tình bỏ quên khi thiết kế thuật toán.

Đối với sinh viên CNTT, bài toán này không chỉ đơn thuần là tìm ra kết quả đúng mà còn là bài tập nền tảng để so sánh sự khác biệt về cách quản lý bộ nhớ của máy tính. Hai hướng tiếp cận chính đại diện cho hai trường phái tư duy khác nhau: tư duy tuần tự (vòng lặp) và tư duy chia để trị (đệ quy).

📌 Góc nhìn thực tế: Trong thực tế giảng dạy, sinh viên thường làm tốt phần tính toán cho các số dương nhưng lại hay bỏ sót bước kiểm tra dữ liệu đầu vào (input validation). Một hệ thống tốt không bao giờ tin tưởng tuyệt đối vào dữ liệu người dùng nhập. Do đó, việc chặn các giá trị âm hoặc giá trị số thực ngay từ đầu là bắt buộc đối với code đạt chuẩn trung cấp.

Giả định

Trong bài viết này, chúng ta giả định hệ thống máy tính có đủ bộ nhớ RAM để chứa kết quả của phép tính. Khác với các ngôn ngữ như C/C++ hay Java (nơi kiểu int bị giới hạn ở 32-bit hoặc 64-bit và dễ gây tràn số thập phân), Python tự động xử lý số nguyên lớn (Arbitrary-precision integers). Do đó, chúng ta không cần lo lắng về hiện tượng tràn bộ đệm (integer overflow) ở kết quả đầu ra, mà chỉ cần tập trung vào việc xử lý giới hạn đệ quy.

Với những phân tích trên, chúng ta sẽ lần lượt đi vào triển khai hai cách giải đáp ứng đúng chuẩn logic thuật toán máy tính.

Cách giải 1: Vòng lặp For (Không đệ quy)

Cách tính giai thừa bằng vòng lặp for là phương pháp tiếp cận trực diện, sử dụng một biến tích lũy để nhân dồn các giá trị khi duyệt qua một tập hợp số nguyên. Đây là cách làm an toàn và thân thiện nhất với bộ nhớ.

Ý tưởng thuật toán lặp

Ý tưởng cốt lõi là tạo ra một biến lưu trữ kết quả ban đầu bằng 1 (vì 1 là phần tử trung hòa của phép nhân). Sau đó, chúng ta sử dụng một vòng lặp chạy tuần tự từ số 1 cho đến số n. Tại mỗi vòng lặp, ta lấy giá trị hiện tại của biến kết quả nhân với biến đếm của vòng lặp, rồi cập nhật ngược lại vào biến kết quả. Quá trình này mô phỏng chính xác công thức toán học nhân liên tiếp.

Các bước triển khai

1. Kiểm tra đầu vào: Nếu n < 0, ném ra lỗi ValueError. Nếu kiểu dữ liệu không phải int, ném ra TypeError.

2. Xử lý trường hợp cơ sở: Nếu n == 0 hoặc n == 1, trả về kết quả là 1 ngay lập tức.

3. Khởi tạo biến result = 1.

4. Mở vòng lặp for với biến i chạy từ 2 đến n (sử dụng hàm range(2, n + 1) trong Python).

5. Trong vòng lặp, thực hiện phép gán result = result * i.

6. Kết thúc vòng lặp, trả về giá trị cuối cùng của result.

Minh họa tay (Trace)

Giả sử người dùng nhập n = 4. Quá trình chạy của vòng lặp sẽ diễn ra như sau:

• Bước chuẩn bị: result = 1

• Vòng lặp thứ 1 (i = 2): result = 1 * 2 = 2

• Vòng lặp thứ 2 (i = 3): result = 2 * 3 = 6

• Vòng lặp thứ 3 (i = 4): result = 6 * 4 = 24

• Hết vòng lặp (vì đã chạy đến n), hàm trả về 24. Kết quả chính xác với 4! = 24.

Đánh giá

• Phù hợp người mới vì: Logic trực quan, dễ hình dung tiến trình thực thi của code dòng qua dòng. Không đòi hỏi tư duy trừu tượng về Call Stack.

• Ưu điểm: Phương pháp dùng vòng lặp tính giai thừa có độ phức tạp không gian O(1), an toàn hơn cho các số cực lớn vì không tiêu tốn bộ nhớ hệ thống để lưu trữ các trạng thái hàm chờ.

• Nhược điểm: Code dài hơn một chút so với các phương pháp khác, cần khai báo biến tạm.

• Độ phức tạp: O(n) thời gian (vì phải lặp n lần) / O(1) bộ nhớ (chỉ dùng duy nhất một biến result bất kể n lớn cỡ nào).

Cách giải 2: Đệ quy

Khác với Cách 1, cách tính giai thừa bằng đệ quy định nghĩa bài toán thông qua chính bài toán đó nhưng ở quy mô nhỏ hơn, đại diện cho tư duy thiết kế “chia để trị” (Divide and Conquer).

Ý tưởng thuật toán đệ quy

Khác với Cách 1 ở chỗ, chúng ta không dùng biến tích lũy. Thay vào đó, ta dựa vào tính chất toán học: n! = n *(n-1)!.

Điều này có nghĩa là, để tính giai thừa của 5, ta chỉ cần lấy 5 nhân với giai thừa của 4. Để tính giai thừa của 4, ta lấy 4 nhân với giai thừa của 3… Quá trình lùi dần này bắt buộc phải có điểm dừng (base case), đó là khi lùi về đến 0, ta biết chắc chắn 0! = 1 để trả kết quả ngược lên.

Các bước triển khai

1. Kiểm tra đầu vào: Validate tương tự như Cách 1 để đảm bảo n là số nguyên không âm.

2. Thiết lập điều kiện dừng (Base case): Nếu n == 0 hoặc n == 1, hàm lập tức trả về giá trị 1.

3. Bước đệ quy (Recursive step): Nếu n > 1, hàm sẽ trả về kết quả của phép tính n * solve_recursive(n - 1).

Minh họa tay (Trace)

Giả sử người dùng nhập n = 4. Hàm fact(4) được gọi:

• fact(4) không phải base case. Nó chờ kết quả của 4 * fact(3). Máy tính mở một vùng nhớ (Stack frame) lưu lại số 4.

• fact(3) gọi 3 * fact(2). Mở thêm một vùng nhớ lưu số 3.

• fact(2) gọi 2 * fact(1). Mở thêm vùng nhớ lưu số 2.

• fact(1) là base case. Lập tức trả về 1.

• Quá trình “cuộn ngược” (Unwinding) bắt đầu: fact(2) nhận được 1, tính 2 * 1 = 2, trả lên trên.

• fact(3) nhận được 2, tính 3 * 2 = 6, trả lên trên.

• fact(4) nhận được 6, tính 4 * 6 = 24, trả về kết quả cuối cùng.

Khi nào nên dùng Cách 2?

Đệ quy giúp code tính giai thừa ngắn gọn hơn nhưng dễ gây lỗi RecursionError nếu n vượt quá 1000 trong Python. Bạn chỉ nên dùng cách này trong môi trường học thuật, khi làm bài tập trên trường để giảng viên chấm điểm tư duy thuật toán, hoặc khi n chắc chắn là một số nhỏ. Trong môi trường production thực tế, đệ quy thuần túy hiếm khi được sử dụng để tính giai thừa.

Đánh giá

• Ưu điểm: Code vô cùng ngắn gọn, thanh lịch, mang đậm chất toán học. Dễ đọc nếu bạn đã quen với mô hình tư duy đệ quy.

• Nhược điểm: Tốn bộ nhớ. Mỗi lần gọi hàm, hệ điều hành phải cấp phát một ngăn xếp (stack frame) mới. Nếu n quá lớn, chương trình sẽ crash.

• Độ phức tạp: O(n) thời gian (có n lần gọi hàm) / O(n) bộ nhớ (Call Stack sẽ phình to tỷ lệ thuận với n).

So sánh nhanh 2 cách

Bảng này giúp bạn quyết định nên dùng cách nào mà không cần đọc lại toàn bài. Trực quan hóa sự khác biệt giữa hai trường phái tư duy.

Code đầy đủ

Cách 1 — Vòng lặp For (Không đệ quy):

# Tên biến nhất quán với phần minh họa tay

def solve_iterative(n):
    """
    Hàm tính giai thừa bằng vòng lặp For.
    Nhận vào số nguyên dương n, trả về kết quả n! (kiểu int).
    Có bao gồm validation chống dữ liệu rác.
    """
    # Validation kiểm tra kiểu dữ liệu và giá trị âm
    if not isinstance(n, int):
        raise TypeError("Lỗi: Vui lòng nhập số nguyên.")
    if n < 0:
        raise ValueError("Lỗi: Giai thừa không xác định cho số âm.")
        
    # Trường hợp cơ sở
    if n == 0 or n == 1:
        return 1
        
    # Logic chính: nhân dồn
    result = 1
    for i in range(2, n + 1):
        result *= i
        
    return result

# --- TEST NHANH (xóa hoặc comment lại trước khi đăng) ---
# assert solve_iterative(4) == 24
# assert solve_iterative(0) == 1
# print("Cách 1: Tất cả test pass!")
# --- Nhập liệu ---
# Bọc trong try-except để giao tiếp thân thiện với người dùng cuối
try:
    n_input = int(input("Nhập số nguyên dương n: "))
    print(f"Kết quả {n_input}! (vòng lặp) là: {solve_iterative(n_input)}")
except ValueError as e:
    print(f"Dữ liệu không hợp lệ: {e}")

Cách 2 — Đệ quy (Recursion):

# Điểm khác với Cách 1: Không dùng biến result, gọi thẳng hàm solve_recursive
def solve_recursive(n):
    """
    Hàm tính giai thừa bằng đệ quy.
    Sử dụng công thức n! = n * (n-1)!
    """
    if not isinstance(n, int):
        raise TypeError("Lỗi: Vui lòng nhập số nguyên.")
    if n < 0:
        raise ValueError("Lỗi: Giai thừa không xác định cho số âm.")
        
    # Base case - Điều kiện dừng
    if n == 0 or n == 1:
        return 1
        
    # Recursive step - Bước đệ quy
    return n * solve_recursive(n - 1)
# --- TEST NHANH ---
# assert solve_recursive(4) == 24
# assert solve_recursive(0) == 1
# print("Cách 2: Tất cả test pass!")
try:
    n_input = int(input("Nhập số nguyên dương n: "))
    print(f"Kết quả {n_input}! (đệ quy) là: {solve_recursive(n_input)}")
except ValueError as e:
    print(f"Dữ liệu không hợp lệ: {e}")

Ví dụ chạy thử

Lỗi thường gặp

Lỗi 1: Quên điều kiện dừng (Base case) trong hàm đệ quy

Lỗi này xảy ra khi bạn gọi hàm đệ quy tính giai thừa nhưng quên không định nghĩa trường hợp n == 0 hoặc n == 1.

Hiện tượng: Output ra thông báo lỗi đỏ chót RecursionError: maximum recursion depth exceeded hoặc chương trình bị treo cứng thay vì trả về kết quả số học.

Nguyên nhân: Vì không có điểm dừng, hàm solve_recursive sẽ gọi mãi: fact(0) gọi fact(-1), fact(-1) gọi fact(-2)… Quá trình này vô tận làm cạn kiệt bộ nhớ Call Stack của Python (mặc định giới hạn khoảng 1000 lần gọi). Khi bộ nhớ đầy, hệ điều hành ép chương trình dừng khẩn cấp.

Code sai:

def solve_recursive(n):
    # Lỗi: Quên if n == 0 return 1
    # output sai là: RecursionError
    return n * solve_recursive(n - 1) 

Code đúng:

def solve_recursive(n):
    # output đúng là: 1 (khi n chạm đáy)
    if n == 0:
        return 1
    return n * solve_recursive(n - 1)

Lỗi 2: Bỏ qua việc kiểm tra số âm đầu vào

Lỗi này xảy ra khi lập trình viên quá tin tưởng vào dữ liệu nhập vào của người dùng mà bỏ qua bước validation.

Hiện tượng: Output ra RecursionError (nếu dùng đệ quy) hoặc 1 (sai toán học, nếu dùng vòng lặp For) thay vì báo lỗi nhập liệu rõ ràng.

Nguyên nhân: Vì range(2, -5 + 1) sẽ tạo ra một danh sách rỗng, vòng lặp for không chạy lần nào, hàm lập tức trả về giá trị khởi tạo result = 1. Điều này sai hoàn toàn về toán học vì số âm không có giai thừa. Đối với đệ quy, việc truyền -1 vào sẽ khiến hàm lùi về -2, -3, gây tràn Stack như Lỗi 1.

Code sai:

def solve_iterative(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result
# solve_iterative(-5) output sai là: 1

Code đúng:

def solve_iterative(n):
    if n < 0:
        raise ValueError("Không tính giai thừa số âm")
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result
# solve_iterative(-5) output đúng là: ValueError

Lỗi 3: Khởi tạo biến tích lũy bằng 0 thay vì 1

Đây là lỗi logic sơ đẳng khi người học nhầm lẫn giữa thuật toán tính tổng và thuật toán tính tích.

Hiện tượng: Output ra 0 cho mọi giá trị input n thay vì ra kết quả giai thừa chính xác.

Nguyên nhân: Vì trong phép nhân, số 0 nhân với bất kỳ số nào cũng bằng 0. Khi bạn gán result = 0 ban đầu, vòng lặp chạy 0 * 1, 0 * 2… kết quả mãi mãi bị triệt tiêu thành số 0. Ở bài toán nhân dồn, phần tử trung hòa phải luôn là 1.

Code sai:

def solve_iterative(n):
    result = 0 # Sai ở đây
    for i in range(1, n + 1):
        result *= i
    return result
# output sai là: 0

Code đúng:

def solve_iterative(n):
    result = 1 # Đúng
    for i in range(1, n + 1):
        result *= i
    return result
# output đúng là: 24 (nếu n=4)

Lỗi 4: Lỗi Type Error do truyền sai kiểu dữ liệu (Float, String)

Lỗi này xuất hiện khi chương trình nhận dữ liệu thẳng từ input() mà quên ép kiểu sang số nguyên (int).

Hiện tượng: Output ra TypeError: 'str' object cannot be interpreted as an integer hoặc vòng lặp range() báo lỗi không nhận kiểu float.

Nguyên nhân: Hàm input() trong Python mặc định luôn trả về một chuỗi ký tự (string), ví dụ "5". Hàm range() bắt buộc phải nhận số nguyên nguyên thủy. Bạn không thể yêu cầu Python “chạy vòng lặp "5" lần” một cách trực tiếp mà không chuyển hóa dữ liệu. Tương tự, giai thừa không áp dụng cho số thực như 3.5.

Code sai:

n = input("Nhập n: ") # Nhận vào chuỗi
# output sai là: TypeError ở range()
print(solve_iterative(n))

Code đúng:

# Ép kiểu rõ ràng
n = int(input("Nhập n: ")) 
# output đúng là: Gọi hàm thành công
print(solve_iterative(n))

Lỗi 5: Vượt quá giới hạn Recursion Limit của Python

Lỗi này không hẳn do bạn code sai logic, mà do đặc tả phần mềm của bản thân trình thông dịch Python.

Hiện tượng: Output ra RecursionError: maximum recursion depth exceeded dù code của bạn hoàn toàn có base case và chạy đúng với n = 10.

Nguyên nhân: Vì ngôn ngữ Python (CPython) không tự động tối ưu hóa đệ quy đuôi (Tail Call Optimization) như các ngôn ngữ C hay Lisp. Để bảo vệ hệ thống không bị sập RAM, CPython đặt ra một hằng số giới hạn ngăn xếp đệ quy, thường là 1000. Nếu bạn gọi hàm đệ quy tính giai thừa của 1500, nó sẽ bị hệ thống chủ động “giết” tiến trình.

Code sai:

# n = 1500
print(solve_recursive(1500))
# output sai là: RecursionError

Code đúng:

import sys
# Tăng giới hạn đệ quy một cách thủ công (Chỉ nên dùng khi thực sự hiểu)
sys.setrecursionlimit(2000)
print(solve_recursive(1500))
# output đúng là: Một số nguyên khổng lồ

Câu hỏi thường gặp

Tính giai thừa là gì và tại sao cần dùng trong lập trình Python?

Tính giai thừa trong toán học là việc nhân các số nguyên dương liên tiếp từ 1 đến n (ký hiệu là n!). Trong lập trình Python, bài toán tính giai thừa thường được sử dụng để giải quyết các hệ thống liên quan đến toán tổ hợp (combinatorics), xác suất thống kê, tính số hoán vị của một mảng dữ liệu, hoặc để sinh viên rèn luyện tư duy thuật toán về vòng lặp và quản lý bộ nhớ.

Hàm đệ quy khi tính giai thừa trong Python hoạt động ra sao?

Hàm đệ quy tính giai thừa hoạt động theo nguyên tắc gọi lại chính nó với giá trị nhỏ dần. Khi bạn yêu cầu tính n!, hàm sẽ tính n nhân với kết quả của hàm đó tại (n-1). Quá trình gọi lồng nhau này sẽ dừng lại khi tham số lùi về 0 (base case), trả về 1, sau đó cuộn ngược lên để tính ra kết quả cuối cùng trên Call Stack.

Làm thế nào để tính giai thừa trong Python mà không dùng vòng lặp hay đệ quy?

Để tính giai thừa Python nhanh và chính xác nhất mà không cần tự code tay thuật toán, bạn hãy import module math có sẵn. Sau đó, gọi hàm math.factorial(n). Hàm này được viết bằng ngôn ngữ C ở tầng dưới nên tốc độ thực thi (runtime) vượt trội hơn hoàn toàn so với việc dùng vòng lặp for hoặc đệ quy thuần túy trong Python.

Cách sử dụng vòng lặp while để tính giai thừa Python thay vì vòng lặp for?

Bạn hoàn toàn có thể tính giai thừa Python bằng vòng lặp while. Cách làm là khởi tạo biến result = 1 và i = n. Trong khi i > 0, bạn gán result = result * i, sau đó giảm i đi 1 đơn vị (i -= 1). Vòng lặp kết thúc khi i chạm 0, kết quả thu được giống hệt vòng lặp for nhưng đòi hỏi bạn tự quản lý biến đếm cẩn thận hơn để tránh vòng lặp vô hạn.

Nên dùng đệ quy hay vòng lặp để tính giai thừa khi code Python thực tế?

Bạn nên ưu tiên dùng vòng lặp (hoặc hàm math.factorial) thay vì đệ quy khi làm dự án Python thực tế. Vòng lặp có độ phức tạp không gian O(1) nên tiết kiệm RAM và ổn định. Đệ quy tốn không gian nhớ O(n), dễ gây lỗi tràn ngăn xếp (RecursionError) nếu tham số đầu vào quá lớn, đồng thời chậm hơn do tốn tài nguyên quản lý lời gọi hàm của hệ điều hành.

Sự khác biệt về quản lý bộ nhớ giữa cách tính đệ quy và không đệ quy là gì?

Cách tính không đệ quy (dùng biến tích lũy) chỉ sử dụng một vài vùng nhớ cố định (O(1)) để lưu biến cục bộ, giá trị cũ bị ghi đè liên tục. Ngược lại, cách tính đệ quy đòi hỏi hệ thống tạo ra một khung ngăn xếp (stack frame) riêng biệt cho mỗi lần gọi hàm. 100 lần đệ quy sẽ tiêu tốn lượng RAM gấp 100 lần so với vòng lặp, độ phức tạp bộ nhớ là O(n).

Tại sao code tính giai thừa bằng đệ quy bị lỗi RecursionError?

Lỗi RecursionError xảy ra chủ yếu do hai nguyên nhân cốt lõi. Thứ nhất, bạn đã quên viết điều kiện dừng (if n == 0 return 1), khiến hàm rơi vào vòng lặp vô tận. Thứ hai, bạn truyền vào một số n quá lớn (lớn hơn 1000) vượt quá giới hạn an toàn mặc định của CPython. Bạn có thể kiểm tra lỗi bằng cách truyền thử n=3, nếu vẫn lỗi tức là thiếu điều kiện dừng.

Kết luận

Bài toán tính giai thừa là một ví dụ tuyệt vời để bạn đối chiếu hai phương pháp lập trình phổ biến nhất. Hãy sử dụng Cách 1 (Vòng lặp For) khi bạn cần viết code an toàn, chạy ổn định, không lo tràn bộ nhớ với những đầu vào phức tạp trong dự án thực tế. Ngược lại, Cách 2 (Đệ quy) sẽ là công cụ hoàn hảo để rèn luyện tư duy toán học, chứng minh khả năng quản lý kiến trúc thuật toán khi bạn còn ngồi trên ghế nhà trường.

Chúc bạn áp dụng thành công kiến thức quản lý bộ nhớ này vào những bài tập khó hơn trong tương lai.

Các khóa học liên quan: 

• Làm chủ Python trong 4 tuần

• Học python căn bản thông qua lập trình 1 game

• Python Excel cho người đi làm

• Học lập trình Python cho mọi lứa tuổi

• Thành thạo xử lý dữ liệu với Python

• Tập làm kĩ sư Amazon vận hành robot nông nghiệp với Python

Một số sản phẩm từ Python:

• Tool MMO: “Máy xay clip” chuẩn MMO cho TikTok, YouTube Shorts, Facebook Reels

Một số sách lập trình Python bạn hãy tham khảo

• Tiki: Python
• Shopee: Pyhon