目录：

一、笔记

二、我的自学路线

三、笔记目录

一、笔记

① 正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

② 正则表达式中包含两个部分，一个是正则语法对应的字符，二个是普通字符，例如：fullmatch(正则表达式字符串，字符串) - - > 判断正则表达式和字符串是否完全匹配。

③ 正则表达式字符串：就是一个字符串，字符串中是正则表达式语法，即 r'正则表达式'。

④ 正则表达式检查字符串满不满足条件，满足的话就返回对象，不满足条件就为空。

⑤ 正则表达式的用处：1. 判断字符串是否满足某个条件.....判断输入的字符是否是邮箱/手机号码。是否是ip地址。

2. 提取满足条件的字符串。

3. 字符串替换。

⑥ compile函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

⑦ re模块提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数，re模块使Python语言拥有全部的正则表达式功能，

⑧ re.match()尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

#coding=utf-8

import re

# 一个 .(点)为只能匹配一个任意字符

pattern = r'a.b' # 匹配三个字符，左边是a，右边是b，中间为任意字符(除换行符以外，都可以)，如果是四个字符就匹配不成功

result1 = re.fullmatch(pattern,'a|b') # fullmatch()为完全匹配，即正则表达式与需要匹配的字符串，模式要完全相等

result2 = re.fullmatch(pattern,'a|b1')

print(result1) # 字符串满足正则表达式返回对象，不满足为空。

print(result2) # span = [0,3) 是一个左闭右开的索引，result1.span() 为索引两端元素组成的元组

print(type(result1))

print(type(result2))

print(result1,result1.span(),result1.group()) # result1.group()为匹配的结果，它是一个字符串类型

运行结果：

None

(0, 3) a|b

#coding=utf-8

import re

# 一个\w匹配一个字符是字母或数字或下划线的字符

pattern = r'\w...'

result1 = re.fullmatch(pattern,r'a*cb')

result2 = re.fullmatch(pattern,r'4\nb')

result3 = re.fullmatch(pattern,r'_(qb')

result4 = re.fullmatch(pattern,r'*\nb')

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

if result2:

print(result2,result2.span(),result2.group())

else:

print(result2)

if result3:

print(result3,result3.span(),result3.group())

else:

print(result3)

if result4:

print(result4,result4.span(),result4.group())

else:

print(result4)

运行结果：

(0, 4) a*cb

(0, 4) 4\nb

(0, 4) _(qb

None

#coding=utf-8

import re

# 一个\W匹配一个字符是非字母或非数字或非下划线的字符

pattern = r'\W...'

result1 = re.fullmatch(pattern,r'a*cb')

result2 = re.fullmatch(pattern,r'4\nb')

result3 = re.fullmatch(pattern,r'_(qb')

result4 = re.fullmatch(pattern,r'*\nb')

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

if result2:

print(result2,result2.span(),result2.group())

else:

print(result2)

if result3:

print(result3,result3.span(),result3.group())

else:

print(result3)

if result4:

print(result4,result4.span(),result4.group())

else:

print(result4)

运行结果：

None

None

None

(0, 4) *\nb

#coding=utf-8

# 一个\b不会去匹配一个字符，而是单纯的检测\b出现的位置是否是单词边界

# 单词边界: 字符串开始和结尾、空格、换行、标点符号等，可以将两个单词隔开的字符都单词边界

pattern1 = r'\babc' # 匹配字符串abc中的a为单词边界，abc是拿来匹配的单词

pattern2 = r'abc\b\saaa' # 匹配字符串abc中的c为单词边界,因为后接空格，没有单词

# 一个 \s 字符匹配一个空白字符，空白字符: 空格、制表符(\t)、回车(换行\n)等，都输入空白字符

result1 = re.fullmatch(pattern1, 'abc aaa') # 虽然abc出现字符串的开头，但是由于用fullmatch，没有完全匹配的字符串，返回也是空

result2 = re.fullmatch(pattern2, 'abc aaa') # 用 pattern = r'abc\saaa' 也可以匹配到

print(result1)

print(result2)

运行结果：

None

import re

# []表示匹配括号中出现的任意一个字符

pattern = r'a[abc]c' # 把中括号里面当做一个字符，只要是a或b或c，都可以匹配到

result1 = re.fullmatch(pattern,'aac')

result2 = re.fullmatch(pattern,'abc')

result3 = re.fullmatch(pattern,'acc')

result4 = re.fullmatch(pattern,'adc')

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

if result2:

print(result2,result2.span(),result2.group())

else:

print(result2)

if result3:

print(result3,result3.span(),result3.group())

else:

print(result3)

if result4:

print(result4,result4.span(),result4.group())

else:

print(result4)

运行结果：

(0, 3) aac

(0, 3) abc

(0, 3) acc

None

import re

# []表示匹配括号中出现的任意一个字符

pattern = r'a[ab\dc]c' # \d表示任意数字，只要是a或b或c或任意数字，都可以匹配到

result1 = re.fullmatch(pattern,'a4c')

result2 = re.fullmatch(pattern,'abc')

result3 = re.fullmatch(pattern,'a*c')

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

if result2:

print(result2,result2.span(),result2.group())

else:

print(result2)

if result3:

print(result3,result3.span(),result3.group())

else:

print(result3)

运行结果：

(0, 3) a4c

(0, 3) abc

None

# +号表示一个或以上个字符，都可以匹配到

pattern = r'a[\d]+c'

result1 = re.fullmatch(pattern,'a42323c')

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

运行结果：

(0, 7) a42323c

pattern = r'a[\d+]c' # 表示数字或+号，都可以匹配到

result1 = re.fullmatch(pattern,'a4c')

result2 = re.fullmatch(pattern,'a+c')

result3 = re.fullmatch(pattern,'a4+c')

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

if result2:

print(result2,result2.span(),result2.group())

else:

print(result2)

if result3:

print(result3,result3.span(),result3.group())

else:

print(result3)

运行结果：

(0, 3) a4c

(0, 3) a+c

None

# {} 表示指定次数，{N}为匹配N次，{M,N}为匹配M到N次，{M,}为至少匹配M次，{,M}为最多匹配N次

pattern = r'a\d*d{3}c' # *号表示零个或以上个字符，都可以匹配到，这里指匹配到3次d

result1 = re.fullmatch(pattern,'adddc') # 零个数字字符

result2 = re.fullmatch(pattern,'a3dddc') # 一个数字字符

result3 = re.fullmatch(pattern,'a348dddc') # 三个数字字符

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

if result2:

print(result2,result2.span(),result2.group())

else:

print(result2)

if result3:

print(result3,result3.span(),result3.group())

else:

print(result3)

运行结果：

(0, 5) adddc

(0, 6) a3dddc

(0, 8) a348dddc

# () 表示分组，它有以下三个特点：

# 1. 组合，将括号中的内容作为一个整体进行操作

# 2. 捕获，使用带括号的正则表达式匹配成功后，只获取括号中的内容。

# 3. 重复，在正则表达式中可以通过\数字来重复前面()中匹配到的结果。数字代表前第几个分组。

# 组合

import re

pattern = r'(\d[a-zA-Z]){3}a' # 这里将数字字母当做一个整体，匹配三次

result1 = re.fullmatch(pattern,'3A2s9ua') # 当运用fullmatch时，正则表达式和匹配的字符串，模式要完全相同

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

pattern = r'(\d[a-zA-Z]){3}a'

result2 = re.fullmatch(pattern,'3A2s9uac') # 不匹配，当运用fullmatch时，正则表达式和匹配的字符串，模式要完全相同，这里多了一个字符

if result2:

print(result2,result2.span(),result2.group())

else:

print(result2)

运行结果：

(0, 7) 3A2s9ua

None

# () 表示分组，它有以下三个特点：

# 1. 组合，将括号中的内容作为一个整体进行操作

# 2. 捕获，使用带括号的正则表达式匹配成功后，只获取括号中的内容。

# 3. 重复，在正则表达式中可以通过\数字来重复前面()中匹配到的结果。数字代表前第几个分组。

# 捕获

import re

re_str = r'(\d{3})abc'

print(re.fullmatch(re_str, '773abc'))

print(re.findall(re_str, 'euhasdhf873abcssjsja235abcu-03s834432abcjjsks')) # 只提取括号内的内容，组成一个列表

运行结果：

['873', '235', '432']

# () 表示分组，它有以下三个特点：

# 1. 组合，将括号中的内容作为一个整体进行操作

# 2. 捕获，使用带括号的正则表达式匹配成功后，只获取括号中的内容。

# 3. 重复，在正则表达式中可以通过\数字来重复前面()中匹配到的结果。数字代表前第几个分组。

# 重复

import re

re_str = r'([a-z]{3})-(\d{2})\2' # \2替换第二组内容，也就是相当于 re_str = r'([a-z]{3})-(\d{2})(\d{2})'

print(re.fullmatch(re_str, 'hsn-2323'))

运行结果：

import re

pattern = r'([a-z]{3})-(\d{2})\2\1\2' # \2表示(\d{2})再重复一次，"-"仅只是一个匹配的减号符号

result1 = re.fullmatch(pattern,'hsn-2323hsn23')

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

运行结果：

(0, 13) hsn-2323hsn23

# \表示转义符号

# 正则表达式中可以通过在特殊的符号前加\，来让特殊的符号没有意义.

# 中括号中有特殊功能的符号，只代表符号本身，不需要转义字符\

# ()需要转义

import re

pattern = r'\+b\>\\' # \就是使得\后面的字符为需要匹配的字符，即要匹配 +b>\ 的形式的字符

result1 = re.fullmatch(pattern,'+b>\\') # 这里同样需要在字符串\前面加\

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

运行结果：

(0, 4) +b>\

import re

pattern = r'\)' # \就是使得\后面的字符为需要匹配的字符

result2 = re.fullmatch(pattern,')') # 非\的字符串时，不能再在前面加\，如果加转义字符\会报错

if result2:

print(result2,result2.span(),result2.group())

else:

print(result2)

运行结果：

(0, 1) )

print('www.163\ncom')

print('www.163\\ncom') # 只有加\，字符串里面的后面的\没有意义，\n才会都显示出来。

print('I\'m a student') # 不报错

#print('I'm a student') # 报错，两个单引号结束字符串内容

运行结果：

www.163

com

www.163\ncom

I'm a student

# compile(正则表达式字符串) 将正则表达式字符串转换成正则表达式对象，可以直接调用正则表达式对象的方法

pattern = re.compile(r'\d+')

print(pattern)

print(pattern.fullmatch('23456')) # 不是用re.fullmatch 因为compile把它正则表达式字符串转换为对象了，对象就有一系列方法了

运行结果：

re.compile('\\d+')

# fullmatch(正则表达式字符串，字符串)

# 用正则表达式完全匹配字符串(匹配整个字符串)，返回匹配对象或None

# match(正则表达式字符串，字符串)

# 用正则表达式匹配字符串开头，返回匹配对象或者None

pattern = r'\d([a-zA-Z]+)12'

result1 = re.match(pattern,'2sdAc123') # 返回的是匹配到的对象

result2 = re.match(pattern,'h2sdAc123') # 没有匹配到，第一个字符都没匹配到，后面就不会看了

if result1:

print(result1,result1.span(),result1.group())

else:

print(result1)

if result2:

print(result2,result2.span(),result2.group())

else:

print(result2)

运行结果：

(0, 7) 2sdAc12

None

import re

result1 = re.match(r'\d([a-zA-Z]+)12','2sdAc123')

print(dir(result1)) # 可以查询对象有哪些方法

运行结果：

['__class__', '__copy__', '__deepcopy__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'end', 'endpos', 'expand', 'group', 'groupdict', 'groups', 'lastgroup', 'lastindex', 'pos', 're', 'regs', 'span', 'start', 'string']

import re

result = re.fullmatch(r'\d([a-zA-Z]+)123', '2hjdsh123')

print(result)

print(result.span(0)) # span(group=0) 获取整个字符串匹配成功的区间(左闭右开区间)

print(result.start(1)) # 里面的1表示与第一个分组匹配到的开始下标，也就是子表达式闭区间的值

print(result.end(1)) # 里面的1表示与第一个分组匹配到的结束下标，也就是子表达式开区间的值

运行结果：

(0, 9)

1

6

# group()/group(0) --> 获取正则表达式完全匹配的结果

# group(index>0) --> 获取正则表达式中第group个分组匹配到的结果

import re

result = re.fullmatch(r'\d([a-zA-Z]+)123', '2hjdsh123')

print(result)

print('0:',result.group())

print('1:',result.group(1))

运行结果：

0: 2hjdsh123

1: hjdsh

# 对象.string --> 获取被匹配的原字符串

import re

result = re.match(r'\d([a-zA-Z]+)123', '2hjdh123ABC')

print('match:',result)

print(result.string)

运行结果：

match:

2hjdh123ABC

# search：查找字符串中满足正则表达式的第一个字符串，返回值是匹配对象或者None。

import re

result1 = re.search(r'\d([a-zA-Z]+)12','eee2cdADCd1223') # 返回的是匹配到的对象

if result1:

print(result1)

运行结果：

# findall：获取字符串中字符串中满足正则表达式的所有的子串，返回一个列表。

# 如果正则表达式中有分组，取值的时候只取分组中匹配到的结果。

# 如果有多个分组，会将每个分组匹配到的结果作为一个元组的元素。

import re

result1 = re.findall(r'\d([a-zA-Z]+)12','eee2cdADCd1223mkKSD129s') # 有一个分组，仅返回分组中匹配到的对象

if result1:

print(result1)

运行结果：

['cdADCd', 'mkKSD']

import re

result1 = re.findall(r'\d[a-zA-Z]+12','eee2cdADCd1223mkKSD129s') # 没有分组，返回的是匹配到的对象

if result1:

print(result1)

运行结果：

['2cdADCd12', '3mkKSD12']

# finditer：查找所有满足正则条件的子串，返回值是迭代器，迭代器中的元素是匹配对象

import re

result1 = re.finditer(r'\d[a-zA-Z]+12','eee2cdADCd1223mkKSD129s')

if result1:

print(result1) # result1 是一个迭代器

for i in result1: # i 不是一个迭代器，是迭代器里面的元素，元素为对象

print(i,i.span(),i.group(0))

运行结果：

(3, 12) 2cdADCd12

(13, 21) 3mkKSD12

# split(正则表达式,字符串) 将字符串按照满足正则表达式条件的子串进行分割

str1 = 'adsd23d2DS-DSAD2dsd+dsn2-dsa2DFaw1'

result1 = re.split(r'[-+]',str1) # 用+或-来切分，如果直接用字符串的str1.split('+') 则只能用一种形式来切分

print(result1)

运行结果：

['adsd23d2DS', 'DSAD2dsd', 'dsn2', 'dsa2DFaw1']

# sub(正则表达式,repl,字符串) --> 将字符串中满足正则表达式条件的子串替换成repl。返回替换后的字符串

str1 = 'hsj8jskfh98ssjj8hshh'

result = re.sub(r'\d+','*', str1)

print(result)

运行结果：

hsj*jskfh*ssjj*hshh

二、我的自学路线

01 安装Python编辑器 [ 已整理 ]

02 Python编译器快捷键 [ 已整理 ]

03 Python基础 [ 已整理 ]

04 Python难点 [ 整理ing ]

05 Python常用的库 [ 整理ing ]

06 爬虫 [ 看视频ing ]

三、笔记目录

1) Python 编辑器

2) Python 基础

03) Python 难点

( ……更多笔记，见专栏 )

"♥我的笔记，希望对你有帮助♥"