Python 字符串

创建字符串和引号的区别

创建字符串

创建字符串时，可以使用单引号(‘)、双引号(")或三引号(即三个连续的单引号’‘‘或双引号’’ ‘’ ‘’)。

例：创建字符串示例。

str1='Hello World!'#使用一对单引号创建字符串并赋给变量str1
str2="你好，世界！"#使用一对双引号创建字符串并赋给变量str2
str3='''我喜欢学习Python语言！'''#使用一对三引号创建字符串并赋给变量str3
print(str1)#输出str1
print(str2)#输出str2
print(str3)#输出str3

单引号、双引号、三引号之间的区别

1、单引号和双引号中的字符串要求写在一行中，二者在使用方法并没有什么区别。
2、只是使用单引号创建字符串时，如果字符串中包含单引号字符，则必须在单引号字符前加上转义符"“;而使用双引号创建字符串时，如果字符串中包含双引号字符，则必须双引号字符前加上转义符”"。
3、因此，我们可以根据实际情况决定创建字符串时使用那种引号，从而在编写代码时可以减少转义符的使用、增强程序的可读性。

例：单引号和双引号使用示例。

str1='It\'s a book.'#使用\'说明其是字符串中的单引号字符，不加\则会报错
st2="It's a book."#使用一对双括号创建字符串，此时字符串中的单引号不需要转义符
str3="He said:\"It is your book.\""#使用\"说明其是字符串中的双引号字符
str4='He said:"It is your book."'#使用一对单引号创建字符串，省掉了转义符
print(str1)#输出str1
print(str2)#输出str2
print(str3)#输出str3
print(str4)#输出str4

单引号和双引号中的字符串如果分多行写，必须在每行结尾加上续行符"“;如果希望一个字符串中包含多行信息，则需要使用换行符”\n"。

例：

s1='Hello\
World!'#上一行以\作为行尾，说明上一行与当前行是同一条语句
s2="你好！\n欢迎学习Python语言程序设计！"#通过\n换行
print(s1)#输出s1
print(s2)#输出s2

使用三引号创建字符串，则允许直接将字符串写成多行的形式。

例：

str='''你好！
欢迎学习Python语言程序设计！
祝你学习愉快！'''#通过一对三引号定义包含多行文本信息的字符串
print(str)#输出str

在一对三引号括起来的字符串中，可以直接包含单引号和双引号，不需要使用转义符。

例：

str='''He said:
"It's a book for you."
'''#通过一对三引号定义包含多行文本信息的字符串，其中的单引号和双引号不需要加转义符
print(str)#输出str

字符串比较

字符串比较规则

1、两个字符串按照从左至右的顺序逐个字符比较，如果对应的两个字符相同，则继续比较下一个字符。
2、如果找到了两个不同的字符，则具有较大ASCII码字符对应的字符串具有更大的值。
3、如果对应字符都相同且两个字符串长度相同，则这两个字符串相等。
4、如果对应字符都相同但两个字符串长度不同，则较长的字符串具有更大的值。

例：字符串比较示例。

str1='Python'
str2='C++'
str3='Python3.7'
str4='Python'
print('str1大于str2:',str1>str2)
print('str1小于等于str2：',str1<=str2)
print('str1小于str3：',str1<str3)
print('str大于等于str3:',str1>=str3)
print('str等于str4：',str1==str4)
print('str1不等于str4:',str1!=str4)

字符串切割

split方法

使用字符串中的split方法可以按照指定的分隔符对字符串进行切割，返回由切割结果组成的列表。spilt方法语法格式为：
str.split(sep=None,maxsplit=-1)
其中，str是待切割的字符串；sep是指定的分隔符，可以由一个或多个字符组成，其默认值为None，表示按空白符（空格、换行、制表符等）做字符串切割；maxsplit决定了最大切割次数，如果指定了maxsplit值则最多可以得到maxsplit+1个切割结果，其默认值为-1，表示不对最大切割次数做限制。

例：split方法使用示例。

str1='It is a book!'
str2='Python##C++##Java##PHP'
ls1=str1,split()#按空白符对str1做切割，切割结果列表保存在ls1中
ls2=str2.split('##')#按'##'对str2做切割，切割结果列表保存在ls2中
ls3=str2.split('##',2)#按'##'对str2做2次切割，切割结果列表保存在ls3中
print('ls1:',ls1)
print('ls2:',ls2)
print('ls3:',ls3)

splitlines方法

除了split方法，字符串中还提供了一个splitlines方法，该方法固定以行结束符（‘\r’、‘\n’、'\r\n‘）作为分隔符对字符串进行切割，返回由切割结果组成的列表。splitlines的语法格式为：
str.splitlines([keepends])
其中，str是待切割的字符串；keepends表示切割结果中是否保留最后的行结束符，如果该参数值为True，则保留行结束符，否则不保留（默认值为False，即在切割结果中不保留行结束符）。

例：splitlines方法使用示例。

str="你好！\n欢迎学习Python语言程序设计！\r\n祝你学习愉快！\r"
ls1=str.splitlines()
ls2=str.splitlines(True)
print('ls1:',ls1)
print('ls2:',ls2)

字符串检索和替换

字符串检索

字符串中提供了4种用于进行字符串检索的方法，分别是find、index、rfind、rindex，它们的语法格式分别为：
str.find(sub[, start[, end]])
str.index(sub[, start[, end]])str.rfind(sub[, start[, end]])
str.rindex(sub[, start[, end]])
1、其作用是从字符串str中检索字符串sub出现的位置。start和end参数指定了检索范围，即在切片str[start:end]范围中检索，默认情况下在str[:]范围中（即在这个字符串中）检索。
2、find方法是在指定检索范围中按照从左至右的顺序检索，找到字符串sub第一次出现的位置；而rfind方法在指定检索范围中按照从右至左的顺序检索，找到字符串sub第一次出现的位置。
3、index与find作用相同，rindex与rfind作用相同，只是find和rfind在检索不到字符串sub时返回-1，而index和rindex会引发ValueError异常。

例：find和rfind方法使用示例。

str='cat dog cat dog cat dog'
print('str中第一次出现cat的位置为：',str.find('cat'))
print('str中最后一次出现cat的位置为:',str.rfind('cat'))
print('str中第一次出现mouse的位置为：',str.find('mouse'))

字符串替换

使用字符串中的replace方法可以将字符串中的指定字串替换成其他内容，replace方法的语法格式为：
str.replace(old,new[,max])
其中，str是要做替换操作的字符串；old和new分别是要替换的子串和替换成的字符串；max是最多替换的子串数量，如果不指定max参数则将所有满足条件的子串替换掉。replace方法返回替换后的字符串。

例：字符串替换示例。

str='cat dog cat dog cat dog'
str1=str.replace('cat','mouse')#将str中的所有'cat'子串替换成'mouse'
str2=str.replace('cat','mouse',2)#将str中的2个'cat'子串替换成'mouse'
print('str1:',str1)
print('str2:',str2)

除去字符串空格和大小写转换

除去字符串空格

如果要去除字符串头部和尾部的空格，则可以使用字符串中的strip、lstrip和rstrip方法，它们的语法格式为：

str.strip()#去除str中头部和尾部的空格
str.lstrip()#去除str中头部的空格
str.rstrip()#去除str中尾部的空格

如果要去除所有的空格，则可以使用replace方法，即：

str.replace('',")#去除str中所有的空格

例：去除字符串空格示例。

str='I like Python!'#创建字符串并赋给变量str
str1=str.strip()#去除str中头部和尾部的空格，并将返回的字符串赋给变量str1
str2=str.lstrip()#去除str中头部的空格，并将返回的字符串赋给变量str2
str3=str.rstrip()#去除str中尾部的空格，并将返回的字符串赋给变量str3
str4=str.replace('',")#去除str中所有的空格，并将返回的字符串赋给给变量str4
print('原字符串：#%s#'%str)#输出时前面和后面各加个#以能够看出str末尾的空格
print('去掉头部和尾部空格后：#%s#'%str1)
print('去掉头部空格后：#%s#'%str2)
print('去掉尾部空格后：#%s#'%str3)
print('去掉所有空格后：#%s#'%str4)

大小写转换

字符串中有capitalize、lower、upper、swapacse等大小写转换相关的方法，它们的语法格式分别为：

str.capitalize()#将字符串中的第一个字母大写，其他字母都小写
str.lower()#将字符串中的所有字母都小写
str.upper()#将字符串中的所有字母大写
str.swapcase()#将字符串中的小写字母变大写、大写字母变小写

例：大小写转换示例。

str='i Like Python'
print('原字符串：',str)
print('capitalize方法的结果：',str.capitalize())
print('lower方法的结果：',str.lower())
print('upper方法的结果：',str.upper())
print('swapace方法的结果：',str.swapcase())

字符串的其他常用操作

复制字符串

由于字符串是不可变类型，无法修改字符串中的某个元素值，不存在修改一个字符串值会影响另一个字符串的问题。因此，直接用赋值运算符"="实现字符串复制功能即可。

例：复制字符串示例。

str1='Java'
str2='C++'
str1='Python'
print('str1:%s,str2:%s'%(str1,str2)

连接字符串

作为一种序列数据，直接使用拼接运算（+）即可实现两个字符串的连接。另外，还可以使用字符串中的join方法将序列中的元素以指定的字符连接一个新的字符串，join方法的语法格式为：str.join(seq)
其中，seq是一个序列对象，str是使用的连接符。join方法返回连接后的字符串。

join方法使用示例。

str1=','#仅包含一个逗号的字符串
str2=' '#仅包含一个空格字符串
str3=''#一个空字符串
ls=['I','like','Python']#列表
print(str1.join(ls))
print(str2.join(ls))
print(str3.join(ls))

获取字符串长度

使用len函数可以计算一个字符串中包含的字符数量（即字符串长度），len函数的语法格式为：len(str)

例：获取字符串长度示例。

print('字符串"Pyhton"的长度为：',len('Python'))
print('字符串"你好！"的长度为：',len('你好！'))

测试字符串的组成部分

如果需要判断一个字符串A是否是另一个字符串B的组成部分（即字串），可以直接使用前面介绍的字符串检索方法，检索成功，则A是B的子串，否则A不是B的子串。另外，也可以使用更简洁的in运算符。

例：测试字符串的组成部分示例。

str='cat dog cat'
print("'cat'是str的子串：",'cat' in str)
print("'mouse'是str的子串：",'mouse' in str)

占位符和format方法

占位符

占位符	描述	占位符	描述
%d或%i	有符号整型十进制数	%o	有符号八进制数
%x	有符号十六进制数（字母小写）	%X	有符号十六进制（字母大写）
%e	指数格式的浮点数（字母小写）	%E	指数格式的浮点数（字母大写）
%f或%F	有符号浮点型十进制数	%g	浮点数（根据数值大小采用%e或%f）
%G	浮点数（根据数值大小采用%E或%f）	%c	单个字符（整型或单个字符的字符串）
%r	字符串（使用repr函数进行对象转换）	%s	字符串（使用str函数进行对象转换）
%a	字符串（使用ascii函数进行对象转换）	%%	表示一个百分号

例：占位符示例。

n,f=20,35.67
print('n的十进制形式：%d,八进制形式：%o,十六进制形式：%x'%(n,n,n))
print('f的十进制形式：%f,指数形式：%e'%(f,f))

format方法

使用字符串中的format方法也可以进行字符串的格式化操作，其语法格式为：str.format(* args,** kwargs)
其中，str是由于格式化的字符串，可以包含由大括号{}括起来的替换字段。每个替换字段可以是位置参数的数字索引，也可以是关键字参数的名称。format方法返回的是格式化的字符串副本（即通过format方法调用并不会改变str的值）。

例：format方法示例。

str1='{0}的计算机成绩是{1},{0}的数学成绩是{2}'#{}中的替换字段是位置参数的数字索引
str2='{name}的计算机成绩是{cs},{name}的数字成绩是{ms}'#替换字段是关键字参数的名称
print(str1.format('小明',90,85))
print(str2.format(cs=90,ms=85,name='小明'))

另外，在format方法格式化字符串时，字符串的替换字段中还可以包含对实参属性的访问。

class Student:#定义Student类
   def __init__(self,name,cs):#定义构造方法
      self.name=name
      self.cs=cs
s=Student('小明',90)
str1='{O.name}的计算机成绩是{O.cs}'#{}中的替换字段是位置参数的数字索引
str2='{stu.name}的计算机成绩是{stu.cs}'#替换字段是关键字参数的名称
print(str1.format(s))
print(str2.format(stu=s))

正则表达式的基础语法

通过正则表达式可以定义一些匹配规则，只要满足匹配规则即认为匹配成功，从而实现模糊匹配。
正则表达式中既可以包含普通字符，也可以包含由特殊字符指定的匹配模式。在实际应用正则表达式进行匹配时，正则表达式中的普通字符需要做精确匹配，而特殊字符指定的匹配模式则对应用于模糊匹配的规则。

部分匹配模式

匹配模式	描述
.(点）	匹配换行外的任一字符。例如，对于正则表达式"ab.c",与其”abdc"和"ab1c"匹配，但与"acdb"、"abc"和"ab12c"不匹配。
^(插入符）	匹配字符串开头的若干字符。例如，对于正则表达式"^py"，其与"python"匹配，但与"puppy"不匹配。
$	匹配字符串末尾的若干字符。例如，对于正则表达式"py$"，其与"puppy"匹配，但与"python"不匹配。
[]	字符集合，对应位置可以是该集合中的任一字符。既可以依次指定每一个字符，如[0123456789];也可以通过短横线"-"指定一个范围，如[0-9].在字符序列前加^表示取反，如[ ^0-9]表示匹配不在0至9之间的字符。
*	匹配前一个模式0次或多次。例如，对于正则表达式"a[0-9]*c"，其与"ac"、"a0c"和"a01c"匹配，但与"ac"和"abc"不匹配
+	匹配前一个模式1次或多次。例如，对于正则表达式"a[0-9]+c"，其与"a0c"和"a01c"匹配，但与"ac"和"abc"不匹配
?	匹配前一个模式0次或1次。例如，对于正则表达式“a[0-9]?c”，其与“ac”和“a0c”匹配，但与“a01c”和“abc”不匹配
{m}	匹配前一个模式m次。例如，对于正则表达式“a[0-9]{1}c”，其与“a0c”匹配，但与“ac”、“a01c”和“abc”不匹配
{m,n}	匹配前一个模式m至n次；省略n则匹配前一个模式m次至无限次。例如，对于正则表达式“a[0-9]{1,2}c”，其与“a0c”和“a01c”匹配，但与“ac”和“abc”不匹配
|	“A|B”表示匹配A或B中的任一模式即可。例如，对于正则表达式“a[b|d]c”，其与“abc”和“adc”匹配，但与“ac”、“aac”和“abbc”不匹配。
(…)	用()括起来的内容表示一个分组。在匹配完成后，可以获取每个分组在字符串中匹配到的内容。例如，对于正则表达式“(.* ?)abc”，其与“123abc456abc”匹配结果为 “123”和“456”；而对于正则表达式“(.* )abc”，其与“123abc456abc”匹配结果为“123abc456”。“* ?”与“ * ”的区别在于：“ * ?”每次匹配尽可能少的字符；而“*”每次会匹配尽可能多的字符。
\	转义符，使后面一个字符改变原来的含义。例如，在正则表达式中要精确匹配字符$，则需要写成“\ $”；要精确匹配字符^，则需要写成“ \ ^ ”

特殊序列

正则表达式中还提供了特殊序列以表示特殊的含义，其由" \ “和一个字符组成。” \ "后面的字符可以是数字，也可以是部分英文字母。

特殊序列	描述
\number	number表示一个数字，\number用于引用同一编号的分组中的模式（分组编号从1开始）。例如，对于正则表达式“([0-9])abc\1”，其中的“\1”就表示引用第1个分组中的模式“[0-9]”，即等价于“([0-9])abc[0-9]”，匹配以一个数字开头、一个数字结尾、中间是abc的字符串
\A	匹配字符串开头的若干字符，同匹配模式中的^
\b	单词边界符，即\b两边的字符应该一个是非单词字符、另一个是单词字符，或者一个是单词字符、另一个是空字符（即字符串的开头或末尾）。例如，对于正则“\bfoo\b”，其与“foo”、“foo.”、“(foo)”和“bar foo baz”匹配，但与“foobar”、“foo3”和“foo_bar”不匹配
\B	非单词边界符，与\b功能相反
\d	匹配任一数字字符，等价于[0-9]
\D	与\d作用相反，匹配任一非数字字符，等价于[ ^ 0-9]
\s	匹配任一空白字符
\S	与\s作用相反，匹配任一非空白字符
\w	匹配包含数字和下划线在内的任一可能出现在单词中的字符
\W	与\w作用相反，即匹配\w不匹配的那些特殊字符
\Z	匹配字符串末尾的若干字符，同匹配模式中的$

注：由于Python的字符串中使用" \ “作为转义符，如果要在字符串中使用字符” \ “，则需要写在” \ \ "。
因此，当进行"\bfoo\b"的匹配时，实际编写代码时要写作’\\bfoo\\b’,这样会造成代码编写时容易出错且代码可读性较差。
我们通常在用于表示正则表达式的字符串前加上一个字符r，使得后面的字符串忽略转义符。例如，对于字符串’\\bfoo\\b’，我们可以写作r’\bfoo\b’。

re模块使用compile和match

compile

compile函数用于将一个字符串形式的正则表达式对象，供match、search以及其他一些函数使用。compile函数的语法格式为：

re.compile(pattern,flags=0)

其中，pattern是一个字符串形式的正则表达式；flags指定了匹配选项，可以使用按位或（|）运算符将多个选项连接起来；flags的默认值为0，表示没有任何匹配选项。

flags参数对应的匹配选项

匹配选项	描述
re.A或re.ASCII	使特殊序列中的\w、\W、\b、\B、\d、\D、\s、\S仅作ASCII码的匹配，而不是Unicode码的匹配
re.DEBUG	显示被编译正则表达式的调试信息
re.I或re.IGNORECASE	匹配时不区分大小写
re.L或re.LOCATE	使特殊序列中的\w、\W、\b、\B和不区分大小写的匹配取决于当前的语言环境（不建议使用）
re.M或re.MULTILINE	使匹配模式中的^能够匹配每行的开头若干个字符，$能够匹配每行的结尾若干个字符
re.S或re.DOTALL	使匹配模式中的.（点）能够匹配任一字符（包括换行符）
re.X或re.VERBOSE	忽略正则表达式中的空格和#后面的注释

match

re模块中的match函数用于对字符串开头的若干字符进行正则表达式的匹配。re.match函数的语法格式为：

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

其中，pattern是要匹配的正则表达式；string要作正则表达式匹配的字符串；flags参数和含义与compile函数中的flags参数相同。如果匹配成功，则返回一个Match对象；如果匹配失败，则返回None。

例：re.match函数使用示例。

import re
result1=re.match(r'python','Python是一门流行的编程语言',re.I)
result2=re.match(r'python','我喜欢学习Python',re.I)
result3=re.match(r'python','''我喜欢学习Python
Python是一门流行的编程语言''',re.I|re.M)
print('result1:',result1)
print('result2:',result2)
print('result3:',result3)

注：match函数返回的是一个Match对象，其中span是匹配的字符串序列在字符串中的位置信息，而match中保存了匹配到的字符序列信息。
即便对flags参数指定了匹配选项re.MULTILINE或re.M，re.match函数也只会对字符串开头的若干字符作匹配，而不对后面行的开头字符作匹配。
除了直接调用re模块中的match函数外，也可以使用compile函数生成的正则表达式对象中的match方法实现同样的功能，其语法格式为：

Pattern.match(string,pos,endpos)

其中，Pattern是compile函数返回的正则表达式对象；string是要做正则表达式匹配的字符串；可选参数pos指定了从string的哪个位置开始进行匹配，默认为0；可选参数endpos指定了string的结束位置，match函数将对string中pos至endpos-1范围的子串进行正则表达式匹配。

例：Pattern.match方法使用示例。

import re
pattern=re.compile(r'python',re.I)#生成正则表达式对象
result1=pattern.match('Python是一门流行的编程语言')
result2=pattern.match('我喜欢学习Python！',5)
print('result1:',result1)
print('result2:',result2)

注：使用compile函数的优点在于：当一个正则表达式在程序中被多次使用时，通过compile函数生成的正则表达式对象可重复使用、从而提高效率。

re模块使用-search

re模块中的search函数对整个字符串进行扫描并返回一个匹配的结果。re.search函数的语法格式为：

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

re.search函数各参数的含义与re,match函数完全相同。如果匹配成功，则返回一个Match对象；否则，返回None。

例：re.search函数使用示例。

import re
result1=re.search(r'python','Python是一门流行的编程语言',re.I)
result2=re.search(r'python','我喜欢学习Python！',re.I)
result3=re.search(r'python','我喜欢学习Python，Python简单易用！',re.I)
result4=re.search(r'Java','我喜欢学习Python！',re.I)
print('result1:',result1)
print('result2:',result2)
print('result3:',result3)
print('result4:',result4)

注：不同于re.match函数（只匹配字符串开头的若干字符），re.search函数可以对整个字符串从左向右扫描找到第一个匹配的字符序列。
同Pattern.match方法一样，也可以使用compile函数返回的正则表达式对象中的search方法实现re.search函数同样的功能，其语法格式为：

Pattern.search(string,pos,endpos)

各参数含义与Pattern.match方法完全相同。

re模块使用-匹配对象

使用前面介绍的match函数和search函数，匹配成功时都会返回一个Match对象，匹配失败时则返回None。这里我们看一下如何操作返回的Match对象。

例：根据Match对象判断是否匹配成功。

import re
result1=re.search(r'python','我喜欢学习Python！',re.I)
if result1:#判断是否匹配成功
   print('result1:',result1)#匹配成功则输出返回的Match对象
result2=re.match(r'python','我喜欢学习Python！',re.I)
if result2:#判断是否匹配成功
   print('result2:',result2)#匹配成功则输出返回的Match对象

注：将Match对象作为判断条件时，其永远返回True；而None则返回False。因此，通过"if result1:"和"if result2:"即可判断前面的匹配是否成功。

Match对象方法	描述
group([group1,…])	根据传入的组号返回对应分组的匹配结果。如果传入一个组号，则返回一个字符串形式的匹配结果；如果传入多个组号，则返回一个由多个匹配结果字符串组成的元组。如果传入0或不传入参数，则返回的是与正则表达式匹配的整个字符串
groups()	返回一个由所有分组的匹配结果字符串组成的元组
start(group=0)	返回指定分组的匹配结果字符串在原字符串中的起始位置；如果group值为0（默认值），则返回与正则表达式匹配的整个字符串在原字符串中的起始位置
end(group=0)	返回指定分组的匹配结果字符串在原字符串中的结束位置；如果group值为0（默认值），则返回与正则表达式匹配的整个字符串在原字符串中的结束位置

例：Match对象中的方法使用示例。

import re
str='''sno:#1810101#,name:#小明#,age:#19#,major:#计算机#
sno:#1810102#,name:#小红#,age:#20#,major:#数学#'''
rlt=re.search(r'name:#([\s\S]*?)#[\s\S]*?major:#([\s\S]*?)#',str,re.I)
if rlt:#判断是否有匹配结果
   print('匹配到的整个字符串：',rlt.group())
   print('name:%s,startpos:%d,endpos:%d'%(rlt.group(1),rlt.start(1),rlt.end(1)))
   print('major:%s,startpos:%d,endpos:%d'%(rlt.group(2),rlt.start(2),rlt.end(2)))
   print('所有分组匹配结果：',rlt.groups())
else:
   print('未找到匹配信息')

re模块使用-findall和finditer

findall

re模块中的findall函数用于在字符串中找到所有与正则表达式匹配的子串。re.findall函数的语法格式为：

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

各参数含义与re.match和re.search函数完全相同。如果匹配成功，则将匹配的数据以列表的形式返回；如果匹配失败，则返回空列表。

例：findall函数使用示例。

import re
str='''sno:#1810101#,name:#小明#,age:#19#,major:#计算机#
sno:#1810102#,name:#小红#,age:#20#,major:#数学#'''
rlt=re.findall(r'name:#([\s\S]*?)#[\s\S]*?major:#([\s\S]*?)#',str,re.I)
print(rlt)

注：与re.match和re.search函数不同，re.findall函数可以一次完成字符串中所有满足正则表达式规则的子串的匹配。

finditer

re模块中的finditer函数与re.findall函数功能完全相同，唯一区别在于re.findall函数返回列表形式的结果，而re.finditer返回迭代器形式的结果。re.finditer的语法格式为：

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

例：finditer函数使用示例。

import re
str='''sno:#1810101#,name:#小明#,age:#19#,major:#计算机#
sno:#1810102#,name:#小红#,age:#20#,major:#数学#'''
rlt1=re.finditer(r'name:#([\s\S]*?)#[\s\S]*?major:#([\s\S]*?)#',str,re.I)
rlt2=re.finditer(r'department:#([\s\S]*?)#',str,re.I)
print('rlt1:')
for r in rlt1:
    print(r)
print('rlt2:')
for r in rlt2:
    print(r)

注：re.finditer函数返回的迭代器中每一个元素都是一个Match对象。当匹配失败时，返回的迭代器中不包含如何元素。

re模块使用-split、sub和subn

split

re模块中的split函数使用于将字符串按与正则表达式匹配的子串分割。re.split函数的语法格式如下：

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

其中，pattern时正则表达式；string是要分割的字符串；maxsplit是最大分割次数，默认为0表示不限制分割次数；flags与re.match等函数中的flags参数含义相同。

例：re.split函数使用示例。

import re
str='sno:1810101,name:小明,age:19,major:计算机'
rlt=re.split(r'\W+',str)
print(rlt)

sub

re模块的sub函数用于替换字符串中与正则表达式匹配的子串。re.sub函数的语法格式为：

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

其中，pattern是正则表达式；repl是要将匹配子串替换成的字符串；string是待做替换操作的字符串；count是最大替换次数，默认为0表示不限制替换次数（即将所有符合正则表达式的子串都替换成repl）；flags与re.match等函数中的flags参数含义相同。

例：re.sub函数使用示例。

import re
html='''<div class="mp-logo" data-v-bc926f6a=""><span data-v-bc926f6a="">创作中心</span></div>'''
content=re.sub(r'<[^<]*>','',html)
content=content.strip()#去除字符串content中两边的空白符
print('去除HTML标记后的内容为：',content)

注：第5行代码中，“<[ ^<]*>“表示匹配由一对尖括号括起来的字符串，通过”[ ^<]“指定匹配的字符串中不能包含左尖括号”<”.

subn

re模块中的subn函数与re.sub函数功能完全相同，只是re.subn函数会以一个元组的形式同时返回替换匹配子串后得到的新字符串和替换的次数。re.subn函数的语法格式为：

re.subn(pattern,repl,string,count=0,flags=0)

例：re.subn函数使用示例。

import re
html='''<div class="mp-logo" data-v-bc926f6a=""><span data-v-bc926f6a="">创作中心</span></div>'''
content=re.subn(r'<[^<]*>','',html)
content=content.strip()#去除字符串content中两边的空白符
print('去除HTML标记后的内容为：',content)

爬虫程序示例。

获取网页数据

使用requests的get函数从指定网页上下载数据：
get(url,params=None,**kwargs)
作用：发送一个get请求。
url参数：指定要从哪个网址获取网页数据。
params参数：（可选）在请求时发送的字典、元组列表或字节类型的数据。
**kwargs参数：一些可选参数。
返回：Response类对象。
如：
request=requests.get(url,timeout=30,headers=headersParameters)

headersParameters中保存了请求头的信息，如：

headersParameters={#发送HTTP请求时的HEAD信息
   'Connection':'Keep-Alive',#Connection决定当前的事务完成后，是否会关闭网络连接。如果该值是"Keep-Alive",网络连接就是持久
   'Accept':'text/html,application/xhtml+xml,*/*',#浏览器接收的媒体类型，text/html代表HTML格式，application/xhtml+xml代表XHTML格式，*/*代表浏览器可以处理所有类型
   'Accept-Language':'en-US,en;q=0.8,zh-Hans-CN;q=0.5,zh-Hans;q=0.3',#浏览器申明自己接收的语言
   'Accept-Encoding':'gzip,deflate',#浏览器申明自己接收的编码方式；通常指定压缩、是否支持压缩、支持什么方式压缩(gzip/default)
   'User-Agent':'Mozilla/6.1(Windows NT 6.3; WOW64;Trident/7.0;rv:11.0)like Gecko'#告诉HTTP服务器客户端浏览器使用的操作系统和浏览器的版本和名称
}

设计的正则表达式：

r'<h3 class="c-title">([\s\S]*?)</h3>'

通过re.sub函数去除title中多余的HTML标记，如：

re.sub(r'<[^>]+>','',title)#去除title中的所有HTML标记

通过for循环将这些新闻标题显示在屏幕上，如：

no=1
for title in titles:
   print(str(no)+':'+title)
   no+=1

按类似的方法，也可以将新闻标题写入到filepath所对应的文件中，如：

with open(filepath,'w') as f:#使用with语句，以使得文件操作完毕后文件能够自动关闭
    no=1
    for title in titles:
       f.write(str(no)+':'+title+'\n')
       no+=1