Python：re.compile 和 re.sub

Question

问题第 1 部分

我得到了这个文件 f1：

<something @37>
<name>George Washington</name> 
<a23c>Joe Taylor</a23c>
</something @37>

我想重新编译它，它看起来像这样 f1:（带空格）

George Washington Joe Taylor

我试过这段代码，但它有点删除了所有内容：

import re
file = open('f1.txt')
fixed = open('fnew.txt','w')
text = file.read()

match = re.compile('<.*>')
for unwanted in text:
    fixed_doc = match.sub(r' ',text)

fixed.write(fixed_doc)

我的猜测是 re.compile 行，但我不太确定如何处理它。 我不应该使用 3rd 方扩展。 有任何想法吗？


问题第 2 部分

我有一个关于比较 2 个文件的不同问题，我从 Alfe 得到了这个代码：

from collections import Counter

def test():
    with open('f1.txt') as f:
        contentsI = f.read()
    with open('f2.txt') as f:
        contentsO = f.read()

    tokensI = Counter(value for value in contentsI.split()
                        if value not in [])
    tokensO = Counter(value for value in contentsO.split()
                        if value not in [])
    return not (tokensI - tokensO) and not (set(tokensO) - set(tokensI))

是否可以在“if value not in []”部分中实现 re.compile 和 re.sub？

Answer 1

我将解释您的代码会发生什么：

import re
file = open('f1.txt')
fixed = open('fnew.txt','w')
text = file.read()

match = re.compile('<.*>')
for unwanted in text:
    fixed_doc = match.sub(r' ',text)

fixed.write(fixed_doc)

指令text = file.read()创建一个名为型串的对象文本 text 。
请注意，我使用粗体字符文本来表示OBJECT，并使用text来表示此对象的名称== IDENTIFIER。
作为for unwanted in text:的指令的结果for unwanted in text: ， unwanted的标识符被连续地分配给文本对象引用的每个字符。

此外， re.compile('<.*>')创建一个RegexObject类型的对象（我个人称之为编译）正则表达式或简单的正则表达式 ， <.*>只是正则表达式模式 ）。
您将此编译的正则表达式对象分配给标识符match ：这是一个非常糟糕的做法，因为match已经是正则表达式对象的方法的名称，特别是您创建的方法的名称，因此您可以编写match.match而不用错误。
match也是re模块的函数名称。
使用此名称满足您的特殊需求非常令人困惑。 你必须避免这种情况。

使用file作为文件f1的文件处理程序的名称存在同样的缺陷。 file已经是语言中使用的标识符，你必须避免使用它。

好。 现在定义了这个命名错误的匹配对象，指令fixed_doc = match.sub(r' ',text)将替换fixed_doc = match.sub(r' ',text)所有正则表达式匹配的文本替换为r' ' 。
请注意，这是完全多余的写r' '而不是仅仅' '因为绝对没有什么在' '需要进行转义。 每当他们必须在正则表达式问题中编写字符串时，一些焦虑的人都会写一些原始字符串。

因为它的模式<.+> ，其中点符号的意思是“贪婪地吃掉位于<和a >之间的每个字符，除非它是换行符”，在匹配的文本中捕获的出现的每一行都是直到最后一个>在里面。
由于此指令中不显示unwanted的名称，因此对于文本的每个字符，它是一个接一个地执行的操作。 也就是说：没什么好玩的。
要分析程序的执行，您应该在代码中添加一些打印指令，以便了解发生的情况。 例如，如果你print repr(fixed_doc) ，你会看到重复打印： ' \\n \\n \\n ' 。 正如我所说：没有什么有趣的。

您的代码中还有一个默认值：您打开文件，但不关闭它们。 关闭文件是强制性的，否则它可能会发生一些奇怪的现象，在我意识到这种需要之前，我个人在我的一些代码中观察到了这些现象。 有些人假装它不是强制性的，但它是假的。
顺便说一下，打开和关闭文件的更好方式是使用with语句。 它可以完成所有工作而无需担心。

。

那么，现在我可以为您提出第一个问题的代码：

import re

def ripl(mat=None,li = []):
    if mat==None:
        li[:] = []
        return
    if mat.group(1):
        li.append(mat.span(2))
        return ''
    elif mat.span() in li:
        return ''
    else:
        return mat.group()

r = re.compile('</[^>]+>'
               '|'
               '<([^>]+)>(?=.*?(</\\1>))',
               re.DOTALL)

text = '''<something @37>
<name>George <wxc>Washington</name> 
<a23c>Joe </zazaza>Taylor</a23c>
</something @37>'''
print '1------------------------------------1'
print text
print '2------------------------------------2'
ripl()
print r.sub(ripl,text)
print '3------------------------------------3'

结果

1------------------------------------1
<something @37>
<name>George <wxc>Washington</name> 
<a23c>Joe </zazaza>Taylor</a23c>
</something @37>
2------------------------------------2

George <wxc>Washington 
Joe </zazaza>Taylor

3------------------------------------3

原则如下：

当正则表达式检测到标签时，
- 如果它是一个结束标记，它匹配 - 如果它是一个开始标记，它只有在文本中的某个地方有相应的结束标记时才匹配
对于每个匹配，正则表达式r的方法sub()调用函数ripl()来执行替换。
如果匹配是一个开始标记（必须在文本中的某个地方跟随其相应的结束标记，通过构造正则表达式），则ripl()返回'' 。
如果匹配是结束标记，则ripl()仅在检测到文本中的此结束标记与先前开始标记的对应结束标记时才返回'' 。 这是通过在一个列表里的每个相应的结束标记的跨度每次检测开始标记时间和匹配的跨度记录完成的可能。

记录列表li被定义为默认参数，以便它始终与函数ripl()每次调用时使用的列表相同（请参考ripl()的默认参数的函数，因为它是微妙的）。
由于将li定义为接收默认参数的参数，列表对象li将保留在分析若干文本时记录的所有跨度，以防连续分析若干文本。 为了避免列表li保留过去文本匹配的跨度，有必要使列表为空。 我编写了函数，以便第一个参数定义为默认参数None ：允许在正则表达式的sub()方法中使用它之前调用ripl()而不使用参数。
然后，必须考虑在使用它之前编写ripl() 。

。

如果要删除文本的换行符以获得您在问题中显示的精确结果，则必须将代码修改为：

import re

def ripl(mat=None,li = []):
    if mat==None:
        li[:] = []
        return
    if mat.group(1):
        return ''
    elif mat.group(2):
        li.append(mat.span(3))
        return ''
    elif mat.span() in li:
        return ''
    else:
        return mat.group()


r = re.compile('( *\n *)'
               '|'
               '</[^>]+>'
               '|'
               '<([^>]+)>(?=.*?(</\\2>)) *',
               re.DOTALL)

text = '''<something @37>
<name>George <wxc>Washington</name> 
<a23c>Joe </zazaza>Taylor</a23c>
</something @37>'''
print '1------------------------------------1'
print text
print '2------------------------------------2'
ripl()
print r.sub(ripl,text)
print '3------------------------------------3'

结果

1------------------------------------1
<something @37>
<name>George <wxc>Washington</name> 
<a23c>Joe </zazaza>Taylor</a23c>
</something @37>
2------------------------------------2
George <wxc>WashingtonJoe </zazaza>Taylor
3------------------------------------3

Answer 2

您可以使用Beautiful Soup轻松完成此操作：

from bs4 import BeautifulSoup
file = open('f1.txt')
fixed = open('fnew.txt','w')

#now for some soup

soup = BeautifulSoup(file)

fixed.write(str(soup.get_text()).replace('\n',' '))

上述行的输出将是：

George Washington Joe Taylor

（至少这适用于你给我的样本）

对不起，我不明白第2部分，祝你好运！

Answer 3

想出第一部分就是缺少'？'

match = re.compile('<.*?>')

诀窍。

无论如何仍然不确定第二个问题。 ：/

Answer 4

对于第1部分，请尝试以下代码段。 但是考虑使用像Moe Jan建议的像beautifulsoup这样的库

import re
import os
def main():
    f = open('sample_file.txt')
    fixed = open('fnew.txt','w')



    #pattern = re.compile(r'(?P<start_tag>\<.+?\>)(?P<content>.*?)(?P<end_tag>\</.+?\>)')
    pattern = re.compile(r'(?P<start><.+?>)(?P<content>.*?)(</.+?>)')
    output_text = []
    for text in f:
        match = pattern.match(text)
        if match is not None:
            output_text.append(match.group('content'))

    fixed_content = ' '.join(output_text)


    fixed.write(fixed_content)
    f.close()
    fixed.close()

if __name__ == '__main__':
    main()

第2部分 ：

我并不完全清楚你所问的是什么 - 但是我的猜测是你想要做的事情， if re.sub(value) not in [] 。 但是，请注意，在初始化Counter实例之前，只需要调用re.compile一次。 如果你澄清问题的第二部分会更好。

实际上，我建议您使用内置的Python diff模块来查找两个文件之间的差异。 使用这种方法比使用自己的diff算法更好，因为diff逻辑经过了很好的测试和广泛使用，并且不容易受到虚假换行符，制表符和空格字符的影响而导致的逻辑或编程错误。

Answer 5

不需要重新编译

进口重新

enter code here clean_string = ''

使用 open('f1.txt') 作为 f1：
对于 f1 中的行：
match = re.search('.+>(.+)<.+', line)
如果匹配：
clean_string += (match.group(1))
clean_string += ' '

打印（clean_string）#'乔治华盛顿乔泰勒'