精华内容
下载资源
问答
  • Python 字符串匹配 match

    千次阅读 2019-04-23 19:25:25
    Python 字符串匹配 match
                   
    import reprint(re.match("abc","abc")) #匹配,左边第一个开始算起来,print(re.match("xabc","abc"))#匹配不成功返回None,匹配成功返回位置详细信息print(re.match("abc","xabc"))print(re.match("abc","abcx"))


    import re#match严格匹配,从第一个开始,"abc"在"abcdefgabc"出现一次matchobj=re.match("abc","abcdefgabc")print(matchobj) #print(type(matchobj))print(matchobj.group(0)) #挖掘的第一个匹配

    import re#(.*)  .任意字符不包含换行,*0-N次line="zhangsan is a boy not a gril"matchobj=re.match(r"(.*) is (.*) not (.*)",line)print(matchobj)    #详细的匹配print(matchobj.group(0))  #zhangsan is a boy not a grilprint(matchobj.group(1))  #zhangsanprint(matchobj.group(2))  #a boyprint(matchobj.group(3))  #a gril#3个正则表达式必须匹配group(1) group(2)group(3)


    import re#切割,相当于字符串的split()line="827007914----penghueix"matchobj=re.match(r"(.*)----(.*)",line)print(matchobj)print(matchobj.group(0))  #827007914----penghueixprint(matchobj.group(1))  #827007914print(matchobj.group(2))  #penghueix




               
    展开全文
  • Scala 模式匹配 match-case

    千次阅读 2016-07-24 16:23:17
    简介cala 提供了强大的模式匹配机制,应用也非常广泛。 一个模式匹配包含了一系列备选项,...以下是一个简单的整型值模式匹配实例:def matchTest(x: Int): String = x match { case 1 => "one" case 2 => "two" ca

    简介

    cala 提供了强大的模式匹配机制,应用也非常广泛。
    一个模式匹配包含了一系列备选项,每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

    以下是一个简单的整型值模式匹配实例:

    def matchTest(x: Int): String = x match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
    }
    matchTest(1)
    matchTest(3)
    
    
    defined function matchTest
    res1_1: String = "one"
    res1_2: String = "many"

    match-case

    match 对应 Java 里的 switch,但是写在选择器表达式之后。即: 选择器 match {备选项}。

    match 表达式通过以代码编写的先后次序尝试每个模式来完成计算,只要发现有一个匹配的case,剩下的case不会继续匹配。
    接下来我们来看一个不同数据类型的模式匹配:

    def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
    }
    println(matchTest("two"))
    println(matchTest("test"))
    println(matchTest(1))
    println(matchTest(6))
    
    
    2
    many
    one
    scala.Int
    defined function matchTest

    实例中第一个 case 对应整型数值 1,第二个 case 对应字符串值 two,第二个 case 对应字符串值 two,第三个 case 对应类型模式,用于判断传入的值是否为整型,相比使用isInstanceOf来判断类型,使用模式匹配更好。第四个 case 表示默认的全匹配备选项,即没有找到其他匹配时的匹配项,类似 switch 中的 default。

    使用样例类

    使用了case关键字的类定义就是就是样例类(case classes),样例类是种特殊的类,经过优化以用于模式匹配。
    以下是样例类的简单实例:

    val alice = new Person("Alice", 25)
    val bob = new Person("Bob", 32)
    val charlie = new Person("Charlie", 32)
    
    for (person <- List(alice, bob, charlie)) {
          person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) =>
               println("Age: " + age + " year, name: " + name + "?")
         }
      }
    // 样例类
    case class Person(name: String, age: Int)
    
    
    Hi Alice!
    Hi Bob!
    Age: 32 year, name: Charlie?
    alice: $user.Person = Person("Alice", 25)
    bob: $user.Person = Person("Bob", 32)
    charlie: $user.Person = Person("Charlie", 32)
    defined class Person

    在声明样例类时,下面的过程自动发生了:
    - 构造器的每个参数都成为val,除非显式被声明为var,但是并不推荐这么做;
    - 在伴生对象中提供了apply方法,所以可以不使用new关键字就可构建对象;
    - 提供unapply方法使模式匹配可以工作;
    - 生成toString、equals、hashCode和copy方法,除非显示给出这些方法的定义。

    展开全文
  • Scala模式匹配 match case

    千次阅读 2018-10-05 16:39:32
    1.匹配字符串/类型/守卫 val arr = Array("YoshizawaAkiho", "YuiHatano", "AoiSola") val i = Random.nextInt(arr.length) println(i) val name = arr(i) println(name) name...

    1.匹配字符串/类型/守卫

    val arr = Array("YoshizawaAkiho", "YuiHatano", "AoiSola")
    
    val i = Random.nextInt(arr.length)
    
    println(i)
    
    val name = arr(i)
    
    println(name)
    
    name match {
    
    case "YoshizawaAkiho" => println("吉泽老师...")
    
    case "YuiHatano" => {
    
    println("波多老师...")
    
    }
    
    case _ => println("真不知道你们在说什么...")
    
    }
    
    //定义一个数组
    
    val arr:Array[Any] = Array("hello123", 1, 2.0, CaseDemo02, 2L)
    
    //取出一个元素
    
    val elem = arr(3)
    
    elem match {
    
    case x: Int => println("Int " + x)
    
    case y: Double if(y >= 0) => println("Double "+ y) // if 守卫
    
    case z: String => println("String " + z)
    
    case w: Long => println("long " + w)
    
    case CaseDemo02 => {
    
    println("case demo 2")
    
    
    }
    
    case _ => { 
    // 其他任意情况
    
    println("no")
    
    println("default")
    
    }
    
    }

    2.匹配数组

    示例:

    val arr = Array(1, 1, 7, 0, 2,3)
    
    arr match {
    
    case Array(0, 2, x, y) => println(x + " " + y)
    
    case Array(2, 1, 7, y) => println("only 0 " + y)
    
    case Array(1, 1, 7, _*) => println("0 ...") 
    // _* 任意多个 
    case _ => println("something else")
    
    }

    3.匹配集合

    val lst = List(0, 3, 4)
    
    println(lst.head)
    
    println(lst.tail)
    
    lst match {
    
    case 0 :: Nil => println("only 0")
    
    case x :: y :: Nil => println(s"x $x y $y")
    
    case 0 :: a => println(s"value : $a")
    
    case _ => println("something else")
    
    }

    4.匹配元组

    val tup = (1, 3, 7)
    
    tup match {
    
    case (3, x, y) => println(s"hello 123 $x , $y")
    
    case (z, x, y) => println(s"$z, $x , $y")
    
    case (_, w, 5) => println(w)
    
    case _ => println("else")
    
    }

    5.匹配样例/样例对象

    //样例类,模式匹配,封装数据(多例),不用 new 即可创建实例 case class SubmitTask(id: String, name: String)
    
    case class HeartBeat(time: Long)
    
    //样例对象,模式匹配(单例)
    
    case object CheckTimeOutTask
    
    val arr = Array(CheckTimeOutTask, new HeartBeat(123), HeartBeat(88888), new HeartBeat(666), SubmitTask("0001", "task-0001"))
    
    val i = Random.nextInt(arr.length)
    
    val element = arr(i)
    
    println(element)
    
    element match {
    
    case SubmitTask(id, name) => {
    
    println(s"$id, $name")
    
    }
    
    case HeartBeat(time) => {
    
    println(time)
    
    }
    
    case CheckTimeOutTask => {
    
    println("check")
    
    }
    
    }

     

    展开全文
  • The result of matches = bf.match(des1,des2) line is a list of DMatch objects. This DMatch object has following attributes: DMatch.distance - Distance between descriptors. The lower, the better it is
    The result of matches = bf.match(des1,des2) line is a list of DMatch objects. This DMatch object has following attributes:
    
        DMatch.distance - Distance between descriptors. The lower, the better it is.
        DMatch.trainIdx - Index of the descriptor in train descriptors
        DMatch.queryIdx - Index of the descriptor in query descriptors
        DMatch.imgIdx - Index of the train image.
    import cv2
    img1 = cv2.imread('s1.jpg')          # queryImage
    img2 = cv2.imread('s2.jpg') # trainImage
    
    #%% BF+ORB method
    def BF_ORB():
      # Initiate ORB detector
      orb = cv2.ORB_create()
    
      # find the keypoints and descriptors with SIFT
      kp1, des1 = orb.detectAndCompute(img1,None)
      kp2, des2 = orb.detectAndCompute(img2,None)
    
       # create BFMatcher object
      bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
    
      # Match descriptors.
      matches = bf.match(des1,des2)
    
      # Sort them in the order of their distance.
      matches = sorted(matches, key = lambda x:x.distance)
    
      # Draw first 10 matches.
      img3 = cv2.drawMatches(img1,kp1,img2,kp2,matches[0:10], None,flags=2)
    
      cv2.imshow('result.jpg',img3)
      cv2.waitKey(0)
      cv2.destroyAllWindows()
      cv2.waitKey(1)
      cv2.waitKey(1)
      cv2.waitKey(1)
      cv2.waitKey(1)  
    
    #%%BF+SIFT
    def BF_SIFT():
    
       # Initiate SIFT detector
      sift = cv2.xfeatures2d.SIFT_create()
      # find the keypoints and descriptors with SIFT
      kp1, des1 = sift.detectAndCompute(img1,None)
      kp2, des2 = sift.detectAndCompute(img2,None)
      # BFMatcher with default params
      bf = cv2.BFMatcher()
      matches = bf.knnMatch(des1,des2, k=2)
      # Apply ratio test
      good = []
      for m,n in matches:
        if m.distance < 0.75*n.distance:
          good.append([m])
      # cv2.drawMatchesKnn expects list of lists as matches.
      img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,good[:10],None, flags=2)
    
      cv2.imshow('result.jpg',img3)
      cv2.waitKey(0)
      cv2.destroyAllWindows()
      cv2.waitKey(1)
      cv2.waitKey(1)
      cv2.waitKey(1)
      cv2.waitKey(1)  
    
    def FLANN():
      '''
      FLANN stands for Fast Library for Approximate Nearest Neighbors. 
      It contains a collection of algorithms optimized for fast nearest 
      neighbor search in large datasets and for high dimensional features. 
      It works more faster than BFMatcher for large datasets. 
      We will see the second example with FLANN based matcher.
    
      For FLANN based matcher, we need to pass two dictionaries which specifies 
      the algorithm to be used, its related parameters etc. First one is IndexParams. 
      For various algorithms, the information to be passed is explained 
      in FLANN docs. As a summary, for algorithms like SIFT, SURF etc. 
      you can pass following: 
    
         index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
    
      While using ORB, you can pass the following. The commented values 
      are recommended as per the docs, but it didn't provide required results
      in some cases. Other values worked fine:
        index_params= dict(algorithm = FLANN_INDEX_LSH,
                           table_number = 6, # 12
                           key_size = 12,     # 20
                           multi_probe_level = 1) #2
      Second dictionary is the SearchParams. It specifies the number of 
      times the trees in the index should be recursively traversed. 
      Higher values gives better precision, but also takes more time.
      If you want to change the value, pass search_params = dict(checks=100).
    
    
      '''
      sift = cv2.xfeatures2d.SIFT_create()
      # find the keypoints and descriptors with SIFT
      kp1, des1 = sift.detectAndCompute(img1,None)
      kp2, des2 = sift.detectAndCompute(img2,None)
    
      # FLANN parameters
      FLANN_INDEX_KDTREE = 0
      index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
      search_params = dict(checks=50)   # or pass empty dictionary
    
      flann = cv2.FlannBasedMatcher(index_params,search_params)
    
      matches = flann.knnMatch(des1,des2,k=2)
    
      # Need to draw only good matches, so create a mask
      matchesMask = [[0,0] for i in range(len(matches))]
    
      # ratio test as per Lowe's paper
      for i,(m,n) in enumerate(matches):
        if m.distance < 0.7*n.distance:
            matchesMask[i]=[1,0]
    
      draw_params = dict(matchColor = (0,255,0),
                       singlePointColor = (255,0,0),
                      matchesMask = matchesMask,
                      flags = 0)
    
      img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params)
      cv2.imshow('result.jpg',img3)
      cv2.waitKey(0)
      cv2.destroyAllWindows()
      cv2.waitKey(1)
      cv2.waitKey(1)
      cv2.waitKey(1)
      cv2.waitKey(1)  
    
    #%%   
    if __name__ == '__main__':
      FLANN()
    
    展开全文
  • 当对平面物体进行视觉定位时,往往采用图像模板匹配的方式,然而当目标含有一定角度的旋转时,如何精确估算出旋转角度成了一个难题。下面是博主根据自己的理解所做的一个小的总结,也能算纠结,欢迎高手围观。 1 ...
  • Lua 正则匹配 gsub match

    千次阅读 2018-06-06 10:29:30
    lua 正则匹配式:(大写都是相反的). 任意字符 %a 字母 %c 控制字符%d 数字%l 小写字母%p 标点字符%s 空白符%u 大写字母%w 字母和数字%x 十六进制数字%z 代表0的字符--s:字符串,pattern:正则匹配字符规则...
  • Scala模式匹配(match case)

    千次阅读 2019-06-01 02:51:00
    Scala的match表达式类似于其他语言中的switch语句,它可以提供给你在多个备选项中做选择。...1. 按值匹配 def valueMatch(fruit: String) { fruit match { case "apple" => print("apple") case "b...
  • 1.ets:match/2 以最常用的match函数为例子 match(Tab, Pattern) -> [Match] Types: Tab = tid() | atom() Pattern = tuple() Match = [term()] Tab是ETS的tid()或ETS的...Pattern是一个匹配模式,是一...
  • Python 字符串匹配(match)

    万次阅读 2017-10-09 19:54:03
    import re print(re.match("abc",...print(re.match("xabc","abc"))#匹配不成功返回None,匹配成功返回位置详细信息 print(re.match("abc","xabc")) print(re.match("abc","abcx")) import re #match严格匹配
  • 匹配查询(Match

    千次阅读 2020-02-28 10:10:24
    匹配Match)查询属于全文(Fulltext)查询,不同于词条查询,ElasticSearch引擎在处理全文搜索时,首先分析(analyze)查询字符串,然后根据分词构建查询,最终返回查询结果。匹配查询共有三种类型,分别是布尔...
  • match_phrase短语匹配和近似匹配

    千次阅读 2020-06-06 15:34:51
    在上一篇match query讨论了全文检索 比如,有如下查询 { "match": { "content": "java spark" } } match query,只能搜索到包含java和spark的document,但是不知道java和...一、match_phrase(短语匹配) GET...
  • preg_match — 执行一个正则表达式匹配preg_match ( $pattern , $subject , $matches )搜索subject与pattern给定的正则表达式的一个匹配.参数 :pattern : 要搜索的模式,字符串类型(正则表达式)。 subject : 输入的...
  • 短语匹配(Phrase Matching)就像用于全文搜索的的match查询一样,当你希望寻找邻近的单词时,match_phrase查询可以帮你达到目的。GET /my_index/my_type/_search { "query": { "match_phrase": { "title": "quick ...
  • 各种总线match匹配函数

    千次阅读 2014-10-28 15:40:46
    当向linux系统总线添加设备或驱动时,总是会调用各总线对应的match匹配函数来判断驱动和设备是否匹配,这些match函数之间都存在一定的差异,本文先对常用的match匹配函数进行讲解,以后会陆续添加新的内容。...
  • PHP 正则表达式匹配 preg_match 与 preg_match_all 函数 原文地址:http://www.5idev.com/p-php_preg_match.shtml 正则表达式在 PHP 中的应用 在 PHP 应用中,正则表达式主要用于: 正则匹配:...
  • PHP 正则表达式匹配函数 preg_match 与 preg_match_allpreg_match()preg_match() 函数用于进行正则表达式匹配,成功返回 1 ,否则返回 0 。语法:1int preg_match( string pattern, string subject [, array ...
  • Scala模式匹配(match)使用

    千次阅读 2017-07-23 15:14:40
    Scala模式匹配机制,有点类似java中switch语句,应用很广泛,一个模式匹配包含一系列的被选项,每一个选项通过case关键字开始,每个备选项都包含了一个模式及一到多个表达式,中间通过箭头隔开:
  • 1. re模块的使用过程 #coding=utf-8 # 导入re模块 import re # 使用match方法进行匹配操作 result = re.match(正则表达式,要匹配的字符串) # 如果上一步匹配到数据的话,可以使用group方法来提取数据 result.group()...
  • 正则表达式之匹配——match()方法

    千次阅读 2012-11-18 00:50:09
    //正则表达式之匹配——match()方法 //例一: //利用正则表达式判断QQ是否合法 //要求: //(1)长度是5—15位,且不以0开头 //(2)不含有除了数字以外的其他东西 //小结: //(1)[1-9]表示第一位只能是1-9的数字...
  • R匹配函数match.fun

    千次阅读 2016-11-04 19:21:30
    R允许将函数作为参数,但如果有一个与函数同名的对象,如下所示: > print(1,2,3) #这里print是一个列表和print函数重名 ...print函数打印了print向量.match,fun()函数查找函数名与"print"匹配的函数.
  • java正则表达式 match find匹配位置

    千次阅读 2019-01-09 12:00:06
    java正则表达式 match find匹配位置
  • 详解正则表达式匹配方法 match()

    千次阅读 2018-12-22 23:53:56
    match本身是JavaScript语言中字符串对象的一个方法,该方法的签名是 match([string] | [RegExp]) 它的参数既可以是一个字符串,也可以是一个正则表达式。该方法绝大多数都是要使用正则表达式的,所以参数为string...
  • 使用过正则表达式的人应该都知道 matcher ,通过 matcher 匹配器运算正则表达式,完成一系列的匹配规则。在Rust 中 没有 switch 语句,matcher 就是 switch 的一个变形,但比其他语言中的 switch 更强大!一、简单举例...
  • 这则匹配用到最多的就是matchmatch([string] | [RegExp]) 这里主要说正则表达式 1、返回值:Array/null 2、不使用g全局匹配时 var str='2019shanghai=nihao !!' str.match(/\w[i]/) 可以...
  • re.match() 匹配字符串

    千次阅读 2019-07-21 16:21:47
    re.match( )方法匹配的是以xxx开头的字符串,若不是开头的,尽管属于str内,则无法匹配 如果大家想学深入了解re模块,可以看看这篇文章 我们为什么要使用这个方法呢?因为我们的歌词有 作词:xxx作曲:xxx 还有一些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 299,027
精华内容 119,610
关键字:

匹配match