programming python Recursive function List recursion Python Recursion Python Recursive function C++ Recursive algorithm Recursion Python Practice Recursive example Indirect recursion

Hướng dẫn each time a function calls itself python - mỗi khi một hàm gọi chính nó là python

Nếu bạn quen thuộc với các chức năng trong Python, thì bạn sẽ biết rằng nó khá phổ biến đối với một chức năng để gọi một chức năng khác. Trong Python, nó cũng có thể cho một chức năng tự gọi mình! Một chức năng tự gọi được cho là đệ quy và kỹ thuật sử dụng một hàm đệ quy được gọi là đệ quy.recursive, and the technique of employing a recursive function is called recursion.

Nó có vẻ kỳ dị cho một chức năng để tự gọi, nhưng nhiều loại vấn đề lập trình được thể hiện tốt nhất một cách đệ quy. Khi bạn chống lại một vấn đề như vậy, đệ quy là một công cụ không thể thiếu để bạn có trong bộ công cụ của mình.

Đến cuối hướng dẫn này, bạn sẽ hiểu:

  • Ý nghĩa của một chức năng để tự gọi mình là đệ quyrecursively
  • Cách thiết kế các chức năng Python hỗ trợ đệ quydesign of Python functions supports recursion
  • Những yếu tố nào cần xem xét khi chọn liệu có nên giải quyết vấn đề hay khôngfactors to consider when choosing whether or not to solve a problem recursively
  • Cách thực hiện chức năng đệ quy trong Pythonimplement a recursive function in Python

Sau đó, bạn sẽ nghiên cứu một số vấn đề lập trình Python sử dụng đệ quy và tương phản giải pháp đệ quy với một giải pháp không được tái tạo tương đương.

Đệ quy là gì?

Việc đệ quy từ xuất phát từ tái phát từ tiếng Latin, có nghĩa là chạy hoặc đẩy lùi, trả lại, hoàn nguyên hoặc tái diễn. Dưới đây là một số định nghĩa trực tuyến về đệ quy:recursion comes from the Latin word recurrere, meaning to run or hasten back, return, revert, or recur. Here are some online definitions of recursion:

  • Dictionary.com: Hành động hoặc quá trình quay lại hoặc chạy lại: The act or process of returning or running back
  • Wiktionary: Hành động xác định một đối tượng [thường là hàm] theo chính đối tượng đó: The act of defining an object [usually a function] in terms of that object itself
  • Từ điển miễn phí: Một phương pháp xác định chuỗi đối tượng, chẳng hạn như biểu thức, hàm hoặc tập hợp, trong đó một số đối tượng ban đầu được đưa ra và mỗi đối tượng liên tiếp được xác định theo các đối tượng trước: A method of defining a sequence of objects, such as an expression, function, or set, where some number of initial objects are given and each successive object is defined in terms of the preceding objects

Một định nghĩa đệ quy là một trong đó thuật ngữ xác định xuất hiện trong chính định nghĩa. Các tình huống tự giới thiệu thường mọc lên trong cuộc sống thực, ngay cả khi chúng không thể nhận ra ngay lập tức như vậy. Ví dụ, giả sử bạn muốn mô tả tập hợp những người tạo nên tổ tiên của bạn. Bạn có thể mô tả chúng theo cách này:recursive definition is one in which the defined term appears in the definition itself. Self-referential situations often crop up in real life, even if they aren’t immediately recognizable as such. For example, suppose you wanted to describe the set of people that make up your ancestors. You could describe them this way:

Lưu ý cách khái niệm đang được xác định, tổ tiên, thể hiện theo định nghĩa riêng của nó. Đây là một định nghĩa đệ quy.ancestors, shows up in its own definition. This is a recursive definition.

Trong lập trình, đệ quy có một ý nghĩa rất chính xác. Nó đề cập đến một kỹ thuật mã hóa trong đó một hàm tự gọi.

Tại sao sử dụng đệ quy?

Hầu hết các vấn đề lập trình là có thể giải quyết mà không cần đệ quy. Vì vậy, nói đúng ra, đệ quy thường không cần thiết.

Tuy nhiên, một số tình huống đặc biệt cho vay đối với một định nghĩa tự giới thiệu, ví dụ, định nghĩa của tổ tiên được hiển thị ở trên. Nếu bạn đang nghĩ ra một thuật toán để xử lý một trường hợp như vậy theo chương trình, một giải pháp đệ quy có thể sẽ sạch hơn và súc tích hơn.self-referential definition—for example, the definition of ancestors shown above. If you were devising an algorithm to handle such a case programmatically, a recursive solution would likely be cleaner and more concise.

Truyền tải các cấu trúc dữ liệu giống như cây là một ví dụ tốt khác. Bởi vì đây là những cấu trúc lồng nhau, chúng dễ dàng phù hợp với một định nghĩa đệ quy. Một thuật toán không nhận được để đi qua một cấu trúc lồng nhau có khả năng là một chút lộn xộn, trong khi một giải pháp đệ quy sẽ tương đối thanh lịch. Một ví dụ về điều này xuất hiện sau này trong hướng dẫn này.

Mặt khác, đệ quy là không phải cho mọi tình huống. Dưới đây là một số yếu tố khác để xem xét:

  • Đối với một số vấn đề, một giải pháp đệ quy, mặc dù có thể, sẽ khó xử hơn là thanh lịch.
  • Việc triển khai đệ quy thường tiêu thụ nhiều bộ nhớ hơn so với không nhận được.
  • Trong một số trường hợp, sử dụng đệ quy có thể dẫn đến thời gian thực hiện chậm hơn.

Thông thường, khả năng đọc của mã sẽ là yếu tố quyết định lớn nhất. Nhưng nó phụ thuộc vào hoàn cảnh. Các ví dụ được trình bày dưới đây sẽ giúp bạn cảm nhận khi nào bạn nên chọn đệ quy.

Đệ quy trong Python

Khi bạn gọi một hàm trong Python, trình thông dịch sẽ tạo một không gian tên cục bộ mới để các tên được xác định trong hàm đó don don va chạm với các tên giống hệt nhau được xác định ở nơi khác. Một chức năng có thể gọi một chức năng khác và ngay cả khi cả hai đều xác định các đối tượng có cùng tên, tất cả đều hoạt động tốt vì các đối tượng đó tồn tại trong các không gian tên riêng biệt.namespaces.

Điều tương tự sẽ đúng nếu nhiều phiên bản của cùng một hàm đang chạy đồng thời. Ví dụ, hãy xem xét định nghĩa sau:

def function[]:
    x = 10
    function[]

Khi 

def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
1 thực hiện lần đầu tiên, Python tạo ra một không gian tên và gán 
def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
2 Giá trị 
def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
3 trong không gian tên đó. Sau đó 
def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
1 tự gọi mình là đệ quy. Lần thứ hai 
def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
1 chạy, trình thông dịch tạo không gian tên thứ hai và gán 
def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
3 cho 
def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
2 ở đó. Hai trường hợp này của tên 
def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
2 khác biệt với nhau và có thể cùng tồn tại mà không cần xung đột vì chúng ở trong các không gian tên riêng biệt.

Thật không may, chạy 

def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
1 vì nó tạo ra kết quả ít truyền cảm hứng hơn, như Traceback sau đây cho thấy:

>>>

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded

Như đã viết, trên lý thuyết 

def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
1 sẽ tiếp tục mãi mãi, tự gọi mình là không có bất kỳ cuộc gọi nào trở lại. Trong thực tế, tất nhiên, không có gì thực sự là mãi mãi. Máy tính của bạn chỉ có quá nhiều bộ nhớ và cuối cùng nó sẽ hết.

Python không cho phép điều đó xảy ra. Trình thông dịch giới hạn số lần tối đa một hàm có thể gọi chính nó theo cách đệ quy và khi nó đạt đến giới hạn đó, nó sẽ tăng ngoại lệ 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
1, như bạn thấy ở trên.

Có rất nhiều việc sử dụng cho một chức năng để tự gọi một cách bừa bãi một cách đệ quy mà không cần kết thúc. Nó gợi nhớ đến những hướng dẫn mà đôi khi bạn tìm thấy trên các chai dầu gội đầu: Lather Lather, Rửa sạch, lặp lại. Nếu bạn phải làm theo những hướng dẫn này theo nghĩa đen, bạn sẽ gội đầu mãi mãi!

Lỗ hổng logic này rõ ràng đã xảy ra với một số nhà sản xuất dầu gội đầu, bởi vì một số chai dầu gội thay vào đó nói là Lather, rửa sạch, lặp lại khi cần thiết. Cung cấp một điều kiện chấm dứt cho các hướng dẫn. Có lẽ, cuối cùng bạn sẽ cảm thấy mái tóc của mình đủ sạch để xem xét các lần lặp lại bổ sung không cần thiết. Dầu gội sau đó có thể dừng lại.

Tương tự, một chức năng tự gọi mình là đệ quy phải có kế hoạch dừng lại. Các chức năng đệ quy thường theo mẫu này:

  • Có một hoặc nhiều trường hợp cơ sở có thể giải quyết trực tiếp mà không cần phải đệ quy thêm.
  • Mỗi cuộc gọi đệ quy di chuyển giải pháp dần dần gần với một trường hợp cơ sở.

Bây giờ bạn đã sẵn sàng để xem cách này hoạt động với một số ví dụ.

Bắt đầu: Đếm xuống 0

Ví dụ đầu tiên là một hàm gọi là 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
2, lấy số dương làm đối số và in các số từ đối số được chỉ định xuống bằng không:

>>>

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0

Lưu ý cách 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
2 phù hợp với mô hình cho một thuật toán đệ quy được mô tả ở trên:

  • Trường hợp cơ sở xảy ra khi 
    >>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
    4 bằng không, tại thời điểm đệ quy dừng lại.
  • Trong cuộc gọi đệ quy, đối số ít hơn một giá trị hiện tại của 
    >>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
    4, do đó, mỗi đệ quy di chuyển gần hơn với trường hợp cơ sở.

Phiên bản của 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
2 được hiển thị ở trên làm nổi bật rõ ràng trường hợp cơ sở và cuộc gọi đệ quy, nhưng có một cách ngắn gọn hơn để thể hiện nó:

def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]

Ở đây, một lần thực hiện không nhận được để so sánh:

>>>

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0

Lưu ý cách 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
2 phù hợp với mô hình cho một thuật toán đệ quy được mô tả ở trên:

Trường hợp cơ sở xảy ra khi 
>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
4 bằng không, tại thời điểm đệ quy dừng lại.

Trong cuộc gọi đệ quy, đối số ít hơn một giá trị hiện tại của 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
4, do đó, mỗi đệ quy di chuyển gần hơn với trường hợp cơ sở.

Phiên bản của 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
2 được hiển thị ở trên làm nổi bật rõ ràng trường hợp cơ sở và cuộc gọi đệ quy, nhưng có một cách ngắn gọn hơn để thể hiện nó:

Ở đây, một lần thực hiện không nhận được để so sánh:

Đây là một trường hợp trong đó giải pháp không nhận được ít nhất là rõ ràng và trực quan như loại đệ quy, và có lẽ nhiều hơn như vậy.reductive, meaning that they reduce to one of the base cases:

  • Tính toán giai thừa
  • Ví dụ tiếp theo liên quan đến khái niệm toán học của giai thừa. Bộ phận của một số nguyên dương N, được ký hiệu là N !, được định nghĩa như sau:

Nói cách khác, n! là sản phẩm của tất cả các số nguyên từ 1 đến N, bao gồm.

Factorial cho vay để định nghĩa đệ quy rằng các văn bản lập trình gần như luôn luôn bao gồm nó như một trong những ví dụ đầu tiên. Bạn có thể thể hiện định nghĩa của N! đệ quy như thế này:

Như với ví dụ được hiển thị ở trên, có những trường hợp cơ sở có thể giải quyết được mà không có đệ quy. Các trường hợp phức tạp hơn là rút gọn, có nghĩa là chúng giảm xuống một trong các trường hợp cơ sở:

Các trường hợp cơ sở [n = 0 hoặc n = 1] có thể giải quyết được mà không có đệ quy.

Đối với các giá trị của n lớn hơn 1, n! được định nghĩa theo nghĩa [n - 1] !, Vì vậy, giải pháp đệ quy dần dần tiếp cận trường hợp cơ sở.

>>>

>>> def factorial[n]:
...     return 1 if n >> factorial[4]
24

Lưu ý cách 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
2 phù hợp với mô hình cho một thuật toán đệ quy được mô tả ở trên:

>>>

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24

Lưu ý cách 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
2 phù hợp với mô hình cho một thuật toán đệ quy được mô tả ở trên:

Trường hợp cơ sở xảy ra khi 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
4 bằng không, tại thời điểm đệ quy dừng lại.

>>>

>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24

Lưu ý cách 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
2 phù hợp với mô hình cho một thuật toán đệ quy được mô tả ở trên:

>>>

>>> from functools import reduce
>>> def factorial[n]:
...     return reduce[lambda x, y: x * y, range[1, n + 1] or [1]]
...

>>> factorial[4]
24

Lưu ý cách 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
2 phù hợp với mô hình cho một thuật toán đệ quy được mô tả ở trên:

Trường hợp cơ sở xảy ra khi 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
4 bằng không, tại thời điểm đệ quy dừng lại.

So sánh tốc độ của việc triển khai giai thừa

Để đánh giá thời gian thực hiện, bạn có thể sử dụng một hàm gọi là 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 từ một mô -đun còn được gọi là 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
4. Chức năng này hỗ trợ một số định dạng khác nhau, nhưng bạn sẽ sử dụng định dạng sau trong hướng dẫn này:

timeit[, setup=, number=]


>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 Đầu tiên thực thi các lệnh có trong 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
6 được chỉ định. Sau đó, nó thực thi 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
7 Số 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
8 đã cho và báo cáo thời gian thực hiện tích lũy tính bằng giây:

>>>

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
0

Ở đây, tham số 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
9 gán 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 Giá trị 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
1. Sau đó 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 in 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 một trăm lần. Tổng thời gian thực hiện chỉ là hơn 3/100 của một giây.

Các ví dụ được hiển thị dưới đây sử dụng 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 để so sánh các triển khai đệ quy, lặp và 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
1 của giai thừa từ trên cao. Trong mỗi trường hợp, 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
6 chứa một chuỗi thiết lập xác định hàm 
>>> def factorial[n]:
...     return 1 if n >> factorial[4]
24
9 có liên quan. 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 sau đó thực hiện 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
9 tổng cộng mười triệu lần và báo cáo việc thực hiện tổng hợp.

Đầu tiên, ở đây, phiên bản đệ quy:

>>>

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
1

Ở đây, tham số 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
9 gán 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 Giá trị 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
1. Sau đó 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 in 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 một trăm lần. Tổng thời gian thực hiện chỉ là hơn 3/100 của một giây.

>>>

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
2

Ở đây, tham số 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
9 gán 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 Giá trị 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
1. Sau đó 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 in 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 một trăm lần. Tổng thời gian thực hiện chỉ là hơn 3/100 của một giây.

>>>

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
3

Ở đây, tham số 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
9 gán 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 Giá trị 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
1. Sau đó 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 in 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 một trăm lần. Tổng thời gian thực hiện chỉ là hơn 3/100 của một giây.

Các ví dụ được hiển thị dưới đây sử dụng 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 để so sánh các triển khai đệ quy, lặp và 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
1 của giai thừa từ trên cao. Trong mỗi trường hợp, 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
6 chứa một chuỗi thiết lập xác định hàm 
>>> def factorial[n]:
...     return 1 if n >> factorial[4]
24
9 có liên quan. 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 sau đó thực hiện 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
9 tổng cộng mười triệu lần và báo cáo việc thực hiện tổng hợp.

Đầu tiên, ở đây, phiên bản đệ quy:

Tiếp theo là triển khai lặp lại:

Cuối cùng, ở đây, phiên bản sử dụng 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
1:

>>>

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
4

Ở đây, tham số 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
9 gán 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 Giá trị 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
1. Sau đó 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 in 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 một trăm lần. Tổng thời gian thực hiện chỉ là hơn 3/100 của một giây.

>>>

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
5

Ở đây, tham số 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
9 gán 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 Giá trị 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
1. Sau đó 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 in 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 một trăm lần. Tổng thời gian thực hiện chỉ là hơn 3/100 của một giây.

Các ví dụ được hiển thị dưới đây sử dụng 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 để so sánh các triển khai đệ quy, lặp và 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
1 của giai thừa từ trên cao. Trong mỗi trường hợp, 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
6 chứa một chuỗi thiết lập xác định hàm 
>>> def factorial[n]:
...     return 1 if n >> factorial[4]
24
9 có liên quan. 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 sau đó thực hiện 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
9 tổng cộng mười triệu lần và báo cáo việc thực hiện tổng hợp.

Đầu tiên, ở đây, phiên bản đệ quy:

Tiếp theo là triển khai lặp lại:

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
6

Cuối cùng, ở đây, phiên bản sử dụng 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
1:

Trong trường hợp này, việc thực hiện lặp là nhanh nhất, mặc dù giải pháp đệ quy không còn xa phía sau. Phương pháp sử dụng 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
1 là chậm nhất. Số dặm của bạn có thể sẽ thay đổi nếu bạn thử các ví dụ này trên máy của riêng bạn. Bạn chắc chắn đã giành được cùng một lần, và bạn thậm chí có thể không nhận được thứ hạng tương tự.leaf elements in this list—the lowest-level 
>>> from functools import reduce
>>> def factorial[n]:
...     return reduce[lambda x, y: x * y, range[1, n + 1] or [1]]
...

>>> factorial[4]
24
6 objects—as though you’d flattened out the list. The leaf elements are 
>>> from functools import reduce
>>> def factorial[n]:
...     return reduce[lambda x, y: x * y, range[1, n + 1] or [1]]
...

>>> factorial[4]
24
7, 
>>> from functools import reduce
>>> def factorial[n]:
...     return reduce[lambda x, y: x * y, range[1, n + 1] or [1]]
...

>>> factorial[4]
24
8, 
>>> from functools import reduce
>>> def factorial[n]:
...     return reduce[lambda x, y: x * y, range[1, n + 1] or [1]]
...

>>> factorial[4]
24
9, 
timeit[, setup=, number=]
0, 
timeit[, setup=, number=]
1, 
timeit[, setup=, number=]
2, 
timeit[, setup=, number=]
3, 
timeit[, setup=, number=]
4, 
timeit[, setup=, number=]
5, and 
timeit[, setup=, number=]
6, so the answer should be 
def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
3.

Nó có quan trọng không? Có một sự khác biệt gần bốn giây trong thời gian thực hiện giữa việc thực hiện lặp lại và cuộc gọi sử dụng 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
1, nhưng phải mất mười triệu cuộc gọi để xem nó.

Nếu bạn sẽ gọi một chức năng nhiều lần, bạn có thể cần tính đến tốc độ thực thi khi chọn triển khai. Mặt khác, nếu hàm sẽ chạy tương đối không thường xuyên, thì sự khác biệt về thời gian thực thi có thể sẽ không đáng kể. Trong trường hợp đó, bạn sẽ tốt hơn khi chọn cách thực hiện dường như thể hiện giải pháp cho vấn đề rõ ràng nhất.

>>>

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
7

Ở đây, tham số 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
9 gán 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 Giá trị 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
1. Sau đó 
>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
3 in 
>>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
0 một trăm lần. Tổng thời gian thực hiện chỉ là hơn 3/100 của một giây.

  1. Các ví dụ được hiển thị dưới đây sử dụng 
    >>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
    3 để so sánh các triển khai đệ quy, lặp và 
    >>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
    1 của giai thừa từ trên cao. Trong mỗi trường hợp, 
    >>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
    6 chứa một chuỗi thiết lập xác định hàm 
    >>> def factorial[n]:
...     return 1 if n >> factorial[4]
24
    9 có liên quan. 
    >>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
    3 sau đó thực hiện 
    >>> def factorial[n]:
...     return_value = 1
...     for i in range[2, n + 1]:
...         return_value *= i
...     return return_value
...

>>> factorial[4]
24
    9 tổng cộng mười triệu lần và báo cáo việc thực hiện tổng hợp.
  2. Đầu tiên, ở đây, phiên bản đệ quy:
  3. Tiếp theo là triển khai lặp lại:
    • Cuối cùng, ở đây, phiên bản sử dụng 
      >>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
      1:
    • Trong trường hợp này, việc thực hiện lặp là nhanh nhất, mặc dù giải pháp đệ quy không còn xa phía sau. Phương pháp sử dụng 
      >>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
      1 là chậm nhất. Số dặm của bạn có thể sẽ thay đổi nếu bạn thử các ví dụ này trên máy của riêng bạn. Bạn chắc chắn đã giành được cùng một lần, và bạn thậm chí có thể không nhận được thứ hạng tương tự.

Nó có quan trọng không? Có một sự khác biệt gần bốn giây trong thời gian thực hiện giữa việc thực hiện lặp lại và cuộc gọi sử dụng 

>>> def factorial[n]:
...     print[f"factorial[] called with n = {n}"]
...     return_value = 1 if n >> factorial[4]
factorial[] called with n = 4
factorial[] called with n = 3
factorial[] called with n = 2
factorial[] called with n = 1
-> factorial[1] returns 1
-> factorial[2] returns 2
-> factorial[3] returns 6
-> factorial[4] returns 24
24
1, nhưng phải mất mười triệu cuộc gọi để xem nó.

Nếu bạn sẽ gọi một chức năng nhiều lần, bạn có thể cần tính đến tốc độ thực thi khi chọn triển khai. Mặt khác, nếu hàm sẽ chạy tương đối không thường xuyên, thì sự khác biệt về thời gian thực thi có thể sẽ không đáng kể. Trong trường hợp đó, bạn sẽ tốt hơn khi chọn cách thực hiện dường như thể hiện giải pháp cho vấn đề rõ ràng nhất.

Đối với giai thừa, thời gian được ghi ở trên cho thấy việc thực hiện đệ quy là một lựa chọn hợp lý.

Thành thật mà nói, nếu bạn mã hóa trong Python, bạn không cần phải thực hiện chức năng giai thừa. Nó đã có sẵn trong mô -đun 

>>> from functools import reduce
>>> def factorial[n]:
...     return reduce[lambda x, y: x * y, range[1, n + 1] or [1]]
...

>>> factorial[4]
24
3 tiêu chuẩn:

>>>

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
8

Bây giờ bạn có các công cụ tại chỗ để thực hiện một chức năng đếm các phần tử lá trong danh sách, chiếm những người phụ thuộc một cách đệ quy:

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
9

Nếu bạn chạy 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
09 trên một số danh sách, bao gồm danh sách 
>>> from functools import reduce
>>> def factorial[n]:
...     return reduce[lambda x, y: x * y, range[1, n + 1] or [1]]
...

>>> factorial[4]
24
5 được xác định ở trên, bạn sẽ nhận được điều này:

>>>

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
0

Như với ví dụ về giai thừa, việc thêm một số câu lệnh 

>>> def countdown[n]:
...     while n >= 0:
...         print[n]
...         n -= 1
...

>>> countdown[5]
5
4
3
2
1
0
7 giúp chứng minh chuỗi các cuộc gọi đệ quy và các giá trị trả về:

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
1

Ở đây, một bản tóm tắt về những gì mà xảy ra trong ví dụ trên:

  • Dòng 9: 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    12 là 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    13, vì vậy 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    09 đã tìm thấy một người phụ.     
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    12 is 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    13, so 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    09 has found a sublist.
  • Dòng 11: Hàm tự gọi mình là đếm ngược để đếm các mục trong trình phụ trợ, sau đó thêm kết quả vào tổng số tích lũy. The function calls itself recursively to count the items in the sublist, then adds the result to the accumulating total.
  • Dòng 12: 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    12 là 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    16, vì vậy 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    09 đã gặp phải một mặt hàng lá.     
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    12 is 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    16, so 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    09 has encountered a leaf item.
  • Dòng 14: Hàm tăng tổng số tích lũy theo một để tính đến mục lá. The function increments the accumulating total by one to account for the leaf item.

Đầu ra từ 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
09 khi nó được thực hiện trong danh sách 
>>> from functools import reduce
>>> def factorial[n]:
...     return reduce[lambda x, y: x * y, range[1, n + 1] or [1]]
...

>>> factorial[4]
24
5 bây giờ trông như thế này:

>>>

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
2

Mỗi lần một cuộc gọi đến 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
09 chấm dứt, nó sẽ trả lại số lượng các yếu tố lá mà nó được ghi trong danh sách được truyền cho nó. Cuộc gọi cấp cao nhất trả về 
def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
3, như bình thường.

Đi qua một danh sách lồng nhau không được quy định

Giống như các ví dụ khác được hiển thị cho đến nay, Danh sách này, Traversal không yêu cầu đệ quy. Bạn cũng có thể hoàn thành nó lặp đi lặp lại. Ở đây, một khả năng:

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
3

Nếu bạn chạy phiên bản không nhận được này của 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
09 trên cùng danh sách như được hiển thị trước đó, bạn sẽ nhận được kết quả tương tự:

>>>

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
0

Chiến lược được sử dụng ở đây sử dụng một ngăn xếp để xử lý những người con được lồng nhau. Khi phiên bản 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
09 này gặp phải một người phụ, nó sẽ đẩy danh sách hiện đang được tiến hành và chỉ mục hiện tại trong danh sách đó lên một ngăn xếp. Khi nó đã tính trình phụ, hàm bật danh sách cha mẹ và chỉ mục từ ngăn xếp để nó có thể tiếp tục đếm nơi nó rời đi.

Trong thực tế, về cơ bản điều tương tự cũng xảy ra trong việc thực hiện đệ quy là tốt. Khi bạn gọi một chức năng đệ quy, Python sẽ lưu trạng thái của thể hiện thực thi trên ngăn xếp để cuộc gọi đệ quy có thể chạy. Khi kết thúc cuộc gọi đệ quy, trạng thái được bật từ ngăn xếp để thể hiện bị gián đoạn có thể tiếp tục. Nó cùng một khái niệm, nhưng với giải pháp đệ quy, Python đang thực hiện công việc tiết kiệm nhà nước cho bạn.

Lưu ý mức độ ngắn gọn và có thể đọc được mã đệ quy khi so sánh với phiên bản không nhận được:

Đệ quy so với danh sách lồng nhau không được ghi lại

Đây là một trường hợp sử dụng đệ quy chắc chắn là một lợi thế.

Phát hiện palindromes

Việc lựa chọn có nên sử dụng đệ quy để giải quyết vấn đề phụ thuộc vào phần lớn bản chất của vấn đề. Factorial, ví dụ, tự nhiên chuyển sang thực hiện đệ quy, nhưng giải pháp lặp cũng khá đơn giản. Trong trường hợp đó, nó được cho là một người ném lên.

Các vấn đề danh sách truyền tải là một câu chuyện khác. Trong trường hợp đó, giải pháp đệ quy là rất thanh lịch, trong khi loại không tái tạo là cồng kềnh ở mức tốt nhất.

Đối với vấn đề tiếp theo, sử dụng đệ quy được cho là ngớ ngẩn.

Một palindrom là một từ đọc cùng nhau về phía trước như nó là về phía trước. Các ví dụ bao gồm các từ sau:palindrome is a word that reads the same backward as it does forward. Examples include the following words:

  • Xe đua
  • Mức độ
  • Chèo xuồng
  • Reviver
  • Công dân

Nếu được yêu cầu nghĩ ra một thuật toán để xác định xem một chuỗi có phải là palindromic hay không, có lẽ bạn sẽ nghĩ ra một cái gì đó giống như đảo ngược chuỗi và xem nó có giống như bản gốc không. Bạn có thể nhận được đơn giản hơn thế.

Thậm chí hữu ích hơn, Python từ 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
24 Cú pháp cắt để đảo ngược một chuỗi cung cấp một cách thuận tiện để mã hóa nó:

>>>

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
5

Điều này là rõ ràng và súc tích. Có hầu như không cần phải tìm kiếm một giải pháp thay thế. Nhưng chỉ để cho vui, hãy xem xét định nghĩa đệ quy này của một palindrom:

  • Các trường hợp cơ sở: Một chuỗi trống và một chuỗi bao gồm một ký tự duy nhất là palindromic. An empty string and a string consisting of a single character are inherently palindromic.
  • Đệ quy khử: Một chuỗi có độ dài hai hoặc lớn hơn là một palindrom nếu nó thỏa mãn cả hai tiêu chí sau: A string of length two or greater is a palindrome if it satisfies both of these criteria:
    1. Các ký tự đầu tiên và cuối cùng là như nhau.
    2. Chất nền giữa các ký tự đầu tiên và cuối cùng là một palindrom.

Cắt lát là bạn của bạn ở đây là tốt. Đối với một chuỗi 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
25, việc lập chỉ mục và cắt, hãy cung cấp cho các chuỗi con sau:

  • Nhân vật đầu tiên là 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    26.
  • Nhân vật cuối cùng là 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    27.
  • Chất nền giữa các ký tự đầu tiên và cuối cùng là 
    >>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
    28.

Vì vậy, bạn có thể xác định 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
29 đệ quy như thế này:

>>>

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
6

Nó là một bài tập thú vị để suy nghĩ đệ quy, ngay cả khi nó không cần thiết.

Sắp xếp với Quicksort

Ví dụ cuối cùng được trình bày, giống như danh sách lồng nhau, là một ví dụ điển hình về một vấn đề rất tự nhiên gợi ý một cách tiếp cận đệ quy. Thuật toán Quicksort là một thuật toán sắp xếp hiệu quả được phát triển bởi nhà khoa học máy tính người Anh Tony Hoare vào năm 1959.

Quicksort là một thuật toán phân chia và chinh phục. Giả sử bạn có một danh sách các đối tượng để sắp xếp. Bạn bắt đầu bằng cách chọn một mục trong danh sách, được gọi là mục Pivot. Đây có thể là bất kỳ mục trong danh sách. Sau đó, bạn phân vùng danh sách thành hai người phụ dựa trên mục Pivot và sắp xếp các nhóm phụ.pivot item. This can be any item in the list. You then partition the list into two sublists based on the pivot item and recursively sort the sublists.

Các bước của thuật toán như sau:

  • Chọn mục Pivot.
  • Phân vùng danh sách thành hai người phụ:
    1. Những mặt hàng ít hơn mục Pivot
    2. Những vật phẩm lớn hơn mục xoay vòng
  • Quicksort The Subers đệ quy.

Mỗi phân vùng tạo ra những người phụ nhỏ hơn, vì vậy thuật toán được khử. Các trường hợp cơ sở xảy ra khi những người con là trống hoặc có một yếu tố, vì chúng vốn đã được sắp xếp.

Chọn mục Pivot

Thuật toán Quicksort sẽ hoạt động bất kể mục nào trong danh sách là mục Pivot. Nhưng một số lựa chọn tốt hơn những lựa chọn khác. Hãy nhớ rằng khi phân vùng, hai người phụ được tạo: một với các mục nhỏ hơn mục trục và một cái có các mục lớn hơn mục trục. Lý tưởng nhất, hai người con có chiều dài gần bằng nhau.

Hãy tưởng tượng rằng danh sách ban đầu của bạn để sắp xếp chứa tám mục. Nếu mỗi phân vùng dẫn đến những người phụ có chiều dài gần bằng nhau, thì bạn có thể đạt được các trường hợp cơ sở trong ba bước:

Phân vùng tối ưu, danh sách tám mục

Ở đầu kia của quang phổ, nếu sự lựa chọn của bạn về mục xoay đặc biệt không may mắn, mỗi phân vùng sẽ dẫn đến một người phụ chứa tất cả các mục gốc ngoại trừ mục Pivot và một người phụ khác trống. Trong trường hợp đó, phải mất bảy bước để giảm danh sách thành các trường hợp cơ sở:

Phân vùng dưới mức tối ưu, danh sách tám mục

Thuật toán Quicksort sẽ hiệu quả hơn trong trường hợp đầu tiên. Nhưng bạn cần phải biết điều gì đó trước về bản chất của dữ liệu mà bạn sắp xếp để chọn một cách có hệ thống các mục xoay tối ưu. Trong mọi trường hợp, có bất kỳ lựa chọn nào sẽ là tốt nhất cho tất cả các trường hợp. Vì vậy, nếu bạn viết một chức năng Quicksort để xử lý trường hợp chung, thì việc lựa chọn mục Pivot có phần tùy ý.

Mục đầu tiên trong danh sách là một lựa chọn phổ biến, như mục cuối cùng. Chúng sẽ hoạt động tốt nếu dữ liệu trong danh sách được phân phối khá ngẫu nhiên. Tuy nhiên, nếu dữ liệu đã được sắp xếp, hoặc thậm chí gần như vậy, thì chúng sẽ dẫn đến phân vùng dưới mức tối ưu như được hiển thị ở trên. Để tránh điều này, một số thuật toán Quicksort chọn mục giữa trong danh sách làm mục Pivot.

Một lựa chọn khác là tìm trung vị của các mục đầu tiên, cuối cùng và giữa trong danh sách và sử dụng nó làm mục Pivot. Đây là chiến lược được sử dụng trong mã mẫu dưới đây.

Thực hiện phân vùng

Khi bạn đã chọn mục Pivot, bước tiếp theo là phân vùng danh sách. Một lần nữa, mục tiêu là tạo ra hai người phụ, một người chứa các mục nhỏ hơn mục trục và cái còn lại chứa những thứ lớn hơn.

Bạn có thể thực hiện điều này trực tiếp tại chỗ. Nói cách khác, bằng cách hoán đổi các mục, bạn có thể xáo trộn các mục trong danh sách xung quanh cho đến khi mục xoay ở giữa, tất cả các mục ít hơn ở bên trái và tất cả các mục lớn hơn ở bên phải của nó. Sau đó, khi bạn nhanh chóng xác định những người con đệ quy, bạn đã chuyển các lát của danh sách sang trái và bên phải của mục Pivot.

Thay phiên, bạn có thể sử dụng khả năng thao tác danh sách Python, để tạo danh sách mới thay vì hoạt động trong danh sách ban đầu. Đây là cách tiếp cận được thực hiện trong mã dưới đây. Thuật toán như sau:

  • Chọn mục Pivot bằng phương pháp trung bình ba được mô tả ở trên.
  • Sử dụng mục Pivot, tạo ba người phụ:
    1. Các mục trong danh sách ban đầu ít hơn mục Pivot
    2. Mục Pivot
    3. Các mục trong danh sách ban đầu lớn hơn mục Pivot
  • Danh sách Quicksort đệ quy 1 và 3.
  • Concatenate cả ba danh sách lại với nhau.

Lưu ý rằng điều này liên quan đến việc tạo ra một nhóm phụ thứ ba có chứa mục Pivot. Một lợi thế cho phương pháp này là nó xử lý trơn tru trường hợp mục Pivot xuất hiện trong danh sách nhiều lần. Trong trường hợp đó, Danh sách 2 sẽ có nhiều hơn một yếu tố.

Sử dụng triển khai Quicksort

Bây giờ nền tảng đã được đặt ra, bạn đã sẵn sàng chuyển sang thuật toán Quicksort. Ở đây, mã Python:

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
7

Đây là những gì mỗi phần của 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
30 đang làm:

  • Dòng 4: Các trường hợp cơ sở trong đó danh sách trống hoặc chỉ có một phần tử duy nhất The base cases where the list is either empty or has only a single element
  • Dòng 7 đến 13: Tính toán mục Pivot bằng phương pháp trung bình ba Calculation of the pivot item by the median-of-three method
  • Dòng 14 đến 18: Tạo ra ba danh sách phân vùng Creation of the three partition lists
  • Các dòng 20 đến 24: Sắp xếp đệ quy và lắp lại danh sách phân vùng Recursive sorting and reassembly of the partition lists

Dưới đây là một số ví dụ về 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
30 trong hành động:

>>>

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
8

Đối với mục đích thử nghiệm, bạn có thể xác định một hàm ngắn tạo ra danh sách các số ngẫu nhiên giữa 

>>> def factorial[n]:
...     return 1 if n >> factorial[4]
24
2 và 
>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
33:

>>> def countdown[n]:
...     print[n]
...     if n == 0:
...         return             # Terminate recursion
...     else:
...         countdown[n - 1]   # Recursive call
...

>>> countdown[5]
5
4
3
2
1
0
9

Bây giờ bạn có thể sử dụng 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
34 để kiểm tra 
>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
30:

>>>

def countdown[n]:
    print[n]
    if n > 0:
        countdown[n - 1]
0

Để hiểu thêm về cách thức hoạt động của 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
30, hãy xem sơ đồ dưới đây. Điều này cho thấy chuỗi đệ quy khi sắp xếp danh sách mười hai phần tử:

Thuật toán Quicksort, danh sách mười hai phần tử

Trong bước đầu tiên, các giá trị danh sách đầu tiên, giữa và cuối cùng lần lượt là 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
37, 
>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
38 và 
>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
39. Trung bình là 
>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
37, do đó trở thành mục trục. Phân vùng đầu tiên sau đó bao gồm các nhóm phụ sau:

Người phụ nữvật phẩm
>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
41		Các mục ít hơn mục Pivot
>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
42		Mục Pivot
>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
43		Các mục lớn hơn mục xoay

Mỗi người phụ sau đó được phân vùng đệ quy theo cùng một cách cho đến khi tất cả các nhóm phụ chứa một phần tử hoặc trống. Khi các cuộc gọi đệ quy trở lại, các danh sách được lắp lại theo thứ tự được sắp xếp. Lưu ý rằng trong bước thứ hai đến cuối cùng bên trái, mục Pivot 

>>> function[]
Traceback [most recent call last]:
  File "", line 1, in 
  File "", line 3, in function
  File "", line 3, in function
  File "", line 3, in function
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
44 xuất hiện trong danh sách hai lần, do đó, danh sách mục Pivot có hai yếu tố.

Sự kết luận

Điều đó kết thúc hành trình của bạn thông qua đệ quy, một kỹ thuật lập trình trong đó một chức năng tự gọi. Đệ quy isn bằng bất kỳ phương tiện nào phù hợp cho mọi nhiệm vụ. Nhưng một số vấn đề lập trình hầu như khóc vì nó. Trong những tình huống đó, nó là một kỹ thuật tuyệt vời để có được sự xử lý của bạn.recursion, a programming technique in which a function calls itself. Recursion isn’t by any means appropriate for every task. But some programming problems virtually cry out for it. In those situations, it’s a great technique to have at your disposal.

Trong hướng dẫn này, bạn đã học được:

  • Ý nghĩa của một chức năng để tự gọi mình là đệ quyrecursively
  • Cách thiết kế các chức năng Python hỗ trợ đệ quydesign of Python functions supports recursion
  • Những yếu tố nào cần xem xét khi chọn liệu có nên giải quyết vấn đề hay khôngfactors to consider when choosing whether or not to solve a problem recursively
  • Cách thực hiện chức năng đệ quy trong Pythonimplement a recursive function in Python

Bạn cũng đã thấy một số ví dụ về các thuật toán đệ quy và so sánh chúng với các giải pháp không nhận được tương ứng.

Bây giờ bạn nên ở một vị trí tốt để nhận ra khi đệ quy được kêu gọi và sẵn sàng sử dụng nó một cách tự tin khi nó cần! Nếu bạn muốn khám phá thêm về đệ quy trong Python, thì hãy xem suy nghĩ đệ quy trong Python.

Chức năng nào liên tục tự gọi?

Đệ quy là một phương pháp trong C ++ tự gọi trực tiếp hoặc gián tiếp cho đến khi đáp ứng điều kiện phù hợp.Trong phương pháp này, chúng tôi liên tục gọi hàm trong cùng một hàm và nó có một trường hợp cơ sở và điều kiện đệ quy. is a method in C++ which calls itself directly or indirectly until a suitable condition is met. In this method, we repeatedly call the function within the same function, and it has a base case and a recursive condition.

Có thể cho một chức năng tự gọi?

Đệ quy là một khái niệm cực kỳ đơn giản: một chức năng chỉ đơn giản là tự gọi.Đệ quy đề cập đến một hàm tự gọi trực tiếp hoặc gián tiếp.. Recursion refers to a function that calls itself either directly or indirectly.

Một chức năng có thể tự chạy python?

Trong Python, một chức năng cũng có thể tự gọi!Một chức năng tự gọi được cho là đệ quy và kỹ thuật sử dụng một hàm đệ quy được gọi là đệ quy.it's also possible for a function to call itself! A function that calls itself is said to be recursive, and the technique of employing a recursive function is called recursion.

Chức năng đệ quy Python là gì?

Các hàm đệ quy trong Python Một hàm đệ quy là một hàm được xác định theo bản thân thông qua các biểu thức tự tham chiếu.Điều này có nghĩa là chức năng sẽ tiếp tục tự gọi và lặp lại hành vi của nó cho đến khi một số điều kiện được đáp ứng để trả về kết quả.a function defined in terms of itself via self-referential expressions. This means that the function will continue to call itself and repeat its behavior until some condition is met to return a result.

Bài Viết Liên Quan

Hướng dẫn how do you open a file using javascript? - làm thế nào để bạn mở một tập tin bằng javascript?
Hướng dẫn css hover image zoom - thu phóng hình ảnh di chuột css
Hướng dẫn recursive while loop python - đệ quy trong khi vòng lặp python
Hướng dẫn nonetype in python - không loại nào trong python
Hướng dẫn php group multidimensional array by key - nhóm php mảng đa chiều theo phím
Hướng dẫn php str_get_html - php str_get_html
Lịch nghỉ tết của nhà nước năm 2023
Hướng dẫn how many bytes is a string python? - một chuỗi python là bao nhiêu byte?
Hướng dẫn how to change color of scatter plot in python - cách thay đổi màu của biểu đồ phân tán trong python
Hướng dẫn is there a for loop in python? - có vòng lặp for trong python không?
Hướng dẫn mysql queries per second - truy vấn mysql mỗi giây
Hướng dẫn python call function from another function in same class - gọi hàm python từ một hàm khác trong cùng một lớp
Hướng dẫn php get first monday of year - php có được thứ hai đầu tiên của năm
Cơ chế quản lý bộ nhớ trong linux
An tâm hưng thịnh 2023
Hướng dẫn what are variables in php? - các biến trong php là gì?
Hướng dẫn phpspreadsheet read excel example - ví dụ về đọc phpspreadsheet excel
Các quyền của user linux
Hướng dẫn how do i remove spaces between two columns in excel? - làm cách nào để xóa khoảng trắng giữa hai cột trong excel?
Hướng dẫn dùng data plots python

Toplist mới

#1
Top 9 tập bản đồ lớp 8 bài 31 2023
5 tháng trước
#2
Top 6 kết quả thi hsg đà nẵng 2022 2023
5 tháng trước
#3
Top 9 tủ nhựa đài loan 4 cánh 3d 2023
5 tháng trước
#4
Top 9 chất khí có thể làm mất màu dung dịch nước brom là: a. so2. b. co2. c. o2. d. hcl. 2023
5 tháng trước
#5
Top 8 tìm việc làm tiện, phay bảo q7 2023
5 tháng trước
#6
Top 3 tôi xuyên thành tiểu kiều the của lão đại phản 2 2023
5 tháng trước
#7
Top 9 đổi mới phong cách, thái độ phục vụ của cán bộ y tế hướng tới sự hài lòng của người bệnh 2023
5 tháng trước
#8
Top 2 bài the dục phát triển chung lớp 6 2022 2023
5 tháng trước
#9
Top 3 bài giảng vũ điệu sắc màu (lớp 4) 2023
5 tháng trước

Bài mới nhất

Camera điều khiển tren không gọi là gì năm 2024
Ký hiệu ext trên tay cầm ps4 pro là gì năm 2024
Nghĩa vụ cơ bản của hợp đồng là gì năm 2024
Dùng ram như thế nào cho máy tính xem phim năm 2024
Bài tập định luật bôi lơ ma ri ốt năm 2024
Quỹ đầu tư pdf là viết tắt của từ gì năm 2024
Soạn bài rằm tháng giêng ngữ văn lớp 7 năm 2024
Giải toán nâng cao lớp 2 có đáp án năm 2024
Lỗi giựt màn hình trong fifa online 3 năm 2024
Bài tập xử lí sự kiện trong java năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Mẹo Hay Là gì Địa Điểm Hay Học Tốt mẹo hay Công Nghệ Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Top List bao nhieu bao nhiêu hướng dẫn Xây Đựng So Sánh Bài tập So sánh Tiếng anh Sản phẩm tốt Ngôn ngữ Bài Tập javascript Ở đâu Thế nào Hướng dẫn Dịch Máy tính Tại sao Đại học Món Ngon Khoa Học