Python之递归与正则

最新推荐文章于 2024-01-21 11:45:50 发布
最新推荐文章于 2024-01-21 11:45:50 发布
阅读量418 收藏
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40199698/article/details/87927221
版权

一.递归
# 在一个函数中调用自己
# count = 0
# def fun():
#     global count
#     count += 1
#     print("第%s次调用自己" %(count))
#     fun()
# fun() # ==> 输出到第998次，递归最大深度默认998或997
# 递归最大深度可修改
# import sys
# sys.setrecursionlimit(1500)
# count = 0
# def fun():
#     global count
#     count += 1
#     print("第%s次调用自己" %(count))
#     fun()
# fun()
# 输出到第1498次
# 斐波那契数列 1,1,2,3,5,8,13...
#f(n) = f(n-1) + f(n-2)

# def fun(n):
#     if n == 1 or n == 2:
#         return 1
#     else:
#        return fun(n-1) + fun(n-2)
#
# ret = fun(1)
# print(ret)
# ret = fun(2)
# print(ret)
# ret = fun(3)
# print(ret)
# ret = fun(4)
# print(ret)
# ret = fun(5)
# print(ret)
# ret = fun(6)
# print(ret)
# ret = fun(50)  # 计算速度剧烈下降，递归在深度增加的同时，广度也在增加
# print(ret)
# 修改只朝深度方向走
# def fun(n):
#     if n == 1 or n == 2:
#         return 1,1
#     else:
#         a,b = fun(n-1)
#         return b,a+b
#
# ret = fun(50)[1]
# print(ret)
-----------------------------------------------------------------------
二.正则
# re模块
'''
正则表达式的特殊字符
  . 普通模式下，匹配除换行符外的任意一个字符，如果指定了模式(DOTALL标记)，换行符也可以匹配
  ^ 匹配一个字符串的开始，在(多行模式)MULTLINE模式下，也匹配新行的开始
  $ 匹配一个字符串的结束，在多行模式下，可以匹配任意一行的结束
正则表达式的数量符号
  * 指定前面的字符出现0次或任意次，普通情况下贪婪匹配
  + 指定前面的字符出现1次或任意次
  ？指定前面的字符出现0次或1次
  *？ +？ ?? 惰性匹配，匹配尽可能少的字符
  {m,n} 指定字符出现m到n次，贪婪匹配,{,n} 0~n次；{m,} m~无限次
  {m,n}? 惰性匹配，匹配尽可能少的字符
  \ 转义，让特殊字符只代表本身的符号
  [] 指定字符集合，集合内的所有特殊字符均为符号本省,且是或的关系例如：[acm.]匹配a,c,m,.四个符号中任意的一个或多个
     [^] 标识取反，[^a]匹配不含有a的
  | 或，从左到右匹配，如果匹配上了左边，则右边不再匹配，是惰性匹配
  () 分组，组默认有编号，可以提取例如：abc(eee)dfg,匹配后可以使用\1提取匹配到的‘eee’
  (?...) 表达式扩展符号，除?P之外;(?iLmsux),iLmsux可以任意一个或多个组合,要与re.I(忽略大小写),re.L(依赖locale),re.M(多行模式)
         re.S(匹配所有字符),re.U(依赖Unicode),re.X(详细模式)
  (?:...) 匹配内部的真则所匹配的内容，但是不分组
  (?P<gname>) 分组，且自定义组名，默认是数字
  (?#...) 注释，括号中的内容会忽略
  (?=...) 前瞻断言，匹配指定字符后面跟着括号中的内容的字符串 -- abc(?=fff)匹配后面有fff的abc:abcfff能匹配
  (?!...) 反前瞻断言,与上相反,匹配指定字符串后不跟括号中内容的字符串 -- abc(?!fff)匹配后面不是fff的abc:abcfff不能匹配
  (?<=...) 后顾断言，匹配指定字符串前面有括号中内容的字符串 -- (?<=abc)def匹配前面是abc的def:abcdef可以匹配
  (?<!...) 反后顾断言,与上相反,匹配指定字符串前面不包含括号中内容的串 -- (?<!abc)def匹配def前面不是abc的串:abcdef不能匹配
  (?(id/name))yes-pattern|no-pattern) 如果由id或name指定的组存在的话。将会匹配yes-pattern,否则将会匹配no-pattern
                                      通常情况下no-pattern可以省略，例如：(<)(\w+@\w+(?:\.\w+)+)(?(1)>)可以匹配
                                      <user@host.com> 和 user@host.com
                                      不能匹配<user@host.com
  \w 匹配字母或数字或下划线或汉字
  \s 匹配任意的空白
  \d 匹配数字
  \b 匹配单词边界
'''
import re
# s1 = 'abc'
# s2 = '_bc'
# ret = re.match('.',s1)  # . 匹配任意字符,re.match匹配字符串开头,返回一个对象，需要用goup取值
# print(ret.group())
# ret = re.match('.',s2)  # . 匹配任意字符
# print(ret.group())

# s1 = 'foo1\nfoo2\nfoo3'
# ret = re.findall('foo.$',s1) # 匹配以foo+一个任意字符结束的串
# print(ret) # ==>['foo3'] 返回匹配到的串组成的列表
#
# s1 = 'foo1\nfoo2\nfoo3'
# ret = re.findall('foo.$',s1,re.MULTILINE) # 匹配以foo+一个任意字符结束的串,多行模式
# print(ret) # ==> ['foo1', 'foo2', 'foo3'] 返回匹配到的串组成的列表
#
# s1 = 'foo1\nfoo2\nfoo3'
# ret = re.findall('foo.$',s1,re.M) # 匹配以foo+一个任意字符结束的串,多行模式第二种写法
# print(ret) # ==> ['foo1', 'foo2', 'foo3'] 返回匹配到的串组成的列表

# s0 = 'ab'
# s1 = 'abc'
# s2 = 'abbc'
# s3 = 'abbbbbbbbbbbbbbbbbbbbc'
# ret = re.search('.b*.',s0) # 匹配前后各一个字符，中间可有含有b或不含b的串
# print(ret.group())
# ret = re.search('.b*.',s1) # 匹配前后各一个字符，中间可有含有b或不含b的串
# print(ret.group())
# # ret = re.search('.b+.',s0) # 匹配前后各一个字符，中间至少含有一个b的串--异常
# # print(ret.group())
# ret = re.search('.b?.',s0) # 匹配前后各一个字符，中间只有一个或没有b的串
# print(ret.group())
# ret = re.search('.b?.',s1) # 匹配前后各一个字符，中间只有一个或没有b的串
# print(ret.group())

# s1 = '<H1>title</H1>'
# ret = re.findall('<.*>',s1) # 贪婪匹配--匹配了最外层的<>
# print(ret) # ==> ['<H1>title</H1>']
# ret = re.findall('<.*?>',s1) # 惰性匹配--匹配了最少的<>,<>中间不再包含<>
# print(ret) # ==> ['<H1>', '</H1>']

# s1 = 'abbbbbc'
# s2 = 'abbbc'
# ret = re.findall('b{2,5}',s1) # 贪婪匹配,匹配多的b
# print(ret) # ==> ['bbbbb']
# ret = re.findall('b{2,5}?',s1) # 贪婪匹配,匹配多的b
# print(ret) # ==> ['bb', 'bb']
# ret = re.findall('b{3}',s1) # 贪婪匹配,匹配3个的b
# print(ret) # ==> ['bbb']

# s1 = 'acfegh'
# ret = re.findall('[abg]',s1) # 匹配字符a或b或g
# print(ret) # ==> ['a', 'g']
# ret = re.findall('[^abg]',s1) # 不匹配字符a或b或g
# print(ret) # ==> ['c', 'f', 'e', 'h']

# s1 = 'ab|abc|abcdef'
# ret = re.findall('ab|abc|abcdef',s1) # 匹配字符ab
# print(ret) # ==> ['ab', 'ab', 'ab']
# ret = re.findall('abc|abcdef',s1) # 匹配字符abc
# print(ret) # ==> ['abc', 'abc']

# s1 = 'hello,every one'
# ret = re.search('.*(every).*',s1) # 将every分组为1
# print(ret.group()) # ==> hello,every one
# print(ret.group(1)) # ==> every

# s1 = 'foo1\nfoo2\nfoo3\n'
# ret = re.findall('(?m)(foo.$)',s1)  # 多行模式第三种写法
# print(ret) # ==> ['foo1', 'foo2', 'foo3']

# s1 = 'foo1\nfoo2\nfoo3\n'
# ret = re.findall('.*',s1)  # 匹配不了换行符
# print(ret) # ==> ['foo1', '', 'foo2', '', 'foo3', '', '']
#
# ret = re.findall('.*',s1,re.S) # 可以匹配换行符
# print(ret) # ==> ['foo1\nfoo2\nfoo3\n', '']
#
# ret = re.findall('(?s)(.*)',s1) # 匹配换行符的第二种写法
# print(ret) # ==> ['foo1\nfoo2\nfoo3\n', '']

# s1 = 'today is a good day'
# ret = re.findall('.*(?P<g1>good).*',s1)
# print(ret)
# ret = re.search('.*(?P<g1>good).*',s1) # 分组名为g1
# print(ret.group()) # ==> today is a good day
# print(ret.group('g1')) # ==> good 通过g1组名取值

# s1 = 'today is a good day'
# s2 = 'yestoday is a nice day'
# ret = re.findall('good (?=day).*',s1) # 前瞻断言'good '后面有day的串
# print(ret) # ==> ['good day']
# ret = re.findall('good (?=day).*',s2)
# print(ret) # ==> []

# s1 = 'today is a good day'
# s2 = 'yestoday is a nice day'
# ret = re.findall('a (?!good).*',s1) # 反前瞻断言'a '后面不是good的串
# print(ret) # ==> []
# ret = re.findall('a (?!=good).*',s2)
# print(ret) # ==> ['a nice day']

# s1 = 'today is a good day'
# s2 = 'yestoday is a nice day'
# ret = re.findall('.*(?<=good) day',s1) # 后顾断言' day'前面是good的串
# print(ret) # ==> ['today is a good day']
# ret = re.findall('.*(?<=good) day',s2)
# print(ret) # ==> []

# s1 = 'today is a good day'
# s2 = 'yestoday is a nice day'
# ret = re.findall('.*(?<!good) day',s1) # 反后顾断言' day'前面不是good的串
# print(ret) # ==> []
# ret = re.findall('.*(?<!good) day',s2)
# print(ret) # ==> ['yestoday is a nice day']

'''
  (?(id/name))yes-pattern|no-pattern) 如果由id或name指定的组存在的话。将会匹配yes-pattern,否则将会匹配no-pattern
                                      通常情况下no-pattern可以省略，例如：(<)(\w+@\w+(?:\.\w+)+)(?(1)>)可以匹配
                                      <user@host.com> 和 user@host.com
                                      不能匹配<user@host.com
'''
s1 = '<user1@host.com>'
s2 = 'user2@host.com.cn'
s3 = '<user3@host.com'
ret = re.search('(<)?(\w+@\w+(?:\.\w+)+)(?(1)>)',s1)
print(ret.group()) # ==> <user1@host.com>
ret = re.search('(<)?(\w+@\w+(?:\.\w+)+)(?(1)>)',s2)
print(ret.group()) # ==> user2@host.com.cn
ret = re.search('(<)(\w+@\w+(?:\.\w+)+)(?(1)>)',s3)
print(ret.group()) # ==> 异常


# re.compile('正则','模式') # 模式：re.M,re.S...

# s1 = 'today is a good day'
# print(re.split('ay',s1)) # 以ay为分割符，切割字符串，增则不可为空

# s1 = 'today is a good day'
# print(re.sub('g.*?d','GOOD',s1)) # 用指定字符串替换正则匹配到的串

参考文档：

https://www.cnblogs.com/JayeHe/p/6656799.html

CODE_Lph
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python全栈开发—递归、算法基础、正则表达式
解启超
06-17 236
递归 特点 递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。 递归算法解决问题的特点： (1) 递归就是在过程或函数里调用自身。 (2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。 (3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。 (...
正则表达式匹配---递归解法
qq_42366884的博客
05-18 1228
题目： 给定一个字符串 (s) 和一个字符模式 （p）。实现支持 ‘.’ 和 ‘*’ 的正则表达式匹配。 首先对于递归，我们不能想的太复杂，因为在方法中会不断的调用自己，所以在写的时候我们需要认为这个方法已经写好了，他的作用就是输入一个字符串和正则表达式，返回是True or False。 然后我们需要知道当方法执行到最后会出现的基本情况，以此来终止循环。 解题思路： 对于这道题，我们不难想象如果...
PYthon-递归
weixin_43499803的博客
11-23 198
文章目录基础 基础 定义：函数调用自身 def recursion(): return recusion 理论上函数无限调用，python设置深度最多100次 修改递归最大深度 import sys sys.setrecursionlimit(120) 递归求阶乘
Python---正则表达式与递归
weixin_43961909的博客
05-02 990
这三种邮箱地址，规则为：^[\w-]+(\.[\w-]+)*@(qq|163|gmail)(\.[\w-]+)+&匹配成功返回匹配对象（包含匹配的信息），匹配不成功返回空。匹配成功返回匹配对象（包含匹配的信息），匹配不成功返回空。位，规则为： ^[0-9a-zA-Z]{6, 10}$0，规则为：^[1-9][0-9]{4, 10}&匹配整个字符串，找出全部匹配项，找不到返回空。从头开始匹配，匹配第一个命中项。从被匹配字符串开头进行匹配，从被匹配字符串开头进行匹配，全局匹配，匹配第一个命中项。
Python正则表达式用法简介
烟雨
12-27 209
正则表达式介绍 在编程中，字符串是涉及到的最多的一种数据结构，对字符串进行操作的需求几乎无处不在。比如判断一个字符串是否是合法的Email地址，虽然可以编程提取@前后的子串，再分别判断是否是单词和域名，但这样做不但麻烦，而且代码难以复用。 正则表达式是一种用来匹配字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该...
python 正则表达式生成_Python 迭代器、生成器、递归、正则表达式 (四)
weixin_39670441的博客
11-28 171
一、迭代器&生成器1、迭代器仅仅是一容器对象，它实现了迭代器协议。它有两个基本方法：1）next 方法　　返回容器的下一个元素2)_iter_方法　　返回迭代器自身。迭代器可以使用内建的iter方法创建ts = iter(['asd','sds','qweq'])#创建iter方法print(ts.__next__())#使用_next_方法返回下一个元素print(ts.__next__())p...
Python-递归
08-21
​是指函数/过程/子程序在运行过程序中直接或间接调用自身而产生的重入现象。在计算机编程里，递归指的是一个过程：函数不断引用自身，直到引用的对象已知。
python这些函数什么意思啊，菜鸟求解
weixin_53184356的博客
12-02 187
import re def main(): # 创建正则表达式对象 使用了前瞻和回顾来保证手机号前后不应该出现数字 pattern = re.compile(r’(?<=\D)1[34578]\d{9}(?=\D)’) sentence = ‘’’ 重要的事情说8130123456789遍，我的手机号是13512346789这个靓号， 不是15600998765，也是110或119，王大锤的手机号才是15600998765。 ‘’’ # 查找所有匹配并保存到一个列表中 mylist = re.find
循序渐进掌握递归正则表达式【推荐】
12-13
一般来说，递归的正则表达式用来匹配任意嵌套层次的...下面这个正则表达式是在网上流传的非常广泛的递归正则的示例，它用来匹配嵌套任意次数的括号，括号内可以有其它字符，比如可以匹配(a(bc)de)、(abc(bc(def)c)de)。
python正则表达式之作业计算器
12-23
用户输入 1 – 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) – (-4*3)/ (16-3*2) )等类似公式后，必须自己解析里面的(),+,-,*,/符号和公式，运算后得出结果，结果必须与真实的计算器所得出...
Python基础入门知识之正则表达式学习 正则表达式30分钟入门教程 共21页.pdf
06-04
目录 一、 本文目标 3 二、 如何使用本教程 3 三、 正则表达式到底是...十七、 贪婪与懒惰 16 十八、 处理选项 17 十九、 平衡组/递归匹配 18 二十、 还有些什么东西没提到 20 二十一、 网上的资源及本文参考文献 21
正则表达式匹配
12-22
我理解的就是递归，一直在判断“*”的存在，最后递归得出结果 class Solution: def isMatch(self, s: str, p: str) -> bool: if not p: return not s f= bool(s and p[0] in {s[0],'.'}) if len(p) >= 2 and p...
regular-expression-in-hy:Hy python正则表达式
05-15
我使用hylang进行正则表达式，但这并不意味着javascript / java / python中的regx不好（它们已经足够好了！），并且我不想替换它们。 这只是为了显示lisp函数编程的便利性。 好了，现在我实现了一个使用hy（python...
python中的递归正则表达式如何实现
12-14 50
本文介绍了如何在python中实现递归正则表达式的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
python学习笔记(8.网络编程9.正则表达式10.递归)
okokok的博客
12-12 513
又称规则表达式（Regular Expression），是使用单个字符串来描述、匹配某个句法规则的字符串，常被用来检索、替换那些符合某个模式（规则）的文本。[\w-]+)*@[\w-]+(.[\w-]+）+$） 即可匹配一个字符串是否是标准邮箱格式。search（匹配规则， 被匹配字符串）搜索整个字符串，从前向后，找一个。findall（匹配规则， 被匹配字符串）匹配整个字符串，找出全部匹配项。re.match（匹配规则， 被匹配字符串）从头匹配。字符串定义规则，并通过规则去验证字符串是否匹配。
学习python仅此一篇就够了（正则表达式，递归）
最新发布
杜小帅的博客
01-21 319
搜索整个字符串，找出匹配的。从前向后，找到第一个后，就停止，不会继续向后。从被匹配字符串开头进行匹配，匹配成功返回匹配对象，匹配不成功返回空。re.match(匹配规则，被匹配字符串)findall(匹配规则， 被匹配字符串)search(匹配规则，被匹配字符串)匹配整个字符串，找出全部匹配项。
理解正则表达式中的(?R)递归
蓝翔顶级电脑技工
11-18 8397
先来个最简单的正则表达式递归 字符串 ：abc123dsf654wre485wer652 传统作法：\w{3}\d{3}\w{3}\d{3}\w{3}\d{3}\w{3}\d{3} 递归做法：(\w{3}\d{3}|(?R))* 你看递归的好处，精悍短少（有力），传统作法无法比拟。 在网上找了一番正则递归的资料，最终谷歌了一下，还是在PHP官网上面找到我想要的示例。<?php $st
【leetcode】正则表达式匹配【python】【递归，后序遍历】
fanc的博客
10-06 518
题目地址 class Solution(object): def myMatch(self, s, p, s_index, p_index): print(s_index, p_index) if p == '' and s != '': #print(1) return False if s...
基于递归正则表达式匹配基于python
03-16
基于递归的正则表达式匹配是一种常见的字符串匹配算法，可以用于在Python中实现正则表达式的匹配功能。该算法通过递归地遍历正则表达式和待匹配字符串，逐个字符进行匹配，直到匹配成功或者失败。在Python中，可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值