Python 如果我知道较长的字符串不区分大小写，我应该如何从另一个字符串的开头删除一个字符串？

假设我有一个工作流，它涉及检查长字符串（

LS

）的开头，以查看它是否以较短的字符串

SS

开头。如果是这样，我将切掉

LS

的匹配部分，并对其余部分进行处理。否则，我会做别的事情。（引发此问题的具体案例是解析库。）

这很简单。现在，假设我想做同样的事情，但是这次我希望字符串不区分大小写地匹配。可以测试“

LS.startswith（SS）

但大小写不敏感”。但是，当我将

LS

传递给

action\u match（）时，我应该如何确定要“切掉”多少？仅仅像以前那样使用
len（SS）
是不够的，因为如果我使用大写、小写或大小写，那么
LS
的匹配前缀的长度可能不是我所期望的：更改字符串的大小写可以更改其长度。传递给
action\u on_match（）
的
LS
部分必须与程序作为输入接收的部分完全一致（当然，在截止点之后）


回答者建议使用
lower（）
并保留
len（SS）
的使用，但这不起作用：

Python 3.4.2 (v3.4.2:ab2c023a9432, Oct  6 2014, 22:15:05) [MSC v.1600 32 bit (In
tel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> def action_on_match (s): return "Match: %s" % s
...
>>> def action_on_no_match (): return "No match"
...
>>> def do_thing (LS, SS):
...     if LS.lower().startswith(SS.lower()):
...         return action_on_match(LS[len(SS):])
...     else:
...         return action_on_no_match()
...
>>> do_thing('i\u0307asdf', '\u0130')
'Match: \u0307asdf'
>>>

这里我们希望看到
'Match:asdf'
，但是还有一个额外的字符。
只需使用
str.lower
，
“FOO”
的长度将与
的“FOO.lower（）相同：

只需使用
str.lower
，
“FOO”
的长度将与
“FOO.lower（）的长度相同：

只需使用
str.lower
，
“FOO”
的长度将与
“FOO.lower（）的长度相同：

只需使用
str.lower
，
“FOO”
的长度将与
“FOO.lower（）的长度相同：

很简单：

def do_thing(LS, SS):
    if LS.lower().startswith(SS.lower()):
        action_on_match(LS[len(SS):])
    else:
        action_on_no_match()

我所做的就是把
LS
和
SS
的大小写都降低，然后比较它们。对于非常长的字符串，这将比正则表达式解决方案慢得多，因为它必须首先将整个字符串转换为小写

正则表达式解决方案如下所示：

import re

def do_thing(LS, SS):
    if re.match("^%s" % SS, LS, re.I):
        action_on_match(LS[len(SS):])
    else:
        action_on_no_match()

性能

对于超过1000000次迭代的短字符串（
len（LL）
==8个字符）：


lower（）
方法：0.86s（优胜者）
re
方法：1.91s

对于超过1000000次迭代的长字符串（
len（LL）
==600个字符）：


lower（）
方法：2.54s
re
方法：1.96s（优胜者）

Unicode组合字符

对于unicode组合字符，需要首先输入数据。这意味着将任何组件转换为其组成部分。例如，您将发现：

>>> '\u0130' == 'I\u0307'
False
>>> normalize("NFD", '\u0130') == normalize("NFD", 'I\u0307')
True

您需要对输入执行此标准化过程：

SS = normalize("NFD", SS)
LS = normalize("NFD", LS)

很简单：

def do_thing(LS, SS):
    if LS.lower().startswith(SS.lower()):
        action_on_match(LS[len(SS):])
    else:
        action_on_no_match()

我所做的就是把
LS
和
SS
的大小写都降低，然后比较它们。对于非常长的字符串，这将比正则表达式解决方案慢得多，因为它必须首先将整个字符串转换为小写

正则表达式解决方案如下所示：

import re

def do_thing(LS, SS):
    if re.match("^%s" % SS, LS, re.I):
        action_on_match(LS[len(SS):])
    else:
        action_on_no_match()

性能

对于超过1000000次迭代的短字符串（
len（LL）
==8个字符）：


lower（）
方法：0.86s（优胜者）
re
方法：1.91s

对于超过1000000次迭代的长字符串（
len（LL）
==600个字符）：


lower（）
方法：2.54s
re
方法：1.96s（优胜者）

Unicode组合字符

对于unicode组合字符，需要首先输入数据。这意味着将任何组件转换为其组成部分。例如，您将发现：

>>> '\u0130' == 'I\u0307'
False
>>> normalize("NFD", '\u0130') == normalize("NFD", 'I\u0307')
True

您需要对输入执行此标准化过程：

SS = normalize("NFD", SS)
LS = normalize("NFD", LS)

很简单：

def do_thing(LS, SS):
    if LS.lower().startswith(SS.lower()):
        action_on_match(LS[len(SS):])
    else:
        action_on_no_match()

我所做的就是把
LS
和
SS
的大小写都降低，然后比较它们。对于非常长的字符串，这将比正则表达式解决方案慢得多，因为它必须首先将整个字符串转换为小写

正则表达式解决方案如下所示：

import re

def do_thing(LS, SS):
    if re.match("^%s" % SS, LS, re.I):
        action_on_match(LS[len(SS):])
    else:
        action_on_no_match()

性能

对于超过1000000次迭代的短字符串（
len（LL）
==8个字符）：


lower（）
方法：0.86s（优胜者）
re
方法：1.91s

对于超过1000000次迭代的长字符串（
len（LL）
==600个字符）：


lower（）
方法：2.54s
re
方法：1.96s（优胜者）

Unicode组合字符

对于unicode组合字符，需要首先输入数据。这意味着将任何组件转换为其组成部分。例如，您将发现：

>>> '\u0130' == 'I\u0307'
False
>>> normalize("NFD", '\u0130') == normalize("NFD", 'I\u0307')
True

您需要对输入执行此标准化过程：

SS = normalize("NFD", SS)
LS = normalize("NFD", LS)

很简单：

def do_thing(LS, SS):
    if LS.lower().startswith(SS.lower()):
        action_on_match(LS[len(SS):])
    else:
        action_on_no_match()

我所做的就是把
LS
和
SS
的大小写都降低，然后比较它们。对于非常长的字符串，这将比正则表达式解决方案慢得多，因为它必须首先将整个字符串转换为小写

正则表达式解决方案如下所示：

import re

def do_thing(LS, SS):
    if re.match("^%s" % SS, LS, re.I):
        action_on_match(LS[len(SS):])
    else:
        action_on_no_match()

性能

对于超过1000000次迭代的短字符串（
len（LL）
==8个字符）：


lower（）
方法：0.86s（优胜者）
re
方法：1.91s

对于超过1000000次迭代的长字符串（
len（LL）
==600个字符）：


lower（）
方法：2.54s
re
方法：1.96s（优胜者）

Unicode组合字符

对于unicode组合字符，需要首先输入数据。这意味着将任何组件转换为其组成部分。例如，您将发现：

>>> '\u0130' == 'I\u0307'
False
>>> normalize("NFD", '\u0130') == normalize("NFD", 'I\u0307')
True

你需要执行