junyi's blog

python_3_numpy模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

numpy库相关笔记

python3 numpy库详解

NumPy（Numerical Python）是Python中用于数值计算的核心库之一。它提供了强大的多维数组对象（例如ndarray）、用于数组操作的基本函数、线性代数运算、傅立叶变换以及随机数生成等功能。以下是NumPy库的一些详解：

多维数组对象（ndarray）：NumPy的核心是多维数组对象（ndarray），它是一个具有固定大小的同类数据项的数组。这意味着在ndarray中的所有元素必须是相同类型的，这使得NumPy非常高效。ndarray可以是一维、二维或更高维度的数组，它可以表示矩阵、张量等数据结构。
数组操作：NumPy提供了许多用于数组操作的函数，例如索引、切片、形状操作、数组拼接、数组分裂等。这些操作使得在NumPy中进行数组操作变得非常方便。
数学函数：NumPy包含了许多常用的数学函数，例如三角函数、指数函数、对数函数等。这些函数可以直接应用于ndarray对象，也可以用于逐元素操作。
线性代数运算：NumPy提供了一组用于执行线性代数运算的函数，例如矩阵乘法、求逆矩阵、求解线性方程组等。这些函数使得在NumPy中进行线性代数计算变得非常方便。
傅立叶变换：NumPy提供了用于执行傅立叶变换的函数，包括离散傅立叶变换（DFT）和傅立叶逆变换。这些函数对信号处理和频域分析非常有用。
随机数生成：NumPy包含了用于生成随机数的函数，例如生成服从特定分布的随机数、随机抽样等。这些函数可以用于模拟、蒙特卡罗方法等。

总之，NumPy是Python中用于数值计算的重要库，它提供了丰富的功能和高效的数组操作，使得在Python中进行科学计算变得非常方便和高效。

python3 numpy库常用技巧

NumPy库提供了许多强大的功能和技巧，使得在处理数值数据时更加高效和便捷。以下是一些常用的NumPy技巧：

创建数组：使用np.array()函数可以从Python列表或元组创建NumPy数组。另外，NumPy还提供了一些便捷的函数来创建特定类型的数组，如np.zeros()、np.ones()、np.arange()、np.linspace()等。

import numpy as np

# 从Python列表创建数组
arr = np.array([1, 2, 3, 4, 5])

# 创建全零数组
zeros_arr = np.zeros((3, 3))

# 创建全一数组
ones_arr = np.ones((2, 2))

# 创建等间隔数组
range_arr = np.arange(0, 10, 2)

# 创建线性空间数组
lin_space_arr = np.linspace(0, 1, 5)

数组操作：NumPy提供了许多用于数组操作的函数，如索引、切片、形状操作、数组拼接、数组分裂等。

import numpy as np

arr = np.array([[1, 2, 3],
                [4, 5, 6],
                [7, 8, 9]])

# 获取数组形状
shape = arr.shape

# 获取数组维度
dim = arr.ndim

# 获取数组元素类型
dtype = arr.dtype

# 获取数组元素数量
size = arr.size

# 数组切片
slice_arr = arr[0:2, 1:3]

# 数组拼接
concat_arr = np.concatenate((arr, arr), axis=0)

# 数组分裂
split_arr = np.split(arr, 3)

数学函数：NumPy提供了丰富的数学函数，如三角函数、指数函数、对数函数等。

import numpy as np

arr = np.array([0, np.pi/4, np.pi/2])

# 正弦函数
sin_arr = np.sin(arr)

# 指数函数
exp_arr = np.exp(arr)

# 自然对数函数
log_arr = np.log(arr)

线性代数运算：NumPy提供了一组用于执行线性代数运算的函数，如矩阵乘法、求逆矩阵、求解线性方程组等。

import numpy as np

A = np.array([[1, 2],
              [3, 4]])

B = np.array([[5, 6],
              [7, 8]])

# 矩阵乘法
mat_mul = np.dot(A, B)

# 求逆矩阵
inv_mat = np.linalg.inv(A)

# 求解线性方程组
x = np.linalg.solve(A, np.array([1, 2]))

这些只是NumPy库中一些常用的技巧和功能。NumPy还提供了许多其他功能，如统计函数、随机数生成、广播等，可以根据具体需求选择合适的函数和方法。

python3 numpy.transpose() 函数详解

numpy.transpose() 函数是 NumPy 库中用于对数组进行转置操作的函数。转置操作是将数组的维度重新排列，即将数组的行和列互换位置。

语法

1	numpy.transpose(a, axes=None)

a: 输入的数组。
axes: 指定转置操作后的维度顺序。如果不指定，则默认将数组的维度逆序。

返回值

返回转置后的数组。

示例

import numpy as np

arr = np.array([[1, 2, 3],
                [4, 5, 6]])

transposed_arr = np.transpose(arr)
print(transposed_arr)

输出：

1
2
3

[[1 4]
 [2 5]
 [3 6]]

在这个例子中，原始数组 arr 是一个 2x3 的数组。调用 np.transpose(arr) 后，得到一个 3x2 的数组，即将原数组的行和列互换了位置。

指定轴顺序

import numpy as np

arr = np.array([[1, 2, 3],
                [4, 5, 6]])

transposed_arr = np.transpose(arr, axes=(1, 0))
print(transposed_arr)

输出：

1
2
3

[[1 4]
 [2 5]
 [3 6]]

在这个示例中，我们通过 axes=(1, 0) 指定了转置后的轴顺序，结果与未指定时相同。

python_3_logging模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

logging模块笔记

python3 logging模块输出到文件并且输出到终端

在Python中，使用logging模块可以方便地进行日志记录。要将日志同时输出到文件和终端，你可以配置两个不同的Handler，一个用于文件输出，另一个用于控制台输出。以下是一个示例：

import logging

# 创建Logger对象
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

# 创建文件处理器，并设置日志级别为DEBUG
file_handler = logging.FileHandler('my_log_file.log')
file_handler.setLevel(logging.DEBUG)

# 创建控制台处理器，并设置日志级别为DEBUG
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)

# 创建日志格式器
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')

# 将格式器添加到处理器
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 将处理器添加到Logger对象
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# 记录一些日志信息
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

在上面的示例中，首先创建了一个Logger对象，然后创建了一个文件处理器(FileHandler)和一个控制台处理器(StreamHandler)。每个处理器都设置了日志级别，并将日志格式器添加到处理器中。最后，将处理器添加到Logger对象中。

在记录日志时，logger.debug(), logger.info(), logger.warning(), logger.error(), 和 logger.critical() 分别对应不同的日志级别。这些消息将根据其级别分别被发送到文件和终端。

请根据实际需求修改文件名、日志级别、日志格式等参数。

python3 logging模块详解

Python的logging模块是一个用于记录日志信息的标准库工具，它提供了强大的日志记录功能，允许你在应用程序中添加日志记录，以便于调试、监视和故障排除。以下是Python 3中logging模块的详解：

基本日志记录示例

首先，让我们看一个基本的logging模块的使用示例：

import logging

# 配置日志记录器
logging.basicConfig(filename='app.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# 记录日志信息
logging.debug('This is a debug message.')
logging.info('This is an info message.')
logging.warning('This is a warning message.')
logging.error('This is an error message.')
logging.critical('This is a critical message.')

上述代码中，我们首先通过basicConfig函数配置了一个日志记录器。配置中的参数包括：

filename：指定日志输出到的文件。
level：设置最低的日志级别，只有达到这个级别或更高级别的日志信息才会被记录。
format：指定日志记录的格式，可以包含时间、日志级别、消息等信息。

然后，我们使用logging模块的不同函数来记录不同级别的日志信息。日志级别从低到高依次为：DEBUG、INFO、WARNING、ERROR、CRITICAL。

日志处理器（Handlers）

logging模块允许你将日志信息发送到不同的目标，这些目标被称为“处理器（Handlers）”。常见的处理器包括：

StreamHandler： 将日志信息输出到控制台（标准输出流）。
FileHandler： 将日志信息写入文件。
RotatingFileHandler： 类似于FileHandler，但可以在日志文件达到一定大小时自动切分成多个文件。
SMTPHandler： 将日志信息通过邮件发送。
SocketHandler： 将日志信息发送到网络套接字。
SysLogHandler： 将日志信息发送到系统日志。

你可以根据需要选择一个或多个处理器，并将它们添加到日志记录器中，以便将日志信息发送到多个目标。例如：

import logging

# 创建日志记录器
logger = logging.getLogger('my_logger')

# 配置日志记录器
logger.setLevel(logging.DEBUG)

# 创建处理器并添加到日志记录器
console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('app.log')

# 配置处理器的日志级别和格式
console_handler.setLevel(logging.INFO)
file_handler.setLevel(logging.DEBUG)

formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

logger.addHandler(console_handler)
logger.addHandler(file_handler)

# 记录日志信息
logger.debug('This is a debug message.')
logger.info('This is an info message.')

日志过滤器（Filters）

日志过滤器允许你更精细地控制哪些日志记录应该被处理器处理。你可以定义自己的过滤器函数，并将它们添加到处理器或日志记录器中。过滤器函数可以基于日志消息内容、日志级别等条件来决定是否处理某条日志记录。

自定义日志记录器

你可以创建多个不同的日志记录器，每个日志记录器可以有不同的配置、处理器和过滤器，以满足不同模块或组件的日志记录需求。这样可以更好地组织和管理日志信息。

import logging

# 创建两个不同的日志记录器
logger1 = logging.getLogger('module1_logger')
logger2 = logging.getLogger('module2_logger')

# 配置日志记录器
logger1.setLevel(logging.DEBUG)
logger2.setLevel(logging.INFO)

# 创建处理器并添加到日志记录器
file_handler1 = logging.FileHandler('module1.log')
file_handler2 = logging.FileHandler('module2.log')

logger1.addHandler(file_handler1)
logger2.addHandler(file_handler2)

# 记录日志信息
logger1.debug('This is a debug message from module 1.')
logger2.info('This is an info message from module 2.')

总之，logging模块是Python中强大而灵活的日志记录工具，可以帮助你有效地记录和管理日志信息，以便更好地监视和维护你的应用程序。通过适当地配置处理器、过滤器和日志记录器，你可以满足各种不同的日志记录需求。

python_3_opencv模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

opencv模块笔记

python3 Opencv 模块详解

OpenCV（Open Source Computer Vision Library）是一个用于计算机视觉任务的开源库。它提供了大量的图像处理和计算机视觉功能，包括图像加载、保存、变换、特征检测、图像分割、目标跟踪等等。以下是有关Python 3中OpenCV模块的详细解释：

安装OpenCV

首先，您需要安装OpenCV库。可以使用以下命令使用pip安装OpenCV：

1	pip install opencv-python

导入OpenCV模块

导入OpenCV模块是使用OpenCV的第一步：

1	import cv2

加载和显示图像

OpenCV可以用于加载、显示和处理图像。以下是加载图像和显示图像的示例：

# 加载图像
image = cv2.imread('example.jpg')

# 显示图像
cv2.imshow('My Image', image)

# 等待按下任意键然后关闭图像窗口
cv2.waitKey(0)
cv2.destroyAllWindows()

图像处理

OpenCV提供了许多图像处理功能，例如调整亮度、对比度、模糊、边缘检测等。以下是一些示例：

# 调整图像亮度
brighter_image = cv2.convertScaleAbs(image, alpha=1.5, beta=50)

# 模糊图像
blurred_image = cv2.GaussianBlur(image, (15, 15), 0)

# 边缘检测
edges = cv2.Canny(image, 100, 200)

# 保存处理后的图像
cv2.imwrite('brighter_image.jpg', brighter_image)
cv2.imwrite('blurred_image.jpg', blurred_image)
cv2.imwrite('edges.jpg', edges)

视频处理

OpenCV还可以用于捕获、处理和保存视频。以下是一个简单的示例：

# 打开视频捕获设备
cap = cv2.VideoCapture(0)  # 0表示默认摄像头

while True:
    # 从捕获设备读取帧
    ret, frame = cap.read()

    # 在窗口中显示帧
    cv2.imshow('Video Frame', frame)

    # 检测按键，如果按下'q'键则退出循环
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放捕获设备并关闭窗口
cap.release()
cv2.destroyAllWindows()

这些只是OpenCV的一些基本功能示例。OpenCV非常强大，可以执行各种计算机视觉任务，包括对象检测、人脸识别、图像分割、目标跟踪等等。要了解更多功能和详细信息，请参阅OpenCV的官方文档和示例代码。

python_3_paramiko模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

paramiko模块笔记

python3 Paramiko模块详解

Paramiko 是一个用于 Python 的库，用于在远程服务器上执行操作，如 SSH 客户端连接、执行命令、文件传输等。它提供了许多功能，使得在 Python 中执行远程操作变得更加简单和灵活。

以下是使用 Python 3 中 Paramiko 模块的一些常见功能和用法：

安装 Paramiko

你可以使用 pip 来安装 Paramiko 模块：

1	pip install paramiko

使用 Paramiko 连接到远程服务器

import paramiko

# 创建 SSH 客户端
ssh_client = paramiko.SSHClient()

# 设置策略自动添加未知主机的密钥
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# 连接到远程服务器
ssh_client.connect(hostname='remote_host', username='username', password='password')

# 执行远程命令
stdin, stdout, stderr = ssh_client.exec_command('ls -l')
print(stdout.read().decode())

# 关闭 SSH 连接
ssh_client.close()

使用 SSH 密钥对连接

import paramiko

# 创建 SSH 客户端
ssh_client = paramiko.SSHClient()

# 设置策略自动添加未知主机的密钥
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# 使用密钥对进行身份验证
private_key = paramiko.RSAKey.from_private_key_file('/path/to/private_key')
ssh_client.connect(hostname='remote_host', username='username', pkey=private_key)

# 执行远程命令
stdin, stdout, stderr = ssh_client.exec_command('ls -l')
print(stdout.read().decode())

# 关闭 SSH 连接
ssh_client.close()

使用 SFTP 进行文件传输

import paramiko

# 创建 SSH 客户端
ssh_client = paramiko.SSHClient()

# 设置策略自动添加未知主机的密钥
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# 连接到远程服务器
ssh_client.connect(hostname='remote_host', username='username', password='password')

# 创建 SFTP 客户端
sftp_client = ssh_client.open_sftp()

# 从远程服务器下载文件
sftp_client.get('/remote/path/file.txt', '/local/path/file.txt')

# 关闭 SFTP 连接和 SSH 连接
sftp_client.close()
ssh_client.close()

以上是一些基本的示例，展示了如何使用 Paramiko 模块在 Python 3 中连接到远程服务器、执行命令和进行文件传输。通过 Paramiko，你可以轻松地在 Python 中管理和操作远程服务器。需要注意的是，使用 SSH 连接时，请谨慎处理凭据和密钥，并确保安全地管理和使用它们。

python_3_psutil模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

psutil模块笔记

python3 psutil 模块详解

psutil 是一个用于检索有关系统进程和系统利用率（CPU、内存、磁盘、网络等）的 Python 模块。它提供了一个简单且跨平台的接口，使得在不同操作系统上获取系统信息变得更加容易。以下是对 psutil 模块的一些常见用法的详解：

安装

你可以使用以下命令来安装 psutil 模块：

1	pip install psutil

基本用法

获取 CPU 信息:

import psutil

# 获取 CPU 核心数量
cpu_count = psutil.cpu_count(logical=False)  # 物理核心数
logical_cpu_count = psutil.cpu_count(logical=True)  # 逻辑核心数

# 获取 CPU 使用率
cpu_usage = psutil.cpu_percent(interval=1)  # 指定时间间隔内的 CPU 使用率
print(f"Physical CPU Count: {cpu_count}, Logical CPU Count: {logical_cpu_count}")
print(f"CPU Usage: {cpu_usage}%")

获取内存信息:

# 获取内存使用情况
memory_info = psutil.virtual_memory()

print(f"Total Memory: {memory_info.total} bytes")
print(f"Available Memory: {memory_info.available} bytes")
print(f"Used Memory: {memory_info.used} bytes")
print(f"Memory Usage Percentage: {memory_info.percent}%")

获取磁盘信息:

# 获取磁盘分区信息
disk_partitions = psutil.disk_partitions()

for partition in disk_partitions:
    print(f"Device: {partition.device}, Mount Point: {partition.mountpoint}")

# 获取磁盘使用情况
disk_usage = psutil.disk_usage('/')
print(f"Total Disk Space: {disk_usage.total} bytes")
print(f"Used Disk Space: {disk_usage.used} bytes")
print(f"Free Disk Space: {disk_usage.free} bytes")
print(f"Disk Usage Percentage: {disk_usage.percent}%")

获取网络信息:

# 获取网络接口信息
net_interfaces = psutil.net_if_addrs()

for interface, addresses in net_interfaces.items():
    print(f"Interface: {interface}")
    for address in addresses:
        print(f"  - Address Family: {address.family}, Address: {address.address}")

# 获取网络连接信息
net_connections = psutil.net_connections(kind='inet')
for conn in net_connections:
    print(f"Local Address: {conn.laddr}, Remote Address: {conn.raddr}, Status: {conn.status}")

获取进程信息:

# 获取当前运行的所有进程
all_processes = psutil.process_iter()

for process in all_processes:
    print(f"Process ID: {process.pid}, Name: {process.name()}")

这只是 psutil 模块的一小部分用法，该模块提供了许多其他方法和属性，用于更详细地获取系统信息。你可以参考 psutil 官方文档获取更多详细信息。

python_3_subprocess模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

subprocess模块笔记

python3 subprocess模块详解

subprocess 模块是 Python 标准库中的一个工具，用于创建和管理新的进程，并与它们进行交互。它提供了许多功能，允许在 Python 程序中执行外部命令、启动新进程、与这些进程进行通信等。

以下是 subprocess 模块的一些主要功能和常用函数：

执行外部命令

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, check=False)：运行指定的命令，并等待其完成。该函数返回一个 CompletedProcess 对象，包含了命令的执行结果。参数 args 是要执行的命令和参数，shell=True 可以用于执行包含通配符或管道的命令。

创建新进程

subprocess.Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, shell=False, cwd=None, env=None, universal_newlines=False, encoding=None, errors=None, text=None, **other_options)：启动一个新进程，并返回一个 Popen 对象，可用于与新进程进行交互。

进程间通信

Popen.communicate(input=None, timeout=None)：与新进程进行交互，发送数据到标准输入并获取标准输出和标准错误。可以设置 input 参数来发送数据给新进程，也可以使用 timeout 参数设置超时时间。

等待进程结束

Popen.wait(timeout=None)：等待进程结束，并返回退出状态码。可以选择设置超时时间以避免无限等待。

其他函数和属性

subprocess.check_output(args, *, stdin=None, stderr=None, shell=False, universal_newlines=False)：执行命令并返回输出结果，如果命令执行失败则抛出异常。
subprocess.check_call(args, *, stdin=None, stdout=None, stderr=None, shell=False)：执行命令，如果命令执行失败则抛出异常。
Popen.pid：获取新进程的进程 ID。
等等。

subprocess 模块提供了许多方法来执行外部命令，创建和管理新进程，并与这些进程进行交互。它在执行系统命令、启动子进程、执行 shell 脚本等方面非常有用。需要注意的是，在执行外部命令时应当格外小心，以防止不必要的安全风险，尤其是在使用 shell=True 时需谨慎防范命令注入问题。

python_3_threading模块

Posted on 2024-05-22 Edited on 2025-01-11 In Python

简介

threading模块笔记

python threading 判断多个线程是否完成

在 Python 中，可以使用 threading.Thread 的 is_alive() 方法或者 join() 方法来判断线程是否完成。

以下是几种判断多个线程是否完成的方法：

方法 1：使用 `join()` 等待所有线程完成

join() 会阻塞主线程，直到子线程完成。这是最常见的方式。

import threading
import time

def worker(name, delay):
    time.sleep(delay)
    print(f"Thread {name} finished.")

# 创建多个线程
threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(f"Thread-{i}", i))
    threads.append(t)
    t.start()

# 等待所有线程完成
for t in threads:
    t.join()

print("All threads are complete.")

方法 2：循环检查 `is_alive()`

is_alive() 返回线程是否仍在运行。

import threading
import time

def worker(name, delay):
    time.sleep(delay)
    print(f"Thread {name} finished.")

# 创建多个线程
threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(f"Thread-{i}", i))
    threads.append(t)
    t.start()

# 检查是否所有线程完成
while any(t.is_alive() for t in threads):
    print("Waiting for threads to complete...")
    time.sleep(0.5)

print("All threads are complete.")

方法 3：使用 `Event` 对象通知主线程

通过线程完成时触发 Event，主线程等待所有事件被设置。

import threading
import time

def worker(name, delay, event):
    time.sleep(delay)
    print(f"Thread {name} finished.")
    event.set()  # 通知主线程

# 创建多个线程和事件
events = []
threads = []

for i in range(5):
    event = threading.Event()
    events.append(event)
    t = threading.Thread(target=worker, args=(f"Thread-{i}", i, event))
    threads.append(t)
    t.start()

# 等待所有事件完成
for event in events:
    event.wait()

print("All threads are complete.")

选择合适的方法

简单场景：使用 join() 是最简洁的方式。
动态监控：使用 is_alive() 可实现更灵活的监控。
通知机制：使用 Event 提供更多控制能力。

如果你的场景需要特定的解决方案，请详细描述，我可以进一步优化代码！

python3 threading库启动线程函数并传递参数

在 Python 的 threading 模块中，可以通过 Thread 类启动线程，并使用 args 和 kwargs 参数向线程函数传递参数。

以下是具体方法和示例：

使用 `args` 和 `kwargs` 传递参数

**args**：用于传递位置参数，以元组形式提供。
**kwargs**：用于传递关键字参数，以字典形式提供。

示例代码

import threading
import time

# 定义线程函数
def worker(name, delay, repeat=5):
    for i in range(repeat):
        time.sleep(delay)
        print(f"Thread {name}: {i+1}")

# 创建线程并传递参数
thread1 = threading.Thread(target=worker, args=("A", 1), kwargs={"repeat": 3})
thread2 = threading.Thread(target=worker, args=("B", 2))

# 启动线程
thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

print("All threads are complete.")

输出示例

Thread A: 1
Thread B: 1
Thread A: 2
Thread B: 2
Thread A: 3
Thread B: 3
Thread B: 4
Thread B: 5
All threads are complete.

注意事项

args 和 kwargs 必须匹配目标函数的参数要求。
使用 join 方法可以让主线程等待子线程执行完成。
启动线程后，不能再调用 start 方法，否则会抛出 RuntimeError。

如果还有其他需求，随时告诉我！

python3 threading 模块详解

threading 模块是 Python 3 中用于多线程编程的标准库模块，它提供了一种方便的方式来创建和管理线程。多线程允许在同一程序中同时执行多个任务，可以提高程序的并发性和性能。以下是有关 threading 模块的详细解释和示例：

线程的创建：

threading.Thread 类：Thread 类是创建线程的主要工具。您可以通过创建 Thread 类的实例来定义一个新线程，并将要执行的任务（通常是一个函数）传递给 target 参数。
1
2
3
4
5
6
import threading

def my_function():
# 执行任务的代码

my_thread = threading.Thread(target=my_function)
启动线程：使用 start() 方法来启动线程，它将在后台执行线程的任务。
1
my_thread.start()

线程的控制：

threading.Thread.is_alive()：检查线程是否处于活动状态（正在运行）。
1
2
if my_thread.is_alive():
print("Thread is alive")
threading.Thread.join()：等待线程执行完毕。主线程可以使用 join() 方法等待其他线程的完成。
1
my_thread.join()

线程同步：

threading.Lock 类：Lock 类用于创建锁，以确保多个线程之间的互斥访问共享资源。

my_lock = threading.Lock()

def my_thread_function():
    with my_lock:
        # 访问共享资源的代码

threading.Event 类：Event 类用于线程之间的事件通知和等待。

my_event = threading.Event()

def waiting_thread():
    my_event.wait()  # 等待事件被设置
    # 事件被设置后执行的代码

def setting_thread():
    # 执行某些操作
    my_event.set()  # 设置事件

线程间通信：

使用队列：queue 模块提供了线程安全的队列（queue.Queue）用于在线程之间安全地传递数据。

import threading
import queue

my_queue = queue.Queue()

def producer():
    # 生产数据
    my_queue.put(data)

def consumer():
    # 消费数据
    data = my_queue.get()

线程池：

threading 模块还提供了 ThreadPoolExecutor 类，它允许您管理线程池，以便在应用程序中管理和重复使用线程。这对于需要执行多个任务的情况非常有用。

import concurrent.futures

def my_function():
    # 执行任务的代码

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    future = executor.submit(my_function)
    # 更多任务提交和管理

注意事项：

Python 中的全局解释器锁（Global Interpreter Lock，GIL）限制了同一时间只能执行一个线程中的 Python 代码。这意味着多线程在 CPU 密集型任务中可能无法充分利用多核处理器。但对于 I/O 密集型任务，多线程通常仍然有用。
线程在共享数据时可能会引发竞争条件和死锁等问题，因此在多线程编程中需要小心谨慎，使用适当的同步工具。

总之，threading 模块提供了方便的工具来创建、管理和同步线程，允许您实现并发性和并行性，但需要注意线程安全和共享资源的管理问题。对于更高级的并发任务，您还可以考虑使用 multiprocessing 模块，它允许您创建多个进程以利用多核处理器。

python3 threading模块传入一个参数

如果你想在线程中传递一个参数，可以使用 args 参数来传递一个包含单个元素的元组。以下是一个简单的示例：

import threading

def my_function(arg):
    print("Thread is running with argument:", arg)

# 创建一个线程，并传递单个参数
my_arg = "Hello"
my_thread = threading.Thread(target=my_function, args=(my_arg,))

# 启动线程
my_thread.start()

# 等待线程结束
my_thread.join()

在这个例子中，my_function 函数期望接收一个参数，我们将参数放入一个元组 (my_arg,) 中，并将该元组作为 args 参数传递给 Thread 类的构造函数。

确保参数传递的数据类型和数量与目标函数的定义相匹配。如果有多个参数，仍然需要将它们放入一个元组中，并将该元组作为 args 参数传递。

python3 threading模块将线程分离到后台

在Python中，可以使用 threading.Thread 的 daemon 属性将线程设置为后台线程。将线程设置为后台线程意味着当主线程退出时，后台线程也会被终止，而不管它是否完成。

以下是一个简单的示例：

import threading
import time

def my_function():
    for i in range(5):
        print("Thread is running...")
        time.sleep(1)

# 创建一个后台线程
my_thread = threading.Thread(target=my_function)
my_thread.daemon = True

# 启动线程
my_thread.start()

# 主线程等待一段时间
time.sleep(2)

# 主线程退出，后台线程也会被终止
print("Main thread exiting.")

在这个例子中，my_function 是一个简单的线程函数，线程会在循环中打印消息并休眠1秒。通过将 my_thread.daemon 设置为 True，我们将线程设置为后台线程。当主线程执行 print("Main thread exiting.") 时，主线程会退出，同时后台线程也会被终止。

请注意，如果你的后台线程执行一些关键任务，可能需要谨慎使用后台线程，因为在主线程退出时，可能导致后台线程无法完成其任务。

python_3_torchvision模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

torchvision相关笔记

python3 torchvision是什么

torchvision是PyTorch生态系统中的一个独立软件包，它提供了一系列用于图像和视频处理的工具和函数。具体来说，torchvision主要包括以下几个方面的功能：

数据集和数据加载器：torchvision提供了用于加载和预处理各种常见计算机视觉数据集的功能，例如MNIST、CIFAR-10、ImageNet等。它还包括用于构建数据加载器（DataLoader）的工具，这些加载器可用于有效地加载和批处理数据。
图像转换和处理：torchvision.transforms模块提供了各种图像转换和处理函数，用于执行诸如裁剪、调整大小、旋转、标准化等操作。这些转换可用于在训练过程中对图像进行数据增强，以及在推理过程中对图像进行预处理。
模型：torchvision.models模块提供了预训练的深度学习模型，例如ResNet、VGG、AlexNet等。这些模型已在大型图像数据集上进行了训练，并且可以用作迁移学习的基础模型，或者直接用于特定的图像分类、目标检测、语义分割等任务。
工具函数：除了上述功能之外，torchvision还提供了一些辅助工具函数，用于可视化图像、计算图像特征、评估模型性能等。

综上所述，torchvision是一个用于图像处理和计算机视觉任务的强大工具包，为PyTorch用户提供了便捷的接口和功能，可以帮助他们更轻松地构建和训练图像相关的深度学习模型。

python3 torchvision详解

torchvision是PyTorch中的一个官方库，专门用于处理计算机视觉任务。它提供了一系列用于图像处理、数据加载和模型构建的工具和功能。下面是torchvision库的一些详解：

数据集和数据加载器：torchvision.datasets模块提供了常用的计算机视觉数据集，如MNIST、CIFAR-10、ImageNet等。这些数据集可以通过简单的API调用来下载并加载到PyTorch中，方便进行模型训练和评估。此外，torchvision还提供了torchvision.transforms模块，用于定义和应用数据转换，如图像缩放、裁剪、旋转、归一化等，以及将图像转换为张量格式。
预训练模型：torchvision.models模块包含了一系列经过预训练的深度学习模型，如ResNet、VGG、AlexNet等。这些模型已经在大型图像数据集上进行了训练，并且可以用于各种图像相关的任务，如图像分类、目标检测、语义分割等。您可以通过简单的API调用来加载这些预训练模型，并进行微调或直接用于推理。
图像工具函数：除了数据集和模型之外，torchvision还提供了一些用于图像处理和可视化的工具函数，如绘制图像、显示图像、计算图像直方图等。这些工具函数可以帮助您对图像数据进行探索和分析，以及展示模型的输出结果。
扩展功能：torchvision还提供了一些扩展功能，如对视频数据进行处理的功能、对自定义数据集进行加载和预处理的功能等。这些扩展功能可以帮助您处理更复杂的图像和视频数据，以及构建更灵活的训练流程。

综上所述，torchvision是一个功能丰富且易于使用的库，为PyTorch用户提供了丰富的图像处理和计算机视觉功能，使他们能够更轻松地构建、训练和部署图像相关的深度学习模型。

python_3_transforms3d模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

transforms3d模块相关笔记

python3 transform3d模块详解

transforms3d是一个Python库，用于处理3D转换、旋转、平移等操作。这个库主要用于处理三维空间中的坐标变换，包括欧拉角、四元数、轴-角等不同表示方式之间的转换。以下是对transforms3d库的一些主要功能和模块的详细解释：

安装transforms3d库

你可以使用以下命令安装transforms3d库：

1	pip install transforms3d

主要模块和功能

1. `transforms3d.euler`

该模块提供了欧拉角的转换函数。主要函数有：

euler2mat：将欧拉角转换为旋转矩阵。
mat2euler：将旋转矩阵转换为欧拉角。

import transforms3d.euler as tf_euler

# 示例
euler_angles = (0.1, 0.2, 0.3)  # (roll, pitch, yaw)
rotation_matrix = tf_euler.euler2mat(euler_angles)
euler_angles_recovered = tf_euler.mat2euler(rotation_matrix)

2. `transforms3d.quaternions`

该模块提供了处理四元数的函数。主要函数有：

quaternion_from_euler：将欧拉角转换为四元数。
euler_from_quaternion：将四元数转换为欧拉角。

import transforms3d.quaternions as tf_quaternions

# 示例
euler_angles = (0.1, 0.2, 0.3)  # (roll, pitch, yaw)
quaternion = tf_quaternions.quaternion_from_euler(*euler_angles)
euler_angles_recovered = tf_quaternions.euler_from_quaternion(quaternion)

3. `transforms3d.axangles`

该模块提供了处理轴-角表示的函数。主要函数有：

axangle2mat：将轴-角表示转换为旋转矩阵。
mat2axangle：将旋转矩阵转换为轴-角表示。

import transforms3d.axangles as tf_axangles

# 示例
axis_angle = (1, 0, 0, 0.1)  # (x, y, z, angle)
rotation_matrix = tf_axangles.axangle2mat(axis_angle)
axis_angle_recovered = tf_axangles.mat2axangle(rotation_matrix)

4. `transforms3d.zooms`

该模块提供了处理缩放变换的函数。主要函数有：

zooms_from_params：将缩放参数转换为缩放矩阵。

import transforms3d.zooms as tf_zooms

# 示例
zoom_params = (2, 3, 4)  # (scale_x, scale_y, scale_z)
zoom_matrix = tf_zooms.zooms_from_params(*zoom_params)

这些模块提供了在3D空间中进行不同类型的变换的工具函数。你可以根据需要选择合适的表示方式，并使用相应的函数进行转换。库的文档提供了更详细的信息和示例，可以帮助你更好地了解如何使用这些功能。

python3 输出旋转轴和旋转角得到旋转矩阵

在Python中，你可以通过旋转轴和旋转角度来构造旋转矩阵。以下是一个例子，演示了如何通过旋转轴和旋转角度得到旋转矩阵：

import numpy as np
from scipy.spatial.transform import Rotation

# 旋转轴（单位向量）
rotation_axis = np.array([1, 0, 0])  # 例如，绕X轴旋转

# 旋转角度（弧度）
rotation_angle = np.radians(90)  # 例如，旋转90度

# 构造Rotation对象
rotation = Rotation.from_rotvec(rotation_angle * rotation_axis)

# 获取旋转矩阵
rotation_matrix = rotation.as_matrix()

print("旋转轴:")
print(rotation_axis)

print("\n旋转角度:")
print(np.degrees(rotation_angle))

print("\n得到的旋转矩阵:")
print(rotation_matrix)

在这个例子中，rotation_axis 是旋转轴的单位向量，rotation_angle 是旋转的角度（以弧度为单位）。通过这两者构造一个 Rotation 对象，然后使用 as_matrix() 方法获取对应的旋转矩阵。确保你的环境中安装了SciPy库：

1	pip install scipy

以上代码输出的结果分别是旋转轴、旋转角度和得到的旋转矩阵。

python_3_scipy模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

scipy模块相关笔记

python3 scipy模块是什么

在Python中，scipy（Scientific Python）是一个用于科学计算的库，它建立在NumPy之上，提供了一组更高级的数学、科学和工程计算功能。scipy库包含许多专业领域的工具和算法，使得科学研究、工程和数据分析更加方便。

主要的 scipy 子模块包括但不限于：

scipy.constants: 包含物理常数，如光速、普朗克常数等。
scipy.optimize: 提供了一系列优化算法，用于最小化或最大化目标函数。
scipy.stats: 包含统计学的工具，如概率分布、假设检验等。
scipy.linalg: 提供线性代数的操作，如矩阵分解、特征值计算等。
scipy.interpolate: 插值和拟合工具，用于处理不完整或不连续的数据。
scipy.fft: 快速傅里叶变换相关的工具。
scipy.signal: 信号处理工具，包括滤波、卷积等。
scipy.spatial: 空间数据结构和算法，如距离计算、几何对象等。
scipy.cluster: 聚类算法。
scipy.ndimage: 多维图像处理工具。
scipy.integrate: 数值积分工具。
scipy.special: 特殊数学函数，如伽马函数、贝塞尔函数等。

这些子模块为科学计算提供了广泛的工具和算法，使得在科学研究、工程领域和数据分析中更容易进行高效的计算和分析。scipy是一个强大的库，通常与NumPy、Matplotlib等其他科学计算库一起使用，以构建完整的科学计算环境。

python3 scipy模块详解

scipy 是一个用于科学计算的Python库，它扩展了NumPy库，并提供了更多的高级数学、科学和工程计算功能。以下是一些 scipy 的主要子模块和其功能的简要详解：

scipy.constants: 包含各种物理常数，例如光速、普朗克常数等。

import scipy.constants as const

print("光速:", const.speed_of_light)
print("普朗克常数:", const.Planck)

scipy.optimize: 提供了各种优化算法，用于最小化或最大化目标函数。

from scipy.optimize import minimize

# 示例：最小化一个简单的二次函数
def objective_function(x):
    return x**2 + 4*x + 4

result = minimize(objective_function, x0=0)
print("最小化结果:", result)

scipy.stats: 包含统计学工具，如概率分布、假设检验等。

from scipy.stats import norm

# 示例：标准正态分布的累积分布函数
cumulative_prob = norm.cdf(1.96)
print("标准正态分布在1.96处的累积概率:", cumulative_prob)

scipy.linalg: 提供线性代数操作，如矩阵分解、特征值计算等。

from scipy.linalg import qr

# 示例：QR分解
A = np.array([[1, 2], [3, 4]])
Q, R = qr(A)
print("Q矩阵:", Q)
print("R矩阵:", R)

scipy.interpolate: 提供插值和拟合工具，用于处理不完整或不连续的数据。

from scipy.interpolate import interp1d

# 示例：线性插值
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 3, 5, 8, 13])

linear_interp = interp1d(x, y)
interpolated_values = linear_interp([1.5, 3.5])
print("线性插值结果:", interpolated_values)

scipy.fft: 提供傅里叶变换相关的工具。

from scipy.fft import fft

# 示例：计算傅里叶变换
signal = np.array([1, 2, 3, 4])
fft_result = fft(signal)
print("傅里叶变换结果:", fft_result)

scipy.signal: 包含信号处理工具，如滤波、卷积等。

from scipy.signal import convolve

# 示例：卷积操作
signal1 = np.array([1, 2, 3])
signal2 = np.array([0.5, 0.5])

result = convolve(signal1, signal2, mode='valid')
print("卷积结果:", result)

这些是 scipy 中一些主要子模块的简要说明。scipy 还包含其他子模块，如 scipy.spatial、scipy.cluster、scipy.ndimage、scipy.integrate 等，提供了更多领域的工具和算法。在实际使用中，你可以根据具体的需求选择合适的子模块和功能。

python3 scipy.spatial 详解

scipy.spatial 模块提供了处理空间数据结构和算法的工具。它包含了许多在计算机图形学、机器学习、计算机视觉等领域常用的算法。以下是一些 scipy.spatial 模块中主要功能的简要详解：

scipy.spatial.distance: 提供了计算两个向量或矩阵之间距离的函数。

from scipy.spatial.distance import euclidean

# 示例：计算欧氏距离
point1 = np.array([1, 2, 3])
point2 = np.array([4, 5, 6])
distance = euclidean(point1, point2)
print("欧氏距离:", distance)

scipy.spatial.KDTree: 实现了 k-dimensional 树，用于快速最近邻搜索。

from scipy.spatial import KDTree

# 示例：构建 KD 树并进行最近邻搜索
points = np.array([[0, 0], [1, 1], [2, 2]])
kdtree = KDTree(points)
query_point = np.array([1.5, 1.5])

# 找到最近邻的点
distance, index = kdtree.query(query_point)
print("最近邻的点:", points[index])
print("到最近邻的距离:", distance)

scipy.spatial.ConvexHull: 计算点集的凸包。

from scipy.spatial import ConvexHull

# 示例：计算点集的凸包
points = np.array([[0, 0], [1, 1], [1, 0], [0, 1]])
hull = ConvexHull(points)

# 获取凸包的顶点
convex_hull_vertices = hull.vertices
print("凸包的顶点:", points[convex_hull_vertices])

scipy.spatial.Delaunay: 计算点集的 Delaunay 三角剖分。

from scipy.spatial import Delaunay
import matplotlib.pyplot as plt

# 示例：Delaunay 三角剖分
points = np.array([[0, 0], [1, 0.5], [2, 0], [1, 2]])
triangulation = Delaunay(points)

# 绘制 Delaunay 三角剖分结果
plt.triplot(points[:, 0], points[:, 1], triangulation.simplices)
plt.plot(points[:, 0], points[:, 1], 'o')
plt.show()

这些是 scipy.spatial 模块中一些主要功能的简要说明。这个模块提供了许多用于处理空间数据结构和进行空间计算的工具，适用于多个领域的应用。在实际应用中，你可以根据具体需求选择合适的函数和类。

1_1_基础

Posted on 2024-05-22 Edited on 2024-12-30 In Redis

简介

Redis相关笔记

redis是什么

Redis是一个开源的内存数据库，它可以用作键值存储、缓存和消息队列。Redis支持各种数据结构，如字符串、哈希、列表、集合、有序集合等，这使得它非常灵活和多用途。它通常被用来加速应用程序的性能，存储会频繁访问的数据，或者作为分布式系统中的数据存储和消息传递中间件。Redis的速度非常快，因为它将数据存储在内存中，并且可以通过持久化机制将数据保存到磁盘上以进行持久化存储。

Redis(维基百科)

Redis(Remote Dictionary Server)是一个使用ANSI C编写的支持网络，基于内存，分布式，可选持久性的键值对存储数据库。
数据模型
- Redis的外围由一个键，值映射的字典构成。与其他非关系型数据库主要不同在于： Redis中值的类型不仅限于字符串，还支持如下抽象数据类型
  - 字符串列表
  - 无序不重复的字符串集合
  - 有序不重复的字符串集合
  - 键，值都为字符串的哈希表
- 值的类型决定了值本身支持的操作。Redis支持不同无序，有序的列表，无序，有序的集合间的交集，并集等高级服务器端原子操作
持久化
- Redis通常将全部数据存储在内存中
- 目前通过两种方式实现持久化
  - 使用快照，一种半持久耐用模式。不时的将数据集以异步方式从内存以RDB格式写入硬盘
  - 1.1版本开始使用更安全的AOF格式替代，一种只能追加的日志类型。将数据集修改操作记录起来。Redis能够在后台对只可追加的记录进行修改，从而避免日志的无限增长。
同步
- Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。从盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助
性能
- 当数据依赖不再需要，Redis这种基于内存的性质，与在执行一个事务时将每个变化都写入硬盘的数据库系统相比就显得执行效率非常高。[11]写与读操作速度没有明显差别。

数据库 redis 详解

Redis是一个非常流行的开源内存数据库，它提供了丰富的功能和灵活的用途。下面是对Redis的一些详细解释：

内存数据库：Redis主要将数据存储在内存中，这使得它能够提供非常快速的读写操作。由于内存的速度远高于磁盘，因此Redis能够在毫秒级别处理大量的读写请求。
键值存储：Redis是一个键值存储系统，其中的每个键都与一个值相关联。这种简单的数据结构使得Redis在处理简单数据模型时非常高效。
数据结构支持：Redis支持多种数据结构，包括字符串、哈希、列表、集合、有序集合等。这些数据结构使得Redis可以应对各种不同的需求，并提供了丰富的数据操作命令。
持久化存储：尽管Redis主要将数据存储在内存中，但它也提供了持久化存储功能，可以将数据定期保存到磁盘上，以防止数据丢失。
缓存：由于其快速的读写速度和灵活的数据结构，Redis经常被用作缓存系统。它可以将经常访问的数据存储在内存中，从而加速应用程序的性能。
发布/订阅：Redis支持发布/订阅模式，可以用作消息队列系统。发布者可以将消息发布到特定的频道，而订阅者则可以订阅这些频道以接收消息。
分布式系统支持：Redis提供了多种分布式特性，如主从复制、分片等，使得它可以在分布式系统中使用，并提供高可用性和可扩展性。
事务支持：Redis支持事务操作，可以将多个命令打包成一个原子操作，从而保证这些命令要么全部执行成功，要么全部执行失败。

总的来说，Redis是一个功能强大、性能优越的内存数据库，可以应对各种不同的应用场景，从简单的缓存系统到复杂的分布式系统都能够发挥作用。

linux redis C++相关工具库

在Linux环境下，有几个与Redis相关的C++工具库可以用来与Redis进行交互和操作。以下是其中一些：

hiredis：hiredis是一个轻量级的C库，用于与Redis进行交互。虽然它是用C编写的，但也提供了C++的包装器，可以在C++项目中使用。hiredis提供了简洁的API，使得与Redis进行连接、发送命令和接收响应变得非常方便。
cpp_redis：cpp_redis是一个用C++编写的Redis客户端库，提供了现代C++风格的API和异步支持。它的设计使得在C++应用程序中与Redis进行交互变得更加简单和高效。
Redox：Redox是另一个用C++编写的Redis客户端库，它提供了类似于cpp_redis的现代C++接口，并支持异步操作。Redox的设计目标是提供简单易用的API，同时保持高性能。

这些工具库都可以在Linux环境下使用，并且都支持与Redis进行连接、命令发送、响应接收等操作。选择哪个库取决于你的项目需求和个人偏好，但无论选择哪个，它们都提供了方便、高效的方式来利用Redis的功能。

linux redis开发结构是什么样的

在Linux环境下进行Redis开发时，通常会采用一种分层结构来组织代码和实现功能。这种结构可以根据项目的规模和复杂度进行调整，但通常包含以下几个层次：

应用层：应用层是最高级别的层次，它包含与业务逻辑直接相关的代码。在这一层，开发者会编写与具体业务需求相关的功能，如数据处理、业务逻辑实现等。应用层通过调用下一层的接口来与Redis进行交互，发送命令、接收响应，并处理返回的数据。
Redis客户端库：在应用层之下是Redis客户端库，它提供了与Redis服务器进行通信的API和功能。开发者可以使用已有的Redis客户端库，如hiredis、cpp_redis或Redox，也可以根据需要自行开发客户端库。这一层负责建立与Redis服务器的连接，发送命令和接收响应，并提供方便的接口供应用层调用。
网络通信层：在客户端库之下是网络通信层，它负责处理与Redis服务器之间的网络通信。这一层实现了与Redis服务器的连接建立、命令发送、响应接收等功能，通常使用TCP/IP协议来进行通信。
Redis服务器：最底层是Redis服务器，它负责存储数据、处理命令、生成响应等功能。Redis服务器通常在Linux环境下运行，可以作为单机或分布式系统来部署和管理。

在这种结构下，应用层通过调用Redis客户端库提供的API与Redis进行交互，而客户端库则通过网络通信层与Redis服务器建立连接，并发送命令和接收响应。这种分层结构使得Redis开发更加模块化和可维护，同时也提供了灵活性和扩展性，能够适应不同规模和复杂度的项目需求。

redis的用途详解

Redis 是一个开源的、基于内存的数据存储系统，它支持多种数据结构（如字符串、哈希表、列表、集合、有序集合等），并提供了丰富的功能和特性。Redis 的用途非常广泛，包括但不限于以下几个方面：

1. 缓存：

Redis 可以作为高性能的缓存系统，用于存储常用的数据，加速访问速度。由于 Redis 的数据存储在内存中，读写速度非常快，适合存储热点数据和频繁访问的数据。常见的缓存应用包括网页缓存、会话缓存、对象缓存等。

2. 数据库：

虽然 Redis 是一个键值存储系统，但它的数据结构支持丰富，可以存储复杂的数据类型，并提供了持久化功能，可以将数据持久化到磁盘上。因此，Redis 也可以作为轻量级的数据库使用，适用于一些对数据持久性要求不是很高的场景，如消息队列、计数器、排行榜等。

3. 分布式锁：

Redis 的原子操作和分布式特性使其成为实现分布式锁的一个理想选择。通过 Redis 的 SETNX（SET if Not eXists）命令可以很方便地实现分布式锁，保证在分布式环境下的数据一致性和并发安全性。

4. 消息队列：

Redis 的发布订阅功能使其成为一个简单而有效的消息队列系统。生产者可以将消息发布到指定的频道，而订阅者则可以订阅这些频道，并在有消息到达时接收并处理。这种发布-订阅模式非常适用于异步任务处理、消息广播等场景。

5. 实时排行榜和计数器：

由于 Redis 支持有序集合和原子操作，可以非常方便地实现实时排行榜和计数器功能。通过有序集合存储分数和成员的对应关系，可以实现按分数排序的排行榜，而通过增减操作可以实现实时计数器功能。

6. 地理位置应用：

Redis 的地理位置数据结构和地理位置计算命令，使其成为实现地理位置应用（如附近的人、地点推荐等）的一个良好选择。通过地理位置数据结构存储经纬度信息，并使用地理位置计算命令进行距离计算和位置查询，可以实现许多有趣的地理位置应用。

总结：

Redis 是一个功能强大、用途广泛的数据存储系统，可以应用于缓存、数据库、分布式锁、消息队列、实时计数器、地理位置应用等众多场景。其快速、高效、稳定的特性使其成为众多互联网应用的首选，是一个非常受欢迎的开源项目。

redis报文详解

在 Redis 中，通信是通过简单的文本协议进行的，称为 Redis 协议（Redis Protocol）。Redis 协议是一种基于文本的、简单易懂的协议，它使用 RESP（REdis Serialization Protocol）格式来进行数据的序列化和反序列化。下面是关于 Redis 协议报文的详细解释：

1. RESP 格式：

RESP 是 Redis 自定义的一种序列化协议，用于在客户端和服务器之间传输数据。RESP 格式有以下几种类型：

单行字符串（Simple Strings）：以 “+” 开头，例如：+OK\r\n。
错误消息（Errors）：以 “-“ 开头，例如：-Error message\r\n。
整数值（Integers）：以 “:” 开头，例如：:1000\r\n。
批量字符串（Bulk Strings）：以 “$” 开头，例如：$6\r\nfoobar\r\n。
数组（Arrays）：以 “*” 开头，例如：*3\r\n:1\r\n:2\r\n:3\r\n。

2. Redis 协议报文示例：

下面是一个 Redis 协议报文的示例：

*3\r\n
$3\r\nSET\r\n
$5\r\nmykey\r\n
$7\r\nmyvalue\r\n

这个报文表示一个数组，包含三个元素，分别是一个字符串 SET、一个字符串 mykey 和一个字符串 myvalue。这个报文表示的操作是向 Redis 数据库中设置一个键值对，键为 mykey，值为 myvalue。

3. 报文的解析与处理：

在 Redis 客户端和服务器之间的通信过程中，客户端会向服务器发送一系列的命令请求报文，服务器接收到请求后进行解析和处理，然后返回相应的响应报文给客户端。客户端收到响应后进行解析并根据需要进行后续的操作。

4. 客户端和服务器之间的通信：

在实际的使用中，Redis 客户端和服务器之间的通信是通过套接字（Socket）来实现的。客户端通过套接字向服务器发送请求报文，服务器接收到请求后进行处理，并根据请求发送响应报文给客户端。

5. 序列化与反序列化：

Redis 协议中的报文需要进行序列化和反序列化操作，以便在网络上传输和在客户端/服务器中进行处理。客户端和服务器需要实现相应的序列化和反序列化算法来处理 Redis 协议报文。

总的来说，Redis 协议是一种简单易懂的文本协议，用于客户端和服务器之间的通信。通过使用 RESP 格式的报文，客户端可以向服务器发送命令请求，服务器接收到请求后进行处理，并返回相应的响应给客户端。这种基于文本的通信协议使得 Redis 在网络传输和数据处理方面具有良好的可扩展性和易用性。

redis有哪些数据结构

Redis 是一个支持多种数据结构的内存数据库，每种数据结构都有其特定的用途和优势。以下是 Redis 中常见的数据结构：

字符串（String）：
- 最基本的数据结构，存储一个键值对，键是字符串，值可以是字符串、整数或浮点数。
哈希表（Hash）：
- 类似于关联数组，存储字段和与其关联的值的映射关系，用于存储对象。
列表（List）：
- 双向链表结构，支持插入、删除、查找等操作，可以用作队列、栈等数据结构。
集合（Set）：
- 无序集合，元素唯一，支持添加、删除、查找等操作，可以用于存储唯一值。
有序集合（Sorted Set）：
- 类似于集合，每个元素都关联了一个分数（score），元素按照分数从小到大排序，支持添加、删除、查找等操作。
位图（Bitmap）：
- 由二进制位组成的数据结构，支持位运算操作，可以用于表示用户在线状态、标记用户行为等。
HyperLogLog：
- 用于基数估计的数据结构，用于估算集合中元素的数量。
地理空间索引（GeoSpatial）：
- 存储地理位置信息的数据结构，支持添加、删除、查找等操作，可以用于位置信息检索和计算。

这些数据结构使 Redis 能够满足不同场景下的需求，例如缓存、计数器、消息队列、排行榜等。在使用 Redis 时，根据具体需求选择合适的数据结构能够更好地发挥其性能和功能优势。

连接操作命令

quit : 关闭连接
auth : 简单密码认证
help cmd : 查看cmd帮助，例如：help quit

持久化

save : 将数据同步保存到磁盘
bgsave : 将数据异步保存到磁盘
lastsave : 返回上次成功将数据保存到磁盘的Unix时戳
shundown : 将数据同步保存到磁盘，然后关闭服务

远程服务控制

info : 提供服务器的信息和统计
monitor : 实时转储收到的请求
slaveof : 改变复制策略设置
config : 在运行时配置Redis服务器

对value操作的命令

exists (key) : 确认一个key是否存在
del (key) : 删除一个key
type (key) : 返回值的类型
keys (pattern) : 返回满足给定pattern的所有key
randomkey : 随即返回key空间的一个
keyrename(oldname, newname) : 重命名key
dbsize : 返回当前数据库中key的数目
expire : 设定一个key的活动时间(s)
ttl : 获得一个key的活动时间
select (index) : 按索引查询
move (key, dbindex) : 移动当前数据库中的key到dbindex数据库
flushdb : 删除当前选择数据库中所有key
flushall : 删除所有数据库中的所有key

List

rpush(key, value) : 在名称为key的list尾部添加一个值为value的元素
lpush(key, value) : 在名称为key的list头部添加一个值为alue的元素
llen(key) : 返回名称为key的list长度
lrange(key, start, end) : 返回名称为key的list中start至end之间的元素
ltrim(key, start, end) : 截取名称为key的list
lindex(key, index) : 返回名称为key的list中index位置的元素
lset(key, index, value) : 给名称为key的list中index位置的元素赋值
lrem(key, count, value) : 删除count个key的list中值为value的元素
lpop(key) : 返回并删除名称为key的list中的首元素
rpop(key) : 返回并删除名称为key的list中的尾元素
blpop(key1, key2, ... key N, timeout) : lpop命令的block版本
brpop(key1, key2, ... key N, timeout) : rpop的block版本

python_3_pycuda模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

pycuda模块

python3 pycuda是什么

PyCUDA 是一个用于在 Python 中进行 GPU 编程的库，它允许你使用 NVIDIA 的 CUDA 框架，利用 GPU 进行并行计算。CUDA 是 NVIDIA 提供的并行计算平台和编程模型，用于利用 GPU 的大规模并行计算能力。

PyCUDA 提供了 Python 对 CUDA API 的封装，使得在 Python 中能够方便地进行 GPU 编程。通过 PyCUDA，你可以：

在 Python 中编写 CUDA C 核心，通过调用 PyCUDA 提供的接口在 GPU 上运行。
使用 PyCUDA 提供的高级抽象，例如 PyCUDA 数组，来简化 GPU 编程。
在 Python 中管理 GPU 内存。
调用 CUDA 运行时 API 和设备驱动程序 API，执行各种 GPU 操作。

要使用 PyCUDA，首先需要安装 CUDA 驱动和运行时，并安装 PyCUDA 包。你可以使用以下命令安装 PyCUDA：

1	pip install pycuda

在安装 PyCUDA 之前，请确保你的系统上已经正确安装了 NVIDIA GPU 驱动和 CUDA 工具包。 PyCUDA 的官方文档包含了更详细的安装和使用说明：PyCUDA Documentation。

请注意，使用 GPU 进行编程需要了解 CUDA 编程模型以及如何有效地利用 GPU 的并行计算能力。

python3 pycuda库详解

PyCUDA 是一个用于在 Python 中进行 GPU 编程的库，它提供了对 NVIDIA CUDA API 的封装，使得在 Python 中可以方便地进行并行计算。以下是一些关于 PyCUDA 的详细说明：

GPU 编程:
- PyCUDA 允许你编写 GPU 内核函数，这些函数使用类似于 CUDA C 的语法。这些内核函数可以在 GPU 上并行执行，从而加速计算密集型任务。
PyCUDA 数组:
- PyCUDA 提供了 pycuda.gpuarray.GPUArray 类，它是一个类似于 NumPy 数组的结构，但存储在 GPU 上。这样可以方便地在 GPU 上进行数组操作。
GPU 内存管理:
- PyCUDA 允许你直接管理 GPU 上的内存，包括分配和释放。这对于在 GPU 上执行大规模计算时非常重要。
CUDA 运行时 API 和设备驱动程序 API 的调用:
- 你可以使用 PyCUDA 直接调用 CUDA 运行时 API 和设备驱动程序 API，以执行更底层的 GPU 操作。
流（Streams）和事件（Events）:
- PyCUDA 支持 CUDA 流（Streams）和事件（Events），这对于管理并行操作的执行顺序和同步非常重要。
高级封装:
- 除了底层的 CUDA 操作之外，PyCUDA 还提供了高级的封装，使 GPU 编程变得更加方便。例如，pycuda.compiler.SourceModule 允许你直接在 Python 中编译 CUDA C 代码。

以下是一个简单的 PyCUDA 示例，展示了在 GPU 上进行向量加法的基本操作：

import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np

# 定义 GPU 内核函数
kernel_code = """
__global__ void vector_add(float *a, float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {
        c[i] = a[i] + b[i];
    }
}
"""

# 编译 GPU 内核
from pycuda.compiler import SourceModule
mod = SourceModule(kernel_code)
vector_add = mod.get_function("vector_add")

# 定义输入数据
n = 100
a = np.random.randn(n).astype(np.float32)
b = np.random.randn(n).astype(np.float32)
c = np.zeros_like(a)

# 将数据传输到 GPU
a_gpu = cuda.mem_alloc(a.nbytes)
b_gpu = cuda.mem_alloc(b.nbytes)
c_gpu = cuda.mem_alloc(c.nbytes)

cuda.memcpy_htod(a_gpu, a)
cuda.memcpy_htod(b_gpu, b)

# 执行 GPU 内核
block_size = 128
grid_size = (n + block_size - 1) // block_size
vector_add(a_gpu, b_gpu, c_gpu, np.int32(n), block=(block_size, 1, 1), grid=(grid_size, 1))

# 将结果从 GPU 传输回 CPU
cuda.memcpy_dtoh(c, c_gpu)

# 打印结果
print("a:", a)
print("b:", b)
print("c:", c)

请注意，PyCUDA 对 GPU 的并行计算进行了良好的封装，使得在 Python 中进行 GPU 编程变得更加直观。在实际使用中，你可能需要根据你的需求进一步探索 PyCUDA 的功能和文档。

python_3_re模块

Posted on 2024-05-22 Edited on 2024-12-30 In Python

简介

re模块笔记

python3 re模块详解

Python 的 re 模块是用于处理正则表达式的标准库，它提供了一组函数和类，用于进行文本匹配和处理。下面是对 Python 3 中的 re 模块的详细解释和示例：

导入 re 模块：

首先，您需要导入 re 模块，以便使用其功能：

import re

常用的 re 模块函数和方法：

re.search(pattern, string, flags=0): 在给定字符串中搜索匹配指定模式的子串。返回一个匹配对象（Match object），或者在找不到匹配时返回 None。

示例：
1
2
3
4
5
6
7
pattern = r'apple'
text = "I like apples."
match = re.search(pattern, text)
if match:
print("Match found:", match.group())
else:
print("No match found.")

re.match(pattern, string, flags=0): 从字符串的开头开始匹配指定模式。返回一个匹配对象或 None。

示例：

pattern = r'apple'
text = "apple pie is delicious."
match = re.match(pattern, text)
if match:
    print("Match found:", match.group())
else:
    print("No match found.")

re.findall(pattern, string, flags=0): 返回所有匹配指定模式的子串列表。

示例：

pattern = r'\d+'
text = "There are 123 apples and 456 oranges."
matches = re.findall(pattern, text)
print("Matches:", matches)

re.finditer(pattern, string, flags=0): 返回一个匹配对象的迭代器，用于遍历所有匹配项。

示例：

pattern = r'\d+'
text = "There are 123 apples and 456 oranges."
matches = re.finditer(pattern, text)
for match in matches:
    print("Match found:", match.group())

re.sub(pattern, repl, string, count=0, flags=0): 将匹配指定模式的子串替换为指定的字符串。可选的 count 参数指定替换次数。

示例：
1
2
3
4
pattern = r'\d+'
text = "There are 123 apples and 456 oranges."
replaced_text = re.sub(pattern, 'X', text)
print("Replaced text:", replaced_text)

re.compile(pattern, flags=0): 将正则表达式模式编译为正则表达式对象，以提高性能并重复使用。

示例：

pattern = re.compile(r'\d+')
text = "There are 123 apples and 456 oranges."
matches = pattern.findall(text)
print("Matches:", matches)

Match 对象的方法：
- group(): 返回匹配的字符串。
- start(): 返回匹配的起始位置。
- end(): 返回匹配的结束位置。
- span(): 返回匹配的起始和结束位置。

正则表达式模式：

正则表达式模式是一组字符，用于描述匹配文本的模式。例如，r'\d+' 表示匹配一个或多个数字。正则表达式模式使用特殊字符和语法来描述匹配模式。

以下是一些常见的正则表达式模式元字符和语法：

.：匹配任何字符（除了换行符）。
*：匹配前一个字符零次或多次。
+：匹配前一个字符一次或多次。
?：匹配前一个字符零次或一次。
[]：定义字符集，匹配括号内的任何字符。
()：定义捕获组，用于提取匹配的子字符串。
\d：匹配数字字符。
\w：匹配字母、数字或下划线字符。
\s：匹配空白字符。

正则表达式的详细语法和用法非常广泛，可以根据需要编写复杂的模式来匹配特定的文本模式。根据您的需求，您可以查阅正则表达式的文档和教程来学习更多内容。

1_2_菜鸟教程

Posted on 2024-05-22 Edited on 2024-12-30 In Redis

简介

redis相关笔记

ubuntu apt 命令安装

在 Ubuntu 系统安装 Redis 可以使用以下命令:
1
2
sudo apt update
sudo apt install redis-server
启动 Redis
1
redis-server
查看 redis 是否启动？
1
redis-cli
以上命令将打开以下终端：
1
redis 127.0.0.1:6379>
127.0.0.1 是本机 IP ，6379 是 redis 服务端口。现在我们输入 PING 命令。
1
2
redis 127.0.0.1:6379> ping
PONG
以上说明我们已经成功安装了redis。

Redis配置

Redis 的配置文件位于 Redis 安装目录下，文件名为 redis.conf(Windows 名为 redis.windows.conf)。

你可以通过 CONFIG 命令查看或设置配置项。

语法

Redis CONFIG 命令格式如下：

1	redis 127.0.0.1:6379> CONFIG GET CONFIG_SETTING_NAME

示例

redis 127.0.0.1:6379> CONFIG GET loglevel

1) "loglevel"
2) "notice"

使用 * 号获取所有配置项：

编辑配置

你可以通过修改 redis.conf 文件或使用 CONFIG set 命令来修改配置。

CONFIG SET 命令基本语法：

1	redis 127.0.0.1:6379> CONFIG SET CONFIG_SETTING_NAME NEW_CONFIG_VALUE

实例

redis 127.0.0.1:6379> CONFIG SET loglevel "notice"
OK
redis 127.0.0.1:6379> CONFIG GET loglevel

1) "loglevel"
2) "notice"

Redis 数据类型

Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

String（字符串）
- string 是 redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。
- string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如jpg图片或者序列化的对象。
- string 类型是 Redis 最基本的数据类型，string 类型的值最大能存储 512MB。
- 实例
  1
  2
  3
  4
  redis 127.0.0.1:6379> SET runoob "菜鸟教程"
  OK
  redis 127.0.0.1:6379> GET runoob
  "菜鸟教程"
- 在以上实例中我们使用了 Redis 的 SET 和 GET 命令。键为 runoob，对应的值为菜鸟教程。
- 注意：一个键最大能存储 512MB。

Hash（哈希）

Redis hash 是一个键值(key=>value)对集合。
Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。

实例

redis 127.0.0.1:6379> DEL runoob
redis 127.0.0.1:6379> HMSET runoob field1 "Hello" field2 "World"
"OK"
redis 127.0.0.1:6379> HGET runoob field1
"Hello"
redis 127.0.0.1:6379> HGET runoob field2
"World"

实例中我们使用了 Redis HMSET, HGET 命令，HMSET 设置了两个 field=>value 对, HGET 获取对应 field 对应的 value

List（列表）

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

实例

redis 127.0.0.1:6379> DEL runoob
redis 127.0.0.1:6379> lpush runoob redis
(integer) 1
redis 127.0.0.1:6379> lpush runoob mongodb
(integer) 2
redis 127.0.0.1:6379> lpush runoob rabbitmq
(integer) 3
redis 127.0.0.1:6379> lrange runoob 0 10
1) "rabbitmq"
2) "mongodb"
3) "redis"
redis 127.0.0.1:6379>

Set（集合）

Redis 的 Set 是 string 类型的无序集合。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。
sadd 命令
- 添加一个 string 元素到 key 对应的 set 集合中，成功返回 1，如果元素已经在集合中返回 0。
- sadd key member

实例

redis 127.0.0.1:6379> DEL runoob
redis 127.0.0.1:6379> sadd runoob redis
(integer) 1
redis 127.0.0.1:6379> sadd runoob mongodb
(integer) 1
redis 127.0.0.1:6379> sadd runoob rabbitmq
(integer) 1
redis 127.0.0.1:6379> sadd runoob rabbitmq
(integer) 0
redis 127.0.0.1:6379> smembers runoob

1) "redis"
2) "rabbitmq"
3) "mongodb"

注意：以上实例中 rabbitmq 添加了两次，但根据集合内元素的唯一性，第二次插入的元素将被忽略。

zset(sorted set：有序集合)

Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序
zset的成员是唯一的,但分数(score)却可以重复。
zadd 命令
- 添加元素到集合，元素在集合中存在则更新对应score
- zadd key score member

实例

redis 127.0.0.1:6379> DEL runoob
redis 127.0.0.1:6379> zadd runoob 0 redis
(integer) 1
redis 127.0.0.1:6379> zadd runoob 0 mongodb
(integer) 1
redis 127.0.0.1:6379> zadd runoob 0 rabbitmq
(integer) 1
redis 127.0.0.1:6379> zadd runoob 0 rabbitmq
(integer) 0
redis 127.0.0.1:6379> ZRANGEBYSCORE runoob 0 1000
1) "mongodb"
2) "rabbitmq"
3) "redis"

1_1_学习路线规划

Posted on 2024-05-12 Edited on 2024-12-30 In 软考

简介

备战2024年5月份软件设计师的考试，备考周期为一个半月。

初步学习计划

快速看完一遍视频教程，目的是为了掌握考试的方向和学习的方向
刷题，在看课程的同时刷题，目的是为了高效率的学习，仅看视频是意义不大的。

软件工程基础

Posted on 2024-01-05 Edited on 2025-01-05 In Engineer

简介

软件工程相关学习笔记

Hexo

Posted on 2023-10-19 Edited on 2024-12-30

简介

Hexo 框架的基础知识

在文章中插入图片

绝对路径本地引用
- 当Hexo项目中只用到少量图片时，可以将图片统一放在 source/images文件夹中，通过markdown的语法访问它们

Hexo使用NexT主题设置主页显示文章摘要方法

方法一：在文章中使用
Read more »

Hugo笔记

Posted on 2023-10-19 Edited on 2024-12-30

简介

hugo 框架相关的理论基础知识

hugo框架详解

Hugo是一个用于构建静态网站的开源网站生成器。它以速度和性能为重点，是一个非常受欢迎的静态网站生成器，特别适用于博客、文档和小型到中型网站的构建。下面是对Hugo框架的详细解释：

静态网站生成器：Hugo是一个静态网站生成器，意味着它不需要动态服务器或数据库来生成网页。它将Markdown、HTML、CSS、JavaScript等源文件转换为静态HTML文件，这些文件可以轻松地托管在各种Web服务器上，因此不需要服务器端的处理。
速度和性能：Hugo以速度和性能为特点。它被设计为非常快速的生成器，允许在几秒钟内生成大型网站。这是因为Hugo是用Go编写的，Go是一门高性能的编程语言。
单一二进制文件：Hugo被构建为一个单一的二进制文件，因此安装非常简单。你不需要安装大量依赖或复杂的配置，只需下载适用于你的操作系统的Hugo二进制文件，然后开始使用它。
主题系统：Hugo支持主题，你可以轻松地更改网站的外观和样式。有许多免费和付费的Hugo主题可供选择，或者你可以创建自己的主题。
Markdown支持：Hugo主要使用Markdown格式来编写内容，这使得创建和编辑网站内容非常容易，因为Markdown语法简单直观。
数据驱动：Hugo采用数据驱动的方法，允许你创建各种类型的内容，例如博客文章、页面、菜单等。你可以使用前端数据文件来定义站点内容。
自定义内容类型：Hugo允许你定义自己的内容类型，这意味着你可以创建适合特定需求的内容结构，如项目、事件、产品等。
多语言支持：Hugo支持多语言站点，允许你轻松创建多语言的网站，每个语言版本都可以有自己的内容。
自动部署支持：Hugo与各种部署工具（如Netlify、GitHub Pages等）集成得很好，这使得将生成的静态文件部署到互联网上变得容易。
活跃的社区：Hugo有一个活跃的开发社区，提供了丰富的文档、主题和插件。如果你遇到问题，可以在社区中找到帮助。

总的来说，Hugo是一个强大的静态网站生成器，适用于个人博客、小型企业网站、文档站点等。它的速度、性能和灵活性使其成为一个受欢迎的选择，特别是对于那些寻求简单、高效的网站构建解决方案的人。

hugo框架安装教程详解

Hugo是一个强大的静态网站生成器，可以帮助你创建快速、高性能的网站。以下是Hugo框架的安装教程，详细解释如何在不同操作系统上安装Hugo。

注意：在安装Hugo之前，请确保你已经安装了Git和一个文本编辑器（如VSCode、Sublime Text等），这些工具在创建和管理Hugo网站时非常有用。

在 macOS 上安装 Hugo

打开终端应用。

使用Homebrew安装Hugo。如果你没有安装Homebrew，请首先安装它。

1	/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"

安装Hugo。
1
brew install hugo
验证安装。
1
hugo version

在 Windows 上安装 Hugo

下载Hugo的Windows二进制文件（.exe）：https://github.com/gohugoio/hugo/releases
解压下载的ZIP文件，将hugo.exe文件移动到一个你可以轻松访问的目录。你可以将它放在C:\Hugo或其他自定义目录中。
添加Hugo的可执行文件路径到系统环境变量：
- 在Windows搜索框中，输入”环境变量”，并选择”编辑系统环境变量”。
- 在”系统属性”窗口中，点击”高级”选项卡，然后点击”环境变量”按钮。
- 在”系统变量”部分，找到”Path”，并点击”编辑”。
- 在”编辑环境变量”窗口中，点击”新建”，并添加Hugo的可执行文件路径，比如C:\Hugo。
- 点击”确定”，保存更改。
验证安装。

打开命令提示符（CMD）或PowerShell，并运行：
1
hugo version

在 Linux 上安装 Hugo

在大多数Linux发行版中，你可以使用包管理器来安装Hugo。以下是一些示例：

使用 apt-get（Debian/Ubuntu）

1 2	sudo apt-get update sudo apt-get install hugo

使用 yum（CentOS/RHEL）

1 2	sudo yum install epel-release sudo yum install hugo

使用 pacman（Arch Linux）

1	sudo pacman -S hugo

使用 snap（通用Linux）

如果你的发行版支持Snap包，你可以使用Snap来安装Hugo。

1	sudo snap install hugo

从源代码编译

如果没有包管理器支持或你想要编译Hugo的最新版本，你可以从源代码编译Hugo。请参考Hugo的官方文档以获取更多信息：https://gohugo.io/getting-started/installing/#source

验证安装

无论你使用哪种操作系统，安装完成后，你可以打开终端或命令行界面并运行以下命令来验证Hugo是否正确安装：

1	hugo version

如果Hugo已成功安装，它将显示版本信息。

一旦你成功安装了Hugo，你就可以开始使用它来创建和管理静态网站。你可以按照前面提到的示例或Hugo的官方文档来创建自己的网站。

简介

python3 numpy库 详解

python3 numpy库 常用技巧

python3 numpy.transpose() 函数 详解

语法

返回值

示例

指定轴顺序

简介

python3 logging模块 输出到文件并且输出到终端

python3 logging模块 详解

基本日志记录示例

日志处理器（Handlers）

日志过滤器（Filters）

自定义日志记录器

简介

python3 Opencv 模块 详解

安装OpenCV

导入OpenCV模块

加载和显示图像

图像处理

视频处理

简介

python3 Paramiko模块 详解

安装 Paramiko

使用 Paramiko 连接到远程服务器

使用 SSH 密钥对连接

使用 SFTP 进行文件传输

简介

python3 psutil 模块 详解

安装

基本用法

简介

python3 subprocess模块 详解

执行外部命令

创建新进程

进程间通信

等待进程结束

其他函数和属性

简介

python threading 判断多个线程是否完成

方法 1：使用 join() 等待所有线程完成

方法 2：循环检查 is_alive()

方法 3：使用 Event 对象通知主线程

选择合适的方法

python3 threading库 启动线程函数并传递参数

使用 args 和 kwargs 传递参数

示例代码

输出示例

注意事项

python3 threading 模块 详解

python3 threading模块 传入一个参数

python3 threading模块 将线程分离到后台

简介

python3 torchvision是什么

python3 torchvision详解

简介

python3 transform3d模块 详解

安装transforms3d库

主要模块和功能

1. transforms3d.euler

2. transforms3d.quaternions

3. transforms3d.axangles

4. transforms3d.zooms

python3 输出旋转轴和旋转角 得到旋转矩阵

简介

python3 scipy模块 是什么

python3 scipy模块 详解

python3 scipy.spatial 详解

简介

redis是什么

Redis(维基百科)

数据库 redis 详解

linux redis C++相关工具库

linux redis开发结构是什么样的

redis的用途 详解

1. 缓存：

2. 数据库：

3. 分布式锁：

4. 消息队列：

python3 numpy库详解

python3 numpy库常用技巧

python3 numpy.transpose() 函数详解

python3 logging模块输出到文件并且输出到终端

python3 logging模块详解

python3 Opencv 模块详解

python3 Paramiko模块详解

python3 psutil 模块详解

python3 subprocess模块详解

方法 1：使用 `join()` 等待所有线程完成

方法 2：循环检查 `is_alive()`

方法 3：使用 `Event` 对象通知主线程

python3 threading库启动线程函数并传递参数

使用 `args` 和 `kwargs` 传递参数

python3 threading 模块详解

python3 threading模块传入一个参数

python3 threading模块将线程分离到后台

python3 transform3d模块详解

1. `transforms3d.euler`

2. `transforms3d.quaternions`

3. `transforms3d.axangles`

4. `transforms3d.zooms`

python3 输出旋转轴和旋转角得到旋转矩阵

python3 scipy模块是什么

python3 scipy模块详解

redis的用途详解

redis报文详解

python3 pycuda库详解

python3 re模块详解

方法一：在文章中使用
Read more »

hugo框架详解

hugo框架安装教程详解