正则表达式做编译器

⑴ python ，正则表达式问题

r'(.*) are (.*?) .*'

首先，这是一袜山旅个字符串，前面的一个r表示字符串为非转义的原始字符串，让编译器忽略反斜杠，也就是忽略转义字符。但是这个字符串里没有反斜杠，所以这个r可有可无。

1. (.*) 第唯槐一个匹配分组，.*代表匹配除换行符之外的所有字符
   

2. (.*?)第二个匹配分组，.*?后面多个问号，代表非贪婪模式，也就是说只匹配符合条件的最少字符
   

3. 后面的一个.* 没有括号包围，所以不是分组，匹配效果和第一个一样，但是不计入匹配结果中。

matchObj.group() 等告凳同于matchObj.group(0)，表示匹配到的完整文本字符

matchObj.group(1) 得到第一组匹配结果，也就是(.*)匹配到的

matchObj.group(2) 得到第二组匹配结果，也就是(.*?)匹配到的

因为只有匹配结果中只有两组，所以填3时会报错。

⑵ 正则表达式是什么

问题一：什么是正则表达式 如果原来没有使用过正则表达式，那么可能对这个术语和概念会不太熟悉。不过，它们并不是您想象的那么新奇。
请回想一下在硬盘上是如何查找文件的。您肯定会使用 ? 和 * 字符来帮助查找您正寻找的文件。? 字符匹配文件名中的单个字符，而 * 则匹配一个或多个字符。一个如 'data?.dat' 的模式可以找到下述文件：
data1.dat
data2.dat
datax.dat
dataN.dat
如果使用 * 字符代替 ? 字符，则将扩大找到的文件数量。'data*.dat' 可以匹配下述所有文件名：
data.dat
data1.dat
data2.dat
data12.dat
datax.dat
dataXYZ.dat
尽管这种搜索文件的方法肯定很有用，但也十分有限。? 和 * 通配符的有限能力可以使骸对正则表达式能做什么有一个概念，不过正则表达式的功能更强大，也消型更灵活。

问题二世喊：正则表达式是什么?有什么用？ 简单的说就是，用一小段简单的各种字符的组合，即叫做 正则表达式，去实现复杂的：
字符串匹配，查找你到你所需要的内容，以便后期提取出来你所要的内容。
这个听起来很简单，但是很多现实的应用中，所要处理的字符串有千千万万种，各种复杂的字符，而且每个人的需求有无穷尽种，需要提取出的内容也是无穷多。而如果手动处理，写普通的if else语句去一点点判断字符串是否相等，则是无法实现的。
而用正则，就可以实现如此多的，繁杂的，极度复杂的，各种需求。

更多的内容，可以看看我所总结的：
正则表达式学习心得

再举几个实际的例子：
Notepad++正则表达式替换举例1：一次性替换多个文件的后缀
Notepad++正则表达式替换举例2：一次性替换多个路径
Notepad++正则表达式替换举例3：一次性替换多个listitem为sect4
Notepad++正则表达式替换举例4：给每一行都添加AddIcon的前缀
Notepad++正则表达式替换举例5：给book的标题和地址添加html代厂
（这里不给贴地址，请自行google搜标题，即可找到帖子地址）

问题三：正则表达式中的*是什么意思 *是一个限定符，用来修饰前一个字符或分组，限定匹配重复的数量为任意数量。
例如：
正则表达式 a* 可以匹配 a aa aaa aaaa aaaaaaa等等
正则表达式 (ab)* 可以匹配 ab abababab ababababababab等等
需要注意个是，*与+不同，+要求重复数量至少为1，*则可以为0，所以字符串为空也是可以匹配的。
以下是常用的限定符代码：
*重复零次或更多次
+重复一次或更多次
?重复零次或一次
{n}重复n次
{n,}重复n次或更多次
{n,m}重复n到m次
望采纳！

问题四：这个正则表达式是什么意思 ^是界定符，表示匹配字符串的开始；
[+-]，中括号表示其内的内容都是符合要求的匹配，所以这个表示“+”或者-；
\d，[0-9]的简写形式，也就是匹配数字；
$也是界定符，表示匹配字符串的结束；
了解以上之后再来看问号(?)和星号(*)：跟在一个模式内容后面的是量词，用来限定模式内容匹配的次数，例如我想要匹配最少1个、最多3个数字，例如4、20、123、226这样的，先前已经解释过单个数字可以用[0-9]或者\d表示，那么怎么表示最少匹配1次、最多3次呢？很简单，拿返猜就在模式后面加上大括号配合次数表示量词，形式为{下限,上限}，就是这样[0-9]{1,3}或者\d{1,3}。类似的，[0-9]{2}就表示只能匹配2个数字（多一个少一个都不行），[0-9]{2,}表示至少要有2个数字最多不限（注意大括号内的逗号），[0-9]{,2}表示最多有2个数字（注意大括号的逗号）。
针对经常用的量词，正则中也有简写，{0,1}简写就是问号（要么没有要么只有一次），{0,}简写就是星号（随便有没有也不限次数），{1,}简写就是加号（至少有一次）

问题五：正则表达式中 .*? 代表什么？ 点 是任意字符
* 是取 0 至 无限长度
问号 是非贪婪模式。
何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：
.*?a
就是取前面任意长度的字符，到底一个 a 出现，匹配如下
[email protected] _qwerqweraljlkjlkjlkj
得到：[email protected] _qwerqwera 这部分，如果匹配不到后面的 a 字符，则匹配为空。

问题六：正则表达式<.*?>是什么意思？ .匹配任意字符1个
*表示匹配重复上一个字符0到无限次
？表示匹配前一个字符0次或一次，跟在*表示非贪婪模式
默认是贪婪模式比如
会把所有字符吞下满足前面是就返回字符串
一次吃一个字符满足条件返回字符串

问题七：简单说下什么是正则表达式 简单地说就是一种格式化的匹配方式，与普通的查找方式相比，可以用一句话匹配出所有格式统一或类似的子串，而不用逐一列出每一种可能的情况，可以大幅降低程序的复杂度，提高程序的可靠性，减少处理遗漏。

问题八：正则表达式中“@”的作用是什么？ C#中的字符串,如正则表达式中,有可能出现一些与C#语言相同的字符,比如\,会让编译器作为C#语言来识别,截断该字符串,并可能产生编译器错误.
为了防止这种情况的发生,在该字符串前加一个@就是告诉编译器,这些特殊字符是作为字符串中的一部分存在的,编译器就不会去编译它了.
比如路径c:\abc\d.txt将产生编译器错误,之前可以[email protected] :\abc\d.txt便得到其真实路径了.
这下明白了吧？

问题九：正则表达式的[],(),{}都指的是什么含义，有什么区别？ [asd]或是[0-9a-zA-Z]
第一个表示匹配asd三个字母中任意一个字符，第一个表示匹配0－9,a-z大小写中的任意一个字符
()表示一个整体吧，比如asdf你想匹配他或是空,asdf?是错误的，问号只能匹配f的存在 ，而是使用(asdf)?，另外在一些替换中可用一些符号表示括号中匹配的内容，比如
/^$/
\1就代表(\w+)中匹配到的内容，这个正则可以匹配 ，开始和结束相同的标签
其他作用这一下也没想起了。。
{}代码匹配内容的数量如/^a{1,4}$/表示最少有一个a，最多4个a，或是/^a{2, }$/表示最少要有两个a，没上限的

问题十：.*([';]+|(--)+).* 正则表达式是什么意思 .*([';]+|(--)+).*
任意字符 ';这两个字符至少处一个，且最少一次
或者 --至少出现一次，或者多次出现 再任意字符
比如
任意字符''''''--任意字符
任意字符;;;;;;--任意字符
任意字符''''''----任意字符
任意字符''----任意字符
任意字符;----任意字符

⑶ 第二十三章 expect-正则表达式-sed-cut 的使用

本节所讲内容

23.1  expect  实现无交互登录

23.2  正则表达式

23.3  sed 流编译器

23.4   cut 命令

23.5  实战-bash  脚本语法检查和查看详细的执行过程

23.1   expect  实现无交互登录

expect  是它发展出来的，如果想要写一个能够自动处理输入输出的脚本（如向用户提问并且要验证码）又不想面对C或者Perl   那么expect 是你最好的选择   它可以用用来做一些linux下无法交互的一些命令操作

安装   expect     正则表达式

[root@localhost ~]# yum -y install expect

1）  定义脚本执行的shell 

#！ /bin/bash/expect  

这里定义的是expect  可执行文件的连接路径   （或真实路径） 功能类似于bash  等shell功能

2）   set  timeout  30  

设置超时时间，单位是秒  。如果设为timeout  -1   意味永不过时

3）  spawn 

spawn  是进入expect 环境之后才能执行的内部命令，如果没有装expect  或者直接在默认的SHELL下执行时找不到spawn  命令的额，不能直接在默认的shell环境中进行执行主要功能是给猜卜ssh 和兆档 运行进程加个壳

用来传递交互指令

4）  expect

这里的expect 同样是expect 的内部命令

主要功能：判断输出结果是否包含某项字符串，没有则立即返回，否则等待一段时间后

timeout 进行设置

执行交互动作 ，将交互要执行的动作进行输入给交互指令

6） exp_continue  

继续执行接下来的交互操作

7）  interact   

执行完保持交互状态，把控制器交给控制台，如果不加这一项，交互完成后，就会自动退出

8）  $ argv 

expect 脚本可以接受从bash   传递过来的参数，可以使用   [ lin dex $argv n] 获得，n从

一个，第二个，第三个，。。。。。参数

例1  ：  面密码通过ssh  登录服务器  （了解）

注意： 运行脚本时，要把#号后面的文字删除，不然无法运行

[root@localhost ~]# vim ssh.exp

①#! /usr/bin/expect   这是开头

②#! /usr/bin/expect

不加注释的脚本

#!/usr/bin/expect

set ipaddr "192.168.1.63"

set name "root"

set passwd "123456"

set timeout 30     #设置超时时间，单位是秒；expect超时等待的时间。默认timeout为10s。

spawn ssh $name@$ipaddr    #   spawn是进入expect环境后才可以执行的expect内部命令，如果没有装expect或者直接在shell下执行是找不到spawn命令唤乱的。这个就好比cd是shell的内建命令，离开shell，就无法执行cd一样。 它主要的功能是给ssh运行进程加个壳，用来传递交互指令。  

expect {

"yes/no" { send "yes\r";exp_continue }

"password" { send "$passwd\r" }    #执行交互动作，与手工输入密码的动作等效。

}

 

expect "#"    #判断上次输出结果里是否包含“password:”的字符串，如果有则立即返回，向下执行；否则就一直等待，直到超时时间到

send "touch /root/xuegod1011.txt\r"

send "ls /etc > /root/xuegod1011.txt\r"

send "mkdir /tmp/xuegod1011\r"

send "exit\r"

expect eof    #执行完成上述命令后，退出Expect，把控制权交给控制台，变回手工操作

③

[root@localhost ~]# expect ssh.exp

spawn ssh [email protected]

[email protected]'s password:

Last login: Sun Apr 12 07:47:56 2020 from 192.168.24.169

[root@localhost ~]# touch /root/xuegod1011.txt

[root@localhost ~]# ls /etc > /root/xuegod1011.txt

[root@localhost ~]# mkdir /tmp/xuegod1011

mkdir: cannot create directory ‘/tmp/xuegod1011’: File exists

[root@localhost ~]# exit

logout

Connection to 192.168.24.169 closed.

④

例2：对服务器批量管理 （了解一下）

[root@xuegod63 ~]# cat ip_pass.txt     #这里写上要执行的IP地址和root用户密码

192.168.1.63  123456

192.168.1.63  123456

192.168.1.63  123456

[root@xuegod63 ~]# cat ssh 2 .exp    #编写要执行的操作

#!/usr/bin/expect

 

set ipaddr [lindex $argv 0]

set passwd [lindex $argv 1]

set timeout 30

spawn ssh root@$ipaddr

expect {

"yes/no" { send "yes\r";exp_continue }

"password" { send "$passwd\r" }

}

 

expect "#"

send "touch /root/xuegod1011.txt\r"

send "ls /etc > /root/xuegod1011.txt\r"

send "mkdir /tmp/xuegod1011\r"

send "exit\r"

send  eof 

3)cat login.sh    #开始执行

#!/bin/bash

echo

for ip in `awk '{print $1}' /root/ip_pass.txt`

do

pass=`grep $ip /root/ip_pass.txt|awk '{print $2}'`

expect /root/ssh.exp $ip $pass

done

4) 开始执行

bash   login.sh 

特别字符 描述

$ 匹配输入字符串的结尾位置。要匹配 $ 字符本身，请使用 \$

( ) 标记一个子表达式的开始和结束位置。要匹配这些字符，请使用 \( 和 \)

* 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*

+ 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+

. 匹配除换行符 \n 之外的任何 单字符 。要匹配 . ，请使用 \.

[ 标记一个中括号表达式的开始。要匹配 [，请使用 \[

? 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?

\ 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("

^ 匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^

{ 标记限定符表达式的开始。要匹配 {，请使用 \{

| 指明两项之间的一个选择。要匹配 |，请使用 \|   如：  Y | y

定位符

^ 匹配输入字符串开始的位置

$ 匹配输入字符串结尾的位置

非打印字符

\n 匹配一个换行符

\r 匹配一个回车符

\t 匹配一个制表符

找出下列中以# 号或者$  开头的多少行

①grep "^$ \|#" /etc/ssh/sshd_config

②[root@localhost ~]# grep -v "^$\|^#" /etc/ssh/sshd_config    #  取反   使用基础正则表达式

③[root@localhost ~]# grep -E -v "^$\|^#" /etc/ssh/sshd_config   扩展表达式

4）[root@localhost ~]# egrep  -v "^$\|^#" /etc/ssh/sshd_config    扩展正则表达式

例3   ：  [root@localhost ~]# grep .ot /etc/passwd     查找passwd  文件包括.ot  的字符

root:x:0:0:root:/root:/bin/bash

23.3   sed  流编译器

sed  编译器是一行一行处理文件的，正在处理的内容放在模式空间内，处理完成后安装选项的规定进行输出或文件的修改

23.3   sed 流编辑器

23.3.1  sed  strem editor 流编辑器

sed编辑器是一行一行的处理文件内容的。正在处理的内容存放在模式空间(缓冲区)内，处理完成后按照选项的规定进行输出或文件的修改。

接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有改变，除非你使用重定向存储输出。Sed主要用来自动编辑一个或多个文件；简化对文件的反复操作；

sed也是支持正则表达式的，如果要使用扩展正则加参数-r

sed的执行过程：

[if !supportLists]1、 [endif] 一次读取一行数据

[if !supportLists]2、 [endif] 根据我们提供的规则来匹配相关的数据，比如查找root。

[if !supportLists]3、 [endif] 按照命令修改数据流中的数据，比如替换

[if !supportLists]4、 [endif] 将结果进行输出

[if !supportLists]5、 [endif] 重复上面四步

23.3.2  如何使用 

语法格式：sed   选项    commands     filename  

例子 [root@localhost ~]# echo "this is aplle" | sed 's/aplle/dog/'

this is dog

[root@localhost ~]# echo "this is aplle" >a.txt

[root@localhost ~]# sed 's/aplle/dog/' a.txt

this is dog

[root@localhost ~]# cat a.txt

this is aplle

23.3.3   sed  选项  | 参数

options  

-a   在当前行下面插入文件

-n   赌气下一行输入行  ，用下要给命令处理新的行而不是用一个命令

-e   执行多个sed  指令

-i   编辑文件内容

 -i.bak   编辑的同时参加。bak   的备份

-r   使用扩展的正则表达式

命令：  重点

i   在当前上面插入文件

c  把选定的行为改为新的指标的文本

p  打印

d   删除

r/R   读取文件/  一行

w   另存

s  查找

y  代替

h   拷贝模板的内容到内存中的缓冲区

H 追加模板库的内容到内存中的缓冲区

g   获得内存缓冲区的内容，并代替当前模板库的文本

G  获得内存缓冲区的内容，并追加到当前模板块文本的后面

D   删除\n 之前的内容

p   打印\n    之前的内容

例1  ：s   只替换第一个匹配到的字符，将password中的root  用户换成  xuegod 

[root@localhost ~]# sed 's/root/xuegod/' /etc/passwd     发现只替换了第一个匹配的root  ，后面的没有替换

全面替换g  

例2   [root@localhost ~]# sed 's/root/xuegod/g' /etc/passwd    全面替换   

xuegod:x:0:0:xuegod:/xuegod:/bin/bash    #  全部替换了

例子2   将sed  中默认的/  定界符改成#号  

[root@localhost ~]# sed 's#/bin/bash#/sbin/nologin#' /etc/passwd | more

[root@localhost ~]# sed 's/root/xuegod/g' /etc/passwd |more

daemon:x:2:2:daemon:/sbin:/sbin/nologin

sed 's/root/xuegod/g' /etc/passwd | more

以 /  来做定界符

[root@localhost ~]# sed 's/\/bin\/bash/\/sbin\/nologin/' /etc/passwd | more

（2）  按行查找代替

写法如下

用数字表示行范围，$  表示行尾

用文本模式配置来过滤

例1  单行代替，将第2行中bin   替换成xuegod 

[root@localhost ~]# sed '2s/bin/xuegod/' /etc/passwd | more

root:x:0:0:root:/root:/bin/bash

xuegod:x:1:1:bin:/bin:/sbin/nologin   可以看到替换了

[root@localhost ~]# sed '2,$s/bin/xuegod/' /etc/passwd | more  第二行到   最后

都替换为xuegod

（3） 删除第2行到第4行  

[root@localhost ~]# sed '2,4d' /etc/hosts

127.0.0.1  localhost localhost.localdomain localhost4 localhost4.localdomain4

[root@localhost ~]# sed '/192.168/d' /etc/hosts    将192.168  的行删除

127.0.0.1  localhost localhost.localdomain localhost4 localhost4.localdomain4

::1        localhost localhost.localdomain localhost6 localhost6.localdomain6

（4）  添加行

命令i  (insert)   插入，在当前行前面加入一行，i\ 

命令   a  append   附加，在当前行后面添加一行  a\

[root@localhost ~]# echo "hello world" | sed 'i\xuegod'

xuegod

hello world

[root@localhost ~]# echo "hello world" | sed 'a\xuegod'

hello world

xuegod

[root@localhost ~]# sed '$a\192.3123 xue.cn' /etc/hosts    在最后一行追加  

127.0.0.1  localhost localhost.localdomain localhost4 localhost4.localdomain4

::1        localhost localhost.localdomain localhost6 localhost6.localdomain6

192.3123 xue.cn

例4  文件在第二行之后开始追加

[root@localhost ~]# sed '2a\192.3123 xue.cn' /etc/hosts   在   第二行追加

127.0.0.1  localhost localhost.localdomain localhost4 localhost4.localdomain4

::1        localhost localhost.localdomain localhost6 localhost6.localdomain6

192.3123 xue.cn

例5   [root@localhost ~]# sed '2,4a\192.3123 xue.cn' /etc/hosts    在第二行和第四行之间都追加

127.0.0.1  localhost localhost.localdomain localhost4 localhost4.localdomain4

::1        localhost localhost.localdomain localhost6 localhost6.localdomain6

192.3123 xue.cn

（5）  c\  修改   change  

[root@localhost ~]# sed '4c\19234.1 192.3123.cn' /etc/hosts

127.0.0.1  localhost localhost.localdomain localhost4 localhost4.localdomain4

::1        localhost localhost.localdomain localhost6 localhost6.localdomain6

例2   将第二行到最后全部修改成192.168.65.cn   /etc/hosts  

[root@localhost ~]# sed '2,$c\192.168.1.65 xuegod65.cn' /etc/hosts

127.0.0.1  localhost localhost.localdomain localhost4 localhost4.localdomain4

192.168.1.65 xuegod65.cn

例3    将包含   192.168.1.65  行的内容修改成   192.168.1.64 

[root@localhost ~]# sed '/192.168.1.65/c\192.168.1.64' /etc/hosts

127.0.0.1  localhost localhost.localdomain localhost4 localhost4.localdomain4

::1        localhost localhost.localdomain localhost6 localhost6.localdomain6

192.168.1.64

（6）   打印，直接输入文件中的内容 

例1  输出 第2行的内容 

[root@localhost ~]# sed -n '2p' /etc/hosts

::1        localhost localhost.localdomain localhost6 localhost6.localdomain6

（7）  将修改过的文件保存到另一个文件中

例2  将pass外的中的包含root字样的行保存到c.txt   中

[root@localhost ~]# sed -n '/root/w c.txt' /etc/passwd

[root@localhost ~]# vim c.txt

（8）  -i   对源文件修改，保存  （必须会）

[root@localhost opt]# sed -i 's/root/xuegod/' /etc/passwd

修改IP地址并保存 

[root@localhost opt]# sed -i 's/IPADDR=192.168.0.151/IPADDR=192.168.0.67/' /etc/sysconfig/network-scripts/ifcfg-ens33

23.4   cut命令  

cut  命令用来显示指定部分，输出文件中的指定字段

说明：该命令有良项功能，其一是用来显示文件的内容，它依次读取由参数file所指的文件，将他们的内容输出到标准输出上，其二是连接两个或多个文件上，如cut  f2  >f3   将文件f1  和fn   所指明的内容合并起来，然后通过输出重定向符 ">"   的作用，将他们放入文件f3   中

语法：cut   选项  参数

选项

-b  仅显示行中指定范围的内容

-c   仅显示行中指定范围的字符

-d   指定字段的分隔符，默认的字段分隔符为   “TAB”

-f  显示指定字段的内容

例1  ：  输出系统中所有用户名

使用-f   选项提取指定字段，使用-d   选项字符分隔符  这里以“：”   冒号做分割

[root@localhost ~]# cut -f1 -d ":" /etc/passwd   指定第一列  -d   以什么为分隔符  “：”

23.4.2   cut  命令可以将一串字符作为列来显示，字符字段的记发

N-   :从第N  个字符，字符，字段到结尾

N-M   ：  从第N个字节，字符，字段到第M 个（包括M在内）字节，字符，字段

-M   ：  从第1个字符，字节，地段到第M 个  包括M在内  字节，字符，字段

上面是记发  

-b   表示字节

-c   表示字符

-d   指定字段的分隔符

-f   表示定义字段

示例   [root@localhost ~]# cut -c1-3 /etc/passwd  打印三个字符   

[root@localhost ~]# cut -c-4 /etc/passwd

检查语法是否有错

bash -v   test.sh       #   查看bash  是否存在语法错误

bash  -x   test.bash   #   查看bash   详细的执行过程

# Script to show debug of shell

tot=`expr $1 + $2`

expr    语法错误，    错误在没有写参数   运行时没有给参数

secho $tot    #  这里是故意写错  没有找到哦啊命令

~                               

过程

[root@localhost ~]# bash -x a.sh 2 3   相差详细过程

++ expr 2 + 3

+ tot=5

+ expr 2 + 3

5

+ echo 5

5

⑷ 请问如何用正则表达式搜重复汉字

正则表达式可以通过某些特定的语法来匹配字符串中的模式，从而实现对字符串中的某些文本的搜索和操作。在用正则表达式搜索重复汉字时，需要使用到两个关键字符：“[]”和“{}”。

以下是实现搜索重复汉字的步骤：

1：创建一个正则表达式字符竖改串，其中汉字可以使用“[]”表示，并且在重复搜索的汉字之前加握帆上“{}”。

2：使用正则表达式编译器将正则表达式字符串编译为正则表达式模式。

3：使用正则表达式模式对目标字符串进行匹配。

4：如果匹配到重复汉字，则可以通过正则表达式匹配器的“find()”方法来获取匹配到的字符串，余皮判并进行后续操作。

如下是一个实现搜索重复汉字的示例代码：

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class Test {

public static void main(String[] args) {

String str = "中华人民共和国";

String pattern = "([\u4e00-\u9fa5])\1+";

Pattern r = Pattern.compile(pattern);

Matcher m = r.matcher(str);

while (m.find()) {

System.out.println(m.group());

}

}

}

在这个示例中，字符串“str”中的所有重复

⑸ java 正则表达式怎么用啊

建议自己查J2SE 的 API java.util.regex Pattern
×××××××××××××××××××××××××××××××××××××××××××××
我给你贴出来
×××××××××××××××××××××××××××××××××××××××××××××

public final class Patternextends Objectimplements Serializable正则表达式的编译表示形式。

指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

因此，典型的调用顺序是

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();在仅使用一次正则表达式时，可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句

boolean b = Pattern.matches("a*b", "aaaaab");等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。
此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。

正则表达式的构造摘要
构造 匹配

字符
x 字符 x
\\ 反斜线字符
\0n 带有八进制值 0 的字符 n (0 <= n <= 7)
\0nn 带有八进制值 0 的字符 nn (0 <= n <= 7)
\0mnn 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh 带有十六进制值 0x 的字符 hh
\uhhhh 带有十六进制值 0x 的字符 hhhh
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A')
\r 回车符 ('\u000D')
\f 换页符 ('\u000C')
\a 报警 (bell) 符 ('\u0007')
\e 转义符 ('\u001B')
\cx 对应于 x 的控制符

字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）

预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

POSIX 字符类（仅 US-ASCII）
\p{Lower} 小写字母字符：[a-z]
\p{Upper} 大写字母字符：[A-Z]
\p{ASCII} 所有 ASCII：[\x00-\x7F]
\p{Alpha} 字母字符：[\p{Lower}\p{Upper}]
\p{Digit} 十进制数字：[0-9]
\p{Alnum} 字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct} 标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} 可见字符：[\p{Alnum}\p{Punct}]
\p{Print} 可打印字符：[\p{Graph}\x20]
\p{Blank} 空格或制表符：[ \t]
\p{Cntrl} 控制字符：[\x00-\x1F\x7F]
\p{XDigit} 十六进制数字：[0-9a-fA-F]
\p{Space} 空白字符：[ \t\n\x0B\f\r]

java.lang.Character 类（简单的 java 字符类型）
\p{javaLowerCase} 等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase} 等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace} 等效于 java.lang.Character.isWhitespace()
\p{javaMirrored} 等效于 java.lang.Character.isMirrored()

Unicode 块和类别的类
\p{InGreek} Greek 块（简单块）中的字符
\p{Lu} 大写字母（简单类别）
\p{Sc} 货币符号
\P{InGreek} 所有字符，Greek 块中的除外（否定）
[\p{L}&&[^\p{Lu}]] 所有字母，大写字母除外（减去）

边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾

Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

Reluctant 数量词
X?? X，一次或一次也没有
X*? X，零次或多次
X+? X，一次或多次
X{n}? X，恰好 n 次
X{n,}? X，至少 n 次
X{n,m}? X，至少 n 次，但是不超过 m 次

Possessive 数量词
X?+ X，一次或一次也没有
X*+ X，零次或多次
X++ X，一次或多次
X{n}+ X，恰好 n 次
X{n,}+ X，至少 n 次
X{n,m}+ X，至少 n 次，但是不超过 m 次

Logical 运算符
XY X 后跟 Y
X|Y X 或 Y
(X) X，作为捕获组

Back 引用
\n 任何匹配的 nth 捕获组

引用
\ Nothing，但是引用以下字符
\Q Nothing，但是引用所有字符，直到 \E
\E Nothing，但是结束从 \Q 开始的引用

特殊构造（非捕获）
(?:X) X，作为非捕获组
(?idmsux-idmsux) Nothing，但是将匹配标志由 on 转为 off
(?idmsux-idmsux:X) X，作为带有给定标志 on - off 的非捕获组
(?=X) X，通过零宽度的正 lookahead
(?!X) X，通过零宽度的负 lookahead
(?<=X) X，通过零宽度的正 lookbehind
(?<!X) X，通过零宽度的负 lookbehind
(?>X) X，作为独立的非捕获组

--------------------------------------------------------------------------------

反斜线、转义和引用
反斜线字符 ('\') 用于引用转义构造，如上表所定义的，同时还用于引用其他将被解释为非转义构造的字符。因此，表达式 \\ 与单个反斜线匹配，而 \{ 与左括号匹配。

在不表示转义构造的任何字母字符前使用反斜线都是错误的；它们是为将来扩展正则表达式语言保留的。可以在非字母字符前使用反斜线，不管该字符是否非转义构造的一部分。

根据 Java Language Specification 的要求，Java 源代码的字符串中的反斜线被解释为 Unicode 转义或其他字符转义。因此必须在字符串字面值中使用两个反斜线，表示正则表达式受到保护，不被 Java 字节码编译器解释。例如，当解释为正则表达式时，字符串字面值 "\b" 与单个退格字符匹配，而 "\\b" 与单词边界匹配。字符串字面值 "\(hello\)" 是非法的，将导致编译时错误；要与字符串 (hello) 匹配，必须使用字符串字面值 "\\(hello\\)"。

字符类
字符类可以出现在其他字符类中，并且可以包含并集运算符（隐式）和交集运算符 (&&)。并集运算符表示至少包含其某个操作数类中所有字符的类。交集运算符表示包含同时位于其两个操作数类中所有字符的类。

字符类运算符的优先级如下所示，按从最高到最低的顺序排列：

1 字面值转义 \x
2 分组 [...]
3 范围 a-z
4 并集 [a-e][i-u]
5 交集 [a-z&&[aeiou]]

注意，元字符的不同集合实际上位于字符类的内部，而非字符类的外部。例如，正则表达式 . 在字符类内部就失去了其特殊意义，而表达式 - 变成了形成元字符的范围。

行结束符
行结束符 是一个或两个字符的序列，标记输入字符序列的行结尾。以下代码被识别为行结束符：

新行（换行）符 ('\n')、
后面紧跟新行符的回车符 ("\r\n")、
单独的回车符 ('\r')、
下一行字符 ('\u0085')、
行分隔符 ('\u2028') 或
段落分隔符 ('\u2029)。
如果激活 UNIX_LINES 模式，则新行符是惟一识别的行结束符。

如果未指定 DOTALL 标志，则正则表达式 . 可以与任何字符（行结束符除外）匹配。

默认情况下，正则表达式 ^ 和 $ 忽略行结束符，仅分别与整个输入序列的开头和结尾匹配。如果激活 MULTILINE 模式，则 ^ 在输入的开头和行结束符之后（输入的结尾）才发生匹配。处于 MULTILINE 模式中时，$ 仅在行结束符之前或输入序列的结尾处匹配。

组和捕获
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：

1 ((A)(B(C)))
2 \A
3 (B(C))
4 (C)

组零始终代表整个表达式。

之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器检索。

与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串 "aba" 与表达式 (a(b)?)+ 相匹配，会将第二组设置为 "b"。在每个匹配的开头，所有捕获的输入都会被丢弃。

以 (?) 开头的组是纯的非捕获 组，它不捕获文本，也不针对组合计进行计数。

⑹ 做编译器有前途吗

有，只要你能做个能用编译器，那就是高级软件工程师了，大多数高级工程师都没这水平，其实做编译器根本没有意义，因为你做出来的不会有人用。。。只有大型软件公司诸如苹果，微软，intel推出新新型软硬件开发环境，或者用新语言包装开发组件的才会去做编译器，你是要去这些公司工作吗？？？？？？？普通人做的编译器根本无法推广，质量保证不了，还有就是非常麻烦，编译器是非常复杂的，最低也要精通目标环境的汇编，被编译的语言（可以自己开发新的，也可以沿用旧的诸如C++等），还有就是令人头疼的正则表达式，这些是最基本要求，这还牵扯不到编译原理。。。。。

⑺ 正则表达式

如果你曾经用过Perl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉这个术语，那么“正则表达式”（Regular Expression）就是一个字符构成的串，它定义了一个用来搜索匹配字符串的模式。
许多语言，包括Perl、PHP、Python、JavaScript和JScript，都支持用正则表达式处理文本，一些文本编辑器用正则表达式实现高级“搜索-替换”功能。那么Java又怎样呢？本文写作时，一个包含了用正则表达式进行文本处理的Java规范需求（Specification Request）已经得到认可，你可以期待在JDK的下一版本中看到它。
然而，如果现在就需要使用正则表达式，又该怎么办呢？你可以从Apache.org下载源代码开放的Jakarta-ORO库。本文接下来的内容先简要地介绍正则表达式的入门知识，然后以Jakarta-ORO API为例介绍如何使用正则表达式。
一、正则表达式基础知识
我们先从简单的开始。假设你要搜索一个包含字符“cat”的字符串，搜索用的正则表达式就是“cat”。如果搜索对大小写不敏感，单词“catalog”、“Catherine”、“sophisticated”都可以匹配。也就是说：

1.1 句点符号
假设你在玩英文拼字游戏，想要找出三个字母的单词，而且这些单词必须以“t”字母开头，以“n”字母结束。另外，假设有一本英文字典，你可以用正则表达式搜索它的全部内容。要构造出这个正则表达式，你可以使用一个通配符——句点符号“.”。这样，完整的表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配“t#n”、“tpn”甚至“t n”，还有其他许多无意义的组合。这是因为句点符号匹配所有字符，包括空格、Tab字符甚至换行符：

1.2 方括号符号
为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（“[]”）里面指定看来有意义的字符。此时，只有方括号里面指定的字符才参与匹配。也就是说，正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”。但“Toon”不匹配，因为在方括号之内你只能匹配单个字符：

1.3 “或”符号
如果除了上面匹配的所有单词之外，你还想要匹配“toon”，那么，你可以使用“|”操作符。“|”操作符的基本意义就是“或”运算。要匹配“toon”，使用“t(a|e|i|o|oo)n”正则表达式。这里不能使用方扩号，因为方括号只允许匹配单个字符；这里必须使用圆括号“()”。圆括号还可以用来分组，具体请参见后面介绍。

1.4 表示匹配次数的符号
表一显示了表示匹配次数的符号，这些符号用来确定紧靠该符号左边的符号出现的次数：

假设我们要在文本文件中搜索美国的社会安全号码。这个号码的格式是999-99-9999。用来匹配它的正则表达式如图一所示。在正则表达式中，连字符（“-”）有着特殊的意义，它表示一个范围，比如从0到9。因此，匹配社会安全号码中的连字符号时，它的前面要加上一个转义字符“\”。

图一：匹配所有123-12-1234形式的社会安全号码

假设进行搜索的时候，你希望连字符号可以出现，也可以不出现——即，999-99-9999和999999999都属于正确的格式。这时，你可以在连字符号后面加上“？”数量限定符号，如图二所示：

图二：匹配所有123-12-1234和123121234形式的社会安全号码

下面我们再来看另外一个例子。美国汽车牌照的一种格式是四个数字加上二个字母。它的正则表达式前面是数字部分“[0-9]{4}”，再加上字母部分“[A-Z]{2}”。图三显示了完整的正则表达式。

图三：匹配典型的美国汽车牌照号码，如8836KV

1.5 “否”符号
“^”符号称为“否”符号。如果用在方括号内，“^”表示不想要匹配的字符。例如，图四的正则表达式匹配所有单词，但以“X”字母开头的单词除外。

图四：匹配所有单词，但“X”开头的除外

1.6 圆括号和空白符号
假设要从格式为“June 26, 1951”的生日日期中提取出月份部分，用来匹配该日期的正则表达式可以如图五所示：

图五：匹配所有Moth DD,YYYY格式的日期

新出现的“\s”符号是空白符号，匹配所有的空白字符，包括Tab字符。如果字符串正确匹配，接下来如何提取出月份部分呢？只需在月份周围加上一个圆括号创建一个组，然后用ORO API（本文后面详细讨论）提取出它的值。修改后的正则表达式如图六所示：

图六：匹配所有Month DD,YYYY格式的日期，定义月份值为第一个组

1.7 其它符号
为简便起见，你可以使用一些为常见正则表达式创建的快捷符号。如表二所示：
表二：常用符号

例如，在前面社会安全号码的例子中，所有出现“[0-9]”的地方我们都可以使用“\d”。修改后的正则表达式如图七所示：

图七：匹配所有123-12-1234格式的社会安全号码

二、Jakarta-ORO库
有许多源代码开放的正则表达式库可供Java程序员使用，而且它们中的许多支持Perl 5兼容的正则表达式语法。我在这里选用的是Jakarta-ORO正则表达式库，它是最全面的正则表达式API之一，而且它与Perl 5正则表达式完全兼容。另外，它也是优化得最好的API之一。
Jakarta-ORO库以前叫做OROMatcher，Daniel Savarese大方地把它赠送给了Jakarta Project。你可以按照本文最后参考资源的说明下载它。
我首先将简要介绍使用Jakarta-ORO库时你必须创建和访问的对象，然后介绍如何使用Jakarta-ORO API。
▲ PatternCompiler对象
首先，创建一个Perl5Compiler类的实例，并把它赋值给PatternCompiler接口对象。Perl5Compiler是PatternCompiler接口的一个实现，允许你把正则表达式编译成用来匹配的Pattern对象。

▲ Pattern对象
要把正则表达式编译成Pattern对象，调用compiler对象的compile()方法，并在调用参数中指定正则表达式。例如，你可以按照下面这种方式编译正则表达式“t[aeio]n”：

默认情况下，编译器创建一个大小写敏感的模式（pattern）。因此，上面代码编译得到的模式只匹配“tin”、“tan”、 “ten”和“ton”，但不匹配“Tin”和“taN”。要创建一个大小写不敏感的模式，你应该在调用编译器的时候指定一个额外的参数：

创建好Pattern对象之后，你就可以通过PatternMatcher类用该Pattern对象进行模式匹配。
▲ PatternMatcher对象
PatternMatcher对象根据Pattern对象和字符串进行匹配检查。你要实例化一个Perl5Matcher类并把结果赋值给PatternMatcher接口。Perl5Matcher类是PatternMatcher接口的一个实现，它根据Perl 5正则表达式语法进行模式匹配：

使用PatternMatcher对象，你可以用多个方法进行匹配操作，这些方法的第一个参数都是需要根据正则表达式进行匹配的字符串：
· boolean matches(String input, Pattern pattern)：当输入字符串和正则表达式要精确匹配时使用。换句话说，正则表达式必须完整地描述输入字符串。
· boolean matchesPrefix(String input, Pattern pattern)：当正则表达式匹配输入字符串起始部分时使用。
· boolean contains(String input, Pattern pattern)：当正则表达式要匹配输入字符串的一部分时使用（即，它必须是一个子串）。
另外，在上面三个方法调用中，你还可以用PatternMatcherInput对象作为参数替代String对象；这时，你可以从字符串中最后一次匹配的位置开始继续进行匹配。当字符串可能有多个子串匹配给定的正则表达式时，用PatternMatcherInput对象作为参数就很有用了。用PatternMatcherInput对象作为参数替代String时，上述三个方法的语法如下：
· boolean matches(PatternMatcherInput input, Pattern pattern)
· boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)
· boolean contains(PatternMatcherInput input, Pattern pattern)
三、应用实例
下面我们来看看Jakarta-ORO库的一些应用实例。
3.1 日志文件处理
任务：分析一个Web服务器日志文件，确定每一个用户花在网站上的时间。在典型的BEA WebLogic日志文件中，日志记录的格式如下：

分析这个日志记录，可以发现，要从这个日志文件提取的内容有两项：IP地址和页面访问时间。你可以用分组符号（圆括号）从日志记录提取出IP地址和时间标记。
首先我们来看看IP地址。IP地址有4个字节构成，每一个字节的值在0到255之间，各个字节通过一个句点分隔。因此，IP地址中的每一个字节有至少一个、最多三个数字。图八显示了为IP地址编写的正则表达式：

图八：匹配IP地址

IP地址中的句点字符必须进行转义处理（前面加上“\”），因为IP地址中的句点具有它本来的含义，而不是采用正则表达式语法中的特殊含义。句点在正则表达式中的特殊含义本文前面已经介绍。
日志记录的时间部分由一对方括号包围。你可以按照如下思路提取出方括号里面的所有内容：首先搜索起始方括号字符（“[”），提取出所有不超过结束方括号字符（“]”）的内容，向前寻找直至找到结束方括号字符。图九显示了这部分的正则表达式。

图九：匹配至少一个字符，直至找到“]”

现在，把上述两个正则表达式加上分组符号（圆括号）后合并成单个表达式，这样就可以从日志记录提取出IP地址和时间。注意，为了匹配“- -”（但不提取它），正则表达式中间加入了“\s-\s-\s”。完整的正则表达式如图十所示。

图十：匹配IP地址和时间标记

现在正则表达式已经编写完毕，接下来可以编写使用正则表达式库的Java代码了。
为使用Jakarta-ORO库，首先创建正则表达式字符串和待分析的日志记录字符串：

这里使用的正则表达式与图十的正则表达式差不多完全相同，但有一点例外：在Java中，你必须对每一个向前的斜杠（“\”）进行转义处理。图十不是Java的表示形式，所以我们要在每个“\”前面加上一个“\”以免出现编译错误
回答者

⑻ 正则表达式中“@”的作用是什么

C#中的字符串,如正则表达式中,有可能出现一些与C#语言相同的字符,比如"\",会让编译器作罩纯为C#语言来识别,截没渗断该字符串,并可能产生编译器错误.
为了防止这种情况的发生,在该字符串前枯闷脊加一个"@"就是告诉编译器,这些特殊字符是作为字符串中的一部分存在的,编译器就不会去编译它了.
比如路径"c:\abc\d.txt"将产生编译器错误,之前可以写为"@c:\abc\d.txt"便得到其真实路径了.

这下明白了吧？

⑼ 就是linux下的vi和vim编译器比其它编译器有什么优势像gedit和kate

vi/vim这类CLI下的编辑器和gedit，kate这些GUI下的编译器是两个世界的东西，没有可比性。

CLI下的编辑器所共有的一个特点是纯键盘操作，因此对键盘操作有针对性的设计与优化，使得熟练掌握这些编辑器之后会拥有极致的效率。这样一来本身低效的鼠标操作就失去了存在的意义（CLI下本来也不能用鼠标）。
而GUI下的编译器则有着更丰富的操作模式，对新手更友好，学习曲线更平滑，展现的内容更丰富。

⑽ python正则表达式是什么呢

python正则表达式如下：

在python中，所谓的“正则表达式”指的是通常被用来检索、替换那些符合某个模式的一段文本。具体而言，它的作用是检测某个字符串是否符合规则和提取网页字符串中想要的数据。

正则表达式是对字符串提取的一套规则，我们把这个规则用正则里面的特定语法表达出来，去匹配满足这个规则的字符串。正则表达式具有通用型，不仅python里面可以用，其他的语言也一样适用。

python的编程特点：

速度快：Python的底层是用C语言写的，很多标准库和第三方库也都是用C写的，运行速度非常快。

免费、开源：Python是FLOSS（自由/开放源码软件）之一。使用者可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。

高层语言：用Python语言编写程序的时候无需考虑诸如如何管理你的程序使用的内存一类的底层细节。

解释性：一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。