189 8069 5689
如下：
麻栗坡网站建设公司创新互联公司,麻栗坡网站设计制作，有大型网站制作公司丰富经验。已为麻栗坡近千家提供企业网站建设服务。企业网站搭建\外贸营销网站建设要多少钱，请找那个售后服务好的麻栗坡做网站的公司定做！
1、index函数：用于从列表中找出某个值第一个匹配项的索引位置。
2、index方法语法：list.index(x[, start[, end]])。
3、参数：x-- 查找的对象。start-- 可选，查找的起始位置。end-- 可选，查找的结束位置。
4、返回值：该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
5、实例：
代码：str1 = "this is string example....wow!!!"；str2 = "exam"。
index函数为print(str1.index(str2))。
python中index函数怎么用？
Python中index方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find方法一样，只不过如果str不在string中会报一个异常。
index函数一般用处是在序列中检索参数并返回第一次出现的索引，没找到就会报错。
一. 简介
正则表达式又叫规则表达式，是处理字符串的强大工具。在python中通过调用re模块，可以实现正则匹配，正则表达式模式被编译成一系列的字节码，然后由C编写的匹配引擎执行
二. python常用字符含义(匹配模式)
1186367-20180604115644788-1913251705.png
三. re模块
1. re.match(pattern, string, flags=0) | match(string, [pos, endpos]) (这个用于编译后返回的正则表达式对象Pattern.match())
1)作用：尝试从字符串的起始位置匹配一个模式，如果起始位置匹配成功，返回一个match对象，否则返回None
pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等
2) 正则表达式可以包含一些可选标志修饰符来控制匹配模式。修饰符被指定为一个可选的标志，多个修饰符可以通过 | 来指定，如re.I | re.M表示对大小写不敏感和多行匹配
1186367-20180604123302464-360465156.png
3) 实例
importreprint(re.match('www', '').span()) #在起始位置匹配
print(re.match('com', '')) #不在起始位置匹配
运行结果为：
(0, 3)
None
为什么第一个起始位置匹配要加span()?
span()的作用是：返回一个元组包含匹配 (开始,结束) 的位置，如果不加span(),我们获得的只是一个match obj，只有加了span()，我们才能获得匹配对象的位置。不信请看：
#在命令行输出
print(re.match('www', ''))_sre.SRE_Match object; span=(0, 3), match='www'
print(re.match('com', ''))
None
为什么第二个非起始位置匹配不加span()?
不在起始位置匹配，默认返回的None，而None对象是没有span()方法的，这时候就会报错：
importreprint(re.match('com', '').span())
Traceback (most recent call last):
File"", line 1, in
print(re.match('com', '').span())
AttributeError: 'NoneType' object has no attribute 'span'
2. re.search(pattern, string, flags=0) | search(string, [pos, endpos])(这个用于编译后返回的正则表达式对象Pattern.search())
1) 作用：在字符串内查找匹配模式，只要找到第一个匹配则返回一个match对象，如果没有找到，则返回None
importre#不加span()返回一个match对象
print(re.search('www', ''))_sre.SRE_Match object; span=(0, 3), match='www'
print(re.search('www', '').span())
(0,3)print(re.search('com', '').span())
(11, 14)
3. re.match和re.search一旦匹配成功，就会返回一个match object对象，而match object对象有以下方法：
group(num) num代表组号，表示匹配第num组的字符串，不写时默认是0，表示匹配整个表达式的字符串。group()也可以一次输入多个组号，如group(1, 2, 3)，这种情况下它将返回一个包含那些组所对应的元组
groups() 返回一个包含所有小组字符串的元组，从1到所含的小组号
span() 返回一个元组包含匹配(开始、结束)的位置
start() 返回匹配开始的位置
end() 返回匹配结束的位置
1) 实例
importre
line= "Cats are smarter than dogs"searchObj= re.search( r'(.*) are (.*?) .*', line, re.M|re.I)print(searchObj.group())
Cats are smarter than dogsprint(searchObj.group(0))
Cats are smarter than dogsprint(searchObj.group(1))
Catsprint(searchObj.group(2))
smarterprint(searchObj.group(1, 2))
('Cats', 'smarter')
print(searchObj.groups())
('Cats', 'smarter')
为什么第二组匹配是 (.*?) 而不是 (.*)
我们做个试验，尝试一下 (.*)
importre
line= "Cats are smarter than dogs"searchObj= re.search( r'(.*) are (.*) .*', line, re.M|re.I)print(searchObj.group())
Cats are smarter than dogsprint(searchObj.group(1))
Catsprint(searchObj.group(2))
smarter thanprint(searchObj.group(1, 2))
('Cats', 'smarter than')
注意到group(2)的数据是不同的，这个是为什么呢？这就涉及到贪婪匹配和非贪婪匹配
贪婪匹配： 在整个表达式匹配成功的情况下，尽可能多的匹配。比如上面的 .*
.表示除换行之外的所有字符， *表示匹配前面的字符0次或无数次
非贪婪匹配：在整个表达式匹配成功的情况下，尽可能少的匹配。比图上面的 .*?
?表示匹配前面字符0次或1次
注意前面 are () .* 中，()前后是两个空格，而are之后两个空格之间有两种情况，1. "smarter than"， 2. "smarter"，具体选择哪种是由匹配模式决定的，当()里是贪婪匹配时，.*可以匹配smarter，可以匹配空格，可以匹配than，当()里是非贪婪模式时， .*?只会匹配smarter，因为它最多匹配一次
为什么要用前缀 r 呢？
我们知道在python中, \ 表示转义字符，如果需要匹配一个 \ 本身呢？我们就要用\\， 而分别对每个 \ 进行转义，就需要用 \\\\
注意：如果字符串中有字符*需要匹配，可以使用\*或字符集[*]
4. re.compile(pattern, [flags])
1) 作用：用于编译正则表达式，生成一个正则表达式对象(Pattern，这个Pattern不能直接实例化，必须由re.compile()进行构造)，供match()和search()这两个函数使用
pattern：一个字符串形式的正则表达式
flags：编译标志位，用于控制正则表达式的匹配方式，如：是否区分大小写、多行匹配等
2) 实例1
importre#用于匹配至少一个数字
pattern = re.compile(r'\d+')#从开始位置匹配
m = pattern.match('one12twothree34four')#没有匹配，返回None
print(m)
None#从"1"的位置开始匹配
m = pattern.match('one12twothree34four', 3, 10)#正好匹配返回一个match对象
print(m)_sre.SRE_Match object; span=(3, 5), match='12'
print(m.group())12
print(m.start())3
print(m.end())5
print(m.span())
(3, 5)
实例2
importre#re.I表示忽略大小写
pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)
m= pattern.match('Hello World Wide Web')#匹配成功返回一个match对象
print(m)_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)#等价于(m.group(1), m.group(2), ...)
print(m.groups())
('Hello', 'World')#不存在第三个分组
print(m.group(3))
Traceback (most recent call last):
File"", line 1, in
print(m.group(3))
IndexError: no such group
5. re.findall(pattern, string, flags=0) | findall(string, [pos, endpos])
1) 作用：遍历匹配，以列表形式返回所有能匹配的子串，如果没找到匹配的，则返回空列表
string：待匹配的字符串
pos：可选参数，指定字符串的起始位置，默认为0
endpos：可选参数，指定字符串的结束位置，默认为字符串的长度
2) 实例
importre#查找数字
pattern = re.compile(r'\d+')
result1= pattern.findall('runoob 123 google 456')print(result1)
['123', '456']
result2= pattern.findall('run88oob123google456', 0, 10)print(result2)
['88', '12']
6. re.finditer(pattern, string, flags=0) | finditer(string, [pos, endpos])
1) 作用：搜索string，返回一个顺序访问每一个匹配结果(match对象)的迭代器。找到匹配的所有子串，并把它们作为一个迭代器返回。
2) 实例
importre
pattern= re.compile(r'\d+')print(pattern.finditer('one1two2three3four4'))
for m in pattern.finditer('one1two2three3four4'):print(m)print(m.group())_sre.SRE_Match object; span=(3, 4), match='1'
1
_sre.SRE_Match object; span=(7, 8), match='2'
2
_sre.SRE_Match object; span=(13, 14), match='3'
3
_sre.SRE_Match object; span=(18, 19), match='4'
4
7. re.split(pattern, string, [maxsplit=0, flags=0]) | split(string, [maxsplit])
1) 作用：按照能够匹配的子串将字符串分割后返回列表
pattern：匹配的正则表达式
string：要匹配的字符串
maxsplit：分割次数，maxsplit=1 分割一次，默认为0，不限制次数
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写、多行匹配等
2) 实例1
importre
pattern= re.compile(r'\d+')print(pattern.split('one1two2three3four4'))
['one', 'two', 'three', 'four', ''] #注意后面没有内容，是一个''字符
实例2
importre#匹配\W+表示非单词字符一次或无数次
pattern = re.compile(r'\W+')#用非单词字符分割
print(pattern.split('hello, world'))
['hello', 'world']
使用带括号的正则表达式则可以将正则表达式匹配的内容也添加到列表内
importre#带括号的正则表达式则可以将正则表达式匹配的内容也添加到列表内
pattern = re.compile(r'(\W+)')print(pattern.split('hello, world'))
['hello', ', ', 'world']
正则表达式是一个特殊的字符序列，可以帮助您使用模式中保留的专门语法来匹配或查找其他字符串或字符串集。 正则表达式在UNIX世界中被广泛使用。
注：很多开发人员觉得正则表达式比较难以理解，主要原因是缺少使用或不愿意在这上面花时间。
re模块在Python中提供对Perl类正则表达式的完全支持。如果在编译或使用正则表达式时发生错误，则re模块会引发异常re.error。
在这篇文章中，将介绍两个重要的功能，用来处理正则表达式。 然而，首先是一件小事：有各种各样的字符，这些字符在正则表达式中使用时会有特殊的意义。 为了在处理正则表达式时避免混淆，我们将使用：r'expression'原始字符串。
匹配单个字符的基本模式
编译标志可以修改正则表达式的某些方面。标志在re模块中有两个名称：一个很长的名称，如IGNORECASE，和一个简短的单字母形式，如。
1.match函数
此函数尝试将RE模式与可选标志的字符串进行匹配。
下面是函数的语法 ：
这里是参数的描述 ：
pattern ： 这是要匹配的正则表达式。
string ： 这是字符串，它将被搜索用于匹配字符串开头的模式。 |
flags ： 可以使用按位OR(|)指定不同的标志。 这些是修饰符，如下表所列。
re.match函数在成功时返回匹配对象，失败时返回None。使用match(num)或groups()函数匹配对象来获取匹配的表达式。
示例
当执行上述代码时，会产生以下结果 ：
2.search函数
此函数尝试将RE模式与可选标志的字符串进行匹配。
下面是这个函数的语法 ：
这里是参数的描述 ：
pattern ： 这是要匹配的正则表达式。
string ： 这是字符串，它将被搜索用于匹配字符串开头的模式。 |
flags ： 可以使用按位OR(|)指定不同的标志。 这些是修饰符，如下表所列。
re.search函数在成功时返回匹配对象，否则返回None。使用match对象的group(num)或groups()函数来获取匹配的表达式。
示例
当执行上述代码时，会产生以下结果 ：
3.匹配与搜索
Python提供基于正则表达式的两种不同的原始操作：match检查仅匹配字符串的开头，而search检查字符串中任何位置的匹配(这是Perl默认情况下的匹配)。
示例
当执行上述代码时，会产生以下结果 ：
4.搜索和替换
使用正则表达式re模块中的最重要的之一是sub。
模块
此方法使用repl替换所有出现在RE模式的字符串，替换所有出现，除非提供max。此方法返回修改的字符串。
示例
当执行上述代码时，会产生以下结果 ：
5.正则表达式修饰符：选项标志
正则表达式文字可能包含一个可选修饰符，用于控制匹配的各个方面。 修饰符被指定为可选标志。可以使用异或(|)提供多个修饰符，如前所示，可以由以下之一表示 ：
6.正则表达模式
除了控制字符(+ ? . * ^ $ ( ) [ ] { } | )，所有字符都与其自身匹配。 可以通过使用反斜杠将其转换为控制字符。
7.正则表达式示例
字符常量
字符类
特殊字符类
重复匹配
非贪婪重复
这匹配最小的重复次数 ：
用圆括号分组
反向引用
这与以前匹配的组再次匹配 ：
备择方案
python|perl ： 匹配“python”或“perl”
rub(y|le) ： 匹配 “ruby” 或 “ruble”
Python(!+|?) ： “Python”后跟一个或多个! 还是一个?
锚点
这需要指定匹配位置。
带括号的特殊语法
开课吧广场-人才学习交流平台-开课吧
match()和search()都是python中的正则匹配函数，那这两个函数有何区别呢？
match（）函数只检测RE是不是在string的开始位置匹配， search()会扫描整个string查找匹配, 也就是说match（）只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回none
例如：
#! /usr/bin/env python
# -*- coding=utf-8 -*-
import re
text = 'pythontab'
m = re.match(r"\w+", text)
if m:
print m.group(0)
else:
print 'not match'
结果是：pythontab
而：
#! /usr/bin/env python
# -*- coding=utf-8 -*-
#
import re
text = '@pythontab'
m = re.match(r"\w+", text)
if m:
print m.group(0)
else:
print 'not match'
结果是：not match
search()会扫描整个字符串并返回第一个成功的匹配
例如：
#! /usr/bin/env python
# -*- coding=utf-8 -*-
#
import re
text = 'pythontab'
m = re.search(r"\w+", text)
if m:
print m.group(0)
else:
print 'not match'
结果是：pythontab
那这样呢：
#! /usr/bin/env python
# -*- coding=utf-8 -*-
#
import re
text = '@pythontab'
m = re.search(r"\w+", text)
if m:
print m.group(0)
else:
print 'not match'
结果是：pythontab
字符串的匹配查询
Python中的re模块中的findall函数可以对指定的字符串进行遍历匹配，如下：
findall(pattern, string, flags=0)
pattern：指定需要匹配的正则表达式。
string：指定待处理的字符串。
flags：指定匹配模式，常用的值可以是re.I、re.M、re.S和re.X。re.I的模式是让正则表达式对大小写不敏感;re.M的模式是让正则表达式可以多行匹配;re.S的模式指明正则符号.可以匹配任意字符，包括换行符 ;re.X模式允许正则表达式可以写得更加详细，如多行表示、忽略空白字符、加入注释等。
字符串的匹配替换
re模块中的sub函数的功能是替换，类似于字符串的replace方法，该函数根据正则表达式把满足匹配的内容替换为repl，如下：
sub(pattern, repl, string, count=0, flags=0)
pattern：同findall函数中的pattern。
repl：指定替换成的新值。
string：同findall函数中的string。
count：用于指定最多替换的次数，默认为全部替换。
flags：同findall函数。
字符串的匹配分割
re模块中的split函数是将字符串按照指定的正则表达式分隔开，类似于字符串的split，如下：
split(pattern, string, maxsplit=0, flags=0)
pattern：同findall函数中的pattern。
maxsplit：用于指定最大分割次数，默认为全部分割。
string：同findall函数中的string。
flags：同findall函数中的flags。
以上就是本次分享的全部内容了，不知大家对我讲述的Python正则表达式妙用感觉怎么样？
脑筋急转弯：有人想喝点牛奶解渴，却一命呜呼了，为什么？