Question

我正在为FOSS语言学习计划编写Python脚本。假设我有一个XML文件（或保持简单，一个Python列表），其中包含特定语言的单词列表（在我的例子中，单词是泰米尔语，它使用基于Brahmi的印度语脚本）。

我需要绘制那些可以使用这些字母拼写的单词的子集。

英文示例：

words = ["cat", "dog", "tack", "coat"] 

get_words(['o', 'c', 'a', 't']) should return ["cat", "coat"]
get_words(['k', 'c', 't', 'a']) should return ["cat", "tack"]

泰米尔人的例子：

words = [u"மரம்", u"மடம்", u"படம்", u"பாடம்"]

get_words([u'ம', u'ப', u'ட', u'ம்')  should return [u"மடம்", u"படம்")
get_words([u'ப', u'ம்', u'ட') should return [u"படம்"]

返回单词的顺序或输入字母的顺序不应有所不同。

虽然我理解unicode代码点和字形之间的区别，但我不确定它们是如何在正则表达式中处理的。

在这种情况下，我想只匹配那些由输入列表中的特定字素组成的单词，而不是其他内容（即字母后面的标记只能跟随该字母，但字形本身可以以任何顺序发生。）

Answer 1

支持可跨越多个Unicode代码点的字符：

# -*- coding: utf-8 -*-
import re
import unicodedata
from functools import partial

NFKD = partial(unicodedata.normalize, 'NFKD')

def match(word, letters):
    word, letters = NFKD(word), map(NFKD, letters) # normalize
    return re.match(r"(?:%s)+$" % "|".join(map(re.escape, letters)), word)

words = [u"மரம்", u"மடம்", u"படம்", u"பாடம்"]
get_words = lambda letters: [w for w in words if match(w, letters)]

print(" ".join(get_words([u'ம', u'ப', u'ட', u'ம்'])))
# -> மடம் படம்
print(" ".join(get_words([u'ப', u'ம்', u'ட'])))
# -> படம்

假设一个单词中可以使用相同的字符零次或多次。

如果您只想要包含确切字符的单词：

import regex # $ pip install regex

chars = regex.compile(r"\X").findall # get all characters

def match(word, letters):
    return sorted(chars(word)) == sorted(letters)

words = ["cat", "dog", "tack", "coat"]

print(" ".join(get_words(['o', 'c', 'a', 't'])))
# -> coat
print(" ".join(get_words(['k', 'c', 't', 'a'])))
# -> tack

注意：在这种情况下输出中没有cat，因为cat不使用所有给定的字符。

规范化意味着什么？你能解释一下re.match（）正则表达式的语法吗？

>>> import re
>>> re.escape('.')
'\\.'
>>> c = u'\u00c7'
>>> cc = u'\u0043\u0327'
>>> cc == c
False
>>> re.match(r'%s$' % (c,), cc) # do not match
>>> import unicodedata
>>> norm = lambda s: unicodedata.normalize('NFKD', s)
>>> re.match(r'%s$' % (norm(c),), norm(cc)) # do match
<_sre.SRE_Match object at 0x1364648>
>>> print c, cc
Ç Ç

没有标准化c和cc不匹配。字符来自unicodedata.normalize() docs。

Answer 2

编辑：好的，不要使用此处的任何答案。我写这些都是在思考Python正则表达式没有单词边界标记时，我试图解决这个缺点。然后@Mark Tolonen添加了一条评论，认为Python有\b作为单词边界标记！所以我使用\b发布了另一个简短的答案。我会留下这个以防万一有人有兴趣看到解决方案可以解决\b的缺乏问题，但我真的不希望有人这样做。

很容易制作一个只匹配特定字符集的字符串的正则表达式。你需要使用的是一个＆＃34;字符类＆＃34;只有你想要匹配的角色。

我将用英语做这个例子。

[ocat]这是一个与集合[o, c, a, t]中的单个字符匹配的字符类。角色的顺序并不重要。

[ocat]+在结尾放置一个+，使其与该集合中的一个或多个字符匹配。但这本身还不够;如果你有“＃34; coach＆＃34;这将匹配并返回＆＃34; coac＆＃34;。

可悲的是，＆＃34;字边界＆＃34;没有正则表达式功能。 [编辑：事实证明这不是正确的，正如我在第一段中所说的那样。]我们需要制作自己的一个。有两个可能的单词开头：一行的开头，或者将单词与前一单词分开的空格。类似地，有两个可能的单词结尾：一行的结尾，或者将单词与下一个单词分开的空格。

由于我们将匹配一些我们不想要的额外内容，我们可以将括号放在我们想要的模式部分。

为了匹配两个替代方案，我们可以在括号中创建一个组，并使用竖线分隔备选方案。 Python正则表达式有一个特殊的表示法，可以创建一个我们不想保留其内容的组：(?:)

所以，这是匹配单词开头的模式。行首或空格：(?:^|\s)

这是单词结尾的模式。空格或行尾：`（？：\ s | $）

总而言之，这是我们的最终模式：

(?:^|\s)([ocat]+)(?:\s|$)

您可以动态构建它。你不需要对整个事情进行硬编码。

import re

s_pat_start = r'(?:^|\s)(['
s_pat_end = r']+)(?:\s|$)'

set_of_chars = get_the_chars_from_somewhere_I_do_not_care_where()
# set_of_chars is now set to the string: "ocat"

s_pat = s_pat_start + set_of_chars + s_pat_end
pat = re.compile(s_pat)

现在，这并没有以任何方式检查有效的单词。如果您有以下文字：

This is sensible.  This not: occo cttc

我向您展示的模式将在occo和cttc上匹配，而这些模式并不是真正的单词。它们是仅由[ocat]的字母组成的字符串。

所以用Unicode字符串做同样的事情。（如果你使用的是Python 3.x，那么所有字符串都是Unicode字符串，所以你可以去。）将泰米尔语字符放在字符类中，你就可以了。

这有一个令人困惑的问题：re.findall()没有返回所有可能的匹配。

编辑：好的，我弄清楚是什么令我感到困惑。

我们想要的是我们的模式与re.findall()一起使用，这样您就可以收集所有单词。但re.findall()只能找到非重叠的模式。在我的示例中，re.findall()仅按预期返回['occo']而不是['occo', 'cttc'] ...但这是因为我的模式与occo之后的空格相匹配。匹配组没有收集空白区域，但它匹配完全相同，并且因为re.findall()希望匹配之间没有重叠，所以空白区域用完了＃34;并且没有为cttc工作。

解决方案是使用我之前从未使用过的Python正则表达式的特性：特殊的语法表示＆＃34;不得以＆＃34;开头。或＆＃34;不得跟随＆＃34;。序列\S匹配任何非空格，因此我们可以使用它。但标点符号是非空白的，我认为我们确实希望标点符号来划分单词。还有特殊的语法＃34;必须以＆＃34;开头。或＆＃34;必须跟随＆＃34;。所以我认为这是我们能做的最好的事情：

构建一个字符串，表示＆＃34;当字符类字符串位于行的开头并且后跟空格时，或者当字符类字符串前面有空格并后跟空格时，或者字符类字符串前面是空格，后跟行尾，或者字符类字符串前面是行的开头，后面是行尾＃34;。

以下是使用ocat的模式：

r'(?:^([ocat]+)(?=\s)|(?<=\s)([ocat]+)(?=\s)|(?<=\s)([ocat]+)$|^([ocat]+)$)'

我很抱歉，但我确实认为这是我们能做的最好的事情，并且仍在使用re.findall()！

尽管如此，它在Python代码中实际上并不那么令人困惑：

import re

NMGROUP_BEGIN = r'(?:'  # begin non-matching group
NMGROUP_END = r')'  # end non-matching group

WS_BEFORE = r'(?<=\s)'  # require white space before
WS_AFTER = r'(?=\s)'  # require white space after

BOL = r'^' # beginning of line
EOL = r'$' # end of line

CCS_BEGIN = r'(['  #begin a character class string
CCS_END = r']+)'  # end a character class string

PAT_OR = r'|'

set_of_chars = get_the_chars_from_somewhere_I_do_not_care_where()
# set_of_chars now set to "ocat"

CCS = CCS_BEGIN + set_of_chars + CCS_END  # build up character class string pattern

s_pat = (NMGROUP_BEGIN +
    BOL + CCS + WS_AFTER + PAT_OR +
    WS_BEFORE + CCS + WS_AFTER + PAT_OR +
    WS_BEFORE + CCS + EOL + PAT_OR +
    BOL + CCS + EOL +
    NMGROUP_END)

pat = re.compile(s_pat)

text = "This is sensible.  This not: occo cttc"

pat.findall(text)
# returns: [('', 'occo', '', ''), ('', '', 'cttc', '')]

所以，疯狂的是，当我们有可以匹配的替代模式时，re.findall()似乎为不匹配的替代品返回一个空字符串。所以我们只需要从结果中过滤掉长度为零的字符串：

import itertools as it

raw_results = pat.findall(text)
results = [s for s in it.chain(*raw_results) if s]
# results set to: ['occo', 'cttc']

我想，只需构建四种不同的模式，在每种模式上运行re.findall()并将结果连接在一起就不那么容易混淆了。

编辑：好的，这是构建四种模式并尝试各种模式的代码。我认为这是一种改进。

import re

WS_BEFORE = r'(?<=\s)'  # require white space before
WS_AFTER = r'(?=\s)'  # require white space after

BOL = r'^' # beginning of line
EOL = r'$' # end of line

CCS_BEGIN = r'(['  #begin a character class string
CCS_END = r']+)'  # end a character class string

set_of_chars = get_the_chars_from_somewhere_I_do_not_care_where()
# set_of_chars now set to "ocat"

CCS = CCS_BEGIN + set_of_chars + CCS_END  # build up character class string pattern

lst_s_pat = [
    BOL + CCS + WS_AFTER,
    WS_BEFORE + CCS + WS_AFTER,
    WS_BEFORE + CCS + EOL,
    BOL + CCS
]

lst_pat = [re.compile(s) for s in lst_s_pat]

text = "This is sensible.  This not: occo cttc"

result = []
for pat in lst_pat:
    result.extend(pat.findall(text))

# result set to: ['occo', 'cttc']

编辑：好的，这是一种非常不同的方法。我最喜欢这个。

首先，我们将匹配文本中的所有单词。单词被定义为一个或多个不是标点符号且不是空格的字符。

然后，我们使用过滤器从上面删除单词;我们只保留仅由我们想要的字符组成的单词。

import re
import string

# Create a pattern that matches all characters not part of a word.
#
# Note that '-' has a special meaning inside a character class, but it
# is valid punctuation that we want to match, so put in a backslash in
# front of it to disable the special meaning and just match it.
#
# Use '^' which negates all the chars following.  So, a word is a series
# of characters that are all not whitespace and not punctuation.

WORD_BOUNDARY = string.whitespace + string.punctuation.replace('-', r'\-')

WORD = r'[^' + WORD_BOUNDARY + r']+'


# Create a pattern that matches only the words we want.

set_of_chars = get_the_chars_from_somewhere_I_do_not_care_where()
# set_of_chars now set to "ocat"

# build up character class string pattern
CCS = r'[' + set_of_chars + r']+'


pat_word = re.compile(WORD)
pat = re.compile(CCS)

text = "This is sensible.  This not: occo cttc"


# This makes it clear how we are doing this.
all_words = pat_word.findall(text)
result = [s for s in all_words if pat.match(s)]

# "lazy" generator expression that yields up good results when iterated
# May be better for very large texts.
result_genexp = (s for s in (m.group(0) for m in pat_word.finditer(text)) if pat.match(s))

# force the expression to expand out to a list
result = list(result_genexp)

# result set to: ['occo', 'cttc']

编辑：现在我不喜欢上述任何一种解决方案;请参阅另一个使用\b的答案，以获得Python中的最佳解决方案。

Answer 3

很容易制作一个只匹配特定字符集的字符串的正则表达式。你需要使用的是一个“字符类”，只包含你想要匹配的字符。

我会用英语做这个例子。

[ocat]这是一个与集合[o, c, a, t]中的单个字符匹配的字符类。角色的顺序无关紧要。

[ocat]+在结尾添加一个+，使其与该集合中的一个或多个字符匹配。但这本身还不够;如果您有单词"coach"，则会匹配并返回"coac"。

\b[ocat]+\b' Now it only matches on word boundaries. (Thank you very much @Mark Tolonen for educating me about \ B`。）

所以，只需构建一个类似上面的模式，只在运行时使用所需的字符集，然后就可以了。您可以将此模式与re.findall()或re.finditer()一起使用。

import re

words = ["cat", "dog", "tack", "coat"]

def get_words(chars_seq, words_seq=words):
    s_chars = ''.join(chars_seq)
    s_pat = r'\b[' + s_chars + r']+\b'
    pat = re.compile(s_pat)
    return [word for word in words_seq if pat.match(word)]

assert get_words(['o', 'c', 'a', 't']) == ["cat", "coat"]
assert get_words(['k', 'c', 't', 'a']) == ["cat", "tack"]

Answer 4

我不会使用正则表达式来解决这个问题。我宁愿像这样使用collections.Counter：

>>> from collections import Counter
>>> def get_words(word_list, letter_string):
    return [word for word in word_list if Counter(word) & Counter(letter_string) == Counter(word)]
>>> words = ["cat", "dog", "tack", "coat"]
>>> letters = 'ocat'
>>> get_words(words, letters)
['cat', 'coat']
>>> letters = 'kcta'
>>> get_words(words, letters)
['cat', 'tack']

此解决方案也适用于其他语言。 Counter(word) & Counter(letter_string)找到两个计数器之间的交集，或min（c [x]，f [x]）。如果此交集等同于您的单词，则您希望将该单词作为匹配项返回。

正则表达式获取具有特定字母的所有单词列表（unicode字形）

4 个答案: