Python将消息记录到令牌中

我有一个格式为的日志消息

[2013-Mar-05 18:21:45.415053] (ThreadID) <Module name> [Logging level]    Message Desciption : This is the message.

我尝试使用空格分割来分割日志消息，然后我可以选择标记并创建列表。大概是这样的：

for i in line1.split(" "):

这将提供这样的代币

['2013-Mar-05', '18:21:45.415053]', '(ThreadID)', '<Module name>', '[Logging level]',    'Message Desciption', ':', 'This is the message.']

['2013-Mar-05'，'18:21:45.415053]，'（ThreadID）'，，'[Logging level]，'Message Description'，'：'，'This is the Message']

然后选择令牌并放入所需列表中

在这种情况下，是否有更好的方法提取令牌。这里有一个模式，如

时间戳

将位于

[]

括号内，

线程ID

将位于

（）

内，

模块名称

将位于

内。 我们可以利用这些信息直接提取令牌吗？

以下内容如何？（这些评论解释了发生的事情）

log='[2013-Mar-05 18:21:45.415053]（线程ID）[日志级别]消息描述：这是消息
#定义有关如何处理不同类型令牌的函数
时间戳=日志记录级别=lambda x:x.strip（“[]”）
螺纹ID=lambda x:x.strip（“（）”）
模块名称=λx:x.strip（“<>”）
消息描述=消息=λx:x
#用于生成字典键的令牌的名称
keys=[“时间戳”，“线程ID”，
“模块名称”、“日志记录级别”，
'消息描述'，'消息']
#定义有关如何处理消息的函数
funcs=[时间戳，线程ID，
模块名称、日志记录级别、，
消息\描述，消息]
#定义要拆分消息的标记
拆分时间=[']'、'）'、'>'、']'、'：']
msg_dict={}
对于范围内的i（len（split_on））：
#将日志一次拆分为一个令牌
temp，log=log.split（在[i]上拆分，1）
#使用定义的函数处理令牌
msg_dict[keys[i]=funcs[i]（临时）
msg_dict[keys[i]=funcs[i]（日志）#处理最后一个令牌
打印消息

虽然在这种情况下使用更简单，但如果您不想使用它，
试试这个

string = '[2013-Mar-05 18:21:45.415053] (ThreadID) <Module name> [Logging level]    Message Desciption : This is the message.'

# the main function, return the items between start and end.
def get_between(start, end, string):
    in_between = 0
    c_str = ''
    items = []
    indexes = []
    for i in range(len(string)):
        char = string[i]
        if char == start:
            if in_between == 0: indexes.append(i) # if starting bracket
            in_between += 1
        elif char == end:
            in_between -= 1
            if in_between == 0: indexes.append(i) # if ending bracket
        elif in_between > 0:
            c_str += char
        if in_between == 0 and c_str != '': # after ending bracket
            items.append(c_str)
            c_str = ''
    return items, indexes

# As both Time Stamp, and Logging Level are between []s,
# And as message comes after Logging Level,
data,last_indexes = get_between('[',']',string)
time_stamp, logging = data
# We only want the first item in the first list
thread_id = get_between('(',')',string)[0][0]
module = get_between('<','>',string)[0][0]

last = max(last_indexes)
# extracting the message    
message = ''.join(string[last+1:].split(':')[1:]).strip()

mydict = {'Time':time_stamp, 'Thread ID':thread_id,'Module':module,'Logging Level':logging,'Message':message}
print mydict

string='[2013-Mar-05 18:21:45.415053]（线程ID）[日志记录级别]消息描述：这是消息。”
#主要功能是返回开始和结束之间的项目。
def get_介于（开始、结束、字符串）之间：
在=0之间
c_str=''
项目=[]
索引=[]
对于范围内的i（len（string））：
char=string[i]
如果char==开始：
if in_between==0:index.append（i）#if起始括号
在+=1之间
elif char==结束：
在-=1之间
if in_between==0:index.append（i）#if结束括号
elif in_介于>0之间：
c_str+=char
如果在=0和c_str！=''：#结束后括号
项目.附加（c_str）
c_str=''
返回项目、索引
#由于时间戳和日志记录级别都在[]s之间，
#当消息在日志级别之后出现时，
数据，last_index=get_between（'['，']'，string）
时间戳，记录=数据
#我们只想要第一个列表中的第一项
thread_id=get_-between（“（”，“）”，string）[0][0]
模块=获取（“”，字符串）[0][0]
最后=最大值（最后索引）
#提取消息
message=''.join（字符串[last+1:].split（'：'）[1:]）.strip（）
mydict={'Time'：时间戳，'Thread ID'：线程ID，'Module'：模块，'Logging Level'：日志，'Message'：Message}
打印mydict

---

在这里，我们获取两个“分类器”之间的字符，并使用正则表达式处理它们…

，希望这有帮助

import re

string = '[2013-Mar-05 18:21:45.415053] (4444) <Module name> [Logging level]  Message Desciption : This is the message.'

regex = re.compile(r'\[(?P<timestamp>[^\]]*?)\] \((?P<threadid>[^\)]*?)\) \<(?P<modulename>[^\>]*?)\>[^:]*?\:(?P<message>.*?)$')

for match in regex.finditer(string):
    dict = {'timestamp': match.group("timestamp"), 'threadid': match.group("threadid"), 'modulename': match.group('modulename'), 'message': match.group('message')}

print dict

重新导入
string='[2013-Mar-05 18:21:45.415053]（4444）[日志记录级别]消息描述：这是消息。”
regex=re.compile（r'\[（？P[^\]]*？）\]\（？P[^\]*？）\）\）\]*？）\>[^:*？\：（？P.*？）$）
对于regex.finditer中的匹配项（字符串）：
dict={'timestamp'：match.group（“timestamp”），'threadid'：match.group（“threadid”），'modulename'：match.group（'modulename'），'message'：match.group（'message'）}
打印口述

输出：

{'timestamp'：'2013-Mar-05 18:21:45.415053'，'message'：'这就是消息'，'modulename'：'modulename'，'threadid'：'4444'}

---

说明：我正在使用组来标记正则表达式的某些部分，以便稍后在脚本中使用。有关更多信息，请参阅。基本上，我从左到右遍历这行，寻找分隔符[，，如果日志格式一致，为什么不使用宏作为索引

范例

DATE = 0
TIME = 1
TID = 2
MODULE = 3
LOG_LVL = 4
MESSAGE = 5 (or more like 7)

log = ['2013-Mar-05', '18:21:45.415053]', '(ThreadID)', '<Module name>', '[Logging level]',    'Message Desciption', ':', 'This is the message.']

DATE=0
时间=1
工业贸易署=2
模块=3
LOG_LVL=4
消息=5（或更像7）
log=['2013-Mar-05'、'18:21:45.415053]、'（ThreadID）'、'[日志记录级别]、'Message Description'、'：'、'这是消息。']

然后只需使用log[DATE]或其他方式访问？最后，在使用基于索引的访问之前，使用“”连接要缝合在一起的块。然后，您可以按照自己的意愿填充词典

---

它没有Oli的解决方案那么简洁，但它可以完成以下工作：）

这里有一个非常类似于@Oli的答案，但是正则表达式更具可读性，我使用了

groupdict（）

，因此不需要形成一个新的字典，因为它是由regexp创建的。日志字符串从左到右解析，使用每个匹配项

fmt = re.compile(
      r'\[(?P<timestamp>.+?)\]\s+' # Save everything within [] to group timestamp
      r'\((?P<thread_id>.+?)\)\s+' # Save everything within () to group thread_id
      r'\<(?P<module_name>.+?)\>\s+' # Save everything within <> to group module_name
      r'\[(?P<log_level>.+?)\]\s+' # Save everything within [] to group to log_level
      r'(?P<message_desc>.+?)(\s:\s|$)' # Save everything before \s:\s or end of line to           group message_desc,
      r'(?P<message>.+$)?' # if there was a \s:\s, save everything after it to group   message. This last group is optional
      )

log = '[2013-Mar-05 18:21:45.415053] (4139) <ModuleA> [DEBUG]  Message Desciption : An example message!'

match = fmt.search(log)

print match.groupdict()

fmt=re.compile(
r'\[（？P.+？）\]\s+'\将[]内的所有内容保存到组时间戳
r'\（？P.+？）\）\s+'\将（）中的所有内容保存到组线程\u id
r'\\s+'#将组中的所有内容保存到组模块_名称
r'\[（？P.+？）\]\s+'\将[]中的所有内容保存到日志级别的组中
r'（？P.+？）（\s:\s |$）#将所有内容保存在\s:\s之前或行尾到组消息_desc，
r'（？P.+$）？'#如果有\s:\s，请将其后面的所有内容保存到组消息。最后一个组是可选的
)
log='[2013-Mar-05 18:21:45.415053]（4139）[调试]消息描述：一条示例消息！'
匹配=fmt.search（日志）
打印match.groupdict（）

示例：

log = '[2013-Mar-05 18:21:45.415053] (4139) <ModuleA> [DEBUG]  Message Desciption : An       example message!'
match = fmt.search(log)

print match.groupdict() 
{'log_level': 'DEBUG',
 'message': 'An example message!',
 'module_name': 'ModuleA',
 'thread_id': '4139',
 'timestamp': '2013-Mar-05 18:21:45.415053'}

log='[2013-Mar-05 18:21:45.415053]（4139）[调试]消息描述：一条示例消息！'
匹配=fmt.se
fmt = re.compile(
      r'\[(?P<timestamp>.+?)\]\s+' # Save everything within [] to group timestamp
      r'\((?P<thread_id>.+?)\)\s+' # Save everything within () to group thread_id
      r'\<(?P<module_name>.+?)\>\s+' # Save everything within <> to group module_name
      r'\[(?P<log_level>.+?)\]\s+' # Save everything within [] to group to log_level
      r'(?P<message_desc>.+?)(\s:\s|$)' # Save everything before \s:\s or end of line to           group message_desc,
      r'(?P<message>.+$)?' # if there was a \s:\s, save everything after it to group   message. This last group is optional
      )

log = '[2013-Mar-05 18:21:45.415053] (4139) <ModuleA> [DEBUG]  Message Desciption : An example message!'

match = fmt.search(log)

print match.groupdict()

log = '[2013-Mar-05 18:21:45.415053] (4139) <ModuleA> [DEBUG]  Message Desciption : An       example message!'
match = fmt.search(log)

print match.groupdict() 
{'log_level': 'DEBUG',
 'message': 'An example message!',
 'module_name': 'ModuleA',
 'thread_id': '4139',
 'timestamp': '2013-Mar-05 18:21:45.415053'}

log = '[2013-Mar-05 18:21:45.415053] (0x7aa5e3a0) <Logger> [Info] Opened settings file : /usr/local/ABC/ABC/var/loggingSettings.ini'

match = fmt.search(log)

print match.groupdict()
{'log_level': 'Info',
 'message': '/usr/local/ABC/ABC/var/loggingSettings.ini',
 'message_desc': 'Opened settings file',
 'module_name': 'Logger',
 'thread_id': '0x7aa5e3a0',
 'timestamp': '2013-Mar-05 18:21:45.415053'}

log = '[2013-Mar-05 18:21:45.415053] (0x7aa5e3a0) <Logger> [Info] Creating a new settings file'

match = fmt.search(log)

print match.groupdict()
{'log_level': 'Info',
 'message': None,
 'message_desc': 'Creating a new settings file',
 'module_name': 'Logger',
 'thread_id': '0x7aa5e3a0',
 'timestamp': '2013-Mar-05 18:21:45.415053'}