Làm thế nào đệ quy giai thừa hoạt động Python?

Theo định nghĩa, giai thừa là tích của một số nguyên dương và tất cả các số nguyên dương nhỏ hơn hoặc bằng số đã cho. Nói cách khác, lấy giai thừa của một số có nghĩa là nhân tất cả các số nguyên từ số đó xuống 1

0. cũng bằng 1, theo quy ước

Giai thừa được biểu thị bằng số nguyên và theo sau là dấu chấm than

5. biểu thị một giai thừa của năm

Và để tính giai thừa đó, chúng tôi nhân số với mọi số nguyên nhỏ hơn nó, cho đến khi chúng tôi đạt 1

5! = 5 * 4 * 3 * 2 * 1
5! = 120

Hãy ghi nhớ những quy tắc này, trong hướng dẫn này, chúng ta sẽ học cách tính giai thừa của một số nguyên bằng Python, sử dụng vòng lặp và đệ quy. Hãy bắt đầu với việc tính giai thừa bằng cách sử dụng các vòng lặp

Tính giai thừa bằng vòng lặp

Chúng ta có thể tính giai thừa bằng cách sử dụng cả vòng lặp

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Hãy bắt đầu với vòng lặp

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Bạn có thể nhận thấy rằng chúng tôi đang đếm bắt đầu từ 1 đến

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

$$
1 * 2 * 3 * 4. * n = n * (n-1) * (n-2) * (n-3) * (n-4). * (n - (n-1))
$$

Để đơn giản hóa,

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

4 sẽ luôn bằng 1

Điều đó có nghĩa là chúng ta đang đếm theo hướng nào không quan trọng. Nó có thể bắt đầu từ 1 và tăng dần về phía 13, hoặc có thể bắt đầu từ 13 và giảm xuống 1. Bây giờ điều đó đã được làm rõ, hãy bắt đầu chia nhỏ chức năng mà chúng ta vừa viết

Hàm của chúng tôi nhận tham số

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Tại sao chỉ định 1 chứ không phải 0 bạn yêu cầu?

Bởi vì nếu ta gán 0 cho nó thì tất cả những phép nhân sau với 0 đương nhiên sẽ ra một con số 0 rất lớn.

Sau đó, chúng tôi bắt đầu vòng lặp

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Bên trong vòng lặp

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Cuối cùng, chúng tôi trả về giá trị cuối cùng của

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Nếu bạn muốn đọc thêm về cách lấy đầu vào của người dùng, hãy đọc phần Lấy đầu vào của người dùng bằng Python của chúng tôi

Nó sẽ nhắc người dùng đưa ra đầu vào. Chúng tôi sẽ thử với

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Bạn có thể sử dụng máy tính để xác minh kết quả

4. là

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Bây giờ hãy xem cách chúng ta có thể tính giai thừa bằng cách sử dụng vòng lặp

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Điều này khá giống với vòng lặp

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Chúng tôi sẽ nhập 4 làm đầu vào một lần nữa

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Hãy xem hướng dẫn thực hành, thực tế của chúng tôi để học Git, với các phương pháp hay nhất, tiêu chuẩn được ngành chấp nhận và bao gồm bảng gian lận. Dừng các lệnh Git trên Google và thực sự tìm hiểu nó

Mặc dù phép tính là

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Tính giai thừa bằng cách sử dụng các vòng lặp thật dễ dàng. Bây giờ chúng ta hãy xem cách tính giai thừa bằng hàm đệ quy

Tính giai thừa bằng cách sử dụng đệ quy

Một hàm đệ quy là một hàm gọi chính nó. Thoạt nghe có vẻ hơi đáng sợ nhưng hãy kiên trì và bạn sẽ thấy rằng các hàm đệ quy rất dễ hiểu

Nói chung, mọi hàm đệ quy đều có hai thành phần chính. một trường hợp cơ sở và một bước đệ quy

Các trường hợp cơ sở là các trường hợp nhỏ nhất của vấn đề. Ngoài ra, một trường hợp ngắt, một trường hợp sẽ trả về một giá trị và sẽ thoát khỏi đệ quy. Về hàm giai thừa, trường hợp cơ bản là khi chúng ta trả về phần tử cuối cùng của giai thừa, là 1

Nếu không có trường hợp cơ sở hoặc trường hợp cơ sở không chính xác, hàm đệ quy của bạn có thể chạy vô hạn, gây ra tràn

Các bước đệ quy - như tên ngụ ý - là phần đệ quy của hàm, trong đó toàn bộ vấn đề được chuyển đổi thành một thứ nhỏ hơn. Nếu bước đệ quy không thu nhỏ được vấn đề, thì đệ quy lại có thể chạy vô hạn

Xem xét phần định kỳ của giai thừa

Nhưng chúng ta cũng biết rằng

Nói cách khác 5. là

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Vì vậy, chúng ta có thể nói rằng

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

26. Đây sẽ là bước đệ quy của giai thừa của chúng tôi

Một đệ quy giai thừa kết thúc khi nó đạt 1. Đây sẽ là trường hợp cơ sở của chúng tôi. Chúng tôi sẽ trả lại

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Chúng ta hãy xem hàm giai thừa đệ quy của chúng ta

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Như bạn thấy, khối

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Hãy kiểm tra chức năng của chúng tôi

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Chúng tôi sẽ nhập 3 làm đầu vào lần này

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Chúng tôi nhận được kết quả tương tự. Nhưng lần này, những gì diễn ra khá thú vị

Bạn thấy đấy, khi chúng ta nhập dữ liệu vào, hàm sẽ kiểm tra với khối

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Chúng tôi biết giá trị hiện tại của

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

3 vào lúc này, đó là

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

56, nhưng

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

57 vẫn cần được tính toán

Sau đó, chương trình gọi hàm tương tự một lần nữa, nhưng lần này hàm của chúng ta lấy 2 làm tham số. Nó kiểm tra khối

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Vì vậy, nó gọi hàm một lần nữa, nhưng lần này là khối

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Theo cùng một mẫu hướng lên trên, nó trả về từng kết quả của hàm, nhân kết quả hiện tại với

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Đồng thời loại bỏ từng chức năng khỏi ngăn xếp cuộc gọi, cho đến khi kết quả cuối cùng của

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Đây thường là cách các hàm đệ quy hoạt động. Một số vấn đề phức tạp hơn có thể yêu cầu đệ quy sâu hơn với nhiều hơn một trường hợp cơ sở hoặc nhiều hơn một bước đệ quy. Nhưng hiện tại, phép đệ quy đơn giản này đủ tốt để giải bài toán giai thừa của chúng ta

Nếu bạn muốn tìm hiểu thêm về đệ quy trong Python, hãy đọc Hướng dẫn của chúng tôi để hiểu về đệ quy trong Python

Sự kết luận

Trong bài viết này, chúng tôi đã đề cập đến cách tính giai thừa bằng cách sử dụng các vòng lặp

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Nếu bạn thích đệ quy và muốn thực hành thêm, hãy thử tính dãy Fibonacci bằng đệ quy. Và nếu bạn có bất kỳ câu hỏi hoặc suy nghĩ nào về bài viết của chúng tôi, vui lòng chia sẻ trong phần bình luận

Giai thừa đệ quy hoạt động như thế nào?

Hàm đệ quy trong giai thừa Python là gì?

Python tính giai thừa như thế nào?

Giai thừa đệ quy có nhanh hơn lặp lại không?