从同一函数内调用函数是否安全？

如何解决从同一函数内调用函数是否安全？

我一直在阅读排序算法。我在合并排序时碰到了这段代码：

def mergeSort(arr):
    if len(arr) > 1:
        mid = len(arr)//2
        L = arr[:mid]
        R = arr[mid:]
        #function calls itself here<<<<<<<<<<<<<<<<<<<<<<<<<
        mergeSort(L)# Sorting the first half
        mergeSort(R)# Sorting the second half

        i = j = k = 0
    
        # Copy data to temp arrays L[] and R[] 
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i] 
                i+= 1
            else: 
                arr[k] = R[j] 
                j+= 1
                k+= 1
    
        # Checking if any element was left 
        while i < len(L): 
            arr[k] = L[i] 
            i+= 1
            k+= 1
    
        while j < len(R): 
            arr[k] = R[j] 
            j+= 1
            k+= 1

# Code to print the list 
def printList(arr):
    for i in range(len(arr)):
        print(arr[i],end =" ")
    print() 

# driver code to test the above code 
if __name__ == '__main__': 
    #arr = [12,11,13,5,6,7]
    arr = [38,27,43,3,9,82,10]
    print ("Given array is",end ="\n") 
    printList(arr) 
    mergeSort(arr) 
    print("Sorted array is: ",end ="\n") 
    printList(arr) 

# This code is contributed by Mayank Khanna 

如上所述，从自身内部调用了mergeSort（）函数，这是一种好习惯吗？我印象中这可能会导致错误。

解决方法

TL; DR通常很好，但是对于某些输入可能非常危险。

给定的mergeSort函数自称-这种现象称为recursion。

什么是递归

1. 解决问题的常用方法，其中解决方案取决于对同一问题的较小实例的解决方案；例如遍历二叉树。
2. 每个递归调用将函数参数推入call stack，并且每个调用都有其自己的局部变量。
3. 递归可能导致漏洞，例如DNS open recursion。
4. 如果由于未定义停止条件或处理导致大量递归调用的输入而被滥用，则会发生stack overflow（这意味着call stack已被最大程度地使用。 ）。
5. Any recursive solution can be converted to an iterative solution (solution using loops)

总结

1. 在合理的时间内调用函数是安全的。

2. Python的默认递归限制为1000，因此函数调用自身的次数不能超过1000次。

您可以使用getrecursionlimit对其进行验证：

import sys
print(sys.getrecursionlimit())

并使用setrecursionlimit进行更改：

new_recursion_limit = 1500
sys.setrecursionlimit(new_recursion_limit)

1. 递归可能会并且将导致漏洞，最好在处理用户输入时避免使用递归，而采用迭代解决方案。

P.S。

现在您也知道我们网站的名字了！

,

在内部调用函数没有问题，但是您要特别注意进入无限循环。一般的良好做法是仅在函数末尾调用该函数（这样可以减少混合变量值的机会），并使用某种if语句或某种意义上的某种方法来提供一种出路