高赞回复一

作者：匿名用户

你以为老师就不吐槽了吗，老师吐槽的更多，但是吧，也不能当面吐槽，毕竟还得找他们办事。。。

现在很多行政就是个复制粘贴的工具，上面发的通知，他往微信群里一转发就完事儿了，你要是没看到，那是你自己的事儿，他才不管。别人问他什么，他根本不解读，就再复制粘贴一次通知让你自己看。

要收集什么资料了，表格发给你自己填，甚至有什么事情问完你了，明明也告诉他们了，还是发个表格给你自己填…他就只想复制粘贴。

还有一个我最无语的，自科现在提倡无纸化，但是我们学校在校内审核这一步非要我们提供纸质版，哪怕是在疫情期间，也是要我们打印出来交给他，他们看完只纸质的再去网上审核，我是真的搞不懂…直接在系统里看不好吗？

还有各种流程上的死板，各种领导签字，我也想知道领导们不烦么？

我也知道有些行政对学生更差，态度更差，但是办事吧，对谁都那样。至于说原因，一个是钱少，你对他们还能有什么要求，还有一个是这些行政岗位挺闲的，很多都是学校领导的亲戚…我读研的时候，那个院所有的行政只有一个人是没有关系背景的，也就只有他一个是工作多态度还很好的。

另外，教务处的老师真的不应该被吐槽，他们是学校里的清水衙门，工作量特别大，不耐烦一点我是可以理解的。

高赞回复二

作者：一一

简单来说，能力不行。

大部分都是人才带来的傻老婆，或者傻老公。

自己没有找工作的能力，跟另一半混。

这样的人，能力和耐心都不会太强。

为什么我这么了解呢，因为我就在催着我老婆把我弄到他们学校图书馆。

高赞回复三

作者：进击的小毛睿

高校行政部门的特点：

1、女的多，特别感性，随性而为的比较多。

2、背景硬，多是领导家属，发火有底气，敢发火。

3、事业编，铁饭碗，怎么折腾都永远不用担心被辞退。

这就决定他们脾气不会太好。

高赞回复四

作者：匿名用户

因为好的大学的正式的行政岗位都是美差，没有关系基本很难进的，所以里面的老师都牛逼轰轰的（毕竟关系户）。除了工资可能不能太高以外（当然也不会太低），基本没有什么缺点了，工作轻松，福利待遇好，上下班时间基本你自己说了算，工作环境还很单纯，对着的都是一群没什么话语权的学生。

我的感受就是，能够尽量减少跟他们的接触就减少跟他们的接触…有时候教务处网站上发一个通知，明明是他们自己写得不清楚，学生打电话过去询问还超级不耐烦。去保卫处咨询学生证火车票充磁的事情，值班的老师就很凶的一句不知道把你打发了，本来就是你们部门的事情，就算不归你管你也应该告诉我该找谁吧，动不动就甩脸子给谁看啊。

永远是一副大爷的样子，对着青年教学老师脾气也没能好到哪里去。官僚气息不能更重了。中午不到十一点二十就下班，下午四点半以后别想找到人。

我对待他们这样的工作态度就是很反感。教学老师和辅导员对学生的态度跟他们比都好到天上去了，本来也是一个服务师生的岗位，我们谁都不欠谁的，帮学生老师办事难道不是你的份内事嘛？怎么成了我们求着你办事。

公众号：尤而小屋编辑：Peter作者：Peter

大家好，我是Peter~

图像基础处理是计算机视觉和数字图像处理的第一步，旨在通过简单而有效的操作改善图像质量或提取关键信息。

常见的处理技术包括：

• 灰度化（将彩色图像转换为单通道灰度图）

• 二值化（通过阈值分割突出目标区域）

• 平滑滤波（如高斯模糊去除噪声）

• 边缘检测（如Sobel、Canny算子提取轮廓）

• 几何变换（如旋转、缩放、裁剪）。

这些方法通常基于像素级操作或卷积运算，能够快速优化图像数据，为后续高级分析（如目标识别、特征匹配）奠定基础。

例如，直方图均衡化可增强低对比度图像的细节，而形态学操作（如腐蚀、膨胀）能优化二值图像中的连通区域。基础处理技术因其高效性和广泛适用性，在工业检测、医学影像、安防监控等领域发挥着重要作用。

本文给大家介绍10个图像处理的基本操作，所有的操作都是基于Numpy实现，用个人本地图片代码复制即可运行。

import numpy as npimport matplotlib.pyplot as plt%matplotlib inlinefrom PIL import Image

图像基础操作 

读取图像

首先读取我们需要处理的图像:

img = Image.open("Mona_Lisa.jpg")type(img)PIL.JpegImagePlugin.JpegImageFile

# 创建矩阵M = np.array(img)type(M)  # numpy数组

结果显示是：

numpy.ndarray

M[:2]

array([[[ 99, 110,  93],        [ 85,  98,  80],        [ 80,  95,  76],        ...,        [ 76,  90,  65],        [ 73,  82,  63],        [ 92,  96,  82]],       [[101, 113,  93],        [ 93, 106,  86],        [ 78,  93,  72],        ...,        [ 60,  74,  49],        [ 64,  73,  54],        [ 58,  62,  48]]], dtype=uint8)

图像基本信息

M.shape  

(447, 300, 3)

可以看到该创建的是一个三维矩阵，表示图像的高度、宽度和颜色通道数

• height：图像的高度（垂直方向的像素行数）。

• width：图像的宽度（水平方向的像素列数）。

• channels：颜色通道数（如RGB图像为3，灰度图像为1）。

M.size  # 图像大小  447*300*3

402300

显示图像

方式1：通过show函数显示

# img.show() # 方式1：新建窗口打开图片

方式2：通过display函数显示该图像：Image.fromarray()是图像处理库Pillow (PIL) 中的一个核心方法，其作用是将 NumPy 数组转换为 PIL 的 Image 对象

display(Image.fromarray(M))  # 将numpy数组转成Image对象

或者直接使用img，因为通过读取进行本身就是Image对象中的JpegImageFile类型。

type(img)

PIL.JpegImagePlugin.JpegImageFile

display(img)

缩小图像 

def reduce_img_size(img, n):    h,w,c = img.shape  # h---height   w---width   c---channel        # 将图像缩小n倍；得到缩小后的高度和宽度    new_h = h // n      new_w = w // n        # 创建一个新矩阵来存储缩小后的图像    new_img = np.zeros((new_h,new_w,c), dtype=img.dtype) # 保持和原图像相同的dtype        for i in range(new_h):        for j in range(new_w): # 遍历每个像素位置(i,j)            new_img[i,j] = img[n*i, n*j]  # 新图像的每个像素 (i, j)，从原图像中取位置为 (n*i, n*j) 的像素值赋值给它    return new_img

reduced_M = reduce_img_size(M,2)  # 缩小为原来一半display(Image.fromarray(reduced_M))

图像亮度调整Image Brightness Adjustment 

基本原理

基本原理：图像亮度调整的原理是通过数学运算改变图像像素的强度值（即亮度），从而整体提亮或压暗图像。

其核心是对每个像素的RGB（或灰度）通道值进行线性或非线性变换，同时确保结果在有效范围内（如0~255）。

案例

np.clip() 是NumPy 中的一个重要函数，用于限制数组值的范围，将超出指定范围的值截断到边界值。它在图像处理中常用于防止像素值溢出或归一化数据。

具体用法为：

np.clip(array, min, max, out=None)

• array: 输入数组（可以是 NumPy 数组或类似数组的对象）。

• min: 最小值，所有比 min 小的值会被替换为 min（可选，默认为 None）。

• max: 最大值，所有比 max 大的值会被替换为 max（可选，默认为 None）。

• out: 可选参数，指定输出数组（避免创建新数组）。

# 增加亮度# 原数组M 乘以1.5，即扩大50%，然后将值限制在0~255；并转成标准np.uint格式brightened_M = np.clip(M * 1.5, 0, 255).astype(np.uint8)  

display(Image.fromarray(brightened_M))

# 降低亮度darkened_M = np.clip(M * 0.5, 0, 255).astype(np.uint8)  # 亮度降低50%display(Image.fromarray(darkened_M))

图像翻转Image Flipping 

• Horizontal水平翻转即沿 垂直轴（Y轴） 翻转图像，相当于对图像的 列（width） 进行逆序排列。

• Vertical垂直翻转即沿 水平轴（X轴） 翻转图像，相当于对图像的 行（height） 进行逆序排列

NumPy 的切片操作是 零拷贝（view），速度极快，适合大规模图像处理

# 方式1# 水平翻转（左右镜像）flipped_horizontal = M[:, ::-1, :]# 垂直翻转（上下镜像）flipped_vertical = M[::-1, :, :]# 显示结果plt.figure(figsize=(12, 4))plt.subplot(131), plt.imshow(img), plt.title("Original"), plt.axis('off')plt.subplot(132), plt.imshow(flipped_horizontal), plt.title("Horizontal Flip"), plt.axis('off')plt.subplot(133), plt.imshow(flipped_vertical), plt.title("Vertical Flip"), plt.axis('off')plt.show()

# 方式2def flip_image(image):    # 水平翻转函数    flip_image = image[:, ::-1]    return flip_image     def rotate_image(image):    # 垂直翻转函数    rotated_img = Image.fromarray(np.rot90(image, k=n, axes=(1, 0)))     return rotated_img

其中np.rot90为内置的矩阵旋转函数，其中：

• k=n：表示旋转次数(90°*n)

• axes=(1, 0)：指定旋转的轴平面（(1, 0) 表示沿高度（行）和宽度（列）组成的平面旋转，即顺时针旋转）。

图像裁剪Image Cropping 

# 定义裁剪函数def crop_image(image, crop_ratio, zoom_ratio):    """    image：待裁剪的函数，(h,w,c)三个参数    crop_ratio：裁剪比例，控制裁剪范围的中心位置    zoom_ratio：缩放比例，控制裁剪后区域的放大倍数    """        # 获取图像的高度shape[0]、宽度shape[1]和通道数shape[2]        # top：从图像顶部向下裁剪 1/crop_ratio 的部分（例如 crop_ratio=4 表示从 25% 高度处开始裁剪）    # bottom：在 top 的基础上，放大 zoom_ratio 倍（例如 zoom_ratio=2 表示裁剪区域高度为原图的 2/crop_ratio）    top = image.shape[0] // crop_ratio    bottom = zoom_ratio * image.shape[0] // crop_ratio    left = image.shape[1] // crop_ratio    right = zoom_ratio * image.shape[1] // crop_ratio        focused_img = image[top:bottom, left:right]    return focused_imgdisplay(Image.fromarray(crop_image(M, 3, 5)))

RGB通道 

RGB简介

RGB（Red, Green, Blue）是一种颜色模型，通过 红（R）、绿（G）、蓝（B） 三个颜色通道的组合来表示所有颜色。它是数字图像处理中最常用的色彩模式，适用于显示器、摄像头、照片等。

RGB通道的作用：

• 红色（R）：控制图像中的红色分量。

• 绿色（G）：控制图像中的绿色分量。

• 蓝色（B）：控制图像中的蓝色分量。

通过调整这三个通道的强度（0-255），可以混合出 1677万种（256×256×256） 颜色。

RGB通道的顺序

RGB 通道的顺序取决于使用的库或工具：

库/工具	通道顺序	示例（image.shape = (H, W, 3)）
PIL/Pillow、Matplotlib	RGB	image[:, :, 0]  = 红（R）image[:, :, 1] = 绿（G）image[:, :, 2] = 蓝（B）
OpenCV	BGR	image[:, :, 0]  = 蓝（B）image[:, :, 1] = 绿（G）image[:, :, 2] = 红（R）

提取指定通道

# 提取 R、G、B 通道（注意通道顺序是 R=0, G=1, B=2）# 指定提取单个通道的数据red_channel = M[:, :, 0]    # 红色通道（二维数组）green_channel = M[:, :, 1]  # 绿色通道blue_channel = M[:, :, 2]   # 蓝色通道# 显示单通道（灰度图）plt.figure(figsize=(12, 4))plt.subplot(131), plt.imshow(red_channel, cmap='Reds'), plt.title("Red Channel")plt.subplot(132), plt.imshow(green_channel, cmap='Greens'), plt.title("Green Channel")plt.subplot(133), plt.imshow(blue_channel, cmap='Blues'), plt.title("Blue Channel")plt.show()

另外一种方式：定义提取单个通道的函数

def RGB_image(image,image_color):    """    定义RGB函数：提取图像的红-绿-蓝色的单色通道，并将其他两个通道置为零    通道顺序：R=0, G=1, B=2    """        if image_color == 'R':        img_R = image.copy()        img_R[:, :, (1, 2)] = 0# 保留 R，G 和 B 置零        return img_R    elif image_color == 'G':        img_G = image.copy()        img_G[:, :, (0, 2)] = 0# 保留 G，R 和 B 置零        return img_G    elif image_color == 'B':        img_B = image.copy()        img_B[:, :, (0, 1)] = 0   # 保留 B，R 和 G 置零        return img_B

M_red = Image.fromarray(RGB_image(M, 'R')) display(M_red)

图片灰度化Image Grayscaling 

图片灰度化是将彩色图像转换为灰度图像的过程，也就是将包含丰富颜色信息的图像转换为仅包含亮度信息的黑白图像（实际上是不同深浅的灰色）。

基本原理：灰度化通过数学转换将彩色图像（通常由红、绿、蓝三个通道组成）转换为单通道的灰度图像，其中每个像素的值代表该点的亮度。

常用的灰度化方法：

• 平均值灰度法：(R+G+B)/3

• 加权平均灰度法：0.5*R+0.3*G+0.2*B；OpenCV等库采用

• 最大值/最小值灰度法：max(R,G,B),min(R,G,B)

def grayscale_image(image):    """    定义加权平均灰度函数    输入：图像数组np.array    """    grayscale_image = np.dot(image[...,:3], [0.5,0.3,0.2])  # 选取RGB通道，忽略可能的alpha通道；自定义加权系数    grayscale_image = np.clip(grayscale_image,0,255)  # 将像素值限制在0-255内，防止计算溢出    grayscale_image = grayscale_image.astype(np.uint8) # # 转换数据类型为np.uint8；标准图像格式        return grayscale_image# 执行灰度转换功能M_gray = grayscale_image(M)display(Image.fromarray(M_gray))

图片添加滤镜Image Filter 

图像滤镜（Image Filter）的本质：

• 给图像添加滤镜，本质上是通过数学运算改变像素的颜色值，从而让图像呈现出特定的视觉效果。

• 滤镜可以模拟自然现象（如老照片）、艺术风格（如油画），或其他的创意表达。

def apply_sepia(image):    """        """    sepia_matrix = np.array([[0.493, 0.769, 0.189],  # 红色通道转换系数                          [0.349, 0.686, 0.168],  # 绿色                          [0.282, 0.434, 0.431]]) # 蓝色    sepia_img = image.dot(sepia_matrix.T)  # .dot  执行矩阵乘法    sepia_img = np.clip(sepia_img, 0, 255)    return sepia_img.astype(np.uint8) M_sepia = Image.fromarray(apply_sepia(M))display(M_sepia)

图片像素化Image Pixelation 

图像像素化是一种通过减少图像分辨率或合并相邻像素来创建块状、马赛克效果的图像处理技术。它通过将图像分割为若干个小方块（像素块），并用每个方块内像素的平均颜色值替换该区域的所有像素来实现。

简单来说,就是把矢量图形转换成像素点组成的点阵图形，也叫栅格化。

基本原理

• 分块处理：将图像划分为N×N的方块网格

• 颜色平均：计算每个方块内所有像素的颜色平均值

• 替换像素：用该平均值替换方块内所有像素

• 效果控制：通过调整方块大小控制像素化程度

案例

def pixelate_image(image,block_size):    """    image：待处理图片    block_size：每个像素化方块的大小，比如block_size=10表示10*10的像素    """        # 计算每个维度的所需分块数    num_blocks_x = image.shape[1] // block_size  # //表示整除计算    num_blocks_y = image.shape[0] // block_size        # 计算每个方块的平均颜色值    block_means = np.zeros((num_blocks_y,num_blocks_x,3), dtype=np.uint8)  # 零矩阵用于存储数据    for y in range(num_blocks_y):        for x in range(num_blocks_x):            # 提取当前方块            block = image[y * block_size:(y+1) * block_size, x * block_size:(x+1) * block_size]            # 计算方块内RGB三通道均值            block_mean = np.mean(block, axis=(0,1))            # 将均值从浮点数转为 uint8（0~255的整数）            block_means[y,x] = block_mean.astype(np.uint8)                 # 扩展均值块生成像素化图像：垂直和水平方向使用两次           pixelated_image = np.repeat(np.repeat(block_means, block_size, axis=0), block_size, axis=1)    return pixelated_image  # 生成的是图像数组M_pixelated = Image.fromarray(pixelate_image(M,block_size=10))display(M_pixelated)

图像二值化Image Binarization 

图像二值化（Image Binarization）是将灰度图像转换为仅包含黑白两色的图像处理技术，通过设定一个阈值将像素分为前景（通常为白色）和背景（通常为黑色）。

二值化基本原理：

• 选择一个灰度值作为分界点（0-255之间）

• 大于阈值的像素设为白色（255），小于等于阈值的像素设为黑色（0）

def binarize_image(image,threshold):    binarize_image = (image > threshold) * 255    binarize_image = binarize_image.astype(np.uint8)  # 转成标准格式    return binarize_image  # 数组格式M_binarized = Image.fromarray(binarize_image(M,threshold=100))  # 数组---转成display((M_binarized))

图像融合Image Blending 

图像融合是指根据两种图片的透明度将二者的像素进行叠加求和的过程。

# 读取第二张图img2 = Image.open("cat.jpg")# 尺寸转换，和第一张图M的相同img2 = img2.resize(M.shape[1::-1])# 创建矩阵M2 = np.array(img2)display(Image.fromarray(M2))

def blend_image(image1,image2,visibility1,visibility2):    blend_image = image1 * visibility1 + image2 * visibility2 # 根据两个权重进行叠加    blend_image = blend_image.astype(np.uint8)  # 标准格式    return blend_image

blended_image = Image.fromarray(blend_image(M,M2,0.6,0.4))display(blended_image)

CognitiveKernel-Pro-Query 文本生成基准数据集：https://go.hyper.ai/ofF3N

很多人习惯了VsCode、Trae这样的图形化AI编程界面，而Anthropic发布的Claude Code是在命令行上写代码，看似简陋，却强大的很。

扔掉复杂的软件外壳，只有极简的命令行，直接在终端让AI接管编程，变成终端原生应用。

这样做的“坏处”是回归到Linux这样的纯代码开发，拦住了不少小白用户，但好处更多，成为真正的自动化编程。

1、代理式编程，从0到100都交给AI。AI作为架构师，接管全局代码，而不是原来简单的补全、生成，压根不需要你插手。

2、访问权限更大。通过命令行工具更直接的控制电脑，包括环境部署、API通信、数据库、监控和版本控制。

3、在本地终端运行，更加安全，任何指令都需要用户批准。

如果还是想在图形界面写代码，Claude Code也能与Pycharm、Vscode等IDE集成，直接写到代码文件中，简单高效。

安装Claude Code也很简单，以Mac为例，首先你需要安装Node.js 18+ 版本。

在终端输入：

# 下载安装nvm:curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash# 下载安装Node.js:nvm install 22# 确认Node.js版本:node -v # Should print "v22.18.0".nvm current # Should print "v22.18.0".# 确认npm版本:npm -v # Should print "10.9.3".

接着安装claude code，在终端输入：

npm install -g @anthropic-ai/claude-code

配置好后，在终端启动Claude Code，输入Claude即可。

你还可以配置其他模型，比如GLM-4.5

先打开终端，然后输入以下命令。

export ANTHROPIC_BASE_URL=https://open.bigmodel.cn/api/anthropic export ANTHROPIC_AUTH_TOKEN="这里输入你注册的bigmodel API keys"

当你看到终端出现以下的界面，说明Claude Code已经安装好，就能开始愉快的编程了。

写一个复杂的任务，直接生成一个网站，比如搭建一个类似知乎的网站。

最终会你会看到如下的效果，它生成了一个完整的网页，UI和知乎几乎一致，可以注册、登陆、提问、关注，还有推荐、热榜、话题等功能，不能说一模一样，可以说形神兼备。

初步测试下来，Claude Code真的很强。

掌握 Python 正则表达式：100个实用技巧与案例。

正则表达式（regex 或 regexp）是 Python 中用于模式匹配与文本处理的强大工具。其语法简洁灵活，能够精准描述字符串中的各类模式，在数据提取、格式验证、文本清洗等场景中发挥着重要作用。

本文系统梳理了 Python 正则表达式的高级特性与一系列使用技巧，帮助读者快速掌握！

一、特性

1.正则表达式简介

正则表达式是定义搜索模式的字符序列，是用于字符串匹配和处理的多功能工具。在 Python 中，re 模块提供了对正则表达式的支持。

import re

2.基本模式

2.1 字面字符

pattern = re.compile(r'hello')result = pattern.match('hello world')print(result.group())  # 输出：'hello'

2.2 字符类

pattern = re.compile(r'[aeiou]')result = pattern.findall('hello world')print(result)  # 输出：['e', 'o', 'o']

2.3 通配符 .

pattern = re.compile(r'he..o')result = pattern.match('hello world')print(result.group())  # 输出：'hello'

3.量词

3.1 *、+、?

pattern = re.compile(r'ab*c')result = pattern.match('ac')print(result.group())  # 输出：'ac'

4.锚点

4.1 ^（字符串开头）和 $（字符串结尾）

pattern = re.compile(r'^hello')result = pattern.match('hello world')print(result.group())  # 输出：'hello'

5.字符转义

pattern = re.compile(r'\d+')  # 匹配一个或多个数字result = pattern.match('123')print(result.group())  # 输出：'123'

6.字符集和范围

pattern = re.compile(r'[a-z]')result = pattern.findall('Hello World')print(result)  # 输出：['e', 'l', 'l', 'o', 'o', 'r', 'l', 'd']

7.分组和捕获

pattern = re.compile(r'(\d+)-(\d+)-(\d+)')result = pattern.match('2023-11-25')print(result.groups())  # 输出：('2023', '11', '25')

8.高级模式

8.1 前瞻和后顾

pattern = re.compile(r'(?<=@)\w+')result = pattern.findall('user@example.com')print(result)  # 输出：['example']

8.2 非捕获组

pattern = re.compile(r'(?:\d+)-(\d+)-(\d+)')result = pattern.match('2023-11-25')print(result.groups())  # 输出：('11', '25')

9.Python 中正则表达式的使用

9.1 match 与 search

pattern = re.compile(r'world')result = pattern.match('hello world')print(result)  # Noneresult = pattern.search('hello world')print(result.group())  # 输出：'world'

9.2 findall

pattern = re.compile(r'\d+')result = pattern.findall('There are 25 apples and 30 oranges')print(result)  # 输出：['25', '30']

10.替换和替换操作

pattern = re.compile(r'\d+')result = pattern.sub('X', 'There are 25 apples and 30 oranges')print(result)  # 输出：'There are X apples and X oranges'

11.不区分大小写

pattern = re.compile(r'hello', re.IGNORECASE)result = pattern.match('HeLLo World')print(result.group())  # 输出：'HeLLo'

二、有效使用正则表达式的100个技巧

1.通用技巧

1. 使用原始字符串（如 r'\d+'）以避免意外的转义字符。

2. 若需多次使用正则表达式模式，建议编译模式以提升性能。

   import re# 不编译模式（重复编译）for _ in range(1000):    result = re.match(r'\d+', '123')# 编译模式（仅编译一次）pattern = re.compile(r'\d+')for _ in range(1000):    result = pattern.match('123')

3. 针对多种情况测试正则表达式，确保其正确性。

   import re# 示例：匹配电子邮件地址pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b')# 测试用例test_cases = [    "user@example.com",             # 有效的电子邮件    "user@company.co.uk",           # 带国家代码的有效电子邮件    "name123@sub.domain.org",       # 带子域名的有效电子邮件    "invalid_email@no_tld",         # 无效的电子邮件（无顶级域名）    "@missing_username.com",        # 无效的电子邮件（无用户名）    "user@invalid_domain",          # 无效的电子邮件（域名无效）    "name@server.c",                # 无效的电子邮件（顶级域名过短）    "name@server.with_space.com",   # 无效的电子邮件（域名含空格）    "user@@double_at.com",          # 无效的电子邮件（含两个@）    "user@excessive_length_domain." + "a" * 255# 无效的电子邮件（域名过长）]# 用每个测试用例测试模式for email in test_cases:    match = pattern.match(email)    print(f"{email}：{'有效' if match else '无效'}")

2.字符类

1. 利用字符类（如 [a-z]）匹配指定范围内的任意字符。

2. 使用否定（字符类中的 ^）匹配不在指定范围内的字符（如 [^0-9] 匹配非数字）。

3.量词

1. 需匹配最小内容时，优先使用非贪婪量词（*?、+?）。

2. 使用贪婪量词（*、+）时需谨慎，避免意外的长匹配。

4.锚点和边界

1. 使用 ^ 和 $ 分别将模式锚定到行的开头和结尾。

2. 利用单词边界（\b）匹配完整单词。

5.选择和分组

1. 使用选择（|）匹配多个模式（如 cat|dog）。

2. 需对模式的特定部分（而非整个模式）应用量词（*、+、{}）或选择（|）时，分组非常有用。

6.字符转义

1. 熟悉常见的字符转义（\d、\w、\s），分别用于匹配数字、单词字符和空白字符。

2. 若需匹配特殊字符（如 .），需转义（如 \.）。

7.环视

1. 使用正向前瞻（(?=...)）匹配后面跟有特定模式的内容。

2. 利用负向前瞻（(?!...)）匹配后面不跟特定模式的内容。

8.替换

1. 使用捕获组在替换中提取并引用匹配字符串的部分内容。

   import re# 示例：替换日期格式pattern = re.compile(r'(\d{1,2})/(\d{1,2})/(\d{4})')# 原始字符串text = "Meeting on 12/25/2022. Deadline is 3/8/2023."# 使用捕获组进行替换result = pattern.sub(r'\3-\1-\2', text)# 打印结果print(f"原始：{text}")print(f"修改后：{result}")

2. 尝试使用反向引用（\1、\2）在替换中引用捕获组。

9.常见模式

1. 使用 \d+ 匹配一个或多个数字。

2. 使用 ? 匹配可选字符（如 colou?r 匹配 color 或 colour）。

3. 使用 \s+ 匹配空白字符。

10.不区分大小写

使用 re.IGNORECASE 标志启用不区分大小写的匹配。

11.注释

使用 (?#comment) 在正则表达式中添加注释，提高可读性。

12.验证

1. 使用健壮的正则表达式模式验证电子邮件地址。

   import redef validate_email(email):    # 电子邮件验证的正则表达式模式    pattern = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')    return bool(pattern.match(email))# 测试用例emails = [    "user@example.com",          # 有效的电子邮件    "user.name@company.co.uk",   # 带国家代码的有效电子邮件    "invalid_email@no_tld",      # 无效的电子邮件（无顶级域名）    "@missing_username.com",     # 无效的电子邮件（无用户名）    "user@invalid_domain",       # 无效的电子邮件（域名无效）    "user@@double_at.com",       # 无效的电子邮件（含两个@）    "user@excessive_length_domain." + "a" * 255# 无效的电子邮件（域名过长）]# 验证每个电子邮件并打印结果for email in emails:    result = validate_email(email)    print(f"{email}：{'有效' if result else '无效'}")

• ^[a-zA-Z0-9._%+-]+：匹配用户名部分中一个或多个允许的字符。

• @：匹配 @ 符号。

• [a-zA-Z0-9.-]+：匹配域名部分中一个或多个允许的字符。

• \.：匹配顶级域名前的点（.）。

• [a-zA-Z]{2,}$：匹配两个或多个字母的顶级域名。

2. 为电话号码创建正则表达式模式。

   import redef validate_phone_number(phone_number):    # 带或不带连字符的美国电话号码的正则表达式模式    pattern = re.compile(r'^\+?1?\s*[-.]?\s*\(?\d{3}\)?[-.]?\s*\d{3}[-.]?\s*\d{4}$')    return bool(pattern.match(phone_number))# 测试用例phone_numbers = [    "+1 123-456-7890",     # 带国家代码的有效电话号码    "123.456.7890",        # 带点的有效电话号码    "(123) 456-7890",      # 带括号的有效电话号码    "1234567890",          # 无连字符的有效电话号码    "987-654-3210",        # 无国家代码的有效电话号码    "invalid_phone_number"# 无效的电话号码]# 验证每个电话号码并打印结果for phone_number in phone_numbers:    result = validate_phone_number(phone_number)    print(f"{phone_number}：{'有效' if result else '无效'}")

• ^：断言字符串的开头。

• \+?1?：匹配可选的 + 和可选的 1（国家代码）。

• \s*[-.]?\s*：匹配可选的空格和可选的连字符或点。

• \(?\d{3}\)?：匹配可选的左括号、三个数字和可选的右括号。

• [-.]?\s*\d{3}[-.]?\s*\d{4}$：匹配可选的连字符或点、可选的空格、三个数字、可选的连字符或点、可选的空格，以及结尾的四个数字。

3. 为邮政编码创建正则表达式模式。

   import redef validate_zip_code(zip_code):    # 美国邮政编码的正则表达式模式（5位或9位）    pattern = re.compile(r'^\d{5}(?:[-\s]\d{4})?$')    return bool(pattern.match(zip_code))# 测试用例zip_codes = [    "12345",            # 有效的5位邮政编码    "98765-4321",       # 带连字符的有效的9位邮政编码    "56789 1234",       # 带空格的有效的9位邮政编码    "invalid_zip_code"# 无效的邮政编码]# 验证每个邮政编码并打印结果for zip_code in zip_codes:    result = validate_zip_code(zip_code)    print(f"{zip_code}：{'有效' if result else '无效'}")

• ^：断言字符串的开头。

• \d{5}：匹配5位数字（5位邮政编码）。

• (?:[-\s]\d{4})?：使用非捕获组使最后四位数字可选，允许带可选连字符或空格的9位邮政编码格式。

• $：断言字符串的结尾。

13.转义用户输入

将用户输入纳入正则表达式时，务必转义用户输入，以防止注入攻击。

import redef search_string_in_text(user_input, text):    # 在正则表达式中使用用户输入前安全转义    escaped_user_input = re.escape(user_input)    # 在正则表达式模式中使用转义后的用户输入    pattern = re.compile(f'\\b{escaped_user_input}\\b', re.IGNORECASE)    # 在文本中搜索转义后的用户输入    match = pattern.search(text)    # 打印结果    if match:        print(f"找到：'{user_input}' 在 '{text}' 中")    else:        print(f"未找到：'{user_input}' 在 '{text}' 中")# 用用户输入和文本测试search_string_in_text(".*", "这是一段简单的文本。")

• re.escape(user_input)：re.escape() 函数转义用户输入中的特殊字符，确保它们被视为字面字符而非正则表达式语法的一部分。

• \\b{escaped_user_input}\\b：{escaped_user_input} 被纳入正则表达式模式，前后包围 \b 单词边界以匹配确切的单词。

• re.IGNORECASE：re.IGNORECASE 标志用于执行不区分大小写的搜索。

14.命名组

使用命名组（(?P<name>...)）提高可读性，并通过名称引用捕获的组。

15.详细模式

启用详细模式（re.VERBOSE 或 re.X），允许模式中包含空格和注释，提高可读性。

16.非捕获组

使用非捕获组 (?:...) 进行分组，而不创建捕获组。

17.Unicode 字符

考虑使用 \p{L} 匹配任何 Unicode 字母。

18.转义点号

若需匹配字面点号，使用 \.。

19.验证 URL

创建正则表达式模式验证 URL。

import redef validate_url(url):    # 验证 URL 的正则表达式模式    pattern = re.compile(        r'^(https?|ftp):\/\/'# 协议（http、https、ftp）        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|[0-9]{1,3}\.?|[A-Z0-9-]+\.?)'# 域名        r'(?:\/[^\s]*)?$'# 路径        , re.IGNORECASE    )    return bool(pattern.match(url))# 测试用例urls = [    "http://www.example.com",    "https://example.com/path",    "ftp://ftp.example.net/file.txt",    "invalid-url",    "ftp://invalid_domain",    "https://example_with_underscores.com"]# 验证每个 URL 并打印结果for url in urls:    result = validate_url(url)    print(f"{url}：{'有效' if result else '无效'}")

• ^(https?|ftp):\/\/：匹配协议（http、https 或 ftp）。

• (?: ... | ... )：域名选项的非捕获组。

• (?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?：匹配典型域名（example.com），带可选子域名。

• |[0-9]{1,3}\.?：或者，匹配 IP 地址（带可选尾点）。

• |[A-Z0-9-]+\.?：或者，匹配仅含字母数字的域名（example-with-hyphens.com），带可选尾点。

• (?:\/[^\s]*)?$：匹配字符串末尾的路径（例如，/path/to/resource）。

• re.IGNORECASE：re.IGNORECASE 标志用于执行不区分大小写的匹配。

20.提取信息

使用捕获组从字符串中提取特定信息。

import redef extract_email_info(email):    # 带捕获组的正则表达式模式，用于提取电子邮件信息    pattern = re.compile(r'^([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+)\.([a-zA-Z]{2,})$')    # 用模式匹配电子邮件    match = pattern.match(email)    # 使用捕获组提取信息    if match:        username, domain, tld = match.groups()        print(f"电子邮件：{email}")        print(f"用户名：{username}")        print(f"域名：{domain}")        print(f"顶级域名：{tld}")    else:        print(f"无效的电子邮件格式：{email}")# 测试用例emails = [    "user@example.com",    "john.doe@company.co.uk",    "invalid_email@no_tld",    "@missing_username.com",    "user@invalid_domain",    "user@@double_at.com",    "user@excessive_length_domain." + "a" * 255]# 从每个电子邮件提取信息并打印结果for email in emails:    extract_email_info(email)    print("-" * 30)

• ^([a-zA-Z0-9._%+-]+)：电子邮件用户名部分的捕获组。

• @：匹配 @ 符号。

• ([a-zA-Z0-9.-]+)：电子邮件域名部分的捕获组。

• \.：匹配顶级域名前的点（.）。

• ([a-zA-Z]{2,})$：顶级域名的捕获组。

• match.groups()：以元组形式检索捕获的组。

21.字符集和范围

使用字符集和范围简洁地匹配多个字符。

import redef match_date_formats(date_string):    # 带字符集和范围的正则表达式模式，用于匹配日期格式    pattern = re.compile(r'^\d{1,2}[/\-]\d{1,2}[/\-]\d{2,4}$')    # 检查日期字符串是否匹配模式    if pattern.match(date_string):        print(f"{date_string} 是有效的日期格式。")    else:        print(f"{date_string} 不是有效的日期格式。")# 测试用例date_strings = [    "12/25/2022",    "3-8-2023",    "invalid_date",    "2023-12-31",    "15/07/2021",    "22-10-21"]# 每个日期字符串与模式匹配并打印结果for date_str in date_strings:    match_date_formats(date_str)

^\d{1,2}[/\-]\d{1,2}[/\-]\d{2,4}$：此正则表达式模式使用字符集和范围匹配不同的日期格式。

• ^\d{1,2}：匹配开头的1或2位数字。

• [/\-]：匹配斜杠（/）或连字符（-）。

• \d{1,2}：匹配1或2位数字（月份）。

• [/\-]：匹配另一个斜杠（/）或连字符（-）。

• \d{2,4}$：匹配结尾的2、3或4位数字（年份）。

22.非贪婪字符匹配

组合 .*? 用于非贪婪匹配任何字符。

23.匹配整个单词

使用 \b 匹配整个单词。

24.匹配特殊字符

要匹配字面意义上的 +、* 和 ? 等特殊字符，需要转义它们。

25.组上的量词

将量词应用于组以匹配重复模式（例如，(ab)+）。

26.匹配日期

创建正则表达式模式匹配日期格式。

1. 模式1：MM/DD/YYYY 或 MM-DD-YYYY

   import redef match_date_format_1(date_string):    pattern = re.compile(r'^(0[1-9]|1[0-2])[/\-](0[1-9]|[12][0-9]|3[01])[/\-]\d{4}$')    if pattern.match(date_string):        print(f"{date_string} 匹配模式。")    else:        print(f"{date_string} 不匹配模式。")# 测试用例dates_pattern_1 = ["12/25/2022", "03-08-2023", "15/07/2021", "2023-12-31", "invalid_date"]for date_str in dates_pattern_1:    match_date_format_1(date_str)

   ^(0[1-9]|1[0-2])[/\-](0[1-9]|[12][0-9]|3[01])[/\-]\d{4}$匹配两位数字的月份、两位数字的日期和四位数字的年份，以斜杠（/）或连字符（-）分隔。

2. 模式2：YYYY/MM/DD 或 YYYY-MM-DD

   import redef match_date_format_2(date_string):    pattern = re.compile(r'^\d{4}[/\-](0[1-9]|1[0-2])[/\-](0[1-9]|[12][0-9]|3[01])$')    if pattern.match(date_string):        print(f"{date_string} 匹配模式。")    else:        print(f"{date_string} 不匹配模式。")# 测试用例dates_pattern_2 = ["2022/12/25", "2023-03-08", "2021/15/07", "2023-12-31", "invalid_date"]for date_str in dates_pattern_2:    match_date_format_2(date_str)

   ^\d{4}[/\-](0[1-9]|1[0-2])[/\-](0[1-9]|[12][0-9]|3[01])$匹配四位数字的年份、两位数字的月份和两位数字的日期，以斜杠（/）或连字符（-）分隔。

3. 模式3：DD Month YYYY

   import redef match_date_format_3(date_string):    pattern = re.compile(r'^(0[1-9]|[12][0-9]|3[01])\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{4}$', re.IGNORECASE)    if pattern.match(date_string):        print(f"{date_string} 匹配模式。")    else:        print(f"{date_string} 不匹配模式。")# 测试用例dates_pattern_3 = ["25 Dec 2022", "08 March 2023", "15/07/2021", "31 October 2023", "invalid_date"]for date_str in dates_pattern_3:    match_date_format_3(date_str)

   ^(0[1-9]|[12][0-9]|3[01])\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{4}$匹配两位数字的日期、三位字母的月份缩写和四位数字的年份，以空格分隔。

27.匹配 HTML 标签

使用正则表达式匹配或提取 HTML 标签中的内容。

import redef extract_content_from_html(html):    # 匹配 HTML 标签内内容的正则表达式模式    pattern = re.compile(r'<[^>]*>([^<]+)<[^>]*>')    # 在 HTML 中查找所有匹配项    matches = pattern.findall(html)    # 打印提取的内容    for match in matches:        print(f"提取的内容：{match.strip()}")# HTML 字符串html_content = """<html>  <body>    <h1>Title</h1>    <p>This is a <strong>sample</strong> paragraph.</p>    <div class="content">Some <em>italicized</em> text.</div>  </body></html>"""# 从 HTML 标签提取内容extract_content_from_html(html_content)

• <[^>]*>：匹配开头 HTML 标签（<），后跟零个或多个非 > 字符（[^>]*），以及结尾 HTML 标签（>）。

• ([^<]+)：用于匹配和提取 HTML 标签内内容的捕获组。它匹配一个或多个非 < 字符。

• <[^>]*>：匹配结尾 HTML 标签。

• findall：在 HTML 字符串中查找模式的所有出现。

28.密码验证

设计正则表达式模式验证密码强度。

import redef validate_password_strength(password):    # 验证强密码的正则表达式模式    pattern = re.compile(        r'^(?=.*[a-z])'     # 至少一个小写字母        r'(?=.*[A-Z])'      # 至少一个大写字母        r'(?=.*\d)'         # 至少一个数字        r'(?=.*[@$!%*?&])'# 至少一个特殊字符        r'(?=^[^\s]{8,}$)'# 最小长度为8个字符，不允许空格    )    if pattern.match(password):        print(f"{password} 是强密码。")    else:        print(f"{password} 不符合密码强度标准。")# 测试用例passwords = [    "StrongPass123!",    "WeakPassword",    "NoSpecialCharacter1",    "Short!23",    "NoUpperLowerCase@1"]# 验证每个密码并打印结果for password in passwords:    validate_password_strength(password)

• (?=.*[a-z])：至少一个小写字母。

• (?=.*[A-Z])：至少一个大写字母。

• (?=.*\d)：至少一个数字。

• (?=.*[@$!%*?&])：至少一个特殊字符（可自定义这个集合）。

• (?=^[^\s]{8,}$)：最小长度为8个字符，且不允许空格。

29.替换空白字符

用单个空格（\s+）替换连续的空白字符。

30.提取数字

使用 \d+ 从字符串中提取数字。

31.提取 URL

创建正则表达式模式从文本中提取 URL。

1. 模式1：基本 URL 提取

   import redef extract_urls(text):    # 提取 URL 的正则表达式模式    pattern = re.compile(r'https?://\S+|www\.\S+')    # 在文本中查找所有匹配项    matches = pattern.findall(text)    # 打印提取的 URL    for match in matches:        print(f"提取的 URL：{match}")# 测试用例text_with_urls = """Check out this website: https://www.example.com.For more information, visit http://www.another-example.org."""# 从文本中提取 URLextract_urls(text_with_urls)

• https?：匹配 "http" 或 "https"。

• ://：匹配 "://"。

• \S+：匹配一个或多个非空白字符（域名）。

• |：或运算符。

• www\.\S+：匹配 "www." 后跟一个或多个非空白字符。

2. 模式2：扩展 URL 提取

   import redef extract_urls_extended(text):    # 提取带可选 www 和查询参数的 URL 的正则表达式模式    pattern = re.compile(r'https?://(?:www\.)?\S+(?:\?\S+)?')    # 在文本中查找所有匹配项    matches = pattern.findall(text)    # 打印提取的 URL    for match in matches:        print(f"提取的 URL：{match}")# 测试用例text_with_urls_extended = """Check out this website: https://www.example.com/path/page?query=123.For more information, visit http://another-example.org."""# 从文本中提取 URLextract_urls_extended(text_with_urls_extended)

• (?:www\.)?：可选 "www." 的非捕获组。

• (?:\?\S+)?)：可选查询参数（以 "?" 开头）的非捕获组。

32.匹配 HTML 实体

使用正则表达式匹配或替换 HTML 实体。

import refrom html import unescapedef replace_html_entities(text):    # 匹配 HTML 实体的正则表达式模式    pattern = re.compile(r'&[a-zA-Z]+;')    # 在文本中查找所有匹配项    matches = pattern.findall(text)    # 将每个 HTML 实体替换为其解码后的等效字符    for match in matches:        decoded_entity = unescape(match)        text = text.replace(match, decoded_entity)    return text# 测试用例html_text = "This is an example with <b>HTML</b> entities."# 替换文本中的 HTML 实体result_text = replace_html_entities(html_text)# 打印结果print("原始文本：", html_text)print("替换后：", result_text)

正则表达式模式 &[a-zA-Z]+; 用于匹配常见的 HTML 实体。然后使用 html 模块中的 unescape 函数将每个 HTML 实体替换为其解码后的等效字符。

33.匹配文件路径

设计正则表达式模式匹配文件路径。

1. 模式1：Unix/Linux 文件路径

   import redef match_unix_file_path(path):    # 匹配 Unix/Linux 文件路径的正则表达式模式    pattern = re.compile(r'^\/(?:[^\/]+\/)*[^\/]+$')    if pattern.match(path):        print(f"{path} 是有效的 Unix/Linux 文件路径。")    else:        print(f"{path} 不是有效的 Unix/Linux 文件路径。")# 测试用例unix_paths = [    "/home/user/documents/file.txt",    "/var/www/html/index.html",    "relative/path/to/file",    "invalid\\path\\file.txt"]for path in unix_paths:    match_unix_file_path(path)

• ^：断言字符串的开头。

• \/：匹配根目录（"/"）。

• (?:[^\/]+\/)*：非捕获组，匹配零个或多个非斜杠字符后跟斜杠的序列。

• [^\/]+$：匹配字符串末尾一个或多个非斜杠字符。

2. 模式2：Windows 文件路径

   import redef match_windows_file_path(path):    # 匹配 Windows 文件路径的正则表达式模式    pattern = re.compile(r'^[a-zA-Z]:\\(?:[^\\]+\\)*[^\\]+$')    if pattern.match(path):        print(f"{path} 是有效的 Windows 文件路径。")    else:        print(f"{path} 不是有效的 Windows 文件路径。")# 测试用例windows_paths = [    "C:\\Users\\User\\Documents\\file.txt",    "D:/Projects/project1/code.py",    "\\absolute\\path\\file.txt",    "/unix/style/path/file"]for path in windows_paths:    match_windows_file_path(path)

• ^：断言字符串的开头。

• [a-zA-Z]:\\：匹配驱动器号（例如，"C:"）后跟反斜杠。

• (?:[^\\]+\\)*：非捕获组，匹配零个或多个非反斜杠字符后跟反斜杠的序列。

• [^\\]+$：匹配字符串末尾一个或多个非反斜杠字符。

34.提取电子邮件地址

创建正则表达式模式从文本中提取电子邮件地址。

1. 模式1：基本电子邮件地址提取

   import redef extract_email_addresses(text):    # 基本电子邮件地址提取的正则表达式模式    pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b')    # 在文本中查找所有匹配项    matches = pattern.findall(text)    # 打印提取的电子邮件地址    for match in matches:        print(f"提取的电子邮件：{match}")# 测试用例text_with_emails = """Contact us at support@example.com for assistance.Send your inquiries to info@company.org or sales@business.com.Invalid emails: user@invalid, @missing_username.com, email@in@valid.com"""# 从文本中提取电子邮件地址extract_email_addresses(text_with_emails)

   \b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b

• \b：单词边界，确保匹配整个电子邮件地址。

• [A-Za-z0-9._%+-]+：匹配电子邮件的用户名部分。

• @：匹配 @ 符号。

• [A-Za-z0-9.-]+：匹配域名。

• \.：匹配顶级域名前的点。

• [A-Z|a-z]{2,}：匹配至少2个字符的顶级域名（TLD）。

2. 模式2：扩展电子邮件地址提取

   import redef extract_email_addresses_extended(text):    # 扩展电子邮件地址提取的正则表达式模式    pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}(?:\.[A-Z|a-z]{2,})?\b')    # 在文本中查找所有匹配项    matches = pattern.findall(text)    # 打印提取的电子邮件地址    for match in matches:        print(f"提取的电子邮件：{match}")# 测试用例text_with_emails_extended = """Contact us at support@example.com for assistance.Send your inquiries to info@company.org or sales@business.co.uk.Invalid emails: user@invalid, @missing_username.com, email@in@valid.com"""# 从文本中提取电子邮件地址extract_email_addresses_extended(text_with_emails_extended)

   ...(?:\.[A-Z|a-z]{2,})?\b

• (?: ... )?：可选附加子域名的非捕获组。

• \.：匹配附加子域名前的点。

• [A-Z|a-z]{2,}：匹配至少2个字符的附加子域名。

35.匹配 IPv4 地址

设计正则表达式模式匹配 IPv4 地址。

1. 模式1：基本 IPv4 地址匹配

   import redef match_ipv4_addresses(text):    # 基本 IPv4 地址匹配的正则表达式模式    pattern = re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b')    # 在文本中查找所有匹配项    matches = pattern.findall(text)    # 打印匹配的 IPv4 地址    for match in matches:        print(f"匹配的 IPv4 地址：{match}")# 测试用例text_with_ipv4 = """Server 1: 192.168.1.1Server 2: 10.0.0.255Invalid IP: 256.256.256.256"""# 在文本中匹配 IPv4 地址match_ipv4_addresses(text_with_ipv4)

   \b(?:\d{1,3}\.){3}\d{1,3}\b

• \b：单词边界，确保匹配整个 IPv4 地址。

• (?:\d{1,3}\.){3}：非捕获组，匹配三次 "1-3 位数字后跟点"。

• \d{1,3}：匹配最后一个八位字节（1-3 位数字）。

2. 模式2：扩展 IPv4 地址匹配

   import redef match_ipv4_addresses_extended(text):    # 扩展 IPv4 地址匹配的正则表达式模式    pattern = re.compile(r'\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)'                       r'(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}\b')    # 在文本中查找所有匹配项    matches = pattern.findall(text)    # 打印匹配的 IPv4 地址    for match in matches:        print(f"匹配的 IPv4 地址：{match}")# 测试用例text_with_ipv4_extended = """Server 1: 192.168.1.1Server 2: 10.0.0.255Invalid IP: 256.256.256.256"""# 在文本中匹配 IPv4 地址match_ipv4_addresses_extended(text_with_ipv4_extended)

   \b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)

• (?: ... ){3}：非捕获组，匹配三次以下模式。

• 25[0-5]：匹配 250 到 255 之间的数字。

• 2[0-4][0-9]：匹配 200 到 249 之间的数字。

• [01]?[0-9][0-9]?：匹配 0 到 199 之间的数字。

36.转义符上的量词

将量词直接应用于转义符（例如，\d{3} 匹配三位数字）。

37.匹配信用卡号

创建正则表达式模式匹配或验证信用卡号。

1. 模式1：基本信用卡号验证

   import redef validate_credit_card_number_basic(card_number):    # 基本信用卡号验证的正则表达式模式    pattern = re.compile(r'^\d{13,19}$')    if pattern.match(card_number):        print(f"{card_number} 可能是有效的信用卡号。")    else:        print(f"{card_number} 不是有效的信用卡号。")# 测试用例credit_cards_basic = [    "1234567890123",    "4567-8901-2345-6789",    "1234 5678 9012 3456",    "invalid_card",]for card in credit_cards_basic:    validate_credit_card_number_basic(card)

   ^\d{13,19}$：匹配长度在13到19个字符之间的数字字符串。

2. 模式2：带卢恩算法的信用卡号验证

   import redef validate_credit_card_number_luhn(card_number):    # 带卢恩算法的信用卡号验证的正则表达式模式    pattern = re.compile(r'^\d{13,19}$')    ifnot pattern.match(card_number):        print(f"{card_number} 不是有效的信用卡号。")        return    # 移除非数字字符    digits = [int(digit) for digit in card_number if digit.isdigit()]    # 应用卢恩算法    total = sum(digits[::-2] + [sum(divmod(d * 2, 10)) for d in digits[-2::-2]])    if total % 10 == 0:        print(f"{card_number} 是有效的信用卡号。")    else:        print(f"{card_number} 不是有效的信用卡号。")# 测试用例credit_cards_luhn = [    "1234567890123",    "4567-8901-2345-6789",    "1234 5678 9012 3456",    "invalid_card",]for card in credit_cards_luhn:    validate_credit_card_number_luhn(card)

• ^\d{13,19}$：与基本模式相同，用于初始数字验证。

• 卢恩算法用于检查信用卡号的有效性。

38.匹配特定单词

使用 \b 匹配较大文本中的特定单词。

39.转义字符

1. 使用 \ 转义特殊字符，如 ^、$、(、)、[、]、{、}、.、*、+、?、|、\。

2. 在非特殊字符前使用 \ 以字面匹配它。

40.Unicode 和单词边界

1. 使用 \b 作为单词边界，\B 作为非单词边界。

2. 对于 Unicode 单词边界，结合 re.UNICODE 标志使用 \b。

41.匹配或排除字符

1. 使用 . 匹配除换行符外的任何字符。

2. 使用 [^...] 匹配不在指定集合中的任何字符。

42.量词组合

1. 组合量词以提高灵活性（例如，a{2,4} 匹配 'aa'、'aaa' 或 'aaaa'）。

2. 使用 {0,} 或 * 表示零次或多次出现。

43.分组和选择

1. 使用括号进行分组，并对序列应用量词。

   import re# 包含电话号码的示例文本text = """Phone Numbers:- (555) 123-4567- (123) 456-7890- (987) 654-3210"""# 带分组和量词的正则表达式模式，用于匹配电话号码pattern = re.compile(r'\(\d{3}\) \d{3}-\d{4}')# 在文本中查找所有匹配项matches = pattern.findall(text)# 打印匹配的电话号码for match in matches:    print("匹配的电话号码：", match)

• \(：匹配左括号。

• \d{3}：匹配恰好三位数字。

• \)：匹配右括号。

• ：匹配空格。

• \d{3}：匹配恰好三位数字。

• -：匹配连字符。

• \d{4}：匹配恰好四位数字。

2. 利用 (?:...) 作为非捕获组。

3. 利用选择匹配多个可能的模式（例如，cat|dog|bird）。

44.替换中的捕获组

1. 在替换模式中使用 \1、\2 等利用捕获组。

2. 对命名捕获组使用 \g<name>。

45.环视

1. 使用正向后顾（(?<=...)）匹配前面有特定模式的内容。

2. 应用负向后顾（(?<!...)）匹配前面没有特定模式的内容。

3. 利用正向前瞻（(?=...)）匹配后面有特定模式的内容。

4. 利用负向前瞻（(?!...)）匹配后面没有特定模式的内容。

46.命名捕获组

1. 使用命名捕获组提高代码可读性。

2. 使用 match.group('name') 访问命名捕获组。

47.详细模式

1. 启用详细模式（re.VERBOSE 或 re.X），支持多行模式和注释。

2. 将复杂模式拆分为多行，提高可读性。

   import re# 包含电子邮件地址的示例文本text = """Email Addresses:- user@example.com- john.doe@company.org- contact@my-website.co.uk"""# 带换行符的正则表达式模式，提高可读性pattern = re.compile(    r'\b'                    # 单词边界    r'[a-zA-Z0-9._%+-]+@'    # 用户名部分    r'[a-zA-Z0-9.-]+\.'      # 域名部分（第一级）    r'[A-Z|a-z]{2,}'         # 域名部分（顶级）    r'\b'                    # 单词边界)# 在文本中查找所有匹配项matches = pattern.findall(text)# 打印匹配的电子邮件地址for match in matches:    print("匹配的电子邮件地址：", match)

48.标志和模式

1. 利用标志，如 re.IGNORECASE 进行不区分大小写的匹配。

2. 使用按位 OR 组合多个标志（例如，re.IGNORECASE | re.MULTILINE）。

49.验证和提取电子邮件域名

1. 使用正则表达式模式验证电子邮件域名。

   import redef validate_email_domain(email):    # 基本电子邮件地址验证的正则表达式模式    email_pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b')    # 检查电子邮件地址是否匹配模式    ifnot email_pattern.match(email):        print(f"{email} 不是有效的电子邮件地址。")        return    # 从电子邮件地址提取域名    domain_pattern = re.compile(r'@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b')    domain_match = domain_pattern.search(email)    if domain_match:        domain = domain_match.group()[1:]        print(f"{email} 的域名是 {domain}。")    else:        print(f"无法从 {email} 提取域名。")# 测试用例emails = [    "user@example.com",    "john.doe@company.org",    "invalid-email",]for email in emails:    validate_email_domain(email)

   请注意，这种方法有局限性，不能保证域名的有效性。对于更可靠的解决方案，考虑使用专门的电子邮件验证库或服务。使用 DNS 查找验证域名是更可靠的方法，但需要正则表达式之外的额外步骤。

• email_pattern 正则表达式与基本电子邮件地址验证中使用的相同。

• domain_pattern 正则表达式用于从电子邮件地址提取域名部分。

• @[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b：匹配 @ 符号后的域名部分。

2. 使用模式中的捕获组提取电子邮件域名。

   import redef extract_email_domain(email):    # 带捕获组的正则表达式模式，用于提取电子邮件域名    pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@([A-Za-z0-9.-]+\.[A-Z|a-z]{2,})\b')    # 用模式匹配电子邮件地址    match = pattern.search(email)    if match:        domain = match.group(1)        print(f"{email} 的域名是 {domain}。")    else:        print(f"无法从 {email} 提取域名。")# 测试用例emails = [    "user@example.com",    "john.doe@company.org",    "invalid-email",]for email in emails:    extract_email_domain(email)

   \b[A-Za-z0-9._%+-]+@([A-Za-z0-9.-]+\.[A-Z|a-z]{2,})\b

   group(1) 方法用于提取第一个（也是唯一一个）捕获组捕获的内容，即电子邮件域名。

• \b：单词边界，确保匹配整个电子邮件地址。

• [A-Za-z0-9._%+-]+：匹配电子邮件的用户名部分。

• @：匹配 @ 符号。

• ([A-Za-z0-9.-]+\.[A-Z|a-z]{2,})：域名部分的捕获组。

• \b：单词边界，确保匹配整个电子邮件地址。

50.匹配平衡括号

创建正则表达式匹配带平衡括号的表达式。

import regexdef is_balanced(expression):    # 匹配带平衡括号的表达式的正则表达式模式    pattern = regex.compile(r'''        \(            (?: [^()]+ | (?R) )*        \)    ''', regex.VERBOSE)    return bool(pattern.fullmatch(expression))# 测试用例expressions = [    "(a + b) * (c - d)",    "((x + y) * z)",    "((a + b) * (c - d)",    "a + b) * (c - d)",]for expr in expressions:    if is_balanced(expr):        print(f"表达式 '{expr}' 有平衡的括号。")    else:        print(f"表达式 '{expr}' 没有平衡的括号。")

• \(：匹配左括号。

• (?: [^()]+ | (?R) )*：非捕获组，零次或多次出现以下内容：

• [^()]+：除括号外的任何字符序列。

• (?R)：递归匹配整个模式。

• \)：匹配右括号。

Python 中的 regex 模块支持递归模式，允许定义引用自身的模式。在这种情况下，模式 (?R) 用于递归匹配整个模式。

51.验证 IP 地址

1. 设计正则表达式模式验证 IPv4 和 IPv6 地址。

   import redef validate_ipv4_address(ipv4):    # IPv4 地址验证的正则表达式模式    pattern = re.compile(        r'^'        r'(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.'        r'(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.'        r'(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.'        r'(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'    )    return bool(pattern.match(ipv4))# 测试用例ipv4_addresses = [    "192.168.1.1",    "10.0.0.255",    "256.256.256.256",    "invalid-ip",]for ipv4 in ipv4_addresses:    if validate_ipv4_address(ipv4):        print(f"{ipv4} 是有效的 IPv4 地址。")    else:        print(f"{ipv4} 不是有效的 IPv4 地址。")

   import redef validate_ipv6_address(ipv6):    # IPv6 地址验证的正则表达式模式    pattern = re.compile(        r'^'        r'(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$'    )    return bool(pattern.match(ipv6))# 测试用例ipv6_addresses = [    "2001:0db8:85a3:0000:0000:8a2e:0370:7334",    "invalid-ipv6",]for ipv6 in ipv6_addresses:    if validate_ipv6_address(ipv6):        print(f"{ipv6} 是有效的 IPv6 地址。")    else:        print(f"{ipv6} 不是有效的 IPv6 地址。")

   IPv4 地址验证：

   IPv6 地址验证：

• (?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}：验证 IPv6 地址块。

• :：匹配冒号分隔符。

• ^：断言字符串的开头。

• (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)：验证每个八位字节。

• \.：匹配点分隔符。

• $：断言字符串的结尾。

2. 使用该模式从文本中提取 IP 地址。

   import redef extract_ip_addresses(text):    # IPv4 地址提取的正则表达式模式    ipv4_pattern = re.compile(r'\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b')    # IPv6 地址提取的正则表达式模式    ipv6_pattern = re.compile(r'\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b')    # 在文本中查找所有匹配项    ipv4_matches = ipv4_pattern.findall(text)    ipv6_matches = ipv6_pattern.findall(text)    # 打印匹配的 IP 地址    print("IPv4 地址：")    for ipv4_match in ipv4_matches:        print(ipv4_match)    print("\nIPv6 地址：")    for ipv6_match in ipv6_matches:        print(ipv6_match)# 测试用例sample_text = """本文中的 IP 地址：- IPv4：192.168.1.1、10.0.0.255、256.256.256.256- IPv6：2001:0db8:85a3:0000:0000:8a2e:0370:7334"""extract_ip_addresses(sample_text)

52.匹配 Markdown 链接

创建正则表达式模式匹配和提取 Markdown 文本中的链接。

import redef extract_markdown_links(markdown_text):    # 提取行内链接的正则表达式模式    inline_link_pattern = re.compile(r'\[([^\]]+)\]\(([^)]+)\)')    # 提取引用式链接的正则表达式模式    reference_link_pattern = re.compile(r'\[([^\]]+)\]:\s*([^\s]+)')    # 在文本中查找所有行内链接    inline_links = inline_link_pattern.findall(markdown_text)    # 在文本中查找所有引用式链接    reference_links = reference_link_pattern.findall(markdown_text)    # 打印提取的链接    print("行内链接：")    for title, url in inline_links:        print(f"标题：{title}，URL：{url}")    print("\n引用式链接：")    for title, url in reference_links:        print(f"标题：{title}，URL：{url}")# 测试用例sample_markdown = """Here are some links in Markdown:- [Google](https://www.google.com)- [OpenAI](https://www.openai.com)Reference-style links:[Markdown Guide]: https://www.markdownguide.org[GitHub]: https://github.com"""extract_markdown_links(sample_markdown)

• inline_link_pattern 正则表达式捕获方括号（[]）内的文本作为链接标题，圆括号（()）内的文本作为链接 URL。

• reference_link_pattern 正则表达式捕获方括号（[]）内的文本作为链接标题，冒号（:）后的文本（含可选空格）作为链接 URL。

53.匹配带引号的字符串

设计正则表达式模式匹配文本中的带引号字符串。

import redef extract_quoted_strings(text):    # 提取单引号字符串的正则表达式模式    single_quoted_pattern = re.compile(r"'([^']+)'")    # 提取双引号字符串的正则表达式模式    double_quoted_pattern = re.compile(r'"([^"]+)"')    # 在文本中查找所有单引号字符串    single_quoted_strings = single_quoted_pattern.findall(text)    # 在文本中查找所有双引号字符串    double_quoted_strings = double_quoted_pattern.findall(text)    # 打印提取的带引号字符串    print("单引号字符串：")    for single_quoted in single_quoted_strings:        print(single_quoted)    print("\n双引号字符串：")    for double_quoted in double_quoted_strings:        print(double_quoted)# 测试用例sample_text = """Here are some quoted strings in the text:- Single-quoted: 'Hello, world!'- Double-quoted: "This is a quoted string."Mixed quotes: 'Single and "double" quotes.'"""extract_quoted_strings(sample_text)

• single_quoted_pattern 正则表达式捕获单引号（'）内的文本作为单引号字符串的内容。

• double_quoted_pattern 正则表达式捕获双引号（"）内的文本作为双引号字符串的内容。

54.提取 HTML 属性

构建模式从文本中提取 HTML 标签属性。

import redef extract_html_attributes(html_text):    # 提取 HTML 标签属性的正则表达式模式    pattern = re.compile(r'<\s*([a-zA-Z0-9_-]+)(?:\s+([a-zA-Z0-9_-]+)\s*=\s*(".*?"|\'.*?\'|[^\s>]+))*\s*/?>')    # 在文本中查找所有 HTML 标签    matches = pattern.finditer(html_text)    # 提取并打印标签名称和属性    for match in matches:        tag_name = match.group(1)        print(f"标签：{tag_name}")        if match.group(2):            attributes = match.group(2)            attribute_pattern = re.compile(r'([a-zA-Z0-9_-]+)\s*=\s*(".*?"|\'.*?\'|[^\s>]+)')            # 提取并打印单个属性            for attribute_match in attribute_pattern.finditer(attributes):                attribute_name = attribute_match.group(1)                attribute_value = attribute_match.group(2)                print(f"  属性：{attribute_name}，值：{attribute_value}")# 测试用例sample_html = """<div class="container" id='main-container' data-value=42>    <p style="color: blue;">This is a paragraph</p>    <a href="https://example.com" target="_blank">Visit Example</a></div>"""extract_html_attributes(sample_html)

• pattern 正则表达式捕获标签名称及其属性。

• attribute_pattern 正则表达式捕获单个属性及其值。

55.组上的量词

将量词直接应用于组（例如，(ab)+ 匹配一个或多个 'ab' 序列）。

56.匹配十六进制颜色

设计模式匹配 HTML 中的十六进制颜色代码。

import redef extract_hex_color_codes(html_text):    # 匹配十六进制颜色代码的正则表达式模式    pattern = re.compile(r'#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})\b')    # 在文本中查找所有颜色代码    color_codes = pattern.findall(html_text)    # 打印匹配的颜色代码    print("十六进制颜色代码：")    for color_code in color_codes:        print(color_code)# 测试用例sample_html = """<style>    .background-color {        background-color: #aabbcc;    }    .text-color {        color: #123;    }</style>"""extract_hex_color_codes(sample_html)

pattern 正则表达式匹配短格式（#abc）或长格式（#aabbcc）的十六进制颜色代码。

• (?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})：

• (?: ... )：非捕获组。

• [0-9a-fA-F]{3}：匹配三位十六进制数字。

• |：选择。

• [0-9a-fA-F]{6}：匹配六位十六进制数字。