Python 忽略字符串中的大小写、标点和空格

忽略字符串中的大小写、标点和空格最有效的方法是什么？这些字符串应该被划分为单词而不是字符。我们应该忽略前面提到的比较细节，并且这些字符串的片段应该尽可能高效并考虑速度

我打算在下面的代码中使用不区分大小写和标点符号的字符串，但在看到计算

类切片需要多长时间后：def uu eq uuu（self，other）：return self.root==other.root

，我决定使用

data=tuple（string.split（））

。使用对大小写、标点符号和间距不敏感的字符串，并对单词而不是字符进行处理，这对于下面代码中已经表达的计算代价高昂的算法来说太昂贵了

class Slice:

    def __init__(self, data, offset, length):
        self.prefix = data[:offset]
        self.root = data[offset:offset+length]
        self.suffix = data[offset+length:]

    def __eq__(self, other):
        return self.root == other.root

    def __len__(self):
        return len(self.root)

################################################################################

class Match:

    def __init__(self, data, key, prefix_tree, suffix_tree):
        self.data = data
        self.key = key
        self.prefix_tree = prefix_tree
        self.suffix_tree = suffix_tree
        self.__value = len(key) + prefix_tree.value() + suffix_tree.value()

    def value(self):
        return self.__value

################################################################################

class Tree(tuple):

    def __new__(cls, nodes):
        tree = super().__new__(cls, nodes)
        tree.__value = max(map(Match.value, tree)) if tree else 0
        return tree

    def value(self):
        return self.__value

    def find(self, value):
        for index, match in enumerate(self):
            if match.value() == value:
                return index
        raise ValueError()

################################################################################

def search(data, key):
    length = 0
    nodes = []
    for d_block in shrink(data, len(key)):
        block_len = len(d_block)
        if length > block_len:
            return Tree(nodes)
        for k_block in slide(key, block_len):
            if d_block == k_block:
                length = block_len
                prefix_tree = search(d_block.prefix, k_block.prefix)
                suffix_tree = search(d_block.suffix, k_block.suffix)
                match = Match(d_block, k_block, prefix_tree, suffix_tree)
                nodes.append(match)
    return Tree(nodes)

def shrink(data, max_len):
    for length in range(min(len(data), max_len), 0, -1):
        for block in slide(data, length):
            yield block

def slide(data, length):
    for offset in range(len(data) - length + 1):
        yield Slice(data, offset, length)

################################################################################

def build_tree(nodes):
    match = nodes[nodes.find(nodes.value())]
    node = match.key
    if match.prefix_tree:
        node.prefix = build_tree(match.prefix_tree)
    if match.suffix_tree:
        node.suffix = build_tree(match.suffix_tree)
    return node

def flatten_tree(node):
    array = [0]
    _flatten(node, array)
    return tuple(array)

def _flatten(node, array):
    if isinstance(node.prefix, Slice):
        _flatten(node.prefix, array)
    else:
        array.append(node.prefix)
    array[0] += 1
    array.append((array[0], node.root))
    if isinstance(node.suffix, Slice):
        _flatten(node.suffix, array)
    else:
        array.append(node.suffix)

---

如果您希望字符串实例上的迭代在其

自身上进行迭代，正如
\uuuu iter\uuuuuuuuuuuuuuu
方法所指出的那样，唯一明智的长度选择也是返回
\uuuuuu字符串
的长度——如果
len（x）
和
sum（1表示x中的uuuuuu），这将是非常奇怪的
产生了不同的值

我必须承认，我不理解这个类的目的（尤其是为什么你做出了一个糟糕的选择，选择了旧的风格，为什么你使用这样一种扭曲的方式来构建
\uu simple
），但是内部一致性无论如何都很重要。因此，要么更改
\uuuu iter\uuuu
，要么使
\uuuu len\uuuu
在逻辑上与之兼容

我也完全搞不懂你的切片逻辑——为什么你要以一种可能不同于从切片的
\uu字符串
重建切片的方式来构建切片的
\uu simple
？例如，如果
self.\u字符串
是“？Boh！”因此，
self.\uu simple
是'boh'，你为什么希望
self[1:-1]
有一个'boh'的
\uu字符串，但是有一个'o'的
\uu simple
，那么与
\uu simple
不兼容、不同，而且不一致，你可以从切片中重新计算它

我想这与关于长度的Q无关，但我只是好奇你正在做的许多非常奇特的设计选择…
如果你想在字符串实例上的迭代在其
自身上进行迭代，唯一明智的长度选择是返回
\uu字符串的长度
——如果
len（x）
和
sum（x中的uu为1）
产生不同的值，这将是非常奇怪的

我必须承认，我不理解这个类的目的（尤其是为什么你做出了一个糟糕的选择，选择了旧的风格，为什么你使用这样一种扭曲的方式来构建
\uu simple
），但是内部一致性无论如何都很重要。因此，要么更改
\uuuu iter\uuuu
，要么使
\uuuu len\uuuu
在逻辑上与之兼容

我也完全搞不懂你的切片逻辑——为什么你要以一种可能不同于从切片的
\uu字符串
重建切片的方式来构建切片的
\uu simple
？例如，如果
self.\u字符串
是“？Boh！”因此，
self.\uu simple
是'boh'，你为什么希望
self[1:-1]
有一个'boh'的
\uu字符串，但是有一个'o'的
\uu simple
，那么与
\uu simple
不兼容、不同，而且不一致，你可以从切片中重新计算它

我想这与关于长度的Q无关，但我只是好奇你正在做的许多非常奇特的设计选择…
“解决这个问题的最佳方法是什么？”

最好的——也是唯一的——方法是定义这个对象“意味着什么”以及这个对象的长度“意味着什么”

该对象似乎是一个单词列表。没别的了。这似乎是
\u string
中的值

不清楚什么是
\u simple
，除了
\u string
中不可访问的过滤词子集之外

那么长度是多少？单词的长度或过滤子集中单词的长度

只有您可以定义此类的含义。的含义将决定如何实现
\uuuu len\uuu
。在定义其含义之前，无法确定应如何实施任何操作。
解决此问题的最佳方法是什么？

最好的——也是唯一的——方法是定义这个对象“意味着什么”以及这个对象的长度“意味着什么”

该对象似乎是一个单词列表。没别的了。这似乎是
\u string
中的值

不清楚什么是
\u simple
，除了
\u string
中不可访问的过滤词子集之外

那么长度是多少？单词的长度或过滤子集中单词的长度

只有您可以定义此类的含义。的含义将决定如何实现
\uuuu len\uuu
。在定义其含义之前，无法确定应如何实现任何内容。
如果有关于类的用途的上下文/文档，则会有所帮助……请不要将
\uuu
用于“私有”变量名。请使用
。
：这更常见，而且我们读代码时大脑的压力更小；问题是什么？如果有关于类的用途的上下文/文档，会有所帮助…请不要对“私有”变量名使用
\uuu
。请使用
。
：这更常见，而且我们读代码时大脑的压力更小；问题是什么？因为蟒蛇