Trong chương trình này, bạn sẽ học cách in trình tự Fibonacci bằng cách sử dụng vòng lặp.
Để hiểu ví dụ này, bạn nên có kiến thức về các chủ đề lập trình Python sau:
- Python nếu ... tuyên bố khác
- Python trong khi vòng lặp
Trình tự Fibonacci là chuỗi số nguyên là 0, 1, 1, 2, 3, 5, 8 ....
Hai thuật ngữ đầu tiên là 0 và 1. Tất cả các thuật ngữ khác có được bằng cách thêm hai thuật ngữ trước đó. Điều này có nghĩa là để nói thuật ngữ thứ n là tổng của [n-1] và thuật ngữ [n-2].
Mã nguồn
# Program to display the Fibonacci sequence up to n-th term
nterms = int[input["How many terms? "]]
# first two terms
n1, n2 = 0, 1
count = 0
# check if the number of terms is valid
if nterms >>>>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
Bên trong fibonacci_of[], trước tiên bạn kiểm tra trường hợp cơ sở. Sau đó, bạn trả về tổng của các giá trị kết quả từ việc gọi hàm với hai giá trị trước là
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0. Danh sách hiểu biết ở cuối ví dụ tạo ra chuỗi Fibonacci với mười lăm số đầu tiên.Chức năng này nhanh chóng rơi vào vấn đề lặp lại mà bạn đã thấy trong phần trên. Việc tính toán ngày càng đắt hơn khi
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 trở nên lớn hơn. Thời gian cần thiết tăng theo cấp số nhân vì hàm tính toán nhiều vấn đề phụ giống hệt nhau nhiều lần.Để tính f [5], fibonacci_of[] phải tự gọi mình là mười lăm lần. Để tính toán f [n], độ sâu tối đa của cây cuộc gọi là n và vì mỗi cuộc gọi hàm tạo ra hai cuộc gọi hàm bổ sung, độ phức tạp của hàm đệ quy này là O [2N].
Hầu hết các cuộc gọi đó đều dư thừa vì bạn đã tính toán kết quả của họ. F [3] xuất hiện hai lần và F [2] xuất hiện ba lần. F [1] và F [0] là các trường hợp cơ sở, vì vậy, nó tốt để gọi chúng nhiều lần. Bạn có thể muốn tránh sự lặp lại lãng phí này, đó là chủ đề của các phần sau.
Tối ưu hóa thuật toán đệ quy cho chuỗi Fibonacci
Có ít nhất hai kỹ thuật bạn có thể sử dụng để tạo thuật toán để tạo chuỗi Fibonacci hiệu quả hơn, nói cách khác, để mất ít thời gian hơn để tính toán. Những kỹ thuật này đảm bảo rằng bạn không liên tục tính toán các giá trị giống nhau nhiều lần, đó là điều làm cho thuật toán ban đầu trở nên không hiệu quả. Họ gọi là ghi nhớ và lặp lại.
Ghi nhớ thuật toán đệ quy
Như bạn đã thấy trong mã trên, hàm Fibonacci tự gọi mình nhiều lần với cùng một đầu vào. Thay vì một cuộc gọi mới mỗi lần, bạn có thể lưu trữ kết quả của các cuộc gọi trước đó trong một cái gì đó như bộ nhớ bộ nhớ. Bạn có thể sử dụng danh sách Python để lưu trữ kết quả của các tính toán trước đó. Kỹ thuật này được gọi là ghi nhớ.memoization.
Ghi nhớ tăng tốc độ thực hiện các hàm đệ quy đắt tiền bằng cách lưu trữ kết quả được tính toán trước đó trong bộ đệm. Bằng cách này, khi cùng một đầu vào xảy ra một lần nữa, chức năng chỉ cần tra cứu kết quả tương ứng và trả về nó mà không phải chạy lại tính toán. Bạn có thể tham khảo những kết quả này là bộ nhớ cache hoặc ghi nhớ:cached or memoized:
Với ghi nhớ, bạn chỉ cần đi qua cây cuộc gọi có độ sâu n một lần sau khi trở về từ trường hợp cơ sở, khi bạn lấy tất cả các giá trị được tính toán trước đó được tô màu vàng, F [2] và F [3], từ bộ đệm trước đó.
Đường dẫn màu cam cho thấy rằng không có đầu vào cho hàm fibonacci được gọi là nhiều lần. Điều này làm giảm đáng kể độ phức tạp thời gian của thuật toán từ O [2N] theo cấp số nhân đến tuyến tính O [N].
Ngay cả đối với các trường hợp cơ sở, bạn có thể thay thế gọi F [0] và F [1] chỉ bằng cách truy xuất các giá trị trực tiếp từ bộ đệm tại các chỉ số 0 và 1, vì vậy bạn sẽ gọi hàm chỉ sáu lần thay vì mười lăm!
Ở đây, một bản dịch có thể có của tối ưu hóa này sang mã Python:
>>>
>>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
Bên trong fibonacci_of[], trước tiên bạn kiểm tra trường hợp cơ sở. Sau đó, bạn trả về tổng của các giá trị kết quả từ việc gọi hàm với hai giá trị trước là
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0. Danh sách hiểu biết ở cuối ví dụ tạo ra chuỗi Fibonacci với mười lăm số đầu tiên.Nếu không có số Fibonacci cho giá trị hiện tại của
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0, thì bạn tính toán nó bằng cách gọi fibonacci_of[] đệ quy và cập nhật How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
3. Bước cuối cùng là trả về số Fibonacci được yêu cầu.
Khám phá một thuật toán lặp
Điều gì sẽ xảy ra nếu bạn không cần phải gọi chức năng Fibonacci đệ quy thì sao? Bạn thực sự có thể sử dụng một thuật toán lặp để tính toán số tại vị trí
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 trong chuỗi Fibonacci.Bạn biết rằng hai số đầu tiên trong chuỗi là 0 và 1 và mỗi số tiếp theo trong chuỗi là tổng của hai người tiền nhiệm trước đó. Vì vậy, bạn chỉ có thể tạo một vòng lặp thêm hai số trước đó,
>>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0 và >>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
1, cùng nhau tìm số tại vị trí How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 trong chuỗi.Các số màu tím đậm trong sơ đồ dưới đây thể hiện các số mới cần được tính toán và thêm vào
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
3 trong mỗi bước lặp lại:Để tính toán số Fibonacci tại vị trí
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0, bạn lưu trữ hai số đầu tiên của chuỗi, 0 và 1, trong How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
3. Sau đó, tính toán các số tiếp theo liên tiếp cho đến khi bạn có thể trả lại >>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
6.Tạo ra chuỗi Fibonacci trong Python
Bây giờ bạn đã biết những điều cơ bản về cách tạo ra chuỗi Fibonacci, đó là thời gian để đi sâu hơn và khám phá thêm các cách khác nhau để thực hiện thuật toán cơ bản trong Python. Trong các phần sau, bạn sẽ khám phá cách thực hiện các thuật toán khác nhau để tạo trình tự Fibonacci bằng cách sử dụng đệ quy, lập trình hướng đối tượng Python và lặp lại.
Sử dụng đệ quy và lớp Python
Cách tiếp cận đầu tiên của bạn để tạo chuỗi Fibonacci sẽ sử dụng lớp Python và đệ quy. Một lợi thế của việc sử dụng lớp so với hàm đệ quy được ghi nhớ mà bạn đã thấy trước đó là một lớp giữ trạng thái và hành vi [đóng gói] với nhau trong cùng một đối tượng. Tuy nhiên, trong ví dụ chức năng,
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
3 là một đối tượng hoàn toàn riêng biệt, vì vậy bạn không có quyền kiểm soát nó.Dưới đây là mã thực hiện giải pháp dựa trên lớp của bạn:
1# fibonacci_class.py
2
3class Fibonacci:
4 def __init__[self]:
5 self.cache = [0, 1]
6
7 def __call__[self, n]:
8 # Validate the value of n
9 if not [isinstance[n, int] and n >= 0]:
10 raise ValueError[f'Positive integer number expected, got "{n}"']
11
12 # Check for computed Fibonacci numbers
13 if n >> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
8. defines the >>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
8 class.Dòng 4 xác định trình khởi tạo lớp, >>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
9. Nó có một phương pháp đặc biệt mà bạn có thể sử dụng để khởi tạo các phiên bản lớp của mình. Các phương pháp đặc biệt đôi khi được gọi là các phương pháp Dunder, viết tắt cho các phương pháp nhấn mạnh gấp đôi. defines the class initializer,
>>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
9. It’s a special method that you can use to initialize your class instances. Special methods are sometimes referred to as dunder methods,
short for double underscore methods.Dòng 5 tạo thuộc tính thể hiện >>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0, có nghĩa là bất cứ khi nào bạn tạo đối tượng >>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
8, sẽ có bộ đệm cho nó. Thuộc tính này ban đầu chứa các số đầu tiên trong chuỗi Fibonacci. creates the
>>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0 instance attribute, which means that whenever you create a >>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
8 object, there will be a cache for it. This attribute initially contains the first numbers in the Fibonacci sequence.Dòng 7 xác định một phương pháp đặc biệt khác, >>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
2. Phương pháp này biến các phiên bản của >>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
8 thành các đối tượng có thể gọi được. defines another special method,
>>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
2. This method turns the instances of >>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
8 into callable objects.Dòng 9 và 10 xác nhận giá trị của How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 bằng cách sử dụng câu lệnh có điều kiện. Nếu How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 không phải là số nguyên dương, thì phương pháp này sẽ tăng >>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
6.
validate the value of
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 by using a conditional statement. If How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 is not a positive integer number, then the method raises a >>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
6.Dòng 13 xác định một câu lệnh có điều kiện để kiểm tra các số Fibonacci đã được tính toán và có sẵn trong >>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0. Nếu số tại INDEX How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 đã có trong >>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0, thì dòng 14 sẽ trả về nó. Mặt khác, dòng 17 tính toán số và dòng 18 nối nó vào >>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0 để bạn không phải tính toán lại. defines a conditional statement to check for those Fibonacci numbers that were already calculated and are available in
>>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0. If the number at index How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 is already in >>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0, then line 14 returns it. Otherwise, line 17 computes the number, and line 18 appends it to >>> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0 so you don’t have to compute
it again.Dòng 20 Trả về số Fibonacci được yêu cầu. returns the requested Fibonacci number.
Để thử mã này, hãy tiếp tục và lưu nó vào
1# fibonacci_class.py
2
3class Fibonacci:
4 def __init__[self]:
5 self.cache = [0, 1]
6
7 def __call__[self, n]:
8 # Validate the value of n
9 if not [isinstance[n, int] and n >= 0]:
10 raise ValueError[f'Positive integer number expected, got "{n}"']
11
12 # Check for computed Fibonacci numbers
13 if n >>>>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
Tại đây, bạn tạo và sau đó gọi một thể hiện của lớp
>>> def fibonacci_of[n]:
... if n in {0, 1}: # Base case
... return n
... return fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
...
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
8 có tên 1# fibonacci_class.py
2
3class Fibonacci:
4 def __init__[self]:
5 self.cache = [0, 1]
6
7 def __call__[self, n]:
8 # Validate the value of n
9 if not [isinstance[n, int] and n >= 0]:
10 raise ValueError[f'Positive integer number expected, got "{n}"']
11
12 # Check for computed Fibonacci numbers
13 if n = 0]:
10 raise ValueError[f'Positive integer number expected, got "{n}"']
11
12 # Check for computed Fibonacci numbers
13 if n = 0]:
10 raise ValueError[f'Positive integer number expected, got "{n}"']
11
12 # Check for computed Fibonacci numbers
13 if n >> cache = {0: 0, 1: 1}
>>> def fibonacci_of[n]:
... if n in cache: # Base case
... return cache[n]
... # Compute and cache the Fibonacci number
... cache[n] = fibonacci_of[n - 1] + fibonacci_of[n - 2] # Recursive case
... return cache[n]
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
0 giữ các số đã được tính toán từ cuộc gọi đến cuộc gọi.
Hình dung thuật toán trình tự Fibonacci đã ghi nhớ
Bạn có thể hiểu một cách hiệu quả mỗi cuộc gọi đến hàm Fibonacci đệ quy được xử lý bằng cách sử dụng biểu diễn ngăn xếp cuộc gọi. Cách mỗi cuộc gọi được đẩy lên ngăn xếp và bật ra phản ánh chính xác cách chương trình chạy. Nó thể hiện rõ ràng cách tính toán số lượng lớn sẽ mất nhiều thời gian nếu bạn không tối ưu hóa thuật toán.
Trong một ngăn xếp cuộc gọi, bất cứ khi nào một hàm trả về kết quả, một khung ngăn xếp biểu thị cuộc gọi hàm được bật ra khỏi ngăn xếp. Bất cứ khi nào bạn gọi một hàm, bạn thêm một khung ngăn xếp mới vào đầu ngăn xếp. Nói chung, hoạt động này có độ phức tạp không gian của O [N] vì không có nhiều hơn N khung ngăn xếp trên ngăn xếp cuộc gọi tại một thời điểm.
Để trực quan hóa thuật toán Fibonacci đệ quy đã ghi nhớ, bạn sẽ sử dụng một tập hợp các sơ đồ đại diện cho ngăn xếp cuộc gọi. Số bước được biểu thị bằng nhãn màu xanh bên dưới mỗi ngăn xếp cuộc gọi.
Nói rằng bạn muốn tính toán F [5]. Để thực hiện việc này, bạn đẩy cuộc gọi đầu tiên đến chức năng vào ngăn xếp cuộc gọi:
Để tính toán F [5], bạn phải tính toán F [4] như được phác thảo bởi mối quan hệ tái phát Fibonacci, vì vậy bạn thêm cuộc gọi chức năng mới đó vào ngăn xếp:
Để tính toán F [4], bạn phải tính toán F [3], vì vậy bạn thêm một cuộc gọi chức năng khác vào ngăn xếp:
Để tính toán F [3], bạn phải tính toán F [2], do đó bạn thêm một cuộc gọi chức năng khác vào ngăn xếp cuộc gọi:
Để tính toán F [2], bạn phải tính toán F [1], vì vậy bạn thêm nó vào ngăn xếp. Vì F [1] là một trường hợp cơ sở, nó trở lại ngay lập tức với 1 và bạn xóa cuộc gọi này khỏi ngăn xếp:
Bây giờ bạn bắt đầu thư giãn kết quả đệ quy. F [1] Trả lại kết quả trở lại chức năng gọi của nó, F [2]. Để tính toán F [2], bạn cũng cần tính toán F [0]:
Bạn thêm f [0] vào ngăn xếp. Vì F [0] là một trường hợp cơ sở, nó trở lại ngay lập tức, cung cấp cho bạn 0. Bây giờ bạn có thể xóa nó khỏi ngăn xếp cuộc gọi:
Kết quả gọi F [0] này được trả lại cho F [2]. Bây giờ bạn có những gì bạn cần tính toán F [2] và loại bỏ nó khỏi ngăn xếp:
Kết quả của F [2] được trả lại cho người gọi của nó, F [3]. F [3] cũng cần kết quả của F [1] để hoàn thành tính toán của nó, do đó bạn thêm nó trở lại vào ngăn xếp:
F [1] là trường hợp cơ sở và giá trị của nó có sẵn trong bộ đệm, do đó bạn có thể trả lại kết quả ngay lập tức và xóa F [1] khỏi ngăn xếp:
Bạn có thể hoàn thành tính toán cho F [3], đó là 2:
Bạn xóa F [3] khỏi ngăn xếp sau khi hoàn thành tính toán của nó và trả lại kết quả cho người gọi của nó, F [4]. F [4] cũng cần kết quả của F [2] để tính toán giá trị của nó:
Bạn đẩy cuộc gọi đến F [2] lên ngăn xếp. Đây là nơi bộ đệm tiện lợi xuất hiện. Bạn đã tính toán nó trước đây, vì vậy bạn chỉ có thể lấy giá trị từ bộ đệm, tránh một cuộc gọi đệ quy để tính toán kết quả của F [2]. Bộ đệm trả về 1 và bạn xóa F [2] khỏi ngăn xếp:
F [2] được trả lại cho người gọi của nó và bây giờ F [4] có tất cả những gì nó cần để tính toán giá trị của nó, đó là 3:
Tiếp theo, bạn xóa F [4] khỏi ngăn xếp và trả lại kết quả của nó cho người gọi cuối cùng và nguyên bản, F [5]:
F [5] hiện có kết quả của F [4] và cũng là kết quả của F [3]. Bạn đẩy một cuộc gọi F [3] vào ngăn xếp và bộ đệm tiện lợi lại phát huy tác dụng. Trước đây bạn đã tính F [3], vì vậy tất cả những gì bạn cần làm là lấy nó từ bộ đệm. Không có quá trình đệ quy để tính toán F [3]. Nó trả về 2 và bạn loại bỏ F [3] khỏi ngăn xếp:
Bây giờ F [5] có tất cả các giá trị cần thiết để tính toán giá trị của chính nó. Bạn nhận được 5 bằng cách thêm 3 và 2, và đó là bước cuối cùng trước khi bạn bật F [5] gọi ra khỏi ngăn xếp. Hành động này kết thúc chuỗi các cuộc gọi chức năng đệ quy của bạn:
Ngăn xếp cuộc gọi hiện đang trống. Bạn đã hoàn thành bước cuối cùng để tính toán F [5]:
Đại diện cho các cuộc gọi chức năng đệ quy bằng sơ đồ ngăn xếp cuộc gọi giúp bạn hiểu tất cả các công việc diễn ra phía sau hậu trường. Nó cũng cho phép bạn xem có bao nhiêu tài nguyên một chức năng đệ quy có thể chiếm.
Đặt tất cả các sơ đồ này lại với nhau cho phép bạn hình dung toàn bộ quá trình trông như thế nào:
Bạn có thể nhấp vào hình ảnh ở trên để phóng to các bước riêng lẻ. Nếu bạn không có bộ đệm được tính toán trước đó, một số giai đoạn ngăn xếp trong sơ đồ này sẽ cao hơn, điều đó có nghĩa là họ sẽ mất nhiều thời gian hơn để trả về kết quả cho người gọi tương ứng.
Sử dụng phép lặp và chức năng Python
Ví dụ trong các phần trước thực hiện một giải pháp đệ quy sử dụng ghi nhớ như một chiến lược tối ưu hóa. Trong phần này, bạn sẽ mã hóa một hàm sử dụng lặp. Mã bên dưới thực hiện một phiên bản lặp của thuật toán trình tự Fibonacci của bạn:
1# fibonacci_func.py
2
3def fibonacci_of[n]:
4 # Validate the value of n
5 if not [isinstance[n, int] and n >= 0]:
6 raise ValueError[f'Positive integer number expected, got "{n}"']
7
8 # Handle the base cases
9 if n in {0, 1}:
10 return n
11
12 previous, fib_number = 0, 1
13 for _ in range[2, n + 1]:
14 # Compute the next Fibonacci number, remember the previous one
15 previous, fib_number = fib_number, previous + fib_number
16
17 return fib_number
Bây giờ, thay vì sử dụng đệ quy trong fibonacci_of[], bạn đã sử dụng phép lặp. Việc triển khai thuật toán trình tự Fibonacci này chạy trong thời gian tuyến tính O [n]. Ở đây, một sự cố của mã:
Dòng 3 định nghĩa fibonacci_of[], có số nguyên dương, How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0, làm đối số. defines fibonacci_of[], which takes a positive integer,
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0, as an argument.Dòng 5 và 6 thực hiện xác thực thông thường của How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0. perform the usual validation of
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0.Dòng 9 và 10 xử lý các trường hợp cơ sở trong đó How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 là 0 hoặc 1. handle
the base cases where
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0 is either 0 or 1.Dòng 12 xác định hai biến cục bộ, >>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
2 và >>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
3 và khởi tạo chúng với hai số đầu tiên trong chuỗi Fibonacci. defines two local variables,
>>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
2 and >>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
3, and initializes them with the first two numbers in the Fibonacci sequence.Dòng 13 bắt đầu một vòng >>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
4 lặp lại từ >>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
5 đến >>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
6. Vòng lặp sử dụng một dấu gạch dưới [>>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
7] cho biến vòng lặp vì nó là một biến vứt bỏ và bạn đã giành được giá trị này trong mã. starts a
>>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
4 loop that iterates from >>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
5 to >>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
6. The loop uses an underscore [>>> from fibonacci_class import Fibonacci
>>> fibonacci_of = Fibonacci[]
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
7] for the loop variable because it’s a throwaway variable and you won’t be
using this value in the code.Dòng 15 tính toán số Fibonacci tiếp theo trong chuỗi và nhớ số trước. computes the next Fibonacci number in the sequence and remembers the previous one.
Dòng 17 Trả về số Fibonacci được yêu cầu. returns the requested Fibonacci number.
Để thử mã này, hãy quay lại phiên tương tác của bạn và chạy mã sau:
>>>
>>> from fibonacci_func import fibonacci_of
>>> fibonacci_of[5]
5
>>> fibonacci_of[6]
8
>>> fibonacci_of[7]
13
>>> [fibonacci_of[n] for n in range[15]]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
Việc thực hiện fibonacci_of[] này là khá tối thiểu. Nó sử dụng không bao gồm việc giải nén để tính toán các số fibonacci trong các vòng lặp, điều này khá hiệu quả. Tuy nhiên, mỗi khi bạn gọi hàm có giá trị khác nhau là ____10, nó phải tái tính trình tự một lần nữa. Để khắc phục điều này, bạn có thể sử dụng đóng cửa và làm cho chức năng của bạn nhớ các giá trị đã được tính toán giữa các cuộc gọi. Hãy tiếp tục và thử nó!iterable unpacking to compute the Fibonacci numbers during the loops, which is quite efficient memory-wise. However, every time you call the function with a different value of
How many terms? 7
Fibonacci sequence:
0
1
1
2
3
5
8
0, it has to recompute the sequence over again. To fix this, you can use closures and make your function remember the already computed values between calls. Go ahead and give it
a try!Sự kết luận
Trình tự Fibonacci có thể giúp bạn cải thiện sự hiểu biết của bạn về đệ quy. Trong hướng dẫn này, bạn đã học được chuỗi Fibonacci là gì. Bạn cũng đã tìm hiểu về một số thuật toán phổ biến để tạo ra chuỗi và cách dịch chúng thành mã Python.Fibonacci sequence is. You’ve also learned about some common algorithms to generate the sequence and how to translate them into Python code.
Trình tự Fibonacci có thể là một bàn đạp tuyệt vời và điểm vào thế giới đệ quy, đây là một kỹ năng cơ bản để có một lập trình viên.
Trong hướng dẫn này, bạn đã học được cách:
- Tạo chuỗi Fibonacci bằng thuật toán đệ quyrecursive algorithm
- Tối ưu hóa thuật toán Fibonacci đệ quy của bạn bằng cách sử dụng ghi nhớmemoization
- Tạo chuỗi Fibonacci bằng thuật toán lặpiterative algorithm
Bạn cũng đã hình dung thuật toán đệ quy ghi nhớ để hiểu rõ hơn về cách nó hoạt động đằng sau hậu trường. Để làm điều đó, bạn đã sử dụng sơ đồ ngăn xếp cuộc gọi.call stack diagram.
Khi bạn nắm vững các khái niệm trong hướng dẫn này, các kỹ năng lập trình Python của bạn sẽ được cải thiện cùng với tư duy thuật toán đệ quy của bạn.
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Khám phá chuỗi Fibonacci với Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding:
Exploring the Fibonacci Sequence With Python
Làm thế nào để bạn giải quyết một chuỗi Fibonacci trong Python?
Mã nguồn Chúng tôi khởi tạo thuật ngữ đầu tiên thành 0 và thuật ngữ thứ hai thành 1. Nếu số lượng điều khoản là hơn 2, chúng tôi sử dụng vòng lặp trong thời gian để tìm thuật ngữ tiếp theo trong chuỗi bằng cách thêm hai thuật ngữ trước đó.Sau đó, chúng tôi trao đổi các biến [cập nhật nó] và tiếp tục với quy trình.We initialize the first term to 0 and the second term to 1. If the number of terms is more than 2, we use a while loop to find the next term in the sequence by adding the preceding two terms. We then interchange the variables [update it] and continue on with the process.
Làm thế nào để bạn giải một phương trình Fibonacci?
Trình tự Fibonacci = 0, 1, 1, 2, 3, 5, 8, 13, 21,.Có thể thu được bằng cách thêm thuật ngữ thứ ba và thứ tư [1+2], v.v.Ví dụ, thuật ngữ tiếp theo sau 21 có thể được tìm thấy bằng cách thêm 13 và 21. Do đó, thuật ngữ tiếp theo trong chuỗi là 34.“3” is obtained by adding the third and fourth term [1+2] and so on. For example, the next term after 21 can be found by adding 13 and 21. Therefore, the next term in the sequence is 34.