1. 基本规则
# 元字符： # . ^ $ * + ? { } [ ] | ( ) # 字符类型匹配： # . 表示匹配任意一个字符(换行符除外) # [asdf] 表示匹配中括号里面的任意一个字母一次 # [a-z] 表示匹配a-z中的任意一个字母 [0-9] 表示匹配0-9中的任意一个数字 # [^0-9] 中括号中有^符号，表示非，除---之外，这里表示除0-9之外的任意字符 # d 匹配数字，即 [0-9] # D 匹配⾮数字，即不是数字 [^0-9] # s 匹配空⽩，即 空格，tab键 [ fv] # S 匹配⾮空⽩ [^ fv] # w 匹配单词字符，即a-z、A-Z、0-9、_ [a-zA-Z0-9_] # W 匹配⾮单词字符 [^[a-zA-Z0-9_]] # 匹配一个特殊字符边界，比如 空格、&、# 等 # 定位： # ^ 表示起始定位 # $ 表示结束定位 # 匹配次数： # * 表示任意次 # + 至少1次 [1,+oo] # ? 匹配0次或者1次 # {a，b} 匹配指定的次数范围，如 {0，}相当于匹配任意次 ，{6} 表示匹配6次 # 分组 & 后向引用 & 别名： # (ab) 将括号中字符作为⼀个分组 # um 引⽤分组num匹配到的字符串 # (?P<name>) 分组起别名 # (?P=name) 引⽤别名为name分组匹配到的字符 # | 匹配左右任意⼀个表达式
2. findall
2.1 贪婪匹配&惰性匹配
1）贪婪模式
- findall默认就是贪婪模式，其会尽可能多的匹配
- findall会将所有匹配符合的内容保存到一个列表中
import re # 导入re模块 # findall方法第一个参数是匹配的规则，第二个参数是要匹配的字符串 # findall会将所有匹配符合的内容保存到一个列表中 print(re.findall("hgzero", "thisishgzero")) # 输出：[hgzero]
data1 = re.findall("hg", "hgzerohgwzh") print(data1) # 输出：['hg', 'hg']
2）惰性模式
- 惰性模式就是尽可能少的去匹配
data1 = re.findall("hg*", "hggggg") # 贪婪模式 data2 = re.findall("hg*?", "hggggg") # 惰性模式，后面的那个问号就表示惰性模式 print(data1) # 输出：['hggggg'] print(data2) # 输出：['h']
2.2 字符串转义流程
字符串转义的流程：字符串 --> python解释器转义 --> re模块的转义
# 转义 ret1 = re.findall("www.baidu", "www.baidu") # 这里面的 . 会代指任意字符(除 外) ret1 = re.findall("www.baidu", "www.baidu") # 这里面，反斜杠的添加会让 . 符号失去元字符代指的意义，从而使其就表示普通的点 . 符号 # 字符串转义的流程： 字符串---> python解释器转义---> re模块的转义 ret2 = re.findall(r"I", "I hIo Ion") # 这里面的r ，表示在python层次不使用转义字符，直接将其传递给re模块 ret3 = re.findall("I\\b", "I hIo Ion") # 这里适用4个 , 表示在python解释器层次转义成2个 , 然后再将其传入re模块进行转义 re.findall("I\b", "I what") # 这样使\b在python层次被转义成传递给re模块 re.findall(r"I", "I what") # 这样在前面加上r ，可以让python不转义字符串内容，而直接传递给re
3. search
search会将匹配到的结果保存到一个对象中，且只匹配第一个对象。
用search取到的对象必须要用group取值。
# search会将匹配到的结果保存到一个对象中,且只匹配第一个对象 sear = re.search("d+", "fasdfsaf345kdf89") # search返回的只是一个对象，且只返回找到的第一个 retu = sear.group() # 用search取到的对象必须要用group取值 # 可以用?P<name>的形式给某一部分命名别名 re.search("(?P<name>[a-z]+)(?P<age>d+)", "hgzero21wzh23hg26").group("name") re.search("(?P<name>[a-z]+)(?P<age>d+)", "hgzero21wzh23hg26").group("age") # 可以一次获取多个值 pattern = re.compile(r"(?P<prv>[d]+[.]?[d]*)(?P<typ>[-])(?P<after>[d]+[.]?[d]*)") prv, typ, aft = pattern.search(calc_str).group("prv", "typ", "after") # 获取三个值，这三个值会被保存在一个元组中
4. match
match只从开始开始匹配，且只匹配一次，返回一个对象，若没匹配到则什么都不返回
# match只从开始开始匹配，且只匹配一次，返回一个对象，若没匹配到则什么都不返回 re.match("d+", "234fda")
5. split
split会将字符串按照某字符分割，然后保存为一个列表
# split会将字符串按照某字符分割 re.split(" ", "hello abc what") # 将字符串按照空格分割，保存到一个列表中 re.split("[ |]", "hello welcome|hi hgzero") # 将字符串按照空格或者|进行分割后保存到一个列表中 re.split("[ab]", "abc") # 先按照a分割，左边形成一个空，然后将得到的bc再按照b分割，左边又得到一个空 # 打印结果为 ['', '', 'c']
6. sub
sub可以完成字符串的替换功能
# sub可以完成字符串的替换功能 re.sub("d+", "A", "welcome666hgzero987") # 将第三个参数中的字符串中的数字转换成A # 这里面的第四个参数可以限定匹配替换的次数 re.subn("d", "A", "welcome666hgzero987") # 将匹配到的内容放在一个元组里，结果中的第二个值为匹配替换的次数 # 打印结果为 ('welcomeAAAhgzeroAAA', 6) result = re.sub(r"([d+-*/.]*)", value, calc_str, 1) # 将calc_str中被正则匹配到的内容替换为value，且只替换第一次匹配到的
7. compile
compile可以事先定义好规则，保存为一个对象，然后后面可以直接使用这个对象而无需再定义规则
# compile可以事先定义好规则，保存一个对象，然后后面可以直接使用这个对象而无需再定义规则 com = re.compile("d+") com.findall("welcome666hgzero987") # 使用示例 pattern = re.compile(r"((?P<init>[d+-*/.]*))") init_str = pattern.search(calc_str).group("init") # re.S，可以让点号 . 匹配所有特殊字符，包括换行 等 re.compile('<dd>.*?>(?P<index>d+)<.*?data-src="(?P<imglink>.*?)".*?</dd>', re.S)
8. finditer
finditer可以将得到的数据保存到一个迭代器中
# finditer可以将得到的数据保存到一个迭代器中 ret = re.finditer("d", "welcome666hgzero987") next(ret).group() # 可以通过next函数加上group调用迭代器中的内容 re.findall("www.(baidu|163).com", "www.baidu.com") # findall会优先将分组中的内容返回 # 这里的返回结果为 ['baidu'] re.findall("www.(?:baidu|163).com", "www.baidu.com") # 【在分组中加上 ?: 可以去掉分组的优先级】
9. 正则小练习
写一个计算器，思路：
- 先去除空格
- 对特殊字符报错(字母、加减乘除之外的字符)
- 括号都是成对的, 要从最内部的括号开始计算, 由内而外, 计算后得出结果
- 将3步骤得到的结果去替换3步骤匹配到的括号及内部的内容, 然后得到一个新的字符串
- 重复执行3步骤和4步骤, 最终得到一个不包含任何括号的字符串, 计算这个字符串表达式就是最终的结果
# 计算器 3+ ((1* 5*3) + ( (3* (8/2)/2) +2 ) *2) *2 + 4 import re def del_space(calc_str): """ 去除整个字符串中的空格 :param calc_str: 原始字符串 :return: 去除空格后的字符串 """ data = calc_str.replace(" ", "") return data def check_special(calc_str): """ 检测字符串中是否有字母及非运算的特殊字符, :param calc_str: 原始字符串 :return: True or False, 若为True，则表示存在特殊字符 """ pattern = re.compile(r"[^d+-*/()]") check = pattern.findall(calc_str) return check def calculate(calc_str): """ 对字符串中的表达式进行计算 :param calc_str: 数学计算表达式类型的字符串 :return: 计算后的结果 """ while True: if calc_str.find("*") != -1: pattern = re.compile(r"(?P<prv>[d]+[.]?[d]*)(?P<typ>[*])(?P<after>[d]+[.]?[d]*)") prv, typ, aft = pattern.search(calc_str).group("prv", "typ", "after") # re.sub("%s%s%s" % (prv, typ, aft), str(value), calc_str) calc_str = calc_str.replace("%s%s%s" % (prv, typ, aft), str(float(prv) * float(aft))) continue elif calc_str.find("/") != -1: pattern = re.compile(r"(?P<prv>[d]+[.]?[d]*)(?P<typ>[/])(?P<after>[d]+[.]?[d]*)") prv, typ, aft = pattern.search(calc_str).group("prv", "typ", "after") calc_str = calc_str.replace("%s%s%s" % (prv, typ, aft), str(float(prv) / float(aft))) continue elif calc_str.find("+") != -1: pattern = re.compile(r"(?P<prv>[d]+[.]?[d]*)(?P<typ>[+])(?P<after>[d]+[.]?[d]*)") prv, typ, aft = pattern.search(calc_str).group("prv", "typ", "after") calc_str = calc_str.replace("%s%s%s" % (prv, typ, aft), str(float(prv) + float(aft))) continue elif calc_str.find("-") != -1: pattern = re.compile(r"(?P<prv>[d]+[.]?[d]*)(?P<typ>[-])(?P<after>[d]+[.]?[d]*)") prv, typ, aft = pattern.search(calc_str).group("prv", "typ", "after") calc_str = calc_str.replace("%s%s%s" % (prv, typ, aft), str(float(prv) - float(aft))) continue else: break return calc_str def replace_expr(calc_str): """ 找到最内部的括号, 计算出值后将值替换到字符串中 :param calc_str: 纯粹的要计算出结果的字符串 :return: 当前字符串最内部的值 """ try: # re的search方法如果匹配不到内容就会报错 pattern = re.compile(r"((?P<init>[d+-*/.]*))") init_str = pattern.search(calc_str).group("init") value = str(calculate(init_str)) result = re.sub(r"([d+-*/.]*)", value, calc_str, 1) # 只替换第一次匹配到的 return result except Exception: return None while True: origin_str = input("请输入要计算的内容: ") calc_str = del_space(origin_str) if check_special(calc_str): print("存在特殊字符, 请检查后再计算!") continue while True: str_init = replace_expr(calc_str) if str_init: calc_str = str_init else: value = calculate(calc_str) print("最终的结果为: ", value) break # 测试: calc_strx = "3+ ((1* 5*3) + ( (3* (8/2)/2) +2 ) *2) *2 + 4 " # 正确结果为:69
10. requests+re正则爬虫实战
requests+re正则爬取猫眼电影Top100电影信息
import re import requests import urllib3 import json # 忽略警告 urllib3.disable_warnings() def get_one_page(url, headers): try: response = requests.get(url, headers=headers, verify=False) if response.status_code == 200: return response.text else: return None except Exception as e: print(e) return None def get_video_info(html_text): pattern = re.compile('<dd>.*?>(?P<index>d+)<.*?data-src="(?P<imglink>.*?)".*?data-val.*?">(?P<name>.*?)<.*?' 'star">(?P<star>.*?)<.*?releasetime">(?P<releasetime>.*?)<.*?' 'integer">(?P<x>.*?)<.*?fraction">(?P<y>.*?)<.*?</dd>', re.S) item = re.findall(pattern, html_text) for i in item: yield { "序号": i[0], "电影名": i[2], "主演": i[3].strip()[3:], "上映时间": i[4][5:], "评分": i[5]+i[6], "图像链接": i[1], } def save_as_file(data): with open("movie_info.txt", "a+", encoding="utf-8") as f: info = json.dumps(data, ensure_ascii=False) # 不以ascii码方式显示 f.write(info + " ") def main(n): url = "http://maoyan.com/board/4?offset=" + str((n-1)*10) headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36", "Referer": "http://maoyan.com/board", } html_text = get_one_page(url, headers) for i in get_video_info(html_text): print(i) save_as_file(i) if __name__ == '__main__': for i in range(1, 11): main(i)