精华内容
下载资源
问答
  • 目录介绍前言1. 什么是正则表达式?2. 基本匹配3. 元字符3.1. 英文句号3.2. 字符集3.2.1. 否定字符集3.3. 重复3.3.1. 星号(*)3.3.2. 加号(+)3.3.3. 问号(?)3.4. 花括号3.5. 字符组3.6. 分支结构3.7. 转义特殊字符3.8...

    前言

    本文篇幅比较长,建议慢慢消化,部分内容来源gitHub开源网站上的高星作品。
    推荐在线正则表达式编译网站:在线正则表达式测试
    边看边练再巩固,效果更佳。

    1. 什么是正则表达式?

    通俗点说,正则表达式就是一种被用于处理字符串的特殊模式的文本

    正则表达式是从左到右来匹配一个字符串的。“Regular Expression” 这个词太长了,我们通常使用它的缩写 “regex” 或者 “regexp”。 正则表达式可以被用来替换字符串中的文本、验证表单、基于模式匹配从一个字符串中提取字符串等等。

    想象一下,您正在编写应用程序,并且您希望在用户选择用户名时设置规则。我们希望用户名可以包含字母,数字,下划线和连字符。 为了让它看起来不丑,我们还想限制用户名中的字符数量。我们可以使用以下正则表达式来验证用户名:
    在这里插入图片描述

    上面这个正则表达式可以匹配 john_doe,jo-hn_doe 和 john12_as。但是它不能匹配 Jo,因为该字符串里面包含了大写字符,并且它太短了。

    2. 基本匹配

    正则表达式只是我们用于在文本中检索字母和数字的模式。例如正则表达式 cat,表示: 字母 c 后面跟着一个字母 a,再后面跟着一个字母 t。

    “cat” => The cat sat on the mat

    正则表达式 123 会匹配字符串 “123”。通过将正则表达式中的每个字符逐个与要匹配的字符串中的每个字符进行比较,来完成正则匹配。 正则表达式通常区分大小写,因此正则表达式 Cat 与字符串 “cat” 不匹配。

    “Cat” => The cat sat on the Cat

    3. 元字符

    元字符是正则表达式的基本组成元素。元字符在这里跟它通常表达的意思不一样,而是以某种特殊的含义去解释。有些元字符写在方括号内的时候有特殊含义。 元字符如下:
    元字符

    3.1. 英文句号

    英文句号 . 是元字符的最简单的例子。元字符 . 可以匹配任意单个字符。它不会匹配换行符和新行的字符。例如正则表达式 .ar,表示: 任意字符后面跟着一个字母 a, 再后面跟着一个字母 r。

    “.ar” => The car parked in the garage.

    3.2. 字符集

    字符集也称为字符类。方括号被用于指定字符集。使用字符集内的连字符来指定字符范围。方括号内的字符范围的顺序并不重要。 例如正则表达式 [Tt]he,表示: 大写 T 或小写 t ,后跟字母 h,再后跟字母 e。

    “[Tt]he” => The car parked in the garage.

    然而,字符集中的英文句号表示它字面的含义。正则表达式 ar[.],表示小写字母 a,后面跟着一个字母 r,再后面跟着一个英文句号 . 字符。

    “ar[.]” => A garage is a good place to park a car.

    3.2.1. 否定字符集

    一般来说插入字符 ^ 表示一个字符串的开始,但是当它在方括号内出现时,它会取消字符集。例如正则表达式 [^c]ar,表示: 除了字母 c 以外的任意字符,后面跟着字符 a, 再后面跟着一个字母 r。

    “[^c]ar” => The car parked in the garage.

    3.3. 重复

    以下元字符 +,* 或 ? 用于指定子模式可以出现多少次。这些元字符在不同情况下的作用不同。

    3.3.1. 星号(*)

    该符号 * 表示匹配上一个匹配规则的零次或多次。正则表达式 a* 表示小写字母 a 可以重复零次或者多次。但是它如果出现在字符集或者字符类之后,它表示整个字符集的重复。 例如正则表达式 [a-z]*,表示: 一行中可以包含任意数量的小写字母。

    “[a-z]*” => The car parked in the garage #21.

    该 * 符号可以与元符号 . 用在一起,用来匹配任意字符串 .。该 * 符号可以与空格符 \s 一起使用,用来匹配一串空格字符。 例如正则表达式 \scat\s*,表示: 零个或多个空格,后面跟小写字母 c,再后面跟小写字母 a,再再后面跟小写字母 t,后面再跟零个或多个空格。

    “\scat\s” => The fat cat sat on the cat. //上面问中漏了一个*号,以下面为准

    3.3.2. 加号(+)

    该符号 + 匹配上一个字符的一次或多次。例如正则表达式 c.+t,表示: 一个小写字母 c,后跟任意数量的字符,后跟小写字母 t。

    “c.+t” => The fat cat sat on the mat. //因为是任意个,所以,直到最后一个t。

    3.3.3. 问号(?)

    在正则表达式中,元字符 ? 用来表示前一个字符是可选的。该符号匹配前一个字符的零次或一次。 例如正则表达式 [T]?he,表示: 可选的大写字母 T,后面跟小写字母 h,后跟小写字母 e。

    “[T]he” => The car is parked in the garage.

    “[T]?he” => The car is parked in the garage.

    3.4. 花括号

    在正则表达式中花括号(也被称为量词 ?)用于指定字符或一组字符可以重复的次数。例如正则表达式 [0-9]{2,3},表示: 匹配至少2位数字但不超过3位(0到9范围内的字符)。

    “[0-9]{2,3}” => The number was 9.9997 but we rounded it off to 10.0. //这里我用颜色区分是两次匹配的,不是同一次匹配4个

    我们可以省略第二个数字。例如正则表达式 [0-9]{2,},表示: 匹配2个或更多个数字。如果我们也删除逗号,则正则表达式 [0-9]{2},表示: 匹配正好为2位数的数字。

    “[0-9]{2,}” => The number was 9.9997 but we rounded it off to 110.0.

    “[0-9]{2}” => The number was 9.9997 but we rounded it off to 10.0.

    3.5. 字符组

    字符组是一组写在圆括号内的子模式 (…)。正如我们在正则表达式中讨论的那样,如果我们把一个量词放在一个字符之后,它会重复前一个字符。 但是,如果我们把量词放在一个字符组之后,它会重复整个字符组。 例如正则表达式 (ab)* 表示匹配零个或多个的字符串 “ab”。我们还可以在字符组中使用元字符 |。例如正则表达式 (c|g|p)ar,表示: 小写字母 c、g 或 p 后面跟字母 a,后跟字母 r。

    “(c|g|p)ar” => The car is parked in the garage.

    3.6. 分支结构

    在正则表达式中垂直条 | 用来定义分支结构,分支结构就像多个表达式之间的条件。现在你可能认为这个字符集和分支机构的工作方式一样。 但是字符集和分支结构巨大的区别是字符集只在字符级别上有作用,然而分支结构在表达式级别上依然可以使用。 例如正则表达式 (T|t)he|car,表示: 大写字母 T 或小写字母 t,后面跟小写字母 h,后跟小写字母 e 或小写字母 c,后跟小写字母 a,后跟小写字母 r。

    “(T|t)he|car” => The car is parked in the garage.

    或者

    “(T|t)he|ype” => The is a base Type.

    3.7. 转义特殊字符

    正则表达式中使用反斜杠 \ 来转义下一个字符。这将允许你使用保留字符来作为匹配字符 { } [ ] / \ + * . $ ^ | ?。在特殊字符前面加 \,就可以使用它来做匹配字符。 例如正则表达式 . 是用来匹配除了换行符以外的任意字符。现在要在输入字符串中匹配 . 字符,正则表达式 (f|c|m)at.?,表示: 小写字母 f、c 或者 m 后跟小写字母 a,后跟小写字母 t,后跟可选的 . 字符。

    “(f|c|m)at.?” => The fat cat sat on the mat.

    3.8. 定位符

    在正则表达式中,为了检查匹配符号是否是起始符号或结尾符号,我们使用定位符。 定位符有两种类型: 第一种类型是 ^ 检查匹配字符是否是起始字符,第二种类型是 $,它检查匹配字符是否是输入字符串的最后一个字符。

    3.8.1. 插入符号

    插入符号 ^ 用于检查匹配字符是否是输入字符串的第一个字符。如果我们使用正则表达式 ^a (如果a是起始符号)匹配字符串 abc,它会匹配到 a。 但是如果我们使用正则表达式 ^b,它是匹配不到任何东西的,因为在字符串 abc 中 “b” 不是起始字符。 让我们来看看另一个正则表达式 ^(T|t)he,这表示: 大写字母 T 或小写字母 t 是输入字符串的起始符号,后面跟着小写字母 h,后跟小写字母 e。

    “(T|t)he” => The car is parked in the garage.

    比较上面的区别不难发现插入符号(开始判断)的作用。

    “^(T|t)he” => The car is parked in the garage.

    3.8.2. 美元符号

    美元 $ 符号用于检查匹配字符是否是输入字符串的最后一个字符。例如正则表达式 (at.)$,表示: 小写字母 a,后跟小写字母 t,后跟一个 . 字符,且这个匹配器必须是字符串的结尾。

    “(at.)” => The fat cat. sat. on the mat.

    比较上面的区别不难发现美元符号(结尾判断)的作用

    “(at.)$” => The fat cat sat on the mat.

    4.简写字符集

    正则表达式为常用的字符集和常用的正则表达式提供了简写。简写字符集如下:

    简写字符集

    5.断言

    后行断言和先行断言有时候被称为断言,它们是特殊类型的 非捕获组 (用于匹配模式,但不包括在匹配列表中)。当我们在一种特定模式之前或者之后有这种模式时,会优先使用断言。 例如我们想获取输入字符串 $4.44 and $10.88 中带有前缀 $ 的所有数字。我们可以使用这个正则表达式 (?<=$)[0-9.]*,表示: 获取包含 . 字符且前缀为 $ 的所有数字。 以下是正则表达式中使用的断言:

    断言

    5.1. 正向先行断言

    正向先行断言认为第一部分的表达式必须是先行断言表达式。返回的匹配结果仅包含与第一部分表达式匹配的文本。 要在一个括号内定义一个正向先行断言,在括号中问号和等号是这样使用的 (?=…)。先行断言表达式写在括号中的等号后面。 例如正则表达式 (T|t)he(?=\sfat),表示: 匹配大写字母 T 或小写字母 t,后面跟字母 h,后跟字母 e。 在括号中,我们定义了正向先行断言,它会引导正则表达式引擎匹配 The 或 the 后面跟着 fat。

    “(T|t)he(\sfat)” => The fat cat sat on the mat.

    上下自行对比结果

    “(T|t)he(?=\sfat)” => The fat cat sat on the mat.

    5.2. 负向先行断言

    当我们需要从输入字符串中获取不匹配表达式的内容时,使用负向先行断言。负向先行断言的定义跟我们定义的正向先行断言一样, 唯一的区别是不是等号 =,我们使用否定符号 !,例如 (?!..)。 我们来看看下面的正则表达式 (T|t)he(?!\sfat),表示: 从输入字符串中获取全部 The 或者 the 且不匹配 fat 前面加上一个空格字符。

    “(T|t)he(\sfat)” => The fat cat sat on the mat.

    这里解释一下,通过上下对比结果可以知道:
    有负向先行断言的,只要是The或者the后面是空格符+fat,那么前面这个the或者The我们就抛弃。
    反之,则是我们先要的结果。

    “(T|t)he(?!\sfat)” => The fat cat sat on the mat.

    5.3. 正向后行断言

    正向后行断言是用于获取在特定模式之前的所有匹配内容。正向后行断言表示为 (?<=…)。例如正则表达式 (?<=(T|t)he\s)(fat|mat),表示: 从输入字符串中获取在单词 The 或 the 之后的所有 fat 和 mat 单词。

    “((T|t)he\s)(fat|mat)” => The fat cat sat on the mat.

    上下对比不难发现有正向后行断言与没有的区别,这里不多说

    “(?<=(T|t)he\s)(fat|mat)” => The fat cat sat on the mat.

    5.4. 负向后行断言

    负向后行断言是用于获取不在特定模式之前的所有匹配的内容。负向后行断言表示为 (?<!..)。例如正则表达式 (?<!(T|t)he\s)(cat),表示: 在输入字符中获取所有不在 The 或 the 之后的所有单词 cat。

    “((T|t)he\s)(cat)” => The cat sat on cat.

    上下对比不难发现有负向后行断言与没有的区别,这里不多说

    “(?<!(T|t)he\s)(cat)” => The cat sat on cat.

    6. 标记

    标记也称为修饰符,因为它会修改正则表达式的输出。这些标志可以以任意顺序或组合使用,并且是正则表达式的一部分。

    标记

    6.1. 不区分大小写

    i 修饰符用于执行不区分大小写匹配。例如正则表达式 /The/gi,表示: 大写字母 T,后跟小写字母 h,后跟字母 e。 但是在正则匹配结束时 i 标记会告诉正则表达式引擎忽略这种情况。正如你所看到的,我们还使用了 g 标记,因为我们要在整个输入字符串中搜索匹配。

    “The” => The fat cat sat on the mat.

    不区分大小写检索应该不难理解,就是这个结果

    “/The/gi” => The fat cat sat on the mat.

    6.2. 全局搜索

    g 修饰符用于执行全局匹配 (会查找所有匹配,不会在查找到第一个匹配时就停止)。 例如正则表达式 /.(at)/g,表示: 除换行符之外的任意字符,后跟小写字母 a,后跟小写字母 t。 因为我们在正则表达式的末尾使用了 g 标记,它会从整个输入字符串中找到每个匹配项。

    “.(at)” => The fat cat sat on the mat.

    上面:.(at) 没有加全局搜索,所以找到第一个就直接停止了,输出fat
    下面:/.(at)/g 有加全局搜索,所以知道整个串找完,才会停止,输出全部符合条件的

    “/.(at)/g” => The fat cat sat on the mat.

    6.3. 多行匹配

    m 修饰符被用来执行多行的匹配。正如我们前面讨论过的 (^, )使使使m/at(.)?),使用定位符来检查匹配字符是输入字符串开始或者结束。但是我们希望每一行都使用定位符,所以我们就使用 m 修饰符。 例如正则表达式 /at(.)?/gm,表示: 小写字母 a,后跟小写字母 t,匹配除了换行符以外任意字符零次或一次。而且因为 m 标记,现在正则表达式引擎匹配字符串中每一行的末尾。

    “/.at(.)?$/” => The fat
    cat sat
    on the mat.

    这个逻辑就很清晰,不解释太多

    “/.at(.)?$/gm” => The fat
    cat sat
    on the mat.

    7.常用正则表达式(摘)

    下面的是我去网上找的一些现成的正则表达式,只是借鉴着看,消化上面的内容,大家可以看看,练练手。

    正整数: ^\d+$
    负整数: ^-\d+$
    电话号码: ^+?[\d\s]{3,}$
    电话代码: ^+?[\d\s]+(?[\d\s]{10,}$
    整数: ^-?\d+$
    密码: (?=.{6,})((?=.[AZaz09])(?=.[AZ])(?=.[az])).)((?=.*[A-Za-z0-9])(?=.*[A-Z])(?=.*[a-z]))^.*
    电子邮件: ^([a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,4})$
    小写字母: ^([a-z])
    $
    大写字母: ^([A-Z])$
    VISA 信用卡号码: ^(4[0-9]{12}(?:[0-9]{3})?)
    $
    日期 (MM/DD/YYYY): ^(0?[1-9]|1[012])- /.- /.?[0-9]{2}$
    日期 (YYYY/MM/DD): ^(19|20)?[0-9]{2}- /.- /.$
    万事达信用卡号码: ^(5[1-5][0-9]{14})*$

    8.总结

    关于正则表达式,涉及的东西实在是太多了,远远不是一两篇博客就能够容纳下庞大的体系的。
    学习是一个积累的过程,今天把学习的内容写下来,以后看见自己写的也能够快速回忆起来。
    如果还能给正在找正则表达式基本内容的朋友带来一些帮助就更加彰显这篇博客的价值了。

    版权声明:转载请注明出处,谢谢!

    展开全文
  • 正则表达式分为元字符和文字。正则表达式的元字符拥有非常强大的描述能力。 行的起始和结束 脱字符号^(代表一行的开始) 美元符号$(代表一行的结束) ^cat //匹配以cat开头的行 cat$ //...

    正则表达式分为元字符文字。正则表达式的元字符拥有非常强大的描述能力。

    行的起始和结束

    • 脱字符号^(代表一行的开始)
    • 美元符号$(代表一行的结束)
    ^cat //匹配以cat开头的行
    cat$ //匹配以cat结尾的行
    

    字符组

    • [ ](用来匹配若干字符之一)
    • [^ ](用来匹配除若干字符以外的字符之一)

    用来匹配若干字符之一,主要这句话的两个限定词,"字符"和“之一”。每个中括号只匹配一个字符,被匹配的字符位置是中括号中字符的其中一个。注意:[]还支持匹配范围,例如[0-9]可以匹配0-9之间的数字,但是注意-不能放在[]开始的位置 ,那样-会被当做字符来处理。

    gr[ea]p //grep或者grap都可以被匹配
    

    匹配任意字符

    • .(匹配任意字符)

    正则表达式是用来匹配任意字符的符号是英文状态下的一个点。(在linux下处理文件时,通常会用*来匹配文件名。或者写sql时,会用select * 用于查询全部字段,有时也用于而在正则表达式里,)

    03.19.23 //03-19-23或者03/19/23都可以被匹配
    

    多选结构

    • | (或)

    将不同的子表达式组合成一个总表达式。只要能够匹配任意一个表达式。子表达式又被称作多选分支。

    //匹配grey或者gray的几种写法:
    grey|gray 
    gr(e|a)y 
    gr[ea]y
    
    //注意:gr[e|a]y这种写法时,|并没有作为“或”的意思,而是作为了一个可选字符。
    

    单词分界符

    • \< (匹配单词的开头,可以理解为单词版的^)
    • \>(匹配单词的结束,可以理解为但此版的$)

    单词分界符用于解决:“期望匹配的单词包含在另一个单词中”。注意:<和>并不是元字符,只有他们跟\结合起来时,才具有相应的意义。 <和\>也被叫做“元字符序列”。

    \<cat //匹配以cat开头的单词
    

    初步总结前面提到的元字符

    这里写图片描述

    这里写图片描述
    这里写图片描述

    下面继续列举元字符:

    量词(quantifiers)

    • ?(可选项,把?放在一个字符后面,表示无论这个字符是否出现都可以被匹配。)
    • +(计数,紧邻元素出现一次或多次)
    • *(紧邻元素出现任意次,也可以不出现)
    • {min,max}(计数区间,可以设置重复次数)
    colou?r //可以匹配color或者colour
    [a-zA-Z]{1,5} //匹配出现1-5个字母
    

    这里写图片描述

    转义字符

    • \

    用于解决匹配的字符本身是元字符的情况。

    \.   //用于匹配字符点。
    

    一些小例子

    匹配由字母、数字、下划线组成的字符串,但是不能以数字开头[a-zA-Z_][a-zA-Z0-9_]*

    匹配双引号内的字符串"[^"]*"

    匹配美元金额\$[0-9]+(\.[0-9]*)?

    元字符总结

    这里写图片描述

    展开全文
  • 1.正则表达式的定义 正则表达式( Regular Expression )是用于匹配字符串中字符组合的模式。在JavaScript中,正则表达式也是对象。 正则表通常被用来检索、替换那些符合某个模式(规则)的文本,例如验证表单:...

    一、知识点要点:

    1.正则表达式的定义
    正则表达式( Regular Expression )是用于匹配字符串中字符组合的模式。在JavaScript中,正则表达式也是对象。

    正则表通常被用来检索、替换那些符合某个模式(规则)的文本,例如验证表单:用户名表单只能输入英文字母、数字或者下划线, 昵称输入框中可以输入中文(匹配)。此外,正则表达式还常用于过滤掉页面内容中的一些敏感词(替换),或从字符串中获取我们想要的特定部分(提取)等 。

    2.如何创建

    1. 显式创建
      var myregex = new RegExp("[0-9]");    //显式定义
    
    1. 隐式创建
     var myregex = /[0-9]/;    //隐式定义
    

    3.如何使用
    用test方法来判断一个str是否满足正则表达式的要求

    var rg = /123/;
    console.log(rg.test(123));//匹配字符中是否出现123  出现结果为true
    console.log(rg.test('abc'));//匹配字符中是否出现123 未出现结果为false
    

    4.边界符
    ^ 表示匹配行首的文本(以谁开始)
    $ 表示匹配行尾的文本(以谁结束)
    如果 ^和 $ 在一起,表示必须是精确匹配。

    var rg = /abc/; // 正则表达式里面不需要加引号 不管是数字型还是字符串型
    // /abc/ 只要包含有abc这个字符串返回的都是true
    console.log(rg.test('abc'));
    console.log(rg.test('abcd'));
    console.log(rg.test('aabcd'));
    console.log('---------------------------');
    var reg = /^abc/;
    console.log(reg.test('abc')); // true
    console.log(reg.test('abcd')); // true
    console.log(reg.test('aabcd')); // false
    console.log('---------------------------');
    var reg1 = /^abc$/; // 精确匹配 要求必须是 abc字符串才符合规范
    console.log(reg1.test('abc')); // true
    console.log(reg1.test('abcd')); // false
    console.log(reg1.test('aabcd')); // false
    console.log(reg1.test('abcabc')); // false
    

    5.字符类
    字符类表示有一系列字符可供选择,只要匹配其中一个就可以了。所有可供选择的字符都放在方括号内。

    var rg = /[abc]/; // 只要包含有a 或者 包含有b 或者包含有c 都返回为true
    console.log(rg.test('andy'));//true
    console.log(rg.test('baby'));//true
    console.log(rg.test('color'));//true
    console.log(rg.test('red'));//false
    var rg1 = /^[abc]$/; // 三选一 只有是a 或者是 b  或者是c 这三个字母才返回 true
    console.log(rg1.test('aa'));//false
    console.log(rg1.test('a'));//true
    console.log(rg1.test('b'));//true
    console.log(rg1.test('c'));//true
    console.log(rg1.test('abc'));//true
    ----------------------------------------------------------------------------------
    var reg = /^[a-z]$/ //26个英文字母任何一个字母返回 true  - 表示的是a 到z 的范围  
    console.log(reg.test('a'));//true
    console.log(reg.test('z'));//true
    console.log(reg.test('A'));//false
    -----------------------------------------------------------------------------------
    //字符组合
    var reg1 = /^[a-zA-Z0-9]$/; // 26个英文字母(大写和小写都可以)任何一个字母返回 true  
    ------------------------------------------------------------------------------------
    //取反 方括号内部加上 ^ 表示取反,只要包含方括号内的字符,都返回 false 。
    var reg2 = /^[^a-zA-Z0-9]$/;
    console.log(reg2.test('a'));//false
    console.log(reg2.test('B'));//false
    console.log(reg2.test(8));//false
    console.log(reg2.test('!'));//true
    

    6.量词符
    *重复0次或更多次
    +重复1次或更多次
    ?重复0次或1次
    {n}重复n次
    {n,}重复n次或更多次
    {n,m}重复n到m次

    二、如何写一个小数(只保留两位小数)

    1.拆分
    分为整数部分和小数部分
    整数部分,如果是一个数的情况可以是0或者1-9;如果是多个数字的话,那么必须是以非0开头,即1-9开头;
    整合之后是([0]{1}) | ([1-9] [0-9]*),这里的[0-9]也可以写成\d,即为

    (([1-9]{1}\d*)|([0]{1}))
    

    小数部分,由于小数部分只保留两位,首先必须有小数点的存在,用转义\表示小数点.,接着就是0-9出现0-2次,最终是:

    (\.(\d){0,2})
    

    整合结果:

    ^(([1-9]{1}\d*)|(0{1}))(\.\d{0,2})?$
    //?就表示了小数点后可以保留0位、1位、或2位小数。
    

    三、如何写一个美元

    要求如下:
    1、以 $ 开始
    2、整数部分,从个位起,满 3 个数字用 , 分隔
    3、如果为小数,则小数部分长度为 2
    4、正确的格式如:$1,023,032.03 或者 $2.03,错误的格式如:$3,432,12.12 或者 $34,344.3

    整数部分:
    开头:$
    匹配紧跟$符的数字:最多三位,最少一位,1位是0-9的,2-3位以1-9开头,[0-9]选一位或者两位

    (0|[1-9]|[1-9]\d{0,2})
    

    接下来是逗号之后的内容
    逗号之后,三位数字,0-9出现3次,并且整个部分可以出现0或者多次,用*表示

    (,\d{3})*
    

    最后是小数部分,首先是.开头,需要转义\.,接下来是[0-9]出现两次,当然整个部分也是可以出现一次或者不出现

    (\.\d{2})?
    

    最后整合

    ^\$(0|[1-9]\d{0,2})(,\d{3})*(\.\d{2})?
    
    展开全文
  • 题目:使用python正则表达式匹配文中所有的美元字样,并且将其转换成纯金额。 dollar.txt: asdasfa$12342.492asgasg$231,999.00h$299124rher$345213 asdasfa$12342.492asgasg$231,999.00h$299124rher$979699 $231,...

    来讲一下正则表达式在python中的简单使用,直接上例子吧~~

    题目:使用python正则表达式匹配文中所有的美元字样,并且将其转换成纯金额。

    dollar.txt:

    asdasfa$12342.492asgasg$231,999.00h$299124rher$345213
    asdasfa$12342.492asgasg$231,999.00h$299124rher$979699
    $231,999.00h$299124rherh5240.00美元$231,999.00$2893529
    asdasfa$12342.492asgasg$231,999.00h$299124rher$039572
    asdasfa$12342.492asgasg$231,999.00h$231,999.00#$02935
    $231,999.00h$299124rherh5240.00美元$231,999.00$29037we
    asdasfa$12342.492asgasg$231,999.00h$231,999.00$352396j
    $231,999.00h$299124rherh5240.00美元$231,999.00$wr$2351
    asdasfa$12342.492asgasg$231,999.00h$231,999.00$2352366
    

    通过浏览可以发现,dollar.txt中的金额样式有
    $12342.492
    $231,999.00(带逗号的)
    5240.00美元
    $345213

    import re
    
    # 获取所有数据
    text = ''
    file = open(r"dollar.txt",encoding="UTF-8")
    for line in file:
        text = text + line
    file.close()
    
    # 通过正则表达式获取结果集
    result = re.findall('(\$[\d+,]*\d+[\.\d+]*)|(\d+\.\d{2}美元)',text)
    
    # 数据清洗
    data = []
    for r in result:
        if r[0] != '':
            data.append(r[0])
        if r[1] != '':
            data.append(r[1])
    
    # 打印输出
    print("{}{}".format("提取的数据:",data))
    
    list_num = []   # 存储纯数字列表
    for n in data:
        list_num.append(re.findall('\d+',n))  # 将字符串除去
    
    print(list_num)
    
    result_num = []     # 存储最终结果
    for i in list_num:
        money = 0
        digit = 0   # 用来表示位数,从个位开始
        if len(i) == 1:
            money = eval(i[0])
        else:
            decimal = eval(i[-1])/pow(10,len(i))    # 小数部分
            money = decimal
            li = list(reversed(i))  # 倒序排序
            for j in range(1,len(li)):
                money = money + eval(li[j])*pow(10,digit)
                digit = digit + len(li[j])
        result_num.append(money)
    
    # 打印输出
    print(result_num)
    
    

    运行一下
    在这里插入图片描述
    OK!现在来讲解一下代码中的正则表达式:
    result = re.findall(’($[\d+,]\d+[.\d+])|(\d+.\d{2}美元)’,text)

    (\$[\d+,]*\d+[\.\d+]*)|(\d+\.\d{2}美元)
    
    1. \$:匹配一个“$”美元符号,\在这里是转义符;

    2. [\d+,]:这可以看做是一个单独的语句
      (1)
      [… …]:中括号,通俗地讲就是看做是一个整体表达式,做一个优先级运算;
      (2)
      \d*:匹配一个数字;
      (3)+:加号,匹配前面的子表达式一次或多次。\d+ 匹配一个或多个数字的组合;
      (4),:逗号,在这里没什么含义,仅仅是为了匹配一个逗号;

    3. *:星号和 加号 作用类似,是为了匹配前面的子表达式零次或多次,例如 \d* ,就可以匹配空字符串或者多个数字的组合;

    4. [.\d+]*:同理,这里补充一下,. 在这里也仅仅是为了匹配一个小数点;

    5. (… …):括号,和中括号功能类似,也是看做是一个整体表达式,但是有一点不同的是,它的子表达式会获取供以后使用,就是说有多少个括号就会匹配多少个结果,例如 (… (…)…(…)…) ,这里有三个括号,那它最后返回的结果集就是 [ [a,b,c], [a,b,c], [a,b,c]… …] 这种形式的,还不懂的话可以将上面的中括号换成小括号再运行一下程序就懂了;

    6. |:竖杠,表示的意思,例如:\d|\s 会匹配一个字符或者是一个数字;

    7. {… …}:大括号,有两种用法,一种是和小括号和中括号一样,另一种就是在上面表达式中的功能

    字符 描述
    {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?’。请注意在逗号和两个数之间不能有空格。
    展开全文
  • 正则表达式

    2019-06-14 11:17:41
    标题一些常用的正则表达式符号量词字符转义 \字符组 () ,即后向引用oracle中四个正则比哦啊大师相关的函数 正则表达式参考: https://www.cnblogs.com/linbo3168/p/6016643.html 一些常用的正则表达式符号 ^ 脱...
  • (我用无望正则表达式(我不能在这个时候换我周围的头),我发现了几个regulair expresions,并用它来进行以下操作:使用正则表达式,如何找到不包含美元和下划线的最后一个字母字符$sName=" $stackOverFlow *^ %";...
  • Java标识符不能以数字开头,但在初始字符后,它们可以使用字母和数字,下划线或美元符号的任意组合:([a-zA-Z_$][a-zA-Z\d_$]*\.)*[a-zA-Z_$][a-zA-Z\d_$]*------------------------ -----------------------N ...
  • 字符串inputStr =“这是一个样本@主机名1 @主机名2,我想将字符串转换等:@test宿主@ test1格式化,例如美元,然后是开放的花括号,字符串和大括号。输出字符串我需要为输出:“这是一个示例$ {主机名1} $ {主机名2}...
  • 正则表达式 入门

    2018-11-18 22:37:57
    文本检索是正则表达式最简单的应用之一 ——许多文本编辑器和文字处理软件都提供了正则表达式检索功能。最简单的就是egrep。在指定了正则表达式和需要检索的文件之后,egrep会尝试用正则表达式来匹配每个文件的每一...
  • 常用正则表达式

    2021-03-03 16:37:13
    目录 基本匹配 元字符 英文句号 字符集 否定字符集 ...美元符号 ...常用正则表达式 ...正则表达式只是我们用于在...例如正则表达式 cat,表示:字母 c 后面跟着一个字母 a,再后面跟着一个字母 t。 "cat" => The cat sa
  • 正则表达式入门

    2020-02-12 11:34:03
    实践出真知 ...^ 和 美元符号框定正则表达式,它指引这个正则表达式对文本中的所有字符都进行匹配。如果省略这些标识,那么只要一个字符串中包含一个数字这个正则表达式就会进行匹配 [-+]? one or more ...
  • 必须从以下字符中选择第一个字符:字母,下划线或美元符号。第一个字符不能是数字。其余字符(除第一个外)可以来自:字母,数字,下划线或美元符号。换句话说,它可以是任何有效的标识符字符。简而言之,标识符是从...
  • $ 美元符 行末的位置 \ 单词起始位置 \> 单词结束位置 | 或 匹配两边任意一个条件 () 括号 限制竖线的作用范围 表示重复的元字符 ? 可以出现0次或一次 * 可以出现任意次 + 出现1次以
  • 匹配行首:^(脱字符号),匹配行尾$(美元符号) ^代表一个行的开始,$代表一行的结束 例如: ^cat只寻找行首有cat的 cataaaa---&amp;amp;amp;amp;amp;amp;amp;amp;gt;匹配 bcatbbb---&amp;amp;amp;amp;amp...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 373
精华内容 149
关键字:

美元正则表达式