第五课 递归、模块、正则

时间：2021-05-31 04:37:12

一、递归

1、递归的定义：

　　在一个函数里再调用这个函数本身

2、递归的最大深度：997 ，可以通过sys模块修改

　　查看最大深度

def foo(n):
    print(n)
    n += 1
    foo(n)
foo(1)

修改最大深度

import sys
print(sys.setrecursionlimit(100000))

3、简单分析递归：

# 小例子：
# 猜年龄
# alex多大了     alex 比 wusir 大两岁  40+2+2
# wusir多大了    wusir 比 金老板大两岁   40+2
# 金老板多大了   40了
# age(1)
# n = 1 age(2)+2
# n = 2 age(3)+2
# n = 3 age(3) = 40

# def age(n):
#     if n == 3:
#         return 40
#     else:
#         return age(n+1)+2
#
# print(age(1))
分析执行过程：
# # n = 1
# def age(1):
#     if 1 == 3:
#         return 40
#     else:
#         return age(2)+2
#
# # n = 2
# def age(2):
#     if 2 == 3:
#         return 40
#     else:
#         return age(3)+2
#
# # n = 3
# def age(3):
#     if 3 == 3:
#         return 40

4、

# 递归求解二分查找算法
# 算法
# 99*99 = 99*(100-1) = 9900-99 = 9801
# 人类的算法
# 99 * 99

# 算法 计算一些比较复杂的问题
    # 所采用的 在空间上（内存里） 或者时间上（执行时间） 更有优势的方法
# 排序 500000万个数 快速排序 堆排序 冒泡排序
# 查找

# 递归求解二分查找算法 : 有序的数字集合的查找问题
# l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
# # 列表不能变
# def cal(l,num,start,end):
#     mid = (end - start)//2 + start
#     if l[mid] > num :
#         cal(l, num, start, mid-1)
#     elif l[mid] < num:      # 13  24
#         cal(l,num,mid+1,end)
#     else:
#         print('找到了',mid,l[mid])
#
# cal(l,60,0,len(l)-1)
# #
# # def cal(l,num=66):
# #     length = len(l)
# #     mid = length//2
# #     if num > l[mid]:
# #         l = l[mid+1:]
# #         cal(l,num)
# #     elif num < l[mid]:
# #         l = l[:mid]
# #         cal(l, num)
# #     else:
# #         print('找到了',l[mid],mid)
# # cal(l,66)
#
# l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
# def cal(l,66,0,24):
#     mid = 12 + 0
#     if 41 > 66 :
#         cal(l, num, start, mid-1)
#     elif 41 < 66:      # 13  24
#         cal(l,66,13,24)
#     else:
#         print('找到了',mid,l[mid])
#
# l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
# def cal(l,66,13,24):
#     mid = 5 + 13
#     if 67 > 66 :
#         cal(l, 66, 13, 17)
#     elif l[mid] < num:      # 13  24
#         cal(l,num,mid+1,end)
#     else:
#         print('找到了',mid,l[mid])
#
# l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
# def cal(l,66,13,17):
#     mid = 2 + 13
#     if 55 > 66 :
#         cal(l, num, start, mid-1)
#     elif 55 < 66:
#         cal(l,66,16,17)
#     else:
#         print('找到了',mid,l[mid])
#
# l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
# def cal(l,60,16,17):
#     mid =0 + 16
#     if 56 > 60 :
#         cal(l, num, start, mid-1)
#     elif 56 < 60:      # 13  24
#         cal(l,60,17,17)   #None
#     else:
#         print('找到了',mid,l[mid])
# #
# # l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
# def cal(l,60,17,17):
#     mid = 0 + 17
#     if 60 > 66 :
#         cal(l, num, start, mid-1)
#     elif 60 < 66:      # 13  24
#         return cal(l,60,18,17)
#     else:
#         print('找到了',17,66)
#
# def cal(l, 60, 18, 17):
#     if start <end:
#         mid = 0+18
#         if 67 > 66:
#             cal(l, 60, 18,17)
#         elif 60 < 66:  # 13  24
#             cal(l, 60, 18, 17)
#         else:
#             print('找到了', 17, 66)
#     else:
#         print('没找到')


# 算法
# def cal(l,num,start=0,end=None):
#     # if end is None:end = len(l)-1
#     end = len(l)-1 if end is None else end
#     if start <= end:
#         mid = (end - start)//2 + start
#         if l[mid] > num :
#             return cal(l, num, start, mid-1)
#         elif l[mid] < num:      # 13  24
#             return cal(l,num,mid+1,end)
#         else:
#             return mid
#     else:
#         return None
# l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
# print(cal(l,56))
# 参数太多       -------- ???
# 找的数不存在   ———— 解决了
# print   return  ------- 解决

 

 

二、模块

一概念：

1、模块定义：

　　一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀

 　　但其实import加载的模块分为四个通用类别：　

　　1 使用python编写的代码（.py文件）

　　2 已被编译为共享库或DLL的C或C++扩展

　　3 包好一组模块的包

　　4 使用C编写并链接到python解释器的内置模块

2、模块的导入和使用：

http://www.cnblogs.com/Eva-J/articles/7292109.html

3、模块补充：

为什么 这些模块中提供的方法 不能像print这些内置函数一样直接使用？
需要先导入模块再使用呢？
常用的 和某个操作相关的 根据相关性分类
分成不同的模块
模块还分为三种： 内置模块 扩展模块 自定义模块

二、常用模块

1、collections模块：

　　在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

　　1.namedtuple: 生成可以使用名字来访问元素内容的tuple

from collections import namedtuple
Point = namedtuple('point',['x','y'])
p = Point(1,2)
print(p.x)
print(p.y)
Card = namedtuple('card',['rank','suit'])
c = Card('2','红心')
print(c.rank,c.suit)

　　2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])
# from collections import deque
# q = deque()
# q.append(1)
# q.append(2)
# q.append(3)
# q.append(3)
# print(q)
# print(q.pop())
# print(q)
# q.appendleft('a')
# q.appendleft('b')
# q.appendleft('c')
# print(q)
# print(q.popleft())
# print(q.popleft())

　　3.Counter: 计数器，主要用来计数

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。

c = Counter('abcdeabcdabcaba')
print c
输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
其他详细内容 http://www.cnblogs.com/Eva-J/articles/7291842.html

　　4.OrderedDict: 有序字典

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)]) >>> d # dict的Key是无序的 {'a': 1, 'c': 3, 'b': 2} >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)]) >>> od # OrderedDict的Key是有序的 OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的顺序返回
['z', 'y', 'x']
# import collections
# d = collections.OrderedDict()
# print(d)
#
# d['电脑'] = 10000
# d['苹果'] = 10
# print(d)
# for i in d:
#     print(i,d[i])
# print(d['电脑'])

　　5.defaultdict: 带有默认值的字典

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： { 'k1' : 大于 66  ,  'k2' : 小于 66 } 
# import collections
# d = collections.OrderedDict()
# print(d)
#
# d['电脑'] = 10000
# d['苹果'] = 10
# print(d)
# for i in d:
#     print(i,d[i])
# print(d['电脑'])

# l= [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
# my_dict = {}
# for value in  l:
#     if value>66:
#         if my_dict.has_key('k1'):
#             my_dict['k1'].append(value)
#         else:
#             my_dict['k1'] = [value]
#     else:
#         if my_dict.has_key('k2'):
#             my_dict['k2'].append(value)
#         else:
#             my_dict['k2'] = [value]

# from collections import defaultdict
# values = [11, 22, 33,44,55,66,77,88,99,90]
# my_dict = defaultdict(list)
# for value in  values:
#     if value>66:
#         my_dict['k1'].append(value)
#     else:
#         my_dict['k2'].append(value)
# 默认这个字典的value是一个空列表
# d = {}
# print(my_dict)
# my_dict['a'].append(1)
# my_dict['b'].append(2)
# my_dict['c'] = 10
# print(my_dict)

2、时间模块

和时间有关系的我们就要用到时间模块。在使用模块之前，应该首先导入这个模块。

#常用方法
1.time.sleep(secs)
(线程)推迟指定的时间运行。单位为秒。
2.time.time()
获取当前时间戳

 

表示时间的三种方式

在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：

(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

(2)格式化的时间字符串(Format String)： ‘1999-12-06’

python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

 

(3)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

索引（Index） 属性（Attribute） 值（Values）
0 tm_year（年） 比如2011
1 tm_mon（月） 1 - 12
2 tm_mday（日） 1 - 31
3 tm_hour（时） 0 - 23
4 tm_min（分） 0 - 59
5 tm_sec（秒） 0 - 60
6 tm_wday（weekday） 0 - 6（0表示周一）
7 tm_yday（一年中的第几天） 1 - 366
8 tm_isdst（是否是夏令时） 默认为0

 首先，我们先导入time模块，来认识一下python中表示时间的几种格式：

第五课 递归、模块、正则 
#导入时间模块
>>>import time

#时间戳
>>>time.time()
1500875844.800804

#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'

#时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
　　　　　　　　　　tm_hour=13, tm_min=59, tm_sec=37, 
                 tm_wday=0, tm_yday=205, tm_isdst=0)
第五课 递归、模块、正则

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

几种格式之间的转换

第五课 递归、模块、正则

第五课 递归、模块、正则 
#时间戳-->结构化时间
#time.gmtime(时间戳)    #UTC时间，与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间 
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#结构化时间-->时间戳　
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0
第五课 递归、模块、正则
第五课 递归、模块、正则 
#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传，则现实当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'

#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
第五课 递归、模块、正则

 

第五课 递归、模块、正则

第五课 递归、模块、正则 
#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.asctime()
'Mon Jul 24 15:18:33 2017'

#时间戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
>>>time.ctime()
'Mon Jul 24 15:19:07 2017'
>>>time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017' 
第五课 递归、模块、正则计算时间差： 
import time
true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

　之前的转换方式：时间戳 《--》 结构化时间 《--》 格式化时间

datetime 日期时间

3、random模块

>>> import random
#随机小数
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585
>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838
#恒富：发红包

#随机整数
>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
>>> random.randrange(1,10,2) # 大于等于1且小于10之间的奇数


#随机选择一个返回
>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#随机选择多个返回，返回的个数为函数的第二个参数
>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']


#打乱列表顺序
>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

练习：生成随机验证码

4、sys 模块

sys模块是与python解释器交互的一个接口

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
import sys  # python解释器
# sys.exit()   # 解释器退出 程序结束
# print('*'*10)
# print(sys.path)
# 一个模块是否能够被导入 全看在不在sys.path列表所包含的路径下
# print(sys.modules)  # 放了所有在解释器运行的过程中导入的模块名

# print(sys.argv)
# if sys.argv[1] == 'alex' and sys.argv[2] == 'alex3714':
#     print('可以执行下面的n行代码')
# else:
#     sys.exi()
# 在执行python脚本的时候，可以传递一些参数进来
# mysql username password

5、os模块

 os模块是与操作系统交互的一个接口

'''
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.environ  获取系统环境变量

os.path
os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。
                        即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
'''

注意：os.stat('path/filename')  获取文件/目录信息 的结构说明

stat 结构:

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。
import os # os模块
# print(os.getcwd())
# os.chdir(r'D:\EVA')
# print(os.getcwd())
# open('aaaaaaa','w').close()   # 文件创建到了当前工作目录下

# import os
# 'path1%spath2'%os.pathsep

# import os
# os.system("dir")   # exec
# ret = os.popen('dir').read()
# print(ret)

# win linux
    # 操作系统自己有的一种简单的语言
#
# print(os.path.abspath('4.模块.py'))
# print(os.path.dirname(r'D:\EVA\周末班python21\day5\4.模块.py'))
# print(os.path.split(r'D:\EVA\周末班python21\day5\4.模块.py'))
# print(os.path.basename(r'D:\EVA\周末班python21\day5\4.模块.py'))
# # print('\\n\\t\\t\\n')
# print(r'\n\t\t\n')   # real
# print(os.path.dirname(r'D:\EVA\周末班python21\day5'))
#
# print(os.path.join('D:\\','EVA','PYTHON','AAA'))

# print(os.path.getsize(r'D:\EVA\周末班python21\day5\4.模块.py'))
# print(os.path.getsize(r'D:\EVA\周末班python21\day5'))
# ret = os.listdir(r'D:\EVA\周末班python21\day5')
# print(ret)
# sum = 0
# for path in ret:
#     if os.path.isfile(path) is True:
#         sum+= os.path.getsize(path)
# print(sum)

 5、re 模块　

1、字符组 ： [字符组]
　　在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示
　　字符分为很多类，比如数字、字母、标点等等。
　　假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。
2、
正则
 
待匹配字符
 
匹配
结果
 
说明
 
[0123456789]
 
8
 
True
 
在一个字符组里枚举合法的所有字符，字符组里的任意一个字符
和"待匹配字符"相同都视为可以匹配
 
[0123456789]
 
a
 
False
 
由于字符组中没有"a"字符，所以不能匹配
  
[0-9]
   
7
 
True
 
也可以用-表示范围,[0-9]就和[0123456789]是一个意思
  
[a-z]
   
s
   
True
   
同样的如果要匹配所有的小写字母，直接用[a-z]就可以表示
  
[A-Z]
   
B
   
True
   
[A-Z]就表示所有的大写字母
  
[0-9a-fA-F]
   
e
   
True
   
可以匹配数字，大小写形式的a～f，用来验证十六进制字符

　3、字符　　

字符：

  
元字符
   
匹配内容
.  匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线
\s 匹配任意的空白符
\d 匹配数字
\n 匹配一个换行符
\t 匹配一个制表符
\b 匹配一个单词的结尾
^ 匹配字符串的开始
$ 匹配字符串的结尾
\W 
匹配非字母或数字或下划线
\D 
匹配非数字
\S 
匹配非空白符
a|b 
匹配字符a或字符b
() 
匹配括号内的表达式，也表示一个组
[...] 
匹配字符组中的字符
[^...] 
匹配除了字符组中字符的所有字符

 

量词：

 

量词
 
用法说明
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

 

 

 

 

 

 

 

 

 

 

 

 

. ^ $

正则 待匹配字符 匹配
结果		 说明
海. 海燕海娇海东 海燕海娇海东   匹配所有"海."的字符
^海. 海燕海娇海东 海燕 只从开头匹配"海."
  海.$   海燕海娇海东 海东 只匹配结尾的"海.$"

 

* + ? { }

正则 待匹配字符 匹配
结果		 说明
李.? 李杰和李莲英和李二棍子

李杰
李莲
李二

   
?表示重复零次或一次，即只匹配"李"后面一个任意字符
 
李.* 李杰和李莲英和李二棍子 李杰和李莲英和李二棍子 
*表示重复零次或多次，即匹配"李"后面0或多个任意字符
李.+ 李杰和李莲英和李二棍子 李杰和李莲英和李二棍子 
+表示重复一次或多次，即只匹配"李"后面1个或多个任意字符
李.{1,2} 李杰和李莲英和李二棍子

李杰和
李莲英
李二棍

 
{1,2}匹配1到2次任意字符

 注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配

 

正则 待匹配字符 匹配
结果		 说明
李.*? 李杰和李莲英和李二棍子 李
李
李		 惰性匹配

字符集［］［^］

正则 待匹配字符 匹配
结果		 说明
李[杰莲英二棍子]* 李杰和李莲英和李二棍子

李杰
李莲英
李二棍子

   
表示匹配"李"字后面[杰莲英二棍子]的字符任意次
 
李[^和]* 李杰和李莲英和李二棍子

李杰
李莲英
李二棍子

 
表示匹配一个不是"和"的字符任意次
[\d] 456bdha3

4
5
6
3

 
表示匹配任意一个数字，匹配到4个结果
[\d]+ 456bdha3

456
3

 
表示匹配任意个数字，匹配到2个结果

 

分组 ()与 或 ｜［^］

 身份证号码是一个长度为15或18个字符的字符串，如果是15位则全部????️数字组成，首位不能为0；如果是18位，则前17位全部是数字，末位可能是数字或x，下面我们尝试用正则来表示：

正则 待匹配字符 匹配
结果		 说明
^[1-9]\d{13,16}[0-9x]$ 110101198001017032

110101198001017032

    表示可以匹配一个正确的身份证号
^[1-9]\d{13,16}[0-9x]$ 1101011980010170

1101011980010170

 
表示也可以匹配这串数字，但这并不是一个正确的身份证号码，它是一个16位的数字
^[1-9]\d{14}(\d{2}[0-9x])?$ 1101011980010170

False

 
现在不会匹配错误的身份证号了
()表示分组，将\d{2}[0-9x]分成一组，就可以整体约束他们出现的次数为0-1次
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$ 110105199812067023

110105199812067023

 
表示先匹配[1-9]\d{16}[0-9x]如果没有匹配上就匹配[1-9]\d{14}

 

转义符 \

在正则表达式中，有很多有特殊意义的是元字符，比如\d和\s等，如果要在正则中匹配正常的"\d"而不是"数字"就需要对"\"进行转义，变成'\\'。

在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\d",字符串中要写成'\\d'，那么正则里就要写成"\\\\d",这样就太麻烦了。这个时候我们就用到了r'\d'这个概念，此时的正则是r'\\d'就可以了。

正则 待匹配字符 匹配
结果		 说明
\d \d  False 
因为在正则表达式中\是有特殊意义的字符，所以要匹配\d本身，用表达式\d无法匹配
\\d \d  True 
转义\之后变成\\，即可匹配
"\\\\d" '\\d'  True 
如果在python中，字符串中的'\'也需要转义，所以每一个字符串'\'又需要转义一次
r'\\d' r'\d'  True 
在字符串之前加r，让整个字符串不转义

 

贪婪匹配

贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配

正则 待匹配字符 匹配
结果		 说明
<.*>

<script>...<script>

 <script>...<script> 
默认为贪婪匹配模式，会匹配尽量长的字符串
<.*?> r'\d'  

<script>
<script>

 
加上？为将贪婪匹配模式转为非贪婪匹配模式，会匹配尽量短的字符串
 
几个常用的非贪婪匹配Pattern
*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
.*?的用法
第五课 递归、模块、正则 
. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：
.*?x

就是取前面任意长度的字符，直到一个x出现
第五课 递归、模块、正则

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']

#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。
第五课 递归、模块、正则

 

综合练习与扩展

1、匹配标签

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>

2、匹配整数

 

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']

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、 匹配出所有整数

4、爬虫练习

code:
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

flag

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字符串可以是多行的，忽略空白字符，并可以添加注释

 

标签：

相关文章