采取文本并清理/转换某些内容。

Question

tickettypepat = (r'MIS Notes:.*(//p//)?.*')
retype = re.search(tickettypepat,line)
if retype:
  print retype.group(0)
  print retype.group(1)

鉴于输入。

MIS Notes: //p//

任何人都可以告诉我为什么组（0）是

MIS Notes: //p//

和组（1）返回为无？

我最初使用的是正则表达式，因为在遇到问题之前，匹配比仅匹配// p //这里的完整代码更复杂。我是相当新的，所以原谅我的小说，我相信有更好的方法可以完成大部分工作，如果有人想指出那些会很棒的话。但除了// [pewPEW]的正则表达式问题之外//太贪心它似乎是功能性的。我很感激帮助。

采取文本并清理/转换某些内容。

filename = (r'.\4-12_4-26.txt')
import re
import sys
#Clean up output from the web to ensure that you have one catagory per line
f = open(filename)
w = open('cleantext.txt','w')

origdatepat = (r'(Ticket Date: )([0-9]+/[0-9]+/[0-9]+),( [0-9]+:[0-9]+ [PA]M)')
tickettypepat = (r'MIS Notes:.*(//[pewPEW]//)?.*')

print 'Begining Blank Line Removal'
for line in f:
    redate = re.search(origdatepat,line)
    retype = re.search(tickettypepat,line)
    if line == ' \n':
        line = ''
        print 'Removing blank Line'
#remove ',' from time and date line    
    elif redate:
        line = redate.group(1) + redate.group(2)+ redate.group(3)+'\n'
        print 'Redating... ' + line

    elif retype:
        print retype.group(0)
        print retype.group(1)

        if retype.group(1) == '//p//':
            line = line + 'Type: Phone\n'
            print 'Setting type for... ' + line
        elif retype.group(1) == '//e//':
            line = line + 'Type: Email\n'
            print 'Setting type for... ' + line
        elif retype.group(1) == '//w//':
            line = line + 'Type: Walk-in\n'
            print 'Setting type for... ' + line
        elif retype.group(1) == ('' or None):
            line = line + 'Type: Ticket\n'
            print 'Setting type for... ' + line

    w.write(line)

print 'Closing Files'                 
f.close()
w.close()

这是一些示例输入。

Ticket No.: 20100426132 
Ticket Date: 04/26/10, 10:22 AM 
Close Date:  
Primary User: XXX
Branch: XXX
Help Tech: XXX
Status: Pending  
Priority: Medium  
Application: xxx
Description: some issue
Resolution: some resolution
MIS Notes: some random stuff //p// followed by more stuff
Key Words:  

Ticket No.: 20100426132 
Ticket Date: 04/26/10, 10:22 AM 
Close Date:  
Primary User: XXX
Branch: XXX
Help Tech: XXX
Status: Pending  
Priority: Medium  
Application: xxx
Description: some issue
Resolution: some resolution
MIS Notes: //p//
Key Words:  

Ticket No.: 20100426132 
Ticket Date: 04/26/10, 10:22 AM 
Close Date:  
Primary User: XXX
Branch: XXX
Help Tech: XXX
Status: Pending  
Priority: Medium  
Application: xxx
Description: some issue
Resolution: some resolution
MIS Notes: //e// stuff....
Key Words:  


Ticket No.: 20100426132 
Ticket Date: 04/26/10, 10:22 AM 
Close Date:  
Primary User: XXX
Branch: XXX
Help Tech: XXX
Status: Pending  
Priority: Medium  
Application: xxx
Description: some issue
Resolution: some resolution
MIS Notes:
Key Words:

Answer 1

MIS Notes:.*(//p//)?.*就像这样，以"MIS Notes: //p//"作为目标的例子：

MIS Notes:匹配"MIS Notes:"，这里没有任何意外。
.*会立即运行到字符串的末尾（到目前为止匹配"MIS Notes: //p//"）
(//p//)?是可选的。没有任何事情发生。
.*没有任何东西要匹配，我们已经在字符串的末尾了。由于星号允许前一个原子的零匹配，因此正则表达式引擎停止将整个字符串报告为匹配，并将子组报告为空。

现在，当您将正则表达式更改为MIS Notes:.*(//p//).*时，行为会发生变化：

MIS Notes:匹配"MIS Notes:"，此处仍然没有任何意外。
.*会立即运行到字符串的末尾（到目前为止匹配"MIS Notes: //p//"）
(//p//)是必要的。引擎开始逐个字符地回溯以满足此要求。（到目前为止匹配"MIS Notes: "）
(//p//)可以匹配。子组1已保存并包含"//p//"。
.*运行到字符串的末尾。提示：如果你对匹配的内容不感兴趣，那就多余了，你可以删除它。

现在，当您将正则表达式更改为MIS Notes:.*?//(p)//时，行为会再次发生变化：

MIS Notes:匹配"MIS Notes:"，此处仍然没有任何意外。
.*?非贪婪并在进行之前检查以下原子（到目前为止匹配"MIS Notes: "）
//(p)//可以匹配。子组1已保存并包含"p"。
完成。请注意，不会发生回溯，这可以节省时间。

现在，如果您知道/之前没有//p//，则可以使用：MIS Notes:[^/]*//(p)//：

MIS Notes:匹配"MIS Notes:"，您明白了。
[^/]*可以快进到第一个斜杠（这比.*?更快）
//(p)//可以匹配。子组1已保存并包含"p"。
完成。请注意，不会发生回溯，这可以节省时间。这应该比版本＃3更快。

Answer 2

正则表达式是贪婪的，这意味着.*尽可能匹配整个字符串。因此，可选组没有任何内容可供匹配。 group(0)始终是整个匹配的刺痛。

你评论，为什么你的活动想要正则表达式？这样的事情不够：

if line.startswith('MIS Notes:'): # starts with that string
    data = line[len('MIS Notes:'):] # the rest in the interesting part
    if '//p//' in data:
        stuff, sep, rest = data.partition('//p//') # or sothing like that
    else:
        pass #other stuff

Answer 3

这种模式对于您的目的来说是模棱两可的。通过前缀或后缀对它们进行分组会很好。在这里的例子中，我选择了前缀分组。基本上，如果行中出现//p//，则前缀为非空。后缀将保留//p//项之后的所有内容，或者行中的所有内容（如果不存在）。

import re
lines = ['MIS Notes: //p//',
    'MIS Notes: prefix//p//suffix']

tickettypepat = (r'MIS Notes: (?:(.*)//p//)?(.*)')
for line in lines:
    m = re.search(tickettypepat,line)
    print 'line:', line
    if m: print 'groups:', m.groups()
    else: print 'groups:', m

结果：

line: MIS Notes: //p//
groups: ('', '')
line: MIS Notes: prefix//p//suffix
groups: ('prefix', 'suffix')

python中的正则表达式可选匹配失败

采取文本并清理/转换某些内容。

3 个答案: