精华内容
下载资源
问答
  • matcher
    2022-04-01 16:43:30

    matcher 方法总结

    下面这个测试能很好的体现

        private static Pattern humpPattern = Pattern.compile("[A-Z]");
        public static void main(String[] args) {
            String str="thisIsOneDog";
            // 1. 使用匹配样式去匹配字符串,生成匹配对象
            Matcher matcher = humpPattern.matcher(str);
            // 使用sb 接收匹配,替换之后的结果
            StringBuffer sb = new StringBuffer();
            // 2. matcher.find() 从字符串 index==0 开始匹配,发现有,返回true
            while (matcher.find()) {
            	// 3. 返回 第一个匹配的字符
                String matchedChar = matcher.group(0);
                // 4. sb 拼接:当前index 到 匹配字符,并返回替换后的结果,sb 再拼接此结果
                matcher.appendReplacement(sb, "_" + matchedChar.toLowerCase());
            }
            // 5. sb 拼接:返回当前index 到匹配字符的字符串,sb 再拼接此结果
            matcher.appendTail(sb);
            System.out.println(sb.toString())
            }
    
    更多相关内容
  • Matcher

    2022-04-22 18:08:35
    Matcher Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查,此类的实例用于多个并发线程是不安全的。 Matcher类的构造方法是私有的,不能随意创建,只能通过Pattern.matcher...

    Matcher

    Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查,此类的实例用于多个并发线程是不安全的。
    Matcher类的构造方法是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例。

    获取Matcher实例

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.pattern();//返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的 
    

    Pattern pattern()

    pattern()返回parentPattern,返回由此匹配器解释的模式,即构造器传入的Pattern对象。

    int groupCount()

    返回此匹配器模式中的捕获组数。根据惯例,零组表示整个模式。

    String group()

    返回当前查找而获得的与组匹配的所有子串内容。group()实际调用了group(int group)方法,参数group为0。组零表示整个模式。

    String group(int group)

    返回当前查找而获得的与组匹配的所有子串内容。

    int start()

    返回当前匹配的子串的第一个字符在目标字符串中的索引位置 。start()方法返回的是匹配器的状态first。

    int start(int group)

    返回当前匹配的指定组中的子串的第一个字符在目标字符串中的索引位置 。

    int end()

    返回当前匹配的子串的最后一个字符的下一个位置在目标字符串中的索引位置 。end()方法返回的是匹配器的状态last。

    int end(int group)

    返回当前匹配的的指定组中的子串的最后一个字符的下一个位置在目标字符串中的索引位置 。

    boolean find()

    在目标字符串里查找下一个匹配子串。如果匹配成功,则可以通过 start、end 和 group 方法获取更多信息。

    boolean find(int start)

    重置此匹配器,然后尝试查找匹配该模式,从指定的位置开始查找下一个匹配的子串。如果匹配成功,则可以通过 start、end 和 group 方法获取更多信息。

    int regionStart()

    报告此匹配器区域的开始索引。end()方法返回的是匹配器的状态from。

    int regionEnd()

    报告此匹配器区域的结束索引(不包括)。end()方法返回的是匹配器的状态to。

    Matcher region(int start,int end)

    设置此匹配器的区域限制。重置匹配器,然后设置区域,使其从 start 参数指定的索引开始,到 end 参数指定的索引结束(不包括end索引处的字符)。

    boolean lookingAt()

    从目标字符串开始位置进行匹配。只有在有匹配且匹配的某一子串中包含目标字符串第一个字符的情况下才会返回true。

    boolean matches()

    只有完全匹配时才会返回true。

    Matcher appendReplacement(StringBuffer sb, String replacement)

    将当前匹配子串替换为指定字符串,并将从上次匹配结束后到本次匹配结束后之间的字符串添加到一个StringBuffer对象中,最后返回其字符串表示形式。

    StringBuffer appendTail(StringBuffer sb)

    将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。

    String replaceAll(String replacement)

    将匹配的子串用指定的字符串替换。

    String replaceFirst(String replacement)

    将匹配的第一个子串用指定的字符串替换。

    Matcher usePattern(Pattern newPattern)

    更改匹配器的匹配模式。

    注意

    1. Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例.
    2. 一个Matcher实例是被用来对目标字符串进行基于既有模式(也就是一个给定的Pattern所编译的正则表达式)进行匹配查找的,所有往Matcher的输入都是通过CharSequence接口提供的,这样做的目的在于可以支持对从多元化的数据源所提供的数据进行匹配工作。

    DEMO

    @RunWith(SpringJUnit4ClassRunner.class)
    @Slf4j
    public class TestInfo {
        public static final String P_UNCAP = "【客户档案:(?<name>.*)】";
        public static final String DATE_STRING = "【客户档案:湖南省银华棉(麻产)业集团股份公司】";
        @Test
    	public void testInfo() {
    		try {
                Pattern pattern = Pattern.compile(P_UNCAP);
                Matcher matcher = pattern.matcher(DATE_STRING);
                boolean b = matcher.find();
                String clientName = matcher.group("name");
    		    System.out.println(clientName);
    
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    

    在这里插入图片描述

    展开全文
  • laser_scan_matcher-kinetic-devel.zip,laser_scan_matcher-kinetic-devel,src,laser_scan_matcher.cpp,CMakeLists.txt,README.md,package.xml,launch,rplidar.launch,demo.rviz,demo.launch,include,laser_scan_...
  • 安装$ npm install matcher用法const matcher = require ( 'matcher' ) ;matcher ( [ 'foo' , 'bar' , 'moo' ] , [ '*oo' , '!foo' ] ) ;//=> ['moo']matcher ( [ 'foo' , 'bar' , 'moo' ] , [ '!*oo' ] ) ;//=> ['...
  • regex_matcher

    2021-02-21 06:34:08
    regex_matcher 此存储库以spacy快速有效地实现了正则表达式匹配器。 此类具有与spacy Matcher和PhraseMatcher相同的行为,但是对基础文本而不是单个标记(不同于Matcher )进行操作,并允许使用正则表达式语法(与...
  • ctrlp-py-matcher 基于python的快速CtrlP匹配器性能差异高达x22,请看以下性能: 默认匹配器: FUNCTIONS SORTED ON SELF TIMEcount total (s) self (s) function 3 17.768008 17.610161 <SNR>102_MatchIt()使用Py ...
  • 要求Python 3.6+ ANTLR Python运行时(4.7+) 3) python-dateutil( ) 六个( ) stix2-patterns( ) (用于运行测试)-pytest( )安装用安装: $ pip install stix2-matcher用法安装软件包会创建一个stix2-...
  • GMS-Feature-Matcher-master.zip,GMS-Feature-Matcher-master,matlab,MexGMS.cpp,Compile.m,gms_match.m,demo.m,src,demo.cpp,CMakeLists.txt,LICENSE,README.md,data,02.jpg,01.jpg,python,gms_matcher.py,include,...
  • java.util.regex是一个用正则表达式所订制的...包括两个类Pattern和Matcher Pattern,Pattern是一个正则表达式经编译后的表现模式。Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查。
  • 安装曲线匹配器可以通过NPM或Yarn安装yarn add curve-matcher或者npm install curve-matcher入门curve-matcher的核心是一个名为shapeSimilarity的函数,该函数估计2条曲线的形状彼此之间的相似程度,并返回介于0和1...
  • 主要介绍了正则表达式Matcher类中group方法,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 安装: $ (sudo) npm install byte-matcher用法: var byteMatcher = require ( 'byte-matcher' ), bufferToSearch = new Buffer ( 'to find the thing' ), bufferToMatch = new Buffer ( 'target to match' )var ...
  • OSM Map Matcher 将 GPS 坐标与现有的 OSM 高速公路相匹配。 目前它只返回匹配高速公路的 id。 需要 Python-gdal psycopg2 带有 PostGIS 和 pgRouting 的 PostgreSQL 将 KML 转换为 GPX 创建数据库 createdb ...
  • 主要介绍了Java正则表达式Pattern和Matcher原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • route-matcher-master.zip,route-matcher-master,.gitignore,package.json,src,main,parse-query-string.js,index.js,param-array-indicator.js,test,parse-query-string.spec.js,param-array-indicator.spec.js,...
  • 主要介绍了Java正则相关的Pattern和Matcher类及遇到的坑,本文给大家提到了Matcher 里面的三个方法,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了Java matches类,Pattern类及matcher类用法,结合实例形式分析了java matches类,Pattern类及matcher类针对字符串常见操作技巧与相关注意事项,需要的朋友可以参考下
  • profile-matcher-master.zip,profile-matcher-master,runtime.txt,requirements.txt,LICENSE,Procfile,README.md,webapp.py,templates,index.html,layout.html,.gitignore
  • PatternMatcher-master.zip,PatternMatcher-master,bin,com,bit,perry,PM_Main$1.class,PM_Main$1$1.class,PM_Main.class,pic,PatternMatcher_Example.PNG,.settings,org.eclipse.core.resources.prefs,org.eclipse....
  • org.aspectj.matcher.jar.zip

    2019-09-17 10:51:37
    java开发必备工具类org.aspectj.matcher.jar。亲测有效
  • matcher与path.Match类似,但是: 支持globstar / doublestar( ** )。 提供快速的Glob功能。 支持组合匹配器。 例子 比赛 package main import "github.com/saracen/matcher" func main () { matched , err :=...
  • NULL 博文链接:https://chengjianxiaoxue.iteye.com/blog/2428561
  • name-matcher-test-master.zip,name-matcher-test-master,.project,README.md,bin,.gitignore,test,com,sarojaba,namematcher,NameMatcherTest.java,.settings,org.eclipse.jdt.core.prefs,LICENSE,src,com,sarojaba...
  • 前端开源库-jeefo_url_matcherjeefo_url_matcher,jeefo框架的一部分
  • color_matcher-master.zip,color_matcher-master,.travis.yml,Gemfile,color_matcher.gemspec,doc,discover.png,spec,color_matcher_spec.rb,LICENSE.md,.gitignore,lib,color_matcher.rb,README.md
  • 前端开源库-jest-matcher-deep-close-tojest matcher deep-close,扩展jest以断言具有近似值的数组
  • 0x20, group_0 start index : 13 end :18 group_1:0x20 group_1 start index : 13 end :17 group_2:, group_2 start index : 17 end :18 Matcher的replace/append方法详解 测试Matcher的匹配替换以及追加的方法: ...

    Pattern.split方法详解

    /**

    * 测试Pattern.split方法

    */

    @Test

    public void testPatternSplit() {

    String str = "{0x40, 0x11, 0x00, 0x00}";

    // 分割符为:逗号, {,}, 空白符

    String regex = "[,\\{\\}\\s]";

    Pattern pattern = Pattern.compile(regex);

    /*

    * 1. split 方法用于使用正则表达式中的字符分割待匹配的字符串

    *

    * 注意:

    * 1. 如果分割符位于原字符串的起始位置,则分割的时候,会在起始位置上分割出一个""出来

    * 2. 如果有连续两个分隔符,则会在这两个分割符之间分割有一个""出来

    * */

    System.out.println("----------- split test -----------");

    String[] results = pattern.split(str);

    System.out.println("length :" + results.length);

    for (int i = 0; i < results.length; i++) {

    System.out.println("element_" +i + " :" + results[i]);

    }

    System.out.println(Arrays.toString(results));

    /*

    * 2. split方法的limit参数的意思是使用正则表达式的分割字符将原字符串分为limit个组

    * **/

    System.out.println("\n----------- split limit test -----------");

    String[] resultsLimit = pattern.split(str, 2);

    for (int i = 0; i < resultsLimit.length; i++) {

    System.out.print(resultsLimit[i]);

    }

    }

    结果:

    ----------- split test -----------

    element_0 :

    element_1 :0x40

    element_2 :

    element_3 :0x11

    element_4 :

    element_5 :0x00

    element_6 :

    element_7 :0x00

    [, 0x40, , 0x11, , 0x00, , 0x00]

    ----------- split limit test -----------

    0x40, 0x11, 0x00, 0x00}

    Matcher的find/find/start/end方法详解

    测试Matcher的find方法:尝试在目标字符串中查找下一个匹配的字串,需在循环中迭代。

    groupCount :返回当前查找所获得的匹配组的数量,不包括整个整个正则表达式的匹配。

    比如,表达式有两个子分组,则groupCount == 2

    group(i):指的是用()包含的子分组,按照定义的顺序标识下标,当正则表达式中使用 |连接分组,那么有的分组匹配的字串可能为null。

    start(group):返回此子分组匹配的子串在原字符串中的起始位置(包含)

    end(group):返回此子分组匹配的子串在原字符串中的结束位置(不包含)

    即子分组匹配的字符串在原字符串的位置为 [start(i),end(i)),左闭右开。

    @Test

    public void testMatcherGroupFindStartEnd() {

    String str = "{0x40, 0x31, 0x20, 0x00}";

    String regex = "([A-Za-z0-9]+)(,)";

    Pattern pattern = Pattern.compile(regex);

    Matcher matcher = pattern.matcher(str);

    // 对于在整个原字符串中,找到的下一个匹配的字串

    while (matcher.find()) {

    // 输出groupCount的数量

    System.out.println("groupCount : " + matcher.groupCount());

    // 0-输出整个匹配

    System.out.println("the substring of contains all group : " + matcher.group(0));

    System.out.println("group_0 start index : " + matcher.start(0) + " end :" + matcher.end(0));

    // 依次输出子分组的匹配结果

    // 如果子分组之间是通过 | 来连接的,则子分组的匹配结果有的为null

    for (int i = 1; i <= matcher.groupCount(); i++) {

    System.out.println("group_" + i + ":" + matcher.group(i));

    System.out.println("group_" + i + " start index : " + matcher.start(i) + " end :" + matcher.end(i));

    }

    }

    }

    结果:

    groupCount : 2

    the substring of contains all group : 0x40,

    group_0 start index : 1 end :6

    group_1:0x40

    group_1 start index : 1 end :5

    group_2:,

    group_2 start index : 5 end :6

    groupCount : 2

    the substring of contains all group : 0x31,

    group_0 start index : 7 end :12

    group_1:0x31

    group_1 start index : 7 end :11

    group_2:,

    group_2 start index : 11 end :12

    groupCount : 2

    the substring of contains all group : 0x20,

    group_0 start index : 13 end :18

    group_1:0x20

    group_1 start index : 13 end :17

    group_2:,

    group_2 start index : 17 end :18

    Matcher的replace/append方法详解

    测试Matcher的匹配替换以及追加的方法:

    matcher.replaceAll方法 :替换在原字符串中所有被正则表达式匹配的字串,并返回替换之后的结果

    matcher.replaceFirst方法 :替换在原字符串中第一个被正则表达式匹配的字串,并返回替换之后的结果

    matcher.appendReplacement方法 : 将当前匹配子串替换为指定字符串,并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里(需while(matcher.find())进行配合迭代)

    matcher.appendTail(StringBuffer sb) 方法则将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。

    3和4的结合能够实现将原字符串中的某些字串替换指定字符,并返回完成替换之后的结果

    @Test

    public void testMatcherReplaceAppend() {

    String str = "{0x40, 0x31, 0x20, 0x00}";

    String regex = "([0-9A-Za-z]+)";

    Pattern pattern = Pattern.compile(regex);

    Matcher matcher = pattern.matcher(str);

    // replaceAll

    System.out.println("----------- replace all test ----------");

    String replacedAllStr = matcher.replaceAll("replace");

    System.out.println("replaced : " + replacedAllStr);

    //matcher.reset(str); // 重置被matcher的字符串

    matcher.reset(); // 重置matcher,以实现对原字符串重新搜索

    // replaceFirst

    System.out.println("------------ replace first test ---------");

    String replacedFirstStr = matcher.replaceFirst("replace");

    System.out.println("replaced first : " + replacedFirstStr);

    matcher.reset();

    // appendReplacement

    System.out.println("------------- appendReplacement test ------------");

    StringBuffer appendRepStr = new StringBuffer();

    while (matcher.find()) {

    matcher.appendReplacement(appendRepStr,"0xffff");

    }

    System.out.println(appendRepStr);

    // 最后调用appendTail将匹配剩余的字符串添加都StringBuffer的末尾

    // 注意这时要实现完整的功能:将所有匹配的内容替换并添加到appendRepStr中,剩余未匹配的继续添加到

    // appendRepStr中,相当于对原字符串进行全部的替换

    // 此时要保证,在遍历所有匹配的字串后调用appendTail方法

    System.out.println("------------ appendTail test ---------------");

    matcher.appendTail(appendRepStr);

    System.out.println(appendRepStr);

    }

    结果:

    ----------- replace all test ----------

    replaced : {replace, replace, replace, replace}

    ------------ replace first test ---------

    replaced first : {replace, 0x31, 0x20, 0x00}

    ------------- appendReplacement test ------------

    {0xffff, 0xffff, 0xffff, 0xffff

    ------------ appendTail test ---------------

    {0xffff, 0xffff, 0xffff, 0xffff}

    测试文件源码地址

    https://github.com/zhanglbjames/exercises/blob/master/src/test/java/huawei_8_16/TestT1.java

    1-匹配字符类

    方括号一次只能匹配括号内的一个字符

    [abc]

    a, b, or c (简单类)

    [^abc]

    除了a、b或c之外的任意 字符(求反)

    [a-zA-Z]

    a到z或A到Z ,包含(范围)

    [a-zA-Z0-9]

    匹配一次所有数字和字母的类型

    [a-b-r]

    匹配 a-b ,连接符 -,r

    注意如果想要连接符起到范围的作用,应该满足如下格式[a-bc-de-gf-k]

    即每个连接符占用的字符不能被其他连接符占用

    圆括号一次匹配多个字符

    比如方括号的正则表达式"t[aeio]n"只匹配"tan"、"Ten"、"tin"和"ton",只能匹配单个字符,不能匹配"taeion"

    圆括号可以一次匹配多个字符,比如使用"t(a|e|i|o|oo)n"正则表达式,可以匹配"taen","tan","taeiooon"等

    也可以配合[]使用,如正则为"t([aei]|o|oo)n",则可以匹配 "taon","teoon",但是不能匹配"taeioon"

    2-预定义字符类

    . 匹配除换行符 \n 之外的任何单字符

    比如:表达式就是“t.n”,它匹配“tan”、“ten”、“tin”和“ton”,还匹配“t#n”、“tpn”甚至“t n”。

    \d 数字: [0-9]

    \D 非数字: [^0-9]

    \s 空格符: [ \t\n\x0B\f\r]

    \S 非空格符: [^\s]

    \w 单词字符: [a-zA-Z_0-9]

    \W 非单词字符: [^\w]

    记忆规则 大写表示取反,小写如下记忆

    d:digit(数字)

    s:space(空白字符)

    w:word(单词字符), 注意包括下划线

    3-表达式匹配次数

    * 0次或者多次(允许0次的贪婪匹配)

    例如,zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}

    + 1次或者多次(贪婪匹配)

    例如,'zo+' 能匹配 "zo" 以及 "zoo",但不能匹配 "z"。+ 等价于 {1,}。

    ? 0次或者1次 (非贪婪匹配,允许0次)

    例如,"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。

    {n} 恰好n次

    {n,m} 从n次到m次

    {n,} 至少n次

    注意上述n为非负数

    4-特殊字符需要转义

    356c116370c4b2d0174a78971d5a55b0.png

    总结

    到此这篇关于java正则表达式之Pattern与Matcher类的文章就介绍到这了,更多相关java正则表达式Pattern与Matcher类内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    展开全文
  • index-matcher

    2021-05-04 20:06:11
    索引匹配器安装$ npm install index-matcher算法莱文施泰因贾罗骰子例子无对象用法const Matcher = require ( "index-matcher" ) ;const store_a = [ "clothes" , "food" , "electronic" ] ;const store_b = [ ...
  • Spacy教程-Matcher

    2022-03-30 15:36:22
    Spacy教程-Matcher 根据模式规则匹配标记序列 Matcher允许您使用描述其标记属性的规则来查找单词和短语。规则可以引用标记注释(如文本或词性标记),以及词法属性(如Token.is_punct)。将匹配器应用于Doc使您能够访问...

    Spacy教程-Matcher

    根据模式规则匹配标记序列

    Matcher允许您使用描述其标记属性的规则来查找单词和短语。规则可以引用标记注释(如文本或词性标记),以及词法属性(如Token.is_punct)。将匹配器应用于Doc使您能够访问上下文中匹配的令牌。有关结合规则和统计模型的深入示例和工作流,请参阅关于基于规则的匹配的使用指南

    Pattern format

    [
      {"LOWER": "i"},
      {"LEMMA": {"IN": ["like", "love"]}},
      {"POS": "NOUN", "OP": "+"}
    ]
    

    添加到Matcher 的模式由词典列表组成。每个词典都描述一个token及其属性。可用的Token模式键对应于许多Token属性。基于规则的匹配支持的属性是:


    运算符和量词定义了标记模式匹配的频率:

    [
      {"POS": "ADJ", "OP": "*"},
      {"POS": "NOUN", "OP": "+"}
    ]
    

    ! 通过要求它精确匹配0次来对模式进行。
    ? 通过允许匹配0或1次,使模式成为可选的。
    **+**要求模式匹配1次或更多次。
    *****允许匹配0次或更多次。

    Token模式还可以映射到一个属性字典,而不是单个值,以指示期望的值是否是列表的成员,或者它与另一个值的比较方式。

    [
      {"LEMMA": {"IN": ["like", "love", "enjoy"]}},
      {"POS": "PROPN", "LENGTH": {">=": 10}},
    ]
    

    IN:属性值是列表的成员。
    NOT_IN:属性值不是列表的成员。
    IS_SUBSET:属性值(用于MORPH或自定义列表属性)是列表的子集。
    IS_SUPERSET:属性值(对于MORPH或自定义列表属性)是列表的超集。
    INTERSECTS:属性值(用于MORPH或自定义列表属性)与列表有一个非空的交集。
    ==, >=, <=, >, <:属性值等于、大于或等于、小于或等于、大于或小于。

    Matcher.init

    创建基于规则的Matcher。如果设置validate=True,所有添加到匹配器的模式都将针对一个JSON模式进行验证,如果发现问题,则会引发一个MatchPatternError。这可能包括不正确的类型(例如,需要整数的字符串)或意外的属性名。

    from spacy.matcher import Matcher
    matcher = Matcher(nlp.vocab)
    

    Matcher.call

    DocSpan上查找与提供的模式匹配的所有标记序列。

    from spacy.matcher import Matcher
    
    matcher = Matcher(nlp.vocab)
    pattern = [{"LOWER": "hello"}, {"LOWER": "world"}]
    matcher.add("HelloWorld", [pattern])
    doc = nlp("hello world!")
    matches = matcher(doc)
    

    Matcher.len

    获取添加到匹配器的规则的数量。注意,这只返回规则的数量(与id的数量相同),而不是单个模式的数量。

    matcher = Matcher(nlp.vocab)
    assert len(matcher) == 0
    matcher.add("Rule", [[{"ORTH": "test"}]])
    assert len(matcher) == 1
    

    Matcher.contains

    检查匹配器是否包含匹配ID的规则。

    matcher = Matcher(nlp.vocab)
    assert "Rule" not in matcher
    matcher.add("Rule", [[{'ORTH': 'test'}]])
    assert "Rule" in matcher
    

    Matcher.add

    向匹配器添加一个规则,由一个ID键、一个或多个模式和一个可选的回调函数组成。回调函数将接收参数matcher, doc,imatches。如果给定ID的模式已经存在,则模式将被扩展。一个on_match回调将被覆盖。

    def on_match(matcher, doc, id, matches):
        print('Matched!', matches)
    
    matcher = Matcher(nlp.vocab)
    patterns = [
       [{"LOWER": "hello"}, {"LOWER": "world"}],
       [{"ORTH": "Google"}, {"ORTH": "Maps"}]
    ]
    matcher.add("TEST_PATTERNS", patterns)
    doc = nlp("HELLO WORLD on Google Maps.")
    matches = matcher(doc)
    

    修改为:

    patterns = [[{"TEXT": "Google"}, {"TEXT": "Now"}], [{"TEXT": "GoogleNow"}]]
    - matcher.add("GoogleNow", on_match, *patterns)
    + matcher.add("GoogleNow", patterns, on_match=on_match)
    

    Matcher.remove

    从匹配器中删除一个规则。如果匹配ID不存在则引发KeyError

    matcher.add("Rule", [[{"ORTH": "test"}]])
    assert "Rule" in matcher
    matcher.remove("Rule")
    assert "Rule" not in matcher
    ```![在这里插入图片描述](https://img-blog.csdnimg.cn/36d4fcfe1dea4501bd92a20dcb5dda6c.png)
    
    ## Matcher.get
    检索为键存储的模式。返回一个包含回调和可用模式的(`on` `match`, `patterns`)元组。
    
    ```python
    matcher.add("Rule", [[{"ORTH": "test"}]])
    on_match, patterns = matcher.get("Rule")
    

    参考

    https://spacy.io/api/matcher

    展开全文
  • Java Pattern和Matcher用法

    2021-02-25 20:22:51
    Pattern用法Java正则表达式通过java.util.regex包下的Pattern和Matcher类实现Pattern类用于创建一个正则表达式,也可以说是创建一个匹配模式,可以通过两个静态方法创建:compile(String regex)和compile(String ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 97,480
精华内容 38,992
关键字:

matcher