Hugo 介绍

Hugo 是一个用 Go 语言编写的开源静态网站生成器，因其卓越的性能和易用性而受到广泛欢迎。它允许用户通过简单的命令行操作快速构建、部署个人博客、文档站点或其他类型的静态内容网站。Hugo 支持无限的内容类型、自定义分类法以及多种内置的短代码（shortcodes），使得内容创建变得异常简单。此外，它还拥有强大的主题系统，用户可以从丰富的官方及社区贡献的主题中选择适合自己的风格进行定制。

• 官方网站: https://gohugo.io/
  在这里你可以找到详细的文档、教程和支持论坛，帮助你从初学者成长为专家。

• 源码仓库: https://github.com/gohugoio/hugo
  Hugo 的源码托管在 GitHub 上，任何人都可以参与贡献或提出问题。

• 快速入门: https://gohugo.com.cn/getting-started/quick-start/
  学习在几分钟内创建一个 Hugo 站点。

• Hugo-Next主题: https://themes.gohugo.io/themes/hugo-theme-next
  Easily & powerful theme for Hugo engine.

• Hugo-Next-Gitee: https://gitee.com/hugo-next/hugo-theme-next/
  «Hugo NexT» 是一款高质量且优雅的 Hugo 主题，从原来 Hexo 引擎的 NexT 主题中移植过来，继续保留其经典的设计和 4 种不同页面布局模式，一切因 重新出发愿你也能喜欢。

Hexo 和 Hugo 的对比

以下是 Hexo 和 Hugo 的主要功能和特性对比：

计划：将 Hexo 转换为 Hugo

考虑到当前时间限制（2025年3月27日星期四11时27分），暂时记录下将 Hexo 转换为 Hugo 的计划。待有更充裕的时间时，我们可以开始这个转换过程。

Hexo 是另一个流行的静态网站生成器，但 Hugo 因其更快的速度和更大的灵活性可能更适合我们的需求。在转换过程中，我们需要注意以下几点：

1. 保持现有内容的完整性
   确保所有文章、页面和媒体文件都完整迁移到 Hugo。

2. 调整主题和样式
   根据 Hugo 的主题系统重新适配或选择新的主题。

3. 插件和功能迁移
   将 Hexo 中使用的插件功能替换为 Hugo 的等效实现。

4. 测试与优化
   完成迁移后，进行全面的测试，确保网站运行正常，并根据需要进行优化。

待方便时再执行具体步骤。

__init__.py 是 Python 中一个特殊的文件命名规则，它的存在和作用与 Python 的模块和包（module and package）系统密切相关。以下是关于 __init__.py 命名规则及其作用的详细说明：

1. 命名规则

• 文件名必须是 __init__.py。
• 它是一种特殊命名约定，Python 解释器会将其视为一个标志，用于标识某个目录是一个 包（package）。

2. 作用

（1）标识包

在 Python 3.3 之前，如果一个目录中没有 __init__.py 文件，Python 不会将其识别为一个包。换句话说，__init__.py 是一个包的“入口标志”。

例如：

1
2
3
4

my_package/
    init.py
    module1.py
    module2.py

在上述结构中，my_package 被视为一个包，可以通过 import my_package 或 from my_package import module1 来使用。

（2）初始化代码

__init__.py 文件可以包含代码，这些代码会在包被导入时自动执行。通常用于： - 初始化包的状态。 - 设置包级别的变量。 - 控制包的导出内容（通过 __all__ 变量）。

示例：

1
2
3
4
5
6
7
8
9
10
11
12

# my_package/__init__.py
print("Initializing my_package...")

# 导入子模块
from .module1 import MyClass
from .module2 import my_function

# 定义包级别的变量
version = "1.0"

# 定义默认导出内容
__all__ = ["MyClass", "my_function"]

当导入 my_package 时，__init__.py 中的代码会被执行：

1
2

import my_package
# 输出: Initializing my_package...

（3）控制导入行为

__init__.py 文件可以通过定义 __all__ 列表来控制 from package import * 行为。__all__ 指定了哪些模块或对象可以被 * 导入。

示例：

1
2
3
4
5

# my_package/__init__.py
__all__ = ["module1", "my_function"]

from my_package import *
# 只会导入 module1 和 my_function

3. Python 3.3+ 的变化

从 Python 3.3 开始，引入了隐式命名空间包（Implicit Namespace Packages），即使目录中没有 __init__.py 文件，Python 也可以将其识别为包。这种特性主要用于支持跨多个项目的大型命名空间包。

例如：

1
2
3
4
5

namespace_package/
    subpackage1/
    module1.py
    subpackage2/
    module2.py

在这种情况下，即使没有 __init__.py，namespace_package.subpackage1 和 namespace_package.subpackage2 仍然可以被正确导入。

然而，为了兼容性和明确性，许多开发者仍然选择显式地添加 __init__.py 文件。

4. 最佳实践

• 显式优于隐式：尽管 Python 3.3+ 支持隐式命名空间包，但显式地添加 __init__.py 文件可以让代码更具可读性和兼容性。
• 保持简洁：__init__.py 文件应尽量简单，避免包含复杂的逻辑。
• 定义导出内容：通过 __all__ 明确指定包的公共接口。

总结

__init__.py 的命名规则是 Python 的约定，用于标识一个目录为包，并提供初始化代码和控制导入行为的功能。虽然在 Python 3.3+ 中不再是强制要求，但它仍然是组织代码和提升可维护性的良好实践。

在现代软件开发中，代码复用是提高效率和减少重复劳动的关键。无论是通过内置的库文件还是自定义的通用模块，开发者都可以利用这些资源来加速开发过程。本文将探讨编程语言中的库使用机制，以及如何实现跨语言的功能共享。

内置库与自定义库

内置库

大多数编程语言都提供了丰富的标准库，这些库包含了预先编写好的功能模块，可以直接在写程序时使用，并且在运行或编辑时自动调用。例如，Python的标准库提供了大量的模块用于处理文件、网络通信等常见任务；Shell脚本则可以通过系统命令快速完成自动化任务。

自定义库

对于自己编写的用于多个程序的通用模块，通常需要以库的形式保存。这样做的好处是显而易见的：一旦某个库更新了，所有依赖它的程序只需重新加载或编译即可享受到最新的改进。这大大简化了代码维护工作。

• 脚本语言：如Python、Shell等，可以通过简单的导入语句（如import或source）直接加载并使用自定义库。
• 编辑型语言：如Rust等，会将库加载到源文件中，在编译时封存进目标文件，避免了对自定义特定程序的过多依赖。

跨语言调用的挑战与解决方案

尽管在同一语言内使用库非常方便，但在不同语言之间直接调用库通常是不可能的，因为每种语言都有其独特的语法和运行时环境。然而，通过一些策略可以实现跨语言的功能共享。

将特殊功能封装成函数

一种常见的做法是将特殊功能封装成独立的函数或服务，然后在其他程序中直接调用这些函数或服务来获取相关值。这种方法不仅适用于脚本语言，也可以应用于编辑型语言。

示例场景

• 网络服务：将某些计算密集型任务封装为RESTful API服务，任何支持HTTP请求的语言都可以轻松调用。
• CLI工具：将功能封装为命令行工具，其他语言可以通过子进程调用来执行该工具并捕获输出结果。

动态链接库

另一种方法是创建动态链接库（如.so或.dll文件），这些库通常用C或C++编写，因为它们具有较低级别的ABI（应用二进制接口）。许多编程语言都支持加载这类动态库，从而实现一定程度上的跨语言调用。

文件或消息队列

此外，还可以通过文件交换或消息队列进行数据传递。比如，一个程序生成JSON格式的数据文件，另一个程序读取并处理这些文件；或者使用RabbitMQ、Kafka等消息队列系统实现异步消息传递。

不同语言使用共同程序片段的方法举例: Python 和 Shell

本节探讨Python和Shell语言通过模块化设计来实现共同程序片段的使用具体方法。

Python：模块与包

在 Python 中，代码复用是通过模块化设计实现的。通过将常用的代码片段封装到模块或包中，开发者可以在不同的程序中轻松地复用这些功能。本节将详细介绍 Python 中使用共同程序片段的方法，包括模块、包以及跨项目复用的最佳实践。

1. 模块（Module）

什么是模块？

模块是一个包含 Python 代码的文件，通常以 .py 为扩展名。模块可以定义函数、类和变量，并且可以通过 import 语句导入到其他脚本中。

创建模块

假设我们有一个常用的功能，比如打印问候语。可以将其封装到一个模块中：

1
2
3
4
5
6

# utils.py
def say_hello(name):
    print(f"Hello, {name}!")

def add_numbers(a, b):
    return a + b

使用模块

在另一个脚本中，可以通过 import 或 from ... import 引入模块并调用其中的功能：

1
2
3
4
5
6

# main.py
from utils import say_hello, add_numbers

say_hello("Alice")  # 输出: Hello, Alice!
result = add_numbers(5, 3)
print(f"5 + 3 = {result}")  # 输出: 5 + 3 = 8

2. 包（Package）

包是一种组织模块的方式，用于管理大型项目中的代码。包是一个包含多个模块的目录，并且必须包含一个名为 __init__.py 的文件（Python 3.3 及以上版本中可省略）。

创建包

假设我们有多个模块，可以将它们组织成一个包。例如：

1
2
3
4

my_package/
    __init__.py
    utils.py
    math_ops.py

• utils.py

  1 2	def say_hello(name): print(f"Hello, {name}!")

• math_ops.py

  1 2	def multiply(a, b): return a * b

使用包

在脚本中可以通过包路径导入模块中的功能：

1
2
3
4
5
6
7

# main.py
from my_package.utils import say_hello
from my_package.math_ops import multiply

say_hello("Bob")  # 输出: Hello, Bob!
result = multiply(4, 6)
print(f"4 * 6 = {result}")  # 输出: 4 * 6 = 24

3. 跨项目复用：发布到PyPI

如果需要在多个项目之间共享代码，可以将模块或包打包为一个 Python 包并发布到 PyPI（Python Package Index）。

• 创建包结构, 创建一个符合 Python 包规范的目录结构。例如：

  1 2 3 4 5

  my_library/ setup.py my_library/ __init__.py utils.py

• 编写setup.py, 在根目录下创建 setup.py 文件，用于描述包信息：

  1 2 3 4 5 6 7

  from setuptools import setup, find_packages setup( name="my_library", version="0.1", packages=find_packages(), )

• 发布到PyPI, 使用以下命令将包发布到 PyPI：

  1 2	python setup.py sdist bdist_wheel twine upload dist/*

• 安装并使用，在其他项目中通过 pip 安装并使用该包：

  1	pip install my_library

  然后在代码中导入：

  1 2	from my_library.utils import say_hello say_hello("Charlie") # 输出: Hello, Charlie!

4. 其他方法

4.1 动态加载模块

如果需要动态加载模块，可以使用 importlib 库。例如：

1
2
3
4
5

import importlib

module_name = "utils"
module = importlib.import_module(module_name)
module.say_hello("Dynamic User")  # 输出: Hello, Dynamic User!

4.2 配置文件与环境变量

对于一些配置相关的代码片段，可以使用配置文件（如 JSON、YAML）或环境变量来实现复用。例如：

1
2
3
4
5
6

import json

with open("config.json", "r") as f:
    config = json.load(f)

print(config["greeting"])  # 输出: Hello, World!

Shell 使用共同程序片段的方法

在 Shell 脚本编程中，复用代码片段是提高效率和减少重复劳动的重要手段。通过将常用的功能封装到函数库文件中，开发者可以在多个脚本中轻松地共享这些功能。本文将详细介绍 Shell 中使用共同程序片段的方法，包括函数库的创建、加载以及全局配置的最佳实践。

1. 函数库的基本概念

什么是函数库？

函数库是一个包含一组 Shell 函数的文件，通常以 .sh 为扩展名。通过将常用的功能封装成函数并存储在单独的文件中，开发者可以在多个脚本中复用这些功能。

2. 创建函数库

定义函数库

创建一个包含常用函数的文件，例如 functions.sh：

1
2
3
4
5
6
7
8
9
10
11

# functions.sh

# 打印问候语
say_hello() {
    echo "Hello, $1!"
}

# 计算两个数的和
add_numbers() {
    echo $(( "$1" + "$2" ))
}

3. 加载函数库

在其他脚本中可以通过 source 或 . 命令加载函数库，并调用其中的函数。

1
2
3
4
5
6
7
8
9

#!/bin/bash

# 加载函数库
source ./functions.sh

# 调用函数
say_hello "Alice"       # 输出: Hello, Alice!
result=$(add_numbers 5 3)
echo "5 + 3 = $result"  # 输出: 5 + 3 = 8

4. 全局函数库

如果希望某些函数在整个系统中都可以使用，可以将函数库文件放到一个通用目录（如 /usr/local/lib），然后在用户的 .bashrc 或 .bash_profile 中加载。操作步骤：

• 将函数库文件放到通用目录: 假设你将 functions.sh 放到了 /usr/local/lib/functions.sh。

• 在.bashrc中加载函数库：编辑用户的.bashrc文件，添加以下内容：

  1 2 3

  if [ -f /usr/local/lib/functions.sh ]; then source /usr/local/lib/functions.sh fi

• 使更改生效：

  1	source ~/.bashrc

• 直接在终端或脚本中使用函数：现在，你可以在任何地方直接调用这些函数，而无需显式加载函数库。

5. 动态加载函数库

如果需要根据需求动态加载不同的函数库，可以使用环境变量来指定函数库的路径。例如：

1
2
3
4
5
6
7

# 设置环境变量
export FUNCTION_LIB_PATH="/path/to/functions.sh"

# 在脚本中动态加载
if [ -f "$FUNCTION_LIB_PATH" ]; then
    source "$FUNCTION_LIB_PATH"
fi

6. 将功能封装为独立脚本

除了函数库，还可以将某些功能封装为独立的脚本文件，并通过子进程调用来获取结果。例如：

• 创建一个名为greet.sh的脚本：

  1 2	#!/bin/bash echo "Hello, $1!"

• 确保脚本具有执行权限：

  1	chmod +x greet.sh

• 在其他脚本中调用：通过子进程调用该脚本并捕获输出

  1 2 3 4

  #!/bin/bash result=$(./greet.sh "Alice") echo "$result" # 输出: Hello, Alice!

7. 注意事项

• 避免命名冲突：函数名应尽量具有唯一性，以免与其他脚本或系统命令发生冲突。
• 检查文件是否存在：在加载函数库时，建议先检查文件是否存在，以避免出错。例如

  1 2 3 4 5

  if [ -f "./functions.sh" ]; then source ./functions.sh else echo "Function library not found!" fi

• 权限问题：如果函数库文件位于系统目录（如 /usr/local/lib），确保文件具有适当的权限。

总结

无论是通过内置库还是自定义库，编程语言都提供了一套机制来促进代码复用。对于同一语言内的库调用相对简单，但对于跨语言调用，则需要借助标准化的接口或协议。理解这些基本原理有助于我们更好地设计和组织代码，同时也能在面对复杂系统时找到合适的解决方案。

掌握如何有效地使用库以及如何跨越语言障碍实现功能共享，是每个程序员应当具备的核心技能之一。希望本文能为您提供有价值的见解，并帮助您更高效地进行软件开发。

简介

keysudo.sh是一个用于安全存储和调用 sudo 密码的 Bash 脚本工具，通过 GNOME Keyring 实现敏感信息的加密存储。脚本设计目标是通过密钥环系统减少密码的明文暴露，同时解决 sudo 验证失败导致的账户锁定问题。

主要功能

• 🔐 自动将 sudo 密码存储至 GNOME Keyring
• 🔄 支持 3 次验证尝试（可配置）
• ⚠️ 智能检测系统环境（支持 Arch/RHEL 系）
• 🔒 密码输入支持 systemd-ask-password 工具
• 🛡️ 密码错误时自动重置 sudo 失败计数
• 🚫 杜绝密码明文存储和传输

快速使用

基础用法

1
2
3
4
5
6

# 获取密码（自动触发存储流程）
syndns_password=$(./keysudo.sh)

# 使用示例（建议立即清理变量）
echo $syndns_password | sudo -S your_command
unset syndns_password

安装依赖

1
2
3
4
5

# Arch 系系统
sudo pacman -S pambase libsecret

# RHEL/CentOS 系系统
sudo yum install pam libsecret-tools

卸载密码

1

secret-tool clear syndns_password_key syndns_password

常见问题

Q1: 密码无法存储到密钥环

1
2
3
4

# 检查密钥环服务状态
gnome-keyring-daemon --start
# 验证存储功能
echo "test" | secret-tool store --label="Test" test_key test_value

Q2: sudo 被锁定后如何处理

1
2
3
4
5

# 显示当前失败计数（RHEL系）
sudo pam_tally2 --user $USER

# 强制解锁所有用户（Arch系）
sudo faillock --reset

程序源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

#! /bin/bash
#
# Program  : keysudo.sh
# Author   : Zhen-Hua Feng(冯振华)
# Email    : fengzhenhua@outlook.com
# Date     : 2025-01-10 20:41
# CopyRight: Copyright (C) 2025--
# License  : Distributed under terms of the MIT license.
#
# 定义标识符
SYN_KEY="syndns_password"  # 密钥环中的唯一标识符
SYN_SUDO_NUM_MAX="3"       # 确保这个数值与您系统中sudo验证次数一致，以免进入死循环
# 检测依赖，确保secret-tool正确安装
if ! command -v secret-tool &>/dev/null; then
  echo "错误：需要安装 secret-tool（包名：libsecret-tools）" >&2
  exit 1
fi
# 探测系统sud解锁程序
SYN_RES_CMD=""
if command -v faillock &>/dev/null; then
    SYN_RES_CMD="faillock --user $USER --reset"
elif command -v pam_tally2 &>/dev/null; then
    SYN_RES_CMD="pam_tally2 --user $USER --reset"
else
    echo "错误：未找到可用SUDO解锁工具 !" >&2
    echo "请安装：Arch系安装pambase，RHEL系安装pam" >&2
    exit 1  # 正确终止脚本
fi
# 存储密码到 GNOME Keyring
# 测试密码过程中存在sudo次数限制，如果sudo被锁定了，那本脚本在首次没有完成密码保存的工作后将处于锁定状态
SYN_KEY_GET(){
    local SYN_AMT="$SYN_SUDO_NUM_MAX"
    while [[ "$SYN_AMT" -gt 0 ]]; do
        SYN_KEY_X=$(secret-tool lookup syndns_password_key "$SYN_KEY")
        if [[ -z "$SYN_KEY_X" ]]; then
            unset SYN_KEY_DATA
            # 使用专业密码输入工具
            if command -v systemd-ask-password &>/dev/null; then
                SYN_KEY_DATA=$(systemd-ask-password --timeout=30 "请求sudo密码:")
            else
                printf "$0 请求输入sudo密码(30秒超时):" >&2
                # 增加超时后的清理逻辑
                if ! read -rs -t 30 SYN_KEY_DATA; then
                    printf "\n输入超时，操作取消。\n" >&2
                    unset SYN_KEY_DATA
                    exit 1
                fi
            fi
            if [[ -z "$SYN_KEY_DATA" ]]; then
                printf "\n密码不能为空，请重新输入。\n" >&2
            else
                if printf "%s" "$SYN_KEY_DATA" | secret-tool store --label="Syndns Password" syndns_password_key "$SYN_KEY"; then
                    sudo -k
                    if printf "%s" "$SYN_KEY_DATA" | sudo -S -v 2>/dev/null; then
                        # 存储成功后立即清理
                        unset SYN_KEY_DATA
                        printf "\n密码已成功存储到 GNOME Keyring 中。\n" >&2
                        return 0
                    else
                        SYN_AMT=$((SYN_AMT - 1))
                        SYN_FAIL_RES "警告：当前系统可能需要手动重置失败计数!"
                    fi
                else
                    printf "\n无法存储密码，请检查 GNOME Keyring 是否可用。\n" >&2
                    exit 1
                fi
            fi
        else
            sudo -k
            if ! printf "%s" "$SYN_KEY_X" | sudo -S -v 2>/dev/null; then
                SYN_AMT=$((SYN_AMT - 1))
                secret-tool clear syndns_password_key "$SYN_KEY" # 清空密码，重新循环才能进入设置
                SYN_FAIL_RES "警告：当前系统可能需要手动重置失败计数!"
            else
                return 0
            fi
        fi
    done
    printf "尝试次数已达上限，操作终止。\n" >&2
    SYN_FAIL_RES "请切换至ROOT权限解除锁定: $SYN_RES_CMD"
    exit 1
}
SYN_FAIL_RES(){
    if grep -qi 'arch' /etc/os-release 2>/dev/null; then
        faillock --user $USER --reset
    else
        # 优先显示传入的定制化提示
        printf "$1 \n" >&2
        # 补充建议命令（带sudo前缀）
        [ -n "$SYN_RES_CMD" ] && echo "可尝试执行: sudo $SYN_RES_CMD" >&2
    fi
}
sudo -k  # 清除sudo缓存
SYN_KEY_GET
echo $SYN_KEY_X

ArchLinux是一款备受推崇的Linux发行版，以其滚动更新机制、最新软件包支持和高度可定制性而闻名。然而，在使用Paru从AUR（Arch User Repository）安装软件时，很多用户遇到了因依赖于GitHub上的资源无法访问而导致的问题。为了解决这一挑战，我最初开发了名为“ParuAxel.sh”的脚本，以帮助用户更顺畅地安装软件。

随着进一步的优化升级，我决定采用更为高效的多线程下载工具Aria2，并对脚本进行了全面改进。为了更好地反映这些变化，我将这个新版本的脚本重命名为“Paria.sh”。通过使用Aria2，“Paria.sh”不仅解决了由于网络限制导致的GitHub资源访问问题，还大幅提升了下载速度与稳定性，为用户提供了一个更加流畅可靠的软件包管理体验。

“Paria.sh”专注于增强ArchLinux用户的AUR软件安装过程，使得即使面对复杂的依赖关系或网络波动，也能轻松完成软件的下载与安装。它体现了我对提升用户体验的持续努力，旨在让每一位ArchLinux用户都能享受更加高效便捷的软件管理过程。

Paria.sh脚本及其配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#! /bin/sh
#
# Program: Paria.sh
# Version: V2.0
# Author : Zhen-Hua Feng
# Email  : fengzhenhua@outlook.com
# Date   : 2025-03-24 11:45
# Copyright (C) 2023-2025 feng <feng@arch>
#
# Distributed under terms of the MIT license.
#
GIT_DOMIN=`echo "$2" | cut -f3 -d'/'`;
GIT_OTHER=`echo "$2" | cut -f4- -d'/'`;
GIT_INIT="https://github.com/"
DNS_SERVERS="1.0.0.1,1.0.0.2,1.0.0.3"
GCF=/home/$USER/.gitconfig
GIT_SIT=($(grep -oP '\[url\s+"\Khttps://[^"]+' $GCF))
mirror_available() {
    local url="$1"
    if curl -fsL --max-time 5 --head "$url" >/dev/null 2>&1; then
        return 0
    else
        return 1
    fi
}
case "$GIT_DOMIN" in
    "github.com")
        GIT_URL="$2"
        echo "Download from mirror $GIT_URL";
        /usr/bin/aria2c --async-dns-server="$DNS_SERVERS" --split=12 --max-connection-per-server=15 -k 1M --auto-file-renaming=false -o "$1" "$GIT_URL" ;
        if [[ $? -ne 0 ]]; then
            echo "[WARN] GitHub 原始地址下载失败，启动镜像检测..."
            if [ -e $GCF ]; then
                GIT_SIT=($(grep -oP '\[url\s+"\Khttps://[^"]+' $GCF))
                for mirror in "${GIT_SIT[@]}"; do
                    if [[ "${mirror}" =~ "/$" ]]; then
                        GIT_URL="${mirror}${GIT_PATH}"
                    else
                        GIT_URL="${mirror}/${GIT_PATH}"
                    fi
                    if mirror_available "${GIT_URL}"; then
                        /usr/bin/aria2c --split=12 --max-connection-per-server=15 -k 1M --auto-file-renaming=false -o "$1" "$GIT_URL" ;
                        if [[ $? -eq 0 ]]; then
                            exit 0  # 下载成功则退出
                        else
                            echo "[ERROR] 镜像下载失败: $GIT_URL (状态码: $?)" >&2
                        fi
                    fi
                done
            fi
            # 所有镜像失败后直接退出（不回退 GitHub）
            echo "[FATAL] 所有下载尝试失败，请检查网络或镜像配置"
            exit 1
        fi
        ;;
    *)
        /usr/bin/aria2c --split=12 --max-connection-per-server=15 -k 1M --auto-file-renaming=false -o "$1" "$2" ;
        ;;
esac

1
2
3
4
5
6

DLAGENTS=('file::/usr/bin/curl -qgC - -o %o %u'
          'ftp::/usr/bin/aria2c -s 15 -x 15 -k 1M --auto-file-renaming=false -o %o %u'
          'http::/usr/bin/aria2c -s 15 -x 15 -k 1M --auto-file-renaming=false -o %o %u'
          'https::/usr/bin/Paria %o %u'
          'rsync::/usr/bin/rsync --no-motd -z %u %o'
          'scp::/usr/bin/scp -C %u %o')

1
2
3
4
5
6
7
8
9
10
11
12
13

#! /bin/sh
#
# 项目：install.sh
# 版本：V1.4
# Copyright (C) 2023 feng <feng@arch>
# Distributed under terms of the MIT license.
#
sudo pacman -S --needed --noconfirm aria &> /dev/null
sudo cp ./makepkg.conf /etc/makepkg.conf
sudo cp ./Paria.sh  /usr/bin/Paria
sudo chmod 755 /usr/bin/Paria
echo "Paria 安装成功，paru配置完毕 !! "
exit

ParuAxel 与 Paria 功能对比

Git克隆修改为SSH

由于在执行依赖安装时，有时候Paru会调用git clone 命令，但是默认是从 https://github.com 克隆仓库，而当它无法访问时可以尝试配置好ssh后采用ssh方法来克隆，于是全局修改https://github.com为git@github.com:github.com.

1
2
3
4
5
6
7

[user]
	email = YourEmail
	name = YourName
[url "git@github.com:"]
	insteadOf = https://github.com/
[init]
	defaultBranch = main

通过浏览器登录路由的方法

1. 确保连接：首先，确保你的设备（如电脑或手机）已经连接到你想要管理的网络。

2. 打开浏览器：在你的设备上打开一个网页浏览器（如Chrome、Firefox等）。

3. 输入IP地址：在浏览器的地址栏中输入图片中显示的默认路由IP地址 192.168.50.1，然后按回车键。

4. 登录界面：你会看到一个登录界面，要求你输入用户名和密码。这些信息通常可以在路由器的说明书上找到，或者使用默认的用户名和密码（如 admin/admin）。如果你之前修改过这些信息，那么请输入你之前设置的用户名和密码。

5. 进入管理界面：成功登录后，你将进入路由器的管理界面，在这里你可以进行各种设置，如更改无线网络名称（SSID）、设置密码、调整安全设置等。

查询默认路由

在不同操作系统中，可以通过图形界面（GUI）轻松查询默认路由（即默认网关）, 具体操作步骤:

• Windows：通过“网络和共享中心” → 当前连接 → “详细信息” 查看默认网关。
• Linux：通过网络设置 → 当前连接 → IPv4 设置 查看默认网关。
• macOS：通过“网络”设置 → 当前连接 → “高级” → “TCP/IP” 查看路由器地址。

通过这些图形界面操作，你可以轻松找到默认路由（即路由器的 IP 地址）。

Linux发行版的基本使用

Linux发行版性能对比（截至2024年）

一、通用性能（基于AMD锐龙9 9950X）

二、服务器性能（企业级场景）

三、桌面/开发性能

四、其他关键性能维度

硬件兼容性

轻量级性能

安全性能

总结建议

• 极致性能：Clear Linux（x86优化最佳）或 CachyOS（轻量快速）。
  
• 通用场景：Ubuntu LTS（新手首选）或 Manjaro（Arch友好版）。
  
• 服务器：Rocky Linux/AlmaLinux（RHEL兼容，稳定性最佳）。
  
• 开发者：Arch Linux（滚动更新）或 Fedora（前沿技术）。
  
• 老旧硬件：MX Linux 或 veket（资源高效）。

星标说明：
★★★★★：性能最优，推荐首选；
★★★★☆：性能优秀，适合特定场景；
★★★☆☆：性能中等，平衡性较好；
★★☆☆☆：性能较弱，需谨慎选择。

在Linux环境中，了解如何有效地查询和展示系统信息是非常重要的。无论是为了调试、监控还是单纯地想了解更多关于你正在使用的硬件和软件的信息，下面列出的一系列命令和工具都将对你有所帮助。

符号说明：✅需要安装，❌无需安装，🔑需sudo权限，🔓无需sudo权限。

系统级硬件信息

CPU信息

存储设备

网络信息

GPU/显卡信息

主板和BIOS

USB设备

温度和传感器

其他设备

系统版本查询

关键说明

1. Fetch类工具：
   • fastfetch：高性能跨平台工具，推荐优先使用。
   • hyfetch：支持主题定制，适合个性化需求。
   • neofetch/screenfetch：经典工具，但前者已停止维护。
2. 专业检测工具：
   • hwinfo：详细硬件检测（需安装，支持传感器）。
   • lshw：综合硬件树状信息（支持XML/HTML输出）。
   • dmidecode：BIOS/主板深度信息（需root权限）。
3. 网络与存储：
   • ethtool：网卡参数调整（需sudo）。
   • smartctl：硬盘健康状态检测（需smartmontools）。
4. 系统版本：
   • /etc/os-release：标准系统版本文件，跨发行版通用。

安装建议

• 基础工具：sudo pacman -S lshw dmidecode neofetch inxi
• 进阶工具：sudo pacman -S hwinfo smartmontools nvidia-smi
• Fetch类：sudo pacman -S fastfetch hyfetch

关于蒙特卡洛方法，我已经连续发布了三篇博文：

• 使用蒙特卡洛方法计算圆周率
• 蒙特卡洛方法计算圆周率：积分公式选择的方差分析
• 蒙特卡洛方法计算圆周率的一个高精度公式

在第一篇文章中我们探讨了蒙特卡洛方法使用面积法计算圆周率的经典案例，对MC方法有了一个初步的认识，在第二篇文章中我们在MC方法中使用不同的公式计算圆周率，得到了影响MC方法精度的条件，在第三篇文章中根据第二篇文章得到的条件实现了高精度计算圆周率的一个公式，从而验证了提高MC精度的条件。本文进一步，基于第三篇文章，在程序实现上将写死的程序代码以循环程序自动化。同时，引入mpmath库，实现迭代求根式的精度拓展，但是仍然使用numpy进行随机采样。

Python3 代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#! /usr/bin/env python3
# vim:fenc=utf-8
import numpy as np
from mpmath import mp, mpf
# 修改为 40 位十进制精度
mp.dps = 40

# 定义函数f(x)
def f(x):
    return 1/(1-x**2)**0.5

# Monte Carlo方法求积分
def monte_carlo_integral(f, m, b, num_samples=1000):
    # 根据半角公式用m设定嵌套次数
    count = 0
    while count < m:
        b = mp.sqrt(1/2-mp.sqrt(1-b**2)/2)
        count +=1
    # 先用半角公式根据b计算a
    a = mp.sqrt(1/2-mp.sqrt(1-b**2)/2)
    # 在区间[a, b]内随机生成num_samples个样本点
    samples = np.random.uniform(a, b, num_samples)
    
    # 计算这些样本点对应的函数值
    y_values = f(samples)
    
    # 根据平均高度估计积分值，乘以区间的宽度得到近似面积
    integral_estimate = 2**(m + 3)*(b - a) * np.mean(y_values)
    
    return integral_estimate

# 使用Monte Carlo方法估计积分
estimated_integral = monte_carlo_integral(f,42, mp.sqrt(2)/2)

print("Pi", estimated_integral)

计算结果

• 运行程序得到的结果： 3.14159265358979313874736836854190094502
• 资源消耗情况： 0.08s user 0.02s system 98% cpu 0.099 total
• 按现有资料\(\pi\)的前20位精确结果为3.1415926535 8979323846, 对比可知我们的程序可以精确到小数点后15位, 用时仅0.08s, 所以这是一个不错的结果。

优化的细节

• 动态精度控制：通过循环，使用参数m灵活调整精度(如m=42时，区间极小，方差极低）。
• 高效性：样本需求低(1000), 计算速度快。
• 可拓展性：增加m可进一步提高精度，代码结构清晰，易于维护。

通过文章蒙特卡洛方法计算圆周率：积分公式选择的方差分析， 我们可以得到提高蒙特卡洛方法计算精度的方法：

1. 确保函数的平滑性，这样可以减少方差，于是每次随机点都更加接近平均值。
2. 减少积分区间，这样同样的随机点数，采样密度更高，有效点更多，所以误差更小。

半角公式的选择

本文就来验证这两条规则，于是仍然选择反正弦三角函数，但是使用半角公式不断减小积分区间, 于是我们选择了\(\frac{\pi}{24576}\)作为积分值，即取积分:

\[ \pi=24576\int_0^b\frac{1}{\sqrt{1-x^2}}dx\]

其中\(b\)为

\[ b=\frac{1}{2}\sqrt{2-\sqrt{2+\sqrt{2+\sqrt{2+\sqrt{2+\sqrt{2+\sqrt{2+\sqrt{2+\sqrt{2+\sqrt{2+\sqrt{2+\sqrt{3}}}}}}}}}}}} \]

Python代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#! /usr/bin/env python3
# vim:fenc=utf-8
import numpy as np

# 定义函数f(x)
def f(x):
    return 1/(1-x**2)**0.5

# Monte Carlo方法求积分
def monte_carlo_integral(f, a, b, num_samples=1000):
    # 在区间[a, b]内随机生成num_samples个样本点
    samples = np.random.uniform(a, b, num_samples)
    
    # 计算这些样本点对应的函数值
    y_values = f(samples)
    
    # 根据平均高度估计积分值，乘以区间的宽度得到近似面积
    integral_estimate = (b - a) * np.mean(y_values)
    
    return 24576*integral_estimate

# 使用Monte Carlo方法估计积分
a, b = 0, np.sqrt(2-np.sqrt(2+np.sqrt(2+np.sqrt(2+np.sqrt(2+np.sqrt(2+np.sqrt(2+np.sqrt(2+np.sqrt(2+np.sqrt(2+np.sqrt(2+np.sqrt(2+np.sqrt(3)))))))))))))/2  # 定义积分区间
estimated_integral = monte_carlo_integral(f, a, b)

print("Pi", estimated_integral)