在本Python教程中，我们将介绍以下主题

• 检查一个字符串是否包含另一个子字符串

• 匹配字符串中的确切子字符串

• 不区分大小写的匹配

"in"和"not in"运算符

运算符" in"和" not in"会测试Python的成员资格。
这是检查Python字符串是否包含另一个字符串的最佳和最常用的方法。
可以确定的是，与本教程将向我们介绍的其他方法相比，该运算符对性能的影响最小。
这些运算符将返回布尔表达式，即True或者False。

说明：

空字符串总是被认为是任何其他字符串的子字符串，因此" abc"中的""将返回True。

#!/usr/bin/env python3
string = 'Entertainment'
substring = 'ent'
# returns boolean value
print(substring in string)
# based on the return value, the condition statement would be executed
if substring in string:
    print('Found')
else:
    print('Not Found')

该脚本的输出：

# python3 /tmp/check_string.py
True
Found

同样，我们可以验证不在操作员中的用例。
运算符not in被定义为具有in的反真值。

#!/usr/bin/env python3
string = 'Entertainment'
substring = 'ent'
# returns boolean value
print(substring not in string)
# based on the return value, the condition statement would be executed
if substring not in string:
    print('Not Found')
else:
    print('Found')

该脚本的输出：

# python3 /tmp/check_string.py
False
Found

不区分大小写的匹配

要在Python中对字符串中的子字符串进行不区分大小写的匹配，可以使用两种方法来实现。

方法1：使用upper()或者lower()

我们可以使用str.upper()或者str.lower()来转换字符串的大小写，然后使用in或者not in运算符在字符串和子字符串之间进行匹配

#!/usr/bin/env python3
string = 'Entertainment'
substring = 'ENT'
# returns boolean value
print(substring.lower() in string.lower())
# based on the return value, the condition statement would be executed
if substring.lower() in string.lower():
    print('Found')
else:
    print('Not Found')

该脚本的输出：

# python3 /tmp/check_string.py
True
Found

方法2：使用正则表达式搜索

使用regex可以使我们更加灵活地搜索字符串。
re.search将扫描字符串以查找正则表达式模式产生match的第一个位置，并返回一个对应的match对象。

如果字符串中的" no position"与模式匹配，则将返回None。

语法是：

re.search(pattern, string, flags=re.IGNORECASE)

我们将在示例脚本中使用此正则表达式搜索

#!/usr/bin/env python3
import re
string = 'Entertainment'
substring = 'ENT'
# returns match object
print(re.search(substring, string, flags=re.IGNORECASE))
# based on the return value, the condition statement would be executed
if re.search(substring, string, flags=re.IGNORECASE):
    print('Found')
else:
    print('Not Found')

该脚本的输出：

# python3 /tmp/check_string.py
<_sre.SRE_Match object; span=(0, 3), match='Ent'>
Found

使用str.index()检查字符串中的子字符串

str.index()可用于查找字符串中某个模式或者子字符串的第一个匹配项的index值。
这将返回首次出现的匹配项的起始索引号(如果找到)，否则将引发ValueError异常

语法是：

str.index(sub[, start[, end]])

其中我们可以定义开始和结束的"索引"编号，以在字符串中搜索子字符串

#!/usr/bin/env python3
string = 'Entertainment'
substring = 'ent'
# search for substring inside string
print(string.index(substring))
# search for substring after index no 5 and before the last available index no
print(string.index(substring, 5, len(string)))

该脚本的输出：

# python3 /tmp/check_string.py
10
10

如果匹配为"未找到"，那么我们将获得" valueError"异常：

# python3 /tmp/check_string.py
Traceback (most recent call last):
  File "/tmp/check_string.py", line 7, in <module>
    print(string.index(substring))
ValueError: substring not found

我们可以使用try try else else块来抑制这种情况：

#!/usr/bin/env python3
string = 'Entertainment'
substring = 'ENT'
# a = full string and b = substring
def check_string(a, b):
   try:
       # check if b substring is present in a string
       a.index(b)
   # Raise exception for ValueError and instead print False
   except ValueError:
       print('False')
   else:
       print('True')
check_string(string, substring)

该脚本的输出：

# python3 /tmp/check_string.py
False

提示：

如果目的只是在字符串中搜索子字符串，则此方法不是很有用；如果我们需要在特定索引位置搜索模式或者子字符串，则可以使用此函数

使用str.find()检查字符串中的子字符串

我们可以选择" str.find"而不是" str.index"，因为其中我们不必担心处理异常。
此方法还返回找到子字符串sub的字符串中的最低索引，但是如果未找到模式或者子字符串，则将返回-1

语法是：

str.find(sub[, start[, end]])

下面的示例python脚本将在字符串中首次出现子字符串时返回索引值

#!/usr/bin/env python3
string = 'Entertainment'
substring = 'ent'
# returns index value if match found and -1 if no match
print('Value: ', string.find(substring))

该脚本的输出：

# python3 /tmp/check_string.py
Value:  10

如果没有找到"匹配项"，则输出为：

# python3 /tmp/check_string.py
Value: -1

提示：

只有在我们需要知道sub的位置时才应使用find()方法。
要检查sub是否是子字符串，请使用in或者not in运算符

使用正则表达式(re.search)

在本教程前面的部分中，我们使用了" re.search"来对字符串中的子字符串进行不区分大小写的检查。
我们可以使用相同的方法进行区分大小写的匹配，而无需使用flags = re.IGNORECASE。
re模块不是内置函数，因此必须导入此模块。
我们可以导入re模块的所有内容，也可以仅从re中导入search。

#!/usr/bin/env python3
import re
string = 'Entertainment'
substring = 'ent'
# returns match object
print(re.search(substring, string))
# based on the return value, the condition statement would be executed
if re.search(substring, string):
    print('Found')
else:
    print('Not Found')

该脚本的输出：

# python3 /tmp/check_string.py
<_sre.SRE_Match object; span=(10, 13), match='ent'>
Found

如果没有匹配项，那么re.search将返回None，输出将是：

# python3 /tmp/check_string.py
None
Not Found

匹配字符串中的确切子字符串

上面的方法仅检查字符串中的子字符串，但不完全匹配。
例如，abc将匹配abcd，dabc和abc。
因此，如果要求是匹配确切的字符串(即abc)，那么我们必须在单词re.search中使用单词边界。

什么是单词边界" \ b"？

\ b与空字符串匹配，但仅在单词的开头或者结尾处匹配。
单词定义为单词字符序列。
注意，形式上，\ b定义为\ w和\ W字符之间的边界(反之亦然)，或者\ w和字符串的开始/结尾之间的边界。
这意味着r'\ bfoo \ b'与'foo'，'foo.'，'(foo)'，'bar foo baz'匹配，但与foobar或者 'foo3'不匹配。

使用的"语法"将是：

re.search(r'\b'+substring+r'\b',string)

如果我们要在re.search中使用变量，则必须使用以下命令对子字符串进行转义：

re.search(r'\b'+re.escape(substring)+r'\b',string)

让我们在示例python脚本中使用它：

#!/usr/bin/env python3
import re
string = 'abc abcd def'
substring = 'abc'
# returns match object if found or returns None if not found
print(re.search(r'\b'+re.escape(substring)+r'\b', string))

该脚本的输出：

# python3 /tmp/check_string.py
<_sre.SRE_Match object; span=(0, 3), match='abc'>

但是子字符串不匹配，那么输出将是`None'。

# python3 /tmp/check_string.py
None