Python 在另一个函数中定义函数的逻辑

我试图编写一个函数，返回所有可能的k-mers，每个输入DNA字符串的最大汉明距离为d。 我最初的尝试是尝试直接的迭代

def motif_enumeration(k, d, DNA):
    pattern = []
    c = 0
    combos = combination(k)
    for combo in combos:
        for strings in DNA:
            while c+k < len(DNA[0])-1:
                if d >= hammingDistance(combo, strings[c:c+k]):
                    #move onto next string 
                elif d < hammingDistance(combo, string[c:c+k]) and c+k == len(DNA[0])-1:
                    #if the combo wasn't valid for a string, move onto the next combo
                    break
                elif d < hammingDistance(combo, string[c:c+k]):
                    #change the window to see if the combo is valid later in the string 
                    c += 1
        pattern+=[combo]   
    return pattern

def motif_枚举（k，d，DNA）：
模式=[]
c=0
组合=组合（k）
对于组合中的组合：
对于DNA中的字符串：
而c+k=汉明距离（组合，字符串[c:c+k]）：
#转到下一个字符串
elif d

不幸的是，我了解到我不能为外部循环生成continue语句，我了解到实现这一点的最佳方法是在我的循环中定义一个函数，然后调用它。这让我非常困惑，但以下是我尝试的方法：

def motif_enumeration(k, d, DNA):
    combos = combination(k)
    global pattern
    global c
    for combo in combos:
        def inner(string, combo, count):
            global pattern
            global DNA
            global c
            if count==len(DNA):
                pattern += [combo]
                return pattern
            while c+k <= len(DNA[0])-1:
                if d >= hammingDistance(combo, string[c:c+k]):
                    #move onto next string 
                        count+=1
                        c = 0
                        string = DNA[count]
                        return inner(string, combo, count)
                elif d < hammingDistance(combo, string[c:c+k]) and c+k == len(DNA[0])-1:
                    #if the combo wasn't valid for a string, the inner function loop breaks
                    break
                elif d < hammingDistance(combo, string[c:c+k]):
                    #change the window to see if the combo is valid later in the string 
                    c += 1
        inner(DNA[0], combo, count = 0)
    return pattern

def motif_枚举（k，d，DNA）：
组合=组合（k）
全球模式
全球c
对于组合中的组合：
def内部（字符串、组合、计数）：
全球模式
全局DNA
全球c
如果计数==len（DNA）：
模式+=[组合]
返回模式
而c+k=汉明距离（组合，字符串[c:c+k]）：
#转到下一个字符串
计数+=1
c=0
字符串=DNA[计数]
返回内部（字符串、组合、计数）
elif d

我的逻辑是，我的内部函数将遍历列表DNA中的所有字符串，如果汉明距离小于或等于d，它将在脑海中不断调用新的DNA元素。然后，如果所有这些都满足条件，因此count==len（DNA），那么模式将被更新并返回（因为它是一个全局变量，我不需要返回内部函数，只需调用它）。 但是，这不会返回任何内容。有没有任何建议的阅读资料或直接的建议来帮助解决这个问题？

你不需要在另一种方法中定义一种方法。您只需要在第一个方法中调用内部方法。通过这种方式移动到外部循环中的下一个迭代，您可以在

内部循环中调用
return

def motif_enumeration(k, d, DNA):
    pattern = []
    c = 0
    combos = combination(k)
    for combo in combos:
        inner_loop(k,d,DNA,combo, c)
    return pattern

def inner_loop(k, d, DNA, combo, c):
    for strings in DNA:
        inner_loop_two(k, d, DNA, combo, c)

编辑
要实现
##移动到下一个字符串
代码，可以使用另一个内部函数

您可以像这样拆分
内部循环
：

def inner_loop(k, d, DNA, combo, c):
    for strings in DNA:
        inner_loop_two(k, d, DNA, combo, c)

def inner_loop_two(k, d, DNA, combo, c):
    while c+k < len(DNA[0])-1:
        if d >= hammingDistance(combo, strings[c:c+k]):
            #move onto next string 
            continue
        elif d < hammingDistance(combo, string[c:c+k]) and c+k == len(DNA[0])-1:
            #if the combo wasn't valid for a string, move onto the next combo
            break
        elif d < hammingDistance(combo, string[c:c+k]):
            #change the window to see if the combo is valid later in the string 
            c += 1
    pattern+=[combo] 

def内循环（k、d、DNA、组合、c）：
对于DNA中的字符串：
内环（k，d，DNA，组合，c）
def内循环（k、d、DNA、组合、c）：
而c+k=汉明距离（组合，字符串[c:c+k]）：
#转到下一个字符串
持续
elif d
如何在代码中输入“移动到下一个字符串”？