用户通过“resources>cli-driver.properties”文件，可以定制CLI设备驱动信息，用于解析和识别设备的CLI回显。常见配置项详细信息如下表所示。表1 配置项配置项名称配置值示例含义与作用userModePrompt^<HUAWEI.*>$用户模式下设备命令行提示符正则表达式，用于解析返回报文是否为用户模式提示符。privilegedModePrompt^\\[[~*]HUAWEI.*\\]$特权模式下设备命令行提示符正则表达式，用于解析返回报文是否为特权模式的提示符。promptSkipRegex(?s).*((Error)|(WARNING)|(MINOR)|(INFO)):[ ]{1}[^@prompt@.]{1,}(@prompt@){1}$跳过解析的提示符正则表达式，用于跳过解析返回报文中的提示符场景。正则表达式中的@prompt@将被替换为userModePrompt或privilegeModePrompt配置值。userNameResponseLogin:登录时提示输入用户名的命令行提示符匹配规则，用于解析返回报文是否为输入用户名提示符。passwordResponsePassword:登录时提示输入密码的命令行提示符匹配规则，用于解析返回报文是否为输入密码提示符。InitCommanddisplay users初始连接设备后发送的初始化命令，用于系统识别到成功登录设备后自动执行和显示的初始化命令。keepAliveCommandShow time保活连接命令，用于定期向设备发送该命令以保持连接。cliTxCreateCommandreturn\n事务创建命令，用于发送配置前先下发创建事务。cliTxCommitCommandcommit\n事务提交命令，用于配置提交后再下发提交事务。cliTxSaveCommandreturn\n事务保存命令，用于配置提交成功后再下发事务保存。cliTxCancelCommandclear configuration candidate \n事务取消命令，用于取消配置等情况时下发事务取消。cliTxCancelRetryTimes3取消事务重试次数，用于设备事务异常时，取消事务可重试的次数。abortCommandquit异常停止命令，用于CLI协议出现异常时，通过该命令强制终止当前命令的执行，最好配置成Ctr+C的unicode码。未配置值时，CLI协议异常时处理策略是先断连，再建连。errorMessagePattern^Error:?[ ]{1}.*配置Error正则表达式，用于解析返回报文中是否为配置失败的信息。ignoreMessagePatternrandomvalueshould#not#match忽略配置Error匹配正则表达式，用于当解析返回报文中为配置失败情况时但该场景又需要被忽略时。warningMessagePattern^((WARNING)|(MINOR)|(INFO)):[ ]{1}.*回显信息告警正则表达式，用于解析返回报文是否为告警信息。maxResponseSize400执行一条命令后，能够允许的最大返回报文大小，单位为KB。用于限制超大报文等异常场景。showConfigCommandreturn\ndisplay current-configuration配置全量读的设备命令，用于查询设备配置。showConfigSkipRegex^(--|echo|#).*$不需要解析的关键字正则表达式，用于忽略解析含有该关键字正则表达式的返回报文。configModeCommandsystem-view配置模式进入命令，用于下发实际配置命令（创建、删除、更新等）前下发该命令进入配置模式。partialReadCommandreturn\nsystem-view\n${context}\ndisplay this配置部分读的设备命令，用于查询设备部分配置。提前构造部分读命令，然后替换${context}生成具体的部分读命令。indentationSequence\u0020\u0020\u0020\u0020命令行缩进序列，用于解析设备命令行的缩进序列。HUAWEI设备通常左缩进，四个空格键的缩进序列。exitSubmodeCommandquit返回上级视图的命令，用于返回上级视图下发该命令。通常为quit、exit。submodeStartSequence@indent@子模式开始序列，用于解析设备命令行子模式开始的缩进序列。@indent@表示缩进一级。submodeEndSequence@dedent@子模式结束序列，用于解析设备命令行子模式结束的缩进序列。@dedent@表示反缩进一级。negateCommmandundo\u0020逆命令表达式，用于解析设备命令行的no、undo等关键字，识别是否为逆命令。shutdownCommand\u0020shutdownshutdown命令表达式，用于解析当下发delete命令时设备返回报文中含有shutdown等关键字，需要用户输入后才能继续的情况。contextSupportsSinglelineCommandfalse表示删除命令是否长命令模式，用于配置是否支持解析长命令模式。HUAWEI设备不支持，所以配置成false。NOKIA既支持短命令也支持长命令。配置值包括true和false。defaultDeleteOperationWithValuefalse表示删除叶子节点时，生成的命令是否需要带上叶子的值。用于其他厂家设备的特殊情况，HUAWEI设备不需要，所以配成false。配置值包括true和false。supportsSinglelineCommandfalse表示创建、修改命令是否支持长命令模式。用于其他厂家设备的特殊情况，HUAWEI设备不支持，所以配置成false。配置值包括true和false。cliInteractionMatchKeyWarning.*(base on this interface, continue| BGP process will be deleted. Continue).*y(es)/n(o)交互匹配信息正则表达式，用于下发设备命令时，解析设备返回提示信息，需要用户通过命令做出交互选择。支持分号分隔多个正则表达式。cliInteractionGoOnCommondy交互匹配信息响应，用于解析出设备交互匹配信息时，对设备进行响应，与cliInteractionMatchKey配置项组合使用。支持分号分隔多个正则表达式，分号数量需要跟cliInteractionMatchKey对应。judgeContinueCondition.*--- More ---*判断继续条件的正则表示式，用于解析返回报文是否包含继续条件正则表达式。常用于查询的配置没有显示完整的情况。partialReadSubmodefalse部分读取子模式，用于配置是否支持通过进入子视图，然后输入一条命令，查询部分配置。例如，HUAWEI支持进入相应视图，display this查询当前配置，就配置为true。配置值包括true和false。continueReadingCommand\u0020继续读取命令，用于查询设备配置时，设备没有全部返回查询的配置，通过该命令，让设备继续返回配置。changePasswordPrompt^The password needs to be changed\\. Change now\\? \\[Y\\/N\\].*修改密码提示正则表达式，用于解析与设备建连时设备要求修改密码的提示信息。skipChangePasswordCmdN连接提示更改密码时下发的命令，用于解析出changePasswordPrompt提示信息时，下发设备的命令。cliNoPrintCommandPattern非打印命令模式，用于打印日志时过滤敏感命令，支持以分号分隔，默认空不过滤敏感命令。channelOpeningTimeout10000建连通道开启超时时间，用于防止通道建连异常长时间空耗资源。单位ms。readMessageTimeout10000通道读取返回报文超时时间，用于防止通道异常长时间读取报文。单位ms。cliInteractionCommand批量下发配置时可能出现交互的命令，用于提前识别批量配置需要交互的命令。以分号分隔，可配置多条命令。ifBatchSendCommandoff是否启用拼接命令方法的批量下发配置，用于其他厂家设备支持启用拼接命令方法批量下发配置时。配置值包括on和off。cliCmdAppender0命令回车符，用于解析命令行中的回车符。通常回车符为\r 或\n 。配置为1表示\n ；配置为1表示\r。

此时matches和equals显示的结果相同，返回值都为true，但实际上matches的功能更为强大，可以匹配符合一个模式的字符串集。如： System.out.println("Java is cool".matches("Java.*"));显示的结果同样为true，Java.*为正则表达式。下面将简要介绍正则表达式的功能。1.matches(“x”)，匹配的是指定的字符x；System.out.println("Java".matches("B"));    输出falseSystem.out.println("Java".matches("J"));     输出true2.matches(".")，匹配的是任意单个字符（换行符除外）；System.out.println("Java".matches("J..a"));   输出trueSystem.out.println("Javb".matches("J..a"));   输出false3.matches(“(ab|cd)”)，匹配的是ab或者cd；System.out.println("ef".matches("ab|cd"));    输出falseSystem.out.println("ab".matches("ab|cd"));   输出trueSystem.out.println("cd".matches("ab|cd"));   输出true4.matches("[abc]"),匹配的是a或者b或者c；System.out.println("Java".matches("Ja[uxve]a"));   输出true  System.out.println("Java".matches("Ja[uxwe]a"));   输出false5.matches("[^abc]")，匹配的是除了a或者b或者c以外的任何字符；System.out.println("Java".matches("Ja[^uxwe]a"));  输出trueSystem.out.println("Java".matches("Ja[^uxve]a"));   输出false6.matches("[a-z]")，匹配的是a到z；System.out.println("Java".matches("Ja[u-z]a"));   输出trueSystem.out.println("Java".matches("Ja[a-f]a"));   输出false7.matches("[^a-z]")，匹配的是a到z以外的任意字符；System.out.println("Java".matches("Ja[^a-f]a"));   输出trueSystem.out.println("Java".matches("Ja[^u-z]a"));   输出false8..matches("[a-e[m-p]]")，匹配的是a到e或者m到p；System.out.println("Java".matches("Ja[u-z[a-d]]a"));  输出trueSystem.out.println("Java".matches("Ja[h-m[a-d]]a"));   输出false9.matches("[a-e&&[c-p]]")，匹配的是a到e和c到p的交集；System.out.println("Java".matches("Ja[h-m[h-l]]a"));   输出falseSystem.out.println("Java".matches("Ja[a-x[u-x]]a"));   输出true10.matches("\\d")，匹配的是一位数字（等同于[0~9]）；System.out.println("Java2".matches("Java(\\d)"));   输出trueSystem.out.println("Javaa".matches("Java(\\d)"));    输出false11.matches("\\D")，匹配的是一位非数字；System.out.println("Javaa".matches("Java(\\D)"));     输出trueSystem.out.println("Java2".matches("Java(\\D)"));     输出false12.matches("\\w")，匹配的是单词字符（单词字符是所有的字母，数字和下划线字符）；System.out.println("Javaa".matches("Java(\\w)"));     输出trueSystem.out.println("Java$".matches("Java(\\w)"));     输出false13.matches("\\W")，匹配的是非单词字符；System.out.println("Java$".matches("Java(\\W)"));    输出trueSystem.out.println("Java2".matches("Java(\\W)"));     输出false14.matches("\\s")，匹配的是空白字符；System.out.println("Java ".matches("Java(\\s)"));    输出trueSystem.out.println("Javaa".matches("Java(\\s)"));   输出false15.matches("\\S")，匹配的是非空白字符；System.out.println("Javaa".matches("Java(\\S)"));    输出trueSystem.out.println("Java ".matches("Java(\\S)"));   输出false  16.matches("p*")，匹配的是0或者多次出现模式p；System.out.println("abab".matches("(ab)*"));   输出trueSystem.out.println("aaaa".matches("(ab)*"));   输出false17.matches("p+")，匹配的是1次或者多次出现模式p；System.out.println("able".matches("(ab)+.*"));   输出trueSystem.out.println("a".matches("a+b*"));   输出trueSystem.out.println("c".matches("a+b*"));  输出false18.matches("p?")，匹配的是0或者1次出现模式p；System.out.println("Java".matches("J?Java"));   输出trueSystem.out.println("ava".matches("J?ava"));   输出trueSystem.out.println("Java".matches("J?Mava"));   输出false19.matches("p{n}")，匹配的是正好出现n次模式p；System.out.println("Java".matches("Ja{1}.*"));  输出trueSystem.out.println("Java".matches(".{2}"));    输出false20.matches("p{n,}")，匹配的是至少出现n次模式p；System.out.println("aaaa".matches("a{1,}"));   输出trueSystem.out.println("aaaa".matches("a{5,}"));    输出false21.matches("p{n,m}")，匹配的是出现n到m次（两侧都包含）模式p；System.out.println("aaaa".matches("a{1,4}"));   输出trueSystem.out.println("aaaa".matches("a{6,8}"));   输出false22.matches("\p{P}")，匹配的是一个标点字符；System.out.println("J?a".matches("J\\p{P}a"));  输出trueSystem.out.println("Jaa".matches("J\\p{P}a"));   输出false===================================================="*"等同于{0,}，"+"等同于{1,}，"?"等同于"{0,1}。其中*,?,{n},{n,},{n,m},+被称为量词符，要注意不要在重复量词符中使用空白。替换和拆分字符串replaceFirst的作用是替换匹配到的第一个字符串System.out.println("Java Java Java".replaceFirst("v\\w","wi"));   输出Jawi Java JavareplaceAll的作用是替换匹配到的所有字符串System.out.println("Java Java Java".replaceAll("v\\w","wi"));    输出Jawi Jawi Jawi拆分split(regex)方法使用使用匹配的分隔符将一个字符串分割成子字符串。split(regex,limit)方法，limit参数确定模式匹配多少次。如果limit<=0，则此方法等同于第一种方法，反之，则最多匹配limit-1次。注意：默认情况下，量词符都是尽可能多次地进行匹配。例如：System.out.println("Jaaavaa".replaceFirst("a+", "R"));    输出JRvaa可以通过在后面加"?"的方法来减少匹配的次数。例如：System.out.println("Jaaavaa".replaceFirst("a+?", "R"));此时就会输出JRaavaa

  用户在使用配置文件配置CLI SND驱动时，需要了解和配置一些正则表达式，常见正则表达式的用法如下所示。正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与运算符可以将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。正则表达式是由普通字符（例如字符 a 到 z）以及特殊字符（称为"元字符"）组成的文字模式。模式描述在搜索文本时要匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。 字符描述\将下一个字符标记为一个特殊字符、或一个原义字符、或一个      后向引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。^匹配输入字符串的开始位置。如果设置了      RegExp 对象的      Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。$匹配输入字符串的结束位置。如果设置了RegExp 对象的      Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。*匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。      * 等价于{0,}。+匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。?匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。{n}n      是一个非负整数。匹配确定的      n 次。例如，'o{2}' 不能匹配 "Bob" 中的      'o'，但是能匹配 "food" 中的两个 o。{n,}n      是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。{n,m}m      和      n 均为非负整数，其中n <= m。最少匹配      n 次且最多匹配      m 次。      "o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。?当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m})      后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。.匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。(pattern)匹配pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用      SubMatches 集合，在Visual Basic Scripting Edition 中则使用      $0…$9 属性。要匹配圆括号字符，请使用 '\(' 或 '\)'。(?:pattern)匹配      pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。(?=pattern)正向预查，在任何匹配      pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如， 'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的      "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。(?!pattern)负向预查，在任何不匹配Negative lookahead matches the search string at any point where      a string not matching pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始      x|y匹配      x 或      y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。      [xyz]字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。      [^xyz]负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。      [a-z]字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。      [^a-z]负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。      \b匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。      \B匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。\cx匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。      x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。      \d匹配一个数字字符。等价于 [0-9]。      \D匹配一个非数字字符。等价于 [^0-9]。      \f匹配一个换页符。等价于 \x0c 和 \cL。\n匹配一个换行符。等价于 \x0a 和 \cJ。\r匹配一个回车符。等价于 \x0d 和 \cM。\s匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。\S匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。\t匹配一个制表符。等价于 \x09 和 \cI。\v匹配一个垂直制表符。等价于 \x0b 和 \cK。\w匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。      \W匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。      \xn匹配      n，其中      n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如， '\x41' 匹配 "A"。'\x041' 则等价于 '\x04' & "1"。正则表达式中可以使用 ASCII 编码。.\num匹配      num，其中      num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。      \n标识一个八进制转义值或一个后向引用。如果 \n 之前至少      n 个获取的子表达式，则      n 为后向引用。否则，如果      n 为八进制数字 (0-7)，则      n 为一个八进制转义值。\nm标识一个八进制转义值或一个后向引用。如果 \nm 之前至少有is preceded by at least nm 个获取得子表达式，则      nm 为后向引用。如果 \nm 之前至少有      n 个获取，则      n 为一个后跟文字      m 的后向引用。如果前面的条件都不满足，若  n 和      m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值      nm。\nml如果      n 为八进制数字 (0-3)，且      m 和      l 均为八进制数字 (0-7)，则匹配八进制转义值      nml。\un匹配      n，其中      n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。 

正则表达式中用一对圆括号括起来的部分被称为一个分组例如： '(\d\d\d)-(\d\d)'1. 只有圆括号括起来的部分才算一组，如果正则表达式中既有被圆括号括起来的部分，也有未被圆括号括起来的部分，那么只将圆括号括起来的部分算一组。2. group方法，如果不指定参数，会返回匹配的整个字符串；如果加参数，会返回指定分组的字符串，组索引从1开始。3. groups方法，以元组形式返回匹配的所有分组。vi sub.pyimport re# 分3组   3个数字-4个数字-2个小写字母#test1:第一部分数字分组的情况m = re.match('(\d{3})-\d{4}-[a-z]{2}','123-4567-xy')print(m)print(m.groups())  #默认提取第一个分组print(m.group())    #将整个分组打印出来print(m.group(1))  print('-------------')执行结果：[root@k8s-master-c71e ~]# python sub.py  <_sre.SRE_Match object at 0x7f023f51e558>('123',)123-4567-xy123-------------#第一，第二部分，分组的情况m = re.match('(\d{3})-(\d{4})-[a-z]{2}','123-4567-xy')print(m)print(m.groups())print(m.group())print(m.group(1))print(m.group(2))print('----------')执行结果：<_sre.SRE_Match object at 0x7f023f656d78>('123', '4567')123-4567-xy1234567---------#数字和字符都划分为分组的情况m = re.match('(\d{3})-(\d{4})-([a-z]{2})','123-4567-xy')print(m)print(m.groups())print(m.group())print(m.group(1))print(m.group(2))print(m.group(3))print('-----------')执行结果：<_sre.SRE_Match object at 0x7f023f5c5a48>('123', '4567', 'xy')123-4567-xy1234567xy---------------------#将数字做成一个分组，字符组成另一个分组m = re.match('(\d{3}-\d{4})-([a-z]{2})','123-4567-xy')print(m)print(m.groups())print(m.group())print(m.group(1))print(m.group(2))执行结果：-----------<_sre.SRE_Match object at 0x7f023f656d78>('123-4567', 'xy')123-4567-xy123-4567xy[root@k8s-master-c71e ~]# 

#使用split函数分隔字符串，import reresult = re.split(';','Bill;Mike;John')print(result)执行结果：[root@k8s-master-c71e ~]# python split.py['Bill', 'Mike', 'John']# 至少有1个逗号（,）或分号（;）或点（\.）或空白符（\s）result = re.split(r'[,;\.\s]+','a,b,,,d.x,;ok')print(result)执行结果：[root@k8s-master-c71e ~]# python split.py['a', 'b', 'd', 'x', 'ok'][root@k8s-master-c71e ~]## 用以3个小写字母开头，紧接着一个连字符（-），并以两个数字结尾的字符串作为分隔符# 如abc-12result = re.split('[a-z]{3}-[0-9]{2}','testabc-3213productxyz-45abill')print(result)result = re.split('[a-z]{3}-[0-9]{2}','testabc-3213productxyz-45abill',maxsplit=1) #仅分割一次。print(result)执行结果：[root@k8s-master-c71e ~]# python split.py['test', '13product', 'abill']['test', '13productxyz-45abill'][root@k8s-master-c71e ~]# 

# 使用'\N'引用匹配字符串的分组# 1abc 1:abc   2xyz 2:xyz   9hfg 9:hfg为了实现上述的分别替换的结果，使用分组来完成。[root@k8s-master-c71e ~]# vi subN.pyimport reresult = re.sub('([0-9])([a-z]+)',r'\1:\2' ,'01-1abc,02-2xyz,03-9hfg')print(result)def fun():    return r'[\1*\2]'result = re.subn('([0-9])([a-z]+)',fun() ,'01-1abc,02-2xyz,03-9hfg')print(result)print(result[0])print(result[1])执行的结果为：[root@k8s-master-c71e ~]# python subN.py01-1:abc,02-2:xyz,03-9:hfg('01-[1*abc],02-[2*xyz],03-[9*hfg]', 3)01-[1*abc],02-[2*xyz],03-[9*hfg]3[root@k8s-master-c71e ~]# 

使用sub和subn函数搜索和替换，subn可以统计次数，sub不统计次数。[root@k8s-master-c71e ~]# vi sub.py    import reresult = re.sub('Bill','Mike', 'Bill is my son.')print(result)result = re.subn('Bill', 'Mike', 'Bill is my son, I like Bill')print(result)print(result[0])print('already replace{}times'.format(result[1]))[root@k8s-master-c71e ~]# python sub.pyMike is my son.('Mike is my son, I like Mike', 2)Mike is my son, I like Mikealready replace2times

使用findall和finditer函数查找所有匹配正则表达式。两者区别：findall：通过列表返回所有满足条件的字符串。finditer:将搜索结果通过一个送代器返回。用法示例：import retest_line = r'ab123abcABC456def789ggh'                                  # 定义一个字符串变量test_lineaa = re.compile('\d')                                                   # 生成一个正则表达式对象aa，\d是匹配额所有数字bb = aa.match(test_line, 3, 9)                                          # 使用aa中定义的正则表达式匹配字符串test_lineprint(aa.findall(test_line, 2, 9))                                      # 使用aa对象的正则表达式，在字符串test_line中匹配值cc = re.findall('\D', test_line)                                        # 使用自定义的正则表达式，在字符串test_line中匹配值，\D是匹配所有非数字print(type(cc))                                                         # 打印变量cc的类型for i in cc:                                                            # 遍历变量cc中的值赋值给变量i，然后打印变量i的值    print(i)dd = re.finditer('\D', test_line)                                       # 定义变量ddprint(type(dd))                                                         # 打印变量dd的类型for i in dd:                                                            # 遍历变量dd中的值赋值给变量i，然后打印变量i的值    print(i, i.group())执行结果：[root@k8s-master-c71e /]# python ttt.py['1', '2', '3']<type 'list'>ababcABCdefggh<type 'callable-iterator'>(<_sre.SRE_Match object at 0x7f4d2715d308>, 'a')(<_sre.SRE_Match object at 0x7f4d2715d370>, 'b')(<_sre.SRE_Match object at 0x7f4d2715d308>, 'a')(<_sre.SRE_Match object at 0x7f4d2715d370>, 'b')(<_sre.SRE_Match object at 0x7f4d2715d308>, 'c')(<_sre.SRE_Match object at 0x7f4d2715d370>, 'A')(<_sre.SRE_Match object at 0x7f4d2715d308>, 'B')(<_sre.SRE_Match object at 0x7f4d2715d370>, 'C')(<_sre.SRE_Match object at 0x7f4d2715d308>, 'd')(<_sre.SRE_Match object at 0x7f4d2715d370>, 'e')(<_sre.SRE_Match object at 0x7f4d2715d308>, 'f')(<_sre.SRE_Match object at 0x7f4d2715d370>, 'g')(<_sre.SRE_Match object at 0x7f4d2715d308>, 'g')(<_sre.SRE_Match object at 0x7f4d2715d370>, 'h')[root@k8s-master-c71e /]# 

Python 正则表达式之匹配多个字符'*': 0到n个字符'+':1到n个字符'?': 可选匹配使用“+”表示匹配多个字符vi test.pyimport res='a+b+c+'strList = ['abc', 'aabc','bbabc', 'aabbbcccxyz']for value in strList:     m= re.match(s, value)     if m is not None:            print(m.group())     else:            print('{}不匹配{'. format(value,s))执行结果是：abcaabcbbabc不匹配a+b+c+aabbbcccxyz

匹配起始：“^”匹配结尾：“$”练习：vi head.pyimport rem=re.search('The','abc The,')print(m.group())m=re.search('^The','abc The.')print(m)m=re.search('^The','The abc.')print(m.group())执行结果：[root@k8s-master-c71e ~]# python head.pyTheNoneThe[root@k8s-master-c71e ~]# vi end.pyimport rem=re.search(r'The','abc The,')print(m.group())m=re.search(r'^The$','abc The dfaksj The1')print(m.group())m=re.search('r^The$','The abc.')print(m.group())[root@k8s-master-c71e ~]# python end.pyTheNoneThe

题目描述提取所有人的生日需要匹配的 -- 需要提取的刘伟 1996.8.24 - - 8 24李伟 1993年1月2日 - - 1 2聂芳 1997-7-24 - - 7 24陈伟 1996.3.21 - - 3 21杜英 1991.12.1 - - 12 1段秀 1994-7-5 - - 7 5路娜 1993年1月6日 - - 1 6编写一个正则表达式，使得以上所有的生日都能被正确提取代码实现import re # 导入正则表达式模块 s = input() # 输入上述任一需要提取的生日格式，如: 刘伟1996.8.24 result = re.findall('[\.年-](\d+)[\.月-](\d+)', s) # 在单引号内输入正则表达式 print(result) # 输出正确结果 如： 8 24实践一下吧：https://marketplace.huaweicloud.com/markets/aihub/notebook/detail/?id=a0dd4029-3bf7-45bd-81e4-5300d71d4c6c

正则表达式（英语：Regular Expression，在代码中常简写为regex、regexp或RE）使用单个字符串来描述、匹配一系列符合某个句法规则的字符串搜索模式。搜索模式可用于文本搜索和文本替换。什么是正则表达式？正则表达式是由一个字符序列形成的搜索模式。当你在文本中搜索数据时，你可以用搜索模式来描述你要查询的内容。正则表达式可以是一个简单的字符，或一个更复杂的模式。正则表达式可用于所有文本搜索和文本替换的操作。语法/正则表达式主体/修饰符(可选)其中修饰符是可选的。实例：var patt = /runoob/i实例解析：/runoob/i  是一个正则表达式。runoob  是一个正则表达式主体 (用于检索)。i  是一个修饰符 (搜索不区分大小写)。使用字符串方法在 JavaScript 中，正则表达式通常用于两个字符串方法 : search() 和 replace()。search() 方法 用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串，并返回子串的起始位置。replace() 方法 用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。search() 方法使用正则表达式实例使用正则表达式搜索 "Runoob" 字符串，且不区分大小写：var str = "Visit Runoob!"; var n = str.search(/Runoob/i);输出结果为：6search() 方法使用字符串search 方法可使用字符串作为参数。字符串参数会转换为正则表达式：实例检索字符串中 "Runoob" 的子串：var str = "Visit Runoob!"; var n = str.search("Runoob");replace() 方法使用正则表达式实例使用正则表达式且不区分大小写将字符串中的 Microsoft 替换为 Runoob :var str = document.getElementById("demo").innerHTML; var txt = str.replace(/microsoft/i,"Runoob");结果输出为:Visit Runoob!replace() 方法使用字符串replace() 方法将接收字符串作为参数：var str = document.getElementById("demo").innerHTML; var txt = str.replace("Microsoft","Runoob");

"""example01 - 爬虫 - 利用正则表达式Author: AsusDate: 2021/8/16"""import reimport requestswith open('resources/豆瓣电影.html', 'r', encoding='utf-8') as file:    content = file.read()    # print(content)# re_str = '<img width="100" alt="(.*?)" src="(.+)" class="">'re_str = '<img width="100" alt="(.*?)" src="([a-z]{5}.{3}[a-z\d]{4}\.[a-z]{8}\.[a-z]{3}/view/photo/s_ratio_poster/public/p\d{9}.jpg)" class="">'result = re.search(re_str, content)print(result)# span()输出匹配到字符的起始位置和结束位置print(result.span())# group(): 将分组的内容返回出来# 如果参数是0(group(0))，将所有分组的内容输出print(result.group(1))print(result.group(2))# 将正则表达式中分组的内容合成一个元组print(result.groups())

正则表达式（英语：Regular Expression，在代码中常简写为regex、regexp或RE）使用单个字符串来描述、匹配一系列符合某个句法规则的字符串搜索模式。搜索模式可用于文本搜索和文本替换。什么是正则表达式？正则表达式是由一个字符序列形成的搜索模式。当你在文本中搜索数据时，你可以用搜索模式来描述你要查询的内容。正则表达式可以是一个简单的字符，或一个更复杂的模式。正则表达式可用于所有文本搜索和文本替换的操作。语法/正则表达式主体/修饰符(可选)其中修饰符是可选的。实例：var patt = /runoob/i实例解析：/runoob/i  是一个正则表达式。runoob  是一个正则表达式主体 (用于检索)。i  是一个修饰符 (搜索不区分大小写)。使用字符串方法在 JavaScript 中，正则表达式通常用于两个字符串方法 : search() 和 replace()。search() 方法 用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串，并返回子串的起始位置。replace() 方法 用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。search() 方法使用正则表达式实例使用正则表达式搜索 "Runoob" 字符串，且不区分大小写：var str = "Visit Runoob!"; var n = str.search(/Runoob/i);输出结果为：6search() 方法使用字符串search 方法可使用字符串作为参数。字符串参数会转换为正则表达式：实例检索字符串中 "Runoob" 的子串：var str = "Visit Runoob!"; var n = str.search("Runoob");replace() 方法使用正则表达式实例使用正则表达式且不区分大小写将字符串中的 Microsoft 替换为 Runoob :var str = document.getElementById("demo").innerHTML; var txt = str.replace(/microsoft/i,"Runoob");结果输出为:Visit Runoob!尝试一下 »replace() 方法使用字符串replace() 方法将接收字符串作为参数：var str = document.getElementById("demo").innerHTML; var txt = str.replace("Microsoft","Runoob");

正则表达式简介正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。许多程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件（例如sed和grep）普及开的。正则表达式通常缩写成“regex”，单数有regexp、regex，复数有regexps、regexes、regexen。引子前端开发中，难免会遇到需要匹配标签的需求，这么简单的需求，不就是两个尖括号包裹一个标签名嘛，接下来一顿操作，/<[\w]+>.*<\/[\w]+>/g，然后完美匹配了 <div>xx</div> 等内容，需求完成…等等，咋看之下，当前正则确实能匹配各种标签，但是它同样能匹配类似 <div>xx</p> 的内容。这就意味着我们需要保持两个尖括号内的内容相同才行。正则之分组回溯引用 分组 ()所谓分组，就是把要匹配的内容放在括号()里。括号里的内容可以视为是一个整体的子表达式1/<([\w]+)>.*<\/([\w]+)>/g回溯引用 \N正则表达式还提供了一种引用之前匹配分组的机制，有些时候，我们或许会寻找到一个子匹配，该匹配接下来会再次出现。1234// 该表达式中的 \1 就是整个表达式中的第一个分组var reg = /<([\w]+)>.*<\/\1>/reg.test('<div>xx</div>') // truereg.test('<div>xx</p>') // false