Python开源实用库与软件收集

PyAutoUI全自动化库

OpenCV

Tesseract OCR 文字识别

wxpy一个基于Python的开源微信个人号API

Python中提取人脸特征的三种方法详解

OpenVINO

Moviepy和OpenCV-Python进行音视频剪辑处理

python-numpy常用方法总结

python关于人脸

PaddleOCR 简单 demo 入门（比EasyOCR效果好可比商业软件)

moviepy视频编辑组件

Pyppeteer 就是 Puppeteer 的 Python 版使用

哪些 Python 库让你相见恨晚

face_recognition使用Python和命令行工具提取、识别、操作人脸。

python-spider网络爬虫实战：淘宝、京东、网易云、B站、12306、抖音、笔趣阁、漫画小说下载、音乐电影下载等

GPT_API_free免费ChatGPT API，支持GPT4 API（免费），ChatGPT国内可用免费转发API，直连无需代理。可以搭配ChatBox等软件/插件使用

chatgpt-mirai-qq-bot一键部署！真正的 AI 聊天机器人！支持ChatGPT、文心一言、讯飞星火、Bing、Bard、ChatGLM、POE，多账号，人设调教，虚拟女仆、图片渲染、语音发送 | 支持 QQ、Telegram、Discord、微信 等平台

ChatGLM3开源双语对话语言模型

Python 抖音机器人，论如何在抖音上找到漂亮小姐姐？

Llama中文社区，最好的中文Llama大模型，完全开源可商用

chinese-dos-games中文 DOS 游戏合集，目前共有 1898 款游戏。

ddddocr带带弟弟 通用验证码识别OCR pypi版

ASRT_SpeechRecognition基于深度学习的中文语音识别系统

Douyin_TikTok_Download_API是一个开箱即用的高性能异步抖音、快手、TikTok、Bilibili数据爬取工具，支持API调用，在线批量解析及下载。

MoneyPrinterTurbo利用AI大模型，一键生成高清短视频

Selenium WebDrive

开源的可视化爬虫EasySpider

edge-tts调用微软的在线TTS合成

surya OCR库

DrissionPage基于python的网页自动化工具

customtkinter基于tkinter的UI界面扩展

OCR开源引擎GOT-OCR

PyAutoUI全自动化库

我们以前讲过怎样使用 Python 在浏览器中实现页面自动化操作，不管用哪种方式实现，都是通过定位页面中的元素来进行相应的操作

今天我们来聊一聊如何在桌面实现自动化操作。与浏览器页面自动化操作类似，桌面自动化操作也是需要定位鼠标在桌面的位置，然后根据定位的位置执行对应的操作。

GUI 控制神器

我们今天的主人公是 pyautogui，pyautogui 是一个纯 Python 的 GUI 自动化工具，通过它可以让程序自动控制鼠标和键盘的一系列操作来达到自动化测试的目的。

这个模块的安装也是老一套：

pip3 install pyautogui

安装好了就可以直接使用了。

鼠标操作

鼠标移动

桌面操作最基本的就是鼠标操作了，我们可以控制鼠标的移动：

# 移动鼠标

pyautogui.moveTo(200,400,duration=2)

pyautogui.moveRel(200,500,duration=2)

整个桌面是以左上角为坐标轴的原点，所有的操作都以这个原点，来确定操作位置。

第一行是将鼠标移动到指定的像素(200,400)位置，第二行代码是将鼠标按照当前点向右移动200px，向下移动400px这个方向移动。

两行代码中都有一个共同的参数 duration，这个参数表示移动时间，即在指定时间内完成移动操作，单位是秒。

运行这两行代码，观察屏幕鼠标的变化，是不是很神奇？

我们还可以获取鼠标位置：

print(pyautogui.position())  

这个很好理解，就是获取鼠标在当前屏幕中的坐标位置，运行这行代码，我们会得到诸如下面的信息：

Point(x=400, y=900)

鼠标点击

通常，我们的鼠标有左右两个按键，高级点的鼠标中间还有个按键。

我的鼠标只有两个按键，中间没有按键，唉~

pyautogui针对这三个按键操作都有相应的处理：

# 鼠标点击，默认左键

pyautogui.click(100,100)   

# 单击左键

pyautogui.click(100,100,button='left')  

# 单击右键

pyautogui.click(100,300,button='right') 

# 单击中间 

pyautogui.click(100,300,button='middle')  

鼠标点击，如果不指定 button 参数，默认是点击左键，前面两个参数就是点击坐标的位置。

运行这段代码，看看你的桌面会发生什么？

鼠标除了点击操作，还有双击操作：

# 双击左键

pyautogui.doubleClick(10,10)  

# 双击右键

pyautogui.rightClick(10,10)   

# 双击中键

pyautogui.middleClick(10,10) 

操作函数也很简单，相信大家一眼就能看明白，如果一眼看不明白，请多看几眼！

熟悉前端的小伙伴可能会马上联想到，鼠标操作有按下和释放的过程，我们屏幕操作也有对应的控制：

# 鼠标按下

pyautogui.mouseDown()   

# 鼠标释放

pyautogui.mouseUp()    

鼠标拖动

我们可以控制鼠标拖动到指定坐标位置，并且设置操作时间：

pyautogui.dragTo(100,300,duration=1)   

这个运行效果和前面移动类似。

根据前面移动的经验，我们也有按照方向拖动鼠标：

pyautogui.dragRel(100,300,duration=4) 

鼠标滚动

在桌面操作中，我们有时候需要滚动鼠标到达向上或者向下的位置，这时候我们可以使用 scroll 这个函数来控制：

pyautogui.scroll(30000) 

参数是整数，表示向上或向下滚动多少个单位，这个单位根据不同的操作系统可能不一样。如果向上滚动，传入正整数，向下滚动传入负整数。

屏幕处理

获取屏幕截图

我们先来假设一个场景：我现在要在屏幕上找到一个红色的点，你会怎么做？通常的做法是拿到这个红色点的颜色值，然后再对屏幕上的点逐个进行比较，直到找到为止。

pyautogui 为我们这个操作场景提供了支持，分别有三个函数可以完成这三件事情。

im = pyautogui.screenshot()

im.save('screenshot.png')

rgb = im.getpixel((100, 500))

print(rgb)

match = pyautogui.pixelMatchesColor(500,500,(12,120,400))

print(match)

第一个是获取屏幕截图函数，它可以返回一个 Pillow 的 image 对象; 第二个是获取屏幕截图中指定坐标点的颜色，返回 rgb 颜色值；第三个是将指定坐标点的颜色和目标的颜色进行比对，返回布尔值。

我们再来升级一下需求：

我现在要在屏幕上找到 edge 浏览器的图标，你会怎么做？

通常的做法是先知道 edge 浏览器的图标长啥样，是绿色还是蓝色，是胖的还是瘦的，对吧？然后再在屏幕上去进行图标的匹配，直到找到一个图标跟我们目标图标一样，就得到了结果。

于是，我们的代码如下：

# 图像识别（一个）

oneLocation = pyautogui.locateOnScreen('1.png')

print(oneLocation)  

# 图像识别（多个）

allLocation = pyautogui.locateAllOnScreen('1.png')

print(list(allLocation))

你可以在桌面上将某个应用的图标截取下来，保存为图片，然后使用上面几行代码来识别，识别成功，你会返回类似下面的结果：

Box(left=20, top=89, width=33, height=34)

[Box(left=20, top=89, width=33, height=34)]

这就是图片在桌面的位置，如果找不到图片，就会返回 None。

键盘输入

键盘函数

键盘输入有下面几个常用的函数：

keyDown()：模拟按键按下

keyUP()：模拟按键松开

press()：模拟一次按键过程，即 keyDown 和 keyUP 的组合

typewrite()：模拟键盘输出内容

举个例子，大家平时输入感叹号（！）是怎么操作键盘的？

按住 shift 按键，然后再按住 1 按键，就可以了。用 pyautogui 控制就是：

pyautogui.keyDown('shift')    

pyautogui.press('1')    

pyautogui.keyUp('shift')   

运行上面的代码，如果你的鼠标是放在编辑框中，你会得到一个感叹号！

我们还可以直接输出内容：

pyautogui.typewrite('python', 1)

第一个参数是输出的内容，第二个参数是间隔时间，单位是秒。

运行上面代码，你的编辑器里面就会每隔1秒钟按顺序输出 python 的6个字母。

特殊符号

有时我们需要输入键盘的一些特殊的符号按键，比如 换行、方向键等，这些有相对应的键盘字符串表示：

pyautogui.typewrite(['p','y','t','h','o','n','enter'])   

运行上面代码，编辑器里面就会输出 python 之后换行。

其他特殊按键对应的字符串请参考官方说明。

快捷键

如果我要复制一个内容，大部分情况下会使用快键键 ctrl + c，按照上面讲的，我们应该这么实现：

pyautogui.keyDown('ctrl')

pyautogui.keyDown('c')

pyautogui.keyUp('c')

pyautogui.keyUp('ctrl')

这样写起来很麻烦，而且需要掌控按键的按下和释放的顺序。

pyautogui 为我们提供了一个快捷的函数：

pyautogui.hotkey('ctrl','c')

实现的效果和上面的4行代码相同。

信息框

当你在模拟一个桌面操作的时候，如果有分支操作需要根据实际情况来判断，你是不是需要有一个地方可以让你选择走哪个分支？

pyautogui 贴心地考虑到了这种情况，你可以通过弹出一个选择框来中断当前的操作，选择操作分支。

way = pyautogui.confirm('领导，该走哪条路？', buttons=['农村路', '水路', '陆路'])

print(way)

这里就是我们 HTML 页面的 confirm 选择框，选择了选项之后，我们可以获取到选择的选项，然后基于这个选项做判断，进入相应的操作分支。

除了选择确认框之外，还有其他一些提示信息框：

# 警告框

alert = pyautogui.alert(text='警告！敌军来袭！', title='警告框')

print(alert)

# 密码框

password = pyautogui.password('请输入密码')

print(password)

# 普通输入框

input = pyautogui.prompt('请输入指令：')

print(input)

总结

pyautogui 的基本知识就给大家介绍到这里，这个 python 模块的功能十分强大，函数都非常简单，对 python 初学者比较友好。学了这些基本知识之后，你可以运用这些基本知识的组合，去实现一些有趣的桌面自动化操作，快去尝试一把吧！

Tesseract OCR 文字识别

当使用Python进行Tesseract OCR文字识别时，你可以使用pytesseract库。pytesseract是Tesseract OCR引擎的Python接口，它使得在Python中进行文字识别变得非常方便。

首先，你需要安装Tesseract OCR引擎和pytesseract库。以下是一个使用pytesseract进行文字识别的简单示例：

import pytesseract

from PIL import Image

# 打开图像文件

image = Image.open('image.png')

# 使用Tesseract进行文字识别

text = pytesseract.image_to_string(image)

# 打印识别结果

print(text)

在这个示例中，我们首先导入了pytesseract库和PIL库中的Image模块。然后，我们使用Image.open()函数打开图像文件（在这个示例中假设图像文件名为'image.png'）。

接下来，我们使用pytesseract.image_to_string()函数对图像进行文字识别。这个函数将图像作为输入，并返回识别出的文字结果。

最后，我们打印出识别结果。

请注意，使用Tesseract OCR进行文字识别依赖于Tesseract OCR引擎本身，因此你需要确保已经正确安装了Tesseract OCR引擎，并且在代码中指定了正确的路径。如果Tesseract OCR引擎没有正确安装或路径设置错误，pytesseract库可能无法正常工作。

wxpy一个基于Python的开源微信个人号API

wxpy是一个基于Python的开源微信个人号API，它提供了简单易用的接口，使得开发者可以使用Python来实现与微信的交互。wxpy可以用于发送消息、接收消息、获取联系人信息、管理群组等操作。

以下是一个使用wxpy的简单示例，演示了如何使用wxpy库登录微信账号并发送消息给指定的好友：

from wxpy import *

# 初始化机器人，扫码登录

bot = Bot(cache_path=True)

# 搜索好友

friend = bot.friends().search('好友昵称')[0]

# 发送消息

friend.send('Hello, wxpy!')

# 保持程序运行

embed()

在这个示例中，首先我们导入了wxpy库。然后通过Bot()函数创建一个机器人实例，并使用cache_path=True参数来启用登录缓存，以避免每次登录都需要扫码。

接下来，我们使用search()函数搜索指定昵称的好友，并取得搜索结果列表的第一个元素，即我们要发送消息的好友对象。

然后，我们使用好友对象的send()方法发送消息。在这个例子中，我们发送了一条简单的消息"Hello, wxpy!"。

最后，我们使用embed()函数保持程序运行，这样我们就可以保持与微信的连接，并接收可能的回复消息。

这只是wxpy的一个简单示例，wxpy还提供了更多功能，例如接收消息、管理群组、获取好友列表等等。你可以参考wxpy的官方文档（https://wxpy.readthedocs.io/）以了解更多关于wxpy的详细信息和用法。

Python中提取人脸特征的三种方法详解

查看原文

1.直接使用dlib

安装dlib方法：

Win10安装dlib GPU过程详解

思路：

1、使用dlib.get_frontal_face_detector()方法检测人脸的位置。

2、使用 dlib.shape_predictor()方法得到人脸的关键点。

3、使用dlib.face_recognition_model_v1()方法提取特征。

新建face_embedding1.py，插入代码：

import dlib,numpy

import cv2

# 人脸关键点检测器

predictor_path = "shape_predictor_68_face_landmarks.dat"

# 人脸识别模型、提取特征值

face_rec_model_path = "dlib_face_recognition_resnet_model_v1.dat"

predictor_path是恋人关键点检测器模型的路径。

face_rec_model_path是提取人脸特征的路径。

# 加载模型

detector = dlib.get_frontal_face_detector() #人脸检测

sp = dlib.shape_predictor(predictor_path) #关键点检测

facerec = dlib.face_recognition_model_v1(face_rec_model_path)# 编码

分别初始化人脸检测、关键点检测、特征编码方法。

image_path='train_images/11.jpg'

image = cv2.imread(image_path)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# 人脸检测

dets = detector(image, 1)

if len(dets)==1:

    print('检测到人脸')

shape = sp(image, dets[0])# 关键点

# 提取特征

face_descriptor = facerec.compute_face_descriptor(image, shape)#获取到128位的编码

v = numpy.array(face_descriptor)

print(v)

读取图片。然后将图片转为RGB格式。

检测人脸。

获取人脸的68个关键点。

获取128位人脸编码。

使用感受： 使用dlib.get_frontal_face_detector()检测人脸效果一般，模糊的人脸检测不出来。速度上也是比较慢。

2.使用深度学习方法查找人脸，dlib提取特征

思路：

这种方法使用 cv2自带的dnn.readNetFromCaffe方法，加载深度学习模型实现人脸的检测。然后继续使用dlib提取人脸特征。

新建face_embedding2.py，插入代码：

import dlib,numpy

import cv2

# 人脸关键点检测器

predictor_path = "shape_predictor_68_face_landmarks.dat"

# 人脸识别模型、提取特征值

face_rec_model_path = "dlib_face_recognition_resnet_model_v1.dat"

prototxt_path = 'deploy.proto.txt'

model_path = 'res10_300x300_ssd_iter_140000_fp16.caffemodel'

导入需要的包。

定义模型的路径。

net = cv2.dnn.readNetFromCaffe(prototxt_path, model_path)

sp = dlib.shape_predictor(predictor_path) #关键点检测

facerec = dlib.face_recognition_model_v1(face_rec_model_path)# 编码

初始化人脸检测模型、关键点检测模型、人脸特征提取模型。

image_path='train_images/11.jpg'

image = cv2.imread(image_path)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

(h, w) = image.shape[:2]

'''

理解image.shape[:2]与image.shape[:3]

[0:2]是切片的意思，.shape 应当是OpenCV模块中处理图片的，是图片的一个属性，这个属性是个列表 ，然后对这个列表切片操作。

例子：h,w = img.shape[:2] 获取彩色图片的高、宽，并且赋值给h和w；如果是h,w,v = img.shape[:3] 获取彩色图片的高、宽、通道，并赋值给h w v

'''

blob = cv2.dnn.blobFromImage(cv2.resize(image, (300, 300)), 1.0,

                             (300, 300), (104.0, 177.0, 123.0))

net.setInput(blob)

detections = net.forward()

startX, startY, endX, endY = 0, 0, 0, 0

for i in range(0, detections.shape[2]):

    # extract the confidence (i.e., probability) associated with the

    # prediction

    confidence = detections[0, 0, i, 2]

    # filter out weak detections by ensuring the `confidence` is

    # greater than the minimum confidence

    if confidence > 0.5:

        # compute the (x, y)-coordinates of the bounding box for the

        # object

        box = detections[0, 0, i, 3:7] * numpy.array([w, h, w, h])

        (startX, startY, endX, endY) = box.astype("int")

        break

rect = dlib.rectangle(startX, startY, endX, endY)

这部分的代码主要是人脸检测逻辑。

读取图片，并将其改为RGB格式。

获取图片的大小。

初始化blob。

net.forward()计算人脸的位置。

遍历检测结果

如果置信度大于0.5，则认为是合格的人脸。

计算出人脸的坐标。

将坐标转为dlib.rectangle对象。

shape = sp(image, rect)

print(shape)

# 提取特征

face_descriptor = facerec.compute_face_descriptor(image, shape)#获取到128位的编码

v = numpy.array(face_descriptor)

print(v)

计算人脸的关键点。

提取人脸的特征。

使用感受：使用深度学习模型提取人脸特征，无论速度还是准确率都有很大的提高，即使很模糊的图像依然能检测到。

3.使用insightface提取人脸特征

InsightFace 是一个开源的 2D&3D 深度人脸分析工具箱，其中高效地实现了丰富多样的人脸识别、人脸检测和人脸对齐算法，并且针对训练和部署进行了优化，在多项算法测评、比赛获得优胜。

安装InsightFace

注意：onnxruntime安装1.9以下的版本。

pip install insightface

pip install onnxruntime-gpu==1.9.0 

提取特征

新建face_embedding3.py 插入代码：

import insightface

import cv2

model = insightface.app.FaceAnalysis()

model.prepare(ctx_id=0, det_thresh=0.45)

face_img = cv2.imread('train_images/11.jpg')

res = model.get(face_img)

print('embedding: ', res[0].embedding)  

初始化FaceAnalysis()模型。

设置置信度位0.45。

读取图片

使用模型预测。

打印人脸特征res[0].embedding。

除了能人脸特征外，还有一些其他的属性，比如：bbox、kps、landmark_3d_68、landmark_2d_106、age、gender 。可以通过res[0].keys()查看。

使用感受：速度比较慢，精度还行。

到此这篇关于Python中提取人脸特征的三种方法详解的文章就介绍到这了,更多相关Python提取人脸特征内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

OpenVINO

OpenVINO，全称为Open Visual Inference & Neural Network Optimization，是一个由英特尔开发的开源工具包。它的目标是帮助开发者在各种硬件设备上优化和加速深度学习模型的推理（inference）过程。

首先，让我们来说说深度学习模型的推理过程。当你训练一个深度学习模型后，你希望将其部署到实际应用中进行推理，也就是输入一些数据，让模型给出预测结果。这个过程通常需要在计算机上进行大量的计算，而且对于复杂的模型来说可能需要很长的时间。

OpenVINO的作用就是优化这个推理过程，使得它更高效、更快速。它通过使用硬件加速（如英特尔的CPU、GPU、VPU等）以及优化的算法来实现这一点。具体来说，OpenVINO可以将深度学习模型转换成它自己的中间表示形式（Intermediate Representation），这种表示形式可以在不同的硬件上运行，并且可以利用硬件的特定功能来提高性能。

使用OpenVINO，你可以将训练好的深度学习模型转换为OpenVINO的中间表示形式，然后在目标设备上加载并运行它。OpenVINO会自动优化模型的推理过程，以便最大限度地利用硬件资源。这样一来，你可以在各种设备上运行你的模型，包括边缘设备（如嵌入式系统、物联网设备）和云服务器，而不需要手动调整代码或重新训练模型。

总结一下，OpenVINO是一个面向开发者的工具包，它可以帮助你优化和加速深度学习模型的推理过程。它使用硬件加速和优化算法，将模型转换为中间表示形式，并自动优化推理过程以提高性能。这样，你就可以更轻松地在各种设备上部署和运行你的模型。

例子代码

import cv2

import matplotlib.pyplot as plt

import numpy as np

from openvino.runtime import Core

# Load the Model

ie = Core()

model = ie.read_model(model="model/v3-small_224_1.0_float.xml")

compiled_model = ie.compile_model(model=model, device_name="CPU")

output_layer = compiled_model.output(0)

# Load an Image

# The MobileNet model expects images in RGB format.

image = cv2.cvtColor(cv2.imread(filename="../data/image/coco.jpg"), code=cv2.COLOR_BGR2RGB)

# Resize to MobileNet image shape.

input_image = cv2.resize(src=image, dsize=(224, 224))

# Reshape to model input shape.

input_image = np.expand_dims(input_image, 0)

plt.imshow(image);

# Do Inference

result_infer = compiled_model([input_image])[output_layer]

result_index = np.argmax(result_infer)

# Convert the inference result to a class name.

imagenet_classes = open("../data/datasets/imagenet/imagenet_2012.txt").read().splitlines()

# The model description states that for this model, class 0 is a background.

# Therefore, a background must be added at the beginning of imagenet_classes.

imagenet_classes = ['background'] + imagenet_classes

imagenet_classes[result_index]

Moviepy和OpenCV-Python进行音视频剪辑处理

pip install moviepy opencv-python

点击查看moviepy中文手册

1、moviepy简介

moviepy是python中强大的音视频处理库，应用moviepy进行处理具有非常广的自由度，因此能够满足我们进行音视频数据处理分析的八九成需求。

moviepy安装：

pip install moviepy

2、movie功能点

视频读取

from moviepy.editor import *

import time

clip = VideoFileClip('./video.mp4')

视频信息

from moviepy.editor import *

video = VideoFileClip('video.mp4')

print(video.size) # 获取分辨率

print(video.duration) #获取总时长

视频剪切

from moviepy.editor import *

import time

clip = VideoFileClip('./video.mp4')

clip.subclip(10, 20) #剪切10s-20s

clip.write_videofile('new_video.mp4') # 保存视频

视频倍速

from moviepy.editor import *

clip = VideoFileClip('./video.mp4')

video_1 = clip.speedx(2)

video_1.write_videofile('s2.mp4')

视频取帧

from moviepy.editor import *

video = VideoFileClip(video_path)

video.save_frame("frame_2.png",t=2) # 保存第2秒的第一帧

画幅裁切

from moviepy.editor import *

import time

clip = VideoFileClip('./video.mp4')

clip.crop(x1=0,y1=100,x2=400,y2=600) #画幅裁切

clip.write_videofile('new_video.mp4')

GIF保存

from moviepy.editor import *

clip = VideoFileClip('./video.mp4').subclip(10, 20)

# clip.write_gif('demo.gif',fps=15) # 生成之后的文件大

clip.write_gif('demo.gif',fps=5) # 生成之后的文件小

音频提取

from moviepy.editor import *

videoclip_a = VideoFileClip("video.mp4")

audio_a = videoclip_a.audio #提取视频音频文件

音频设置

from moviepy.editor import *

videoclip_a = VideoFileClip("1644974996.mp4")

videoclip_b = VideoFileClip("1644974998.mp4")

audio_a = videoclip_a.audio

videoclip_c = videoclip_b.set_audio(audio_a) # 音频设置

videoclip_c.write_videofile("videoclip_c.mp4")

音频剔除

from moviepy.editor import *

video = VideoFileClip('video.mp4')

video = video.without_audio()

video.write_videofile('cc.mp4')

Python关于人脸

要使用Python和OpenCV提取人脸特征，你可以使用dlib库来实现。下面是一个示例代码：

下载人脸模型

http://dlib.net/files/

另一个易用包:pip install face_recognition

face_recognition基于dlib

import dlib

import cv2

# 初始化人脸检测器和预测器

detector = dlib.get_frontal_face_detector()

predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')

# 加载图像

image = cv2.imread('image.jpg')

# 将图像转换为灰度图像

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 使用人脸检测器检测人脸

faces = detector(gray)

# 遍历检测到的人脸

for face in faces:

    # 使用预测器提取人脸特征

    landmarks = predictor(gray, face)

    # 遍历人脸特征点并绘制

    for n in range(0, 68):

        x = landmarks.part(n).x

        y = landmarks.part(n).y

        cv2.circle(image, (x, y), 2, (0, 255, 0), -1)

# 显示带有人脸特征点的图像

cv2.imshow('Facial Landmarks', image)

cv2.waitKey(0)

cv2.destroyAllWindows()

在上述代码中，我们首先导入了所需的库，然后初始化了人脸检测器和预测器。接下来，我们加载图像，并将其转换为灰度图像。然后，使用人脸检测器检测图像中的人脸，并使用预测器提取人脸特征。最后，我们遍历特征点并在图像上绘制它们。最后，显示带有人脸特征点的图像。

请注意，上述代码中使用的人脸特征点预测器文件"shape_predictor_68_face_landmarks.dat"可以在dlib的官方网站上下载。确保将该文件放在与代码文件相同的目录中，或者根据你的文件路径进行适当的更改。

此外，确保已经安装了所需的库（dlib和opencv-python），你可以使用pip命令进行安装：

pip install dlib opencv-python

要通过OpenCV比较两张人脸图像是否属于同一个人，可以使用人脸识别算法。以下是使用OpenCV和dlib库实现的一个简单示例：

import cv2

import dlib

# 加载预训练的人脸检测器和人脸识别模型

detector = dlib.get_frontal_face_detector()

face_recognizer = dlib.face_recognition_model_v1('dlib_face_recognition_resnet_model_v1.dat')

# 加载图像1和图像2

image1 = cv2.imread('image1.jpg')

image2 = cv2.imread('image2.jpg')

# 将图像1和图像2转换为灰度图像

gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)

gray2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)

# 使用人脸检测器检测图像1和图像2中的人脸

faces1 = detector(gray1)

faces2 = detector(gray2)

# 确保每张图像中都只有一个人脸

if len(faces1) != 1 or len(faces2) != 1:

    print("图像中必须只有一个人脸")

else:

    # 提取图像1和图像2中的人脸特征向量

    face_descriptor1 = face_recognizer.compute_face_descriptor(image1, faces1[0])

    face_descriptor2 = face_recognizer.compute_face_descriptor(image2, faces2[0])

    # 计算人脸特征向量之间的欧氏距离

    distance = dlib.distance(face_descriptor1, face_descriptor2)

    # 根据阈值判断是否为同一个人

    threshold = 0.6  # 调整阈值以适应你的需求

    if distance < threshold:

        print("是同一个人")

    else:

        print("不是同一个人")

在上述代码中，我们首先导入所需的库，然后加载预训练的人脸检测器和人脸识别模型。接下来，我们加载图像1和图像2，并将它们转换为灰度图像。然后，使用人脸检测器检测图像中的人脸，并确保每张图像中只有一个人脸。接下来，使用人脸识别模型提取人脸特征向量，并计算两个人脸特征向量之间的欧氏距离。最后，根据设定的阈值判断两个人脸是否属于同一个人。

请注意，上述示例中使用的人脸识别模型文件"dlib_face_recognition_resnet_model_v1.dat"也可以在dlib的官方网站上下载。确保将该文件放在与代码文件相同的目录中，或者根据你的文件路径进行适当的更改。

此外，确保已经安装了所需的库（dlib和opencv-python），你可以使用pip命令进行安装：

pip install dlib opencv-python

这个示例只是一个基本的人脸比较方法，实际的人脸识别系统可能会使用更复杂的算法和模型来实现更准确的识别。

要通过OpenCV实现换脸，你可以使用人脸关键点检测和图像变换的技术。以下是一个简单的示例代码，演示如何在两张图像之间进行换脸：

import cv2

import dlib

# 加载预训练的人脸检测器和关键点检测器

detector = dlib.get_frontal_face_detector()

predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')

# 加载图像1和图像2

image1 = cv2.imread('image1.jpg')

image2 = cv2.imread('image2.jpg')

# 将图像1和图像2转换为灰度图像

gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)

gray2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)

# 使用人脸检测器检测图像1和图像2中的人脸

faces1 = detector(gray1)

faces2 = detector(gray2)

# 确保图像1和图像2都有且只有一个人脸

if len(faces1) == 1 and len(faces2) == 1:

    # 提取图像1和图像2中的人脸关键点

    landmarks1 = predictor(gray1, faces1[0])

    landmarks2 = predictor(gray2, faces2[0])

    # 提取图像1和图像2中的人脸区域

    face1 = cv2.convexHull(cv2.face.StandardCollector_create())

    face2 = cv2.convexHull(cv2.face.StandardCollector_create())

    for i in range(0, 68):

        x1 = landmarks1.part(i).x

        y1 = landmarks1.part(i).y

        x2 = landmarks2.part(i).x

        y2 = landmarks2.part(i).y

        face1.append((x1, y1))

        face2.append((x2, y2))

    # 进行仿射变换

    mask = np.zeros_like(image2)

    mask = cv2.fillConvexPoly(mask, face2, (255, 255, 255), 16, 0)

    r = cv2.boundingRect(face2)

    center = ((r[0] + int(r[2] / 2), r[1] + int(r[3] / 2)))

    output = cv2.seamlessClone(image2, image1, mask, center, cv2.NORMAL_CLONE)

    # 显示换脸结果

    cv2.imshow('Face Swapped', output)

    cv2.waitKey(0)

    cv2.destroyAllWindows()

else:

    print("图像中必须只有一个人脸")

在上述代码中，我们首先导入所需的库，然后加载预训练的人脸检测器和关键点检测器。接下来，我们加载图像1和图像2，并将它们转换为灰度图像。然后，使用人脸检测器检测图像中的人脸，并确保每张图像中只有一个人脸。接下来，使用关键点检测器提取人脸关键点，并提取人脸区域。然后，使用仿射变换将图像2的人脸区域变换到图像1上，并使用融合技术进行无缝融合。最后，显示换脸结果。

请注意，上述示例中使用的人脸关键点检测器文件"shape_predictor_68_face_landmarks.dat"可以在dlib的官方网站上下载。确保将该文件放在与代码文件相同的目录中，或者根据你的文件路径进行适当的更改。

此外，确保已经安装了所需的库（dlib和opencv-python），你可以使用pip命令进行安装：

pip install dlib opencv-python

这个示例只是一个基本的换脸方法，实际的换脸应用会更复杂，可能需要使用深度学习模型来实现更好的效果。请注意，使用上述示例代码进行换脸操作可能会产生一些不理想的效果，因为它仅使用了基于仿射变换和融合技术的简单方法。对于更高质量的换脸效果，通常需要使用更复杂的算法和技术，例如基于深度学习的方法（如人脸关键点检测、面部对齐和生成对抗网络）。

如果你希望获得更好的换脸效果，可以考虑使用现有的开源库和工具，例如DeepFaceLab、OpenFaceSwap和FOMM等。这些工具通常使用深度学习技术，并提供了更高级的功能和更好的结果。

PaddleOCR 简单 demo 入门（比EasyOCR效果好可比商业软件)

点击查看原文

PaddleOCR开源地址：https://github.com/PaddlePaddle/PaddleOCR

实际我们常用的是PP-OCR,点击了解

1. 配置环境

安装依赖库：CPU版本的paddlepaddle

pip install paddlepaddle

安装PaddleOCR

pip install “paddleocr>=2.0.1”执行有错时候可使用下面命令行安装

pip install "paddleocr>=2.0.1" --upgrade "PyMuPDF>=1.21.0"

2. 下载预训练模型

点击进入模型下载地址，在使用时模型时如发现没有应该是自动下载的

PaddleOCR 分为 Detection（文本检测）、 Direction classifier（方向分类器）和Recognition（文本识别）三部分，因此需要三个模型。

文本检测：定位出图像中的文字区域

方向分类器：将各种方向的文本框通过仿射变换变为水平方向，文本方向分类器用来判断文本是不是上下颠倒的

文本识别：文本行图像解码为文本

官方代码仓中有模型下载地址：

其中文本检测有三个模型，分别是 MobileNetV3、ResNet18_vd 和 ResNet50，其中最常使用的是MobileNetV3 模型，整体比较小，适合应用于手机端。文本识别只有一个MobileNetV3预训练模型。方向分类器使用默认的模型。

这里使用中英文通用检测模型 PP-OCR (143.4M)，将其三个子模型（tar压缩包）下载下来并解压，PaddleOCR加载的model是解压后的文件夹，而不是压缩包。

from paddleocr import PaddleOCR, draw_ocr

from PIL import Image

# load model

# Paddleocr目前支持中英文、英文、法语、德语、韩语、日语，可以通过修改 lang参数进行切换

# lang参数依次为`ch`, `en`, `french`, `german`, `korean`, `japan`

ocr = PaddleOCR(lang="ch",

                use_gpu=False,

                det_model_dir="../paddleORC_model/ch_ppocr_server_v2.0_det_infer/",

                cls_model_dir="ch_ppocr_mobile_v2.0_cls_infer/",

                rec_model_dir="ch_ppocr_server_v2.0_rec_infer/")

# load dataset

img_path = 'test.jpg'

resul = ocr.ocr(img_path)

for line in result:

    print(line)

# 注：

# result是一个list，每个item包含了文本框，文字和识别置信度

# line的格式为：

# [[[3.0, 149.0], [43.0, 149.0], [43.0, 163.0], [3.0, 163.0]], ('人心安', 0.6762619018554688)]

# 文字框 boxes = line[0]，包含文字框的四个角的(x,y)坐标

# 文字 txts = line[1][0]

# 识别置信度 scores = line[1][1]

# visual

image = Image.open(img_path).convert('RGB')

boxes = [line[0] for line in result]

txts = [line[1][0] for line in result]

scores = [line[1][1] for line in result]

im_show = draw_ocr(image, boxes, txts, scores)

im_show = Image.fromarray(im_show)

im_show.save('result.jpg')

moviepy视频编辑组件

点击查看手册

Pyppeteer 就是 Puppeteer 的 Python 版使用

点击查看原文

安装

Pyppeteer 的安装与 Playwright 相似。

Pyppeteer 采用了async机制，所以必须使用Python 3.5及以上版本。

首先使用 pip 安装 Pyppeteer 包：

pip install pyppeteer

安装完成后可以选择执行 pyppeteer-install 下载用于 pyppeteer 的 chromium，这一步可以省略，因为第一次运行 Pyppeteer 时会自动检测是否安装了 chromium 浏览器，如果没有安装程序会自动进行安装配置。

使用

前两期文章中介绍到了 Selenium 与 Playwright 库的使用方法，因为自动化库的使用大同小异，所以这里只介绍 Pyppeteer 中比较特殊的方法

Pyppeteer 基于异步实现，所以它支持异步操作。

启动

以百度热搜榜为例：

import asyncio

from pyppeteer import launch

async def main():

    browser = await launch(headless=False)

    page = await browser.newPage()

    await page.goto('https://top.baidu.com/board?tab=realtime')

    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

示例代码中使用 launch 方法创建了一个浏览器对象 browser ，设置了 headless=False 来关闭无头模式，这一行代码的作用相当于启动一个浏览器，await的作用就是等待浏览器启动完毕。

创建完浏览器后，使用到了 newPage 方法，创建了一个 Page 对象，这一步相当于打开了一个新的标签页，通过 await 等待标签页创建完毕，然后调用 goto 方法打开目标网址，最后使用 close 方法关闭浏览器。

launch详解

launch 方法用于启动浏览器进程并返回浏览器实例，它包含了多个参数：

参数 描述

ignoreHTTPSErrors（bool） 是否忽略HTTPS错误。默认为 False

headless（bool） 是否开启无头模式。默认为True

executablePath （str） 可执行文件的路径，设置该参数可以指定已有的 Chrome 或 Chromium 浏览器。

slowMo （int | float） 传入指定时间（毫秒），用于延缓 Pyppeteer 的一些模拟操作。

args （List [str]） 传递给浏览器的额外参数。

dumpio（bool） 是否将 Pyppeteer 的输出信息传给 process.stdout和process.stderr。默认为False。

userDataDir （str） 用户数据文件夹。

env（dict） 浏览器环境。默认与 Python 进程相同。

devtools（bool） 是否为每个标签页打开 DevTools 面板，默认为False,如果该参数为 True，则 headless 会被强制设置为 False。

logLevel（int | str） 日志级别。默认值与根记录器相同。

autoClose（bool） 脚本完成时自动关闭浏览器进程。默认为True。

loop（asyncio.AbstractEventLoop） 事件循环。

禁用提示条

与 Selenium 一样，Pyppeteer 控制浏览器时会提示 Chrome 正受到自动测试软件的控制。可以通过 设置 launch 方法中的 args 参数来关闭提示。

browser = await launch(headless=False, args=['--disable-infobars'])

用户数据持久化

自动化工具如 Selenium 、Playwright 都有一个特征，就是每一次运行的时候创建的都是一个全新的浏览器，它不会记录用户之前的行为。如第一次运行时我登录了某个网站，而第二次运行时再次进入该网站时依旧需要登录。这是因为自动化工具没有记录用户行为信息。Pyppeteer 中，如果需要记录用户的行为信息，可以通过设置 launch 方法中的 userDataDir 方法来实现。

browser = await launch(headless=False, args=['--disable-infobars'], userDataDir='./userdata')

设置了用户数据文件夹后运行代码，会生成一个 userdata 文件夹，其中就存储着用户上次控制浏览器时记录的一些行为数据。

执行 JS 语句

import asyncio

from pyppeteer import launch

async def main():

    browser = await launch(headless=False)

    page = await browser.newPage()

    await page.goto('https://top.baidu.com/board?tab=realtime')

    dimensions = await page.evaluate('''() => {

           return {

               width: document.documentElement.clientWidth,

               height: document.documentElement.clientHeight,

               deviceScaleFactor: window.devicePixelRatio,

           }

       }''')

    print(dimensions)

    await browser.close()

# {'width': 783, 'height': 583, 'deviceScaleFactor': 1}

通过调用 Page 对象下的 evaluate 方法可以执行一段 JS 语句。

反检测

Pyppeteer 的反检测方式与 Selenium 和 Playwright 有些区别，但是思想是一样的。

首先需要安装 pyppeteer_stealth 库，它的作用就是用来隐藏特征。

pip install pyppeteer_stealth

以无头模式为例：

import asyncio

from pyppeteer import launch

from pyppeteer_stealth import stealth

async def main():

    browser = await launch()

    page = await browser.newPage()

    # 隐藏特征

    await stealth(page)

    await page.goto('https://bot.sannysoft.com/')

    await page.screenshot(path='page.png')

    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

等待

waitForSelector ：等待符合条件的节点加载完成

waitForFunction ：等待某个 JavaScript 方法执行完毕或返回结果

waitForRequest ：等待某个特定的请求发出

waitForResponse ：等待某个特定请求对应的响应

waitForNavigation ：等待页面跳转，如果页面加载失败则抛出异常

waitFor ：通用等待

waitForXpath ：等待符合 Xpath 的节点加载出来

选择器

Pyppeteer 提供了一些比较有意思的选择器方法。

J() ：返回匹配到的第一个节点，等同于 querySelector 方法。

JJ() ：返回匹配到的所有节点，等同于 querySelectorAll 方法。

JJeval() ：执行 JS 脚本并返回一个 JSON 对象，等同于 querySelectorAllEval 方法。

Jeval() ：执行 JS 脚本并返回执行结果，等同于 querySelectorEval 方法。

Jx() ：通过 Xpath 匹配符合条件的内容，等同于 xpath 方法。

import asyncio

from pyppeteer import launch

async def main():

    browser = await launch(headless=False)

    page = await browser.newPage()

    await page.goto('https://top.baidu.com/board?tab=realtime')

    # 等待元素加载

    await page.waitForXPath('//div[@class="c-single-text-ellipsis"]')

    element_j = await page.J('.c-single-text-ellipsis')

    element_jj = await page.JJ('.c-single-text-ellipsis')

    # 打印元素的文本信息

    print(await (await element_j.getProperty('textContent')).jsonValue())

    for element in element_jj:

        # 打印元素的文本信息

        print(await (await element.getProperty('textContent')).jsonValue())

    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

"""

运行结果：

青年强则国家强 

青年强则国家强 

乌代表举自家国旗挑衅暴揍俄代表 

英王加冕礼彩排：黄金钻石马车亮眼 

平凡岗位上的奋斗故事 

俞敏洪建议24节气都放假 

7人吃自助4小时炫300多个螃蟹 

  .

  .

  .

总结

Pyppeteer 类似于轻量级的 Playwright ，它使用起来更加简单，且 Pyppeteer 与 Playwright 一样都支持异步，性能方面也比较强。缺点就是它基于 Chromium 内核，资源消耗比较大，不支持其它浏览器，而且 Pyppeteer 的作者近年来都没对该库进行维护，导致存在一些 bug。

Pyppeteer 使用Jquery

import asyncio

from pyppeteer import launch

async def main():

    browser = await launch()

    page = await browser.newPage()

    # 添加 jQuery

    await page.evaluate('''() => {

        const script = document.createElement('script');

        script.src = 'https://code.jquery.com/jquery-3.1.1.min.js';

        script.onload = function() {

            console.log('jQuery loaded');

        };

        document.head.appendChild(script);

    }''')

    await page.evaluate('''() => {

        // 使用 jQuery

        console.log($('title').text());

    }''')

    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

如果你不想在每次使用 jQuery 时都要加载它，你可以在页面上直接插入 jQuery，然后将其保存在页面上，这样在后续的交互中，你可以直接使用 jQuery，而不用每次都加载。

import asyncio

from pyppeteer import launch

async def main():

    # 启动浏览器

    browser = await launch()

    page = await browser.newPage()

    # 导航到页面

    await page.goto('https://example.com')

    # 注入 jQuery

    await page.addScriptTag({'url': 'https://code.jquery.com/jquery-3.6.0.min.js'})

    # 等待 jQuery 加载完成

    await page.waitForFunction('typeof jQuery !== "undefined"')

    # 使用 jQuery 进行操作

    await page.evaluate('''

        // 使用 jQuery 选择元素并执行操作

        $('h1').text('Hello, Pyppeteer!');

        $('p').css('color', 'red');

    ''')

    # 截图以查看操作结果

    await page.screenshot({'path': 'example.png'})

    # 关闭浏览器

    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

下面是两个示例，分别演示了如何使用 Pyppeteer 保存登录状态和如何使用保存的登录状态。

保存登录状态的示例：

import asyncio

from pyppeteer import launch

async def save_login_state():

    browser = await launch(headless=False)  # 可见浏览器，方便演示

    page = await browser.newPage()

    await page.goto('https://example.com/login')

    # 在这里执行登录操作，并等待登录成功后的页面加载完成

    # 保存登录状态（cookies）

    cookies = await page.cookies()

    # 将 cookies 保存到文件或数据库中

    await browser.close()

asyncio.get_event_loop().run_until_complete(save_login_state())

在上述示例中，我们使用 page.cookies() 方法获取登录后的页面的 cookies，并将其保存到变量 cookies 中。你可以根据需要将 cookies 保存到文件或数据库中，以便后续使用。

使用登录状态的示例：

import asyncio

from pyppeteer import launch

async def load_login_state():

    browser = await launch(headless=False)  # 可见浏览器，方便演示

    page = await browser.newPage()

    # 加载之前保存的登录状态（cookies）

    saved_cookies = load_cookies_from_storage()  # 从文件或数据库中加载保存的 cookies

    await page.setCookie(*saved_cookies)

    # 使用登录状态浏览其他页面

    await page.goto('https://example.com/profile')  # 这里可以是需要登录才能访问的页面

    # 在这里执行需要登录状态的操作

    # ...

    # 保存更新后的登录状态（可选）

    cookies = await page.cookies()

    # 将 cookies 保存到文件或数据库中

    await browser.close()

asyncio.get_event_loop().run_until_complete(load_login_state())

在上述示例中，我们使用 page.setCookie() 方法将之前保存的登录状态（cookies）加载到新的页面中。然后，我们可以使用这个已登录的页面执行需要登录状态的操作。如果有必要，你还可以使用 page.cookies() 方法获取更新后的 cookies，并将其保存到文件或数据库中。

请注意，示例中的 load_cookies_from_storage() 方法是一个占位方法，你需要根据实际情况实现加载保存的 cookies 的逻辑。

这些示例演示了如何使用 Pyppeteer 保存和使用登录状态。你可以根据具体的需求和网站的登录机制进行相应的调整和扩展。

在 Pyppeteer 中，你可以通过监听 request 事件来拦截和处理 AJAX 请求。下面是一个示例代码，演示了如何拦截 AJAX 请求并对其进行处理：

import asyncio

from pyppeteer import launch

async def intercept_ajax_requests():

    browser = await launch(headless=False)  # 可见浏览器，方便演示

    page = await browser.newPage()

    # 监听请求事件

    def request_interceptor(request):

        if request.resourceType == 'xhr':

            # 输出请求的 URL

            print(f'Intercepted AJAX Request: {request.url}')

            # 拦截并修改请求的数据，这里可以根据需求进行处理

            # 例如，修改请求的 Headers 或 PostData

            request.continue_()

    await page.setRequestInterception(True)

    page.on('request', request_interceptor)

    await page.goto('https://example.com')

    # 在页面中触发 AJAX 请求

    await page.evaluate("fetch('https://api.example.com/data', { method: 'GET' })")

    # 等待一段时间，以便观察和处理拦截的 AJAX 请求

    await browser.close()

asyncio.get_event_loop().run_until_complete(intercept_ajax_requests())

在上述示例中，我们使用 setRequestInterception(True) 方法启用请求拦截，并通过定义 request_interceptor 函数来处理拦截的请求。在 request_interceptor 函数中，我们判断请求的 resourceType 是否为 'xhr'，即 AJAX 请求。如果是 AJAX 请求，我们输出请求的 URL，并可以根据需求拦截并修改请求的数据，然后使用 request.continue_() 方法继续请求。

对于非 AJAX 请求，你可以根据需要选择继续或中止请求，并使用 request.continue_() 或 request.abort() 方法进行相应的操作。

请注意，拦截 AJAX 请求可能会对页面的功能和性能产生影响，因此在使用时需要谨慎考虑。确保你的拦截逻辑正确处理请求，并避免对页面的正常运行造成不必要的干扰。

face_recognition使用Python和命令行工具提取、识别、操作人脸。

点击进入软件页

本项目的人脸识别是基于业内领先的C++开源库 dlib中的深度学习模型，用Labeled Faces in the Wild人脸数据集进行测试，有高达99.38%的准确率。但对小孩和亚洲人脸的识别准确率尚待提升。

MoneyPrinterTurbo利用AI大模型，一键生成高清短视频

点击进入项目

由于该项目的 部署 和 使用，对于一些小白用户来说，还是 有一定的门槛，在此特别感谢

录咖（AI智能 多媒体服务平台） 网站基于该项目，提供的免费AI视频生成器服务，可以不用部署，直接在线使用，非常方便。

中文版：https://reccloud.cn

英文版：https://reccloud.com

视频教程

完整的使用演示：https://v.douyin.com/iFhnwsKY/

如何在Windows上部署：https://v.douyin.com/iFyjoW3M

前提

尽量不要使用 中文路径，避免出现一些无法预料的问题

请确保你的 网络 是正常的，即可以正常访问境外网站

① 安装好 ImageMagick

Windows:

下载 https://imagemagick.org/archive/binaries/ImageMagick-7.1.1-29-Q16-x64-static.exe

安装下载好的 ImageMagick，注意不要修改安装路径

② 修改配置文件

将 config.example.toml 文件复制一份，命名为 config.toml

按照 config.toml 文件中的说明，配置好 pexels_api_keys 和 llm_provider，并根据 llm_provider 对应的服务商，配置相关的 API Key

如果是Windows系统，imagemagick_path 为你的实际安装路径（如果安装的时候没有修改路径，直接取消注释即可）

③ 配置大模型(LLM)

如果要使用 GPT-4.0 或 GPT-3.5，需要有 OpenAI 的 API Key，如果没有，可以将 llm_provider 设置为 g4f ( 一个免费使用GPT的开源库 https://github.com/xtekky/gpt4free)

或者可以使用到 月之暗面 申请。注册就送 15元体验金，可以对话1500次左右。然后设置 llm_provider="moonshot" 和 moonshot_api_key 。感谢 @jerryblues 的建议

启动Web界面 🌐

注意需要到 MoneyPrinterTurbo 项目 根目录 下执行以下命令

Windows

conda activate MoneyPrinterTurbo

webui.bat

MacOS or Linux

conda activate MoneyPrinterTurbo

sh webui.sh

启动后，会自动打开浏览器

启动API服务 🚀

python main.py

启动后，可以查看 API文档 http://127.0.0.1:8080/docs 直接在线调试接口，快速体验。

Selenium WebDrive

开源的可视化爬虫EasySpider

点击进入开源地址

软件地址

edge-tts调用微软的在线TTS合成

开源地址

To install it, run the following command:

$ pip install edge-tts

If you only want to use the edge-tts and edge-playback commands, it would be better to use pipx:

$ pipx install edge-tts

edge-tts --text "hello world" --write-media hello.mp3

立即播放

edge-playback --text "Hello, world!"

注意以上需要安装mpv命令行播放器。所有命令也都edge-tts可以工作。edge-playback

支持的语言和音色

edge-tts支持英语、汉语、日语、韩语、法语等40多种语言，共300多种可选声音，执行以下命令查询：

edge-tts --list-voices

查询结果中的Gender为声音的性别，Name为声音的名字，如zh-CN-YunjianNeural，其中zh表示语言，CN表示国家或地区，可以根据需求选择不同的声音。

使用--voice参数来指定声音名称，下面我使用zh-CN-YunyangNeural声音来合成一个中文音频。

edge-tts --voice zh-CN-YunyangNeural --text "大家好，欢迎关注语音之家，语音之家是一个助理AI语音开发者的社区。" --write-media hello_in_cn.mp3

调整语速、音量和音调

可以对生成的语音进行细微修改。

$ edge-tts --rate=-50% --text "Hello, world!" --write-media hello_with_rate_halved.mp3 --write-subtitles hello_with_rate_halved.vtt

$ edge-tts --volume=-50% --text "Hello, world!" --write-media hello_with_volume_halved.mp3 --write-subtitles hello_with_volume_halved.vtt

$ edge-tts --pitch=-50Hz --text "Hello, world!" --write-media hello_with_pitch_halved.mp3 --write-subtitles hello_with_pitch_halved.vtt

此外，必须使用 --rate=-50% 而不是 --rate -50%（注意等号的缺失），否则 -50% 将被解释为另一个参数。

使用代码转换

上面都是用命令转换，我们也可以写代码调用，开发http接口来提供语音合成服务。

以下是一个代码示例，将代码保存到一个文件中，如tts.py。

import asyncio

import edge_tts

TEXT = "大家好，欢迎关注语音之家，语音之家是一个助理AI语音开发者的社区。"

VOICE = "zh-CN-YunyangNeural"

OUTPUT_FILE = "d:/test.mp3"

async def amain() -> None:

    """Main function"""

    communicate = edge_tts.Communicate(TEXT, VOICE)

    await communicate.save(OUTPUT_FILE)

if __name__ == "__main__":

    loop = asyncio.get_event_loop_policy().get_event_loop()

    try:

        loop.run_until_complete(amain())

    finally:

        loop.close()

运行python tts.py，稍等即可在d盘生成合成后的音频test.mp3。

edge-playback 实际上是 edge-tts 的一个封装，用于播放生成的语音。它接受与 edge-tts 选项相同的参数。

原理非常简单，就是调用了微软的在线语音合成服务，看一下源码中的constants.py和communicate.py便可猜出大概，语音合成是用的websocket服务，获取声音列表是用的https接口，但是作者不知道这个TrustedClientToken是怎样得到的，也没有搜到官方的api文档，猜测是抓包edge浏览器中的朗读所选内容得到的，应该算是免费薅羊毛。

surya OCR库

点击查看源码

Surya 是一个文档 OCR 工具包，其功能如下：

支持 90 多种语言的 OCR，与云服务相比具有优势

任何语言的行级文本检测

布局分析（表格、图像、标题等检测）

阅读顺序检测

安装方式：

pip install surya-ocr

ddddocr带带弟弟 通用验证码识别OCR pypi版

点击查看源码

DdddOcr，通过大批量生成随机数据后进行深度网络训练，本身并非针对任何一家验证码厂商而制作，本库使用效果完全靠玄学，可能可以识别，可能不能识别。

DdddOcr、最简依赖的理念，尽量减少用户的配置和使用成本，希望给每一位测试者带来舒适的体验

安装

pip install ddddocr

基础ocr识别能力

主要用于识别单行文字，即文字部分占据图片的主体部分，例如常见的英数验证码等，本项目可以对中文、英文（随机大小写or通过设置结果范围圈定大小写）、数字以及部分特殊字符。

# example.py

import ddddocr

ocr = ddddocr.DdddOcr()

image = open("example.jpg", "rb").read()

result = ocr.classification(image)

print(result)

本库内置有两套ocr模型，默认情况下不会自动切换，需要在初始化ddddocr的时候通过参数进行切换

# example.py

import ddddocr

ocr = ddddocr.DdddOcr(beta=True)  # 切换为第二套ocr模型

image = open("example.jpg", "rb").read()

result = ocr.classification(image)

print(result)

提示 对于部分透明黑色png格式图片得识别支持: classification 方法 使用 png_fix 参数，默认为False

 ocr.classification(image, png_fix=True)

注意

之前发现很多人喜欢在每次ocr识别的时候都重新初始化ddddocr，即每次都执行ocr = ddddocr.DdddOcr()，这是错误的，通常来说只需要初始化一次即可，因为每次初始化和初始化后的第一次识别速度都非常慢

目标检测能力

主要用于快速检测出图像中可能的目标主体位置，由于被检测出的目标不一定为文字，所以本功能仅提供目标的bbox位置 （在⽬标检测⾥，我们通常使⽤bbox（bounding box，缩写是 bbox）来描述⽬标位置。bbox是⼀个矩形框，可以由矩形左上⻆的 x 和 y 轴坐标与右下⻆的 x 和 y 轴坐标确定）

如果使用过程中无需调用ocr功能，可以在初始化时通过传参ocr=False关闭ocr功能，开启目标检测需要传入参数det=True

import ddddocr

import cv2

det = ddddocr.DdddOcr(det=True)

with open("test.jpg", 'rb') as f:

    image = f.read()

bboxes = det.detection(image)

print(bboxes)

im = cv2.imread("test.jpg")

for bbox in bboxes:

    x1, y1, x2, y2 = bbox

    im = cv2.rectangle(im, (x1, y1), (x2, y2), color=(0, 0, 255), thickness=2)

cv2.imwrite("result.jpg", im)

滑块检测

本项目的滑块检测功能并非AI识别实现，均为opencv内置算法实现。可能对于截图党用户没那么友好~，如果使用过程中无需调用ocr功能或目标检测功能，可以在初始化时通过传参ocr=False关闭ocr功能或det=False来关闭目标检测功能

DrissionPage基于python的网页自动化工具

基于python的网页自动化工具。既能控制浏览器，也能收发数据包。可兼顾浏览器自动化的便利性和requests的高效率。功能强大，内置无数人性化设计和便捷功能。语法简洁而优雅，代码量少

点击进入源码页

点击查看中文说明文档

customtkinter基于tkinter的UI界面扩展

点击进入项目主页

Install the module with pip:

pip3 install customtkinter

To test customtkinter you can try this simple example with only a single button:

import customtkinter

customtkinter.set_appearance_mode("System")  # Modes: system (default), light, dark

customtkinter.set_default_color_theme("blue")  # Themes: blue (default), dark-blue, green

app = customtkinter.CTk()  # create CTk window like you do with the Tk window

app.geometry("400x240")

def button_function():

    print("button pressed")

# Use CTkButton instead of tkinter Button

button = customtkinter.CTkButton(master=app, text="CTkButton", command=button_function)

button.place(relx=0.5, rely=0.5, anchor=customtkinter.CENTER)

app.mainloop()

OCR开源引擎GOT-OCR

点击打开开源页

Install

0.Our environment is cuda11.8+torch2.0.1

1.Clone this repository and navigate to the GOT folder

git clone https://github.com/Ucas-HaoranWei/GOT-OCR2.0.git

cd 'the GOT folder'

2.Install Package

conda create -n got python=3.10 -y

conda activate got

pip install -e .

3.Install Flash-Attention

pip install ninja

pip install flash-attn --no-build-isolation

Demo

1.plain texts OCR:

python3 GOT/demo/run_ocr_2.0.py  --model-name  /GOT_weights/  --image-file  /an/image/file.png  --type ocr

2.format texts OCR:

python3 GOT/demo/run_ocr_2.0.py  --model-name  /GOT_weights/  --image-file  /an/image/file.png  --type format

3.fine-grained OCR:

python3 GOT/demo/run_ocr_2.0.py  --model-name  /GOT_weights/  --image-file  /an/image/file.png  --type format/ocr --box [x1,y1,x2,y2]

python3 GOT/demo/run_ocr_2.0.py  --model-name  /GOT_weights/  --image-file  /an/image/file.png  --type format/ocr --color red/green/blue

4.multi-crop OCR:

python3 GOT/demo/run_ocr_2.0_crop.py  --model-name  /GOT_weights/ --image-file  /an/image/file.png 

5.multi-page OCR (the image path contains multiple .png files):

python3 GOT/demo/run_ocr_2.0_crop.py  --model-name  /GOT_weights/ --image-file  /images/path/  --multi-page

6.render the formatted OCR results:

python3 GOT/demo/run_ocr_2.0.py  --model-name  /GOT_weights/  --image-file  /an/image/file.png  --type format --render

点击体验站点