精华内容
下载资源
问答
  • 一、单项选择题1、以下说法中正确的是(C)(2分)A、C语言程序总是从第一个的函数开始执行B、在C语言程序中,要调用的...不合法常量的是(B)(2分)A、1.234e04B、1.234e0.4C、1.234e+4D、1.234e03、C语言中最简单的数据类...

    一、单项选择题

    1、以下说法中正确的是(C)(2分)

    A、C语言程序总是从第一个的函数开始执行

    B、在C语言程序中,要调用的函数必须在main()函数中定义

    C、C语言程序总是从main()函数开始执行

    D、C语言程序中的main()函数必须放在程序的开始部分

    2、以下选项中,不合法常量的是(B)(2分)

    A、1.234e04

    B、1.234e0.4

    C、1.234e+4

    D、1.234e0

    3、C语言中最简单的数据类型包括(B)(2分)

    A、整型、实型、逻辑型

    B、整型、实型、字符型

    C、整型、字符型、逻辑型

    D、整型、实型、逻辑型、字符型

    4、能正确表示逻辑关系:“10≥=a≥=0”的C语言表达式是 (D)(2分)

    A、 10>=a>=0

    B、 a>=0 and a<=10

    C、 a>=0||a<=10

    D、 a>=0&&a<=10

    5、设a和b均为double型变量,且a=5.5、b=2.5,则表达式(int)a+b/b的值是(D)(2分)

    A、 6.500000

    B、 6

    C、 5.500000

    D、 6.000000

    6、x、y、z被定义为int型变量,若从键盘给x、y、z输入数据,正确的输入语句是(B)(2分)

    A、 INPUT x、y、z;

    B、 scanf("%d%d%d",&x,&y,&z);

    展开全文
  • 表达式

    2019-10-05 13:24:05
    1.Java表达式19%5的结果是什么? 答:结果是4 2.Java表达式13/4的结果是什么? 答:结果是3 3.如果整型变量diameter当前的值为5,那么执行下面的表达式后其值将变成什么?...5.下列表达式的值分别是多少? ...

    1.Java表达式19%5的结果是什么?

    答:结果是4

    2.Java表达式13/4的结果是什么?

    答:结果是3

    3.如果整型变量diameter当前的值为5,那么执行下面的表达式后其值将变成什么?

    diameter=diamteter*4

    答:结果是20

    4.什么是运算符优先级?

    答:运算符优先级是一组定义了表达式中运算符执行顺序的规则

    5.下列表达式的值分别是多少?

    a.15+7*3                       36

    b.(15+7)*3                     66

    c.3*6+10/5+5                 25

    d.27%5+7%3                 1

    e.100/2/2/2                    12

    f.100/(2/2)/2                   50

    6.判断下列表达式是否合法。若不合法请给出理由。

    a.result=(5+2);                                                        合法;

    b.result=(5+2*(15-3);                                    不合法,少了右圆括号;

    c.result=(5+2(;                                                        不合法,把右圆括号改成了左圆括号;

    d.result=(5+2(4));                                               不合法,2和“(4)”之间没有运算符。

    7.执行下列代码后,整型变量result的值是多少?

    result=27;                         

    result=result+3;                                  结果result值是8

    result=result/7;                  

    result=result*2; 

    8.执行下列代码后,整型变量result的值是多少?

    int base;                            

    int result; 

    base=5;                                               结果result值是8

    result=base+3;

    base=7;

    9.什么是赋值运算符?

    答:赋值运符是基本运算符和赋值运算符进行了组合。例如,使用“+=”运算符的语句

    10.如果·整型变量weight当前的值为100,那么执行下面的表达式后其值将变成什么?

    weight-=17

    答:变成83

    转载于:https://www.cnblogs.com/hzyhx/p/9543387.html

    展开全文
  • 正则表达式

    千次阅读 2019-12-09 02:30:24
    正则表达式 正则表达式(又称规则表达式)是一组特殊的字符串,通常被用来检索、替换那些符合某个模式(规则)的字符串。 许多程序设计语言都支持利用正则表达式进行字符串操作。Python 自1.5版本起增加了re 模块,...

    正则表达式

    正则表达式(又称规则表达式)是一组特殊的字符串,通常被用来检索、替换那些符合某个模式(规则)的字符串。
    许多程序设计语言都支持利用正则表达式进行字符串操作。Python 自1.5版本起增加了re 模块,提供 Perl 风格的正则表达式模式,re 模块使 Python 语言拥有全部的正则表达式功能。下面讲解正则表达式在Python中的一些简单应用。

    正则表达式的常用方法或函数

    compile函数

    compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。
    正则对象 = compile(正则表达式语法)

    match函数

    如果正则表达式中没有设置^开头和match结尾限制这种操作,match的作用类似于验证待校验字符串是否以正则表达式对应的字符串内容开头;如果正则表达式中设置了^开头和结尾限制这种操作,match的作用检查待校验的字符串的整体内容是否符合正则表达式的语法。
    如果找到满足要求的字符串,返回Match对象,否则返回None。下面是2个实例

    import re
    #生成一个对应的正则对象
    re_obj = re.compile("hello")
    #match验证
    res = re_obj.match("Hello good good study")
    #输出结果
    print(res)
    

    结果输出为:None

    import re
    re_obj = re.compile("^hello$")
    res = re_obj.match("hello")
    print(res)
    

    结果输出为:<_sre.SRE_Match object; span=(0, 5), match=‘hello’>

    search函数

    在待查询的字符串中查找是否有满足正则表达式的子串,如果有返回查找到的第一个子串对应的匹配Match对象,如果没有返回None。

    import re
    re_obj = re.compile("to")
    res = re_obj.search("nice to meet you hello nice to meet you too")
    

    结果输出为:<_sre.SRE_Match object; span=(5, 7), match=‘to’>

    findall函数

    在待查询的字符串中查找是否有满足正则表达式的子串,有的话将其放在列表中返回,没有的话返回空列表。

    import re
    s = "i13love14you520"
    re_obj = re.compile("[0-9]+")
    res = re_obj.findall(s)
    print(f"{'+'.join(res)} = {eval('+'.join(res))}")
    

    结果输出为:13+14+520 = 547

    finditer函数

    在待查询的字符串中查找是否有满足正则表达式的子串,将检验到的数据对应的Match对象放在迭代器中返回。

    s = "i13love14you520"
    re_obj = re.compile("[0-9]+")
    res_iter = re_obj.finditer(s)
    print(res_iter)
    

    结果输出为:<callable_iterator object at 0x000002560E19BD30>
    查看其存储的结果

    for ele in res_iter:
         print(ele)
    

    输出为:
    <_sre.SRE_Match object; span=(1, 3), match=‘13’>
    <_sre.SRE_Match object; span=(7, 9), match=‘14’>
    <_sre.SRE_Match object; span=(12, 15), match=‘520’>
    可使用下列代码更方便地查看其中的结果

    num_list = [ele.group() for ele in res_iter]
    print(num_list)
    str_res = " + ".join(num_list)
    print(f"{str_res} = {eval(str_res)}")
    

    最终输出结果为:[‘13’, ‘14’, ‘520’]

    split函数

    在待切割的字符串中以正则表达式对应的内容为切割符,对字符串进行切割,返回列表。

    import re
    s = "i13love14you520hi"
    re_obj = re.compile("[^0-9]+")
    res_list = re_obj.split(s)
    print(res_list)
    

    结果输出为:[’’, ‘13’, ‘14’, ‘520’, ‘’]
    去除其中的空字符串

    str_list = [ele for ele in res_list if ele != ""]
    print(str_list)
    

    结果输出为:[‘13’, ‘14’, ‘520’]

    sub函数

    re模块中也提供了用于替换字符串的函数sub(新子串,待替换的子串)。

    import re
    s = "1314"
    re_obj = re.compile("1")
    res = re_obj.sub("一", s)
    print(res)
    

    结果输出为:一3一4

    正则表达式模式

    模式字符串使用特殊的语法来表示一个正则表达式:
    字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
    多数字母和数字前加一个反斜杠时会拥有不同的含义。
    标点符号只有被转义时才匹配自身,否则它们表示特殊的含义。
    反斜杠本身需要使用反斜杠转义。
    由于正则表达式通常都包含反斜杠,所以最好使用原始字符串来表示它们。模式元素(如 r’\t’,等价于 \t )匹配相应的特殊字符。
    下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数,某些模式元素的含义会改变。

    模式 描述
    .(点) 通配符,可以匹配除了\n之外的任意一个字符。若要表示其原本的意思,点前面要加\
    ^ 匹配字符串每一行的开头
    $ 匹配字符串每一行的末尾
    \Z 匹配字符串的末尾
    […] 用来表示一组字符中的任意一个,[amk] 匹配 ‘a’,‘m’或’k’
    [^…] 不在[]中的字符:[^abc] 匹配除了a,b,c之外的任意一个字符。
    \d 表示的是0-9中任意一个字符
    \D 表示的是除了0-9之外任意一个字符
    \w 数字字母下划线和汉字中的任意一个
    \W 非数字字母下划线和汉字中的任意一个
    \s 表示的是任意空白字符中的一个
    \S 表示的是非任意空白字符中的一个
    \b 单词的边界
    \B 单词非边界
    re.I 忽略大小写的情况下进行匹配
    re.M 将数据视作多行进行匹配
    re.S 将内容视作一行进行匹配,在这种模式下 .可以匹配\n
    x* 表示x连续出现任意次 [可有可无]
    x+ 表示x连续出现至少1次
    x? 表示x最多出现1次
    x{m,n} 表示x最少连续出现m次 最多连续出现n次
    x{m,} 表示x最少连续出现m次
    x{m} 表示x必须连续出现m次
    \num 后面匹配出的内容与前面某组匹配出的内容一模一样 就可以使用\num模式,num为数值看与哪个小组内容匹配 num就是几 (从1开始的)。<([a-zA-Z]+)> </\1>

    下面用三个例子来进行演示:
    例1 验证邮箱格式是否正确(只能包含数字字母下划线 长度最小是6 最大是16)

    import re
    re_obj = re.compile(r"^[0-9a-zA-Z_]{6,16}@(qq|sina|163)\.(com|cn|net)$")
    res = re_obj.match("12367@qq.com")
    if res:
        print("邮箱格式正确")
    else:
        print("邮箱格式错误")
    

    结果输出为:邮箱格式错误
    例2 验证录入的地址是否合法

    import re
    re_obj = re.compile(r"^((2[0-4]\d|25[0-5]|1?\d?\d)\.){3}(2[0-4]\d|25[0-5]|1?\d?\d)$")
    res = re_obj.match("2.0.25.0")
    print(res)
    

    结果输出为:<_sre.SRE_Match object; span=(0, 8), match=‘2.0.25.0’>
    例3 利用正则表达式提取字符串中的数值[包括正数与负数 整数与小数], 并对其进行累加。

    import re
    re_obj = re.compile(r"[-]?(0|[1-9]\d*)(\.\d+)?")
    s = "i12323love3.14are-2.71you0.28"
    res_iter = re_obj.finditer(s)
    data_list = [ele.group() for ele in res_iter]
    expression_str = "+".join(data_list)
    print(f"{expression_str} = {eval(expression_str)}")
    

    结果输出为:12323+3.14±2.71+0.28 = 12323.710000000001

    展开全文
  • 什么是正则表达式

    2011-01-18 17:26:00
    什么是正则表达式? 在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说,正则表达式就是记录文本规则的代码。 很可能...

    什么是正则表达式?
    在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说,正则表达式就是记录文本规则的代码。

    很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard),也就是*和?。如果你想查找某个目录下的所有的Word文档的话,你会搜索*.doc。在这里,*会被解释成任意的字符串。和通配符类似,正则表达式也是用来进行文本匹配的工具,只不过比起通配符它能更精确地描述你的需求——当然,代价就是更复杂。比如你可以编写一个正则表达式来查找所有以0开头,后面跟着2-3个数字,然后是一个连字号“-”,最后是7或8位数字的字符串(像010-12345678或0376-7654321)。

    正则表达式是用于进行文本匹配的工具,所以本文里多次提到了在字符串里搜索/查找,这种说法的意思是在给定的字符串中,寻找与给定的正则表达式相匹配的部分。有可能字符串里有不止一个部分满足给定的正则表达式,这时每一个这样的部分被称为一个匹配。匹配在本文里可能会有三种意思:一种是形容词性的,比如说一个字符串匹配一个表达式;一种是动词性的,比如说在字符串里匹配正则表达式;还有一种是名词性的,就是刚刚说到的“字符串中满足给定的正则表达式的一部分”。

    入门
    学习正则表达式的最好方法是从例子开始,理解例子之后再自己对例子进行修改,实验。下面给出了不少简单的例子,并对它们作了详细的说明。

    假设你在一篇英文小说里查找hi,你可以使用正则正则表达式hi。

    这是最简单的正则表达式了,它可以精确匹配这样的字符串:由两个字符组成,前一个字符是h,后一个是i。通常,处理正则表达式的工具会提供一个忽略大小写的选项,如果选中了这个选项,它可以匹配hi,HI,Hi,hI这四种情况中的任意一种。

    不幸的是,很多单词里包含hi这两个连续的字符,比如him,history,high等等。用hi来查找的话,这里边的hi也会被找出来。如果要精确地查找hi这个单词的话,我们应该使用/bhi/b。

    /b是正则表达式规定的一个特殊代码(好吧,某些人叫它元字符,metacharacter),代表着单词的开头或结尾,也就是单词的分界处。虽然通常英文的单词是由空格或标点符号或换行来分隔的,但是/b并不匹配这些单词分隔符中的任何一个,它只匹配一个位置。(如果需要更精确的说法,/b匹配这样的位置:它的前一个字符和后一个字符不全是/w)

    假如你要找的是hi后面不远处跟着一个Lucy,你应该用/bhi/b.*/bLucy/b。

    这里,.是另一个元字符,匹配除了换行符以外的任意字符。*同样是元字符,不过它代表的不是字符,也不是位置,而是数量--它指定*前边的内容可以重复任意次以使整个表达式得到匹配。因此,.*连在一起就意味着任意数量的不包含换行的字符。现在/bhi/b.*/bLucy/b的意思就很明显了:先是一个单词hi,然后是任意个任意字符(但不能是换行),最后是Lucy这个单词。

    如果同时使用其它的一些元字符,我们就能构造出功能更强大的正则表达式。比如下面这个例子:

    0/d/d-/d/d/d/d/d/d/d/d匹配这样的字符串:以0开头,然后是两个数字,然后是一个连字号“-”,最后是8个数字(也就是中国的电话号码。当然,这个例子只能匹配区号为3位的情形)。

    这里的/d是一个新的元字符,匹配任意的数字(0,或1,或2,或……)。-不是元字符,只匹配它本身——连字号。

    为了避免那么多烦人的重复,我们也可以这样写这个表达式:0/d{2}-/d{8}

    这里/d后面的{2}({8})的意思是前面/d必须连续重复匹配2次(8次)。

    测试正则表达式
    如果你不觉得正则表达式很难读写的话,要么你是一个天才,要么,你不是地球人。正则表达式的语法很令人头疼,即使对经常使用它的人来说也是如此。由于难于读写,容易出错,所以很有必要创建一种工具来测试正则表达式。

    由于在不同的环境下正则表达式的一些细节是不相同的,本教程介绍的是Microsoft .Net 2.0下正则表达式的行为,所以,我向你介绍一个.Net下的工具Regex Tester。首先你确保已经安装了.Net Framework 2.0,然后下载Regex Tester,下载完后打开压缩包,运行setup.exe安装。

    下面是Regex Tester运行时的截图:

     

    元字符
    现在你已经知道几个很有用的元字符了,如/b,.,*,还有/d.当然还有更多的元字符,比如/s匹配任意的空白符,包括空格,制表符(Tab),换行符,中文全角空格等。/w匹配字母或数字或下划线或汉字。

    下面来试试更多的例子:

    /ba/w*/b匹配以字母a开头的单词——先是某个单词开始处(/b),然后是字母a,然后是任意数量的字母或数字(/w*),最后是单词结束处(/b)(好吧,现在我们说说这里的单词是什么意思吧:就是几个连续的/w。不错,这与学习英文时要背的成千上万个同名的东西的确关系不大)。

    /d+匹配1个或更多连续的数字。这里的+是和*类似的元字符,不同的是*匹配重复任意次(可能是0次),而+则匹配重复1次或更多次。

    /b/w{6}/b 匹配刚好6个字母/数字的单词。

    表1.常用的元字符 代码 说明
    . 匹配除换行符以外的任意字符
    /w 匹配字母或数字或下划线或汉字
    /s 匹配任意的空白符
    /d 匹配数字
    /b 匹配单词的开始或结束
    ^ 匹配字符串的开始
    $ 匹配字符串的结束

    元字符^(和6在同一个键位上的符号)以及$和/b有点类似,都匹配一个位置。^匹配你要用来查找的字符串的开头,$匹配结尾。这两个代码在验证输入的内容时非常有用,比如一个网站如果要求你填写的QQ号必须为5位到12位数字时,可以使用:^/d{5,12}$。

    这里的{5,12}和前面介绍过的{2}是类似的,只不过{2}匹配只能不多不少重复2次,{5,12}则是必须重复最少5次,最多12次,否则都不匹配。

    因为使用了^和$,所以输入的整个字符串都要用来和/d{5,12}来匹配,也就是说整个输入必须是5到12个数字,因此如果输入的QQ号能匹配这个正则表达式的话,那就符合要求了。

    和忽略大小写的选项类似,有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项,^和$的意义就变成了匹配行的开始处和结束处。

    字符转义
    如果你想查找元字符本身的话,比如你查找.,或者*,就出现了问题:你没法指定它们,因为它们会被解释成其它的意思。这时你就必须使用/来取消这些字符的特殊意义。因此,你应该使用/.和/*。当然,要查找/本身,你也得用//.

    例如:www/.unibetter/.com匹配www.unibetter.com,c://windows匹配c:/windows,2/^8匹配2^8(通常这是2的8次方的书写方式)。

    重复
    你已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有指定重复的方式:

    表2.常用的限定符 代码/语法 说明
    * 重复零次或更多次
    + 重复一次或更多次
    ? 重复零次或一次
    {n} 重复n次
    {n,} 重复n次或更多次
    {n,m} 重复n到m次

    下面是一些使用重复的例子:

    Windows/d+匹配Windows后面跟1个或更多数字

    13/d{9}匹配以13后面跟9个数字(中国的手机号)

    ^/w+匹配一行的第一个单词(或整个字符串的第一个单词,具体匹配哪个意思得看选项设置)

    字符类
    要想查找数字,字母或数字,空白是很简单的,因为已经有了对应这些字符集的元字符,但是如果你想匹配没有预定义元字符的字符集比如元音字母(a,e,i,o,u),怎么办?

    很简单,你只需要在中括号里列出它们就行了,像[aeiou]就匹配任何一个元音字母,[.?!]匹配标点符号(.或?或!)(英文语句通常只以这三个标点结束)。注意,我们不需要写成[/./?!]。

    我们也可以轻松地指定一个字符范围,像[0-9]代表的含意与/d就是完全一致的:一位数字,同理[a-z0-9A-Z_]也完全等同于/w(如果只考虑英文的话)。

    下面是一个更复杂的表达式:/(?0/d{2}[) -]?/d{8}。

    这个表达式可以匹配几种格式的电话号码,像(010)88886666,或022-22334455,或02912345678等。我们对它进行一些分析吧:首先是一个转义字符/(,它能出现0次或1次(?),然后是一个0,后面跟着2个数字({2}),然后是)或-或空格中的一个,它出现1次或不出现(?),最后是8个数字(/d{8})。不幸的是,它也能匹配010)12345678或(022-87654321这样的“不正确”的格式。要解决这个问题,请在本教程的下面查找答案。

    反义
    有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外,其它任意字符都行的情况,这时需要用到反义:

    表3.常用的反义代码 代码/语法 说明
    /W 匹配任意不是字母,数字,下划线,汉字的字符
    /S 匹配任意不是空白符的字符
    /D 匹配任意非数字的字符
    /B 匹配不是单词开头或结束的位置
    [^x] 匹配除了x以外的任意字符
    [^aeiou] 匹配除了aeiou这几个字母以外的任意字符

    例子:/S+匹配不包含空白符的字符串。

    <a[^>]+>匹配用尖括号括起来的以a开头的字符串。

    替换
    好了,现在终于到了解决3位或4位区号问题的时间了。正则表达式里的替换指的是有几种规则,如果满足其中任意一种规则都应该当成匹配,具体方法是用|把不同的规则分隔开。听不明白?没关系,看例子:

    0/d{2}-/d{8}|0/d{3}-/d{7}这个表达式能匹配两种以连字号分隔的电话号码:一种是三位区号,8位本地号(如010-12345678),一种是4位区号,7位本地号(0376-2233445)。

    /(0/d{2}/)[- ]?/d{8}|0/d{2}[- ]?/d{8}这个表达式匹配3位区号的电话号码,其中区号可以用小括号括起来,也可以不用,区号与本地号间可以用连字号或空格间隔,也可以没有间隔。你可以试试用替换|把这个表达式扩展成也支持4位区号的。

    /d{5}-/d{4}|/d{5}这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字,或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题:使用替换时,顺序是很重要的。如果你把它改成/d{5}|/d{5}-/d{4}的话,那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配替换时,将会从左到右地测试每个分枝条件,如果满足了某个分枝的话,就不会去管其它的替换条件了。

    Windows98|Windows2000|WindosXP这个例子是为了告诉你替换不仅仅能用于两种规则,也能用于更多种规则。

    分组
    我们已经提到了怎么重复单个字符(直接在字符后面加上限定符就行了);但如果想要重复一个字符串又该怎么办?你可以用小括号来指定子表达式(也叫做分组),然后你就可以指定这个子表达式的重复次数了,你也可以对子表达式进行其它一些操作(后面会有介绍)。

    (/d{1,3}/.){3}/d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式,请按下列顺序分析它:/d{1,3}匹配1到3位的数字,(/d{1,3}/.}{3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次,最后再加上一个一到三位的数字(/d{1,3})。

    不幸的是,它也将匹配256.300.888.999这种不可能存在的IP地址(IP地址中每个数字都不能大于255)。如果能使用算术比较的话,或许能简单地解决这个问题,但是正则表达式中并不提供关于数学的任何功能,所以只能使用冗长的分组,选择,字符类来描述一个正确的IP地址:((2[0-4]/d|25[0-5]|[01]?/d/d?)/.){3}(2[0-4]/d|25[0-5]|[01]?/d/d?)。

    理解这个表达式的关键是理解2[0-4]/d|25[0-5]|[01]?/d/d?,这里我就不细说了,你自己应该能分析得出来它的意义。

    后向引用
    使用小括号指定一个子表达式后,匹配这个子表达式的文本可以在表达式或其它程序中作进一步的处理。默认情况下,每个分组会自动拥有一个组号,规则是:从左向右,以分组的左括号为标志,第一个出现的分组的组号为1,第二个为2,以此类推。

    后向引用用于重复搜索前面某个分组匹配的文本。例如,/1代表分组1匹配的文本。难以理解?请看示例:

    /b(/w+)/b/s+/1/b可以用来匹配重复的单词,像go go, kitty kitty。首先是一个单词,也就是单词开始处和结束处之间的多于一个的字母或数字(/b(/w+)/b),然后是1个或几个空白符(/s+,最后是前面匹配的那个单词(/1)。

    你也可以自己指定子表达式的组号或组名。要指定一个子表达式的组名,请使用这样的语法:(?<Word>/w+),这样就把/w+的组名指定为Word了。要反向引用这个分组捕获的内容,你可以使用/k<Word>,所以上一个例子也可以写成这样:/b(?<Word>/w+)/b/s*/k<Word>/b。

    使用小括号的时候,还有很多特定用途的语法。下面列出了最常用的一些:

    表4.分组语法 捕获
    (exp) 匹配exp,并捕获文本到自动命名的组里
    (?<name>exp) 匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name'exp)
    (?:exp) 匹配exp,不捕获匹配的文本
    位置指定
    (?=exp) 匹配exp前面的位置
    (?<=exp) 匹配exp后面的位置
    (?!exp) 匹配后面跟的不是exp的位置
    (?<!exp) 匹配前面不是exp的位置
    注释
    (?#comment) 这种类型的组不对正则表达式的处理产生任何影响,只是为了提供让人阅读注释

    我们已经讨论了前两种语法。第三个(?:exp)不会改变正则表达式的处理方式,只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面。

    位置指定
    接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西,也就是说它们用于指定一个位置,就像/b,^,$那样,因此它们也被称为零宽断言。最好还是拿例子来说明吧:

    (?=exp)也叫零宽先行断言,它匹配文本中的某些位置,这些位置的后面能匹配给定的后缀exp。比如/b/w+(?=ing/b),匹配以ing结尾的单词的前面部分(除了ing以外的部分),如果在查找I'm singing while you're dancing.时,它会匹配sing和danc。

    (?<=exp)也叫零宽后行断言,它匹配文本中的某些位置,这些位置的前面能给定的前缀匹配exp。比如(?<=/bre)/w+/b会匹配以re开头的单词的后半部分(除了re以外的部分),例如在查找reading a book时,它匹配ading。

    假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了),你可以这样查找需要在前面和里面添加逗号的部分:((?<=/d)/d{3})*/b。请仔细分析这个表达式,它可能不像你第一眼看出来的那么简单。

    下面这个例子同时使用了前缀和后缀:(?<=/s)/d+(?=/s)匹配以空白符间隔的数字(再次强调,不包括这些空白符)。

    负向位置指定
    前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现,但并不想去匹配它时怎么办?例如,如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样:

    /b/w*q[^u]/w*/b匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐,直接就观察出来了),你会发现,如果q出现在单词的结尾的话,像Iraq,Benq,这个表达式就会出错。这是因为[^u]总是匹配一个字符,所以如果q是单词的最后一个字符的话,后面的[^u]将会匹配q后面的单词分隔符(可能是空格,或者是句号或其它的什么),后面的/w+/b将会匹配下一个单词,于是/b/w*q[^u]/w*/b就能匹配整个Iraq fighting。负向位置指定能解决这样的问题,因为它只匹配一个位置,并不消费任何字符。现在,我们可以这样来解决这个问题:/b/w*q(?!u)/w*/b。

    零宽负向先行断言(?!exp),只会匹配后缀exp不存在的位置。/d{3}(?!/d)匹配三位数字,而且这三位数字的后面不能是数字。

    同理,我们可以用(?<!exp),零宽负向后行断言来查找前缀exp不存在的位置:(?<![a-z])/d{7}匹配前面不是小写字母的七位数字(实验时发现错误?注意你的“区分大小写”先项是否选中)。

    一个更复杂的例子:(?<=<(/w+)>).*(?=<///1>)匹配不包含属性的简单HTML标签内里的内容。(<?(/w+)>)指定了这样的前缀:被尖括号括起来的单词(比如可能是<b>),然后是.*(任意的字符串),最后是一个后缀(?=<///1>)。注意后缀里的//,它用到了前面提过的字符转义;/1则是一个反向引用,引用的正是捕获的第一组,前面的(/w+)匹配的内容,这样如果前缀实际上是<b>的话,后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒,不包括前缀和后缀本身)。

    注释
    小括号的另一种用途是能过语法(?#comment)来包含注释。例如:2[0-4]/d(?#200-249)|25[0-5](?#250-255)|[01]?/d/d?(?#0-199)。

    要包含注释的话,最好是启用“忽略模式里的空白符”选项,这样在编写表达式时能任意的添加空格,Tab,换行,而实际使用时这些都将被忽略。启用这个选项后,在#后面到这一行结束的所有文本都将被当成注释忽略掉。

    例如,我们可以前面的一个表达式写成这样:

          (?<=    # 查找前缀,但不包含它

          <(/w+)> # 查找尖括号括起来的字母或数字(标签)

          )       # 前缀结束

          .*      # 匹配任意文本

          (?=     # 查找后缀,但不包含它

          <///1>  # 查找尖括号括起来的内容:前面是一个"/",后面是先前捕获的标签

          )       # 后缀结束
        贪婪与懒惰
    当正则表达式中包含能接受重复的限定符(指定数量的代码,例如*,{5,12}等)时,通常的行为是(在使整个表达式能得到匹配的前提下)匹配尽可能多的字符。考虑这个表达式:a.*b,它将会匹配最长的以a开始,以b结束的字符串。如果用它来搜索aabab的话,它会匹配整个字符串aabab。这被称为贪婪匹配。

    有时,我们更需要懒惰匹配,也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式,只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧:

    a.*?b匹配最短的,以a开始,以b结束的字符串。如果把它应用于aabab的话,它会匹配aab和ab(为什么第一个匹配是aab而不是ab?简单地说,最先开始的区配最有最大的优先权——The Match That Begins Earliest Wins)。

    表5.懒惰限定符 *? 重复任意次,但尽可能少重复
    +? 重复1次或更多次,但尽可能少重复
    ?? 重复0次或1次,但尽可能少重复
    {n,m}? 重复n到m次,但尽可能少重复
    {n,}? 重复n次以上,但尽可能少重复

    平衡组
    如果想要匹配可嵌套的层次性结构的话,就得使用平衡组了。举个例子吧,如何把“xx <aa <bbb> <bbb> aa> yy”这样的字符串里,最长的括号内的内容捕获出来?

    这里需要用到以下的语法构造:

    (?<group>) 把捕获的内容命名为group,并压入堆栈
    (?<-group>) 从堆栈上弹出最后压入堆栈的名为group的捕获内容,如果堆栈本来为空,则本分组的匹配失败
    (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话,继续匹配yes部分的表达式,否则继续匹配no部分
    (?!) 零宽负向先行断言,由于没有后缀表达式,试图匹配总是失败
    如果你不是一个程序员(或者你是一个对堆栈的概念不熟的程序员),你就这样理解上面的三种语法吧:第一个就是在黑板上写一个(或再写一个)"group",第二个就是从黑板上擦掉一个"group",第三个就是看黑板上写的还有没有"group",如果有就继续匹配yes部分,否则就匹配no部分。

    我们需要做的是每碰到了左括号,就在黑板上写一个"group",每碰到一个右括号,就擦掉一个,到了最后就看看黑板上还有没有-如果有那就证明左括号比右括号多,那匹配就应该失败(为了能看得更清楚一点,我用了(?'group')的语法):

    <                         #最外层的左括号

        [^<>]*                #最外层的左括号后面的不是括号的内容

        (

            (

                (?'Open'<)    #碰到了左括号,在黑板上写一个"Open"

                [^<>>]*       #匹配左括号后面的不是括号的内容

            )+

            (

                (?'-Open'>)   #碰到了右括号,擦掉一个"Open"

                [^<>]*        #匹配右括号后面不是括号的内容

            )+

        )*

        (?(Open)(?!)) #在遇到最外层的右括号前面,判断黑板上还有没有没擦掉的"Open";如果还有,则匹配失败

    >                         #最外层的右括号还有些什么东西没提到
    我已经描述了构造正则表达式的大量元素,还有一些我没有提到的东西。下面是未提到的元素的列表,包含语法和简单的说明。你可以在网上找到更详细的参考资料 来学习它们--当你需要用到它们的时候。如果你安装了MSDN Library,你也可以在里面找到关于.net下正则表达式详细的文档。

    表6.尚未详细讨论的语法 /a 报警字符(打印它的效果是电脑嘀一声)
    /b 通常是单词分界位置,但如果在字符类里使用代表退格
    /t 制表符,Tab
    /r 回车
    /v 竖向制表符
    /f 换页符
    /n 换行符
    /e Escape
    /0nn ASCII代码中八进制代码为nn的字符
    /xnn ASCII代码中十六进制代码为nn的字符
    /unnnn Unicode代码中十六进制代码为nnnn的字符
    /cN ASCII控制字符。比如/cC代表Ctrl+C
    /A 字符串开头(类似^,但不受处理多行选项的影响)
    /Z 字符串结尾或行尾(不受处理多行选项的影响)
    /z 字符串结尾(类似$,但不受处理多行选项的影响)
    /G 当前搜索的开头
    /p{name} Unicode中命名为name的字符类,例如/p{IsGreek}
    (?>exp) 贪婪子表达式
    (?<x>-<y>exp) 平衡组
    (?im-nsx:exp) 在子表达式exp中改变处理选项
    (?im-nsx) 为表达式后面的部分改变处理选项
    (?(exp)yes|no) 把exp当作零宽正向先行断言,如果在这个位置能匹配,使用yes作为此组的表达式;否则使用no
    (?(exp)yes) 同上,只是使用空表达式作为no
    (?(name)yes|no) 如果命名为name的组捕获到了内容,使用yes作为表达式;否则使用no
    (?(name)yes) 同上,只是使用空表达式作为no

    一些我认为你可能已经知道的术语的参考
    字符
    程序处理文字时最基本的单位,可能是字母,数字,标点符号,空格,换行符,汉字等等。
    字符串
    0个或更多个字符的序列。
    文本
    文字,字符串。
    匹配
    符合规则,检验是否符合规则,符合规则的部分。
    网上的资源及本文参考文献
    微软的正则表达式教程
    专业的正则表达式教学网站(英文)
    关于.Net下的平衡组的详细讨论(英文)
    Mastering Regular Expressions (Second Edition)
    第二版更新说明
    修正了几个细节上的错误和不准确的地方
    增加了对处理中文时的一些说明
    更改了几个术语的翻译(采用了MSDN的翻译方式)
    增加了平衡组的介绍
    放弃了对The Regulator的介绍,改用Regex Tester

     

    "^/d+$"  //非负整数(正整数 + 0)
    "^[0-9]*[1-9][0-9]*$"  //正整数
    "^((-/d+)|(0+))$"  //非正整数(负整数 + 0)
    "^-[0-9]*[1-9][0-9]*$"  //负整数
    "^-?/d+$"    //整数
    "^/d+(/./d+)?$"  //非负浮点数(正浮点数 + 0)
    "^(([0-9]+/.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*/.[0-9]+)|([0-9]*[1-9][0-9]*))$"  //正浮点数
    "^((-/d+(/./d+)?)|(0+(/.0+)?))$"  //非正浮点数(负浮点数 + 0)
    "^(-(([0-9]+/.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*/.[0-9]+)|([0-9]*[1-9][0-9]*)))$"  //负浮点数
    "^(-?/d+)(/./d+)?$"  //浮点数
    "^[A-Za-z]+$"  //由26个英文字母组成的字符串
    "^[A-Z]+$"  //由26个英文字母的大写组成的字符串
    "^[a-z]+$"  //由26个英文字母的小写组成的字符串
    "^[A-Za-z0-9]+$"  //由数字和26个英文字母组成的字符串
    "^/w+$"  //由数字、26个英文字母或者下划线组成的字符串
    "^[/w-]+(/.[/w-]+)*@[/w-]+(/.[/w-]+)+$"    //email地址
    "^[a-zA-z]+://(/w+(-/w+)*)(/.(/w+(-/w+)*))*(/?/S*)?$"  //url
    /^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/ // 年-月-日
    /^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/ // 月/日/年
    "^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$" //Emil
    "(d+-)?(d{4}-?d{7}|d{3}-?d{8}|^d{7,8})(-d+)?" //电话号码
    "^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$" //IP地址

    匹配中文字符的正则表达式: [/u4e00-/u9fa5]
    匹配双字节字符(包括汉字在内):[^/x00-/xff]
    匹配空行的正则表达式:/n[/s| ]*/r
    匹配HTML标记的正则表达式:/<(.*)>.*<///1>|<(.*) //>/
    匹配首尾空格的正则表达式:(^/s*)|(/s*$)
    匹配Email地址的正则表达式:/w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*
    匹配网址URL的正则表达式:^[a-zA-z]+://(//w+(-//w+)*)(//.(//w+(-//w+)*))*(//?//S*)?$
    匹配帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$
    匹配国内电话号码:(/d{3}-|/d{4}-)?(/d{8}|/d{7})?
    匹配腾讯QQ号:^[1-9]*[1-9][0-9]*$

    展开全文
  • 一、强制类型表达式 格式:(类型名)(表达式) ...注:1、可以颠倒(左边必须是变量名,右边必须是C语言中合法表达式) 2、功能就是先求出右边表达式的值,,然后把赋值给赋值号左边的变量 ...
  • 赋值表达式

    千次阅读 2018-02-11 11:26:00
    1、在C语言中,有下列五个基本的算术运算符:+、-、*、/和%,依次表示加、减、乘、除、求 余运算。(考得最多的是/ 和%符号!!!) 2、求余运算符%的运算对象只能是整型,即%左侧的被除数与右侧的除数都只能为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,368
精华内容 8,947
关键字:

下列表达式不合法的是