IFDESS

2026年5月22日

2026-05-22T21:29:06+08:00

重大事件！终于买了人生中第一台台式电脑，自费1W1+，9700X+RTX5070，总算实现了初中时期的一个梦想。游戏？爽玩！AI？文生图走起！以前在Steam买的游戏总算可以玩个遍了。

2026年5月13日

2026-05-13T16:47:43+08:00

今天起床看到电脑配件降价了，预算1W直接开买。

但是感冒还没好，本来只是嗓子的问题，现在又开始流鼻涕了。

2026年5月12日

2026-05-12T11:39:00+08:00

前天早上开始感冒了，一早起来还没有反应，吃完早饭就感冒了，喉咙很痛。昨天晚上开始鼻塞，并且睡觉会咳嗽。熬不住去买药了。

本来这两天应该找学生分析成绩的，现在这个状态就不去传染学生了。

618好难等，等了这么久，别到时候价格还不如之前。

2026年5月10日

2026-05-10T18:48:00+08:00

昨天刚考完期中，得知4班平均分依旧是倒数第一。就差0.13分就超过倒二，有点闹心。不过对比起上一次，还是有不小的进步。2班平均分跃升至第二，仅次于6班，不少学生都有进步。

昨晚跟两个家长简单交流了一下，都是差生，必须得让家长知道他的孩子情况。

有一个学生给我发微信，觉得自己一直在退步，我也没啥好办法。她纯粹是没发挥好，保持下去迟早能回归巅峰。我是一顿安慰，不知道她能不能听进去。

本来想去剪头发，照照镜子发现还挺帅的，再拖一周。

今天一天心情都还不错，我觉得人生就差一台高性能电脑了。

VHDX镜像转移硬盘后的问题

2026-05-10T18:07:00+08:00

博主属于是WTG的重度用户，目前使用ventoy+VHDX镜像的方案。最近打算配一台电脑，于是想把之前的WTG镜像转移一下，放在空闲的一个旧硬盘中。

出现问题

引导系统加载时报错：

Windows failed to start. A recent hardware or software change might be the case
……
Status: 0xc000000f
Info: There is an invalid object in the Boot Configuration Date store.

原因

旧硬盘时sata协议，可能会导致主板引导出现问题
原硬盘和新硬盘的分区表格式不一致，导致系统引导有问题
ventoy镜像制作时默认会把硬盘分区表调整为MBR

解决方案

保证新旧硬盘的分区表格式相同
硬盘分区表尽量使用GUID(GPT)格式，GUID是主流
设置BIOS中的OS Surport兼容legacy，可以兼容旧系统引导
打开BIOS设置中的CSM功能，可以兼容旧协议硬盘
不要用ventoy镜像制作硬盘，可以使用ventoy应用程序制作

我记得以前制作win11的VHDX镜像也出现了类似的问题，当时没想到这些原因，以后有时间得重新试试。

博客写作自救

2026-05-05T11:07:00+08:00

尽管这一份工作有比较多的假期，但是从去年离职到现在没写几篇文章。总想着写点什么，但是每一次都无法完成一篇完整的博文。我必须要弄明白是什么阻挡了我写文，是时候做出一点改变了。

首先是写作水平差劲，每次写不到两百字就写不下去了，导致我明明有很多灵感，一闭上眼就思考个不停，但是一打开电脑又什么都写不出来。这底层的原因可能是我书读少了，没有受到文学的熏陶。确实，以前初中就觉得思政和历史没有学的必要。高中又直接就作为一个纯理科生入学。对课外文学书籍更是有一些排斥，总觉得书中的故事带有太多情绪，不如科普类刊物有意思。大学纯粹是荒废了，四年看的纸质书（包括专业课教材）加起来估计不及网络小说的百分之五。也是成为当代本科废物之典范了。

然后是写博客的态度问题，自我反思结果为“太过正经”，说难听点叫“轴”，无论是语言情绪还是行为逻辑。总是希望句子不能有语病错误，包括现在我写的这篇文章，几乎每一句话我都要检查好几遍，我希望读起来语意精确并且顺畅，同时还要排查用词不当和理论错误。其他方面也同样太过正经，从我23年创建博客以来，只有第一个博客主题的风格比较“感性”，后面更换的几个风格越来越不活泼，直到现在我已经把博客做成了“知识库+文档”的形式，少了很多人情味。我一直以为博客应该以内容为核心，直到今天刷了几个博客站。其中https://www.xnmoe.com/和https://delosha.com/令我印象非常深刻，你也可以点进去看看，最好是查看电脑版网页。他们的网站让我觉得很有个性，并且极具人味，我非常喜欢。

从发现问题到解决问题的这个过程中，最难的是正视问题和执行解决方案。现在的解决方案是坚持写日志，我相信写的文字多了，一定能提高写作水平。同时日志是一种很随意的内容文本，我可以加入更多情绪化的内容，这能增加我的人味。

坚持最帅了！

“刷到我就快去背单词”

2026-05-03T08:43:00+08:00

这篇文章纯粹是想吐槽一些事情。

不知道你们有没有刷到过“答应我，不管什么时候刷到我，都叫我去背单词”这种评论，博主作为一个中度网络依赖者，每隔一段时间就会看到这样的评论。每一次看到我都有一种难以表达的感受，像是哈哈大笑时吃到了一只蚊子，又像是玩游戏正开心时妈妈叫我去吃水果，反正不是很愉快。关键是还有很多网友点赞评论他，让我怀疑这些网友是不是伪人。不能理解这种人！让我不能愉快的刷视频了，我就想在网络上放松一下，实在是被恶心到了。

还有一些评论明显是骗赞骗评论的，仍然有一大堆人回应他，真是蠢得不行。

我喜欢网友玩梗（并非任何梗），也喜欢看网友理智的讨论话题，要是以后网络能够自定义净化内容就好了，让AI学习用户的偏好，净化掉用户不希望看到的内容。

另外我还有一个疑问，为什么有那么多的人喜欢发弹幕发评论，尤其是喜欢发无意义、感动自我的内容。我从18年开始混迹网络，迄今为止我也没发过多少弹幕和评论。我这种应该是有问题的，我不明白为什么大多数人和我相反。

数字域名靓号筛查

2026-04-21T18:26:00+08:00

这是一个AI编写的通用数字域名候选生成与可注册性检查脚本，本站的111654.xyz便是通过这个脚本寻找到的。

源代码

from __future__ import annotations

import argparse
import json
import socket
import ssl
import sys
import threading
import time
import urllib.error
import urllib.parse
import urllib.request
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
from tempfile import NamedTemporaryFile
from typing import Callable

RDAP_URL_TEMPLATE = "https://rdap.centralnic.com/{suffix}/domain/{domain}"
WHOIS_SERVER = "whois.nic.xyz"
WHOIS_PORT = 43
USER_AGENT = "domain-suffix-checker/1.0"

# 默认域名后缀
DEFAULT_SUFFIX = ".xyz"
# 默认候选数字文件路径
DEFAULT_INPUT = Path("candidates.txt")
# 默认生成的数字列表输出路径
DEFAULT_NUMBERS_OUTPUT = Path("numbers.txt")
# 默认生成的域名候选列表输出路径
DEFAULT_DOMAIN_OUTPUT = Path("candidates.txt")
# 默认可注册结果输出路径
DEFAULT_AVAILABLE_OUTPUT = Path("available.txt")
# 默认已注册结果输出路径
DEFAULT_REGISTERED_OUTPUT = Path("registered.txt")
# 默认错误结果输出路径
DEFAULT_ERROR_OUTPUT = Path("errors.txt")
# 默认完整结果输出路径
DEFAULT_RESULTS_OUTPUT = Path("results.txt")
# 默认并发线程数
DEFAULT_WORKERS = 1
# 默认查询超时时间（秒）
DEFAULT_TIMEOUT = 15.0
# 默认失败重试次数
DEFAULT_RETRIES = 3
# 默认失败后暂停时间（秒）
DEFAULT_PAUSE = 1.0
# WHOIS 查询最小间隔（秒）
DEFAULT_WHOIS_INTERVAL = 1.0
# 限流退避基数（秒）
DEFAULT_RATE_LIMIT_BACKOFF = 60.0
# 日志打印间隔
DEFAULT_LOG_EVERY = 100
# 默认启用 RDAP 回退
DEFAULT_USE_RDAP_FALLBACK = True
# 默认从已有结果文件恢复检查
DEFAULT_RESUME = True
# 默认数字长度
DEFAULT_NUM_DIGITS = 6

PatternChecker = Callable[[str], bool]

# 支持的数字筛选规则定义：
# key = 规则名, value = (中文标签, 默认最小匹配长度, 检查函数)
PATTERN_DEFINITIONS = {
    "same": ("相同数字", 4, lambda fragment: len(set(fragment)) == 1),
    "ascending": ("递增顺子", 4, lambda fragment: all(int(fragment[i + 1]) - int(fragment[i]) == 1 for i in range(len(fragment) - 1))),
    "descending": ("递减顺子", 5, lambda fragment: all(int(fragment[i + 1]) - int(fragment[i]) == -1 for i in range(len(fragment) - 1))),
    "palindrome": ("回文", 6, lambda fragment: fragment == fragment[::-1]),
    "rhythm": ("重复节奏", 5, lambda fragment: any(
        len(fragment) % unit_length == 0
        and all(fragment[i] == fragment[i % unit_length] for i in range(len(fragment)))
        for unit_length in range(2, len(fragment))
    )),
}


class WhoisRateLimitError(Exception):
    pass


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="通用数字域名候选生成与可注册性检查脚本")

    parser.add_argument("--suffix", type=str, default=DEFAULT_SUFFIX, help="域名后缀，例如 .xyz 或 .top")
    parser.add_argument("--num-digits", type=int, default=DEFAULT_NUM_DIGITS, help="数字部分长度，默认 6")
    parser.add_argument("--mode", choices=["generate", "check", "both"], default="both", help="运行模式: generate=生成候选, check=检查可注册, both=先生成再检查")

    parser.add_argument("--start", type=int, default=0, help="生成候选号码的起始范围，默认 0")
    parser.add_argument("--end", type=int, default=999999, help="生成候选号码的结束范围，默认 999999")
    parser.add_argument("--numbers-input", type=Path, help="从已有号码文件加载候选号码（支持纯号码列表或带分类的 tab 文本）")
    parser.add_argument("--domain-input", type=Path, help="从已有域名列表加载候选域名，优先于生成的域名")
    parser.add_argument("--output-numbers", type=Path, default=DEFAULT_NUMBERS_OUTPUT, help="保存生成数字列表的文件")
    parser.add_argument("--output-domains", type=Path, default=DEFAULT_DOMAIN_OUTPUT, help="保存生成域名候选列表的文件")

    parser.add_argument("--patterns", nargs="*", choices=list(PATTERN_DEFINITIONS) + ["all"], default=["all"], help="启用的靓号规则，可重复指定，如 --patterns same palindrome")
    parser.add_argument("--min-length-same", type=int, default=4, help="相同数字最小连续长度")
    parser.add_argument("--min-length-ascending", type=int, default=4, help="递增顺子最小连续长度")
    parser.add_argument("--min-length-descending", type=int, default=5, help="递减顺子最小连续长度")
    parser.add_argument("--min-length-palindrome", type=int, default=6, help="回文最小连续长度")
    parser.add_argument("--min-length-rhythm", type=int, default=5, help="重复节奏最小连续长度")

    parser.add_argument("--available-output", type=Path, default=DEFAULT_AVAILABLE_OUTPUT, help="可注册域名输出文件")
    parser.add_argument("--registered-output", type=Path, default=DEFAULT_REGISTERED_OUTPUT, help="已注册域名输出文件")
    parser.add_argument("--error-output", type=Path, default=DEFAULT_ERROR_OUTPUT, help="查询错误输出文件")
    parser.add_argument("--results-output", type=Path, default=DEFAULT_RESULTS_OUTPUT, help="完整结果输出文件")

    parser.add_argument("--workers", type=int, default=DEFAULT_WORKERS, help="线程池并发数，WHOIS 主流程会自动限速")
    parser.add_argument("--timeout", type=float, default=DEFAULT_TIMEOUT, help="查询超时时间（秒）")
    parser.add_argument("--retries", type=int, default=DEFAULT_RETRIES, help="失败重试次数")
    parser.add_argument("--pause", type=float, default=DEFAULT_PAUSE, help="失败后的重试等待时间（秒）")
    parser.add_argument("--whois-interval", type=float, default=DEFAULT_WHOIS_INTERVAL, help="两个 WHOIS 查询之间的最小间隔（秒）")
    parser.add_argument("--rate-limit-backoff", type=float, default=DEFAULT_RATE_LIMIT_BACKOFF, help="遇到 WHOIS 限流时的退避基数（秒）")
    parser.add_argument("--use-rdap-fallback", action="store_true", default=DEFAULT_USE_RDAP_FALLBACK, help="启用 WHOIS 失败后的 RDAP 回退")
    parser.add_argument("--no-use-rdap-fallback", action="store_false", dest="use_rdap_fallback", help="禁用 RDAP 回退")
    parser.add_argument("--resume", action="store_true", default=DEFAULT_RESUME, help="从已有结果文件继续检查，跳过已完成条目")
    parser.add_argument("--log-every", type=int, default=DEFAULT_LOG_EVERY, help="每处理多少条输出一次日志")
    return parser.parse_args()


def normalize_suffix(suffix: str) -> str:
    if not suffix.startswith("."):
        suffix = "." + suffix
    return suffix.lower()


def parse_selected_patterns(selected: list[str], args: argparse.Namespace) -> dict[str, tuple[str, int, PatternChecker]]:
    if not selected or "all" in selected:
        selected = [key for key in PATTERN_DEFINITIONS if key != "all"]

    patterns: dict[str, tuple[str, int, PatternChecker]] = {}
    for key in selected:
        if key not in PATTERN_DEFINITIONS:
            continue
        label, default_min, checker = PATTERN_DEFINITIONS[key]
        min_length = getattr(args, f"min_length_{key}", default_min)
        patterns[key] = (label, min_length, checker)
    return patterns


def format_number(value: int, width: int) -> str:
    return f"{value:0{width}d}"


def is_valid_number_token(token: str, length: int) -> bool:
    return len(token) == length and token.isdigit()


def load_numbers_from_file(path: Path, num_digits: int) -> list[str]:
    numbers: list[str] = []
    seen: set[str] = set()
    for line in path.read_text(encoding="utf-8").splitlines():
        if not line or line.startswith("#"):
            continue
        token = line.split()[0].strip()
        if token.endswith("."):
            token = token[:-1]
        if is_valid_number_token(token, num_digits) and token not in seen:
            numbers.append(token)
            seen.add(token)
    return numbers


def generate_candidate_numbers(start: int, end: int, num_digits: int, patterns: dict[str, tuple[str, int, PatternChecker]]) -> list[str]:
    if start < 0 or end < 0 or start > end:
        raise ValueError("范围必须是非负且起始值不大于结束值")
    if end >= 10 ** num_digits:
        raise ValueError(f"结束值必须小于 {10**num_digits}")

    results: list[str] = []
    seen: set[str] = set()

    for value in range(start, end + 1):
        number = format_number(value, num_digits)
        matched = False
        for label, min_length, checker in patterns.values():
            for fragment_length in range(num_digits, min_length - 1, -1):
                for start_index in range(0, num_digits - fragment_length + 1):
                    fragment = number[start_index : start_index + fragment_length]
                    if checker(fragment):
                        matched = True
                        break
                if matched:
                    break
            if matched:
                break

        if matched and number not in seen:
            results.append(number)
            seen.add(number)
    return results


def numbers_to_domains(numbers: list[str], suffix: str) -> list[str]:
    return [f"{number}{suffix}" for number in numbers]


def load_domains(path: Path, suffix: str) -> list[str]:
    domains: list[str] = []
    seen: set[str] = set()
    for line in path.read_text(encoding="utf-8").splitlines():
        domain = line.strip().lower()
        if not domain or domain.startswith("#"):
            continue
        if not domain.endswith(suffix):
            if domain.isdigit() and len(domain) == len(suffix) - 1:
                domain = f"{domain}{suffix}"
            else:
                continue
        if domain not in seen:
            domains.append(domain)
            seen.add(domain)
    return domains


class DomainChecker:
    def __init__(
        self,
        timeout: float,
        retries: int,
        pause: float,
        whois_interval: float,
        rate_limit_backoff: float,
        use_rdap_fallback: bool,
    ) -> None:
        self.timeout = timeout
        self.retries = retries
        self.pause = pause
        self.whois_interval = whois_interval
        self.rate_limit_backoff = rate_limit_backoff
        self.use_rdap_fallback = use_rdap_fallback
        self._ssl_context = ssl.create_default_context()
        self._insecure_context = ssl._create_unverified_context()
        self._force_insecure = False
        self._lock = threading.Lock()
        self._whois_lock = threading.Lock()
        self._last_whois_at = 0.0

    def _whois_request(self, domain: str) -> str:
        with self._whois_lock:
            elapsed = time.monotonic() - self._last_whois_at
            if elapsed < self.whois_interval:
                time.sleep(self.whois_interval - elapsed)
            with socket.create_connection((WHOIS_SERVER, WHOIS_PORT), timeout=self.timeout) as sock:
                sock.sendall(f"{domain}\r\n".encode("utf-8"))
                chunks: list[bytes] = []
                while True:
                    data = sock.recv(4096)
                    if not data:
                        break
                    chunks.append(data)
            self._last_whois_at = time.monotonic()
        return b"".join(chunks).decode("utf-8", "ignore")

    def _parse_whois_response(self, domain: str, payload: str) -> tuple[str, str, str]:
        content = payload.strip()
        upper_content = content.upper()
        if "QUERY RATE EXCEEDED" in upper_content:
            raise WhoisRateLimitError("WHOIS query rate exceeded")
        if "DOMAIN NOT FOUND" in upper_content or "THE QUERIED OBJECT DOES NOT EXIST" in upper_content:
            return domain, "available", "WHOIS: DOMAIN NOT FOUND"
        if "DOMAIN NAME:" in upper_content or "REGISTRY DOMAIN ID:" in upper_content:
            return domain, "registered", "WHOIS: REGISTERED"
        snippet = " ".join(content.split())[:200]
        return domain, "error", f"WHOIS unexpected response: {snippet}"

    def _request_rdap(self, domain: str, suffix: str, insecure: bool) -> tuple[int, str]:
        url = RDAP_URL_TEMPLATE.format(suffix=suffix.lstrip("."), domain=domain)
        request = urllib.request.Request(
            url,
            headers={"User-Agent": USER_AGENT, "Accept": "application/rdap+json, application/json"},
        )
        context = self._insecure_context if insecure else self._ssl_context
        with urllib.request.urlopen(request, timeout=self.timeout, context=context) as response:
            payload = response.read().decode("utf-8", "ignore")
            return response.status, payload

    def _build_result(self, domain: str, status_code: int, payload: str) -> tuple[str, str, str]:
        if status_code == 200:
            return domain, "registered", "RDAP 200"
        return domain, f"unknown_{status_code}", summarize_payload(payload)

    def check_domain(self, domain: str, suffix: str) -> tuple[str, str, str]:
        last_error = ""
        insecure = self._force_insecure
        allow_insecure_retry = True
        for attempt in range(self.retries + 1):
            try:
                return self._parse_whois_response(domain, self._whois_request(domain))
            except WhoisRateLimitError as exc:
                last_error = str(exc)
                if attempt < self.retries:
                    time.sleep(self.rate_limit_backoff * (attempt + 1))
                    continue
                return domain, "error", last_error
            except (socket.timeout, TimeoutError) as exc:
                last_error = f"WHOIS timeout: {exc}"
            except OSError as exc:
                last_error = f"WHOIS network error: {exc}"

            if not self.use_rdap_fallback:
                if attempt < self.retries:
                    time.sleep(self.pause)
                    continue
                return domain, "error", last_error or "WHOIS failed"

            try:
                status_code, payload = self._request_rdap(domain, suffix, insecure=insecure)
                if status_code == 404:
                    return domain, "available", summarize_payload(payload)
                return self._build_result(domain, status_code, payload)
            except urllib.error.HTTPError as exc:
                payload = exc.read().decode("utf-8", "ignore")
                if exc.code == 404:
                    return domain, "available", summarize_payload(payload)
                last_error = f"HTTP {exc.code}: {summarize_payload(payload)}"
            except urllib.error.URLError as exc:
                reason = str(exc.reason)
                last_error = reason
                if "CERTIFICATE_VERIFY_FAILED" in reason and not insecure and allow_insecure_retry:
                    with self._lock:
                        self._force_insecure = True
                    allow_insecure_retry = False
                    try:
                        status_code, payload = self._request_rdap(domain, suffix, insecure=True)
                        if status_code == 404:
                            return domain, "available", summarize_payload(payload)
                        return self._build_result(domain, status_code, payload)
                    except Exception as retry_exc:
                        last_error = str(retry_exc)
            except ssl.SSLError as exc:
                reason = str(exc)
                last_error = reason
                if "CERTIFICATE_VERIFY_FAILED" in reason and not insecure and allow_insecure_retry:
                    with self._lock:
                        self._force_insecure = True
                    allow_insecure_retry = False
                    try:
                        status_code, payload = self._request_rdap(domain, suffix, insecure=True)
                        if status_code == 404:
                            return domain, "available", summarize_payload(payload)
                        return self._build_result(domain, status_code, payload)
                    except Exception as retry_exc:
                        last_error = str(retry_exc)
            except Exception as exc:
                last_error = str(exc)

            if attempt < self.retries:
                time.sleep(self.pause)

        return domain, "error", last_error or "unknown error"


def summarize_payload(payload: str) -> str:
    if not payload:
        return ""
    try:
        data = json.loads(payload)
    except json.JSONDecodeError:
        return payload[:160].replace("\n", " ")

    title = data.get("title")
    description = data.get("description")
    error_code = data.get("errorCode")
    parts: list[str] = []
    if error_code:
        parts.append(str(error_code))
    if title:
        parts.append(str(title))
    if isinstance(description, list):
        parts.extend(str(item) for item in description[:2])
    elif description:
        parts.append(str(description))
    return " | ".join(parts)[:200]


def read_existing_results(path: Path) -> set[str]:
    if not path.exists():
        return set()
    existing: set[str] = set()
    for line in path.read_text(encoding="utf-8").splitlines():
        if not line or line.startswith("domain\t"):
            continue
        domain = line.split("\t", 1)[0].strip().lower()
        if domain:
            existing.add(domain)
    return existing


def write_candidates(numbers: list[str], domains: list[str], numbers_path: Path, domains_path: Path) -> None:
    if numbers_path:
        numbers_path.write_text("\n".join(numbers) + ("\n" if numbers else ""), encoding="utf-8")
    if domains_path:
        domains_path.write_text("\n".join(domains) + ("\n" if domains else ""), encoding="utf-8")


def write_results(available: list[tuple[str, str, str]], registered: list[tuple[str, str, str]], errors: list[tuple[str, str]], results_path: Path, available_path: Path, registered_path: Path, error_path: Path) -> None:
    available_path.write_text("\n".join(domain for domain, _, _ in available) + ("\n" if available else ""), encoding="utf-8")
    registered_path.write_text("\n".join(domain for domain, _, _ in registered) + ("\n" if registered else ""), encoding="utf-8")
    error_lines = [f"{domain}\t{detail}" for domain, detail in errors]
    error_path.write_text("\n".join(error_lines) + ("\n" if error_lines else ""), encoding="utf-8")

    # 完整结果包含可注册、已注册和错误三个部分
    lines = ["domain\tstatus\tdetail"]
    lines.extend(f"{domain}\t{status}\t{detail}" for domain, status, detail in available)
    lines.extend(f"{domain}\t{status}\t{detail}" for domain, status, detail in registered)
    lines.extend(f"{domain}\terror\t{detail}" for domain, detail in errors)
    results_path.write_text("\n".join(lines) + "\n", encoding="utf-8")


def check_domains(domains: list[str], checker: DomainChecker, suffix: str, resume: bool, results_path: Path, log_every: int) -> list[tuple[str, str, str]]:
    # 已存在结果域名，用于 resume 模式下跳过已处理项
    existing = read_existing_results(results_path) if resume else set()
    # 本次检查的域名状态结果列表
    tasks: list[tuple[str, str, str]] = []

    for index, domain in enumerate(domains, start=1):
        if domain in existing:
            continue
        status = checker.check_domain(domain, suffix)
        tasks.append(status)
        if log_every and index % log_every == 0:
            print(f"[{index}/{len(domains)}] checked {domain}: {status[1]}")
    return tasks


def main() -> None:
    args = parse_args()
    suffix = normalize_suffix(args.suffix)
    patterns = parse_selected_patterns(args.patterns, args)
    if not patterns:
        raise ValueError("请至少启用一个筛选规则")

    # 生成或加载的候选域名和候选数字列表
    candidate_domains: list[str] = []
    candidate_numbers: list[str] = []

    if args.mode in ("generate", "both"):
        if args.numbers_input:
            # 支持从现有数字文件读取候选号码
            candidate_numbers = load_numbers_from_file(args.numbers_input, args.num_digits)
            if not candidate_numbers:
                raise ValueError(f"从文件 {args.numbers_input} 未加载到任何数字")
        else:
            # 按规则生成候选数字
            candidate_numbers = generate_candidate_numbers(args.start, args.end, args.num_digits, patterns)
            if not candidate_numbers:
                raise ValueError("未生成任何候选号码，请检查范围与筛选规则")

        # 将候选数字拼接为域名后缀
        candidate_domains = numbers_to_domains(candidate_numbers, suffix)
        write_candidates(candidate_numbers, candidate_domains, args.output_numbers, args.output_domains)
        print(f"已生成 {len(candidate_numbers)} 个候选号码 / {len(candidate_domains)} 个候选域名")
        print(f"号码输出: {args.output_numbers}")
        print(f"域名输出: {args.output_domains}")

    if args.mode in ("check", "both"):
        if args.domain_input:
            candidate_domains = load_domains(args.domain_input, suffix)
        if not candidate_domains:
            if args.mode == "check":
                raise ValueError("检查模式需要通过 --domain-input 或 --output-domains 提供候选域名")
            candidate_domains = load_domains(args.output_domains, suffix)

        if not candidate_domains:
            raise ValueError("未获取任何候选域名进行检查")

        checker = DomainChecker(
            timeout=args.timeout,
            retries=args.retries,
            pause=args.pause,
            whois_interval=args.whois_interval,
            rate_limit_backoff=args.rate_limit_backoff,
            use_rdap_fallback=args.use_rdap_fallback,
        )

        print(f"开始检查 {len(candidate_domains)} 个域名，后缀 {suffix}")
        results = check_domains(candidate_domains, checker, suffix, args.resume, args.results_output, args.log_every)

        available = [(domain, status, detail) for domain, status, detail in results if status == "available"]
        registered = [(domain, status, detail) for domain, status, detail in results if status == "registered"]
        errors = [(domain, detail) for domain, status, detail in results if status == "error"]

        write_results(available, registered, errors, args.results_output, args.available_output, args.registered_output, args.error_output)
        print(f"检查完成: {len(available)} 可注册, {len(registered)} 已注册, {len(errors)} 错误")
        print(f"结果输出: {args.results_output}")
        print(f"可注册列表: {args.available_output}")
        print(f"已注册列表: {args.registered_output}")
        print(f"错误列表: {args.error_output}")


if __name__ == "__main__":
    main()

功能

生成数字候选
按指定后缀组装域名候选
检查域名可注册性
支持 WHOIS 查询和 RDAP 回退
支持可配置的筛选规则

运行方式

python domain_suffix_checker.py --help

参数说明

基本参数

--suffix：域名后缀，默认 .xyz
--num-digits：数字部分长度，默认 6
--mode：运行模式，可选 generate|check|both
- generate：只生成候选
- check：只检查可注册性
- both：先生成再检查

生成候选相关

--start：生成号码起始值，默认 0
--end：生成号码结束值，默认 999999
--numbers-input：从已有号码文件加载候选号码
--domain-input：从已有域名列表加载候选域名
--output-numbers：保存生成数字列表文件，默认 numbers.txt
--output-domains：保存生成域名候选列表文件，默认 candidates.txt

筛选规则

--patterns：启用规则，支持以下选项：
- same：相同数字
- ascending：递增顺子
- descending：递减顺子
- palindrome：回文
- rhythm：重复节奏
- all：全部规则（默认）

每项规则最小长度

--min-length-same
--min-length-ascending
--min-length-descending
--min-length-palindrome
--min-length-rhythm

检查结果输出

--available-output：可注册域名输出文件，默认 available.txt
--registered-output：已注册域名输出文件，默认 registered.txt
--error-output：查询错误输出文件，默认 errors.txt
--results-output：完整结果输出文件，默认 results.txt

查询调优参数

--timeout：单次查询超时时间（秒），默认 15
--retries：失败重试次数，默认 3
--pause：失败后重试等待时间（秒），默认 1
--whois-interval：WHOIS 查询最小间隔（秒），默认 1
--rate-limit-backoff：限流退避基数（秒），默认 60
--use-rdap-fallback：启用 RDAP 回退（默认开启）
--no-use-rdap-fallback：禁用 RDAP 回退
--resume：从已有结果继续检查，默认开启
--log-every：每处理多少条记录输出一次日志，默认 100

示例

1. 生成 `.xyz` 候选

python domain_suffix_checker.py --mode generate --suffix .xyz --start 0 --end 999999 --patterns same ascending

2. 生成并检查可注册

python domain_suffix_checker.py --mode both --suffix .xyz --start 0 --end 999999 --patterns same ascending

3. 仅检查已有域名列表

python domain_suffix_checker.py --mode check --domain-input test_domains.txt --suffix .xyz

4. 只生成回文和重复节奏

python domain_suffix_checker.py --mode generate --patterns palindrome rhythm --start 0 --end 999999

输出文件说明

numbers.txt：生成的数字候选列表
candidates.txt：生成的域名候选列表
available.txt：可注册域名列表
registered.txt：已注册域名列表
errors.txt：查询错误和详细报错
results.txt：完整结果明细

注意事项

--domain-input 优先于自动生成的候选域名
--numbers-input 可直接加载现成数字列表
建议先用小范围测试，如 --start 0 --end 99
如果需要中断后继续，开启 --resume

2026年4月21日

2026-04-21T17:40:23+08:00

上周六跑了3公里，到现在腿还是酸痛，一定要多锻炼啊。早睡！早起！多锻炼！少玩手机！

练习册处理方法

2026-04-16T17:21:00+08:00

作为一个青年教师，对于教学确实没有太多经验。之前困扰我一个问题：如何处理练习册。直到前几天，偶然有了一点思路。我们一共有两本练习册，一本偏提升比较难，一本偏基础比较简单。

偏难的练习册处理方法

Section A学完之后，把练习册当做考试，成绩较差比如说倒数五名的同学，允许翻书看笔记完成。题目课上完成，马上对答案并统计分数。第二节课讲题，要求用不同颜色的笔订正，讲完收上来。

简单练习册处理方法

当做周末作业或者课堂作业，允许翻书，做完不用收，过一两天讲题，讲完收上来，没有订正或者订正有错误的叫来办公室改错。

IFDESS

2026年5月22日

2026年5月13日

2026年5月12日

2026年5月10日

VHDX镜像转移硬盘后的问题

​出现问题

​原因

​解决方案

博客写作自救

“刷到我就快去背单词”

数字域名靓号筛查

​源代码

​功能

​运行方式

​参数说明

​基本参数

​生成候选相关

​筛选规则

​每项规则最小长度

​检查结果输出

​查询调优参数

​示例

​1. 生成 .xyz 候选

​2. 生成并检查可注册

​3. 仅检查已有域名列表

​4. 只生成回文和重复节奏

​输出文件说明

​注意事项