التكرار (Recursion) في بايثون

في هذا المقال، ستتعلم كيفية إنشاء وظائف تكرارية (وظائف تسمي نفسها).

ما هو التكرار في بايثون؟

التكرار هو عملية تحديد بعض الأشياء بناءً على نفسها.

مثال في العالم الطبيعي هو وضع مرايا متوازية تواجه بعضها البعض. أي جسم بينها سيتم انعكاسه بشكل تكراري.

وظيفة بايثون التكرارية

في بايثون، نعرفوظيفةيمكن تسمية وظائف أخرى. قد تقوم الوظيفة بتسمية نفسها. هذه الأنواع من البنيات تسمى الوظائف التكرارية.

فيما يلي مثال على وظيفة تكرارية لتحديد مضاعف عدد صحيح.

مضاعف الرقم هو المنتج لكل الأعداد الصحيحة من 1 إلى هذا الرقم. على سبيل المثال، مضاعف 6 (مكتوب ك6!) هو1 * 2 * 3 * 4 * 5 * 6 = 720。

مثال على وظيفة تكرارية

def calc_factorial(x):
　　　　"""
　　　　وظيفة حساب مضاعف عدد صحيح
　　　　if x == 1:
　　　　　　　　return 1
　　　　else:
　　　　　　　　return (x * calc_factorial(x-1))
num = 4
print("The factorial of", num, "is", calc_factorial(num))

في المثال السابق، func_calc_factorial() هي وظيفة تكرارية، وتقوم بتسمية نفسها.

عندما نستدعي هذه الوظيفة بعدد صحيح، فإنها ستقوم بتكرار نفسها باستخدام عدد أقل.

كل وظيفة تقوم بضرب الرقم في مضاعفه الخاص به حتى يصبح 1. يمكن شرح هذه النداءات التكرارية في الخطوات التالية.

calc_factorial(4) # 1st call with 4
4 * calc_factorial(3) # 2nd call with 3
4 * 3 * calc_factorial(2) # 3rd call with 2
4　*　3　*　2　*　calc_factorial(1)　　#　4th　call　with　1
4　*　3　*　2　*　1　　　　　　　　　　　　　　　　　　#　return　from　4th　call　as　number=1
4　*　3　*　2　　　　　　　　　　　　　　　　　　　　　　#　return　from　3rd　call
4　*　6　　　　　　　　　　　　　　　　　　　　　　　　　　#　return　from　2nd　call
24　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#　return　from　1st　call

当数字减少到1时，递归结束。这称为基本条件。

每个递归函数必须具有停止递归的基本条件，否则该函数将无限调用自身。

Python解释器限制了递归的深度，以帮助避免无限递归，从而导致堆栈溢出。

默认情况下，最大递归深度为 1000。如果超出限制，则结果为RecursionError。让我们看一个这样的条件。

def　recursor():
　　　　recursor()
recursor()

输出结果

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

递归的优点

1. 递归函数使代码看起来干净整洁。

2. 使用递归可以将复杂的任务分解为更简单的子问题。

3. 与使用嵌套嵌套相比，使用递归更容易生成序列。

递归的缺点

1. 有时，递归背后的逻辑很难遵循。

2. 递归调用很昂贵（效率低），因为它们占用大量内存和时间。

3. 递归函数很难调试。