编程基础---不同软件中的字符串操作

字符串长度计算

软件：mysql
函数：LENGTH(str)
解释：一个汉字算3个字符，一个数字或字母算一个字符
例子：SELECT LENGTH('12三')
结果： 5

软件：mysql
函数：CHAR_LENGTH(str)
解释：一个汉字算3个字符，一个数字或字母算一个字符
例子：SELECT CHAR_LENGTH('12三')
结果： 3

字符串截取

软件：mysql
函数：left(str,length)
解释：从左往右截取length个字符
例子：SELECT left('12三字符',3)
结果： 12三

软件：mysql
函数：right(str,length)
解释：从右往左截取length个字符
例子：SELECT right('12三字符',3)
结果： 三字符

软件：mysql
函数：substr(str,pos)
解释：从字符串的第pos个字符开始截取,没有第三人参数就是截到末尾
例子：SELECT substr('12三字符',3)
结果： 三字符

软件：mysql
函数：substr(str,pos,length)
解释：从字符串的第pos个字符开始截取,共截length个字符,如果长度很大,则截取到末尾,length可以是负数,-n表示倒数第n个开始,往后截取,可以达到right的效果
例子：SELECT substr('12三字符',3,2);SELECT substr('12三字符',-2,2)
结果： 三字;字符

软件：mysql
函数：substring_index(str,delim,count)
解释：用分隔符delim将字符串截成几段,选出前count段,count也可以是负数,表示从倒数第几个开始
例子：SELECT substring_index('12.三字.符','.',2);
结果： 12.三字;三字.符

软件：python
函数：利用索引取字符串
解释：将原字符串中每个字符当作列表中的一个元素，然后按列表取数的方法
例子：
s = 'i love  python'
#截取一段
print(s[1:5])#结果为' lov'
#-1对应最后一位，由于python中索引取头不取尾，故取到除最后一位之外的其他其他字符
print(s[:-1])#结果为'i love  pytho'
#获得全部字符
print(s[:])#结果为'i love  python'
#逆序取字符串
print(s[::-1])#结果为'nohtyp  evol i'
#逆序取一部分字符串，注意尽管是逆序，下面的-5仍然是右端，右端不包括在结果索引里。
print(s[:-5:-1])#结果为'noht'

字符串拆分

软件：python
函数：split()
解释：加参数时，以参数作为分隔符，如果分隔符两侧没有内容，则会分割出一个空字符串，如果分隔符之间空格，则空格也是字符串的一部分，注意空字符串与空格是不一样的；不加参数时，以空格作为分隔符，由于分隔符本身是不会作为拆分后的内容的，所以不管中间有几个空格，都可以作为一个空格看，最终得到空格两侧的字符串，而不会得到空字符串；
例子1：
st0= 'i i  song   iiihuaniiiigongi'
print(st0.split('i'))
结果： ['', ' ', '  song   ', '', '', 'huan', '', '', '', 'gong', '']
例子2：
st0= ' song  huan   gong    '
print(st0.split())
结果： ['song', 'huan', 'gong']

字符串拼接

软件：mysql
函数：concat(string1,string2,…)
解释：string1,string2表示要连接的字符串，只要其中一个为null,最后的结果就为null
例子：SELECT concat('12','三字','符');
结果： 12三字符

去除首尾空字符

Python strip()方法
python中strip()，lstrip()，rstrip()函数的讲解

判断字符串是否包含子字符串

python 判断字符串是否包含子字符串

python字符串的格式化

更完整的可参考：python基础_格式化输出（%用法和format用法）
Python format 格式化函数
虽然下面都是介绍占位符，但是format不用记忆不同的占位符，而可进行的操作更丰富，这里作一个规范，python字符串操作均使用format形式。Python 字符串 .format 方法详解

软件：python
函数：var='str1%dstr3%dstr5'%(num2,num4)
解释：上式中''内部的内容即为拼接后的字符串,%d相当于占位符,表示这个地方有个数值类型的变量将转换为字符串,并拼接进来,与其对应的内容由紧跟在%后的括号中的变量给出。这里%d也可以是其他类型如%s
例子：
website = 'www.%s%s%s' % ('python', 'tab', '.com')
print(website)
结果： www.pythontab.com
python还有另外两种字符串接近方式，但这种方法是效率最高的。

Python格式化字符 %s %d %f

格式 描述
%% 百分号标记 #就是输出一个%
%c 字符及其ASCII码
%s 字符串
%d 有符号整数(十进制)
%u 无符号整数(十进制)
%o 无符号整数(八进制)
%x 无符号整数(十六进制)
%X 无符号整数(十六进制大写字符)
%e 浮点数字(科学计数法)
%E 浮点数字(科学计数法，用E代替e)
%f 浮点数字(用小数点符号)
%g 浮点数字(根据值的大小采用%e或%f)
%G 浮点数字(类似于%g)
%p 指针(用十六进制打印值的内存地址)
%n 存储输出字符的数量放进参数列表的下一个变量中
        
%格式化符也可用于字典，可用%(name)引用字典中的元素进行格式化输出。
        
负号指时数字应该是左对齐的，“0”告诉Python用前导0填充数字，正号指时数字总是显示它的正负(+，-)符号，即使数字是正数也不例外。
        
可指定最小的字段宽度，如："%5d" % 2。也可用句点符指定附加的精度，如："%.3d" % 3。

e.g.
# 例：数字格式化
nYear = 2018
nMonth = 8
nDay = 18
# 格式化日期 %02d数字转成两位整型缺位填0
print '%04d-%02d-%02d'%(nYear,nMonth,nDay)
>> 2018-08-18 # 输出结果

fValue = 8.123
print '%06.2f'%fValue # 保留宽度为6的2位小数浮点型
>> 008.12 # 输出

print '%d'%10 # 输出十进制
>> 10
print '%o'%10 # 输出八进制
>> 12
print '%02x'%10 # 输出两位十六进制，字母小写空缺补零
>> 0a
print '%04X'%10 # 输出四位十六进制，字母大写空缺补零
>> 000A
print '%.2e'%1.2888 # 以科学计数法输出浮点型保留2位小数
>> 1.29e+00

格式化操作符辅助指令
符号 作用
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
<sp> 在正数前面显示空格
# 在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于
          用的是'x'还是'X')
0 显示的数字前面填充‘0’而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

python中使用%s等进行字符串拼接时，如果出现如下错误：
“ValueError: unsupported format character ‘Y’ (0x59) at index 70”
产生原因:因为python执行的sql中存在类似DATE_FORMAT(MAX(CREATE_TIME), ‘%Y-%m-%d’) 的写法,
其中%Y与python的参数%s冲突

解决方法:将DATE_FORMAT(MAX(CREATE_TIME), ‘%Y-%m-%d’) 修改为DATE_FORMAT(MAX(CREATE_TIME), ‘%%Y-%%m-%%d’) 即可

软件：python
函数：'sep'.join(list)
解释：上式中sep表示分隔符，可以为空，则没有分隔符；list表示一个元素为字符串的列表，列表里面的元素就是我们要拼接的字符串
例子：
binfo = ['lao','wang','python']
content = ",".join(binfo)
print content
结果： lao,wang,python

软件：mysql
函数：concat_ws(separator,string1,string2,…)
解释：利用分隔符将字符串拼接起来，ws表示with separator,separator为字符中之间的分隔符,如果分隔符为null，则结果也为null
例子：SELECT concat_ws('.','12','三字','符');
结果： 12.三字.符

软件：mysql
函数：group_concat([distinct] 要连接的字段 [order by 排序字段] separator '分隔符')
解释：后面一定是跟着一个group byr ,group_concat将组内的要连接的字段的元素拼接在一起，其他元素只会选择组的其中一个（这个是由group by函数决定的）
例子：假设
select * from stu1;
+------+------+
| id| name |
+------+------+
|1 | 10|
|1 | 20|
|1 | 20|
|2 | 20|
|3 | 200   |
|3 | 500   |
+------+------+
select id,group_concat(name) from aa group by id;
结果： 
+------+--------------------+
| id| group_concat(name) |
+------+--------------------+
|1 | 10,20,20|
|2 | 20 |
|3 | 200,500|
+------+--------------------+

软件：java
函数：+
解释：在JDK1.5之后，编译时jvm会自动将+号替换为StringBuilder的append方法;在做字符串连接时，String类的concat方法优于+号。
例子：
    String str1 = "tom";  
    String str2 = "cat";  
    String str5 = str1 + str2;  
结果： tomcat
虽然+与其他方式效率差别不大，但是如果是循环拼接，最好还是用StringBuilder的append方法，如下：

public void explicitUseStringBuider(String[] values) {
  StringBuilder result = new StringBuilder();
  for (int i = 0; i < values.length; i ++) {
      result.append(values[i]);
  }
}

字符串比较

软件：mysql
函数：string1=string2
解释：相等返回1，否则返回0
例子：select 'abc'='bc';
结果： 0；
但是如果不小心取字段里出现字符串与数字比较，那么mysql会自动将字符串转换成数字再比较
例子：select '03abc2'=3;
结果： 1；截取字符串前面的非0数字了
例子：select '030abc2'=3;
结果： 0；
例子：select 'abc'=0;
结果： 1；对于开头部分不能截取出数字的字符串来说，转换的结果自然就是0了。

更多比较请查询官网

字符替换

软件：mysql
函数：REPLACE(str,from_str,to_str)
解释：str表示被替换的字符串或字段名,from_str表示被替换的字符，to_str表示替换的字符
例子：SELECT REPLACE('12三字符','三字','替换');
结果： 12替换符

软件：mysql
函数：REPLACE INTO table (id,name) values('1','aa'),('2','bb') 
解释：此语句的作用是向表table中插入两条记录。如果主键id为1或2不存在就相当于
insert into table (id,name) values('1','aa'),('2','bb')
如果存在相同的值则不会插入数据 

软件：python
函数：'字符串'.replace('被替换','替换') 
解释：
例子：
a = 'hello word'
print(a.replace('word','python'))
结果：
hello python

字符串类型与bytes类型互为转换及转码问题

软件：python
函数：bytes()、decode()和str()
解释：
例子：
str0 = 'abc'
a = bytes(str0, 'utf-8')
print(type(str0), str0)
print(type(a), a)
print('-----------------------')
print(a.decode('utf-8'))#利用decode()函数直接将bytes类型转换为字符串
print('-----------------------')
c = bytes([97, 98, 99, 100])#利用bytes函数进行部分解码
print(type(c), c)
str1 = str(c, "utf-8")#利用str函数将bytes类型数据直接转换为字符串
print(type(str1), str1)
结果：
<class 'str'> abc
<class 'bytes'> b'abc'
-----------------------
abc
-----------------------
<class 'bytes'> b'abcd'
<class 'str'> abcd

实现上的转码过程可能更复杂。比如给出一个16进制字符串，aa=‘654C756F4875286672656529’,需要将其转换成原始的字符串。
首先我们需要知道原本的编码方式，比如每人字符被编码成2位16进行数。这样我们就可以对上述字符串以两位两位来进行分割，并解码。过程如下：

bb='374744'
def HexStr2Unicode(Hex_Str):
    Unicde_Str = ""
    for i in range(0, len(Hex_Str) // 2):
        chr(int(Hex_Str[i * 2:i * 2 + 2], 16))
        Unicde_Str += chr(int(Hex_Str[i * 2:i * 2 + 2], 16))
    return Unicde_Str
print(HexStr2Unicode(bb))

得到的结果为

7GD

其他情况类似。更详细的情况可参考该文

Python 字符串前面加u,r,b,f的含义

正则表达式 - 教程

漫画：如何优化 “字符串匹配算法”？

正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。

正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。

正则表达式是繁琐的，但它是强大的，学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。只要认真阅读本教程，加上应用的时候进行一定的参考，掌握正则表达式不是问题。

许多程序设计语言都支持利用正则表达式进行字符串操作。

正则表达式 - 简介

最主要有不同语言正则表达式的对比

实例

匹配以数字开头，并以 abc 结尾的字符串。：

var str = "123abc";
var patt1 = /^[0-9]+abc$/;
document.write(str.match(patt1));

以下标记的文本是获得的匹配的表达式：
123abc
文中的正则表达不够严谨，可改为如下

var str = "123abc";
var patt1 = /^[0-9].*abc$/;
document.write(str.match(patt1));

正则表达式 - 元字符

()是子表达式，具有较高运算优先级
[]是字符簇，可用来表示字符范围
{}表达重复次数，是一个限定符
终于搞懂了回车与换行的区别

正则表达式 - 匹配规则

正则表达式 - 运算符优先级

正则表达式 - 语法

正则表达式 - 示例

正则表达式在线测试

在线正则表达式测试

mysql中正则表达式

项目	功能	说明
标准SQL模式匹配	使用LIKE或NOT LIKE，而不能使用=或！=	mysql提供标准的SQL模式匹配，以及基于像linux实用程序vi,grep,sed的正则表达式模式匹配，在mysql中模式默认忽略大小写
“_”	匹配任何单个字符
“%”	匹配任意数目字符，包括零字符
扩展正则表达式	REGEXP或NOT REGEXP或RLIKE或NOT RLIKE	为了定位一个模式，以便匹配被测试值的开始或结束，以"^“在模型的开头，表示匹配以某模式开始的记录；以”$"在模式的结尾，表示匹配以某模式结束的记录;要想使用regexp来强制区分大小写需要使其中一个字符转换为二进制字符
‘.’	匹配任意单个的字符
“[XXX]”	匹配在方括号内的任意字符，如"[abc]“匹配"a"或"b"或"c”;"[a-z]“匹配任何字母，因为mysql不区分大小写；”[0-9]"匹配任何数字
“*”	匹配一个或任意多个出现在它前面的字符，如"x*“匹配任意数量的x，”[0-9]“匹配任何数量数字，”."匹配任何数量的任意字符
要想找出以“b”开头的名字	SELECT * FROM PET WHERE name LIKE ‘b%’;	SELECT * FROM PET WHERE name REGEXP ‘^b’;
要想找出以“b”开头的名字,只要小写b开头的	SELECT * FROM PET WHERE name REGEXP BINARY ‘^b’;
要想找出以“fy”结尾的名字	SELECT * FROM PET WHERE name LIKE ‘%fy’;	SELECT * FROM PET WHERE name REGEXP ‘fy$’;
要想找出包含“w”的名字	SELECT * FROM PET WHERE name LIKE ‘%w%’;	SELECT * FROM PET WHERE name REGEXP ‘W’;
要想找出正好包含5个字符的名字，使用“_”模式字符	SELECT * FROM PET WHERE name LIKE ‘_____’;	SELECT * FROM PET WHERE name REGEXP ‘^…$’; 或者用.{5}代替5个点

hive 中正则表达式

hive 正则表达式详解
Hive常用字符串函数

Python3 正则表达式

盘一盘 Python 系列特别篇 - 正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能。

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

re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

本章节主要介绍Python中常用的正则表达式处理函数。

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

函数语法：

re.match(pattern, string, flags=0)

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

匹配成功re.match方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
groups的结果可以看成是group中除了num=0之外的结果。
实例

#-*-coding:utf-8-*-

import re
print(re.match("www","www.runoob.com")) # 在起始位置匹配
print(re.match("www","www.runoob.com").span())
print(re.match('com', 'www.runoob.com')) # 不在起始位置匹配

以上实例运行输出结果为：

<_sre.SRE_Match object; span=(0, 3), match='www'>
(0, 3)
None

实例

#-*-coding:utf-8-*-

import re
line= "Cats are smarter than dogs"
matchObj = re.match( '(.*) are (.*)', line)
print(matchObj.group())
print(matchObj.groups())
#Cats are smarter than dogs
#('Cats', 'smarter than dogs')
#尽量在整个字符串中匹配，因而group()的结果是 "Cats are smarter than dogs"
#默认是贪婪匹配，以are为界，两边都是尽可能多的匹配，因而存储在groups()结果对象中的值为'Cats'和'smarter than dogs'
matchObj = re.match( '(.*) are (.*?)', line)
print(matchObj.group())
print(matchObj.groups())
#Cats are
#('Cats', '')
#与前面的结果比较，这是第二个子表达式是非贪婪匹配，所以以are为界，前边匹配到'Cats'，后面匹配到'',整个匹配的表达式其实是Cats are
matchObj = re.match( '(.*) are (.*) .*', line)
print(matchObj.group())
print(matchObj.groups())
#Cats are smarter than dogs
# ('Cats', 'smarter than')
#这里每一个表达式都是贪婪匹配，第一个子表达式先尽量多的匹配，但是又要保证' are '得到匹配；
# 然后第二个子表达式尽量多的匹配'，但又要使' .*'得到匹配，所以两个子表达式匹配的结果是'Cats', 'smarter than'
matchObj = re.match( '(.*) are (.*?) .*', line)
print(matchObj.group())
print(matchObj.groups())
print(len(matchObj.groups()))
#Cats are smarter than dogs
# ('Cats', 'smarter')
#2
#与上面对比，这里第二个子表达式匹配结果应尽可能少，按说可以匹配一个''，但此时' .*'得不到满足；当第二个子表达式匹配'smarter'时，' .*'得到满足。
matchObj = re.match(r'(.*) are (.*?) .*', line, re.M | re.I)

if matchObj:
    print("matchObj.group() : ", matchObj.group())
    print("matchObj.group(1) : ", matchObj.group(1))
    print("matchObj.group(2) : ", matchObj.group(2))
else:
    print("No match!!")
#matchObj.group() :  Cats are smarter than dogs
# matchObj.group(1) :  Cats
# matchObj.group(2) :  smarter
#这里可以看到.group()返回结果里其实是包含.groups()返回结果的，只不过在不知匹配结果的情况下不好操作;
# 而.groups()返回的是子表达的匹配结果，以元组形式存放，便于操作。

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

函数语法：

re.search(pattern, string, flags=0)

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

匹配成功re.search方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

实例

import re
 
print(re.search('www', 'www.runoob.com')) # 在起始位置匹配
print(re.search('www', 'www.runoob.com').span())
print(re.search('com', 'www.runoob.com')) # 不在起始位置匹配
print(re.search('com', 'www.runoob.com').span())

以上实例运行输出结果为：

<_sre.SRE_Match object; span=(0, 3), match='www'>
(0, 3)
<_sre.SRE_Match object; span=(11, 14), match='com'>
(11, 14)

实例

import re
 
line= "Cats are smarter than dogs"
searchObj = re.search( '(.*) are (.*)', line)
print(searchObj.group())
print(searchObj.groups())
#Cats are smarter than dogs
#('Cats', 'smarter than dogs')
#尽量在整个字符串中匹配，因而group()的结果是 "Cats are smarter than dogs"
#默认是贪婪匹配，以are为界，两边都是尽可能多的匹配，因而存储在groups()结果对象中的值为'Cats'和'smarter than dogs'
searchObj = re.search( '(.*) are (.*?)', line)
print(searchObj.group())
print(searchObj.groups())
#Cats are
#('Cats', '')
#与前面的结果比较，这是第二个子表达式是非贪婪匹配，所以以are为界，前边匹配到'Cats'，后面匹配到'',整个匹配的表达式其实是Cats are
searchObj = re.search( '(.*) are (.*) .*', line)
print(searchObj.group())
print(searchObj.groups())
#Cats are smarter than dogs
# ('Cats', 'smarter than')
#这里每一个表达式都是贪婪匹配，第一个子表达式先尽量多的匹配，但是又要保证' are '得到匹配；
# 然后第二个子表达式尽量多的匹配'，但又要使' .*'得到匹配，所以两个子表达式匹配的结果是'Cats', 'smarter than'
searchObj = re.search( '(.*) are (.*?) .*', line)
print(searchObj.group())
print(searchObj.groups())
print(len(searchObj.groups()))
#Cats are smarter than dogs
# ('Cats', 'smarter')
#2
#与上面对比，这里第二个子表达式匹配结果应尽可能少，按说可以匹配一个''，但此时' .*'得不到满足；当第二个子表达式匹配'smarter'时，' .*'得到满足。
searchObj = re.search(r'(.*) are (.*?) .*', line, re.M | re.I)

if searchObj:
    print("searchObj.group() : ", searchObj.group())
    print("searchObj.group(1) : ", searchObj.group(1))
    print("searchObj.group(2) : ", searchObj.group(2))
else:
    print("No search!!")
#searchObj.group() :  Cats are smarter than dogs
# searchObj.group(1) :  Cats
# searchObj.group(2) :  smarter
#这里可以看到.group()返回结果里其实是包含.groups()返回结果的，只不过在不知匹配结果的情况下不好操作;
# 而.groups()返回的是子表达的匹配结果，以元组形式存放，便于操作。

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

line = "Cats are smarter than dogs";

matchObj = re.match('dogs', line, re.M | re.I)
if matchObj:
    print("match --> matchObj.group() : ", matchObj.group())
else:
    print("No match!!")

matchObj = re.search('dogs', line, re.M | re.I)
if matchObj:
    print("search --> matchObj.group() : ", matchObj.group())
else:
    print("No match!!")

以上实例运行结果如下：

No match!!
search --> matchObj.group() :  dogs

检索和替换

Python 的re模块提供了re.sub用于替换字符串中的匹配项。

语法：

re.sub(pattern, repl, string, count=0)

参数：

pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

实例

import re
 
phone = "2004-959-559 # 这是一个电话号码"
 
# 删除注释
num = re.sub(r'#.*$', "", phone)
print ("电话号码 : ", num)
 
# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print ("电话号码 : ", num)

以上实例执行结果如下：

电话号码 :  2004-959-559 
电话号码 :  2004959559

repl 参数是一个函数

以下实例中将字符串中的匹配的数字乘于 2：
实例

import re
 
# 将匹配的多位数乘于 2
def double(matched):
    print(matched)
    value = int(matched.group('value'))
    print(value)
    return str(value * 2)

s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

执行输出结果为：

<_sre.SRE_Match object; span=(1, 3), match='23'>
23
<_sre.SRE_Match object; span=(4, 5), match='4'>
4
<_sre.SRE_Match object; span=(8, 11), match='567'>
567
A46G8HFD1134

这里可以把(?P)当成是获取匹配模式，并赋值给matched.group(‘value’)的一种特殊用法，可对比(?=)，(?!)等一般正则表达用法。

compile 函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
compile 函数的好处是可编译生成一个Pattern 对象，之后可重复使用这个对象来匹配其他字符串，提高程序效率；第二个好处是pattern.match()函数可以从指定位置范围进行匹配，而不像re.match()只能从头开始匹配。
语法格式为：

re.compile(pattern[, flags])

参数：

• pattern : 一个字符串形式的正则表达式
• flags 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：

  •    re.I 忽略大小写
    

  •    re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
    

  •    re.M 多行模式
    

  •    re.S 即为' . '并且包括换行符在内的任意字符（' . '不包括换行符）
    

  •    re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
    

  •    re.X 为了增加可读性，忽略空格和' # '后面的注释
    

实例
实例

import re
pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
print(m)
#None
m = pattern.match('one12twothree34four', 2, 12) # 从'e'的位置开始匹配，没有匹配
print(m)
#None
m = pattern.match('one12twothree34four', 3, 18) # 从'1'的位置开始匹配，正好匹配
print(m)                                         # 返回一个(m)atch 对象
#<_sre.SRE_Match object; span=(3, 5), match='12'>
print(m.group(0))   # 可省略 0
#'12'
print(m.start(0))  # 可省略 0
#3
print(m.end(0))     # 可省略 0
#5
print(m.span(0))   # 可省略 0
#(3, 5)

在上面，当匹配成功时返回一个 Match 对象，其中：

• group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
• start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
• end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
• span([group]) 方法返回 (start(group), end(group))。

再看看一个例子：
实例

import re
pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)   # re.I 表示忽略大小写
m = pattern.match('Hello World Wide Web')
print(m)                               # 匹配成功，返回一个(m)atch 对象
#<_sre.SRE_Match object; span=(0, 11), match='Hello World'>
print(m.group(0))                        # 返回匹配成功的整个子串
#'Hello World'
print(m.span(0))                        # 返回匹配成功的整个子串的索引
#(0, 11)
print(m.group(1))                      # 返回第一个分组匹配成功的子串
#'Hello'
print(m.span(1))                           # 返回第一个分组匹配成功的子串的索引
#(0, 5)
print(m.group(2))                           # 返回第二个分组匹配成功的子串
#'World'
print(m.span(2))                            # 返回第二个分组匹配成功的子串
#(6, 11)
print(m.groups())                           # 等价于 (m.group(1),(m).group(2), ...)
#('Hello', 'World')
print(m.group(3))                           # 不存在第三个分组
"""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: no such group
"""

从上面也可以看到，re.compile()生成的pattern对象，在后续的匹配中不是全局搜索所有的匹配模式，找到一个就结束了，这一点与re.match(）和re.search()是一样

findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次 findall 匹配所有。

语法格式为：

findall(string[, pos[, endpos]])

参数：

• string 待匹配的字符串。
• pos 可选参数，指定字符串的起始位置，默认为 0。
• endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。

查找字符串中的所有数字：
实例

import re
 
pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)#不包括边界10
 
print(result1)
print(result2)

输出结果：

['123', '456']
['88', '12']

re.finditer

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

re.finditer(pattern, string, flags=0)

参数：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
实例

import re
 
it = re.finditer(r"\d+","12a32bc43jf3") 
for match in it: 
    print (match.group() )

输出结果：

12 
32 
43 
3

re.split

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

re.split(pattern, string[, maxsplit=0, flags=0])

与str.split相比，最大的好处是可以用一个正则表达式来作分隔符，这样就比较多样了。
参数：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
maxsplit	分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
实例

import re
print(re.split('\W+', ' runoob, runoob, runoob.'))
#['', 'runoob', 'runoob', 'runoob', '']
print(re.split('(\W+)', ' runoob, runoob, runoob.'))
#['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', '']
print(re.split('\W+', ' runoob, runoob, runoob.', 1))#与第一个相比，主要的不同是只分割了一次
#['', 'runoob, runoob, runoob.']
print(re.split('a*', 'hello world')) # 对于一个找不到匹配的字符串而言，split 不会对其作出分割
#['hello world']

正则表达式对象

re.RegexObject

re.compile() 返回 RegexObject 对象。

re.MatchObject

group() 返回被 RE 匹配的字符串。

• start() 返回匹配开始的位置
• end() 返回匹配结束的位置
• span() 返回一个元组包含匹配 (开始,结束) 的位置

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：
一般情况下不需要管，默认就是最常用的模式。

python中的正则表达式（re模块）
Python Re模块
Python中的字符串
python 列表生成式、lower()和upper()的使用

正则表达式太慢？这里有一个提速100倍的方案（附代码）

Java 中正则表达式

Java 正则表达式
JAVA 正则表达式 （超详细）

Scala 中正则表达式

Scala 正则表达式
Scala 通过 scala.util.matching 包中的 Regex 类来支持正则表达式。以下实例演示了使用正则表达式查找单词 Scala :

import scala.util.matching.Regex

object Test {
   def main(args: Array[String]) {
      val pattern = "Scala".r
      val str = "Scala is Scalable and cool"
      
      println(pattern findFirstIn str)
   }
}

执行以上代码，输出结果为：

$ scalac Test.scala 
$ scala Test
Some(Scala)

linux 中的正则表达

正则表达式-linux路径匹配