python常用正则表达式 python中正则表达式是什么

本文以作者实际工作写的中、英文语句语法检查工具为例来介绍正则表达式的用法。

#encoding:utf-8

Created on 2016年5月11日

import chardet

import sys

import re

#中文编码字符串

chinese_code=u'\u4E00-\u9FA5'

fullwidth_num=u'\uFF10-\uFF19'

fullwidth_char=u'\uff21-\uff3a\uff41-\uff5a'

fullwidth_black=u'\u3000'

fullwidth_common_symbol=u'\uff01-\uff0f\uff1a-\uff20\uff3b-\uff40\uff5b-\uff5e\uFF5F-\uFF65\uFF9E-\uFF9F'

halfwidth_num=u'\u0030-\u0039'

halfwidth_char=u'\u0041-\u005a\u0061-\u007a'

halfwidth_black=u'\u0020'

halfwidth_symbol=u'\u0021-\u002f\u003a-\u0040\u005b-\u0060\u007b-\u007e'

english_code=halfwidth_num+halfwidth_char+halfwidth_black+halfwidth_symbol

english_code_withoutblack=halfwidth_num+halfwidth_char+halfwidth_symbol

fullwidth_period=u'\u3002'#中文句号

fullwidth_double_quote_front=u'\u201c'#“

fullwidth_double_quote_end=u'\u201d'#”

fullwidth_single_quote_front=u'\u2018'#‘

fullwidth_single_quote_end=u'\u2019'#’

fullwidth_comma=u'\uff0c'#,

fullwidth_slight_pause=u'\u3001'#、

fullwidth_round_bracket_left=u'\uff08'#圆括号左半部（

fullwidth_round_bracket_right=u'\uff09'#圆括号右半部）

fullwidth_book_left=u'\u300a'#书名号左半部《

fullwidth_book_right=u'\u300b'#书名号右半部》

fullwidth_colon=u'\uff1a'#中文冒号：

fullwidth_dash=u'\u2014\u2014'#中文破折号——

fullwidth_percent=u'\uff05'#中文百分号%

halfwidth_dash=u'\u002d'#-

halfwidth_percent=u'\u0025'#百分号%

check_stauts_ok_str="ok"

check_stauts_fail_str="fail"

check_stauts_manual_str="manual"

def record_log(aLog):

f=open('website.txt','ab')

f.write(aLog)

f.close()

#需要人工检查的标点符号

special_sysmbol=fullwidth_period+fullwidth_double_quote_front+ \

fullwidth_double_quote_end+fullwidth_single_quote_front+ \

fullwidth_single_quote_end+fullwidth_comma+ \

fullwidth_slight_pause+fullwidth_round_bracket_left+ \

fullwidth_round_bracket_right+fullwidth_book_left+ \

fullwidth_book_right+fullwidth_colon+fullwidth_dash+ \

halfwidth_dash+fullwidth_percent+halfwidth_percent

#所有已知的标点符号（包括全角、半角）

all_symbol=fullwidth_common_symbol+ \

halfwidth_symbol+ \

special_sysmbol

#所有全角标点符号（不包括空格）

fullwidth_symbol_all=fullwidth_common_symbol+fullwidth_period+fullwidth_double_quote_front+ \

fullwidth_double_quote_end+fullwidth_single_quote_front+ \

fullwidth_single_quote_end+fullwidth_comma+fullwidth_slight_pause+ \

fullwidth_round_bracket_left+fullwidth_round_bracket_right+ \

fullwidth_book_left+fullwidth_book_right+fullwidth_colon+ \

fullwidth_dash+fullwidth_percent

#中/英文语句：无全角英文、无全角数字、全角空格

def rule_one(aUnicodeStr):

pat1=re.compile('[%s%s%s]'%(fullwidth_num,fullwidth_char,fullwidth_black))

#print pat1.pattern

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

if mat1:

res_status='fail'

res_message=u'规则1-中英文语句：不能含有全角英文、全角数字、全角空格\n出错范围：%s'%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

return (res_status,res_message)

#英文语句：不含有全角标点符号、全角空格、全角数字

def rule_four(aUnicodeStr):

pat1=re.compile('[%s]+'%fullwidth_symbol_all)

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

if mat1:

res_status=check_stauts_fail_str

res_message=u"规则4-英文语句：不能含有非ascii码字符\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

return (res_status,res_message)

#中文语句：结尾必须是全角标点符号或无标点

def rule_five(aUnicodeStr):

#pat1=re.compile('[%s]*$'%fullwidth_symbol_all)

pat1=re.compile('[%s]+$'%(halfwidth_symbol))

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

#mat2=pat2.search(aUnicodeStr)

if mat1 :

res_status=check_stauts_fail_str

res_message=u"规则5-中文语句：结尾必须是全角标点符号或无标点符号\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

return (res_status,res_message)

#中文语句：英文字母、数字之间如果有标点符号，必须为半角

def rule_six(aUnicodeStr):

pat1=re.compile('[%s]{1}[%s]+[%s]{1}'%(halfwidth_num+halfwidth_char,

fullwidth_symbol_all,halfwidth_num+halfwidth_char))

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

if mat1:

res_status=check_stauts_fail_str

res_message=u"规则6-中文语句：英文字母、数字之间如果有标点符号，必须为半角\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

return (res_status,res_message)

#中文语句：中文前后标点符号，必须为全角

def rule_seven(aUnicodeStr):

pat1=re.compile('[%s]+[%s]+'%(chinese_code,halfwidth_symbol))

pat2=re.compile('[%s]+[%s]+'%(halfwidth_symbol,chinese_code))

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

if mat1 or mat2:

res_status=check_stauts_fail_str

if mat1:

res_message=u"规则7-中文语句：中文前后标点符号，必须为全角\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

else:

res_message=u"规则7-中文语句：中文前后标点符号，必须为全角\n出错范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

#return (res_status,res_message)

return (check_stauts_ok_str,'')

#中文语句：全角双引号（“”）中可出现单引号，反之不可以

def rule_eight(aUnicodeStr):

pat1=re.compile(u'[‘]+[^“”‘’]*[“]+[^“”‘’]*[”]+[^“”‘’]*[’]+')

pat2=re.compile(u'[‘]+[^“”‘’]*[“]+[^“”‘’]*[‘]+[^“”‘’]*[”]+')

pat3=re.compile(u'[‘]+[^“”‘’]*[“]+[^“”‘’]*[”]+[^“”‘’]*[’]+')

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

mat3=pat3.search(aUnicodeStr)

if mat1 or mat2 or mat3 :

res_status=check_stauts_fail_str

if mat1:

res_message=u"规则8-中文语句：全角双引号（“”）中可出现单引号‘’，反之不可以\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

elif mat2:

res_message=u"规则8-中文语句：全角双引号（“”）中可出现单引号‘’，反之不可以\n出错范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

else :

res_message=u"规则8-中文语句：全角双引号（“”）中可出现单引号‘’，反之不可以\n出错范围：%s"%("("+str(mat3.span()[0])+','+str(mat3.span()[1])+")")

return (res_status,res_message)

#中文语句：全角双引号内不允许含有全角分号、冒号

def rule_nine(aUnicodeStr):

pat1=re.compile(u'[“]+[^“”]*[：]+[”]')

pat2=re.compile(u'[“]+[^“”]*[；]+[”]')

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

if mat1 or mat2:

res_status=check_stauts_fail_str

if mat1:

res_message=u"规则9-中文语句：全角双引号内不允许含有全角分号、冒号\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

else:

res_message=u"规则9-中文语句：全角双引号内不允许含有全角分号、冒号\n出错范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

return (res_status,res_message)

#中文语句：括号内包含纯中文或同时包含中文及英文和数字时，使用全角括号，括号前后不加空格。

def rule_ten(aUnicodeStr):

pat1=re.compile(u'（[ ]+')

pat2=re.compile(u'[ ]+（')

pat3=re.compile(u'）[ ]+')

pat4=re.compile(u'[ ]+）')

pat5=re.compile(u'[（]{1}[a-zA-Z0-9]*[^%s%s]+[a-zA-Z0-9]*[）]{1}'%(chinese_code,fullwidth_symbol_all))

#pat5=re.compile(u'[(]{1}[a-zA-Z0-9]*[%s%s]+[a-zA-Z0-9]*[)]{1}'%(chinese_code,fullwidth_symbol_all))

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

mat3=pat3.search(aUnicodeStr)

mat4=pat4.search(aUnicodeStr)

mat5=pat5.search(aUnicodeStr)

if mat1 or mat2 or \

mat3 or mat4 or \

mat5:

res_status=check_stauts_fail_str

if mat1:

res_message=u"规则10-中文语句：括号内包含纯中文或同时包含中文及英文和数字时，使用全角括号，括号前后不加空格\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

elif mat2:

res_message=u"规则10-中文语句：括号内包含纯中文或同时包含中文及英文和数字时，使用全角括号，括号前后不加空格\n出错范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

elif mat3:

res_message=u"规则10-中文语句：括号内包含纯中文或同时包含中文及英文和数字时，使用全角括号，括号前后不加空格\n出错范围：%s"%("("+str(mat3.span()[0])+','+str(mat3.span()[1])+")")

elif mat4:

res_message=u"规则10-中文语句：括号内包含纯中文或同时包含中文及英文和数字时，使用全角括号，括号前后不加空格\n出错范围：%s"%("("+str(mat4.span()[0])+','+str(mat4.span()[1])+")")

else :

res_message=u"规则10-中文语句：括号内包含纯中文或同时包含中文及英文和数字时，使用全角括号，括号前后不加空格\n出错范围：%s"%("("+str(mat5.span()[0])+','+str(mat5.span()[1])+")")

return (res_status,res_message)

#中文语句：括号内的内容为纯英文、纯数字或纯半角英文符号时，使用半角括号，括号前后加半角空格。

def rule_eleven(aUnicodeStr):

#pat1=re.compile(u'[(]{1}[^\u0020]+')

pat2=re.compile(u'[^\u0020]+[(]{1}')

pat3=re.compile(u'[)]{1}[^\u0020]+')

#pat4=re.compile(u'[^\u0020]+[)]{1}')

pat5=re.compile(u'[\u0020]{1}[(]{1}[\u0020]{1}[%s]*[%s]+[%s]*[\u0020]{1}[)]{1}[\u0020]{1}'%(

english_code_withoutblack,

chinese_code+fullwidth_symbol_all,

english_code_withoutblack))

pat6=re.compile(u'^[(]')

pat7=re.compile(u'[)]{1}$')

res_status=check_stauts_ok_str

res_message=''

#mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

mat3=pat3.search(aUnicodeStr)

#mat4=pat4.search(aUnicodeStr)

mat5=pat5.search(aUnicodeStr)

mat6=pat6.search(aUnicodeStr)

mat7=pat7.search(aUnicodeStr)

if mat2 or \

mat3 or \

mat5 or mat6 or \

mat7 :

res_status=check_stauts_fail_str

#if mat1:

# res_message=u"规则11-中文语句：括号内的内容为纯英文、纯数字或纯半角英文符号时，使用半角括号，括号前后加半角空格\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

if mat2:

res_message=u"规则11-中文语句：括号内的内容为纯英文、纯数字或纯半角英文符号时，使用半角括号，括号前后加半角空格\n出错范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

elif mat3:

res_message=u"规则11-中文语句：括号内的内容为纯英文、纯数字或纯半角英文符号时，使用半角括号，括号前后加半角空格\n出错范围：%s"%("("+str(mat3.span()[0])+','+str(mat3.span()[1])+")")

#elif mat4:

# res_message=u"规则11-中文语句：括号内的内容为纯英文、纯数字或纯半角英文符号时，使用半角括号，括号前后加半角空格\n出错范围：%s"%("("+str(mat4.span()[0])+','+str(mat4.span()[1])+")")

elif mat5:

res_message=u"规则11-中文语句：括号内的内容为纯英文、纯数字或纯半角英文符号时，使用半角括号，括号前后加半角空格\n出错范围：%s"%("("+str(mat5.span()[0])+','+str(mat5.span()[1])+")")

elif mat6:

res_message=u"规则11-中文语句：括号内的内容为纯英文、纯数字或纯半角英文符号时，使用半角括号，括号前后加半角空格\n出错范围：%s"%("("+str(mat6.span()[0])+','+str(mat6.span()[1])+")")

else:

res_message=u"规则11-中文语句：括号内的内容为纯英文、纯数字或纯半角英文符号时，使用半角括号，括号前后加半角空格\n出错范围：%s"%("("+str(mat7.span()[0])+','+str(mat7.span()[1])+")")

return (res_status,res_message)

#中文语句：全角中文字符与半角英文字符和半角阿拉伯数字之间应有一个半角空格

def rule_twelve(aUnicodeStr):

pat1=re.compile(u'[a-zA-Z0-9]+[%s]+'%chinese_code)

pat2=re.compile(u'[%s]+[a-zA-Z0-9]+'%chinese_code)

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

if mat1 or mat2 :

res_status=check_stauts_fail_str

if mat1:

res_message=u"规则12-中文语句：全角中文字符与半角英文字符和半角阿拉伯数字之间应有一个半角空格\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

else:

res_message=u"规则12-中文语句：全角中文字符与半角英文字符和半角阿拉伯数字之间应有一个半角空格\n出错范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

return (res_status,res_message)

#中文语句：全角标点符号与前后字符之间均不留空。

def rule_thirteen(aUnicodeStr):

pat1=re.compile(u'[%s]+[\u0020]+'%fullwidth_symbol_all)

pat2=re.compile(u'[\u0020]+[%s]+'%fullwidth_symbol_all)

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

if mat1 or mat2 :

res_status=check_stauts_fail_str

if mat1:

res_message=u"规则13-中文语句：全角标点符号与前后字符之间均不留空。\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

else:

res_message=u"规则13-中文语句：全角标点符号与前后字符之间均不留空。\n出错范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

return (res_status,res_message)

#中文语句：中文之间无空格

def rule_fourteen(aUnicodeStr):

pat1=re.compile(u'[%s]+[\u0020]+[%s]'%(chinese_code,chinese_code))

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

if mat1:

res_status=check_stauts_fail_str

res_message=u"规则14-中文语句：全角标点符号与前后字符之间均不留空。\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

return (res_status,res_message)

中文语句：以下标点符号成对出现，且有先后顺序：

全角：（）、“”、‘’，《》，｛｝，【】

半角：()、{},[]

def rule_fifteen(aUnicodeStr):

res_status=check_stauts_ok_str

res_message=''

symbol_count_map={u'（':0,u'）':0,u'“':0,u'”':0,u'‘':0,u'’':0,u'《':0,u'》':0,

u'｛':0,u'｝':0,u'【':0,u'】':0,u'(':0,u')':0,u'{':0,u'}':0,

u'[':0,u']':0}

symbol_pos_map={u'（':[],u'）':[],u'“':[],u'”':[],u'‘':[],u'’':[],u'《':[],u'》':[],

u'｛':[],u'｝':[],u'【':[],u'】':[],u'(':[],u')':[],u'{':[],u'}':[],

u'[':[],u']':[]}

symbol_pair_map={u'（':u'）',u'“':u'”',u'‘':u'’',u'《':u'》',

u'｛':u'｝',u'【':u'】',u'(':u')',u'{':u'}',

u'[':u']'}

#获取字符的个数

for (kT,vT) in symbol_count_map.items():

symbol_count_map[kT]=aUnicodeStr.count(kT)

#获取字符位置

for (kT,vT) in symbol_count_map.items():

if vT==0:

continue

else:

for i in range(1,vT+1):

symbol_pos_map[kT].append(get_substr_pos(aUnicodeStr,kT,i))

#检查是否成对出现，且前后顺序正确

for (kT,vT) in symbol_pair_map.items():

if symbol_count_map[kT] != symbol_count_map[vT]:

res_status=check_stauts_fail_str

res_message=u"规则15-中英文语句：（）、“”、‘’，《》，｛｝，【】 ()、{},[]必须成对出现，且有先后顺序"

elif symbol_count_map[kT] != 0:

for i in range(0,symbol_count_map[kT]):

if symbol_pos_map[kT][i]>=symbol_pos_map[vT][i]:

res_status=check_stauts_fail_str

res_message=u"规则15-中英文语句：（）、“”、‘’，《》，｛｝，【】 ()、{},[]必须成对出现，且有先后顺序"

break

if res_status == check_stauts_fail_str:

break

return (res_status,res_message)

#中文语句：中文后面的标点符号应为全角标点符号

def rule_sixteen(aUnicodeStr):

pat1=re.compile(u'[%s]+[%s]+'%(chinese_code,halfwidth_symbol))

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

if mat1:

res_status=check_stauts_fail_str

res_message=u"规则16-中文语句：中文后面的标点符号应为全角标点符号。\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

return (res_status,res_message)

#中文语句：开头和结尾不能是半角、全角空格

def rule_seventeen(aUnicodeStr):

pat1=re.compile(u'^ +')

pat2=re.compile(u' +$')

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

if mat1 or mat2:

res_status=check_stauts_fail_str

if mat1:

res_message=u"规则17-中文语句：开头和结尾不能是半角、全角空格。\n出错范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

else:

res_message=u"规则17-中文语句：开头和结尾不能是半角、全角空格。\n出错范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

return (res_status,res_message)

#中文语句：括号中的内容为独立的语句时，句号应包含在括号内

def rule_eightteen(aUnicodeStr):

pat1=re.compile(u'（+.*。+.*）+')

pat2=re.compile(u'（+.*）+.*。+')

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

if mat1 or mat2:

res_status=check_stauts_manual_str

if mat1:

res_message=u"规则18-中文语句：括号中的内容为独立的语句时，句号应包含在括号内。请人工检查\n检查范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

else :

res_message=u"规则18-中文语句：括号中的内容为独立的语句时，句号应包含在括号内。请人工检查\n检查范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

return (res_status,res_message)

#中文语句：
19.20.22.23.24.25.26.27.28.30.33

def rule_nineteen(aUnicodeStr):

symbol_manual_map={u'“': u"规则19-引用说话的语句或对特定词句进行强调时使用全角双引号（“”），注意前后双引号不同,请手工检查",

u'‘': u"规则20-双重引用时使用全角单引号（‘’），注意前后单引号不同,请手工检查",

u'，': u"规则22-中文语句中的停顿应用全角逗号（，）,请手工检查",

u'、': u"规则23-中文语句中的并列词间和中文语句中的英文并列词间均应该用全角顿号（、）分隔，而不用逗号。,请手工检查",

u'（': u"规则24-对于前一语句改换说法，或作补充说明时，使用圆括号。圆括号包括全角（）和半角 () 两种形式,请手工检查",

u'(': u"规则24-对于前一语句改换说法，或作补充说明时，使用圆括号。圆括号包括全角（）和半角 () 两种形式,请手工检查",

u'：': u"规则25-列举项目时，使用全角冒号。2. 表示时间的 (:) 应使用半角冒号。,请手工检查",

u':': u"规则25-列举项目时，使用全角冒号。2. 表示时间的 (:) 应使用半角冒号。,请手工检查",

u'——':u"规则26-做补充说明或话题转换时使用中文全角破折号（——） ,请手工检查",

u'-': u"规则26- 当表示数值间的范围（例如日期、时间或数字），或当表示两个名词的复合，或表示图序、表序的标号时，使用英文半角连字符 (-) ,请手工检查",

u'《': u"规则27-书名、节目名、法律法规名等需要所以书名号（《》）进行标注,请手工检查 ",

u'%': u"规则28-针对占位符，如果占位符代替的是数字，则前后视情况加空格，如果代替的是中文，则无需空格,请手工检查 ",

u'％': u"规则28-针对占位符，如果占位符代替的是数字，则前后视情况加空格，如果代替的是中文，则无需空格 ,请手工检查",

u'月': u"规则30-针对日期，只有在日历里显示日期的时候不加空格，比如：2016年5月6日；在其他地方，比如设置里显示“开始于 1 月 1 日”的时候需要空格,请手工检查 ",

u'年': u"规则30-针对日期，只有在日历里显示日期的时候不加空格，比如：2016年5月6日；在其他地方，比如设置里显示“开始于 1 月 1 日”的时候需要空格,请手工检查",

u'日': u"规则30-针对日期，只有在日历里显示日期的时候不加空格，比如：2016年5月6日；在其他地方，比如设置里显示“开始于 1 月 1 日”的时候需要空格,请手工检查",

u'.': u"规则33-如果需要沿用原文中的外文缩写、外国人姓和名缩写、注册商标、产品名、公司名及国名的缩写，则用半角英文句点 (.) 来表示该缩写。3. 半角句点 (.) 也可用作数字中的小数点或文件名中的分隔符,请手工检查 ",

res_status=check_stauts_ok_str

res_message=''

for (kT,vT) in symbol_manual_map.items():

pat1=re.compile('[%s]+'%kT)

if pat1.search(aUnicodeStr):

res_status=check_stauts_manual_str

res_message=vT

break

return (res_status,res_message)

引号:3. 除非引用的内容与标点符号相对独立，否则句号（。）、逗号（，）、问号（？）、感叹号（！）应保留在双引号内，

并采用全角输入。

def rule_twentyone(aUnicodeStr):

pat1=re.compile(u'“+[^”]*[。，？！.\,\?\!]+')

pat2=re.compile(u'”+[。，？！.\,\?\!]+')

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

mat2=pat2.search(aUnicodeStr)

if mat1 or mat2:

res_status=check_stauts_manual_str

if mat1:

res_message=u"规则21-中文语句：除非引用的内容与标点符号相对独立，否则句号（。）、逗号（，）、问号（？）、感叹号（！）应保留在双引号内，并采用全角输入\n检查范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

else :

res_message=u"规则21-中文语句：除非引用的内容与标点符号相对独立，否则句号（。）、逗号（，）、问号（？）、感叹号（！）应保留在双引号内，并采用全角输入\n检查范围：%s"%("("+str(mat2.span()[0])+','+str(mat2.span()[1])+")")

return (res_status,res_message)

数字与英文单位间加一个半角空格

def rule_twentynine(aUnicodeStr):

pat1=re.compile(u'[0-9]+[ 　]*[a-zA-Z]+')

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

if mat1:

res_status=check_stauts_manual_str

res_message=u"规则29-数字与英文单位间加一个半角空格\n检查范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

return (res_status,res_message)

标点符号连续出现

def rule_thirtyone(aUnicodeStr):

pat1=re.compile(u'[\!\%\(\)\{\}\[\]\;\:\'\"\?\,\.。！\%（）\{\}【】；：’“”’？，。、《》]{2,}')

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

if mat1:

res_status=check_stauts_manual_str

res_message=u"规则31-标点符号连续出现\n检查范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

return (res_status,res_message)

中文语句：英文字母、数字后面如果是标点符号，则应该是半角

def rule_thirtytwo(aUnicodeStr):

pat1=re.compile(u'[a-zA-Z0-9]+[\!\%\(\)\{\}\[\]\;\:\'\"\?\,\.。！\%（）\{\}【】；：’“”’？，。、《》]+')

res_status=check_stauts_ok_str

res_message=''

mat1=pat1.search(aUnicodeStr)

if mat1:

res_status=check_stauts_manual_str

res_message=u"规则32-英文字母、数字后面如果是标点符号，则应该是半角\n检查范围：%s"%("("+str(mat1.span()[0])+','+str(mat1.span()[1])+")")

return (res_status,res_message)

def get_substr_pos(aString, subStr, findCnt):

listStr = aString.split(subStr,findCnt)

if len(listStr) <= findCnt:

return -1

return len(aString)-len(listStr[-1])-len(subStr)

#中文语句是:含有至少一个中文（数字、标点符号不作为判断依据）

def check_iseng(aUnicodeStr):

pat1=re.compile(u'[%s]'%chinese_code)

res=True

if pat1.search(aUnicodeStr):

res=False

return res

def get_unicode_str(aOriginStr):

u_string=u''

if isinstance(aOriginStr, str):

print "ordinary string"

record_log("ordinary string")

u_string = unicode(aOriginStr, chardet.detect(aOriginStr)["encoding"])

elif isinstance(aOriginStr, unicode):

print "unicode string"

record_log("unicode string")

u_string=aOriginStr

else:

print "ERROR:not a string"

record_log("ERROR:not a string"+type(aOriginStr))

print type(aOriginStr)

return u_string

def rule_check_sentence(aOriginStr):

res_status=check_stauts_ok_str

res_message=''

uni_str=get_unicode_str(aOriginStr)

for i in range (0,1):

#规则1：中/英文语句：无全角英文、无全角数字、无全角空格

(res_status,res_message)=rule_one(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则17：中英文语句：开头和结尾不能是半角、全角空格

(res_status,res_message)=rule_seventeen(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则15：中英文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_fifteen(uni_str)

if res_status!=check_stauts_ok_str:

break

if check_iseng(uni_str):#英文语句

#规则4：英文语句：不含有全角标点符号、全角空格、全角数字

(res_status,res_message)=rule_four(uni_str)

if res_status!=check_stauts_ok_str:

break

else:

#规则5：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_five(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则6：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_six(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则7：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_seven(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则8：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_eight(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则9：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_nine(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则10：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_ten(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则11：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_eleven(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则12：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_twelve(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则13：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_thirteen(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则14：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_fourteen(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则16：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_sixteen(uni_str)

if res_status!=check_stauts_ok_str:

break

#检查是否需要人工干预

#规则18：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_eightteen(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则19：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_nineteen(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则21：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_twentyone(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则29：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_twentynine(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则31：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_thirtyone(uni_str)

if res_status!=check_stauts_ok_str:

break

#规则32：中文语句：以下标点符号成对出现，且有先后顺序

(res_status,res_message)=rule_thirtytwo(uni_str)

if res_status!=check_stauts_ok_str:

break

return (res_status,res_message)

def rule_check_buffer(aBuffer):

res_map={'ok':u'检查正确语句列表：\n','manual':u'需要人工检查语句列表：\n\n','fail':u'检查错误语句列表：\n\n'}

str_array=aBuffer.split('\n')

for i in range(0,len(str_array)):

uncheck_str=str_array[i].strip('\r\n')

#print uncheck_str

res_status=check_stauts_ok_str

res_message=''

(res_status,res_message)=rule_check_sentence(uncheck_str)

if res_status==check_stauts_ok_str:

res_map['ok']+=(u"语句："+uncheck_str+'\n')

elif res_status==check_stauts_fail_str:

res_map['fail']+=(u"语句："+uncheck_str+'\n'+u'出错原因：'+res_message+'\n\n')

elif res_status==check_stauts_manual_str:

res_map['manual']+=(u"语句："+uncheck_str+'\n'+u'待查原因：'+res_message+'\n\n')

else:

print "ERROR:can not check the sentence:%s"%uncheck_str

return res_map

if __name__ == '__main__':

print "This script is not for call directly。the following code is only for testing"

print rule_eleven(u"请停止(4k) 录像。")[0]

print rule_eleven(u"请停止(4k) 录像。")[1]