Python 如何使用算法使白名单功能更有效？

我设计了一个白名单功能来过滤windows中的文件路径。 要过滤的模式有三种类型：

• 根据后缀筛选路径，例如所有txt文件
• 例如，从左侧筛选路径，筛选以“C:\Windows\System32”开头的所有路径
• 过滤包含特殊单词的路径，例如，过滤包含“系统”的所有路径

模式以以下格式保存：

patternList = [{'type': 'suffix', 'content':'\.txt'},
            {'type': 'keyword', 'content':'system'},
            {'type': 'left', 'content': 'C:\Windows\System32'}]

每个dict都是一个模式，所有模式都在一个名为patternList的列表中

然后，我有另一个名为pathInfoObjectList的列表，其中包含许多对象，每个对象都有一个名为“filelist”的属性，这是一个列表。在文件列表中，有一些文件路径

现在，我想使用该模式删除文件列表中的每个路径

我的方法是将模式更改为regex以完成这项工作

我的代码在这里：

patternRegexList = []
for each in patternList:
    if each['type'] == 'suffix':
        patternRegex = '.*?' + each['content'] + '$'
    elif each['type'] == 'keyword':
        patternRegex = '.*?' + each['content'] + '.*?'
    elif each['type'] == 'left':
        patternRegex = '^' + each['content'] + '.*?'
    patternRegexList.append(patternRegex)


for pathInfoObject in pathInfoObjectList:
    for path in pathInfoObject.filelist[:]:
        for patternRegex in patternRegexList:
            if re.match(patternRegex, path):
                pathInfoObject.filelist.remove(path)
                break

但我认为我的算法太愚蠢了，事实的确如此

你有完成任务的聪明方法吗

---

现在我发现算法知识的缺乏使我的代码效率低下，你有什么建议让我更好地学习算法吗？我认为通过阅读算法简介来学习太慢了。有没有更有效的学习方法？

它看起来更像是黑名单而不是白名单，但如果我弄错了，很容易修复

首先，我试图以更清晰、更灵活的方式表达你的规则。我也尽量避免使用无用的正则表达式，它们可能会花费你很多时间。最后，通过使用

any

I避免在第一个排除规则匹配时测试每个排除规则。在for循环中使用

continue

具有相同的效果

exclusion_rules = [
    lambda path: path.endswith('.txt'),
    lambda path: 'system' in path,
    lambda path: path.startswith(r'c:\Windows\System32')]

for pathInfoObject in pathInfoObjectList:
    pathInfoObject.filelist = filter(
        lambda path: not any(rule(path) for rule in exclusion_rules),
        pathInfoObject.filelist)

使用列表压缩而不是筛选器执行此操作的另一种方法：

for pathInfoObject in pathInfoObjectList:
    pathInfoObject.filelist = [path for path in pathInfoObject.filelist if
                               not any(rule(path) for rule in exclusion_rules)]

---

它看起来更像是黑名单而不是白名单，但如果我弄错了，很容易修复它

首先，我试图以更清晰、更灵活的方式表达你的规则。我也尽量避免使用无用的正则表达式，它们可能会花费你很多时间。最后，通过使用

any

I避免在第一个排除规则匹配时测试每个排除规则。在for循环中使用

continue

具有相同的效果

exclusion_rules = [
    lambda path: path.endswith('.txt'),
    lambda path: 'system' in path,
    lambda path: path.startswith(r'c:\Windows\System32')]

for pathInfoObject in pathInfoObjectList:
    pathInfoObject.filelist = filter(
        lambda path: not any(rule(path) for rule in exclusion_rules),
        pathInfoObject.filelist)

使用列表压缩而不是筛选器执行此操作的另一种方法：

for pathInfoObject in pathInfoObjectList:
    pathInfoObject.filelist = [path for path in pathInfoObject.filelist if
                               not any(rule(path) for rule in exclusion_rules)]

我认为您不需要re，只需使用简单的字符串匹配即可。这里你也不需要字典

patternList = (( 'suffix', '.txt'),
               ('keyword', 'system'),
               ('left',  'C:\Windows\System32'))

matchFuncList = []
for pattern, text in patternList:
    if pattern == 'suffix':
        matchFuncList.append(lambda s: s.endswith(text))
    elif pattern == 'keyword':
        matchFuncList.append(lambda s: text in s)
    elif pattern == 'left':
        matchFuncList.append(lambda s: s.startswith(text))

现在，不要从列表中删除值-重建列表

for pathInfoObject in pathInfoObjectList:
    pathInfoObject.fileList = [path for path in pathInfoObject.fileList 
                               if not any(matchFunc(path) 
                                          for matchFunc in matchFuncList)]

我认为您不需要re，只需使用简单的字符串匹配即可。这里你也不需要字典

patternList = (( 'suffix', '.txt'),
               ('keyword', 'system'),
               ('left',  'C:\Windows\System32'))

matchFuncList = []
for pattern, text in patternList:
    if pattern == 'suffix':
        matchFuncList.append(lambda s: s.endswith(text))
    elif pattern == 'keyword':
        matchFuncList.append(lambda s: text in s)
    elif pattern == 'left':
        matchFuncList.append(lambda s: s.startswith(text))

现在，不要从列表中删除值-重建列表

for pathInfoObject in pathInfoObjectList:
    pathInfoObject.fileList = [path for path in pathInfoObject.fileList 
                               if not any(matchFunc(path) 
                                          for matchFunc in matchFuncList)]

---

谢谢你的回答。代码行确实在减少，但是大O呢？也许你的代码是！[]()? 还是这样！[]在这里，我用Python编写了我的代码，你也是，尽管如此，我的老板还是强迫我使用Java6来实现这个函数，你知道，lambda出现在Java8中。。。。Java也没有进行过滤……好处在于使用“any”避免检查已经丢弃的文件，并避免使用regex。此外，当按顺序检查排除规则时，您可以将最具鉴别性的规则放在第一位，以避免在大多数时间计算其他规则。您可以轻松地用Java重写这两点，顺便说一句，感谢您用Python提问！我喜欢Python，但讨厌Java。再次感谢您的回答。一旦实现，请告诉我们性能增益是否足够，以及每秒处理了多少文件。事实上，即使使用愚蠢的方式，一切都正常，因为只有4种模式，

len（pathInfoObjectList）感谢您的回答。代码行确实在减少，但是大O呢？也许你的代码是！[]()? 还是这样！[]在这里，我用Python编写了我的代码，你也是，尽管如此，我的老板还是强迫我使用Java6来实现这个函数，你知道，lambda出现在Java8中。。。。Java也没有进行过滤……好处在于使用“any”避免检查已经丢弃的文件，并避免使用regex。此外，当按顺序检查排除规则时，您可以将最具鉴别性的规则放在第一位，以避免在大多数时间计算其他规则。您可以轻松地用Java重写这两点，顺便说一句，感谢您用Python提问！我喜欢Python，但讨厌Java。再次感谢您的回答。一旦实现，请告诉我们性能增益是否足够，以及每秒处理了多少文件。事实上，即使使用愚蠢的方式，一切都正常，因为只有4种模式，
len（pathInfoObjectList）感谢您的回答。关键不在于如何定义patternList，也不在于是否需要使用dict或tuple。因为我使用了
pathInfoObject.filelist[：]
来复制列表，所以不会引发异常，所以为什么您仍然建议我不要从列表中删除项目？从列表中删除是一项昂贵的操作；相对而言，复制列表也是如此。我只是建立一个新的列表，并用一个新的列表引用替换旧的列表引用。有O（n*m）种最坏情况，其中n是文件列表的长度，m是函数列表的长度。由于任何捷径-在第一次失败时退出-它也应该接近0（n*m/2）@Mitangrice-您“不需要”的部分执行缓慢，并添加不必要的代码（原始罪恶），谢谢您的回答。关键不在于如何定义patternList，也不在于是否需要使用dict或tuple。因为我使用了
pathInfoObject.filelist[：]
来复制列表，所以不会引发异常，所以为什么您仍然建议我不要从列表中删除项目？从列表中删除是一项昂贵的操作；相对而言，复制列表也是如此。我只是建立一个新的列表，并用一个新的列表引用替换旧的列表引用。有O（n*m）种最坏情况，其中n是文件列表的长度，m是函数列表的长度。由于任何捷径-在第一次故障时退出-应接近0（n*m/2）@Mitangrice Al