1，正则表达式
正则表达式，就是匹配字符串内容的一种规则。
官方定义：正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
字符组 ： [字符组]
在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示
字符分为很多类，比如数字、字母、标点等等。
假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。
字符组只能匹配一个元素。字符组代表一个字符位置上可以出现的所有内容。范围是根据asc码来的，范围必须是从小到大的指向，一个字符组可以有多个范围。
[0-9] 匹配0到9的整数
[1-9][0-9][0-9] 匹配三位数
[a-z]小写字母
[A-Z]大写字母
[A-Za-z]大小写字母
[0-9a-fA-F]用来验证16进制字符
字符:在正则表达式中有特殊意义。
. 点匹配除换行符(enter)回车键以为的任意字符
\w 匹配字母数字或下划线
\s 匹配任意的空白符
\d 匹配数字
\t 匹配一个制表符
\n 匹配一个换行符
\b 匹配一个单词的结尾
^ 匹配字符串的开始
$ 匹配字符串的结尾
\W 匹配非字母数字或下划线
\D 匹配非数字
\S 匹配非空白符 [\s\S]
[\W\w]
[\d\D]
全局匹配
a|b 匹配字符a或字符b
()匹配括号内的表达式，也表示一个组。
[....]匹配字符组中的字符
[^...]匹配除了字符组中字符的所有字符
量词：
* 重复零次或者多次
+ 重复一次或者多次
？重复零次或者一次
{n},重复n次，表示具体的次数
{n,}重复n次或者更多次
{n,m}重复n到m次
量词只约束前一个字符：
*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
.*?的用法
. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：
.*?x 就是取前面任意长度的字符，直到一个x出现
转义符\
在正则表达式中，有很多有特殊意义的是元字符，比如\d和\s等，如果要在正则中匹配正常的"\d"而不是"数字"就需要对"\"进行转义，变成'\\'。
在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\d",字符串中要写成'\\d'，那么正则里就要写成"\\\\d",这样就太麻烦了。这个时候我们就用到了r'\d'这个概念，此时的正则是r'\\d'就可以了。
2,re模块
re 模块下常用方法：
import re
ret = re.findall('a', 'eva egon yuan') # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['a', 'a']
ret = re.search('a', 'eva egon yuan').group()
print(ret) #结果 : 'a'
# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
ret = re.match('a', 'abc').group() # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : 'a'
ret = re.split('[ab]', 'abcd') # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret) # ['', '', 'cd']
ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H'，参数1表示只替换1个
print(ret) #evaHegon4yuan4
ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H'，返回元组(替换的结果,替换了多少次)
print(ret)
obj = re.compile('\d{3}') #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group()) #结果 ： 123
import re
ret = re.finditer('\d', 'ds3sy4784a') #finditer返回一个存放匹配结果的迭代器
print(ret) # <callable_iterator object at 0x10195f940>
print(next(ret).group()) #查看第一个结果
print(next(ret).group()) #查看第二个结果
print([i.group() for i in ret]) #查看剩余的左右结果
1 findall的优先级查询：
import re
ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret) # ['oldboy'] 这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(ret) # ['www.oldboy.com']
2 split的优先级查询
ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 ： ['eva', 'egon', 'yuan']
ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']
#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。
匹配标签
import re
ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
#还可以在分组中利用?<name>的形式给分组起名字
#获取的匹配结果可以直接用group('名字')拿到对应的值
print(ret.group('tag_name')) #结果 ：h1
print(ret.group()) #结果 ：<h1>hello</h1>
ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
#如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致
#获取的匹配结果可以直接用group(序号)拿到对应的值
print(ret.group(1))
print(ret.group()) #结果 ：<h1>hello</h1>
匹配整数
import re ret=re.findall(r"\d+","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '2', '60', '40', '35', '5', '4', '3']
ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '-2', '60', '', '5', '-4', '3']
ret.remove("")
print(ret) #['1', '-2', '60', '5', '-4', '3']
数字匹配
1、 匹配一段文本中的每行的邮箱
http://blog.csdn.net/make164492212/article/details/51656638 2、 匹配一段文本中的每行的时间字符串，比如：‘1990-07-12’； 分别取出1年的12个月（^(0?[1-9]|1[0-2])$）、
一个月的31天：^((0?[1-9])|((1|2)[0-9])|30|31)$ 3、 匹配qq号。(腾讯QQ号从10000开始) ［1,9］[0,9]{4,} 4、 匹配一个浮点数。 ^(-?\d+)(\.\d+)?$ 或者 -?\d+\.?\d* 5、 匹配汉字。 ^[\u4e00-\u9fa5]{0,}$ 6、 匹配出所有整数
爬虫练习
import requests import re
import json def getPage(url): response=requests.get(url)
return response.text def parsePage(s): com=re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
'.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>',re.S) ret=com.finditer(s)
for i in ret:
yield {
"id":i.group("id"),
"title":i.group("title"),
"rating_num":i.group("rating_num"),
"comment_num":i.group("comment_num"),
} def main(num): url='https://movie.douban.com/top250?start=%s&filter='%num
response_html=getPage(url)
ret=parsePage(response_html)
print(ret)
f=open("move_info7","a",encoding="utf8") for obj in ret:
print(obj)
data=json.dumps(obj,ensure_ascii=False)
f.write(data+"\n") if __name__ == '__main__':
count=0
for i in range(10):
main(count)
count+=25
import re
import json
from urllib.request import urlopen def getPage(url):
response = urlopen(url)
return response.read().decode('utf-8') def parsePage(s):
com = re.compile(
'<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
'.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>', re.S) ret = com.finditer(s)
for i in ret:
yield {
"id": i.group("id"),
"title": i.group("title"),
"rating_num": i.group("rating_num"),
"comment_num": i.group("comment_num"),
} def main(num):
url = 'https://movie.douban.com/top250?start=%s&filter=' % num
response_html = getPage(url)
ret = parsePage(response_html)
print(ret)
f = open("move_info7", "a", encoding="utf8") for obj in ret:
print(obj)
data = str(obj)
f.write(data + "\n") count = 0
for i in range(10):
main(count)
count += 25 简化版
flags有很多可选值： re.I(IGNORECASE)忽略大小写，括号内是完整的写法
re.M(MULTILINE)多行模式，改变^和$的行为
re.S(DOTALL)点可以匹配任意字符，包括换行符
re.L(LOCALE)做本地化识别的匹配，表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境，不推荐使用
re.U(UNICODE) 使用\w \W \s \S \d \D使用取决于unicode定义的字符属性。在python3中默认使用该flag
re.X(VERBOSE)冗长模式，该模式下pattern字符串可以是多行的，忽略空白字符，并可以添加注释 flags
计算器的作业：实现能计算类似
1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式的计算器程序
import re
#处理符号用的
def dealwith_symbol(express):
if '--' in express:express = express.replace('--','+')
if '+-' in express:express = express.replace('+-','-')
if '-+' in express:express = express.replace('-+','-')
if '++' in express:express = express.replace('++','+')
return express
#处理乘除法
def mul_div(express):
#a*b a/b
if '*' in express:
a,b = express.split('*')
ret = float(a)*float(b)
elif '/' in express:
a, b = express.split('/')
ret = float(a) / float(b)
return str(ret) # 将没有括号的子表达式中的乘除法先提取出来，再计算加减法
def simplify_express(express_son): #(9-2*5/3)
while True: #取乘除法计算
ret = re.search(r'\d+\.?\d*[*/]-?\d+\.?\d*',express_son) #(9-2*5/3)
if ret:
mul_div_express = ret.group() #2*5
result = mul_div(mul_div_express) #
express_son = express_son.replace(mul_div_express,result,1) #(9-3.3)
express_son = dealwith_symbol(express_son)
else:break
express_son = dealwith_symbol(express_son)
num_lst = re.findall(r'[\+\-]?\d+\.?\d*',express_son) #(-8)
sum = 0
for i in num_lst:
sum += float(i)
return str(sum) # 将表达式中的括号提取出来
def remove_bracket(express):
#\([^\(\)]+\)、\([^\(]+?\)、\([\-\d\+\/\*\.]+\)
while True:
ret = re.search(r'\([^\(\)]+\)',express)
if ret:
express_no_bracket = ret.group() #express_no_bracket: 没有括号的表达式
sum = simplify_express(express_no_bracket)
express = express.replace(express_no_bracket,sum,1)
else:break
return simplify_express(express) e = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
new_express = e.replace(' ','')
result = remove_bracket(new_express)
print(result)
import re
# 1 - 2 * ( (60-30 +(-40/5) * 20) - (-4*3)/ (16-5+3*2) ) 259.58823529412
def main():
while True:
try:
arg = input('请输入计算的表达式:').strip()
counter = calc(arg)
print(counter)
break
except Exception:
print('请重新输入:')
def add(arg):
arg = arg.replace("++", "+").replace("--", "+").replace("+-", "-").replace("-+", "-")
num = re.findall(r"([+\-]?\d+\.?\d*)", arg)#匹配所有的数字
result = 0
for i in num:
result = result + float(i)
return result def mul(arg):
while True:
result = re.split(r"(\d+\.?\d*[\*/][\+-]?\d+\.?\d*)",arg,1)#匹配括号内的乘除法
if len(result) == 3:
bef,cen,aft = result
if "*" in cen:
num1,num2 = cen.split("*")
new_cen = float(num1) * float(num2)
arg = bef +str(new_cen) + aft
elif "/" in cen:
num1,num2 = cen.split("/")
new_cen = float(num1) / float(num2)
arg = bef + str(new_cen) + aft
else:
return add(arg) def calc(arg):
while True:
arg = arg.replace(" ","")
result = re.split(r"\(([^()]+)\)",arg,1)#匹配最里面的括号并且只取括号中的内容
if len(result) == 3:
bef,cen,aft = result
r = mul(cen)
arg = bef + str(r) + aft
else:
return mul(arg)
if __name__ == '__main__':
main()