Python 我试图通过删除索引来简化代码

这是我的名为

find（text，substring）

的递归函数，如果子字符串在文本中，它将返回子字符串；如果子字符串不在文本中，它将返回空字符串。另一个名为

的函数是\u string（text，string）

以测试

find

函数。如果字符串在文本内，函数将返回

True

；如果字符串不在文本内，函数将返回

False

我是否能够取消文本索引和子字符串索引，以删除打印编码区域的两个

（0,0）

，从而减少我的代码，使其更简单、更易于理解，以便我可以教我的学生

def find（文本、子字符串、文本索引、子字符串索引）：
如果text_index==len（text）和子字符串_index！=len（子字符串）：
返回错误
如果子字符串_index==len（子字符串）：
返回真值
如果文本[文本索引]==子字符串[子字符串索引]：
返回查找（文本、子字符串、文本索引+1、子字符串索引+1）
返回错误
def oo（文本、子字符串、文本索引、子字符串索引）：
如果text_index==len（text）：
返回错误
如果文本[文本索引]==子字符串[子字符串索引]：
如果查找（文本、子字符串、文本索引、子字符串索引）：
返回真值
其他：
返回oo（文本、子字符串、文本索引+1、子字符串索引）
返回oo（文本、子字符串、文本索引+1、子字符串索引）
打印（oo（“我爱派”，“派”，0,0））
打印（oo（“我爱pie1”，“pie1”，0,0））

在代码中，使用oo（）检查字符是否匹配，然后调用find（）检查其余字符是否匹配。您可以使用检查字符串相等性的思想，而不是逐个字符进行检查。在oo（）函数中，可以检查子字符串是否等于原始文本的拼接。这将减少代码，但会使find（）函数过时，同时仍然可以作为递归的简单演示

def oo(text, substring, index): 
    if index == len(text):
        return False  

    start = index
    end = start + len(substring)  

    if text[start:end] == substring: 
        return True
    else: 
        return oo(text, substring, index+1) 


print(oo("I love pie", "pie",0)) 
print(oo("I love pie1", "pie1",0))
print(oo("I love pie", "pie1",0))
print(oo("I love pie1", "pie",0))
print(oo("pie", "pie",0))
print(oo("pi", "pie1",0))
print(oo("pie1", "pie",1))

输出：

True
True
False
True
True
False
False

---

如果您想从print命令中永久删除索引，您可以使用一个类。通过这种方式，您甚至可以创建其他函数来接受用户输入等，并利用类变量的可读性。不确定案例是否应采用形式if elif else，但：

class test():    
    def __init__(self):
        self.reset()
        self.run()
    def reset(self):
        self.substring_index = 0 #instead of putting in function they are now class variables
        self.text_index = 0
    def run(self):#more stuff can be done here

        print(self.oo("I love pie","pie"))
        self.reset() #reset the class variables for each step
        print(self.oo("I love pie1","pie1"))

    def find(self,text, substring): #pretty much the same code just using class variables and class methods
        if self.text_index == len(text) and self.substring_index != len(substring): 
            return False

        elif self.substring_index == len(substring): 
            return True

        elif text[self.text_index] == substring[self.substring_index]: 
            self.text_index +=1
            self.substring_index +=1
            return self.find(text, substring) 

        else:
            return False


    def oo(self,text, substring): 
        if self.text_index == len(text): 
            return False


        elif text[self.text_index] == substring[self.substring_index]: 
            if self.find(text, substring): 
                return True
            else: 
                self.text_index +=1
                return oo(text, substring) 
        else:
            self.text_index +=1
        return self.oo(text , substring)

if __name__=='__main__':
    test()

虽然仅供参考，但解决此问题的一个超级简单的方法实际上是：

def oo(text,substring):
    if substring in text:
        return True
    else:
        return False

如评论中所述：

def oo(text,substring):
    if text.find(substring) == 0:
        return True
    else:
        return False

如果文本中存在，则返回0；如果不存在，则返回-1

---

考虑大写或小写差异时，可能会出现有趣的扩展。”A'！='我不明白，为什么要以复杂的递归方式重新实现string类的

find（）

方法。只是为了学习？如果字符串中的子字符串已经解决了这个问题，但是我认为OP想要演示递归函数。