So verwenden Sie Platzhalter zum Zuordnen von Zeichenfolgen in Python

Zeichenfolgen mithilfe von Platzhaltern abgleichen:

• Verwenden Sie die Methode fnmatch.filter(), um die Zeichenfolgen, die dem Muster entsprechen, aus der Liste abzurufen . fnmatch.filter() 方法从列表中获取匹配模式的字符串。

• 使用 fnmatch.fnmatch() 方法检查字符串是否与模式匹配。

import fnmatch

a_list = ['fql.txt', 'jiyik.txt', 'com.csv']

pattern = '*.txt'
filtered_list = fnmatch.filter(a_list, pattern)
print(filtered_list)  # ????️ ['fql.txt', 'jiyik.txt']

如果我们更愿意使用正则表达式，请向下滚动到下一个副标题。

fnmatch.filter 方法接受一个可迭代对象和一个模式，并返回一个新列表，该列表仅包含与提供的模式匹配的可迭代对象元素。

示例中的模式以任意一个或多个字符开头，以 .txt 结尾。

示例中的模式仅包含一个通配符，但您可以根据需要使用任意多个通配符。

请注意，星号 * 匹配所有内容（一个或多个字符）。

如果要匹配任何单个字符，请将星号 * 替换为问号 ?。

• * 匹配所有内容（一个或多个字符）

• ? 匹配任何单个字符

• [sequence] 匹配序列中的任意字符

• [!sequence] 匹配任何不按顺序的字符

下面是使用问号匹配任何单个字符的示例。

import fnmatch

a_list = ['abc', 'abz', 'abxyz']

pattern = 'ab?'
filtered_list = fnmatch.filter(a_list, pattern)
print(filtered_list)  # ????️ ['abc', 'abz']

该模式匹配以 ab 开头后跟任何单个字符的字符串。

如果要使用通配符检查字符串是否与模式匹配，请使用 fnmatch.fnmatch() 方法。

import fnmatch

a_string = '2023_jiyik.txt'
pattern = '2023*.txt'

matches_pattern = fnmatch.fnmatch(a_string, pattern)
print(matches_pattern)  # ????️ True

if matches_pattern:
    # ????️ this runs
    print('The string matches the pattern')
else:
    print('The string does NOT match the pattern')

该模式以 2023 开头，后跟任意一个或多个字符，并以 .txt 结尾。

fnmatch.fnmatch 方法接受一个字符串和一个模式作为参数。如果字符串与模式匹配，则该方法返回 True，否则返回 False。只需将星号 * 替换为问号 ? 如果您想匹配任何单个字符而不是任何一个或多个字符。

或者，我们可以使用正则表达式。

使用正则表达式使用通配符匹配字符串

使用通配符匹配字符串：

使用 re.match() 方法检查字符串是否匹配给定的模式。使用 .* 字符代替通配符。

import re

a_list = ['2023_fql.txt', '2023_jiyik.txt', '2023_com.csv']

regex = re.compile(r'2023_.*\.txt')

list_of_matches = [
    item for item in a_list
    if re.match(regex, item)
]

print(list_of_matches)  # ????️ ['2023_fql.txt', '2023_jiyik.txt']

re.compile 方法将正则表达式模式编译成一个对象，该对象可用于使用其 match() 或 search() 方法进行匹配。

这比直接使用 re.match 或 re.search 更有效，因为它保存并重用了正则表达式对象。

正则表达式以 2023_ 开头。

正则表达式中的 .* 字符用作匹配任何一个或多个字符的通配符。

• 点 . 匹配除换行符以外的任何字符。

• 星号 * 与前面的正则表达式（点 .）匹配零次或多次。

我们使用反斜杠字符来转义点。 在扩展名中，因为正如我们之前看到的，点 . 在正则表达式中使用时具有特殊含义。换句话说，我们使用反斜杠来处理点。 作为文字字符。

我们使用列表理解来迭代字符串列表。

列表推导用于对每个元素执行某些操作或选择满足条件的元素子集。

在每次迭代中，我们使用 re.match() 方法检查当前字符串是否与模式匹配。

import re

a_list = ['2023_fql.txt', '2023_jiyik.txt', '2023_com.csv']

regex = re.compile(r'2023_.*\.txt')

list_of_matches = [
    item for item in a_list
    if re.match(regex, item)
]

print(list_of_matches)  # ????️ ['2023_fql.txt', '2023_jiyik.txt']

如果提供的正则表达式在字符串中匹配，则 re.match 方法返回一个匹配对象。

如果字符串与正则表达式模式不匹配，则 match() 方法返回 None。

新列表仅包含原始列表中与模式匹配的字符串。

如果只想匹配任何单个字符，请删除点后面的星号 *. 在正则表达式中。

import re

a_list = ['2023_a.txt', '2023_bcde.txt', '2023_z.txt']

regex = re.compile(r'2023_.\.txt')

list_of_matches = [
    item for item in a_list
    if re.match(regex, item)
]

print(list_of_matches)  # ????️ ['2023_a.txt', '2023_z.txt']

点 . 匹配除换行符以外的任何字符。

通过使用点 . 在不转义的情况下，正则表达式匹配任何以 2023_ 开头，后跟任何单个字符并以 .txt 结尾的字符串。

如果大家在阅读或编写正则表达式时需要帮助，请参考我们的正则表达式教程。

该页面包含所有特殊字符的列表以及许多有用的示例。

如果想使用正则表达式检查字符串是否与模式匹配，我们可以直接使用 re.match()

#🎜🎜#Verwenden Sie die Methode fnmatch.fnmatch(), um zu prüfen, ob eine Zeichenfolge mit einem Muster übereinstimmt. #🎜🎜#

import re

a_string = '2023_fql.txt'

matches_pattern = bool(re.match(r'2023_.*\.txt', a_string))
print(matches_pattern)  # ????️ True

if matches_pattern:
    # ????️ this runs
    print('The string matches the pattern')
else:
    print('The string does NOT match the pattern')

#🎜🎜##🎜🎜##🎜🎜#Wenn wir lieber reguläre Ausdrücke verwenden möchten, scrollen Sie bitte nach unten zum nächsten Untertitel. #🎜🎜#

#🎜🎜#fnmatch.filter-Methode akzeptiert ein iterierbares Objekt und ein Muster und gibt eine neue Liste zurück, die nur iterierbare Objekte enthält, die mit dem bereitgestellten Musterelement übereinstimmen. #🎜🎜#

#🎜🎜#Das Muster im Beispiel beginnt mit einem oder mehreren beliebigen Zeichen und endet mit .txt. #🎜🎜#

#🎜🎜#Das Muster im Beispiel enthält nur einen Platzhalter, Sie können jedoch so viele Platzhalter verwenden, wie Sie möchten. #🎜🎜#

#🎜🎜#Beachten Sie, dass das Sternchen * mit allem übereinstimmt (einem oder mehreren Zeichen). #🎜🎜#

#🎜🎜# Wenn Sie ein einzelnes Zeichen zuordnen möchten, ersetzen Sie das Sternchen * durch das Fragezeichen ?. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#* entspricht allem (einem oder mehreren Zeichen) #🎜🎜##🎜🎜##🎜🎜# ? entspricht jedem einzelnen Zeichen #🎜🎜##🎜🎜##🎜🎜#[sequence] entspricht jedem Zeichen in der Sequenz #🎜🎜# #🎜🎜##🎜🎜#[!sequence] Entspricht allen Zeichen, die nicht in der Reihenfolge sind #🎜🎜##🎜🎜#Im Folgenden werden Fragezeichen verwendet Entspricht einem beliebigen Beispiel eines einzelnen Zeichens. #🎜🎜#

import re

a_string = '2023_ABC.txt'

matches_pattern = bool(re.match(r'2023_.\.txt', a_string))
print(matches_pattern)  # ????️ False

if matches_pattern:
    print('The string matches the pattern')
else:
    # ????️ this runs
    print('The string does NOT match the pattern')

#🎜🎜#Dieses Muster entspricht einer Zeichenfolge, die mit ab beginnt, gefolgt von einem beliebigen einzelnen Zeichen. #🎜🎜##🎜🎜#Wenn Sie Platzhalter verwenden möchten, um zu prüfen, ob eine Zeichenfolge mit einem Muster übereinstimmt, verwenden Sie die Methode fnmatch.fnmatch(). #🎜🎜#rrreee#🎜🎜#Das Muster beginnt mit 2023, gefolgt von einem oder mehreren Zeichen und endet mit .txt. #🎜🎜#

#🎜🎜#fnmatch.fnmatch-Methode akzeptiert eine Zeichenfolge und ein Muster als Parameter. Die Methode gibt True zurück, wenn die Zeichenfolge mit dem Muster übereinstimmt, andernfalls False. Ersetzen Sie einfach das Sternchen * durch das Fragezeichen ?, wenn Sie ein beliebiges einzelnes Zeichen anstelle eines oder mehrerer Zeichen finden möchten. #🎜🎜#

#🎜🎜#Alternativ können wir reguläre Ausdrücke verwenden. #🎜🎜##🎜🎜#Verwenden Sie reguläre Ausdrücke, um Zeichenfolgen mithilfe von Platzhaltern abzugleichen. #🎜🎜##🎜🎜#Verwenden Sie Platzhalter, um Zeichenfolgen abzugleichen:#🎜🎜##🎜🎜#Verwenden Sie The Die Methode re.match() prüft, ob eine Zeichenfolge mit einem bestimmten Muster übereinstimmt. Verwenden Sie .*-Zeichen anstelle von Platzhalterzeichen. #🎜🎜#rrreee#🎜🎜# Die Methode re.compile kompiliert ein reguläres Ausdrucksmuster in ein Objekt, das mit seiner match()- oder -Suche verwendet werden kann () Methode zum Abgleichen. #🎜🎜##🎜🎜#Dies ist effizienter als die direkte Verwendung von re.match oder re.search, da das reguläre Ausdrucksobjekt gespeichert und wiederverwendet wird. #🎜🎜##🎜🎜#Regulärer Ausdruck beginnend mit 2023_. #🎜🎜#

#🎜🎜#Die .*-Zeichen in regulären Ausdrücken werden als Platzhalter verwendet, um ein oder mehrere Zeichen abzugleichen. #🎜🎜#

#🎜🎜##🎜🎜##🎜🎜#Punkt . entspricht jedem Zeichen außer Zeilenumbrüchen. #🎜🎜##🎜🎜##🎜🎜#Das Sternchen * stimmt null oder mehrmals mit dem vorhergehenden regulären Ausdruck (Punkt .) überein. #🎜🎜#

#🎜🎜# Wir verwenden das Backslash-Zeichen, um Punkte zu maskieren. in der Erweiterung, denn wie wir zuvor gesehen haben, hat der Punkt . eine besondere Bedeutung, wenn er in regulären Ausdrücken verwendet wird. Mit anderen Worten: Wir verwenden Backslashes, um Punkte zu verarbeiten. als wörtliche Zeichen. #🎜🎜#

#🎜🎜# Wir verwenden ein Listenverständnis, um eine Liste von Zeichenfolgen zu durchlaufen. #🎜🎜##🎜🎜#Listenverständnisse werden verwendet, um bestimmte Operationen für jedes Element auszuführen oder eine Teilmenge von Elementen auszuwählen, die eine Bedingung erfüllen. #🎜🎜##🎜🎜#In jeder Iteration verwenden wir die Methode re.match(), um zu prüfen, ob die aktuelle Zeichenfolge mit dem Muster übereinstimmt. #🎜🎜#rrreee#🎜🎜#Die Methode re.match gibt ein Match-Objekt zurück, wenn der bereitgestellte reguläre Ausdruck in der Zeichenfolge übereinstimmt. #🎜🎜#

#🎜🎜#Die Methode match() gibt None zurück, wenn die Zeichenfolge nicht mit dem regulären Ausdrucksmuster übereinstimmt. #🎜🎜#

#🎜🎜#Die neue Liste enthält nur die Zeichenfolgen in der ursprünglichen Liste, die mit dem Muster übereinstimmen. #🎜🎜##🎜🎜# Wenn Sie nur ein einzelnes Zeichen abgleichen möchten, entfernen Sie das Sternchen nach dem Punkt *. im regulären Ausdruck. #🎜🎜#rrreee#🎜🎜#Punkt . entspricht jedem Zeichen außer Zeilenumbrüchen. #🎜🎜#

#🎜🎜# Durch die Verwendung des Punkts . ohne Escapezeichen findet der reguläre Ausdruck alles, was mit 2023_ beginnt, gefolgt von einem einzelnen Zeichen und endet mit < strong>.txt. #🎜🎜#

#🎜🎜#Wenn Sie Hilfe beim Lesen oder Schreiben regulärer Ausdrücke benötigen, lesen Sie bitte unser Tutorial zu regulären Ausdrücken. #🎜🎜##🎜🎜#Diese Seite enthält eine Liste aller Sonderzeichen sowie viele nützliche Beispiele. #🎜🎜##🎜🎜#Wenn Sie reguläre Ausdrücke verwenden möchten, um zu prüfen, ob eine Zeichenfolge mit einem Muster übereinstimmt, können wir die Methode re.match() direkt verwenden. #🎜🎜#

import re

a_string = '2023_fql.txt'

matches_pattern = bool(re.match(r'2023_.*\.txt', a_string))
print(matches_pattern)  # ????️ True

if matches_pattern:
    # ????️ this runs
    print('The string matches the pattern')
else:
    print('The string does NOT match the pattern')

如果字符串与模式匹配，则 re.match() 方法将返回一个匹配对象，如果不匹配，则返回 None 。

我们使用 bool() 类将结果转换为布尔值。

如果要对单个字符使用通配符，请删除星号 * 。

import re

a_string = '2023_ABC.txt'

matches_pattern = bool(re.match(r'2023_.\.txt', a_string))
print(matches_pattern)  # ????️ False

if matches_pattern:
    print('The string matches the pattern')
else:
    # ????️ this runs
    print('The string does NOT match the pattern')

请注意 ，点 . 我们没有使用反斜杠作为前缀用于匹配任何单个字符，而点 . 我们以反斜杠 \ 为前缀的被视为文字点。

示例中的字符串与模式不匹配，因此 matches_pattern 变量存储一个 False 值。

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Platzhalter zum Zuordnen von Zeichenfolgen in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!