正则表达式:Python 模块 re 简介

正则表达式简介
正则表达式(RegExp)是一种文本模式,包括普通字符(例如,a 到 z 之间的字母)和特殊字符(元字符)。
为了使文章更具可读性,本文将正则表达式冗长的 语法介绍 放在了文章的末尾。
运算符的优先级
正则表达式运算符的优先级顺序由高到低依次为:
转义符:\
括号和中括号:(),(?:),(?=), []
限定符:*,+,?,{n},{n,},{n,m}
定位点和序列:^,$,\元字符,字符
替换:|
字符具有高于替换运算符的优先级,使得 m|food 匹配 m 或 food。若要匹配 mood 或 food,请使用括号创建子表达式,即 (m|f)ood。
Raw String
正则表达式使用反斜杠 \ 来代表特殊形式或用作转义字符,这里跟 Python 的语法冲突,因此,Python 只好用 \\\\ 匹配 \,因为正则表达式中如果要匹配 \,需要用 \ 来转义,变成 \\,而 Python 语法中又需要对字符串中每一个 \ 进行转义,所以就变成了 \\\\。
为了使正则表达式具有更好的可读性,Python 特别设计了 Raw String。Raw String 以 r 作为字符串的前缀,如 r”\n” 表示字符 \ 和 n。
并非所有的正则表达式都需要使用 Raw String,但 compile 方法必须以 r 作为字符串的前缀;
对于其他方法(如 match、search 等 )而言,是否以 r 作为字符串的前缀并不影响结果。
re 模块简介
re 模块提供了 Perl 风格的正则表达式模式。Perl 5 对标准正则表达式增加了几个附加功能,re 模块也支持其中的大部分。

正则表达式对象

compile(RegExp [, flags]) 可以把正则表达式编译成一个正则表达式对象。其中,RegExp 为正则表达式,flags 为编译标志。

1
2
import re
html = re.compile(r"<\s*(\S+)(\s[^>]*)?>[\s\S]*<\s*/\1\s*>") # 匹配 HTML 标记(1)

编译标志
编译标志控制表达式的匹配方式。多个标志可以通过 | 来指定,如 re.I | re.M 被设置成 I 和 M 标志。
标志 含义
S 或 DOTALL 使 . 匹配包括换行在内的所有字符
I 或 IGNORECASE 使匹配对大小写不敏感
L 或 LOCALE 做本地化识别匹配
M 或 MULTILINE 多行匹配,影响 ^ 和 $
X 或 VERBOSE 提高正则表达式的可读性
X 标志的作用:
不在字符集中的空白字符将被忽略。这使得:dog | cat 和可读性差的 dog|cat 相同,但 [a b] 将匹配字符 a、b 或空格。
可以把注释放到正则表达式当中。注释从 # 开始到行末结束。

1
2
3
4
5
Xhtml = re.compile(r'''# 匹配 HTML 标记(2)
<\s*(\S+)(\s[^>]*)?>   # 开始标签
[\s\S]*                # 标签内的文本
<\s*/\1\s*>            # 同名结束标签
'''
, re.X)             # 同样匹配 HTML 标记,方法(2)的可读性比(1)高了很多。

执行匹配
方法 用途
match(RegExp, string [, flags]) 从字符串的开始匹配一个模式,成功则返回 MatchObject 实例,否则返回 None
search(RegExp, string [, flags]) 在整个字符串内查找模式匹配,成功则返回 MatchObject 实例,否则返回 None
findall(RegExp, string [, flags]) 获取所有匹配的子串,并把它们作为一个列表返回
finditer(RegExp, string [, flags]) 获取所有匹配的子串,并把它们作为一个迭代器返回
若已将正则表达式 RegExp 编译成了正则表达式对象 RegPat,还可以使用 RegPat.match(string) 执行匹配。

1
2
3
4
5
6
7
8
9
10
11
12
string = '''Hello World!
<ul class="nav">
    <li class="inactive"> 云 </li>
    <li class="inactive"> 大数据 </li>
</ul>
'''

match_1 = re.match("\s\S*",string)
match_2 = re.match("\S*",string)
search_1 = re.search("\s\S*",string)
search_2 = Xhtml.search(string)
print(match_1, "\n", match_2, end = "\n-------------\n ")
print(search_1, "\n", search_2)

Output:

1
2
3
4
5
None
 <_sre.SRE_Match object; span=(0, 5), match='Hello'>
-------------
 <_sre.SRE_Match object; span=(5, 12), match=' World!'>
 <_sre.SRE_Match object; span=(13, 99), match='<ul class="nav">\n\t<li class="inactive"> 云 </li>>

MatchObject 实例
方法 用途
group() 返回匹配的字符串
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个二元元组: (开始位置,结束位置)

1
print(search_2.group())

Output:

1
2
3
4
<ul class="nav">
    <li class="inactive"></li>
    <li class="inactive"> 大数据 </li>
</ul>

操作字符串
方法 用途
split(RegExp, string [, maxsplit = 0]) 将字符串在匹配的位置分片,并生成一个列表;若 maxsplit 非零,则只能得到 maxsplit 个分片
sub(RegExp, replacement, string[, count = 0]) 找到所有匹配的子串,并用其它的字符串替换;若 count 非零,则最多执行 count 次替换
subn(RegExp, replacement, string) 与 sub 类似,但返回二元元组:(新的字符串,执行替换的次数)

1
2
print(re.split("\n",string))                                 # 用回车符分片
print(re.sub("\t", lambda m: '[' + m.group() + ']', string)) # 将制表符用 [ ] 括起来

Output:

1
2
3
4
5
6
['Hello World!', '<ul class="nav">', '\t<li class="inactive"> 云 </li>', '\t<li class="inactive"> 大数据 </li>', '</ul>', '']
Hello World!
<ul class="nav">
[   ]<li class="inactive"></li>
[   ]<li class="inactive"> 大数据 </li>
</ul>

正则表达式的基本语法
\:将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如, n 匹配字符 n, \n 匹配 \n。序列 \\ 匹配 \ , \( 匹配 ( 。
^:匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^ 还会与 \n 或 \r 之后的位置匹配。
$:匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性,$ 还会与 \n 或 \r 之前的位置匹配。
*:零次或多次匹配前面的字符或子表达式。例如,zo* 匹配 z 和 zoo 。* 等效于 {0,}。
+:一次或多次匹配前面的字符或子表达式。例如, zo+ 与 zo 和 zoo 匹配,但与 z 不匹配。+ 等效于 {1,}。
?:零次或一次匹配前面的字符或子表达式。例如, do(es)? 匹配 do 或 does 中的 do 。? 等效于 {0,1}。
{n:n 是非负整数。正好匹配 n 次。例如, o{2} 与 Bob 中的 o 不匹配,但与 food 中的两个 o 匹配。
{n,}:n 是非负整数。至少匹配 n 次。例如, o{2,} 不匹配 Bob 中的 o ,而匹配 food 中的所有 o。 o{1,} 等效于 o+ 。 o{0,} 等效于 o* 。
{n,m}:M 和 n 是非负整数,其中 n <= m。匹配至少 n 次,至多 m 次。例如, o{1,3} 匹配 fooooood 中的头三个 o。o{0,1} 等效于 o?。 ?:当此字符紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时,匹配模式是非贪心的。非贪心的模式匹配搜索到的,尽可能短的字符串,而默认的贪心模式匹配搜索到的,尽可能长的字符串。例如,在字符串 oooo 中, o+? 只匹配单个 o,而 o+ 匹配所有 o。 .:匹配除 \n 之外的任何单个字符。若要匹配包括 \n 在内的任意字符,请使用诸如 [\s\S] 之类的模式。 (pattern):匹配 pattern 并捕获该匹配的子表达式。可以使用 \num 对捕获子表达式进行反向引用。括号 ( ) 使用 \( 或者 \) 匹配 。 (?:pattern):匹配 pattern 但不捕获该匹配的子表达式,即它是一个非捕获匹配,不存储供以后使用的匹配。这对于用 | 组合模式部件的情况很有用。例如,industr(?:y|ies) 是比 industry|industries 更经济的表达式。 (?=pattern):执行正向预测先行搜索的子表达式,该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,Windows (?=95|98|NT|2000) 匹配 Windows 2000 中的 Windows ,但不匹配 Windows 3.1 中的 Windows 。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。 (?!pattern):执行反向预测先行搜索的子表达式,该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,Windows (?!95|98|NT|2000) 匹配 Windows 3.1 中的 Windows ,但不匹配 Windows 2000 中的 Windows 。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。 x|y:匹配 x 或 y。例如,z|food 匹配 z 或 food 。(z|f)ood 匹配 zood 或 food 。 [xyz]:字符集。匹配包含的任一字符。例如, [abc] 匹配 plain 中的 a 。 [^xyz]:反向字符集。匹配未包含的任何字符。例如, [^abc] 匹配 plain 中的 p 。 [a-z]:字符范围。匹配指定范围内的任何字符。例如, [a-z] 匹配 a 到 z 范围内的任何小写字母。 [^a-z]:反向范围字符。匹配不在指定的范围内的任何字符。例如, [^a-z] 匹配任何不在 a 到 z 范围内的任何字符。 \b:匹配一个字边界,即字与空格间的位置。例如, er\b 匹配 never 中的 er ,但不匹配 verb 中的 er 。 \B:非字边界匹配。 er\B 匹配 verb 中的 er ,但不匹配 never 中的 er 。 \cx:匹配 x 指示的控制字符。例如,\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。否则假定 \c 就是 c 字符本身。 \d:数字字符匹配。等效于 [0-9]。 \D:非数字字符匹配。等效于 [^0-9]。 \f:换页符匹配。等效于 \x0c 和 \cL。 \n:换行符匹配。等效于 \x0a 和 \cJ。 \r:匹配一个回车符。等效于 \x0d 和 \cM。 \s:匹配任何空白字符,包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。 \S:匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。 \t:制表符匹配。与 \x09 和 \cI 等效。 \v:垂直制表符匹配。与 \x0b 和 \cK 等效。 \w:匹配任何字类字符,包括下划线。与 [A-Za-z0-9_] 等效。 \W:与任何非单词字符匹配。与 [^A-Za-z0-9_] 等效。 \xn:匹配 n,此处的 n 是一个十六进制转义码。十六进制转义码必须是两位数长。例如, \x41 匹配 A 。允许在正则表达式中使用 ASCII 代码。 \num:匹配 num,此处的 num 是第 num 个捕获子表达式的反向引用。例如, (.)\1 匹配两个连续的相同字符。 \n: 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式,那么是反向引用。如果 n 是八进制数 0-7,那么是八进制转义码。 \nm:标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式,那么是反向引用。如果 \nm 前面至少有 n 个捕获,则是反向引用,后面跟有字符 m。如果两种前面的情况都不存在,则 \nm 匹配八进制值 nm,其中 n 和 m 是八进制数 0-7。 \nml:当 n 是八进制数 0-3,m 和 l 是八进制数 0-7 时,匹配八进制转义码 nml。 \un:匹配 n,其中 n 是以四位十六进制数表示的 Unicode 字符。例如,\u00A9 匹配版权符号 ©。 来源:http://www.cnblogs.com/Pandaman/p/RegExp.html

CentOS/linux:如何查找目录下文件中是否包含指定字符串

在centos linux系统下查找文件中是否包含特定的行是经常会做的事情。那么如何来查看特定目录下的文件中是否包含特定的字符串呢?我们可以使用linux find命令来实现。
输入下面的命令:

1
find . | xargs grep -ri "IBM"

查找目录下的所有文件中是否含有某个字符串,并且只打印出文件名

1
find . | xargs grep -ril "IBM"

1.正则表达式
(1)正则表达式一般用来描述文本模式的特殊用法,由普通字符(例如字符a-z)以及特殊字符(称为元字符,如/、*、?等)组成。
(2)基本元字符集及其含义
^ :只匹配行首。 如^a 匹配以a开头的行abc,a2e,a12,aaa,……
$ :只匹配行尾。 如^a 匹配以a结尾的行bca,12a,aaa,…….
* :匹配0个或多个此单字符。 如(a)* 匹配 空,a,aa,aaa,….
[] :只匹配[]内字符。可以是一个单字符,也可以是字符序列,用”,”将里面要匹配的不同字符串分开。也可以使用-来表示[]内字符序列的范围,如[1-5]表示[12345]
\ :只用来屏蔽一个元字符的特殊含义。 如\*,\’,\”,\|,\+,\^,\. 等
.:(点)只匹配任意单字符。
pattern\{n\}:只用来匹配前面pattern出现的次数.n为次数。如a\{2\}匹配aa.
pattern\{n,\}:含义同上,但次数最少为n.如a\{2,\}匹配aa,aaa,aaaa,…..
pattern\{n,m\}:含义同上,但次数在n和m之间。如a\{2,4\}匹配aa,aaa,aaaa三个
(3)举例说明:
^$ :匹配空行
^.$ :匹配包含一个字符的行
\*\.pas :匹配以*.pas结尾的所有字符或文件
[0123456789]或[0-9] :假定要匹配任意一个数字
[a-z] :任意小写字母
[A-Za-z] :任意大小写字母
[S,s] :匹配大小写S
[0-9]\{3\}\.[0-9]\{3\}\.[0-9]\{3\}\.[0-9]\{3\} :匹配IP地址 [0-9]\{3\}三个0-9组成的字符串;\. :匹配点(注意这里点是特殊的字符,所以要用”\”来屏蔽其含义)
2.find介绍
(1)查找具有某些特征文件的命令,可遍历当前目录甚至于整个文件系统来查看某些文件或目录,其遍历大的文件系统时一般放在后台执行。
(2)find命令的一般形式
find pathname -options [-print -exec -ok]
-pathname :find命令所查找的目录路径。如用”.”来表示当前的目录,用/来表示系统根目录
-print :find命令将匹配的文件输出到标准输出
-exec: find命令对匹配的文件执行该参数所给出的shell命令,相应的命令形式为
‘command'{} \; (注意{}和\之间的空格)
-ok 和 -exec的作用相同,只不过以一种更为安全的模式来执行该参数所给出的shell命令,在执行每一个命令之前,都会给出提示,让用户来确定是否执行。
options有如下几种:
-name :按照文件名查找文件
-perm :按照文件权限来查找文件
-user :按照文件属主来查找文件
-group :按照文件所属的组来查找文件
-mtime -n +n 按照文件的更改时间来查找文件,-n表示文件更改时间距现在n天以内,+n表示文件更改时间距现在n天以前。find命令还有-atime 和-ctime选项,但它们都和-mtime选项相似。
-size n[c]查找文件长度为n块的文件,带有c时表示文件长度以字节计。
-nogroup 查找无有效所属组的文件,即该文件所属的组在/etc/groups中不存在
-newer file1 !file2查找更改时间比文件file1新但比文件file2旧的文件
-depth 先查找指定目录有无匹配文件,若无则再在子目录中查找
-type 查找某一类型的文件,如
b :块设备文件
d:目录
e:字符设备文件
p;管道文件
l:符号链接文件
f:普通文件
(3)find命令举例
find -name “*.txt” -print 查找txt结尾的文件并输出到屏幕上
find /cmd “.sh” -print 查找/cmd目录下所有sh文件,并输出
find . -perm 755 -print 查找当前目录下权限为755的文件,并输出
find `pwd` -user root -print 查找当前目录下属主为root的文件,并输出
find ./ -group sunwill -print 查找当前目录下所属主是sunwill的文件
find /var -mtime -5 -print 查找/var目录下更改时间为5天内的所有文件
find /var -mtime +5 -print 查找/var目录下更改时间为5天以前的所有文件
find /var -newer “myfile1” ! -newer “myfile2” -print 查找/var目录下比myfile1新,但是比myfile2旧的所有文件。
find /var -type d -print 查找/var目录下所有目录
find /var -type l -print 查找/var目录下所有的符号链接文件。
find . -size +1000000c -print 查找当前目录下大于1000000字节的文件
find / -name “con.file” -depth -print 查找根目录下有无”con.file”,若无则在其子目录中查找
find . -type f -exec ls -l {} \; 查找当前目录下是否有普通文件,若有则执行ls -l
(4)xargs命令
在 使用find命令的-exec选项处理匹配到的文件时,find命令将所有匹配到的文件一起传递给exec。不幸的是,有些系统对能够传递给exec的命 令长度有限制,这样find命令运行几分钟之后就算出现溢出错误。错误信息通常是“参数列太长”或“参数列溢出”。这就是xargs的用处所在,特别是与 find命令一起使用,exec会发起多个进程,而xargs会多个,只有一个
find ./ -perm -7 -print | xargs chmod o-w 查找权限为7的文件并传递给chmod处理
3.grep介绍
(1)grep 的一般格式为 grep [options] 基本正则表达式 [文件]
字符串参数最好采用是双引号括,一是以防被误解为shell命令,二是可以用来查找多个单词组成的字符串
-c:只输出匹配行的记数
-i:不区分大小写(只适用于单个字符)
-h:查询多个文件时不显示文件名
-H:只显示文件名
-l:查询多文件时只输出包含匹配字符的文件名
-n:只显示匹配行及其行号
-s:不显示不存在或无匹配文本的错误信息。
-v:显示不包含匹配文本的所有行。
(2)举例说明:
grep ^[^210] myfile 匹配myfile中以非2、1、0开头的行
grep “[5-8][6-9][0-3]” myfile 匹配myfile中第一位为5|6|7|8,第二位6|7|8|9,第三位为0|1|2|3的三个字符的行
grep “4\{2,4\}” myfile 匹配myfile中含有44,444或4444的行
grep “\?” myfile匹配myfile中含有任意字符的行
(3)grep命令类名
[[:upper:]] 表示[A-Z]
[[:alnum:]] 表示[0-9a-zA-Z]
[[:lower:]] 表示[a-z]
[[:space:]] 表示空格或者tab键
[[:digit:]] 表示[0-9]
[[:alpha:]] 表示[a-zA-Z]
如:grep “5[[:digit:]][[:digit:]]” myfile 匹配myfile中含有5开头接下去两位都是数字的行。
4.awk介绍
可以从文件或字符串中基于指定规则浏览和抽取信息,是一种自解释的变成语言。
(1)awk命令行方式 awk [-F filed-spearator] ‘command’ input-files
awk脚本:所有awk命令插入一个文件,并使awk程序可执行,然后用awk命令解释器作为脚本的首行,以便通过键入脚本名称来调用它。awk脚本是由各种操作和模式组成。
模式部分决定动作语句何时触发及触发事件。(BEGIN,END)
动作对数据进行处理,放在{}内指明(print)
(2)分隔符、域和记录
awk执行时,其浏览域标记为$1,$2,…$n.这种方法成为域标识。$0为所有域。
(3)举例说明:
awk ‘{print $0}’ test.txt |tee test.out 输出test.txt中所有行$0表示所有域
awk -F : ‘{print $1} test.txt |tee test.out’ 同上。。只是分隔符为”:”
awk ‘BEGIN {print “IPDate\n”}{print $1 “\t” $4} END{print “end-of-report”}’ test.txt
开始时打印“IPDate”结束时打印“end-of-report”中间打印主体信息,比如总共匹配三条信息,则输出如下:

1
2
3
4
5
IPDate
1 first
2 second
3 third
end-of-report

(4)匹配操作符 ~ 匹配,!~ 不匹配
cat test.txt |awk ‘$0~/210.34.0.13/’ 匹配test.txt中为210.34.0.13的行
awk ‘$0!~/210.34.0.13’ test.txt 匹配test.txt中不是210.34.0.13的行
awk ‘{if($1==”210.34.0.13″) print $0}’ test.txt 匹配 test.txt中第一个域为210.34.0.13的行。
5.sed介绍
sed不与初始化文件打交道,它操作的只是一个拷贝,然后所有的改动如果没有重定向到一个文件,将输出到屏幕。
sed是一种很重要的文本过滤工具,使用一行命令或者使用管道与grep与awk相结合。是一种非交互性文本流编辑。
(1)调用sed的三种方式
使用sed命令行格式为:sed [options] sed命令 输入文件
使用sed脚本文件格式为:sed[options] -f sed脚本文件 输入文件
sed脚本文件[options] 输入文件
–不管是使用shell命令行方式或脚本文件方式,如果没有指定输入文件,sed从标准输入中接受输入,一般是键盘或重定向结果。
(2)sed 命令的options如下
-n:不打印
-c:下一命令是编辑命令
-f:如果正在调用sed脚本文件
(3)sed在文件中查询文本的方式
–使用行号,可以是一个简单的数字,或是一个行号的范围
–使用正则表达式
(4)读取文本的方式
x x为一行号
x,y 表示行号范围从x到y
/pattern/ 查询包含模式的行
/pattern/pattern/ 查询包含两个模式的行
pattern/,x 在给定的行号上查询包含模式的行
x,/pattern/ 通过行号和模式查询匹配行
x,y! 查询不包含指定行号x和y的行
(5)基本sed编辑命令
p 打印匹配行
d 删除匹配行
= 显示文件行号
a\ 在定位行号后附加新文本信息
i\ 在定位行号后插入新文本信息
c\ 用新文本替换定位文本
s 使用替换模式替换相应模式
r 从另一个文件中读文件
w 写文本到一个文件
q 第一个模式匹配完成后推出或立即退出
l 显示与八禁止ASCII代码等价的控制字符
{} 在定位行执行的命令组
n 从另一个文件中读文本下一行,并附加在下一行
g 将模式2粘贴到/pattern n/
y 传送字符
(6)举例说明:
sed -n ‘2p’ test.txt 打印第二行的信息(注意:-n是不打印不匹配的信息,若没加-n,则打印文件的所有信息而不是匹配信息)
sed -n ‘1,4p’ test.txt 打印第一行到第四行的信息
sed -n ‘/los/p’ test.txt模式匹配los,并打印出来
sed -n ‘2,/los/p’ test.txt 从第二行开始。。知道匹配第一个los
sed -n ‘/^$/p’ test.txt 匹配空行
sed -n -e ‘/^$/p’ -e ‘/^$/=’ test.txt 打印空行及行号
sed -n ‘/good/a\morning’ test.txt 在匹配到的good后面附加morning
sed -n ‘/good/i\morning’ test.txt 在匹配到的good前面插入morning
sed -n ‘/good/c\morning’ test.txt 将匹配到的good替换成morning
sed ‘1,2d’ test.txt 删除第1和2行
sed ‘s/good/good morning/g’ test.txt 匹配good并替换成goodmorning
send ‘s/good/& hello /p’ test.txt 匹配到good就在其后面加上hello
send ‘s/good/ hello &/p’ test.txt 匹配到good就在其前面加上hello
6.合并与分割(sort,uniq,join,cut,paste,split)
(1)sot命令
sort [options] files 许多不同的域按不同的列顺序排序
-c 测试文件是否已经排序
-m 合并两个排序文件
-u 删除所有同样行
-o 存储sort结果的输出文件名
-t 域分隔符,用非空格或tab开始排序
+n :n 为列号,使用此列号开始排序
-n 指定排序是域上的数字分类项
-r 比较求逆
sort -c test.txt 测试文件是否分类过
sort -u test.txt 排序并合并一样的行
sort -r test.txt 以相反的顺序排列
sort -t “/” +2 test.txt 以”/”分隔,第二个域开始分类
(2)uniq命令
uniq [options ] files 从一个文本文件中去除或禁止重复行
-u 只显示不重复行
-d 只显示有重复数据行,每种重复行只显示其中一行
-c 打印每一重复行出现次数
-f :n为数字,前n个域被忽略
uniq -f 2 test.txt 忽略前2个域
(3)join 命令
join [options] file1 file2 用来将来自两个分类文本文件的行连在一起
-an,n为一数字,用于连接时从文件n中显示不匹配行
-onm ,连接域,n为文件号,m为域号
-jnm,n为文件号,m为域号,使用其他域作连接域
-t ,域分隔符。用来设置非空格或tab键的域分隔符。
(4)split命令
split -output_file_size intput_filename output_filename
用来将大文件分割成小文件。
-b n,每个分割文件的大小n
-C n,每个分割文件一行最多n字节
-l n,每个分割文件的行数
-n,同-l n
split -10 test.txt 将test.txt分割成10行的小文件
(5)cut 命令
cut -c n1-n2 filename 显示每行从开头算起 n1 到 n2 的文字。
cut -c 3-5 test.txt 显示test.txt中每行从第3到第5个字符
原文 92csz.com

Grep正则表达式:如何查找某个特定的IP地址

下面会举几个在grep命令中使用正则表达式从一个文件中匹配到特定的IP地址。下面的正则表达式将会匹配IPV4的地址。
正则表达式匹配IP地址:
使用下面的正则表达式来匹配IPV4的地址,先来匹配从0.0.0.0到999.999.999.999的模式。

1
"([0-9]{1,3}[\.]){3}[0-9]{1,3}"

示例:使用grep命令来查找匹配特定的地址

1
2
3
4
5
$ grep -E -o "([0-9]{1,3}[\.]){3}[0-9]{1,3}" filename
[root@devops ~]# echo 000.333.222.444 &gt;test1
[root@devops ~]#
[root@devops ~]# grep -E -o "([0-9]{1,3}[\.]){3}[0-9]{1,3}" test1
000.333.222.444

上面的正则表达只是简单的匹配了特定的类似于ip地址的传,但它不能匹配真正的IPv4地址。可以通过下面的正则表达式来匹配.

1
2
"(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"

通过grep命令匹配文件中的IPv4地址

1
2
3
4
5
6
7
[root@devops ~]# grep -E -o "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-
4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)" test1
[root@devops ~]# echo 192.168.1.234 &gt; test1
[root@devops ~]# grep -E -o "
(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-
4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)" test1
192.168.1.234
[root@devops ~]

#
其中:-E选项表示使用grep扩展的正则表达式
-o选项是只显示匹配到的字符串
前面的文章里有更多的关于grep中正则表达式的用法。

Grep:如何在linux下使用grep命令

在linux/unix下,我们是怎么使用grep命令的呢?什么是grep呢?我们能用grep命令来干些什么呢?下面我们来分析:
grep命令是在文件中全局查找指定的正则表达式,并且打印所有包含该表达式的行。egrep命令是扩展的grep,支持更多的正则表达式元字符。自由软件基金会提供了grep的免费版本,称作GNU grep,在linux系统上默认安装就是这个免费版本。
grep命令参数

1
2
3
4
5
6
grep 'word' 文件名
grep 'word' 文件1 文件2 文件3 ...文件N
grep ‘字符串1 字符串2’ 文件名
cat 文件名| grep ”字符串“
命令 | grep "字符串"
grep --color "字符串" 文件名

如何使用grep命令去搜索某个文件中的内容呢?
查找 /etc/passwd 文件中是否存在user1这个用户,可以使用下面的命令:

1
2
3
[root@devops ~]# grep user1 /etc/passwd
user1:x:501:501::/home/user1:/bin/bash
[root@devops ~]#

如果想忽略大小写去查找比如:User1,USER1或者其它的组合,可以使用-i选项

1
2
3
4
[root@devops ~]# grep -i user1 /etc/passwd
user1:x:501:501::/home/user1:/bin/bash
USER1:x:502:502::/home/USER1:/bin/bash
[root@devops ~]#

grep 命令递归查找
你可以递归去查找某个目录下各级子目录里的匹配查找模式的行,使用-r 选项

1
2
3
4
5
6
7
8
9
10
11
[root@devops ~]# grep -r user1 /etc | more
/etc/group-:user1:x:501:
/etc/shadow:user1:!!:16176:0:99999:7:::
/etc/group:user1:x:501:
/etc/passwd-:user1:x:501:501::/home/user1:/bin/bash
/etc/gshadow-:user1:!::
/etc/shadow-:user1:!!:16176:0:99999:7:::
/etc/passwd:user1:x:501:501::/home/user1:/bin/bash
/etc/gshadow:user1:!::
/etc/postfix/virtual:# user1@virtual-alias.domain address1
[root@devops ~]#

使用grep去匹配某一个单词
选项-w使grep命令只查找作为一个词,而不是词的一部分去做匹配
举例说明:

1
2
3
4
5
[root@devops ~]# grep user1 /etc/passwd
user1:x:501:501::/home/user1:/bin/bash
user1add:x:503:503::/home/user1add:/bin/bash
[root@devops ~]# grep -w 'user1' /etc/passwd
user1:x:501:501::/home/user1:/bin/bash

在本例中能够匹配“user1″的模式有两行,那么当你只想匹配一个完整的user1这个单词的时候,可以使用-w选项。
使用grep命令去查找2个不同的词

1
2
3
4
[root@devops ~]# egrep -w "user1|USER1" /etc/passwd
user1:x:501:501::/home/user1:/bin/bash
USER1:x:502:502::/home/USER1:/bin/bash
[root@devops ~]#

统计grep查找出来的行数
grep命令可以使用-c选项来显示出匹配到的行数

1
2
[root@devops ~]# grep -c 'user1' /etc/passwd
2

使用-n 选项可以显示出查找到的行在文件中的行号

1
2
3
[root@devops ~]# grep -n 'user1' /etc/passwd
23:user1:x:501:501::/home/user1:/bin/bash
25:user1add:x:503:503::/home/user1add:/bin/bash

grep反向查找只显示不匹配的行
你可以使用-v 选项来显示不匹配的行,例如:

1
2
3
4
5
6
7
[root@devops ~]# grep -v user1 /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync

linux 管道符和grep命令的搭配使用
grep命令经常会和linux或unix管道符搭配使用,如显示硬盘设备的名字:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[root@devops ~]# dmesg | egrep '(s|h)d[a-z]'
NMI watchdog disabled (cpu0): hardware events not enabled
sd 2:0:0:0: [sda] 41943040 512-byte logical blocks: (21.4 GB/20.0 GiB)
sd 2:0:0:0: [sda] Write Protect is off
sd 2:0:0:0: [sda] Mode Sense: 61 00 00 00
sd 2:0:0:0: [sda] Cache data unavailable
sd 2:0:0:0: [sda] Assuming drive cache: write through
sd 2:0:0:0: [sda] Cache data unavailable
sd 2:0:0:0: [sda] Assuming drive cache: write through
sda: sda1 sda2
sd 2:0:0:0: [sda] Cache data unavailable
sd 2:0:0:0: [sda] Assuming drive cache: write through
sd 2:0:0:0: [sda] Attached SCSI disk
dracut: Scanning devices sda2 for LVM logical volumes vg_devops/lv_root vg_devops/lv_swap
EXT4-fs (sda1): mounted filesystem with ordered data mode. Opts:
SELinux: initialized (dev sda1, type ext4), uses xattr

显示cpu模块名字:

1
2
3
4
[root@devops ~]# cat /proc/cpuinfo | grep -i 'Model'
model : 42
model name : Intel(R) Core(TM) i3-2350M CPU @ 2.30GHz
[root@devops ~]#

如何只输出包含模式的文件名,而不是输出文本行

1
2
3
4
5
6
7
8
9
[root@devops ~]# grep -l 'user1' /etc/*
/etc/group
/etc/group-
/etc/gshadow
/etc/gshadow-
/etc/passwd
/etc/passwd-
/etc/shadow
/etc/shadow-

Grep命令中正则表达式(regular Expressions,RE)的用法

当你在使用grep命令的时候肯定会用到正则表达式,那么怎么在grep命令中使用正则表达式呢?
正则表达式元字符
grep命令支持很多正则表达式的元字符,以使用户能够更精准的定义要查找的模式。例如,可以通过制定的选项来关闭大小写敏感,要求显示行号等。

元字符 功能 示例 匹配对象
^ 行首定位符 ‘^user’ 匹配所有以user开头的行
$ 行尾定位符 ’user$’ 匹配所以以user结尾的行
匹配一个字符 ‘u.r’ 匹配包含一个u,后跟一个字符,再跟一个r的行
* 匹配两个或多个前导字符 ’u*ser’ 匹配包含零个或多个u后,跟ser模式的行
[] 匹配一组字符中的人一个 ‘[uU]ser’ 匹配包含user或者User的行
[^] 匹配不在指定字符组里的字符 ’[^A-S]ser‘ 匹配一个不在A到S之间的字符,并且该字符后紧跟着ser的行
\< 词首定位符 ’\<user‘ 匹配包含以user开头的词的行
\> 词尾定位符 ’user\>‘ 匹配包含以user结尾的词的行
\<..\> 标记匹配到的字符 ’\<user\>’ 匹配包含<user>的行
{M}{M,}{M,N} 匹配重复出现的次数M次匹配出现的次数至少M次
匹配出现的次数至少M次,但不超过N次
‘u\{4\}u\{5\}
u\{5,8\}’
匹配连续出现4个u的行匹配连续出现最少5个u的行
匹配连续出现最少5个,最多8个u的行

 
grep 正则表达式示例:
在/etc/passwd 里查找包含“user1“字符串的行

[root@devops ~]# grep user1 /etc/passwd
user1:x:502:503::/home/user1:/bin/bash

如果想忽略大小写的区做搜索可以使用-i选项

#grep  user1 /etc/passwd

你可以使用”.”元字符为一个单个的字符做匹配,例如我们可以使用下面的命令去匹配一个以”u”开头,以“r”结尾,中间是任意一个字符的行

[root@devops ~]# grep '\<u.r\>' /etc/passwd
game:x:12:100:games:/usr/games:/sbin/nologin

如何在grep正则表达式中准确的匹配所有包含两个字符的行?

[root@devops ~]# grep '^..$' /