Python正则表达式—Python Day 13

最新推荐文章于 2024-07-25 16:39:13 发布
最新推荐文章于 2024-07-25 16:39:13 发布
阅读量950 收藏 1
点赞数
文章标签： 正则表达式 python 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Colorfully_lu/article/details/121209486
版权

学习目的

1.区分正则表达式和Python正则表达式的相同点和不同点

2.使用re模块的相关方法处理数据（重点、难点）

3.区分贪婪模式与非贪婪模式，使用非贪婪模式解决特殊的数据处理问题（难点）

1.概述

正则表达式

正则表达式，英文名为Regular Expression，又称规则表达式。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。

在主流操作系统（*nix[Linux, Unix等]、Windows、HP、BeOS等）、主流的开发语言（delphi、Scala、PHP、C#、Java、C++、Objective-c、Swift、VB、Javascript、Ruby以及Python等）、数以亿万计的各种应用软件中，都可以看到正则表达式优美的舞姿。

Python正则表达式

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式功能。同时，re 模块是用c语言写的，其匹配速度非常快。

其中compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

2.re模块

re.match方法

re.match 尝试从字符串的起始位置匹配一个规则，匹配成功就返回match对象，否则返回None。可以使用group()获取匹配成功的字符串。

语法：re.match(pattern, string, flags=0)

参数说明：

参数

描述

pattern

匹配的正则表达式

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，

如：是否区分大小写，多行匹配等等。

示例 （无标志位）

import re
data ="Python is the best language in the world"
# match 只能匹配以xxx开头的子符串，第一个参数是正则，第二个参数是需要匹配的字符串
result=re.match("P",data)   #精确匹配，以什么来开头
print(type(result))   #<class 're.Match'>
print(result.group())   ## 匹配成功使用group方法取出字符串 

result=re.match("Python",data)   #精确匹配，以什么来开头
print(type(result))   #<class 're.Match'>
print(result.group())   ## 匹配成功使用group方法取出字符串 

result=re.match("t",data)   #精确匹配，t不是什么开头的  所以会报错
print(type(result))   #<class 're.Match'>
print(result.group())   #匹配成功就会返回

 输出结果

E:\pythonProject9\venv\Scripts\python.exe E:/pythonProject9/Regex.py
<class 're.Match'>
P
<class 're.Match'>
Python
<class 'NoneType'>
Traceback (most recent call last):
  File "E:/pythonProject9/Regex.py", line 14, in <module>
    print(result.group())   #匹配成功就会返回
AttributeError: 'NoneType' object has no attribute 'group'

Process finished with exit code 1

示例2（有标志位）：

如果同时使用多个标志位使用|分割，比如re.I | re.M

flags可选标志位

修饰符

描述

re.I

使匹配对大小写不敏感

re.L

做本地化识别（locale-aware）匹配

re.M

多行匹配，影响 ^ 和 $

re.S

使 . 匹配包括换行在内的所有字符

re.U

根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.

re.X

该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

import re
data ="Python is the best language in the world"
# 如果同时使用多个标志位使用|分割，比如re.I | re.M
res=re.match("p",data,re.I|re.M)   #使匹配对大小写不敏感
if res:
    print('匹配成功......')
    print(res)
    print(res.group())
else:
    print(res)
    print('匹配失败......')
    # 如果匹配失败，是没有group函数的 因为一个空对象是None
    print(res.group())

 输出结果

匹配成功......
<re.Match object; span=(0, 1), match='P'>
P

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

匹配对象方法

描述

group(num=0)

匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。

groups()

返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

 group和groups示例：

import re
str ="Python is the best language in the world"
res=re.match('(.*) the (.*?) .*',str)  #is前后的内容
print(res)
print(res.group())
print(res.group(1))  #the前面是Python is
print(res.group(2))  #the后面是best
print(res.groups())   #以元组形式返回两个结果('Python is', 'best')

输出结果

<re.Match object; span=(0, 40), match='Python is the best language in the world'>
Python is the best language in the world
Python is
best
('Python is', 'best')

 常用的匹配规则-匹配字符

符号

匹配规则

.（点）

匹配任意1个字符除了换行符\n

[abc ]

匹配abc中的任意一个字符

\d

匹配一个数字，即0-9

\D

匹配非数字，即不是数字

\s

匹配空白，即空格，tab键

\S

匹配非空白，除空格，tab键之类的

\w

匹配单词字符，即a-z、A-Z、0-9、_

\W

匹配非单词字符

示例

import re
str1='aaaa'
#(点.)匹配任意除换行符之外的字符
str1_Test=re.match('.',str1).group()   #a
print(str1_Test)

#[ ]匹配中括号中的任意一个字符开头都可以
str2='hello'
str2_Test=re.match('[he]',str2).group()  #h
print(str2_Test)
str3='eee'
str3_Test=re.match('[He]',str3).group()  #e
print(str3_Test)

#\d匹配一个数字
str='123abc'
str1=re.match('\d',str).group()  #1
str2=re.match('\d\d',str).group()   #12
print(str1)
print(str2)

#\D匹配非数字，即不是数字
str='aG123asb'
str1=re.match('\D',str).group()   #a
str2=re.match('\D\D',str).group()    #aG
print(str1)
print(str2)

#\s匹配空白字符串
str='  hello'
str1=re.match('\s',str).group()   #a
print("空白字符串"+str1+"空白字符串")  #"  "

#\S匹配非空白字符串
#str=' hello'
#str1=re.match('\S',str).group()   #如果第一个是空格，会报错
str='hello'
str1=re.match('\S',str).group()
print(str1)  #h

#\W匹配非单词字符
str='    python'
str1=re.match('\W',str).group()  #' '
print(str1)

#\w匹配非单词字符
str='python'
str2=re.match('\w',str).group()  #p
print(str2)

输出结果 

a
h
e
1
12
a
aG
空白字符串 空白字符串
h
 
p

Process finished with exit code 0

常用的匹配规则-匹配字符数量

符号

匹配规则

*

匹配前一个字符出现0次或者无限次，即可有可无

+

匹配前一个字符出现1次或者无限次，即至少有1次

\?

匹配前一个字符出现1次或者0次，即要么有1次，要么没有

{m}

匹配前一个字符出现m次

{m,}

匹配前一个字符至少出现m次

{n,m}

匹配前一个字符出现从n到m次

*：匹配前一个字符出现0次或者无限次，即可有可无 

import re
ret=re.match('[A-Z][A-Z]*','Mn').group()   #M
print(ret)
ret=re.match('[A-Z][a-z]*','Mn').group()   #Mn
print(ret)
ret=re.match('[A-Z][a-z]*','Python').group()   #Python
print(ret)

输出结果

M
Mn
Python

 + ：使用实例，写一个正则匹配python变量名（变量名的语法规则：不能以数字开头，变量名只能包含字母，数字，下划线）

import re
ret=re.match('[a-zA-Z_]+[\w]*','name').group()  #name
print(ret)
#ret=re.match('[a-zA-Z_]+[\w]*','123name').group()  #name  数字开头不是变量名，不能匹配

name

 ？：使用实例，匹配0-99的数字

import re
ret=re.match('[0-9]?[0-9]','25').group()  #25
print(ret)
ret=re.match('[0-9]?[0-9]','09').group()   #09
print(ret)
ret=re.match('[0-9]?[0-9]','9').group()   #9
print(ret)

{n,m} ：匹配前一个字符出现从n到m次,使用实例，匹配qq邮箱

import re
ret=re.match('[0-9]{6,11}@qq.com','123654@qq.com').group()
print(ret)

#123654@qq.com

注意：大于11位匹配失败，少于6位匹配失败

常用的匹配规则-原生字符串

python字符串中\作为转义字符开头，比如\n表示换行，\t表示tab键，为了表示\本身，再加一个\，成为\\形式 在python中表示路径‘G:\py资料\1-上课资料\4-正则表达式课件\html’

import re
#My_path='C:\Users\Administrator\Desktop\汀澜水岸.xlsx' #会报错
My_path='C:\\Users\\Administrator\\Desktop\\汀澜水岸.xlsx'
print(My_path)

下面使用正则表达式来匹配路径 

import re
#My_path=re.match('c:\\D.txt','c:\\D.txt').group()   #会报错
My_path=re.match('c:\\\\D.txt','c:\\D.txt').group()
print(My_path)

正则中\也表示转义，所以要匹配字符串中的\需要再次转义  

正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\"。

在python中有原生字符串，在字符串前面加上r表示字符串中的\不转义

import re
My_path=re.match(r'c:\\D.txt','c:\\D.txt').group()
print(My_path)

常用的匹配规则-匹配开头结尾

符号

匹配规则

^

匹配字符串开头

$

匹配字符串结尾

示例：匹配163.com的邮箱地址 

import re
ret = re.match('[\w]{4,20}@163\.com','python@163.com').group()
print(ret)   #python@163.com
ret = re.match('[\w]{4,20}@163\.com','python@163.comsdsdds').group()
print(ret)   #python@163.com  输出不完整
# 通过$来限定结尾
ret = re.match('[\w]{4,20}@163\.com$','python@163.comsdsdds').group()
print(ret)    #报错，不是以com结尾的

 输出结果

python@163.com
python@163.com

Traceback (most recent call last):
  File "E:/pythonProject9/Regex.py", line 127, in <module>
    ret = re.match('[\w]{4,20}@163\.com$','python@163.wercom').group()
AttributeError: 'NoneType' object has no attribute 'group'

常用的匹配规则- 分组匹配

符号

匹配规则

|

匹配左右任意一个表达式

(ab)

将括号中字符作为一个分组

\num

引用分组num匹配到的字符串

(?P)

分组起别名

(?P=name)

引用别名为name分组匹配到的字符串

 |：匹配出0-100之间的数字

import re
ret= re.match('[1-9]?\d','78').group()
print(ret)
ret= re.match('[1-9]?\d$|100','78').group()
print(ret)
ret= re.match('[1-9]?\d$|100','100').group()
print(ret)

输出结果

78
78
100

 (ab) 分组：分别匹配电号码区号和电话号码

import re
ret= re.match('([^-]*)-(\d*)','0756-12345678').group()
print(ret)
ret= re.match('([^-]*)-(\d*)','0756-12345678').group(0)
print(ret)
ret= re.match('([^-]*)-(\d*)','0756-12345678').group(1)
print(ret)
ret= re.match('([^-]*)-(\d*)','0756-12345678').group(2)
print(ret)

输出结果

0756-12345678
0756-12345678
0756
12345678

\ ：匹配html中的文本    \2 \1这种是直接引用之前的定义格式

import re
ret=re.match('<[a-zA-Z]*>(.*)</[a-zA-Z]*>','<div>hello world</div>').group()
print(ret)
ret=re.match('<[a-zA-Z]*>(.*)</[a-zA-Z]*>','<div>hello world</div>').group(1)
print(ret)
ret=re.match(r'<([a-zA-Z]*)>.*</\1>','<div>hello world</div>').group()
print(ret)   # \1 表示引用前面第一组
'''
在使用组引用的时候如果有多个组就容易造成混乱，比如下面多个组引用，
这样很混乱也不容易阅读
'''
ret = re.match(r'<(\w*)><(\w*)>.*</\2></\1>','<div><h1>www.baidu.com</h1></div>').group()
print(ret)
'''
解决上面这个问题得给分组起别名
(?P)分组起别名 P必须是大写
(?P=name)引用别名为name分组匹配到的字符串
'''
ret = re.match(r'<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>',
'<div><h1>www.baidu.com</h1></div>').group()
print(ret)

 输出结果

<div>hello world</div>
hello world
<div>hello world</div>

其实我们发现html的标签都是成对出现的，这样匹配规则html就可以引用组来实现，避免重复写。

\1 表示引用前面第一组

在使用组引用的时候如果有多个组就容易造成混乱，比如上面多个组引用，这样很混乱也不容易阅读

解决上面这个问题得给分组起别名

(?P)分组起别名

(?P=name)引用别名为name分组匹配到的字符串

re.complie方法

complie将正则表达式模式编译成一个正则表达式对象

reg = re.compile(pattern) result = reg.match(string)

等效于 result = re.match(pattern, string)

使用re.compile()和保存所产生的正则表达式对象重用效率更高

示例

import re
ret_obj=re.compile('\d{4}')
#开始去使用模式对象ret_obj
ret=ret_obj.match('123456')
print(ret.group())
#等同于
ret=re.match('\d{4}','123456').group()
print(ret)
import re
data='华为是华人的骄傲华侨人'
retobj=re.compile('华.')  #创建一次  多次使用
print(retobj.search(data))
print(retobj.findall(data))

re.search方法

search 在全文中匹配一次，匹配到就返回

语法：re.search(pattern, string, flags=0)

函数参数说明：

参数

描述

pattern

匹配的正则表达式

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

示例：扫描字符串，寻找的第一个由该正则表达式模式产生匹配的位置，并返回相应的MatchObject实例

import re
data='我爱我伟大的祖国，I love China，China is a great country'
re=re.search('China',data)   #只返回第一个对象，找到就返回
print(re)
print(re.group())

re.findall方法

findall 匹配所有返回一个列表，这个方法使用频率较高

语法：findall(string[, pos[, endpos]]) 

参数说明：

参数

描述

string

待匹配的字符串。

pos

可选参数，指定字符串的起始位置，默认为 0。

endpos

可选参数，指定字符串的结束位置，默认为字符串的长度。

查询字符串中某个正则表达式全部的非重复出现的情况 返回的是一个列表 

import re
data='华为是华人的骄傲华侨人'
re=re.findall('华.',data)
print(re)

运行结果

['华为', '华人', '华侨']

 示例：使用findall来匹配出段子网中的所有段子

re.sub方法

sub 将匹配到的数据进行替换 

语法：sub(pattern, repl, string, count=0, flags=0)

参数说明：

参数

描述

pattern

正则中的模式字符串。

repl

替换的字符串，也可为一个函数。

string

要被查找替换的原始字符串。

count

模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

flags

标志位，用于控制正则表达式的匹配方式

import re
data="Python是很受欢迎的编程语言，我喜欢Python"
pattern='[a-zA-Z]+'  #字符集的范围 +号代表
res=re.sub(pattern,'C#',data)
print(res)
#subn  实现目标的搜索和替换，还返回被替换的数量
res=re.subn(pattern,'C#',data)
print(res)

 运行结果

C#是很受欢迎的编程语言，我喜欢C#
('C#是很受欢迎的编程语言，我喜欢C#', 2)

re.split方法

split 根据匹配进行切割字符串，并返回一个列表 

语法：split(pattern, string, maxsplit=0, flags=0)

参数说明：

参数

描述

pattern

匹配的正则表达式

string

要匹配的字符串。

maxsplit

分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。

flags

标志位，用于控制正则表达式的匹配方式

import re
data='百度，腾讯，阿里，华为，360'
re=re.split("，",data)
print(type(re))
print(re)

运行结果

<class 'list'>
['百度', '腾讯', '阿里', '华为', '360']

3.贪婪模式与非贪婪模式

概述

Python里数量词默认是贪婪的,总是尝试匹配尽可能多的字符,非贪婪则相反，总是尝试匹配尽可能少的字符。

在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪.

import  re
#贪婪模式，取最多的
ret=re.match('\d{6,9}','111222333')
print(ret.group())
#非贪婪模式，取最少的
ret=re.match('\d{6,9}?','111222333')   #加一个？就是非贪婪模式
print(ret.group())

content='aacbscbc'
#贪婪模式，取最少的
pattern=re.compile('a.*b')
result=pattern.search(content)
print('贪婪模式%s'%result.group())
#贪婪模式，取最多的
pattern=re.compile('a.*?b')  #加一个？就是非贪婪模式
result=pattern.search(content)
print('非贪婪模式%s'%result.group())

运行结果

111222333
111222
贪婪模式aacbscb
非贪婪模式aacb

小结

元字符说明
\d匹配任意单个数字
\D匹配非数字
\w匹配任意单个字母数字下划线a-zA-Z_
\W匹配\w之外的任意单个字符
\s匹配单个空格
\S匹配非空白，除空格，tab键之类
\n匹配换行符
.匹配任意单个字符【换行符除外】
\num匹配前面引用的分组

 

正则表达式说明正确错误
A{3}精准N次匹配AAAAA、A、AAAA
A{3,}最少出现n次AAAA
\d{3,5}约定出现最少次数和最大次数
\d*可以出现0次至无限次相当于{0,}
\d+最少出现一次，相当于{1,}
\d?最多出现一次，相当于{0,1}  112
定位匹配
正则表达式说明正确错误
^A.*开头匹配ABCCBA
.*A$尾部匹配CBAABC
^A.*A$全字匹配ACCABAAA
字符的范围匹配
正则表达式说明正确错误
A精准匹配Aa
x|y允许匹配左右两边的字符x  或者   yn
[xyz]字符集合允许出现集合内任意单个字符x y za  b  c
[a-z][A-Z][0-9]字符范围
[^xyz][^0-9]取反，集合内字符不允许出现

 

Colorfully_lu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python正则匹配数字_python——正则匹配数字
weixin_39947314的博客
11-20 3767
数字：^[0-9]*$n位的数字：^\d{n}$至少n位的数字：^\d{n,}$m-n位的数字：^\d{m,n}$零和非零开头的数字：^(0|[1-9][0-9]*)$非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})?$正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$有两位...
Python基础语法_Day12
lanbingjie999的博客
07-17 177
68-元组 "元组： 类似列表（当成容器） 特点： 1. 定义的符号：() eg.(1,2,3) 2. 元组中的内容不可修改 3. 关键字: tuple " " 列表 元组 [] （） [1] (1,) [1,2] (1,2)" "t1 = () print(type(t1)) # <class 'tu...
python编译问题—Traceback (most recent call last): File “E:\python\pythonProject\文件读取.py“, line 3, in ＜
wxhxiaowen的博客
01-01 5216
File "E:\python\pythonProject\文件读取.py", line 3, in f=open(r'D:\测试.text',encoding="UTF-8")FileNotFoundError: [Errno 2] No such file or directory: 'D:\\测试.text'
line 4, in ＜module＞ ModuleNotFoundError: No module named ‘pip‘
行走
12-06 2698
pip install 报错 以下命令可解决 python -m ensurepip
Python3 错误和异常
weixin_33895604的博客
11-12 169
Edit笔记内容：Python3 错误和异常 笔记日期：2017-11-12Python3 错误和异常语法错误异常异常处理抛出异常用户自定义异常finally语句预定义的清理行为异常处理机制概述： 异常处理，是编程语言或计算机硬件里的一种机制，用于处理软件或信息系统中出现的异常状况（即超出程序正常执行流程的某些特殊条件）。通过异常处理，我们可以对用户在程序中的非法输入进行控制...
使用正则表达式时提示：DeprecationWarning: invalid escape sequence \w
Caoqingqing521的博客
11-19 3086
原因是Python3将字符串解释为Unicode字符串，因为正则中的D或者*就被视为转义的Unicode字符，解决的办法有两种： 原： data_mark_list = re.findall("#(\w+)#", case_str) # 列表 改过后： data_mark_list = re.findall(r"#(\w+)#", case_str) # 列表 或 data_mark_list = re.findall("#(|\w+)#", case_str) # 列表 总结：一种是：在
【python】常见正则表达式匹配练习
Evan_QB的博客
06-05 3561
收集一些常用的python正则练习 # 匹配出0-99之间的数字 print("---匹配出0-99之间的数字---") ret = re.match(r"^[1-9]?[0-9]$","77") print(ret.group()) # 8到20位的密码，可以是⼤⼩写英⽂字⺟、数字、下划线 print("---，8到20位的密码，可以是⼤⼩写英⽂字⺟、数字、下划线---") ret = r...
Python基础语法_Day10
lanbingjie999的博客
07-15 217
57-随机数+列表使用案例 # 产生10个随机数，将其保存到列表中 ''' 步骤： 1. 如何产生随机数 2. 10个数字产生 3. 将产生的随机数放到列表中 4. 打印列表 "import random # random_list=[] # 用来存放随机数 # for i in range(10): # ran = random.randint(1,20) # # 保存到列表中 # random_list.append(ran) # print(rando...
Python_正则表达式：Day16
12-22
正则表达式是一种用来匹配字符串的强有力的武器，它用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的。 用\d可以匹配一个数字，\w可以匹配一...
第11.17节 Python 正则表达式扩展功能：命名组功能及组的反向引用.rar
09-16
Python正则表达式是强大的文本处理工具，它允许程序员通过模式匹配来处理字符串。在Python中，正则表达式不仅提供了基本的匹配功能，还扩展了一些高级特性，其中包括命名组和组的反向引用。本节我们将深入探讨这两个...
Python-Python36及以上易懂的正则表达式
08-10
在Python编程语言中，正则表达式（Regular Expression，简称RE）是一种强大的文本处理工具，用于处理字符串。Python 3.6及更高版本对正则表达式的支持更加完善，提供了丰富的函数和模块来帮助开发者进行复杂的文本...
Java 正则表达式详解
09-06
正则表达式在许多编程语言中都有应用，包括Perl、PHP、Python、JavaScript等，并且在各种文本编辑器中也常用于高级搜索和替换。 ### 正则表达式基础 1. **句点符号 (.)** 句点符号代表任意单个字符，它可以匹配...
Python 09、正则表达式 1-1_PYTHON_RE_Day01_AM.mp4
02-19
Python 09、正则表达式 1-1_PYTHON_RE_Day01_AM.mp4
Python正则表达式基础知识总结
lifelegendc的博客
02-22 1059
一、正则表达式概念 Ÿ   使用单个字符串来描述匹配一系列符合某个句法规则的字符串 Ÿ   是对字符串操作的一种逻辑公式 Ÿ   应用场景：处理文本和数据 Ÿ   正则表达式过程：依次拿出表达式和文本中的字符比较，如果每一个字符都能匹配，则匹配成功；否则匹配失败   为什么使用正则？ 把匹配做成一个规则   ‘a’ 二、Python正则表达式re模块 #EXAMPLE #
正则表达式（Python）
Asaasa1的博客
11-20 361
一、概念 如果要处理的文件比较简单，直接使用字符串匹配就可以了，如下： 那么使用字符串匹配的python代码： def find_start_re(fname): f = open(fname,'r') for line in f: if line.startswith('re'): print(line) f.close() find_start_re('re.txt') 执行结果： 单个处理数据和文本，效率不高，不适合数据量大的场景，正
【Python】正则表达式
殷小速的博客
12-11 1037
正则表达式，又称规则表达式。(英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式（视则）的文本。（1）测试字符串的某个模式，即数据有效性验证（查找）（2）实现按照某种规则替换文本（3）根据模式匹配从字符串中提取一个子字符串（爬虫）原子（普通字符，如英文字符）、元字符（有特殊功能的字符）、以及模式修正字符组成。注意：一个正则表达式中至少包含一个原子。RegexBuddy。
用Python实现表达式求值，递归解法和栈解法（附详细代码和测试）
热门推荐
mmprintf的博客
08-17 1万+
问题描述： 输入四则运算表达式，仅由数字、+、-、*、/、()组成，没有空格，要求求其值，假设运算符结果都是整数，/结果也是整数 输入： (2+3)*(5+7)+9/3 输出： 63 第一种解法：eval()函数 >>> eval('(3+5)*2') 16 第二种解法：递归 搞清楚表达式的递归定义很关键 表达式=项或项的加减 项=因子或因子的乘除 因子=(...
正则基础知识
ChanCherry的博客
09-04 322
今天学了一点正则表达式的用法，记一记吧。 要用正则表达式，首先要包含re这个文件包进去，即import re。 ''' re.match('匹配的规则','用于匹配的内容')，从头开始匹配，找到一个就会停下 re.search() 搜索整个字符串 re.findall() 搜索整个字符串，返回一个List ''' print(re.match(r'a','abcd')) print(r...
正则表达式与文本处理
最新发布
A6985HG的博客
07-25 582
正则表达式（Regular Expression，简称 regex 或 regexp）是一种用于描述字符串模式的工具。它是一种强大的文本处理工具，用于查找、匹配、替换或验证字符串中的文本数据。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。sed（Stream EDitor）是一个强大而简单的文本解析转换工具，可以读取文本，并根据指定的条件对文本内容进行编辑（删除、替换、添加、移动等），最后输出所有行或者仅输出处理的某些行。
python日期正则表达式
04-02
Python中可以使用正则表达式来匹配和处理日期。以下是一些常见的Python日期正则表达式示例： 1. 匹配YYYY-MM-DD格式的日期： ```python import re date_pattern = r"\d{4}-\d{2}-\d{2}" date_string = "2022-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值