天影大侠的小站

Linux通过Howdy实现人脸登录和一些bug修复

Sat, 28 Feb 2026 20:57:22 GMT

前言

Windows上有Hello登录，很羡慕，然后Linux不仅没有人脸，还到处需要输入密码很麻烦，配置为不用密码后又不太可靠，所以找到了Howdy这个东西，实现了Linux上的人脸登录。
Howdy请按照下面步骤使用beta版本。

方法

下载并安装howdy(以deb系为例)

Arch系用户如果直接yay -S howdy-beta-git来安装，可跳过此步骤，如果安装失败也可以按照下面步骤进行

{warning} 目前尽量不要用Howdy README里的安装方式，因为过于久远没有更新readme了

在终端里输入：

# 安装依赖
sudo apt-get update && sudo apt-get install -y \
python3 python3-pip python3-setuptools python3-wheel \
cmake make build-essential \
libpam0g-dev libinih-dev libevdev-dev python3-opencv \
python3-dev libopencv-dev
sudo apt install python3-numpy python3-dlib libpam-python dlib-models libinireader0
# 克隆仓库并进入
git clone https://github.com/boltgolt/howdy
cd howdy

# 进入最新的Beta3.0分支(重要)
# (目前分支名是这个，如有更新请自行改为最新分支)
git checkout d3ab993

# 编译和安装
meson setup build
meson compile -C build
meson install -C build

进行配置howdy

下载模型

先输入sudo howdy add，它会弹出

Data files have not been downloaded, please run the following commands:
	cd (一个路径)
    sudo ./install.sh

执行弹出的那两行命令，然后会下载识别的模型

识别并配置摄像头

在shell里输入

v4l2-ctl --list-devices --all

获取摄像头路径，一般来说/dev/video0就是普通摄像头，/dev/video2就是摄像头加红外，但你的可能不一样，看情况而定
再输入

sudo howdy config

找到device_path，将后面的值设置为/dev/video2或你设备对应的路径，然后再输入

sudo howdy test

如果看到摄像头开启并红外正常活动便成功了，如果没有的话就换个device_path试试

添加人脸数据

输入sudo howdy add即可

配置PAM

把howdy配置好后，就能配置pam来用上人脸识别了，进入 /etc/pam.d/ 文件夹，可以看到很多配置文件，可以单独配置，但如果想每个地方都能使用人脸识别的话，就直接修改里面的system-auth就行了
用你熟悉的编辑器打开 /etc/pam.d/system-auth ，然后在 #%PAM-1.0 下面加上这两行

auth sufficient pam_unix.so try_first_pass likeauth nullok
auth sufficient /usr/local/lib/security/pam_howdy.so

第二行就是使用人脸识别，第一行是优先使用密码输入，不加这一行可能会出现输入密码后回车后仍然需要等待人脸识别的时间

如果是arch直接安装的话第二行中pam_howdy.so可能是lib/security/pam_howdy.so，请注意修改

保存后无须重启，应该人脸识别就生效了！

一些bug修复

如果红外始终唤不醒的话可以使用linux-enable-ir-emitter来唤醒，具体看它的README
如果发现greeting和sudo等都能正常使用人脸识别，而使用kde时弹出的Polkit界面无法使用时，请按照以下方法修改: 在shell里输入

sudo systemctl edit polkit-agent-helper@.service

在 ### Edits below this comment will be discarded的上面加上以下几行

[Service]
PrivateDevices=no
DeviceAllow=/dev/video2 rw

上面的DeviceAllow后的值应该是你的红外正常工作的摄像头路径

然后sudo systemctl daemon-reload并重启即可这个似乎是kde更新给polkit引入了更安全的机制，在日志中可以看到 Unknown line ‘Howdy could not find a camera device at the path specified in the config file.’ from helper ，解决方法来自这个issue下面的解答

后言

sudo howdy config中还有一些配置可修改，可以自行试试
howdy的精确度肯定不如Windows Hello高，所以使用有风险
如有错误，欢迎指正

解决Linux上星露谷物语合作页面一直显示正在连接到在线服务…

Mon, 09 Feb 2026 11:56:31 GMT

前言

在Linux上玩Steam原生星露谷物语，联机页面一直显示正在连接到在线服务…，但用proton来玩就没有问题，所以猜可能是原生版的一个小bug，然后找到了这个帖子临时解决 Arch Linux 原生运行星露谷物语时由 glibc 导致的 Galaxy API 初始化错误，就解决了，搬运一下下次玩的时候给自己看看。

原因

搬运一下原帖怎么写的

是由于 glibc 在 2.41 版本引入的兼容性变化，导致 GOG Galaxy API 库（libGalaxy64.so 和 libGalaxyCSharpGlue.so）加载失败。具体原因是新版本对 GNU_STACK 段进行了更严格的检查。简单说，就是新官上任三把火，glibc 现在对 GNU_STACK 段的检查更严格了，而老库有点跟不上节奏。

方法

安装patchelf

sudo apt install patchelf

patch相关文件

找到星露谷物语安装目录，默认是 ~/.steam/steam/steamapps/common/Stardew\ Valley ，里面应该会有 libGalaxy64.so 和 libGalaxyCSharpGlue.so 这两个文件
在目录下执行

patchelf --clear-execstack libGalaxy64.so
patchelf --clear-execstack libGalaxyCSharpGlue.so

即可，重新进入游戏后就能正常联机。

给kde添加触摸板三指滑动来移动窗口的功能

Sun, 01 Feb 2026 21:41:01 GMT

前言

之前用deepin最舒适的就是它的触摸板手势，可以通过触摸板三指左右滑动来快速使窗口左右平铺，用来一个窗口编辑，一个窗口预览非常方便。
来到kde后却没有这个功能，但快捷键里发现可以通过Super+左箭头或右箭头来实现同样的效果，所以想到可以通过用libinput让把三指滑动翻译为Super+相应的按键，然后就成功了，所以分享一下。

目前环境kubuntu26.04 + KDE Plasma 6.5.5, 以三指左右滑动来快速使窗口左右平铺演示。

方法

1.安装libinput-gestures和相关工具

sudo apt update
sudo apt install libinput-tools xdotool wmctrl python3 python3-setuptools python3-gi

git clone https://github.com/bulletmark/libinput-gestures.git
cd libinput-gestures
sudo ./libinput-gestures-setup install
cd ..

2.检查快捷键和测试ydotool

{warning}如果是x11的话就把所有的ydotool改为xdotool即可

查看KDE设置里的键盘-快捷键-窗口管理里的快速铺放窗口到左(右)侧的快捷键，默认是Meta+左(右)方向键。

再在终端里输入：

ydotool key Super_L+Left

输入后当前的窗口会执行平铺到左侧，说明ydotool生效。

3.配置libinput-gestures

nano ~/.config/libinput-gestures.conf

输入以下内容：

# 三指左滑 -> 触发 Super+左方向键 (平铺窗口到左侧)
gesture swipe left 3 ydotool key super+Left

# 三指右滑 -> 触发 Super+右方向键 (平铺窗口到右侧)
gesture swipe right 3 ydotool key super+Right

4.将用户加入输入组并启动libinput

# 将自己加入 input 用户组（需要重新登录生效）
sudo gpasswd -a $USER input

# 启用自动启动并立即启动
libinput-gestures-setup autostart start
libinput-gestures-setup start

{warning} 执行完gpasswd命令后，需要完全注销并重新登录，权限才会生效。

这样就大功告成，能使用触控屏手势！

其他

其他触摸板手势也类似添加，话说kde设置里为什么没有触控板手势这么方便的东西呢，是我眼瞎没找到吗。

用 Tailwind CSS 做一个简单仿ios26液态玻璃风格的卡片

Fri, 30 Jan 2026 12:57:39 GMT

前言

刷B站视频的时候突然看到一个视频说卡片加上顶部白色阴影会更有质感，就突然想到了可以根据白色阴影来做一个伪ios26液态风格风格的卡片，根据想法测试了下还行(虽然和26原版比起来差很多)，方法非常简单，效果也非常简单，那就简单分享一下。

效果预览

简单分享

先根据Tailwindcss文档引入tailwindcss，然后随便放个卡片，在卡片的class里写入以下东西即可：

rounded-4xl
shadow-[inset_1px_1px_0_0_rgba(255,255,255,0.8),inset_-1px_-1px_0_0_rgba(255,255,255,0.8)]
ease-[cubic-bezier(0.175,0.885,0.32,1.5)]
backdrop-blur-sm
bg-white/30
duration-400

其中前四个就是实现的所有东西了，分别是大圆角，左上角和右下角白色高光描边，动画曲线和一点点背景模糊。
后两个是背景色和动画时长，如果不添加动画时长的话动画就只会出现始末态，背景的话第一层元素背景可以透一点，但更高层的元素背景最好就不要太透并加上模糊，不然可读性真的很差。
想要卡片出现的动画的话可以通过添加 scale-0 origin-top-right 等后再写相关逻辑来给卡片添加从右上角弹出的Q弹动画。

示例

在一个测试项目中我试了下这个样式，HTML和CSS分别为：

<div class="glass-card h-96">
    <div class="p-6 w-full h-full flex flex-col justify-between">
        <!-- 标题 -->
        <h1 class="text-2xl font-bold text-white text-center">
            一个卡片
        </h1>
    </div>
</div>

.glass-card {
  @apply
    rounded-4xl /* 圆角 */
    relative
    shadow-[inset_1px_1px_0_0_rgba(255,255,255,0.8),inset_-1px_-1px_0_0_rgba(255,255,255,0.8)] /* 白色高光 */
    flex /* 布局相关 */
    items-center /* 中心居中 */
    bg-white/30 /* 浅色背景 */
    overflow-hidden /* 超出这个卡片的里面的东西截断 */
    transition-all /* 有动画 */
    duration-400 /* 动画时长 */
    ease-[cubic-bezier(0.175,0.885,0.32,1.5)] /* 动画曲线 */
    hover:scale-105 /* hover时变大 */
    w-10/12
    md:w-8/12 /* 宽度（写两个是因为宽度切换的动画很好看） */
    max-w-lg /* 最大宽度（防止太难看） */
    min-h-96 /* 最小高度 */
    mt-10 /* 外面的上边距 */
    backdrop-blur-sm /* 背景小小的模糊 */
}

这样就诞生了一个鼠标悬停时会Q弹变大的卡片，你也去试试吧！

后言

如果需要更相似和优质的效果的话移步其他位置吧。
可能有误，欢迎指正。

简单总结一下自己的大一上册(AI精简)

Thu, 29 Jan 2026 14:06:12 GMT

前言

这里是MiniMax，一个人在放假第一天，想总结大一上册。写了很多废话，现由我精简为以下内容。

军训

军训没什么特别的：没有迟到、缺勤、抱怨、才艺表演。

拆分军体拳和队列时，很多人选了队列（传言说分高）。他们班很多男生留在了军体拳，希望是那个教官教。结果分人时教官开玩笑说：“从今以后你们军体拳的就和我们10连没有关系了！”

后来他问教官能不能去队列，得到肯定后第二天就悄悄混进去了。最后几天和同学一起玩狼人杀、谁是卧底，挺开心。

学习

写得最少，因为他学习最差。化学最差，数学第二差。大一上学的偏偏是无机化学和高数。

期末化学有保护机制，错很多但没感觉；高数连保护机制都没用了。

英语四级没复习，考前连题型都不知道，能过就行。还被学长骗去加了英语口语班。

另外他花几小时在化工官网找了个教授，提前写4页小抄希望能流畅交流。老师让他第二天就去见他，只和他聊了大一学习和英语，然后把他安排给一个博士。下学期应该能做实验了。

团委

他是班上20人中仅有的5个非团员之一，但面试加了化工院新媒体部和学校网信部，两个都过了。

新媒体部编辑微信公众号推文，包括正文、小尾巴、封面，帮供稿人审错。最后一次编辑时供稿没问题了，排版还受到审核老师表扬。总共编辑了11个推文，可能是新干事中干得最多的。

在网信部做前端。军训时被拉去做基地预约项目，只做了两个页面，后来被学长大改。后来又被推荐去另一个项目，主要复制粘贴学长写好的代码。

其他

参加开源鸿蒙技术大会和谷歌Dev Fest，收到deepin几次社区小礼物，翻译并被接纳两个项目，参与编写Wiki。参加马拉松跑得很快。和高中同学、室友玩游戏，室友都挺好。

刷了很多次电脑手机，扣分项。被骗了很多次，太容易相信别人了。敢主动和想聊天的人聊天了。买主板高估自己了。报健身房没坚持下去。

下学期还有一堆事：英语口语班、健身房、找导师、计算机考试、英语竞赛、6级、可能的补考、两个公选课。真想累死下学期的他。但上学期他啥都没干，他可真坏。

期末沉迷《终末地》，这游戏好玩。

最后QQ和微信去重加了70个好友。对别人来说不多，但对他足够甚至过剩了。

总结

每学期总结他都写：

这学期啥也没干

所以这学期也如下：

这学期啥也没干

简单总结一下自己的大一上册

Thu, 29 Jan 2026 11:10:45 GMT

前言

这里是天影大侠，这个博客的主人。现在是放假后的第一天，想总结一下自己的大一上册，但日记本没有带回家，写在其他平台可能会打扰到其他好友，所以就写在自己的这个破站上吧。
嗯我不习惯用“我”这个称呼，也不太方便叫自己真名，大家也不会乐意看我用四个字称呼自己，所以这篇里我就叫自己“他”吧。

从如何进入中南说起

他在高中的时候算很差很差的一个学生(后面拿到笔记本了可以补充一下成绩排名)，到高三的时候他数学已经上不去100分了，其他科都是一样的差，课也听不懂，题也做不来，也玩不进去，就装模作样练字加上写日记，字写的比狗爬还差，日记写的也全是负能量。后来一天中午睡醒他就把高三的笔记本扔了，扔了后一下午满脸烧得慌，下午早早吃完饭又去掏大垃圾桶——所以有时看到别人掏垃圾桶，不一定是他饿了，可能是他有东西不小心扔了。最后当然没有找到，但高一高二的笔记本同样也是同样的负能量。如果我当时没扔的话未来哪天翻出高三的日记看也一定会扔掉的。现实也没有奇迹，他直到最后一次月考还是班上30名左右(参考笔记本后修改为具体排名)

(这里拿到笔记本后配一个很多很多骂自己的段落图片)

但是当时班主任提醒开始强基计划报名的时候，老师说成绩只要600分往上都能报来试试，我已经很久没有考上600分了，也没有打算要报。但我家长非常想让我去哈工大，另一个家长非常想让我去中国人民大学(虽然但是我肯定考不到)，所以给班主任打电话让我报一下，然后也给我说了很多很多希望我报。最后我想反正报一下也无伤大雅，肯定上不了，但最后我还是报了一个没有笔试，排名不算靠前，离家不太远的学校，嗯就是中南大学，然后应用化学专业。

报了后又是一段摸鱼的复习。终于到了高考。嗯提一下他的大脑有保护机制，考试的时候不管靠得好不好，他总会觉得自己做的还行，错的分能够接受，所以之前每次他化学考完都觉得诶自己错的不多，但每次成绩出来都是倒数的样子。没错他化学最差。但当时强基中南只有化学和数学，数学他第二差，而且数学无聊，所以还是报了化学。说回高考。高考前一两天玩得很舒服。然后我们学校高考期间会在综合楼复习，不会让我们回家和玩手机。高考前一天我们也在那复习，然后空调温度没把握对。所以高考前一天他很难受地感冒了。后面几天空调还是调那么低，所以他一直都是迷糊的状态。晚上的自习除了睡觉发神聊天就复习不进去。但不知道是谁在我最难受的时候顶号帮我高考了。谢谢那个人，如果那个人是他自己的话就谢谢自己吧。最后，除了化学，其他的科目都考到了难以置信的成绩。浅浅炫耀一下，第一次考这么好。

到了填志愿，到的隔壁重庆市和两位高中老师亲戚一起帮忙填的。他的所有志愿都是和计算机相关的，除了之前的强基。志愿填完后强基面试那发来信息，然后马不停蹄地往长沙飞去。哦那是他第一次坐飞机。家长和亲戚也都提醒我面试放水一点，不要被录进去了。嗯他真不太厉害，面试能过才奇怪。但神奇的是最后面试还是过了。面试会问几个有新意、有知识素养以及和学科有关的问题。其中一个是我的化学优势在哪里。哈哈他的化学优势在哪里，高考最差的一科，上课永远听不懂的那一科。他能怎么说呢。就这样说，然后讲了下刘慈欣的科幻给面试老师。然后不知道谁给谁顶号了，反正最后他还是被录取了。你说这奇不奇怪。

军训

军训和大多数人一样没有迟到，没有缺勤，没有抱怨，也没有才艺表演。值得说的就是拆分军体拳和队列的时候。拆分前我们教官一直暗示我们她是教军体拳的(也可能是我理解有误)，所以当时选择的时候很多很多都选了队列(有传言说队列分高一些)，我们班长和隔壁班班长也选了队列。但我们班还是很多男的留在了军体拳，希望是我们教官教我们。最后当结束分人的时候，教官们开玩笑似的对我们军体拳的说：“从今以后你们军体拳的就和我们10连没有关系了！”。当时心凉了一下，后来发现军体拳是挺落寞的。唉。后来有一次教官从军体拳中又挑几个人去队列。没挑到我。但当晚我问了下教官能去不，得到教官肯定的回答后，我第二天就悄悄地混进队列了。累一点，但舒服一点。最后几天和周围同学一起玩狼人杀和谁是卧底，他玩得很开心。

就像我们连长说的，军训是我们最后一次像孩子一样聚集在一起统一行动了，以后大学就没机会这么多人一起了。大概是这个意思。连长说的主要目的是让我们认为大家一起定腿很“浪漫”。他说得对吧。
军训没啥总结的，就那样吧，和大多数人一样。

学习

这一条我要写得最少，因为学习他最差了。上面说过，他化学最差，然后数学第二差吧，高三他是年级认定的数学边缘生。大一上主要学的两科目居然就是无机化学和高等数学。代入一下，理解一下他。最后期末的时候嗯化学上面说过有保护机制，错的很多，但没有感觉。高数是保护机制都没用了。

英语四级的话没有任何复习，在考试前连题型都不知道是什么。能过就行吧，感觉很大概率过不了。嗯还被学长骗了加了个英语口语班。

还花几个小时在中南大学化工官网上仔细分析找了个看起来很好的教授，原本想的是去和教授交流一下，他还提前写了整整4页密密麻麻的碳点小抄，希望和教授交流时能流畅一点。给老师发邮件后老师让我第二天就去找他，比我想象中的快得多。老师也没有和我交流知识相关的，就和我讲了下大一学习相关和英语如何的话题，然后就把我安排给了一个博士…挺快的。去的时候还碰到了这个教授带的另一个大三强基的学姐，她是这个教授另一个课题组的，给我说的教授人很好，当时太紧张了没注意教授好不好。然后这个博士的话说的带我做实验，上个学期各种事耽搁了，下学期一定能做上实验了。

然后最后一节无机化学课下课时问了老师两个问题。他很勇敢的。

团委

他是班上20个人中仅有的5个不是团员之一，但不小心面试加了两个团委的部门。一个是化工院的新媒体部，一个是学校的网信部。谁能想到面试两个都过了呢，一定是他吹牛吹过了。在新媒体部里的工作是编辑微信公众号推文，有正文，小尾巴，封面，还要帮供稿人审错，当然一般是两个人合作。供稿的错误可真多，每次他们文案错了被指点的是我们新媒体小干事。但最后一次编辑的时候供稿已经一个问题都没有了。那一次的排版他还受到了两个审核老师一致的表扬。总共的话编辑了11个推文，还有一个备注的当两个算，还有一次提供文案，可能是新干事中干得最多的，不详细统计。挺好的，有分赚，而且本来我就有自己的博客，也是编辑发推，能学到很多东西。

在网信部的工作就是做前端。你看我自己也有网站和博客，所以刚去的时候还是能完成一些小任务。刚还在军训我就被拉去做一个基地预约的项目。只做了两个页面，两个页面后来还被学长给大改了，但还是学了点前后端通信啥的，名字我都忘了。至少学了东西，还有R赚。后来群里说爬山的项目缺人手，带上个项目的学长就把我推荐过去了。这个项目就添加新功能，修了点bug，又创造了点bug，又自己把bug偷偷补回去了。这个项目我大部分就复制粘贴学长们写好的代码就行了，样式、逻辑只要随便找找就能找到现成的，写得不好的第二天还会自动刷新学长的修改和注释，真神奇。按照学长的话来说，他参与开发过上万人使用过的国内顶级高校永久性重要项目，且被多位中国工程院院士使用过并提出过指导意见。

嗯对我还同时是清华大学所在国家学生，诺贝尔文学奖读者。

所以以后有机会他要申请团员了，这么多贡献应该能过吧。

其他

参加了一次开源鸿蒙技术大会和一次谷歌Dev Fest，收到了deepin的3次还是4次社区小礼物，收到了4个鼠标垫(送走了3个)，翻译并被接纳了两个项目，参与编写了一个Wiki，吹了无数次牛，认识了很多外校的对计算机感兴趣的同学和老师，参加了一次马拉松并跑得很快很快，和以前的高中同学玩了几次游戏，还和整个寝室的同学一起玩了游戏，室友都还挺好，没有传说中的神人，除了未来可能的自己。
刷了很多次电脑手机，这个算扣分项。
被骗了很多次，他不长脑，太容易相信别人了。
敢主动和想要聊天的人聊天了，唉。
买了个主板然后高估自己了。
报了健身房然后没有坚持下去。还好报的是今年的，还有11个月。
给下学期的自己留了好多好多的事要做，报了英语口语班，弄了健身房，找了导师，报了计算机考试，报了英语竞赛，还要报6级，4级没过的话还要4级，期末没过的话还要补考，唉。还选了两个公选课。真想累死下学期的他。但上个学期他又啥都没干，啥都没学。他可真坏。
期末那几天突然沉迷终末地了，这游戏好玩，继续玩。
最后在QQ和微信去重一共添加了70个好友左右。当然对于其他人来说肯定不多，但他来说足够甚至过剩了。但也挺好，多几个好友没啥坏处。

总结

这时候我该翻阅我的日记本，然后根据之前的总结来写一段精简的总结了。但很可惜本子没带。但很有幸我记得每学期我的总结都写的什么：
这学期啥也没干
这学期啥也没干
…
所以按照模板，这学期的总结也如下：
这学期啥也没干

分享一个kde的仿Deepin窗口装饰

Wed, 21 Jan 2026 23:13:30 GMT

分享一个kde的仿Deepin窗口装饰

预览

aurorae版

klassy版

Aurorae版本预览(不推荐，有动画bug)

# 克隆仓库&进入文件夹
git clone git@github.com:SkyShadowHero/skyshadow-aurorae-theme.git
cd skyshadow-aurorae-theme
# 复制主题到用户主题目录
cp -r ./deepin-like-light ~/.local/share/aurorae/themes/

然后在设置 - 颜色和主题 - 窗口装饰元素 里选择对应的主题。

{warning}目前主题底部圆角异常，尝试修复后纯黑窗口可能有白底，所以目前请搭配圆角插件使用，如KDE-Rounded-Corners，我想为了视觉统一应该会使用的这个的吧。

Klassy版本

先安装klassy 到这个网页选择发行版并安装，如果是arch的话直接

yay/paru -S klassy

即可
在这里下载DeepinExp Klassy主题然后同样在设置 - 颜色和主题 - 窗口装饰元素 里面选择 Klassy
再在klassy设置里点击右上角 Presents - add - import from file，然后选择下载好的文件并应用即可

闲话

之前不小心从Deepin转到Kubuntu，发现KDE的主题商店中窗口装饰风格大多模仿macOS或Windows，或是暗色、复古等设计，不太符合个人偏好👀。

所以根据已经习惯的deepin风格改了下Win11OS-light的窗口装饰器，预览如上图所示。

后言

这个主题目前自用，所以只做了亮色和亮色半透明(可添加模糊)主题，如有需要可以添加暗色的。
该项目由Win11OS-kde修改，同样遵循GPL v3 协议。
放在Github上了。

分享一个Linux上的我的世界样式桌面物品栏

Sat, 15 Nov 2025 23:11:30 GMT

分享一个我的世界物品栏桌面组件

使用pyqt5制作，仅在deepin25上测试
因为看隔壁Windows系统上都有我的世界物品栏桌面小部件，而我们deepin却吃不到，所以就想办法自己做一个
当然实力不行，大部分是由llm完成的，等以后学得更多了再自己重新写一遍。

图片预览

已实现功能

拖拽Desktop文件到物品栏格子中
右键编辑格子（右键菜单为我的世界书的样式）
设置大小缩放和窗口位置固定
设置窗口置于底层，置于顶层或正常窗口（置于底层时就跟桌面小部件一样了）

一些操作逻辑

拽桌面上的应用图标（即.desktop文件）到格子里即可将应用放到物品栏里
右键有物品的格子打开右键菜单，可以启动应用，从物品栏移除和设置，退出等
此物品栏设置里可以更改名称和图标路径
总设置里可以选择窗口固定和设置窗口缩放
右键空格子也同理，只是没有启动应用和此物品栏设置
然后可点击格子边的框拖拽窗口移动位置。

格子的配置在.config/desktophotbar/config.json里，也可以手动改改每个格子的配置和窗口位置

启动方式

建议使用python启动
在shell里输入

# 克隆仓库
git clone git@github.com:SkyShadowHero/DesktopHotbar.git
# 创建python虚拟环境
python -m venv venv
# 进入虚拟环境(bash,zsh等)
source ./venv/bin/activate
# 进入虚拟环境(fish)
source ./venv/bin/activate.fish
# 安装pyqt5依赖
pip install pyqt5
# 运行程序
python main.py

即可

当然无聊也通过pyinstaller打包为了二进制，仅amd64,在Releases里，因为打包时要把轮子全打进去，所以内存很大，还是python启动实在。

分享一个mcp应用，可以让你的大模型生成python代码并自动执行

Fri, 26 Sep 2025 23:50:30 GMT

前言

前前言

见帖子分享一个python做的MCP应用在deepin论坛发现UOS AI最近集成了MCP,然后还有个MCP场景大发现活动,就试了试,万一赢了个小鼠标呢。
所以就找llm帮忙做了一个mcp应用，调用本地ollama的(现在也可以用在线api了)。

真前言

上次这个活动也是成功拿到了二等奖，有很多奖品，就顺便更新并整理到了Github上
链接🔗：GitHub

简介

一个用python做的mcp应用，会根据用户输入的内容执行以下操作：

发送要求—>mcp把要求发给大模型(ollama或api)—>生成python代码以实现这个功能—>安装相应依赖—>自动执行。

目前支持ollama和在线api
添加linux上快速初始化脚本（方便UOS AI和其他客户端应用用户导入）
完善依赖安装
细化执行步骤

Linux使用方法

请前往README查看详细方法，这里只分享linux上简单的使用方法

# 克隆项目
git clone https://github.com/SkyShadowHero/McpCoderRunner.git
cd McpCoderRunner
# 运行脚本
./first_launch.sh

然后它会弹出 import_mcp.json 和 mcp_config.json 两个文本
前者里的内容直接复制到支持导入mcp服务的客户端里里导入即可，后者里可以配置模型，如ollama或在线api，

# 使用ollama示例:
{
"llm_config": {
"model": "deepseek-coder-v2:16b",
"base_url": "http://127.0.0.1:11434",
"api_key": "ollama"
}
}

# 使用在线 API (如 DeepSeek )示例:
{
    "llm_config": {
        "model": "deepseek-chat",
        "base_url": "https://api.deepseek.com",
        "api_key": "sk-xxxxxxxxxxxxxxxxxxxx"
    }
}

建议使用deepseek-coder、qwen3-coder等模型

简单演示

获取bing今日美图（使用UOS AI演示，已倍数）

最后还是希望在github里点个star

在deepin上(x11)使用waydroid来运行安卓arm64的应用

Sat, 16 Aug 2025 18:06:21 GMT

前言

分享一下怎么在deepin上(x11)使用waydroid来运行安卓的应用，星火商店里的waydroid运行工具自己用不来，所以是找了很多网上的方法整合出的。
仅支持Intel，amd的我没有所以没法试，nvidia的也试不了
可能有误，欢迎指出

运行方法

1 安装WayDroid

Deepin可直接shell输入

sudo apt install waydroid -y

其他debian系的参考这里的 Ubuntu/Debian and derivatives 一栏

安装依赖

sudo apt install curl ca-certificates -y

添加源

curl -s https://repo.waydro.id | sudo bash

安装WayDroid

sudo apt install waydroid -y

1.5 先简单配置WayDroid

shell里输入

sudo waydroid init

2 安装Weston（用来在x11上运行WayDroid）

sudo apt-get install weston

2.5 简单配置Weston

在~/.config目录里新建一个 weston.ini 文件
里面写上需要的配置，可以去bing搜搜，我这里只写了窗口大小，还可以设置一些scale之类的，虽然没必要，因为安卓子系统似乎缩放会正常

[output]
name=X1
mode=600x1200

3 arm64转译安装

这个应该有更简单的方法，但我使用的waydroid_script,前往它的github按照readme弄好后，运行

sudo venv/bin/python3 main.py

在里面选择

Android 13（目前WayDroid用的是安卓13）
Install
libhoudini（这个是Intel 的ARM 二进制转译器）

然后等待它安装完成即可

4.启动脚本编写

这时候其实就已经可以终端输入weston后再在weston里的终端输入waydroid show-full-ui来运行一个安装子系统了，但懒人不想输入这么多，所以从use-waydroid-on-x11偷了一个sh脚本,随便创建一个sh文件，输入

#!/bin/bash

weston --xwayland &
WESTON_PID=$!
export WAYLAND_DISPLAY=wayland-1
sleep 2

waydroid show-full-ui &
WAYDROID_PID=$!

trap "waydroid session stop; kill $WESTON_PID; kill $WAYDROID_PID" EXIT

wait $WESTON_PID

，然后就可以双击这个sh文件来快捷打开waydroid安卓子系统了
当然可以放个桌面快捷方式，这个大家自己写

5 运行

运行就看自己的了，我就用它白嫖酷狗音乐概念版vip听歌，听歌是正常的

6 一些tips

WayDroid安卓子系统的内部目录在 .local/share/waydroid/data/media/0/ 里，以管理员身份打开
其他更高阶的用法和配置可以去WayDroid或Weston相关网站看看
因为是x11,所以有一些小问题，比如无法使用剪切板
输入法的话请自行下载Fcitx5 for Android（小企鹅）或者安装Google套件后使用Gboard，不然好像无法输入中文
懒的话其实可以直接用use-waydroid-on-x11

Linux上使用fcitx5+rime+雾凇词库和一些双拼配置

Thu, 14 Aug 2025 15:49:22 GMT

前言

在一个灵车群看到有人争论说一个输入法没有云拼音就没法用，就有人回复说他用fcitx5+rime+雾凇词库挺好的，所以我也去试了试使用Deepin做演示，输入法为雾凇词库自带的小鹤双拼

安装fcitx5

deepin默认自带fcitx5,所以无需其他操作来安装，如果是其他没有fcitx5的系统的话，可以查看官方wiki或知乎教程

安装fcitx5-rime

shell里输入

sudo apt-get install fcitx5-rime

后重启电脑即可

安装雾凇词库

前往Github，安装readme说的做，因为我后面会使用github来备份我的配置和词库，所以就是手动安装的方法，即将仓库打包下载，将所有文件复制粘贴到 RIME 前端的配置目录，重新部署。 RIME配置目录在linux上位于

.local/share/fcitx5/rime

一些小鹤双拼的配置

因为我不会使用git来更新，所以没有使用打补丁的方式，如有需求，可以按照这里的方法进行打补丁

双拼模糊音

在 double_pinyin_flypy.schema.yaml 文件里的 speller/algebra: 里加上

    - derive/([ei])n$/$1ng/            # en => eng, in => ing
    - derive/([ei])ng$/$1n/            # eng => en, ing => in
    - derive/^([zcs])h/$1/             # zh, ch, sh => z, c, s

即可，但要注意这三行要放在 - xform 行的前面才行

双拼启用首字母简拼

同样在speller/algebra:里加上

    - abbrev/^([a-z]).+$/$1/        # 简拼
    - abbrev/^([zcs]h).+$/$1/       # zh,ch,sh等模糊音简拼

即可，放在最后
我的拼写设定就修改为了

# 拼写设定
speller:
  # 如果不想让什么标点直接上屏，可以加在 alphabet，或者编辑标点符号为两个及以上的映射
  alphabet: zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA`
  # initials 定义仅作为始码的按键，排除 ` 让单个的 ` 可以直接上屏
  initials: zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA
  delimiter: " '"  # 第一位<空格>是拼音之间的分隔符；第二位<'>表示可以手动输入单引号来分割拼音。
  algebra:
    - erase/^xx$/
    - derive/^([jqxy])u$/$1v/
    - derive/^([aoe])([ioun])$/$1$1$2/
    - derive/([ei])n$/$1ng/            # en => eng, in => ing
    - derive/([ei])ng$/$1n/            # eng => en, ing => in
    - derive/^([zcs])h/$1/             # zh, ch, sh => z, c, s
    - derive/^([zcs])([^h])/$1h$2/
    - xform/^([aoe])(ng)?$/$1$1$2/
    - xform/iu$/Ⓠ/
    - xform/(.)ei$/$1Ⓦ/
    - xform/uan$/Ⓡ/
    - xform/[uv]e$/Ⓣ/
    - xform/un$/Ⓨ/
    - xform/^sh/Ⓤ/
    - xform/^ch/Ⓘ/
    - xform/^zh/Ⓥ/
    - xform/uo$/Ⓞ/
    - xform/ie$/Ⓟ/
    - xform/(.)i?ong$/$1Ⓢ/
    - xform/ing$|uai$/Ⓚ/
    - xform/(.)ai$/$1Ⓓ/
    - xform/(.)en$/$1Ⓕ/
    - xform/(.)eng$/$1Ⓖ/
    - xform/[iu]ang$/Ⓛ/
    - xform/(.)ang$/$1Ⓗ/
    - xform/ian$/Ⓜ/
    - xform/(.)an$/$1Ⓙ/
    - xform/(.)ou$/$1Ⓩ/
    - xform/[iu]a$/Ⓧ/
    - xform/iao$/Ⓝ/
    - xform/(.)ao$/$1Ⓒ/
    - xform/ui$/Ⓥ/
    - xform/in$/Ⓑ/
    - xlit/ⓆⓌⓇⓉⓎⓊⒾⓄⓅⓈⒹⒻⒼⒽⒿⓀⓁⓏⓍⒸⓋⒷⓃⓂ/qwrtyuiopsdfghjklzxcvbnm/
    - abbrev/^([a-z]).+$/$1/
    - abbrev/^([zcs]h).+$/$1/

输入时显示双拼编码而不展开

把 translator/preedit_format: 下的内容全部删掉即可

最后我使用的patch方案

在 double_pinyin_flypy.custom.yaml 里写上

# double_pinyin_flypy.custom.yaml
# 小鹤双拼自定义配置补丁

patch:
  speller/algebra:
    - erase/^xx$/
    - derive/^([jqxy])u$/$1v/
    - derive/^([aoe])([ioun])$/$1$1$2/
    - derive/([ei])n$/$1ng/            # en => eng, in => ing
    - derive/([ei])ng$/$1n/            # eng => en, ing => in
    - derive/^([zcs])h/$1/             # zh, ch, sh => z, c, s
    - derive/^([zcs])([^h])/$1h$2/
    - xform/^([aoe])(ng)?$/$1$1$2/
    - xform/iu$/Ⓠ/
    - xform/(.)ei$/$1Ⓦ/
    - xform/uan$/Ⓡ/
    - xform/[uv]e$/Ⓣ/
    - xform/un$/Ⓨ/
    - xform/^sh/Ⓤ/
    - xform/^ch/Ⓘ/
    - xform/^zh/Ⓥ/
    - xform/uo$/Ⓞ/
    - xform/ie$/Ⓟ/
    - xform/(.)i?ong$/$1Ⓢ/
    - xform/ing$|uai$/Ⓚ/
    - xform/(.)ai$/$1Ⓓ/
    - xform/(.)en$/$1Ⓕ/
    - xform/(.)eng$/$1Ⓖ/
    - xform/[iu]ang$/Ⓛ/
    - xform/(.)ang$/$1Ⓗ/
    - xform/ian$/Ⓜ/
    - xform/(.)an$/$1Ⓙ/
    - xform/(.)ou$/$1Ⓩ/
    - xform/[iu]a$/Ⓧ/
    - xform/iao$/Ⓝ/
    - xform/(.)ao$/$1Ⓒ/
    - xform/ui$/Ⓥ/
    - xform/in$/Ⓑ/
    - xlit/ⓆⓌⓇⓉⓎⓊⒾⓄⓅⓈⒹⒻⒼⒽⒿⓀⓁⓏⓍⒸⓋⒷⓃⓂ/qwrtyuiopsdfghjklzxcvbnm/
    - abbrev/^([a-z]).+$/$1/        # 简拼
    - abbrev/^([zcs]h).+$/$1/       # zh,ch,sh等模糊音简拼

  # 输入时显示双拼编码而不展开
  translator/preedit_format: {}

其他

如果想使用小鹤音形输入的话，可以去凇鹤拼音Github看看

简单修改Linux的默认emoji

Wed, 13 Aug 2025 11:08:43 GMT

先看看不同emoji的样式

图一是Noto的，linux和大部分安卓系统自带emoji
图二是HMOS的，华为鸿蒙的所有系统自带emoji
图三是IOS的，苹果设备自带emoji

怎么修改呢

简单方法

复制替换即可

如果是安卓的话可能还需要magisk模块来实现，但是linux可就简单多了，下载相应emoji的ttf字体后，重命名 NotoColorEmoji ，然后复制到 /usr/share/fonts/truetype/noto 里即能完成emoji的切换但这个方法简单，也有不足，emoji覆盖不全

复杂方法

修改linux的配置

修改配置

前往 .config/fontconfig/conf.d 文件夹添加 01-hmos-emoji.conf
在 01-hmos-emoji.conf 文件里输入

<?xml version="1.0"?>
<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
<fontconfig>
    <!-- 1. 将常见的emoji字体别名指向HMOS -->
    <alias binding="strong">
        <family>Apple Color Emoji</family>
        <prefer>
            <family>HMOS Color Emoji</family>
        </prefer>
    </alias>
    
    <alias binding="strong">
        <family>Segoe UI Emoji</family>
        <prefer>
            <family>HMOS Color Emoji</family>
        </prefer>
    </alias>
    
    <alias binding="strong">
        <family>Noto Color Emoji</family>
        <prefer>
            <family>HMOS Color Emoji</family>
        </prefer>
    </alias>
    
    <alias binding="strong">
        <family>emoji</family>
        <prefer>
            <family>HMOS Color Emoji</family>
        </prefer>
    </alias>
    
    <!-- 2. 针对所有字体匹配，添加HMOS到字体列表 -->
    <match target="pattern">
        <test name="family" compare="eq">
            <string>sans-serif</string>
        </test>
        <edit name="family" mode="prepend">
            <string>HMOS Color Emoji</string>
        </edit>
    </match>
    
    <match target="pattern">
        <test name="family" compare="eq">
            <string>serif</string>
        </test>
        <edit name="family" mode="prepend">
            <string>HMOS Color Emoji</string>
        </edit>
    </match>
    
    <match target="pattern">
        <test name="family" compare="eq">
            <string>monospace</string>
        </test>
        <edit name="family" mode="prepend">
            <string>HMOS Color Emoji</string>
        </edit>
    </match>
</fontconfig>

如果想要系统级而不是用户级的话就把这个文件添加到 /etc/fonts/conf.d/ 里。

将字体添加进系统字体

进入 /usr/share/fonts/truetype 文件，创建一个 hmos 文件夹，然后把HMOSColorEmojiCompat.ttf文件放进去即可

诶或许可以直接安装字体就行了👀。

刷新字体缓存

shell里输入

sudo fc-cache -f -v

刷新缓存，然后重启电脑可以通过以下命令检验字体是否被系统正确识别

fc-list | grep "HMOS"

我的输出为

SkyShadowHero@SkyShadowHero-Deepin ~/Desktop> fc-list | grep "HMOS"                                           
/usr/share/fonts/truetype/hmos/HMOSColorEmojiCompat.ttf: HMOS Color Emoji:style=Regular
/home/SkyShadowHero/.local/share/fonts/HMOS Color Emoji/HMOSColorEmojiCompat.ttf: HMOS Color Emoji:style=Regular

即代表已成功识别

后言

其他的emoji字体也应该可以通过同样的方法替换，顺便分享一下HMOSColorEmojiCompat.ttf文件，~~这是以前刷手机时，从一个鸿蒙的系统包里拆出来的 123云盘链接🔗 提取码:eQNA~~
又从DevCo里面的镜像里提取了最新鸿蒙6的ttf字体出来,似乎是emoji unicode15.1的，123云盘链接🔗 提取码:CtKW

后后言

~~为了这个封面图，找不到好用明了的字体管理器，我甚至找llm用pyqt5重新做了一个，好神奇~~
字体预览器Github仓库地址

此博客已转移至新Astro博客中

Fri, 08 Aug 2025 09:14:43 GMT

先说说为什么会出现这个博客

这个博客是hexo+butterfly和自己的一点美化做出来的，具体时间已经忘了，但翻看和一位同学的聊天记录，至少是在2022/10/28以前，也就是刚步入高中的时候

当时高中会提前在暑假时军训，就认识了很多新同学，其中床对面的室友自我介绍说他是个计算机爱好者，恰巧我也喜欢玩电脑。
高一也喜欢炫耀和分享，那位同学在那个暑假用z-blog做了自己的博客，而我用namelessmc做了一个神奇的论坛 ~~现在觉得自己想法太神奇了~~

独乐乐不如众乐乐，那位同学跟我说了论坛国内要申请什么什么的，做博客有多好多好的，所以后来我也用z-blog做了博客
虽然我发现自己的博客和别人的有点不一样
但一会就开学了，开学有个入学考试，考完后，额就放假了(因为疫情)
这次放假放了一个月左右，在家也是干些无聊的（主要当时电脑差，玩游戏玩不了，前台挂个网课，后台真的什么都做不了）
还是那句高一喜欢炫耀和分享，我在Q群里挺活跃，也喜欢把自己的博客给其他人看，当时还是z-blog
~~返校了还有人开心地问我啊你是不是群里的天影大侠呢~~

最后发现不一样的原因是我看到的那些博客好多都用的hexo
当时看着什么nodejs,什么git还是觉得挺难
但之前的z-blog用的都是很神奇的免费域名，什么.is.best，什么.gal，都是不知哪免费弄的，看到托管到github上有.github.io这个二级域名，挺想弄过去的

所以高一应该就转到hexo+butterfly了，但肯定不早，因为我在一次运动会上用班上破电脑把我的网站给上面那位同学看，因为用的二级域名不安全所以跳到了一个神奇的网站 ~~可太神奇了~~
不久后在github上还是嫖到了.is-cool.dev这个安全正常的二级域名，用在了我的hexo博客上
以前博客有啥加啥，雪花特效，彩带背景，振动特效，烟花特效，访问地图，等等，看起来挺花的，内容的话就没有什么东西了，都是些没有用的。

后来在高一高二慢慢删减修改成了现在的样子
链接: 天影大侠的小站

为什么会转移新博客呢

现在高考结束了
以前用butterfly的时候，就觉得每次要加新东西，都要去改别人的主题，去网上看教程加上别人做过的东西
我想不可能一直这样吧

而且hexo用起来网站加载速度太慢了，后来嫖了个cdn也很慢。
所以就用astro做了一个，样式按照旧博客来做的用的Tailwindcss。
在重写这个博客之前还用tailwindcss写了个个人主页，在互联网留下一个脚印

域名是18岁给自己买的.fun域名(当时.top,.xyz那些都被注册了，谁知道现在这个域名这么坑)

自己写markdown的样式(其实是手误不小心把astro默认的md样式css删了),写我的世界栅栏风格的分割线样式，写虽然丑但是有深度的代码块样式，写大屏和小屏不同的导航栏，写页脚这些，从头到脚都差不多自己编写（当然找了llm帮忙），虽然很乱，但知道哪个功能放在哪个文件，有bug会第一时间责备自己，而不是一个主题或框架的问题。

现在还有很多没有完成，文章卡片分页(已完成)，最近文章卡片，图片放大查看(已完成)，标签页，分类页等等
但能凑合着用，已经把主站迁移过来了

链接: 天影大侠的小站
旧站也不会删，虽然只有自己会看了

分享一个python做的MCP应用

Wed, 06 Aug 2025 13:14:43 GMT

前言

在deepin论坛发现UOS AI最近集成了MCP,然后还有个MCP场景大发现活动，地址,就试了试，万一赢了个小鼠标呢。
所以就找llm帮忙做了一个mcp应用，调用本地ollama的。

介绍

功能很简单，输入需求，如

请帮我 xxx

然后该mcp应用会实现以下功能

调用本地ollama模型来根据xxx生成相应python代码
创建虚拟环境或使用已创建的虚拟环境
自动安装依赖或你的llm通过输入 pip install xxx 来帮忙安装依赖
执行代码，并发出日志

这样就实现了一个几乎可以帮你完成任何任务的mcp工具！

运行时会创建一个文件夹放生成的py,同时会使用一个共用的env，deepseek或其他llm在执行命令发现依赖问题时会尝试pip install xxx，把这个指令单独弄了出来识别并执行

简单演示

图中为Deepseek+UOS AI+这个mcp服务

svg图片换色

把一个蓝色的b站小图标换为粉色

文字生成

在一个文本里生成一些废话

网络功能

抓取bing美图到本地

复杂任务

将MiSans字体中的天影大侠提取出来绘制为白色图片并添加黑色边框

当然python有无限的可能

代码(2025/8/28修改)

import os
import re
import sys
import json
import logging
import subprocess
import datetime
from pathlib import Path
from typing import Dict, Any, Optional, Set, Tuple

# 导入 MCP 核心库
from mcp.server.fastmcp import FastMCP, Context

# 导入 LangChain 和 Pydantic
from langchain_community.llms import Ollama
from pydantic import BaseModel, Field

# --- 全局日志配置 (用于服务本身) ---
# 这个 logger 用于记录服务启动、关闭等非任务相关的核心日志
global_logger = logging.getLogger("mcp_service")
if not global_logger.handlers:
    global_logger.setLevel(logging.INFO)
    handler = logging.StreamHandler(sys.stdout)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    global_logger.addHandler(handler)


# --- MCP 服务器定义 ---
mcp = FastMCP(name="SkyShadowHero Task Execution Server")

# --- Pydantic 返回模型 ---
class ExecutionStage(BaseModel):
    code_generation: str
    dependency_installation: str
    execution: str

class ExecutionResult(BaseModel):
    stages: ExecutionStage
    code: str
    output: str
    error: str
    work_dir: str
    returncode: int

class ServerInfo(BaseModel):
    name: str
    model: Optional[str]
    status: str

class CommandOutput(BaseModel):
    status: str
    result: ExecutionResult
    server: ServerInfo

# --- 配置管理 ---
class MCPConfig:
    _instance = None
    config_path = Path(__file__).parent / "mcp_config.json"

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.load_config()
        return cls._instance

    def load_config(self):
        if not self.config_path.exists():
            self.config = {
                "mcpServers": {
                    "default": {
                        "model": "deepseek-coder-v2:16b",
                        "task_templates": {
                            "file_operations": {
                                "prompt": (
                                    "你是一个顶级的Python自动化专家。你的任务是根据用户的自然语言指令，生成一段完整、健壮、可直接在标准Python环境中执行的脚本。你拥有完全的创作自由，但必须严格遵守以下规范。\n\n"
                                    "## 用户指令:\n"
                                    "{task}\n\n"
                                    "## 代码生成规范 (必须严格遵守):\n"
                                    "1.  **【代码纯净性】**: 你的输出必须是纯粹的Python代码。绝对禁止包含任何Markdown标记，尤其是 ` ```python ` 和 ` ``` `。\n"
                                    "2.  **【依赖声明】**: 如果代码需要任何第三方库 (例如 `requests`, `pandas`)，必须在代码的最开始，使用 `# REQUIRE: <package_name>` 的格式进行声明。**每个依赖独立一行**。如果不需要任何第三方库，则完全不要写 `# REQUIRE:` 注释。\n"
                                    "3.  **【日志记录】**: 必须使用Python的 `logging` 模块。在脚本开始处配置好 `basicConfig`，确保日志同时输出到控制台(stdout)和当前工作目录下的 `task.log` 文件。在关键步骤和任何 `except` 块中，都必须使用 `logging.info()` 或 `logging.error()` 进行记录。\n"
                                    "4.  **【错误处理】**: 所有可能失败的操作都必须被包含在 `try...except Exception as e:` 块中。\n"
                                    "5.  **【成功信号】**: 在脚本所有操作成功完成的最后，必须调用 `print(\"任务成功完成\")`。\n"
                                    "6.  **【完整性】**: 生成的代码必须是完整的、自包含的，包含所有必要的 `import` 语句。\n\n"
                                    "现在，请根据用户指令生成代码。"
                                ),
                            }
                        }
                    }
                }
            }
            self.save_config()
        else:
            with open(self.config_path, 'r', encoding='utf-8') as f:
                self.config = json.load(f)

    def save_config(self):
        with open(self.config_path, 'w', encoding='utf-8') as f:
            json.dump(self.config, f, indent=2, ensure_ascii=False)

    def get_server(self, name: str) -> Optional[Dict[str, Any]]:
        return self.config.get("mcpServers", {}).get(name)

# --- 【最终修复架构】核心逻辑封装 ---
class TaskWorkflow:
    def __init__(self):
        self.config = MCPConfig().config
        self.llm_cache = {}
        self.standard_libs = self._get_standard_libs()
        script_dir = Path(__file__).parent.resolve()
        self.shared_work_dir = script_dir / "mcp_tasks"
        self.shared_work_dir.mkdir(exist_ok=True)

        global_logger.info("正在初始化并检查共享虚拟环境...")
        try:
            self.venv_path = self.shared_work_dir / "venv"
            self.python_executable, self.pip_executable = self._create_virtual_env(str(self.venv_path))
            global_logger.info(f"共享虚拟环境已就绪。Python: {self.python_executable}, Pip: {self.pip_executable}")
        except Exception as e:
            global_logger.error(f"初始化共享虚拟环境失败: {e}", exc_info=True)
            raise RuntimeError(f"无法创建或验证共享虚拟环境，服务无法启动。错误: {e}")

    def _get_standard_libs(self) -> Set[str]:
        common_libs = {'os', 'sys', 'json', 're', 'logging', 'subprocess', 'pathlib', 'datetime', 'time', 'math', 'random', 'collections', 'itertools', 'functools', 'glob', 'shutil', 'tempfile', 'argparse', 'typing', '__future__'}
        if sys.version_info >= (3, 10):
            try:
                from sys import stdlib_module_names
                return set(stdlib_module_names)
            except ImportError:
                return common_libs
        return common_libs

    async def get_llm(self, model_name: str) -> Ollama:
        if model_name not in self.llm_cache:
            global_logger.info(f"正在加载模型: {model_name}")
            self.llm_cache[model_name] = Ollama(model=model_name, temperature=0.1, top_p=0.9, timeout=300)
        return self.llm_cache[model_name]

    def _create_virtual_env(self, venv_path_str: str) -> Tuple[str, str]:
        venv_path = Path(venv_path_str)
        if sys.platform == "win32":
            python_exe = venv_path / 'Scripts' / 'python.exe'
            pip_exe = venv_path / 'Scripts' / 'pip.exe'
        else:
            python_exe = venv_path / 'bin' / 'python'
            pip_exe = venv_path / 'bin' / 'pip'

        if not python_exe.exists() or not pip_exe.exists():
            global_logger.info(f"共享虚拟环境不完整或不存在，正在创建于: {venv_path_str}")
            try:
                subprocess.run(
                    [sys.executable, "-m", "venv", venv_path_str],
                    check=True, capture_output=True, text=True, timeout=120
                )
            except subprocess.CalledProcessError as e:
                global_logger.error(f"创建虚拟环境失败: {e.stderr}")
                raise RuntimeError(f"创建虚拟环境失败，错误: {e.stderr}")
  
        if not python_exe.exists() or not pip_exe.exists():
             raise FileNotFoundError(f"虚拟环境创建后，未找到 Python/Pip 可执行文件。")
  
        global_logger.info("虚拟环境验证成功。")
        return str(python_exe), str(pip_exe)

    def _post_process_code(self, generated_code: str) -> Tuple[str, Set[str]]:
        cleaned_code = re.sub(r"```python\n|```", "", generated_code).strip()
        required_deps = set(re.findall(r"#\s*REQUIRE:\s*(\S+)", cleaned_code))
        final_code = "\n".join([line for line in cleaned_code.split('\n') if not line.strip().startswith("# REQUIRE:")])
        global_logger.info(f"代码后处理完成。提取的依赖: {required_deps or '无'}。")
        return final_code.strip(), required_deps

    def _install_dependencies(self, deps: Set[str], task_work_dir: Path):
        if not deps:
            global_logger.info("代码中未发现 # REQUIRE: 声明，跳过依赖安装。")
            return
        
        deps_to_install = {dep for dep in deps if dep.lower() not in self.standard_libs}
        if not deps_to_install:
            global_logger.info(f"所有声明的依赖 {list(deps)} 均为标准库，无需安装。")
            return

        # 确保文件名是 requirements.txt
        requirements_path = task_work_dir / "requirements.txt"
        with open(requirements_path, 'w', encoding='utf-8') as f:
            for dep in deps_to_install:
                f.write(f"{dep}\n")
        global_logger.info(f"已生成依赖文件: {requirements_path}")

        command = [self.pip_executable, "install", "-r", str(requirements_path)]
        global_logger.info(f"执行依赖安装命令: {' '.join(command)}")
  
        result = subprocess.run(
            command,
            cwd=str(task_work_dir),
            capture_output=True,
            text=True,
            timeout=300,
            check=False,
            encoding='utf-8',
        )
  
        if result.returncode != 0:
            error_message = f"依赖安装失败: {result.stderr}"
            global_logger.error(error_message)
            raise RuntimeError(error_message)
      
        global_logger.info(f"依赖 {list(deps_to_install)} 安装成功。")

    def _execute_code(self, code_to_execute: str, task_work_dir: str) -> Dict[str, Any]:
        script_name = "generated_script.py"
        code_path = os.path.join(task_work_dir, script_name)
        with open(code_path, "w", encoding="utf-8") as f:
            f.write(code_to_execute)
  
        global_logger.info(f"最终执行的脚本已保存至: {code_path}")
  
        command = [self.python_executable, script_name]
        global_logger.info(f"执行代码命令: {' '.join(command)}")
  
        result = subprocess.run(
            command,
            cwd=task_work_dir,
            capture_output=True,
            text=True,
            timeout=300,
            check=False,
            encoding='utf-8',
        )
  
        return {"output": result.stdout, "error": result.stderr, "returncode": result.returncode}

    def _is_direct_command(self, instruction: str) -> bool:
        common_commands = ['python', 'pip', 'uv', 'bash', 'sh', 'ls', 'rm', 'cp', 'mv', 'mkdir']
        return any(instruction.strip().startswith(cmd) for cmd in common_commands)

    def _execute_direct_command(self, command: str, task_work_dir: str) -> Dict[str, Any]:
        global_logger.info(f"检测到直接命令，将在虚拟环境中执行: {command}")
  
        if sys.platform == "win32":
            activate_script = Path(self.python_executable).parent / "activate.bat"
            full_command = f'call "{activate_script}" && {command}'
        else:
            activate_script = Path(self.python_executable).parent / "activate"
            full_command = f'. "{activate_script}" && {command}'

        result = subprocess.run(
            full_command,
            cwd=task_work_dir,
            capture_output=True,
            text=True,
            timeout=300,
            check=False,
            encoding='utf-8',
            shell=True,
            executable='/bin/bash' if sys.platform != "win32" else None
        )
  
        return {"output": result.stdout, "error": result.stderr, "returncode": result.returncode}

    async def run_workflow(self, instruction: str, server_name: str, ctx: Context):
        result = {
            "stages": {
                "code_generation": "pending",
                "dependency_installation": "pending",
                "execution": "pending"
            },
            "code": "", "output": "", "error": "", "work_dir": "", "returncode": -1
        }
        
        try:
            timestamp = datetime.datetime.now().strftime("task_%Y%m%d_%H%M%S")
            task_work_dir = self.shared_work_dir / timestamp
            task_work_dir.mkdir(exist_ok=True)
            result["work_dir"] = str(task_work_dir)
            
            global_logger.info(f"任务 '{timestamp}' 启动，指令: '{instruction}'")
            await ctx.info(f"任务工作目录已创建: {task_work_dir}")

            # --- 指令嗅探和模式切换 ---
            if self._is_direct_command(instruction):
                await ctx.info("检测到直接命令模式。")
                result["stages"]["code_generation"] = "skipped (direct command)"
                result["stages"]["dependency_installation"] = "skipped (direct command)"
                result["code"] = f"# Direct Command Execution\n{instruction}"

                result["stages"]["execution"] = "pending"
                await ctx.info(f"正在直接执行命令: {instruction}")
                exec_result = self._execute_direct_command(instruction, str(task_work_dir))
                result.update(exec_result)
          
                is_successful = exec_result.get("returncode") == 0
                result["stages"]["execution"] = "success" if is_successful else "failed"
                final_status = "success" if is_successful else "failed"
                
                global_logger.info(f"直接命令执行完成。状态: {final_status}。")
          
                return {"status": final_status, "result": result, "server": {"name": server_name, "model": "N/A (Direct Command)", "status": "active"}}
      
            # --- 如果不是直接命令，则执行原有的 LLM 工作流 ---
            await ctx.info("进入 LLM 代码生成模式。")
            server_config = self.config.get("mcpServers", {}).get(server_name)
            if not server_config: raise ValueError(f"服务器 '{server_name}' 未配置")
      
            template = server_config["task_templates"]["file_operations"]
            prompt = template["prompt"].format(task=instruction)
      
            await ctx.info(f"正在使用模型 '{server_config['model']}' 生成代码...")
            llm = await self.get_llm(server_config['model'])
            generated_code = await llm.ainvoke(prompt)
            result["stages"]["code_generation"] = "success"
            await ctx.info("代码生成成功。")
      
            pure_code, dependencies = self._post_process_code(generated_code)
            result["code"] = pure_code
      
            result["stages"]["dependency_installation"] = "pending"
            await ctx.info(f"正在检查并安装依赖: {dependencies or '无'}")
            self._install_dependencies(dependencies, task_work_dir)
            result["stages"]["dependency_installation"] = "success"
            await ctx.info("所有依赖已就绪。")
      
            result["stages"]["execution"] = "pending"
            await ctx.info("正在执行生成的代码...")
            exec_result = self._execute_code(pure_code, str(task_work_dir))
      
            result.update(exec_result)
      
            is_successful = "任务成功完成" in exec_result.get("output", "")
            result["stages"]["execution"] = "success" if is_successful else "failed"

            final_status = "success" if is_successful else "failed"
            global_logger.info(f"代码执行完成。状态: {final_status}。")
            return {"status": final_status, "result": result, "server": {"name": server_name, "model": server_config.get("model"), "status": "active"}}

        except Exception as e:
            current_stage = next((s for s, status in result["stages"].items() if status == "pending"), "unknown")
            result["stages"][current_stage] = "failed"
            error_message = f"在 '{current_stage}' 阶段失败: {e}"
            result["error"] = error_message
            global_logger.error(error_message, exc_info=True)
            await ctx.error(error_message)
      
            for stage, status in result["stages"].items():
                if status == "pending":
                    result["stages"][stage] = "skipped"

            return {"status": "failed", "result": result, "server": {"name": server_name, "model": self.config.get("mcpServers", {}).get(server_name, {}).get("model"), "status": "error"}}

# --- 单例和工具定义 ---
workflow_executor = TaskWorkflow()

@mcp.tool()
async def do_it_using_python(
    instruction: str = Field(
        description="用户用自然语言下达的、需要在本地计算机上执行的具体任务指令。例如：'在桌面上创建一个名为'todo.txt'的文件' 或 '将/home/user/docs目录下的所有.log文件压缩成一个zip包'。"
    ),
    server: str = Field(default="default", description="要使用的服务器配置名称。"),
    ctx: Context = Field(exclude=True)
) -> CommandOutput:
    """
    当用户需要执行任何与文件、文件夹或系统相关的本地操作时，请使用此工具。
    此工具接收一条自然语言指令，将其转换为可执行的Python代码，并在安全的虚拟环境中运行，然后返回详细的执行结果。
    """
    try:
        await ctx.info(f"收到指令，开始处理: '{instruction}'")
  
        result_dict = await workflow_executor.run_workflow(
            instruction=instruction,
            server_name=server,
            ctx=ctx
        )
  
        await ctx.info("任务流程执行完毕。")
  
        return CommandOutput.model_validate(result_dict)
    except Exception as e:
        global_logger.error(f"执行工具时发生严重错误: {e}", exc_info=True)
        await ctx.error(f"执行工具时发生严重错误: {e}")
  
        return CommandOutput(
            status="failed",
            result=ExecutionResult(
                stages=ExecutionStage(
                    code_generation="failed",
                    dependency_installation="skipped",
                    execution="skipped"
                ),
                code="",
                output="",
                error=f"执行工具时发生顶层错误: {e}",
                work_dir="",
                returncode=-1
            ),
            server=ServerInfo(name=server, model=None, status="error")
        )

# --- 服务器启动---
def run():
    """
    服务器主入口函数。
    """
    try:
        subprocess.run(["ollama", "list"], check=True, capture_output=True, text=True)
        global_logger.info("Ollama 服务已在运行。")
    except (subprocess.CalledProcessError, FileNotFoundError):
        global_logger.warning("Ollama服务未运行，请确保Ollama已安装并正在运行。")
  
    mcp.run()

if __name__ == "__main__":
    run()

大功告成，可以使用mcp+ollama+python实现的万能工具了！

分享一个python做的我的世界mod批量下载工具

Wed, 30 Jul 2025 16:16:27 GMT

前言

Mojang太会刷版本号了，而每一次更新都要重新把自己想用的mod全部下载一遍
为了节省时间，就做了这个东西
找的mauns和deepseek帮忙
只支持modrinth的mod下载，因为courseforge弄不来
支持forge,fabric,quilt,neoforge

代码

使用前请先

pip install asyncio aiohttp tqdm

# 引入一些东西
import os  
import asyncio  
import aiohttp  
from tqdm import tqdm  
import platform  
import zipfile  
import json  
import hashlib  

# 颜色
C_RED = "\033[91m";   
C_GREEN = "\033[92m";   
C_YELLOW = "\033[93m";  
C_BLUE = "\033[94m";   
C_CYAN = "\033[96m";   
C_MAGENTA = "\033[95m";  
C_RESET = "\033[0m";   
C_BOLD = "\033[1m"  

# print
def print_color(message, color ): print(f"{color}{message}{C_RESET}")  
def print_title(message): print_color(f"\n{'='*10} {message} {'='*10}", f"{C_CYAN}{C_BOLD}")  
def print_success(message): print_color(f"✓ {message}", C_GREEN)  
def print_warning(message): print_color(f"⚠️ {message}", C_YELLOW)  
def print_error(message): print_color(f"✗ {message}", C_RED)  
def print_info(message): print_color(f"ℹ️ {message}", C_BLUE)  
def print_local(message): print_color(f"Found: {message}", C_MAGENTA)  

class ModUpdater:  
    MODRINTH_API_URL = "https://api.modrinth.com/v2"
    USER_AGENT = "一个mod下载工具"
    PATHS_FILE = "mod_paths.json"
    TQDM_BAR_FORMAT = "{l_bar}{bar:20}| {n_fmt}/{total_fmt}"

    def __init__(self, mc_version, mod_loader, mod_folder ):
        self.mc_version = mc_version
        self.mod_loader = mod_loader
        self.mod_folder = mod_folder
        self.download_dir = f"{self.mc_version}-{self.mod_loader}"
        os.makedirs(self.download_dir, exist_ok=True)

    @staticmethod
    def load_paths():
        if not os.path.exists(ModUpdater.PATHS_FILE): return []
        try:
            with open(ModUpdater.PATHS_FILE, 'r', encoding='utf-8') as f: return json.load(f)
        except (json.JSONDecodeError, IOError): return []

    @staticmethod
    def save_paths(paths):
        try:
            with open(ModUpdater.PATHS_FILE, 'w', encoding='utf-8') as f: json.dump(paths, f, indent=2)
        except IOError as e: print_error(f"无法保存路径文件: {e}")

    def _calculate_sha1(self, filepath):
        sha1 = hashlib.sha1()
        with open(filepath, 'rb') as f:
            while chunk := f.read(8192):
                sha1.update(chunk)
        return sha1.hexdigest()

    async def _api_request(self, session, method, url, **kwargs):
        try:
            async with session.request(method, url, **kwargs) as resp:
                if resp.status == 200: return await resp.json()
        except aiohttp.ClientError: pass
        return None

    async def _get_project_info(self, session, project_id ):
        url = f"{self.MODRINTH_API_URL}/project/{project_id}"
        return await self._api_request(session, "GET", url)

    async def _download_file(self, session, version_id, pbar):
        try:
            url = f"{self.MODRINTH_API_URL}/version/{version_id}"
            version_data = await self._api_request(session, "GET", url)
            if not version_data: raise ValueError("无法获取版本信息")

            file_info = version_data["files"][0]
            download_url, name = file_info["url"], file_info["filename"]
            path = os.path.join(self.download_dir, name)

            async with session.get(download_url) as r:
                r.raise_for_status()
                with open(path, "wb") as f:
                    while True:
                        chunk = await r.content.read(8192)
                        if not chunk: break
                        f.write(chunk)
            pbar.update(1)
            return name, True
        except Exception:
            pbar.update(1)
            return None, False

    async def run(self):
        print_info(f"模组将被下载到: ./{self.download_dir}/")
        print_title("1. 扫描并识别本地模组")
        jar_files = [os.path.join(self.mod_folder, f) for f in os.listdir(self.mod_folder) if f.endswith(".jar")]
        hashes = [self._calculate_sha1(f) for f in tqdm(jar_files, desc="计算哈希", bar_format=self.TQDM_BAR_FORMAT, ascii=' -')]

        local_projects = {}
        async with aiohttp.ClientSession(headers={"User-Agent": self.USER_AGENT} ) as session:
            url = f"{self.MODRINTH_API_URL}/version_files"
            version_data = await self._api_request(session, "POST", url, json={"hashes": hashes, "algorithm": "sha1"})
            
            if not version_data:
                print_error("无法从 Modrinth API 获取任何模组信息。")
                return

            print_info("从你选择的mod文件夹中找到以下模组:")
            project_ids = {info['project_id'] for info in version_data.values()}
            project_infos = await asyncio.gather(*[self._get_project_info(session, pid) for pid in project_ids])
            
            for info in project_infos:
                if info:
                    local_projects[info['id']] = info
                    print_local(info['title'])

            unidentified_hashes = [h for h in hashes if h not in version_data]

            print_title(f"2. 下载 {len(local_projects)} 个mod")
            version_tasks = []
            for pid in local_projects.keys():
                url = f"{self.MODRINTH_API_URL}/project/{pid}/version"
                params = {"loaders": f'["{self.mod_loader}"]', "game_versions": f'["{self.mc_version}"]'}
                version_tasks.append(self._api_request(session, "GET", url, params=params))
            
            versions_results = await asyncio.gather(*version_tasks)
            
            download_tasks, failed_to_find_version = [], []
            project_ids_list = list(local_projects.keys())
            for i, versions in enumerate(versions_results):
                pid = project_ids_list[i]
                if versions:
                    download_tasks.append(versions[0]['id'])
                else:
                    failed_to_find_version.append(local_projects[pid]['title'])

            download_results = []
            if download_tasks:
                with tqdm(total=len(download_tasks), desc="下载中", bar_format=self.TQDM_BAR_FORMAT, ascii=' -') as pbar:
                    tasks_to_run = [self._download_file(session, vid, pbar) for vid in download_tasks]
                    download_results = await asyncio.gather(*tasks_to_run)

        print_title("3. 下载完成")
        successful = [name for name, success in download_results if success]
        failed_titles = [info['title'] for (pid, info), (name, success) in zip(local_projects.items(), download_results) if not success]
        failed_titles.extend(failed_to_find_version)

        print_success(f"成功下载: {len(successful)} 个")
        if failed_titles:
            print_error(f"下载失败或未找到兼容版本: {len(set(failed_titles))} 个")
            for mod in sorted(list(set(failed_titles))): print(f"  - {mod}")
        if unidentified_hashes:
            print_warning(f"无法识别 {len(unidentified_hashes)} 个 .jar 文件")

def get_user_mod_folder():  
    paths = ModUpdater.load_paths()
    print(f"{C_YELLOW}请选择一个模组文件夹路径:{C_RESET}")
    for i, path in enumerate(paths): print(f"  {i}. {path}")
    
    new_path_index = len(paths)
    print(f"  {new_path_index}. 手动输入新路径")

    choice = -1
    while not (0 <= choice <= new_path_index):
        try: choice = int(input(f"{C_YELLOW}请输入您的选择 (0-{new_path_index}): {C_RESET}"))
        except ValueError: choice = -1

    if choice == new_path_index:
        new_path = input(f"{C_YELLOW}请输入新的模组文件夹路径: {C_RESET}")
        if os.path.isdir(new_path):
            if new_path not in paths:
                paths.append(new_path)
                ModUpdater.save_paths(paths)
            return new_path
        else:
            print_error(f"错误: 路径 '{new_path}' 不存在或不是一个文件夹。")
            return None
    else:
        return paths[choice]

async def main():  
    print_title("一个mod下载工具")
    
    mod_folder = get_user_mod_folder()
    if not mod_folder: return

    mc_version = input(f"{C_YELLOW}请输入 Minecraft 版本 (例如 1.20.1): {C_RESET}")
    
    print(f"{C_YELLOW}请选择 Mod 加载器:{C_RESET}")
    loaders = ["fabric", "forge", "neoforge", "quilt"]
    for i, loader in enumerate(loaders, 1): print(f"  {i}. {loader.capitalize()}")
    
    choice = 0
    while not 1 <= choice <= len(loaders):
        try: choice = int(input(f"{C_YELLOW}请输入您的选择 (1-{len(loaders)}): {C_RESET}"))
        except ValueError: choice = 0
    mod_loader = loaders[choice - 1]

    updater = ModUpdater(mc_version, mod_loader, mod_folder)
    await updater.run()

if __name__ == "__main__":  
    if platform.system() == "Windows":
        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
    
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print_warning("\n程序被中断。")
    finally:
        print_title("程序结束")

使用方法

使用python打开，然后输入之前的版本的mod文件夹路径（添加了输入的路径保留功能的）
选择mod加载器
输入版本
它就会下载到你启动该python程序目录下的1.21.1-fabric等文件夹里
但有时还是有些mod下不到，只能一定程度上方便一些。

在linux上优雅地玩Minecraft和一些问题解决

Sat, 19 Jul 2025 13:10:37 GMT

分享如何在Linux上优雅地玩我的世界

更多细节可以去arch或者deepin的wiki里的我的世界页面查看。
我的世界 | DeepinWiki
Minecraft - Arch Linux 中文维基

(deepin wiki上更简单点，arch上更全面)

启动器

Linux上有很多可以用的启动器，比如官方启动器,HMCL,XMCL,LauncherX,Modrinth启动器等等。
唯独可惜的是没有自认为最舒服的PCL2,但由社区开发的跨平台的PCL.Neo正在路上了，最迟明年就能在Linux上体验到pcl丝滑的动画了
我目前用的是HMCL,因为用起来很熟悉，在用PCL2之前就用的它，再次用hmcl时，同样的名字，不一样的界面，还有更舒服的动画。

附:HMCL无法输入中文解决

用HMCL时最开始无法输入中文，~~在启动器里几乎没有输入中文的需求~~，后来发现是javafx版本的原因。一开始下载的jdk21,所以hmcl运行时就会自下载javafx17,这个版本适配输入法有问题，所以直接更新java到jdk24即可，hmcl第一次启动时就会下载javafx24,这样在启动器里就可以输入中文了。

MOD

mod的话有两个必要的mod：

IMBlocker

modrinth介绍页
这个mod可以在帮你切换输入法，比如在聊天界面上就能自动切换为中文输入，离开聊天页面就回到英文，避免影响游戏。
当然在Windows上体验是满血的，非常优秀，但在Linux上似乎不会在游戏时屏蔽输入法切换操作，在游戏页面使用输入法切换快捷键输入法还是会反应，~~也许是Deepin的问题?~~
所以对于我来说最优解是不用CTRL的键位。

Fcitx5-Enhancer

modrinth介绍页
这个mod可以修复fcitx5在mc里的一个bug，就是当你用fcitx5输入时，如果点击退格键，极有可能输入法里预编辑的文本被删除，同时游戏里已写好的文本也被删了，这个mod可以修复此问题.

Nvidia卡独显启动

这个方法来自此博客
在HMCL启动器的 版本管理-游戏设置-编辑高级设置 或 设置-全局游戏设置-编辑高级设置 里的环境变量 里写上

__NV_PRIME_RENDER_OFFLOAD=1 __GLX_VENDOR_LIBRARY_NAME=nvidia

即可

AMD卡独显启动

在HMCL启动器的 版本管理-游戏设置-编辑高级设置 或 设置-全局游戏设置-编辑高级设置 里的 环境变量 里写上

DRI_PRIME=1

即可

现在启动XPlus等整合包，加上Derivative等光影，就可以优雅地在Linux里玩上mc了

分享自己新做的主页，太空主题

Sun, 13 Jul 2025 14:22:00 GMT

前言

在Codepen上转的时候看到了一个很厉害的2.5D动态地球，突然有了灵感，就用两天做了个个人网站。
太空主题，页脚是根据一个月球的svg画的，感觉就像站在月球上一样，背景就是找到的那个动态地球了，还加上了一些动态的小星星。
其他元素像加载动画和其他文字都是用的Tailwindcss做的，动画都是用在hover上的，手机端没有鼠标，所以相应的动画就显示不了。

诶后来把这个问题解决了，现在触屏端和电脑端都能正常触发动画。

网站标题为 在互联网留下一个脚印,因为想到了第一个登上月球的人说的那句话。

截图

链接

网站：在互联网留下一个脚印 | 天影大侠
同时也放在Gtihub上了，也分享一下
Github：SkyShadowHero-Space-Themed-Website
动态地球原地址: Codepen

博客首页大图模糊渐进式加载和夜间模式遮罩

Thu, 10 Jul 2025 10:10:15 GMT

前言

修改博客时觉得主页大图加载太慢，而且为了加载快一点已经把图片弄得很糊了，效果还是不好
正好发现了这位大佬的文章，首页背景图渐进式加载，解决卡顿难题
正好解决了加载过慢和图片不能太清晰的问题
但夜间模式下的深色遮罩又没了，
所以分享一下解决方法
安知鱼和butterfly主题适用

首页背景图渐进式加载（转载）

新建文件

新建文件 source/js/imgloaded.js 新增以下内容，并按照注释调整图片路径

// 首页头图加载优化  
/**  
 * @description 实现medium的渐进加载背景的效果  
 */  
class ProgressiveLoad {  
    constructor(smallSrc, largeSrc) {
      this.smallSrc = smallSrc;
      this.largeSrc = largeSrc;
      this.initTpl();
    }
  
    /**
     * @description 生成ui模板
     */
    initTpl() {
      this.container = document.createElement('div');
      this.smallStage = document.createElement('div');
      this.largeStage = document.createElement('div');
      this.smallImg = new Image();
      this.largeImg = new Image();
      this.container.className = 'pl-container';
      this.smallStage.className = 'pl-img pl-blur';
      this.largeStage.className = 'pl-img';
      this.container.appendChild(this.smallStage);
      this.container.appendChild(this.largeStage);
      this.smallImg.onload = this._onSmallLoaded.bind(this);
      this.largeImg.onload = this._onLargeLoaded.bind(this);
    }
  
    /**
     * @description 加载背景
     */
    progressiveLoad() {
      this.smallImg.src = this.smallSrc;
      this.largeImg.src = this.largeSrc;
    }
  
    /**
     * @description 大图加载完成
     */
    _onLargeLoaded() {
      this.largeStage.classList.add('pl-visible');
      this.largeStage.style.backgroundImage = `url('${this.largeSrc}')`;
    }
  
    /**
     * @description 小图加载完成
     */
    _onSmallLoaded() {
      this.smallStage.classList.add('pl-visible');
      this.smallStage.style.backgroundImage = `url('${this.smallSrc}')`;
    }
  }  
  
  const executeLoad = (config, target) => {  
    console.log('执行渐进背景替换');
    const isMobile = window.matchMedia('(max-width: 767px)').matches;
    const loader = new ProgressiveLoad(
      isMobile ? config.mobileSmallSrc : config.smallSrc,
      isMobile ? config.mobileLargeSrc : config.largeSrc
    );
    // 和背景图颜色保持一致，防止高斯模糊后差异较大
    if (target.children[0]) {
      target.insertBefore(loader.container, target.children[0]);
    }
    loader.progressiveLoad();
  };  
  
  const config = {  
    smallSrc: '/img/xiaotu.jpg', // 小图链接 尽可能配置小于100k的图片
    largeSrc: '/img/tu.jpg', // 大图链接 最终显示的图片
    mobileSmallSrc: '/img/sjxt.jpg', // 手机端小图链接 尽可能配置小于100k的图片
    mobileLargeSrc: '/img/sjdt.jpg', // 手机端大图链接 最终显示的图片
    enableRoutes: ['/'],
    };

  function initProgressiveLoad(config) {  
    const target = document.getElementById('page-header');
    if (target && target.classList.contains('full_page')) {
      executeLoad(config, target);
    }
  }  
  
  function onPJAXComplete(config) {  
    const target = document.getElementById('page-header');
    if (target && target.classList.contains('full_page')) {
      initProgressiveLoad(config);
    }
  }  

  document.addEventListener("DOMContentLoaded", function() {  
    initProgressiveLoad(config);
  });  
  
  document.addEventListener("pjax:complete", function() {  
    onPJAXComplete(config);
  });

新建文件 label source/css/imgloaded.css 新增以下内容，并按照注释自行决定调整内容

/* 首页头图加载 */  
.pl-container {  
  width: 100%;  
  height: 100%;  
  position: relative;  
  overflow: hidden;  
  will-change: transform; /* 添加性能优化 */  
  animation: blur-to-clear 2s cubic-bezier(.62,.21,.25,1) 0s 1 normal backwards running, scale 1.5s cubic-bezier(.62,.21,.25,1) 0s 1 both;  
}  
.pl-img {  
  width: 100%;  
  height: 100%;  
  position: absolute;  
  background-position: center;  
  background-size: cover;  
  background-repeat: no-repeat;  
  opacity: 0;  
  transition: opacity 1s;  
}  

@keyframes blur-to-clear {  
  0% {  
    filter: blur(50px);
    opacity: 1;
  }  
  100% {  
    filter: blur(0);
    opacity: 1;
  }  
}  

@keyframes scale {  
  0% {  
    transform: scale(1.5) translateZ(0);
    opacity: 0;
  }  
  to {  
    transform: scale(1) translateZ(0);
    opacity: 1;
  }  
}  

.pl-visible {  
  opacity: 1;  
}  

.pl-blur {  
  /* 小图锯齿多，增加高斯模糊 */  
  filter: blur(50px);  
}

引入文件

在inject里引入即可

inject:  
  head:  
    - <link rel="stylesheet" href="/css/imgloaded.css?1">

  bottom:  
    - <script async data-pjax src="/js/imgloaded.js?1"></script> # 首页图片渐进式加载

夜间模式深色遮罩

也很简单，在css里加入这一段即可

/* 深色模式遮罩 */  
[data-theme="dark"] .pl-container::after {  
  content: "";  
  position: absolute;  
  top: 0;  
  left: 0;  
  width: 100%;  
  height: 100%;  
  background: rgba(0, 0, 0, 0.3); /* 30%透明度的黑色遮罩 */  
  z-index: 1;  
}

回到终端，执行hexo三连就完成了！

Deepin(或者其他Debian系Linux?)上准备安卓刷机环境

Wed, 09 Jul 2025 18:55:39 GMT

前言

在Deepin上用了好久了，一个需求就是能够给我的N11 5G稍微刷一下，防止有时死机之类的 ~~label 你不刷机怎么会死机呢?~~ ，刚好Linux上也完全可以，就分享一下
Debian和Ubuntu等应该通用

adb fastboot环境

方法一

在终端输入

sudo apt-get install adb fastboot

即可

方法二

如果有的linux发行版自带仓库里没有的话，就去这个链接点击下载适用于Linux的SDK Platform-Tools,下载好后放到一个文件夹里，然后配置路径环境
如果shell是bash，就输入

sudo nano ~/.bashrc

如果shell是zsh,就输入

sudo nano ~/.zshrc

以此类推fish等其他shell,当然也可以把nano换成vim，看习惯
然后在这个文件找个地方添上

export PATH=$PATH:/你放的目录/platform-tools

然后退出shell重进，或者source一下你编辑的文件即可

magiskboot环境

有时给boot分区换内核时，可以使用到magiskboot这个东西，很方便
去Github下载对应架构的magiskboot文件，Github链接
然后把它放到一个目录里，然后就是上文中的方法二中的配置路径那一步
当然也可以直接放同一个文件夹里
随便说说magiskboot的简单用法:
解包boot分区文件:
在有提取出的boot.img目录下

magiskboot unpack -h boot.img

打包boot分区文件

magiskboot repack boot.img boot_new.img

一般的内核分享的是个anykernel3包，里面的image.gz里的image文件就是内核
所以只要把新的内核重命名为kernel后，重新打包在boot里就能快速替换内核，而不需要anykernel或者twrp等工具了

Deepin手动安装nvidia闭源显卡驱动

Wed, 02 Jul 2025 20:29:00 GMT

前言

弄这个英伟达显卡让我一口气重刷了4次系统
那就分享一下怎么手动刷入的和问题解决方法

论坛方法

只要不是一些较新的nvidia显卡就可以用这个方法
原论坛链接：这里
简单重复一遍

卸载原有驱动

pkexec apt autoremove nvidia-*

添加32位架构并刷新源

pkexec dpkg --add-architecture i386  
pkexec apt update

安装和执行nvidia-detect

pkexec apt install nvidia-detect

再输入

nvidia-detect

它可能会输出一段绿色的话，告诉你
It is recommended to install the nvidia-driver或者其他内容比如nvidia-legacy-390xx-driver
如果你的显卡较新的话就会在这里提示你，然后请移步第二种方法

安装nvidia驱动

如果显示的是 nvidia-driver ,那就终端输入

pkexec apt install nvidia-driver nvidia-settings nvidia-smi

如果是其他的，那就输入

pkexec apt install xxx

xxx是它显示的名字

较新显卡的问题

如果你显卡比较新的话，输入 nvidia-detect 后大概率它会告诉你sorry,然后推荐你安装较新的显卡驱动
如果你执意输入 pkexec apt install nvidia-driver nvidia-settings nvidia-smi 的话，安装里也没用，输入nvidia-smi后它会说

No devices were found

在nvidia设置面板里也没有什么信息
那就只能去安装英伟达官网里的驱动

{warning}此方法安装好驱动后有一定的危险性，请尽量不要再使用apt安装与显卡驱动有关的东西

最后还是用这个方法弄好了，所以分享一下.

使用官网的驱动程序手动安装

去英伟达官网查找你的显卡对应驱动

输入

lspci | grep -i nvidia

查看显卡型号
Nvidia驱动查找官网
我的是Geforce RTX5060笔记本版的,那么我就选择

Geforce  
Geforce Rtx 50 Series(Notebooks)   
NVIDIA GeForce RTX 5060 Laptop GPU  
Linux 64-bit  
Chinese(Simplified)

然后点击寻找
下载它推荐的或者dev的驱动，应该是个run后缀的文件

安装驱动

确保所有nvidia相关的东西都已删除，和论坛上说的一样
如果是deepin系统的话，似乎要先关闭磐石保护系统，方法看这链接
删除干净和关闭磐石系统后重启电脑
然后在下载目录中打开shell,输入

sudo ./xxx.run

xxx.run是你下的驱动文件名
输入密码后进入安装界面
如果它提示有nvidia等进程，说明没删干净，请删干净后重启再安装，不然可能会出现bug
如果提示有nouveau等进程，自行去bing搜搜怎么禁用

NVIDIA Proprietary和MIT/GPL选择

前者是nvidia的专有内核，可能会更好，后者是开源协议，较新的显卡需要使用开源协议安装，否则也会出现
NVIDIA-SMI has failed because it couldn‘t communicate with the NVIDIA driver.

32位库安装

如果你想玩steam的话，就必须要安装32位的兼容库，所以在出现有Nvidia's 32-bit compatibility libraries字样的一个选项时就要选择yes
但如果报错有unable啥的，就请先和方法一一样在shell里输入

# 添加i386架构支持
sudo dpkg --add-architecture i386
sudo apt update

然后再重新运行run文件

一个重要选项

Would you like to run the nvidia-xconfig utility to automatically update your X configuration file so that the NVIDIA X driver will be used when you restart X? Any pre-existing X configuration file will be backed up.
这个选择要选no,选yes的话其他人说的会开机黑屏，我一开始不知道也试了下，真开机黑屏
如果不小心选了yes又懒得重刷的话，可以看看这个博客链接

其他选项

continue install是继续安装，abort install是退出安装
其他选项按照它默认的即可

其他博客中会推荐在tty环境下安装驱动，但我自己试了很多次在dde桌面环境下安装，重启后正常，所以应该可以放心安装吧

检查是否安装成功

输入

nvidia-smi

后有输出即可

上图是我的输出
我还试了下在deepin上玩漫威蜘蛛侠重制版，用deepin的统信Windows应用兼容引擎，
在调试里只要设置好dxvk,vkd3d和wine版本后就能玩到满血流畅且可开光追的蜘蛛侠了！

Deepin上firefox火狐浏览器缩放和圆角问题解决

Wed, 02 Jul 2025 19:49:47 GMT

Firefox在Deepin上窗口圆角消失？

deepin系统有专门的窗口圆角设置，但firefox浏览器默认似乎还是直角窗口，解决方法也很简单
点击右上角三横线菜单，依次点击 “更多工具“，“定制工具栏“，在左下角的“标题栏“那打勾即可，窗口圆角就会恢复

Firefox在笔记本上缩放不正常

笔记本在deepin上会自动全局缩放，在Windows上也是，但Firefox似乎会在开机后再缩放一次，看起来很怪，但也可以简单地解决
在firefox顶部输入框里输入”about:config”
点击 “接受风险并继续“
搜索“browser.display.os-zoom-behavior”
将此值设置为0即可
重启后也不会缩放异常。

华硕天选6pro安装Deepin和Windows双系统分享和一些bug解决方法

Fri, 13 Jun 2025 10:32:29 GMT

前言

高考结束了，也是拥有了自己的第一台电脑 华硕天选6pro，电脑到手就刷了个deepin系统双系统到G盘，系统适配上似乎没有一点bug，蓝牙、wifi、摄像头等都能正常使用，不用额外配置。Deepin作为最好的国产linux，界面是真好看，也挺流畅的，比C盘的Windows11好得多，~~没想到文件管理器卡死的bug现在还有~~

就分享一下怎么刷入吧。

前图是Deepin,后图是Windows11

关于Deepin

国产第一的Linux，界面很好看，对我们来说使用很友好，内置方便的应用商城，里面安装东西很快，甚至都有HMCL,还有修改的更好用的wine。额反正我用起来很习惯，比其他linux都好用一点。

这是它的官网deepin - 基于Linux的开源国产操作系统

刷入

制作安装U盘

用的Ventoy制作刷入U盘，会把你的U盘清空，记得备份，做好后系统iso放进去即可

一些设置和进入Ventory

开机时一直按住F2,~~其实按一次就够了，只是这电脑开机太快了有时按不到~~，进入华硕的bios面板，其他的电脑可能是F12或F8,查查就是里。华硕的需要在高级设置里把安全启动和快速启动关了，看不懂的先设置为中文，如果不关的话大概率用ventory刷不上。然后回到主页面，在启动菜单（Boot Menu）里点击你的Ventory U盘。其他电脑也是用你的U盘来启动。

刷入Deepin

选择你的iso镜像，两种启动模式，都试试，进入后会到Deepin的安装界面，Try开头的是试试Deepin系统，看看有没有bug, Install with kernel 6.x就是安装系统，点击后略过选择语言那些，之后可选择全盘安装和自定义安装，如果你想只用一个系统的话就用全盘安装，我想Windows11和Deepin双系统共存，所以自定义安装，新手选择后再选一个空的盘挂载“/”根分区即可，如果想自定义安装各分区也可以试试。然后就是等待它的安装。

一些天选6pro上的问题

在选择install deepin with kernel 6.12时kernel panic

建议先安装6.6内核的，然后在系统里通过命令行升级内核
手动升级内核的方法为
用终端执行：

sudo apt search linux-image-*
（搜索可用内核）

如果是fish shell的话可能需要输入

sudo apt search "linux-image-*"

找到想要升级的内核版本后，执行：
```shell
sudo apt install linux-image-[内核版本号，有的加后缀] linux-headers-[内核版本号，有的加后缀]

安装对应版本的内核

sudo apt install linux-image-6.12.31-rolling linux-headers-6.12.31-rolling

除了挂载“/”的分区盘，其他盘显示Bitlocker锁定打开不了

你在Windows11系统里打开了设备加密，所以所有盘都被Bitlocker锁了

解决方法：在Window11系统里打开「设置」>「隐私和安全性」>「安全性」>「设备加密」页面，关闭即可。

另一个Windows系统挂了，要输入密匙才能进入

也是Bitlocker的原因，去它屏幕上显示的网页，登陆你电脑登陆的微软账号，它会有几个密匙，找第二列和电脑显示一样的，输入那很长的密匙即可

使用nvidia-detect显示源里最新的nvidia驱动不支持Geforce 5060 moblie的显卡

截止该文章最后修改的2025年11月15日，deepin源里最新的驱动还是只有580的专有驱动，没有开源驱动（不是指社区开源驱动nouveau），所以目前只能用nvidia官网里下载的最新.run驱动，然后sudo sh ./xx.sh运行，并选择MIT开源协议。详细看我的另一个帖子Deepin手动安装nvidia闭源显卡驱动

{warning}注意：使用.run文件安装的驱动会和deepin源里与nvidia驱动相关东西冲突，安装后请尽量避免使用apt安装这些东西

分享一个python做的mask+图片快捷抠图工具

Tue, 10 Jun 2025 15:50:30 GMT

分享用Python做的一个mask深度图+图片快捷抠图工具，这是以前为了给手机弄景深壁纸时做的，给自己做了个很简陋能用的，后来觉得有点方便，又有点bug，所以扔给deepseek改了改
用了tkinter,cv2和numpy

使用方法：

准备好图片文件和mask.png文件，运行，在弹出的用tkinter做的个简陋ui界面上选择主图片和深度图就行了
阈值调得越大越精确，但不是越大越效果好，多试试即可

代码如下：

import cv2  
import numpy as np  
import os  
import tkinter as tk  
from tkinter import filedialog, messagebox  

class ImageProcessorApp:  
    def __init__(self, root):
        self.root = root
        self.root.title("mask抠图")
        self.root.geometry("300x400")
        
        title_label = tk.Label(root, text="用image和mask来抠图", font=("微软雅黑", 14))
        title_label.pack(pady=10)

        self.select_image_button = tk.Button(root, text="选择主图像", command=self.select_image)
        self.select_image_button.pack(pady=10)

        self.select_mask_button = tk.Button(root, text="选择深度图", command=self.select_mask)
        self.select_mask_button.pack(pady=10)

        self.process_button = tk.Button(root, text="处理图像", command=self.process_images)
        self.process_button.pack(pady=10)

        self.image_label = tk.Label(root, text="未选择主图像")
        self.image_label.pack(pady=5)

        self.mask_label = tk.Label(root, text="未选择深度图")
        self.mask_label.pack(pady=0)

        self.result_label = tk.Label(root, text="")
        self.result_label.pack(pady=0)

        self.threshold_label = tk.Label(root, text="调整阈值:", font=("微软雅黑", 10))
        self.threshold_label.pack(pady=0)

        self.threshold_scale = tk.Scale(root, from_=0, to=255, orient=tk.HORIZONTAL)
        self.threshold_scale.set(199)
        self.threshold_scale.pack(pady=0)

        footer_label = tk.Label(root, text="Make by SkyShadowHeo with python\n(With MIAI,to put it accurately)", font=("微软雅黑", 8))
        footer_label.pack(side=tk.BOTTOM, pady=0)

        self.image_path = None
        self.mask_path = None
        
    def select_image(self):
        self.image_path = filedialog.askopenfilename(title="选择主图像",
                                                      filetypes=[("图像文件", "*.jpg;*.jpeg;*.png")])
        if self.image_path:
            self.image_label.config(text=f"已选择主图像: {os.path.basename(self.image_path)}")

    def select_mask(self):
        self.mask_path = filedialog.askopenfilename(title="选择深度图",
                                                     filetypes=[("图像文件", "*.jpg;*.jpeg;*.png")])
        if self.mask_path:
            self.mask_label.config(text=f"已选择深度图: {os.path.basename(self.mask_path)}")

    def process_images(self):
        if not self.image_path or not self.mask_path:
            messagebox.showerror("错误", "请确保已选择主图像和深度图。")
            return

        image = cv2.imread(self.image_path)
        depth_map = cv2.imread(self.mask_path, cv2.IMREAD_GRAYSCALE)

        if image.shape[:2] != depth_map.shape[:2]:
            depth_map = cv2.resize(depth_map, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_CUBIC)

        normalized_depth = cv2.normalize(depth_map, None, 0, 255, cv2.NORM_MINMAX)

        threshold_value = self.threshold_scale.get()
        _, mask = cv2.threshold(normalized_depth, threshold_value, 255, cv2.THRESH_BINARY)

        kernel = np.ones((5, 5), np.uint8)
        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)

        result = cv2.cvtColor(image, cv2.COLOR_BGR2BGRA)
        result[:, :, 3] = mask

        output_path = os.path.join(os.getcwd(), f'output_{threshold_value}.png')
        cv2.imwrite(output_path, result)

        self.result_label.config(text=f"处理结果已保存:\n {output_path}")

if __name__ == "__main__":  
    root = tk.Tk()
    app = ImageProcessorApp(root)
    root.mainloop()

分享一个网站飘落雪花样式

Thu, 01 May 2025 09:11:39 GMT

分享一个网站飘落雪花样式，效果如本页面所示，可和鼠标手指等有简单躲避互动

使用方法：

在页面head或body里插入这三行即可

<div><canvas id="snow" style="position:fixed;top:0;left:0;width:100%;height:100%;z-index:99999;pointer-events:none"></canvas></div>  
<script>const notMobile = (!(navigator.userAgent.match(/(phone|pad|pod|iPhone|iPod|ios|iPad|Android|Mobile|BlackBerry|IEMobile|MQQBrowser|JUC|Fennec|wOSBrowser|BrowserNG|WebOS|Symbian|Windows Phone)/i)));</script>  
<script async type="text/javascript" src="https://cdn.jsdelivr.net/gh/Candinya/Kratos-Rebirth@latest/source/js/snow.min.js"></script>

本页面雪花样式可能被拉伸，请执行复制代码查看完整效果

分享一个用python做的ttf字体转png图片的小程序

Sun, 13 Apr 2025 08:38:04 GMT

分享一个用python做的ttf字体转png图片的小程序，设置好参数后输入想要生成的文字即可
制作表盘时文字图片不用一个一个去ps抠了
代码如下

# 引入该用的库
print("正在准备中，请稍等...")  
import os  
import matplotlib.pyplot as plt  
from fontTools.ttLib import TTFont  
from matplotlib.font_manager import FontProperties  
import matplotlib.patheffects as path_effects  


# 这些是可以修改的参数
font_path = '1.ttf'  # 字体文件，你的字体名  
output_dir = './output/' # 字体输出目录  
dpi = 60 # 值越大，生成的图片越大  
hs = 92 # 镂空字体大小  
hw = 4 # 镂空字体描边宽度  
hc = "black" # 镂空字体颜色  
ss = 100 # 实心字体大小  
sc = "black" # 实心字体颜色  


# 来一句欢迎语
print("欢迎使用一个生成字体图片的小pyhton程序\n请提前在py文件里设置相应的参数\nmade by 天影大侠")  
# 创建输出目录存
if not os.path.exists(output_dir):  
    os.makedirs(output_dir)
i = "欢迎给天影大侠点赞"  
while i == "欢迎给天影大侠点赞":  
    # 输入字符
    input_text = input("请输入要生成图片的字符: ")
    print("正在生成中... 字符越多生成越久")

    # 使用fontTools读取字体
    font = TTFont(font_path)

    # 生成实心字体和镂空字体的PNG图片
    def render_character(char, is_hollow=False):
        # 替换非法字符，防止命名报错
        valid_char = char.replace("?", "问号")

        # 使用matplotlib生成字体图像
        fig, ax = plt.subplots(figsize=(1.2, 2), dpi=dpi)
        ax.set_axis_off()

        # 选择字体
        prop = FontProperties(fname=font_path)

        if is_hollow:
            # 镂空字体
            text = ax.text(0.5, 0.5, char, fontsize=hs, ha='center', va='center', fontproperties=prop, color='none', weight='bold')
            text.set_path_effects([
                path_effects.withStroke(linewidth=hw, foreground=hc, 
                                        capstyle='round', joinstyle='round')  # 圆滑转角
            ])
        else:
            # 实心字体
            ax.text(0.5, 0.5, char, fontsize=ss, ha='center', va='center', fontproperties=prop, color=sc, weight='bold')

        # 调整边界
        plt.subplots_adjust(left=0, right=1, top=1, bottom=0)

        # 转换为透明背景的PNG
        image_path = os.path.join(output_dir, f'{valid_char}_{"hollow" if is_hollow else "solid"}.png')
        plt.savefig(image_path, format='png', transparent=True)
        plt.close(fig)

    # 渲染输入的每个字符
    for char in input_text:
        render_character(char, is_hollow=False)  # 实心字体
        render_character(char, is_hollow=True)   # 镂空字体

    print("所有字符图像已生成！")

给你的网站后面加上一只会跟着鼠标动的小蜘蛛

Sat, 05 Apr 2025 16:06:13 GMT

先看效果

源码原地址：
CodePen:Parametric Spider
稍微修改了一下，去掉了设置和署名，分享一下代码

HTML里要引入

https://unpkg.co/gsap@3/dist/gsap.min.js

和

https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.7.9/dat.gui.min.js

然后再放上

<canvas id="spidercanvas" />

即可
如果想要一个按钮可以打开或关闭它的话，可以加上

<button onclick="spider()" id="spiderbutton">蜘蛛，启动！</button>

JS文件:

/*--------------------  
Vars  
--------------------*/  
const canvas = document.querySelector("#spidercanvas");  
const ctx = canvas.getContext("2d");  
const button = document.getElementById("spiderbutton");  
const win = {  
  w: window.innerWidth,  
  h: window.innerHeight  
};  
const mouse = {  
  x: win.w * 0.5,  
  y: win.h * 0.5,  
  lerpX: win.w * 0.5,  
  lerpY: win.h * 0.5,  
  stepX: 0,  
  stepY: 0,  
  oldStepX: 0,  
  oldStepY: 0,  
  angle: 0  
};  
const opts = {  
  cellSize: 40,  
  pawRadius: 94,  
  pawHeight: 200,  
  pawRandomStep: 0.2,  
  bodyHeight: 20,  
  spiderOffsetX: 30,  
  spiderOffsetY: 40,  
  shadowY: 0.3,  
  speed: 0.12,  
  stop: false,  
  jump: 0  
};  
let cols = 0;  
let rows = 0;  
canvas.style.display = "block";  
/*--------------------  
button  
--------------------*/  
function spider() {  
  if (canvas.style.display == "none") {  
    canvas.style.display = "block";
  } else {  
    canvas.style.display = "none";
  }  
}  
/*--------------------  
Lerp  
--------------------*/  
const lerp = (a, b, c) => {  
  return (1 - c) * a + c * b;  
};  

/*--------------------  
Random  
--------------------*/  
const random = (start, range) => {  
  return start - range + Math.random() * range * 2;  
};  

/*--------------------  
Resize  
--------------------*/  
const handleResize = () => {  
  win.w = window.innerWidth;  
  win.h = window.innerHeight;  
  canvas.width = win.w;  
  canvas.height = win.h;  
  cols = Math.round(win.w / opts.cellSize) + 1;  
  rows = Math.round(win.h / opts.cellSize) + 1;  
};  
handleResize();  
window.addEventListener("resize", handleResize);  

/*--------------------  
Paws  
--------------------*/  
const Paws = [  
  { x: win.w * 0.5, y: win.h * 0.5 },  
  { x: win.w * 0.5, y: win.h * 0.5 },  
  { x: win.w * 0.5, y: win.h * 0.5 },  
  { x: win.w * 0.5, y: win.h * 0.5 },  
  { x: win.w * 0.5, y: win.h * 0.5 },  
  { x: win.w * 0.5, y: win.h * 0.5 },  
  { x: win.w * 0.5, y: win.h * 0.5 },  
  { x: win.w * 0.5, y: win.h * 0.5 }  
];  

/*--------------------  
Clear  
--------------------*/  
const clear = () => {  
  ctx.clearRect(0, 0, win.w, win.h);  
};  

/*--------------------  
Circle  
--------------------*/  
const circle = (x, y, r, c) => {  
  ctx.fillStyle = c;  
  ctx.beginPath();  
  ctx.ellipse(x, y, r, r, 0, 0, Math.PI * 2);  
  ctx.fill();  
  ctx.closePath();  
};  

/*--------------------  
Rect  
--------------------*/  
const rect = (x, y, r, c) => {  
  ctx.fillStyle = c;  
  ctx.fillRect(x, y, r, r);  
};  

/*--------------------  
Walk  
--------------------*/  
const walk = () => {  
  let ind = 0;  
  Array(10)  
    .fill()
    .forEach((a, i) => {
      const theta = i / 10;
      if (i % 5 === 0) return;
      const x = random(
        mouse.x + cols * 0.5 + opts.pawRadius * Math.sin(theta * Math.PI * 2),
        opts.pawRadius * opts.pawRandomStep
      );
      const y = random(
        mouse.y + rows * 0.5 + opts.pawRadius * Math.cos(theta * Math.PI * 2),
        opts.pawRadius * opts.pawRandomStep
      );

      gsap.to(Paws[ind++], {
        x,
        y,
        duration: opts.speed,
        ease: "power3.out()",
        delay: ((i + 2) % 4) * 0.1
      });
    });
};  

/*--------------------  
Check Step  
--------------------*/  
const checkStep = () => {  
  mouse.stepX = Math.round((mouse.x / win.w) * (cols - 1)) * opts.cellSize;  
  mouse.stepY = Math.round((mouse.y / win.h) * (rows - 1)) * opts.cellSize;  

  if (mouse.oldStepX !== mouse.stepX || mouse.oldStepY !== mouse.stepY) {  
    walk();
  }  

  mouse.oldStepX = mouse.stepX;  
  mouse.oldStepY = mouse.stepY;  
  // rect(mouse.stepX, mouse.stepY, opts.cellSize, 'rgba(255, 0, 0, .1)')  
};  

/*--------------------  
Draw Spider  
--------------------*/  
const drawSpider = () => {  
  const x = mouse.lerpX - opts.spiderOffsetX;  
  const y = mouse.lerpY - opts.spiderOffsetY;  

  // Shadows  
  Paws.forEach((p, i) => {  
    ctx.strokeStyle = "#eee";
    ctx.lineWidth = 1;
    ctx.beginPath();
    ctx.moveTo(x, y + opts.bodyHeight);
    const x2 = lerp(x, p.x, 0.5);
    const y2 = lerp(y + opts.jump, p.y, opts.shadowY);
    ctx.quadraticCurveTo(x2, y2, p.x, p.y);
    ctx.stroke();
    ctx.closePath();
  });  

  // Paws  
  Paws.forEach((p, i) => {  
    ctx.strokeStyle = "black";
    ctx.lineWidth = 1;

    ctx.beginPath();
    ctx.moveTo(x, y + opts.jump);
    const x1 = lerp(x, p.x, 0.5);
    const y1 = lerp(y + opts.jump, p.y - opts.pawHeight, 0.5);
    ctx.quadraticCurveTo(x1, y1, p.x, p.y);
    ctx.stroke();
    ctx.closePath();
  });  

  // Head  
};  

/*--------------------  
Draw Mouse  
--------------------*/  
const drawMouse = () => {  
  mouse.lerpX = lerp(mouse.lerpX, mouse.x, 0.1);  
  mouse.lerpY = lerp(mouse.lerpY, mouse.y, 0.1);  

  if (opts.stop) {  
    mouse.lerpX = win.w * 0.5;
    mouse.lerpY = win.h * 0.5;
    mouse.x = win.w * 0.5;
    mouse.y = win.h * 0.5;
  }  
  checkStep();  
};  

/*--------------------  
Draw  
--------------------*/  
const draw = (t) => {  
  clear();  
  drawMouse();  
  drawSpider();  
  requestAnimationFrame(draw);  
};  
draw();  

/*--------------------  
Mouse  
--------------------*/  
const handleMouseMove = (e) => {  
  if (opts.stop) {  
    mouse.lerpX = win.w * 0.5;
    mouse.lerpY = win.h * 0.5;
    mouse.x = win.w * 0.5;
    mouse.y = win.h * 0.5;
  } else {  
    mouse.x = e.clientX;
    mouse.y = e.clientY;
  }  
};  
const handleTouchMove = (e) => {  
  mouse.x = e.touches[0].clientX;  
  mouse.y = e.touches[0].clientY;  
};  
const handleMouseDown = () => {  
  if (opts.stop) return;  
  gsap.killTweensOf(opts);  
  gsap.to(opts, {  
    jump: opts.bodyHeight,
    duration: 0.5,
    ease: "power3.out"
  });  
};  
const handleMouseUp = () => {  
  if (opts.stop) return;  
  gsap.killTweensOf(opts);  
  gsap.to(opts, {  
    jump: 0,
    duration: 2,
    ease: "elastic(1.4, 0.1)"
  });  
};  
window.addEventListener("mousemove", handleMouseMove);  
window.addEventListener("touchstart", handleTouchMove);  
window.addEventListener("touchmove", handleTouchMove);  
window.addEventListener("mousedown", handleMouseDown);  
window.addEventListener("mouseup", handleMouseUp);

CSS文件:

#spidercanvas {
  position: fixed;  
  top: 0;  
  left: 0;  
  width: 100%;  
  height: 100%;  
  z-index: -1; #把它放在背景前，其他元素后，放在其他元素前也行  
}

安卓类原生生存指南分享

Sat, 05 Apr 2025 15:51:31 GMT

前言

好丑

安卓类原生使用分享

分享一下类原生使用的一些小经验
这系统桌面功耗有时比玩游戏还高👀
都需要root后并且有核心破解与lsposed
有点多，可以在右下角使用目录(新astro博客移动端还未添加目录)

一.DSU

GitHub DSU-Sideloader

dsu是安卓11以上自带的一个功能，可以快捷地侧载一个系统，两个系统都可以正常使用，如设置密码等等。使用dsu-sideloader可以最快捷地体验一下类原生，毕竟不推荐给自己的主力机直接刷。

dsu可以刷入通用镜像gsi或者你系统的类原生包等，

通用镜像在这找到Generic System Image (GSI) list · phhusson/treble_experimentations Wiki · GitHub

如果是做好了的类原生rom话，把payload.bin里的除了boot，dtbo，vbmeta和vbmeta为前缀的其他分区提取出来又压缩到一个zip里，放进dsu-sideloader即可，其他定制的系统也可以试试

如果是gsi的话，就会有很多bug，如自动亮度跳跃，ims无法注册导致收发不了电话信息，所以最好找自己系统的包

二.美化

iconify

这个用过类原生的应该都会用，aosp一般的美化都是这个软件，如果你的系统自带的美化足够的话推荐不用，因为用它容易系统界面死机等等问题，当然你可以把它后台保好，或者只使用lsposed区里的功能

状态栏把窗口级模糊处理打开，模糊度设置为70可有如下效果

Github链接: iconify

colorblendr

这个是用来改material you配色的，可以把md3设计的软件背景色改亮一点或者改改配色，{% hideInline 虽然不得不说背景是那种淡色的好丑，不如纯白 %}

Github链接:colorblendr

小窗

一些系统都把米窗整合了进去，链接在这，支持安卓8到14

Github:Mi-Freeform

安卓15的话有从RisingOS提取出来的，下载链接123网盘提取码：1ESM

当然自己更喜欢用二改的flyme样式米窗，更好看，可以原版米窗侧边栏和flyme样式的小窗一起用

Flyme样式二改米窗Github:Flyme-FreeForm

负一屏

Google的广告机负一屏没人想用吧，可以用SmartSpacer替换成放安卓小部件的

Github:Smartspacer

在lsposed里要勾选桌面启动器和Google应用

只打开相应的负一屏功能就行了，里面的本机smartspace等功能不用开，开了经常需要重启系统界面

负一屏可以改成这种

图标包

图标包去酷安里找找就行了，一般的系统在更改图标包后只是更改了桌面图标，如果想要系统全覆盖的话(如最近任务卡片上)，可以用这个模块，Github:GitHub - RichardLuo0/global-icon-pack-android: An Xposed module for applying icon packs globally

字体和emoji

字体的话可以用这个字体模块，把你想更换的字体ttf放进去就行了

Github: # CJK 字体 Magisk 模块模板

但安卓15好像没用，所以又因为一般的系统都会内置字体选择，可以选inter-vf，harmonyos-sans，ubuntu等字体，就可以直接把字体文件重命名为如ubuntu.ttf，然后用模块放进system/product/fonts里，再在系统的字体选择里选择ubuntu就行了

emoji的话能找到很多ios的emoji模块，但觉得华为的更好看一点，所以用的华为的，分享一下123网盘提取码：DLjW，把它命名为NotoColorEmoji.ttf后也放到system/product/fonts即可

华为emoji长这样

通知图标

把有些空白通知图标改为矢量图标的，不用的话有些通知看起来很难受，或者可以在iconify里打开彩色通知图标，像其他系统一样

Github:NoticeFix

三.功能

Thanos

压后台，划卡关闭应用，管理自启动等，不用它的话一晚20格电有好受的，是付费软件，没r的话只能自显神通了，免费功能也够了。

Github:GitHub - Tornaco/Thanox: I am thanos! 😈 👌

mi-push

推送的，比hms麻烦一点，但酷安和QQ都接入了，还可以自定义通知格式，使用文档看这MiPush Framework使用指南

下载时要下载最新版的，看版本号，它网盘里的排序100是排在2前面的，要自己找最新版的，旧版可能用不了

墓碑

怎么说呢，要用的可以用，我用的n11内核版本太低了，用起来并不好。

还是分享一下

freezer

no-active

freezeit 额这个没更了，酷安有二改的还在更，可以试试

四.一些bug修复

酷安闪退

大概率Selinux宽容问题，可以找模块或者shell输入setenforce 0 暂时解决

收发不了电话和短信

如果你用的gsi的话，能打电话发短信才奇怪，如果是做好的rom话，一般不会有这个问题，如果有，用pixel ims弄一下，还不行的话网上说的要重刷底包，我建议的话，不刷系统算了

用了魔法后某蓝底软件还是连接不上

一些类原生连了梯子，某蓝底软件还是一直显示连接中，我这CrDroid和基于它的系统都这样，在Clash设置里关闭允许应用绕过可以解决

五.其他

系统软件

类原生上Google和moto的都好用，moto全家桶可在酷安找到，我这甚至找到了小米的大部分系统软件给类原生的mod版，大家想用的也自显神通找找吧

其他软件

语燕输入法

Github:GitHub - gurecn/YuyanIme: 语燕拼音输入法-一款基于Rime定制开发的九键、全拼、双拼、手写、火星文等方案、支持悬浮、单手、数字行等键盘模式的中文输入法

这是基于Rime的一个输入法，做的比其他同类输入法要更易用更美观，虽然和搜狗，百度等比起来还是略逊一点。

清浊

一个清理内存的软件，还有一言诗词小部件，负一屏上放的就是它，可以在酷安找到

后言

就分享到这了，大家觉得有帮助可以弄弄，自己的话早就没用类原生了，百日誓师后没碰过类原生，18以后能玩游戏了，就更不想弄这些了。

这次是最后一次长假，既然都弄过了，就分享出来一下

怎么说呢，弄类原生就像玩游戏一样

但现在能玩真正的游戏了

参考：酷安类原生板块和此帖一个帖子

【过时】用Canta删除手机自带的系统软件！

Thu, 15 Feb 2024 15:52:50 GMT

前言

这里是2025年的天影大侠，Android删除系统软件的话用adb很方便了，这就是给懒人的一个麻烦方式，没有意义，如果root了的话，scene更方便，如果没root的话建议不要去动系统软件。

问候

今天分享一个无需root即可删除安卓手机自带app的软件，Canta!

GitHub - samolego/Canta: Uninstall any Android app without root (Shizuku)!

要用到软件！

shizuku和canta它自己！

在这里看看Shizuku

canta的github见上文

到相应的网站下载最新版本

第一步，shizuku激活！

这一步网上教程很多很多，大家可以去别的地方看看

毕竟~~懒得抄过来~~

这是官方的教程: https://shizuku.rikka.app/zh-hans/guide/setup/

第二步，开始删除了！

安装好下载的Canta，它会先请求shizuku权限，允许就好

然后就能删除各种软件了包括系统软件

删除了还有记录，可以恢复，神奇的东西

一些没用的话

这个软件其实很简单，就是用adb命令删除软件

如果你想试试的话，可以在shizuku runner里直接输入pm uninstall -k —user 0 [应用包名]

或在其他终端里输入adb shell pm uninstall -k —user 0 [应用包名]

但有现成的软件，为啥要自己动手呢

最后吐槽一下，小米自带的浏览器还没用就1GB，不如via，几MB的大小

【过时】无需root给QQ添加模块！

Tue, 13 Feb 2024 10:05:50 GMT

前言

这是2025年的天影大侠，这篇文章或许有用，但不建议QQ使用模块，会被风控，况且root后使用lsposed更方便，不root也没需要弄。

问候

大家好，分享一下怎么给安卓QQ添加模块，QQNT版可用，且不需root！

准备工具：

~~shizuku,lspatchd~~,opatch(或onpatch),QQ,你的模块

什么意思呢？

Lsposed是一个不需要root就可以植入模块的Lsposed框架，可以分别去看看它们的GitHub

LSPatch

LSPosed

后者需要root，前者已经很久没有更新了，且需要shizuku激活（这又是个麻烦事），所以我们可以直接使用lspatch的魔改版的修改版，onpatch！

看看它们简单的关系吧

而且opatch和onpatch不需要使用shizuku，所以检测shizuku安装那变成了~~检测原神是否安装~~，当然没安装也没事。

onpatch 0.0.6的网盘下载链接：Here

当然QQ安装包自己准备，最新版也行

模块的话这里以QAuxiliary为例这个模块功能很丰富，更新也较快

QAuxiliary这是它的github，可在此下载最新的版本

开始吧

使用步骤：

当然要先安装onpatch和QAuxiliary的安装包

然后进入onpatch，点击左下角

再点击那个+号，先要选择存储目录，选好后再点击从已存储的目录中选择你的QQ安装包

，或选择已安装的应用

进入后应该是这样子

(注入修改器模式和集成原神模式上面都有介绍，如果是前者的话，可以随时修改注入的模块，但自己使用起来容易掉模块且需要打开onpatch的自启动权限，后者的话把模块集成到安装包里，不会掉，但不能灵活地修改模块，自己选。)

再将我们的QAuxiliary模块注入即可！

现在进入QQ，在设置里应该就会出现QAuxiliary的设置了！

模块推荐！

分享一些好用的模块：

一个很多功能的模块

GitHub - cinit/QAuxiliary: QNotified phoenix - To make OICQ great again

也是一个很多功能的模块

GitHub - Suzhelan/QStory

QQ省电模块

GitHub - fankes/TSBattery: A new way to save your battery avoid cancer apps hacker it.

自动打卡，点赞，续火花的模块

GitHub - LuckyPray/XAutoDaily: 一个基于QQ的全自动签到模块

使用typed.js来给你的网页添加打字效果吧

Sat, 12 Aug 2023 10:30:54 GMT

使用typed.js来给你的网页添加打字效果吧

typed.js官网看这JavaScript Animated Typing with Typed.js | by Matt Boldt

先看看效果:

右侧公告栏也是同样的方法

使用指北：

先在head或body里引入js

<script src="https://unpkg.com/typed.js@2.0.16/dist/typed.umd.js"></script>

然后再创建一个自己的js文件，输入以下代码

var typed = new Typed('#hello-world', {  
  strings: ['Hello World!']  
});

在引入typed.js的cdn后面引入你的js文件

再在html里输入

<span id="hello-world"></span>

你就可以看到你的打字效果了

这里必须要span，如果是div的话光标会显示不正常，跑文字下一行去

当然这只是最基本的用法，你还可以在js里添加一些自定义的

如将strings替换为

  strings: [  
    '你猜这些是啥！',
    '你该干些啥！',
    '用你自己的!',
    '我去！',
  ],

并添加循环：

  loop: true,  
  loopCount: Infinity,

同时你可以在string中的文字里加上 ^3000 来让打字效果在此延迟3000毫秒再继续

如

  strings: [  
    '你猜这些^3000是啥！',
    '你该^5000干些啥！',
    '用你^2000自己的!',
    '我去^3000！',
  ],

它就会无限循环打字这几行文字

还可以设置打字速度，回溯速度

  typeSpeed: 100,  
  backSpeed: 50,

typed.js自带很多可自定义的

在GitHub - mattboldt/typed.js: A JavaScript Typing Animation Library

里可以看到所有可以的自定义项

var typed = new Typed('#element', {  
  /**  
   * @property {array} strings strings to be typed  
   * @property {string} stringsElement ID of element containing string children  
   */  
  strings: [  
    'These are the default values...',
    'You know what you should do?',
    'Use your own!',
    'Have a great day!',
  ],  
  stringsElement: null,  

  /**  
   * @property {number} typeSpeed type speed in milliseconds  
   */  
  typeSpeed: 0,  

  /**  
   * @property {number} startDelay time before typing starts in milliseconds  
   */  
  startDelay: 0,  

  /**  
   * @property {number} backSpeed backspacing speed in milliseconds  
   */  
  backSpeed: 0,  

  /**  
   * @property {boolean} smartBackspace only backspace what doesn't match the previous string  
   */  
  smartBackspace: true,  

  /**  
   * @property {boolean} shuffle shuffle the strings  
   */  
  shuffle: false,  

  /**  
   * @property {number} backDelay time before backspacing in milliseconds  
   */  
  backDelay: 700,  

  /**  
   * @property {boolean} fadeOut Fade out instead of backspace  
   * @property {string} fadeOutClass css class for fade animation  
   * @property {boolean} fadeOutDelay Fade out delay in milliseconds  
   */  
  fadeOut: false,  
  fadeOutClass: 'typed-fade-out',  
  fadeOutDelay: 500,  

  /**  
   * @property {boolean} loop loop strings  
   * @property {number} loopCount amount of loops  
   */  
  loop: false,  
  loopCount: Infinity,  

  /**  
   * @property {boolean} showCursor show cursor  
   * @property {string} cursorChar character for cursor  
   * @property {boolean} autoInsertCss insert CSS for cursor and fadeOut into HTML <head>  
   */  
  showCursor: true,  
  cursorChar: '|',  
  autoInsertCss: true,  

  /**  
   * @property {string} attr attribute for typing  
   * Ex: input placeholder, value, or just HTML text  
   */  
  attr: null,  

  /**  
   * @property {boolean} bindInputFocusEvents bind to focus and blur if el is text input  
   */  
  bindInputFocusEvents: false,  

  /**  
   * @property {string} contentType 'html' or 'null' for plaintext  
   */  
  contentType: 'html',  

  /**  
   * Before it begins typing  
   * @param {Typed} self  
   */  
  onBegin: (self) => {},  

  /**  
   * All typing is complete  
   * @param {Typed} self  
   */  
  onComplete: (self) => {},  

  /**  
   * Before each string is typed  
   * @param {number} arrayPos  
   * @param {Typed} self  
   */  
  preStringTyped: (arrayPos, self) => {},  

  /**  
   * After each string is typed  
   * @param {number} arrayPos  
   * @param {Typed} self  
   */  
  onStringTyped: (arrayPos, self) => {},  

  /**  
   * During looping, after last string is typed  
   * @param {Typed} self  
   */  
  onLastStringBackspaced: (self) => {},  

  /**  
   * Typing has been stopped  
   * @param {number} arrayPos  
   * @param {Typed} self  
   */  
  onTypingPaused: (arrayPos, self) => {},  

  /**  
   * Typing has been started after being stopped  
   * @param {number} arrayPos  
   * @param {Typed} self  
   */  
  onTypingResumed: (arrayPos, self) => {},  

  /**  
   * After reset  
   * @param {Typed} self  
   */  
  onReset: (self) => {},  

  /**  
   * After stop  
   * @param {number} arrayPos  
   * @param {Typed} self  
   */  
  onStop: (arrayPos, self) => {},  

  /**  
   * After start  
   * @param {number} arrayPos  
   * @param {Typed} self  
   */  
  onStart: (arrayPos, self) => {},  

  /**  
   * After destroy  
   * @param {Typed} self  
   */  
  onDestroy: (self) => {},  
});

一些有趣的

butterfly主题的话，主页副标题就使用了这个打字库

所以如果你不引入它的cdn的话，在主页里也会正常显示

这样就做了一个只会出现在主页的打字特效了！

分享:一个python身高计算器/滑稽

Fri, 11 Aug 2023 10:27:38 GMT

分享用Python做的一个身高计算器
当然不是真的了
使用tkinter制作，先输入你的身高后点击计算，就计算出你的身高…

代码

如下：

import tkinter as tk  
import time  
import random  

#函数
def calculate_height():  
    try:
        height = float(entry.get()) 
        result_label.config(text="计算中...")
        root.update()

        for _ in range(100):
            random_code = ''.join(random.choice("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()") for _ in range(10))  # 生成随机的乱码
            result_var.set("计算中..." + random_code)
            root.update()
            time.sleep(0.1)

        result_var.set(f"您的身高是 {height} 厘米")
    except ValueError:
        result_var.set("请输入有效的数字身高")

root = tk.Tk()  
root.title("身高计算器")  
root.geometry("400x200")  

label = tk.Label(root, text=" \n \n请输入您的身高（厘米）:", font=("Arial", 14))  # 调整字体大小为14  
label.pack()  
entry = tk.Entry(root)  
entry.pack()  

button = tk.Button(root, text="计算", command=calculate_height)  
button.pack()  

result_var = tk.StringVar()  
result_label = tk.Label(root, textvariable=result_var)  
result_label.pack()  

credit_label = tk.Label(root, text="天影大侠制作（非原创）\n由最强AI驱动", anchor="se")  
credit_label.pack(side="bottom", padx=10, pady=10)  

root.mainloop()

演示

如下：

4种方法给你的我的世界开启n卡独显！

Sun, 06 Aug 2023 21:46:18 GMT

前言

这是之前随便找的几个方法，在之前的老电脑里适用，现在的新电脑应该不需要这些方法了吧。 Linux上的话可以去deepin的我的世界wiki上看看方法，n卡和amd卡都有。
我的世界 | DeepinWiki

正文

大家好！
当你玩我的世界开光影时，如果电脑差的话可能会当场回到电脑主屏幕并给你的电脑几分钟左右的“执行动作冷却期”
当然很有可能你不小心用的电脑自带的集显，那么，也许打开独显游玩我的世界会有所帮助

现在就看看怎么打开独显吧

步骤1：检查是否有独显

首先，我们需要确认你的计算机是否安装了独立显卡。你可以通过以下步骤在设备管理器中查看：
在电脑里右键计算机，点击“属性“，再点击”设备管理器”。或者直接Win键+X，点击”设备管理器“
展开”显示适配器”选项。

如果你看到如下图所示，里面有两行或多行，就有戏

如果只有Intel HD Graphics，那就只有集显，没法使用独立显卡（Tips:图示的GeForce GT 620可能还没有集显好呢…）。

方法1：使用NVIDIA控制面板设置

如果你的计算机安装了NVIDIA独立显卡，并且已经安装了NVIDIA控制面板，你可以按照以下步骤设置我的世界使用独立显卡：

右键点击桌面空白处，选择”NVIDIA控制面板”。
在左侧导航栏中，点击”3D设置”或”3D设置管理”。
在右侧页面中，选择”程序设置”选项卡。
点击”添加”按钮，然后选择找到我的世界的java文件（可以打开任务管理器复制我的世界的Java的路径，也可以直接在启动器看看用的是哪个Java.exe或kavaw.exe）。
在”选择首选图形处理器为以下程序”下拉菜单中，选择你的独立显卡。
点击”应用”按钮保存设置。

方法1.5：解决NVIDIA控制面板不可用的问题

如果在方法1中，你发现NVIDIA控制面板不可用，可以试下以下解决方法：
从NVIDIA官方网站下载并安装最新的驱动程序。

或者看看这两个链接里的教程Link1 Link2

方法2：使用Windows 10游戏模式

如果你的计算机是运行Windows 10及以上版本的操作系统，你可以使用内置的游戏模式来开启独立显卡：

打开Windows设置。
点击”游戏”选项，并在左侧导航栏中，选择”游戏模式”。
在右侧页面中，切换”使用游戏模式”开关为打开状态，再在相关设置的图形设置里选择你的我的世界的Java.exe或javaw.exe的路径

方法3：使用BIOS设置

这一方法看起来有些奇怪，且一些老显卡不适用

重启你的计算机，并在启动过程中按下F12等按键进入BIOS设置界面，就那个很蓝的设置界面。通常在启动时会显示一个提示信息告诉你应该按下哪个键。
进入BIOS设置界面后，通过左右箭头选择Advanced”或”Graphics”菜单。
在这个菜单选项下，可能会有一个名为”Primary Display”、“Graphics Configuration”的选项。使用箭头键选择该选项进入详细设置页面。
在详细设置页面中，找到一个个名为”Primary Graphics Adapter”、“Primary Display Adapter”或类似名称的选项。
使用键盘上的方向键或相关的功能键来选择独立显卡作为首选显卡。
完成设置后，按Save and Exit的按键即可

方法4：禁用集成显卡

你可以在设备管理器中禁用集成显卡（Windows7可能会出现不知名的错误！）

打开设备管理器，展开”显示适配器”选项。
右键点击集成显卡就是那个Graphics的东西，选择”禁用设备”。（Windows7会要求重启电脑，Windows10不会）
Warning！禁用集成显卡可能会导致其他应用程序或系统功能无法正常运行，所以请谨慎使用，并在需要时重新启用集成显卡。

闲言

现在就可以进入你的我的世界，并且开一个好的光影了！如果你的显卡好的话

哈哈当然我的不行…

转载:提问的智慧

Mon, 31 Jul 2023 17:58:58 GMT

提问的智慧

How To Ask Questions The Smart Way

本指南英文版版权为 Eric S. Raymond, Rick Moen 所有。

原文网址：http://www.catb.org/~esr/faqs/smart-questions.html

Copyleft 2001 by D.H.Grand(nOBODY/Ginux), 2010 by Gasolin, 2015 by Ryan Wu

本中文指南是基于原文 3.10 版以及 2010 年由 Gasolin 所翻译版本的最新翻译；

协助指出翻译问题，请发 issue，或直接发 pull request 给我。

本文另有繁體中文版。

原文版本历史

声明

许多项目在他们网站的帮助文档中链接了本指南。这很好，这正是我们想要的用途。但如果你是该项目管理员并试图创建指向本指南的超链接，请在超链接附近的显著位置注明：

本指南不提供此项目的实际支持服务！

我们已经深刻领教到缺少上述声明所带来的痛苦：我们将不停地被那些认为发布这本指南就意味着有责任解决世上所有技术问题的傻瓜苦苦纠缠。

如果你因寻求某些帮助而阅读本指南，并在离开时还觉得可以从本文作者这里得到直接帮助，那你就是我们之前说的那些傻瓜之一。别问我们问题，我们只会忽略你。我们在这本指南中想教你如何从那些真正懂得你所遇到的软件或硬件问题的人处取得协助，而 99% 的情况下那不会是我们。除非你确定本指南的作者之一刚好是你所遇到的问题领域的专家，否则请不要打扰我们，这样大家都会开心一点。

简介

在黑客的世界里，当你拋出一个技术问题时，最终是否能得到有用的回答，往往取决于你所提问和追问的方式。本指南将教你如何正确地提问以获得你满意的答案。

现在开源（Open Source）软件已经相当盛行，您通常可以从其他更有经验的用户那里获得与黑客一样好的答案，这是件好事；和黑客相比，用户们往往对那些新手常遇到的问题更宽容一些。尽管如此，以我们在此推荐的方式对待这些有经验的用户通常也是从他们那里获得有用答案的最有效方式。

首先你应该明白，黑客们喜爱有挑战性的问题，或者能激发他们思维的好问题。如果我们并非如此，那我们也不会成为你想询问的对象。如果你给了我们一个值得反复咀嚼玩味的好问题，我们自会对你感激不尽。好问题是激励，是厚礼。好问题可以提高我们的理解力，而且通常会暴露我们以前从没意识到或者思考过的问题。对黑客而言，“好问题！”是诚挚的大力称赞。

尽管如此，黑客们有着蔑视或傲慢面对简单问题的坏名声，这有时让我们看起来对新手、无知者似乎较有敌意，但其实不是那样的。

我们不讳言我们对那些不愿思考、或者在发问前不做他们该做的事的人的蔑视。那些人是时间杀手 —— 他们只想索取，从不付出，消耗我们可用在更有趣的问题或更值得回答的人身上的时间。我们称这样的人为 失败者（撸瑟） （由于历史原因，我们有时把它拼作 lusers）。

我们意识到许多人只是想使用我们写的软件，他们对学习技术细节没有兴趣。对大多数人而言，电脑只是种工具，是种达到目的的手段而已。他们有自己的生活并且有更要紧的事要做。我们认可这点，也从不指望每个人都对这些让我们着迷的技术问题感兴趣。尽管如此，我们只为那些真正有兴趣并愿意积极参与问题解决的人调整回答问题的风格。这点不会变，也不该变：否则，我们就是在最擅长的事情上降低效率。

我们（在很大程度上）是自愿的，从繁忙的生活中抽出时间来解答疑惑，而且时常被提问淹没。所以我们无情地滤掉一些话题，特别是拋弃那些看起来像失败者的家伙，以便更高效地利用时间来回答赢家（winner）的问题。

如果你厌恶我们的态度，高高在上，或过于傲慢，不妨也设身处地想想。我们并没有要求你向我们屈服 —— 事实上，我们大多数人非常乐意与你平等地交流，只要你付出小小努力来满足基本要求，我们就会欢迎你加入我们的文化。但让我们帮助那些不愿意帮助自己的人是没有效率的。无知没有关系，但装白痴就是不行。

所以，你不必在技术上很在行才能吸引我们的注意，但你必须表现出能引导你变得在行的特质 —— 机敏、有想法、善于观察、乐于主动参与解决问题。如果你做不到这些使你与众不同的事情，我们建议你花点钱找家商业公司签个技术支持服务合同，而不是要求黑客个人无偿地帮助你。

如果你决定向我们求助，当然你也不希望被视为失败者，更不愿成为失败者中的一员。能立刻得到快速并有效答案的最好方法，就是像赢家那样提问 —— 聪明、自信、有解决问题的思路，只是偶尔在特定的问题上需要获得一点帮助。

（欢迎对本指南提出改进意见。你可以把你的建议发送至 esr@thyrsus.com 或 respond-auto@linuxmafia.com。然而请注意，本文并非网络礼节的通用指南，而我们通常会拒绝无助于在技术论坛得到有用答案的建议）。

在提问之前

在你准备要通过电子邮件、新闻群组或者聊天室提出技术问题前，请先做到以下事情：

尝试在你准备提问的论坛的旧文章中搜索答案。
尝试上网搜索以找到答案。
尝试阅读手册以找到答案。
尝试阅读常见问题文件（FAQ）以找到答案。
尝试自己检查或试验以找到答案。
向你身边的强者朋友打听以找到答案。
如果你是程序开发者，请尝试阅读源代码以找到答案。

当你提出问题的时候，请先表明你已经做了上述的努力；这将有助于树立你并不是一个不劳而获且浪费别人的时间的提问者。如果你能一并表达在做了上述努力的过程中所学到的东西会更好，因为我们更乐于回答那些表现出能从答案中学习的人的问题。

运用某些策略，比如先用 Google 搜索你所遇到的各种错误信息（搜索 Google 论坛和网页），这样很可能直接就找到了能解决问题的文件或邮件列表线索。即使没有结果，在邮件列表或新闻组寻求帮助时加上一句 我在 Google 中搜过下列句子但没有找到什么有用的东西 也是件好事，即使它只是表明了搜索引擎不能提供哪些帮助。这么做（加上搜索过的字串）也让遇到相似问题的其他人能被搜索引擎引导到你的提问来。

别着急，不要指望几秒钟的 Google 搜索就能解决一个复杂的问题。在向专家求助之前，再阅读一下常见问题文件（FAQ）、放轻松、坐得舒服一些，再花点时间思考一下这个问题。相信我们，他们能从你的提问看出你做了多少阅读与思考，如果你是有备而来，将更有可能得到解答。不要将所有问题一股脑拋出，只因你的第一次搜索没有找到答案（或者找到太多答案）。

准备好你的问题，再将问题仔细地思考过一遍，因为草率的发问只能得到草率的回答，或者根本得不到任何答案。越是能表现出在寻求帮助前你为解决问题所付出的努力，你越有可能得到实质性的帮助。

小心别问错了问题。如果你的问题基于错误的假设，某个普通黑客（J. Random Hacker）多半会一边在心里想着蠢问题…，一边用无意义的字面解释来答复你，希望着你会从问题的回答（而非你想得到的答案）中汲取教训。

绝不要自以为够格得到答案，你没有；你并没有。毕竟你没有为这种服务支付任何报酬。你将会是自己去挣到一个答案，靠提出有内涵的、有趣的、有思维激励作用的问题 —— 一个有潜力能贡献社区经验的问题，而不仅仅是被动地从他人处索取知识。

另一方面，表明你愿意在找答案的过程中做点什么是一个非常好的开端。谁能给点提示？、我的这个例子里缺了什么？以及我应该检查什么地方比请把我需要的确切的过程贴出来更容易得到答复。因为你表现出只要有人能指个正确方向，你就有完成它的能力和决心。

当你提问时

慎选提问的论坛

小心选择你要提问的场合。如果你做了下述的事情，你很可能被忽略掉或者被看作失败者：

在与主题不合的论坛上贴出你的问题。
在探讨进阶技术问题的论坛张贴非常初级的问题；反之亦然。
在太多的不同新闻群组上重复转贴同样的问题（cross-post）。
向既非熟人也没有义务解决你问题的人发送私人电邮。

黑客会剔除掉那些搞错场合的问题，以保护他们沟通的渠道不被无关的东西淹没。你不会想让这种事发生在自己身上的。

因此，第一步是找到对的论坛。再说一次，Google 和其它搜索引擎还是你的朋友，用它们来找到与你遭遇到困难的软硬件问题最相关的网站。通常那儿都有常见问题（FAQ）、邮件列表及相关说明文件的链接。如果你的努力（包括阅读 FAQ）都没有结果，网站上也许还有报告 Bug（Bug-reporting）的流程或链接，如果是这样，链过去看看。

向陌生的人或论坛发送邮件最可能是风险最大的事情。举例来说，别假设一个提供丰富内容的网页的作者会想充当你的免费顾问。不要对你的问题是否会受到欢迎做太乐观的估计 —— 如果你不确定，那就向别处发送，或者压根别发。

在选择论坛、新闻群组或邮件列表时，别太相信它的名字，先看看 FAQ 或者许可书以弄清楚你的问题是否切题。发文前先翻翻已有的话题，这样可以让你感受一下那里的文化。事实上，事先在新闻组或邮件列表的历史记录中搜索与你问题相关的关键词是个极好的主意，也许这样就找到答案了。即使没有，也能帮助你归纳出更好的问题。

别像机关枪似的一次“扫射”所有的帮助渠道，这就像大喊大叫一样会使人不快。要一个一个地来。

搞清楚你的主题！最典型的错误之一是在某种致力于跨平台可移植的语言、套件或工具的论坛中提关于 Unix 或 Windows 操作系统程序界面的问题。如果你不明白为什么这是大错，最好在搞清楚这之间差异之前什么也别问。

一般来说，在仔细挑选的公共论坛中提问，会比在私有论坛中提同样的问题更容易得到有用的回答。有几个理由可以支持这点，一是看潜在的回复者有多少，二是看观众有多少。黑客较愿意回答那些能帮助到许多人的问题。

可以理解的是，老练的黑客和一些热门软件的作者正在接受过多的错发信息。就像那根最后压垮骆驼背的稻草一样，你的加入也有可能使情况走向极端 —— 已经好几次了，一些热门软件的作者由于涌入其私人邮箱的大量不堪忍受的无用邮件而不再提供支持。

Stack Overflow

搜索，然后在 Stack Exchange 问。

近年来，Stack Exchange 社区已经成为回答技术及其他问题的主要渠道，尤其是那些开放源码的项目。

因为 Google 索引是即时的，在看 Stack Exchange 之前先在 Google 搜索。有很高的几率某人已经问了一个类似的问题，而且 Stack Exchange 网站们往往会是搜索结果中最前面几个。如果你在 Google 上没有找到任何答案，你再到特定相关主题的网站去找。用标签（Tag）搜索能让你更缩小你的搜索结果。

如果你还是找不到任何对你的问题有用的内容，请把你的问题发在与它最相关的网站上。提问的时候请善用格式化工具，尤其注意为代码添加格式，并且添加相关的标签（特别是编程语言、操作系统或库/包的名称）。当有人要求你提供更多相关信息时，请编辑你的贴子来补充它们[译注：而不是发一个回帖或回答！]。如果你觉得一个答案对你有帮助，点击向上的箭头来为它投票；如果一个答案提供了问题的正确解决方案，点击投票按钮下方的对勾来将它标记为正解。

Stack Exchange 已经成长到超过一百个网站，以下是最常用的几个站：

Super User 是问一些通用的电脑问题，如果你的问题跟代码或是写程序无关，只是一些网络连线之类的，请到这里。
Stack Overflow 是问写程序有关的问题。
Server Fault 是问服务器和网管相关的问题。

网站和 IRC 论坛

本地的用户群组（user group），或者你所用的 Linux 发行版本也许正在宣传他们的网页论坛或 IRC 频道，并提供新手帮助（在一些非英语国家，新手论坛很可能还是邮件列表），这些都是开始提问的好地方，特别是当你觉得遇到的也许只是相对简单或者很普通的问题时。有广告赞助的 IRC 频道是公开欢迎提问的地方，通常可以即时得到回应。

事实上，如果程序出的问题只发生在特定 Linux 发行版提供的版本（这很常见），最好先去该发行版的论坛或邮件列表中提问，再到程序本身的论坛或邮件列表提问。（否则）该项目的黑客可能仅仅回复“使用我们的版本”。

在任何论坛发文以前，先确认一下有没有搜索功能。如果有，就试着搜索一下问题的几个关键词，也许这会有帮助。如果在此之前你已做过通用的网页搜索（你也该这样做），还是再搜索一下论坛，搜索引擎有可能没来得及索引此论坛的全部内容。

通过论坛或 IRC 频道来提供用户支持服务有增长的趋势，电子邮件则大多为项目开发者间的交流而保留。所以最好先在论坛或 IRC 中寻求与该项目相关的协助。

在使用 IRC 的时候，首先最好不要发布很长的问题描述，有些人称之为频道洪水。最好通过一句话的问题描述来开始聊天。

第二步，使用项目邮件列表

当某个项目提供开发者邮件列表时，要向列表而不是其中的个别成员提问，即使你确信他能最好地回答你的问题。查一查项目的文件和首页，找到项目的邮件列表并使用它。有几个很好的理由支持我们采用这种办法：

任何好到需要向个别开发者提出的问题，也将对整个项目群组有益。反之，如果你认为自己的问题对整个项目群组来说太愚蠢，那这也不能成为骚扰个别开发者的理由。
向列表提问可以分散开发者的负担，个别开发者（尤其是项目领导人）也许太忙以至于没法回答你的问题。
大多数邮件列表都会被存档，那些被存档的内容将被搜索引擎索引。如果你向列表提问并得到解答，将来其他人可以通过网页搜索找到你的问题和答案，也就不用再次发问了。
如果某些问题经常被问到，开发者可以利用此信息来改进说明文件或软件本身，以使其更清楚。如果只是私下提问，就没有人能看到最常见问题的完整场景。

如果一个项目既有“用户”也有“开发者”（或“黑客”）邮件列表或论坛，而你又不会动到那些源代码，那么就向“用户”列表或论坛提问。不要假设自己会在开发者列表中受到欢迎，那些人多半会将你的提问视为干扰他们开发的噪音。

然而，如果你确信你的问题很特别，而且在“用户”列表或论坛中几天都没有回复，可以试试前往“开发者”列表或论坛发问。建议你在张贴前最好先暗地里观察几天以了解那里的行事方式（事实上这是参与任何私有或半私有列表的好主意）

如果你找不到一个项目的邮件列表，而只能查到项目维护者的电子邮件地址，尽管向他发信。即使是在这种情况下，也别假设（项目）邮件列表不存在。在你的电子邮件中，请陈述你已经试过但没有找到合适的邮件列表，也提及你不反对将自己的邮件转发给他人（许多人认为，即使没什么秘密，私人电子邮件也不应该被公开。通过允许将你的电子邮件转发他人，你给了相应人员处置你邮件的选择）。

使用有意义且描述明确的标题

在邮件列表、新闻群组或论坛中，大约 50 字以内的标题是抓住资深专家注意力的好机会。别用喋喋不休的帮帮忙、跪求、急（更别说救命啊！！！！这样让人反感的话，用这种标题会被条件反射式地忽略）来浪费这个机会。不要妄想用你的痛苦程度来打动我们，而应该是在这点空间中使用极简单扼要的描述方式来提出问题。

一个好标题范例是目标 —— 差异式的描述，许多技术支持组织就是这样做的。在目标部分指出是哪一个或哪一组东西有问题，在差异部分则描述与期望的行为不一致的地方。

蠢问题：救命啊！我的笔记本电脑不能正常显示了！

聪明问题：X.org 6.8.1 的鼠标指针会变形，某牌显卡 MV1005 芯片组。

更聪明问题：X.org 6.8.1 的鼠标指针，在某牌显卡 MV1005 芯片组环境下 - 会变形。

编写目标 —— 差异 式描述的过程有助于你组织对问题的细致思考。是什么被影响了？仅仅是鼠标指针或者还有其它图形？只在 X.org 的 X 版中出现？或只是出现在 6.8.1 版中？是针对某牌显卡芯片组？或者只是其中的 MV1005 型号？一个黑客只需瞄一眼就能够立即明白你的环境和你遇到的问题。

总而言之，请想像一下你正在一个只显示标题的存档讨论串（Thread）索引中查寻。让你的标题更好地反映问题，可使下一个搜索类似问题的人能够关注这个讨论串，而不用再次提问相同的问题。

如果你想在回复中提出问题，记得要修改内容标题，以表明你是在问一个问题，一个看起来像 Re: 测试 或者 Re: 新 bug 的标题很难引起足够重视。另外，在不影响连贯性之下，适当引用并删减前文的内容，能给新来的读者留下线索。

对于讨论串，不要直接点击回复来开始一个全新的讨论串，这将限制你的观众。因为有些邮件阅读程序，比如 mutt ，允许用户按讨论串排序并通过折叠讨论串来隐藏消息，这样做的人永远看不到你发的消息。

仅仅改变标题还不够。mutt 和其它一些邮件阅读程序还会检查邮件标题以外的其它信息，以便为其指定讨论串。所以宁可发一个全新的邮件。

在网页论坛上，好的提问方式稍有不同，因为讨论串与特定的信息紧密结合，并且通常在讨论串外就看不到里面的内容，故通过回复提问，而非改变标题是可接受的。不是所有论坛都允许在回复中出现分离的标题，而且这样做了基本上没有人会去看。不过，通过回复提问，这本身就是暧昧的做法，因为它们只会被正在查看该标题的人读到。所以，除非你只想在该讨论串当前活跃的人群中提问，不然还是另起炉灶比较好。

使问题容易回复

以请将你的回复发送到……来结束你的问题多半会使你得不到回答。如果你觉得花几秒钟在邮件客户端设置一下回复地址都麻烦，我们也觉得花几秒钟思考你的问题更麻烦。如果你的邮件程序不支持这样做，换个好点的；如果是操作系统不支持这种邮件程序，也换个好点的。

在论坛，要求通过电子邮件回复是非常无礼的，除非你认为回复的信息可能比较敏感（有人会为了某些未知的原因，只让你而不是整个论坛知道答案）。如果你只是想在有人回复讨论串时得到电子邮件提醒，可以要求网页论坛发送给你。几乎所有论坛都支持诸如追踪此讨论串、有回复时发送邮件提醒等功能。

使用清晰、正确、精准且合乎语法的语句

我们从经验中发现，粗心的提问者通常也会粗心地写程序与思考（我敢打包票）。回答粗心大意者的问题很不值得，我们宁愿把时间耗在别处。

正确的拼写、标点符号和大小写是很重要的。一般来说，如果你觉得这样做很麻烦，不想在乎这些，那我们也觉得麻烦，不想在乎你的提问。花点额外的精力斟酌一下字句，用不着太僵硬与正式 —— 事实上，黑客文化很看重能准确地使用非正式、俚语和幽默的语句。但它必须很准确，而且有迹象表明你是在思考和关注问题。

正确地拼写、使用标点和大小写，不要将its混淆为it's，loose搞成lose或者将discrete弄成discreet。不要全部用大写，这会被视为无礼的大声嚷嚷（全部小写也好不到哪去，因为不易阅读。Alan Cox 也许可以这样做，但你不行）。

更白话的说，如果你写得像是个半文盲[译注：小白]，那多半得不到理睬。也不要使用即时通信中的简写或火星文，如将的简化为d会使你看起来像一个为了少打几个键而省字的小白。更糟的是，如果像个小孩似地鬼画符那绝对是在找死，可以肯定没人会理你（或者最多是给你一大堆指责与挖苦）。

如果在使用非母语的论坛提问，你可以犯点拼写和语法上的小错，但决不能在思考上马虎（没错，我们通常能弄清两者的分别）。同时，除非你知道回复者使用的语言，否则请使用英语书写。繁忙的黑客一般会直接删除用他们看不懂的语言写的消息。在网络上英语是通用语言，用英语书写可以将你的问题在尚未被阅读就被直接删除的可能性降到最低。

如果英文是你的外语（Second language），提示潜在回复者你有潜在的语言困难是很好的：
[译注：以下附上原文以供使用]

English is not my native language; please excuse typing errors.

英文不是我的母语，请原谅我的错字或语法。

If you speak $LANGUAGE, please email/PM me; I may need assistance translating my question.

如果你说某语言，请向我发电邮/私信；
我需要有人协助我翻译我的问题。

I am familiar with the technical terms, but some slang expressions and idioms are difficult for me.

我对技术名词很熟悉，但对于俗语或是特别用法不甚了解。

I’ve posted my question in $LANGUAGE and English. I’ll be glad to translate responses, if you only use one or the other.

我把我的问题用某语言和英文写出来。
如果你只用其中的一种语言回答，我会乐意将回复翻译成为你使用的语言。

使用易于读取且标准的文件格式发送问题

如果你人为地将问题搞得难以阅读，它多半会被忽略，人们更愿读易懂的问题，所以：

使用纯文字而不是 HTML (关闭 HTML 并不难）。
使用 MIME 附件通常是可以的，前提是真正有内容（譬如附带的源代码或 patch），而不仅仅是邮件程序生成的模板（譬如只是信件内容的拷贝）。
不要发送一段文字只是一行句子但自动换行后会变成多行的邮件（这使得回复部分内容非常困难）。设想你的读者是在 80 个字符宽的终端机上阅读邮件，最好设置你的换行分割点小于 80 字。
但是，对一些特殊的文件不要设置固定宽度（譬如日志文件拷贝或会话记录）。数据应该原样包含，让回复者有信心他们看到的是和你看到的一样的东西。
在英语论坛中，不要使用Quoted-Printable MIME 编码发送消息。这种编码对于张贴非 ASCII 语言可能是必须的，但很多邮件程序并不支持这种编码。当它们处理换行时，那些文本中四处散布的=20符号既难看也分散注意力，甚至有可能破坏内容的语意。
绝对，永远不要指望黑客们阅读使用封闭格式编写的文档，像微软公司的 Word 或 Excel 文件等。大多数黑客对此的反应就像有人将还在冒热气的猪粪倒在你家门口时你的反应一样。即便他们能够处理，他们也很厌恶这么做。
如果你从使用 Windows 的电脑发送电子邮件，关闭微软愚蠢的智能引号功能（从[选项] > [校订] > [自动校正选项]，勾选掉智能引号单选框），以免在你的邮件中到处散布垃圾字符。
在论坛，勿滥用表情符号和HTML功能（当它们提供时）。一两个表情符号通常没有问题，但花哨的彩色文本倾向于使人认为你是个无能之辈。过滥地使用表情符号、色彩和字体会使你看来像个傻笑的小姑娘。这通常不是个好主意，除非你只是对性而不是对答案感兴趣。

如果你使用图形用户界面的邮件程序（如微软公司的 Outlook 或者其它类似的），注意它们的默认设置不一定满足这些要求。大多数这类程序有基于选单的查看源代码命令，用它来检查发送文件夹中的邮件，以确保发送的是纯文本文件同时没有一些奇怪的字符。

精确地描述问题并言之有物

仔细、清楚地描述你的问题或 Bug 的症状。
描述问题发生的环境（机器配置、操作系统、应用程序、以及相关的信息），提供经销商的发行版和版本号（如：Fedora Core 4、Slackware 9.1等）。
描述在提问前你是怎样去研究和理解这个问题的。
描述在提问前为确定问题而采取的诊断步骤。
描述最近做过什么可能相关的硬件或软件变更。
尽可能地提供一个可以重现这个问题的可控环境的方法。

尽量去揣测一个黑客会怎样反问你，在你提问之前预先将黑客们可能提出的问题回答一遍。

以上几点中，当你报告的是你认为可能在代码中的问题时，给黑客一个可以重现你的问题的环境尤其重要。当你这么做时，你得到有效的回答的机会和速度都会大大的提升。

Simon Tatham 写过一篇名为《如何有效的报告 Bug》的出色文章。强力推荐你也读一读。

话不在多而在精

你需要提供精确有内容的信息。这并不是要求你简单的把成堆的出错代码或者资料完全转录到你的提问中。如果你有庞大而复杂的测试样例能重现程序挂掉的情境，尽量将它剪裁得越小越好。

这样做的用处至少有三点。
第一，表现出你为简化问题付出了努力，这可以使你得到回答的机会增加；
第二，简化问题使你更有可能得到有用的答案；
第三，在精炼你的 bug 报告的过程中，你很可能就自己找到了解决方法或权宜之计。

别动辄声称找到 Bug

当你在使用软件中遇到问题，除非你非常、非常的有根据，不要动辄声称找到了 Bug。提示：除非你能提供解决问题的源代码补丁，或者提供回归测试来表明前一版本中行为不正确，否则你都多半不够完全确信。这同样适用在网页和文件，如果你（声称）发现了文件的Bug，你应该能提供相应位置的修正或替代文件。

请记得，还有其他许多用户没遇到你发现的问题，否则你在阅读文件或搜索网页时就应该发现了（你在抱怨前已经做了这些，是吧？）。这也意味着很有可能是你弄错了而不是软件本身有问题。

编写软件的人总是非常辛苦地使它尽可能完美。如果你声称找到了 Bug，也就是在质疑他们的能力，即使你是对的，也有可能会冒犯到其中某部分人。当你在标题中嚷嚷着有Bug时，这尤其严重。

提问时，即使你私下非常确信已经发现一个真正的 Bug，最好写得像是你做错了什么。如果真的有 Bug，你会在回复中看到这点。这样做的话，如果真有 Bug，维护者就会向你道歉，这总比你惹恼别人然后欠别人一个道歉要好一点。

低声下气不能代替你的功课

有些人明白他们不该粗鲁或傲慢的提问并要求得到答复，但他们选择另一个极端 —— 低声下气：我知道我只是个可悲的新手，一个撸瑟，但...。这既使人困扰，也没有用，尤其是伴随着与实际问题含糊不清的描述时更令人反感。

别用原始灵长类动物的把戏来浪费你我的时间。取而代之的是，尽可能清楚地描述背景条件和你的问题情况。这比低声下气更好地定位了你的位置。

有时网页论坛会设有专为新手提问的版面，如果你真的认为遇到了初学者的问题，到那去就是了，但一样别那么低声下气。

描述问题症状而非你的猜测

告诉黑客们你认为问题是怎样造成的并没什么帮助。（如果你的推断如此有效，还用向别人求助吗？），因此要确信你原原本本告诉了他们问题的症状，而不是你的解释和理论；让黑客们来推测和诊断。如果你认为陈述自己的猜测很重要，清楚地说明这只是你的猜测，并描述为什么它们不起作用。

蠢问题

我在编译内核时接连遇到 SIG11 错误，我怀疑某条飞线搭在主板的走线上了，这种情况应该怎样检查最好？

聪明问题

我的组装电脑是 FIC-PA2007 主机板搭载 AMD K6/233 CPU（威盛 Apollo VP2 芯片组）， 256MB Corsair PC133 SDRAM 内存，在编译内核时，从开机 20 分钟以后就频频产生 SIG11 错误，但是在头 20 分钟内从没发生过相同的问题。重新启动也没有用，但是关机一晚上就又能工作 20 分钟。所有内存都换过了，没有效果。相关部分的标准编译记录如下…

由于以上这点似乎让许多人觉得难以配合，这里有句话可以提醒你：所有的诊断专家都来自密苏里州。 美国国务院的官方座右铭则是：让我看看（出自国会议员 Willard D. Vandiver 在 1899 年时的讲话：我来自一个出产玉米，棉花，牛蒡和民主党人的国家，滔滔雄辩既不能说服我，也不会让我满意。我来自密苏里州，你必须让我看看。）针对诊断者而言，这并不是一种怀疑，而只是一种真实而有用的需求，以便让他们看到的是与你看到的原始证据尽可能一致的东西，而不是你的猜测与归纳的结论。所以，大方地展示给我们看吧！

按发生时间先后列出问题症状

问题发生前的一系列操作，往往就是对找出问题最有帮助的线索。因此，你的说明里应该包含你的操作步骤，以及机器和软件的反应，直到问题发生。在命令行处理的情况下，提供一段操作记录（例如运行脚本工具所生成的），并引用相关的若干行（如 20 行）记录会非常有帮助。

如果挂掉的程序有诊断选项（如 -v 的详述开关），试着选择这些能在记录中增加调试信息的选项。记住，多不等于好。试着选取适当的调试级别以便提供有用的信息而不是让读者淹没在垃圾中。

如果你的说明很长（如超过四个段落），在开头简述问题，接下来再按时间顺序详述会有所帮助。这样黑客们在读你的记录时就知道该注意哪些内容了。

描述目标而不是过程

如果你想弄清楚如何做某事（而不是报告一个 Bug），在开头就描述你的目标，然后才陈述重现你所卡住的特定步骤。

经常寻求技术帮助的人在心中有个更高层次的目标，而他们在自以为能达到目标的特定道路上被卡住了，然后跑来问该怎么走，但没有意识到这条路本身就有问题。结果要费很大的劲才能搞定。

蠢问题

我怎样才能从某绘图程序的颜色选择器中取得十六进制的 RGB 值？

聪明问题

我正试着用替换一幅图片的色码（color table）成自己选定的色码，我现在知道的唯一方法是编辑每个色码区块（table slot），但却无法从某绘图程序的颜色选择器取得十六进制的 RGB 值。

第二种提问法比较聪明，你可能得到像是建议采用另一个更合适的工具的回复。

别要求使用私人电邮回复

黑客们认为问题的解决过程应该公开、透明，此过程中如果更有经验的人注意到不完整或者不当之处，最初的回复才能够、也应该被纠正。同时，作为提供帮助者可以得到一些奖励，奖励就是他的能力和学识被其他同行看到。

当你要求私下回复时，这个过程和奖励都被中止。别这样做，让回复者来决定是否私下回答 —— 如果他真这么做了，通常是因为他认为问题编写太差或者太肤浅，以至于不可能使其他人产生兴趣。

这条规则存在一条有限的例外，如果你确信提问可能会引来大量雷同的回复时，那么这个神奇的提问句会是向我发电邮，我将为论坛归纳这些回复。试着将邮件列表或新闻群组从洪水般的雷同回复中解救出来是非常有礼貌的 —— 但你必须信守诺言。

清楚明确地表达你的问题以及需求

漫无边际的提问是近乎无休无止的时间黑洞。最有可能给你有用答案的人通常也正是最忙的人（他们忙是因为要亲自完成大部分工作）。这样的人对无节制的时间黑洞相当厌恶，所以他们也倾向于厌恶那些漫无边际的提问。

如果你明确表述需要回答者做什么（如提供指点、发送一段代码、检查你的补丁、或是其他等等），就最有可能得到有用的答案。因为这会定出一个时间和精力的上限，便于回答者能集中精力来帮你。这么做很棒。

要理解专家们所处的世界，请把专业技能想像为充裕的资源，而回复的时间则是稀缺的资源。你要求他们奉献的时间越少，你越有可能从真正专业而且很忙的专家那里得到解答。

所以，界定一下你的问题，使专家花在辨识你的问题和回答所需要付出的时间减到最少，这技巧对你获得有用的答案相当有帮助 —— 但这技巧通常和简化问题有所区别。因此，问我想更好地理解 X，可否指点一下哪有好一点说明？通常比问你能解释一下 X 吗？更好。如果你的代码不能运作，通常请别人看看哪里有问题，比要求别人替你改正要明智得多。

询问有关代码的问题时

如果没有提示别人应该从何入手，别要求他人帮你调试有问题的代码。张贴几百行的代码，然后说一声：它不能工作会让你完全被忽略。只贴几十行代码，然后说一句：在第七行以后，我期待它显示 <x>，但实际出现的是 <y>比较有可能让你得到回应。

最有效描述程序问题的方法是提供最精简的 Bug 展示测试用例（bug-demonstrating test case）。什么是最精简的测试用例？那是问题的缩影；一小个程序片段能刚好展示出程序的异常行为，而不包含其他令人分散注意力的内容。怎么制作最精简的测试用例？如果你知道哪一行或哪一段代码会造成异常的行为，复制下来并加入足够重现这个状况的代码（例如，足以让这段代码能被编译/直译/被应用程序处理）。如果你无法将问题缩减到一个特定区块，就复制一份代码并移除不影响产生问题行为的部分。总之，测试用例越小越好（查看话不在多而在精一节）。

一般而言，要得到一段相当精简的测试用例并不太容易，但永远先尝试这样做是一个好习惯。这种方式可以帮助你了解如何自行解决这个问题 —— 而且即使你的尝试不成功，黑客们也会看到你在尝试取得答案的过程中付出了努力，这可以让他们更愿意与你合作。

如果你只是想让别人帮忙审查（Review）一下代码，在信的开头就要说出来，并且一定要提到你认为哪一部分特别需要关注以及为什么。

别把自己家庭作业的问题贴上来

黑客们很擅长分辨哪些问题是家庭作业式的问题；因为我们中的大多数都曾自己解决这类问题。同样，这些问题得由你来搞定，你会从中学到东西。你可以要求给点提示，但别要求得到完整的解决方案。

如果你怀疑自己碰到了一个家庭作业式的问题，但仍然无法解决，试试在用户群组，论坛或（最后一招）在项目的用户邮件列表或论坛中提问。尽管黑客们会看出来，但一些有经验的用户也许仍会给你一些提示。

去掉无意义的提问句

避免用无意义的话结束提问，例如有人能帮我吗？或者这有答案吗？。

首先：如果你对问题的描述不是很好，这样问更是画蛇添足。

其次：由于这样问是画蛇添足，黑客们会很厌烦你 —— 而且通常会用逻辑上正确，但毫无意义的回答来表示他们的蔑视，例如：没错，有人能帮你或者不，没答案。

一般来说，避免用 是或否、对或错、有或没有类型的问句，除非你想得到是或否类型的回答。

即使你很急也不要在标题写`紧急`

这是你的问题，不是我们的。宣称紧急极有可能事与愿违：大多数黑客会直接删除无礼和自私地企图即时引起关注的问题。更严重的是，紧急这个字（或是其他企图引起关注的标题）通常会被垃圾信过滤器过滤掉 —— 你希望能看到你问题的人可能永远也看不到。

有半个例外的情况是，如果你是在一些很高调，会使黑客们兴奋的地方，也许值得这样去做。在这种情况下，如果你有时间压力，也很有礼貌地提到这点，人们也许会有兴趣回答快一点。

当然，这风险很大，因为黑客们兴奋的点多半与你的不同。譬如从 NASA 国际空间站（International Space Station）发这样的标题没有问题，但用自我感觉良好的慈善行为或政治原因发肯定不行。事实上，张贴诸如紧急：帮我救救这个毛茸茸的小海豹！肯定让你被黑客忽略或惹恼他们，即使他们认为毛茸茸的小海豹很重要。

如果你觉得这点很不可思议，最好再把这份指南剩下的内容多读几遍，直到你弄懂了再发文。

礼多人不怪，而且有时还很有帮助

彬彬有礼，多用请和谢谢您的关注，或谢谢你的关照。让大家都知道你对他们花时间免费提供帮助心存感激。

坦白说，这一点并没有比使用清晰、正确、精准且合乎语法和避免使用专用格式重要（也不能取而代之）。黑客们一般宁可读有点唐突但技术上鲜明的 Bug 报告，而不是那种有礼但含糊的报告。（如果这点让你不解，记住我们是按问题能教给我们什么来评价问题的价值的）

然而，如果你有一串的问题待解决，客气一点肯定会增加你得到有用回应的机会。

（我们注意到，自从本指南发布后，从资深黑客那里得到的唯一严重缺陷反馈，就是对预先道谢这一条。一些黑客觉得先谢了意味着事后就不用再感谢任何人的暗示。我们的建议是要么先说先谢了，然后事后再对回复者表示感谢，或者换种方式表达感激，譬如用谢谢你的关注或谢谢你的关照。）

问题解决后，加个简短的补充说明

问题解决后，向所有帮助过你的人发个说明，让他们知道问题是怎样解决的，并再一次向他们表示感谢。如果问题在新闻组或者邮件列表中引起了广泛关注，应该在那里贴一个说明比较恰当。

最理想的方式是向最初提问的话题回复此消息，并在标题中包含已修正，已解决或其它同等含义的明显标记。在人来人往的邮件列表里，一个看见讨论串问题 X和问题 X - 已解决的潜在回复者就明白不用再浪费时间了（除非他个人觉得问题 X有趣），因此可以利用此时间去解决其它问题。

补充说明不必很长或是很深入；简单的一句你好，原来是网线出了问题！谢谢大家 – Bill比什么也不说要来的好。事实上，除非结论真的很有技术含量，否则简短可爱的小结比长篇大论更好。说明问题是怎样解决的，但大可不必将解决问题的过程复述一遍。

对于有深度的问题，张贴调试记录的摘要是有帮助的。描述问题的最终状态，说明是什么解决了问题，在此之后才指明可以避免的盲点。避免盲点的部分应放在正确的解决方案和其它总结材料之后，而不要将此信息搞成侦探推理小说。列出那些帮助过你的名字，会让你交到更多朋友。

除了有礼貌和有内涵以外，这种类型的补充也有助于他人在邮件列表/新闻群组/论坛中搜索到真正解决你问题的方案，让他们也从中受益。

至少，这种补充有助于让每位参与协助的人因问题的解决而从中得到满足感。如果你自己不是技术专家或者黑客，那就相信我们，这种感觉对于那些你向他们求助的大师或者专家而言，是非常重要的。问题悬而未决会让人灰心；黑客们渴望看到问题被解决。好人有好报，满足他们的渴望，你会在下次提问时尝到甜头。

思考一下怎样才能避免他人将来也遇到类似的问题，自问写一份文件或加个常见问题（FAQ）会不会有帮助。如果是的话就将它们发给维护者。

在黑客中，这种良好的后继行动实际上比传统的礼节更为重要，也是你如何透过善待他人而赢得声誉的方式，这是非常有价值的资产。

如何解读答案

RTFM 和 STFW：如何知道你已完全搞砸了

有一个古老而神圣的传统：如果你收到RTFM（Read The Fucking Manual）的回应，回答者认为你应该去读他妈的手册。当然，基本上他是对的，你应该去读一读。

RTFM 有一个年轻的亲戚。如果你收到STFW（Search The Fucking Web）的回应，回答者认为你应该到他妈的网上搜索。那人多半也是对的，去搜索一下吧。（更温和一点的说法是 Google 是你的朋友！）

在论坛，你也可能被要求去爬爬论坛的旧文。事实上，有人甚至可能热心地为你提供以前解决此问题的讨论串。但不要依赖这种关照，提问前应该先搜索一下旧文。

通常，用这两句之一回答你的人会给你一份包含你需要内容的手册或者一个网址，而且他们打这些字的时候也正在读着。这些答复意味着回答者认为：

你需要的信息非常容易获得；
你自己去搜索这些信息比灌给你，能让你学到更多。

你不应该因此不爽；依照黑客的标准，他已经表示了对你一定程度的关注，而没有对你的要求视而不见。你应该对他祖母般的慈祥表示感谢。

如果还是搞不懂

如果你看不懂回应，别立刻要求对方解释。像你以前试着自己解决问题时那样（利用手册，FAQ，网络，身边的高手），先试着去搞懂他的回应。如果你真的需要对方解释，记得表现出你已经从中学到了点什么。

比方说，如果我回答你：看来似乎是 zentry 卡住了；你应该先清除它。，然后，这是一个很糟的后续问题回应：zentry 是什么？ 好的问法应该是这样：哦~~~我看过说明了但是只有 -z 和 -p 两个参数中提到了 zentries，而且还都没有清楚的解释如何清除它。你是指这两个中的哪一个吗？还是我看漏了什么？

处理无礼的回应

很多黑客圈子中看似无礼的行为并不是存心冒犯。相反，它是直截了当，一针见血式的交流风格，这种风格更注重解决问题，而不是使人感觉舒服而却模模糊糊。

如果你觉得被冒犯了，试着平静地反应。如果有人真的做了出格的事，邮件列表、新闻群组或论坛中的前辈多半会招呼他。如果这没有发生而你却发火了，那么你发火对象的言语可能在黑客社区中看起来是正常的，而你将被视为有错的一方，这将伤害到你获取信息或帮助的机会。

另一方面，你偶尔真的会碰到无礼和无聊的言行。与上述相反，对真正的冒犯者狠狠地打击，用犀利的语言将其驳得体无完肤都是可以接受的。然而，在行事之前一定要非常非常的有根据。纠正无礼的言论与开始一场毫无意义的口水战仅一线之隔，黑客们自己莽撞地越线的情况并不鲜见。如果你是新手或外人，避开这种莽撞的机会并不高。如果你想得到的是信息而不是消磨时光，这时最好不要把手放在键盘上以免冒险。

（有些人断言很多黑客都有轻度的自闭症或亚斯伯格综合症，缺少用于润滑人类社会正常交往所需的神经。这既可能是真也可能是假的。如果你自己不是黑客，兴许你认为我们脑袋有问题还能帮助你应付我们的古怪行为。只管这么干好了，我们不在乎。我们喜欢我们现在这个样子，并且通常对病患标记都有站得住脚的怀疑。）

Jeff Bigler 的观察总结和这个相关也值得一读 (tact filters)。

在下一节，我们会谈到另一个问题，当你行为不当时所会受到的冒犯。

如何避免扮演失败者

在黑客社区的论坛中，你以本指南所描述的或类似的方式，可能会有那么几次搞砸了。而你会在公开场合中被告知你是如何搞砸的，也许攻击的言语中还会带点夹七夹八的颜色。

这种事发生以后，你能做的最糟糕的事莫过于哀嚎你的遭遇、宣称被言语攻击、要求道歉、高声尖叫、憋闷气、威胁诉诸法律、向其雇主报怨、不去关马桶盖等等。相反地，你该这么做：

熬过去，这很正常。事实上，它是有益健康且合理的。

社区的标准不会自行维持，它们是通过参与者积极而公开地执行来维持的。不要哭嚎所有的批评都应该通过私下的邮件传送，它不是这样运作的。当有人评论你的一个说法有误或者提出不同看法时，坚持声称受到个人攻击也毫无益处，这些都是失败者的态度。

也有其它的黑客论坛，受过高礼节要求的误导，禁止参与者张贴任何对别人帖子挑毛病的消息，并声称如果你不想帮助用户就闭嘴。 结果造成有想法的参与者纷纷离开，这么做只会使它们沦为毫无意义的唠叨与无用的技术论坛。

夸张的讲法是：你要的是“友善”（以上述方式）还是有用？两个里面挑一个。

记着：当黑客说你搞砸了，并且（无论多么刺耳）告诉你别再这样做时，他正在为关心你和他的社区而行动。对他而言，不理你并将你从他的生活中滤掉更简单。如果你无法做到感谢，至少要表现得有点尊严，别大声哀嚎，也别因为自己是个有戏剧性超级敏感的灵魂和自以为有资格的新来者，就指望别人像对待脆弱的洋娃娃那样对你。

有时候，即使你没有搞砸（或者只是在他的想像中你搞砸了），有些人也会无缘无故地攻击你本人。在这种情况下，抱怨倒是真的会把问题搞砸。

这些来找麻烦的人要么是毫无办法但自以为是专家的不中用家伙，要么就是测试你是否真会搞砸的心理专家。其它读者要么不理睬，要么用自己的方式对付他们。这些来找麻烦的人在给他们自己找麻烦，这点你不用操心。

也别让自己卷入口水战，最好不要理睬大多数的口水战 —— 当然，这是在你检验它们只是口水战，并且未指出你有搞砸的地方，同时也没有巧妙地将问题真正的答案藏于其后（这也是有可能的）。

不该问的问题

以下是几个经典蠢问题，以及黑客没回答时心中所想的：

问题：我能在哪找到 X 程序或 X 资源？

问题：我怎样用 X 做 Y？

问题：如何设定我的 shell 提示？

问题：我可以用 Bass-o-matic 文件转换工具将 AcmeCorp 文件转换为 TeX 格式吗？

问题：我的程序/设定/SQL 语句没有用

问题：我的 Windows 电脑有问题，你能帮我吗？

问题：我的程序不会动了，我认为系统工具 X 有问题

问题：我在安装 Linux（或者 X ）时有问题，你能帮我吗？

问题：我怎么才能破解 root 帐号/窃取 OP 特权/读别人的邮件呢？

问题：我能在哪找到 X 程序或 X 资源？

回答：就在我找到它的地方啊，白痴 —— 搜索引擎的那一头。天哪！难道还有人不会用 Google 吗？

问题：我怎样用 X 做 Y？

回答：如果你想解决的是 Y ，提问时别给出可能并不恰当的方法。这种问题说明提问者不但对 X 完全无知，也对 Y 要解决的问题糊涂，还被特定形势禁锢了思维。最好忽略这种人，等他们把问题搞清楚了再说。

问题：如何设定我的 shell 提示？？

回答：如果你有足够的智慧提这个问题，你也该有足够的智慧去 RTFM，然后自己去找出来。

问题：我可以用 Bass-o-matic 文件转换工具将 AcmeCorp 文件转换为 TeX 格式吗？

回答：试试看就知道了。如果你试过，你就知道了答案，就不用浪费我的时间了。

问题：我的{程序/设定/SQL 语句}没有用

回答：这不算是问题吧，我对要我问你二十个问题才找得出你真正问题的问题没兴趣 —— 我有更有意思的事要做呢。在看到这类问题的时候，我的反应通常不外如下三种

你还有什么要补充的吗？
真糟糕，希望你能搞定。
这关我屁事？

问题：我的 Windows 电脑有问题，你能帮我吗？

回答：能啊，扔掉微软的垃圾，换个像 Linux 或 BSD 的开源操作系统吧。

注意：如果程序有官方版 Windows 或者与 Windows 有互动（如 Samba），你可以问与 Windows 相关的问题，只是别对问题是由 Windows 操作系统而不是程序本身造成的回复感到惊讶，因为 Windows 一般来说实在太烂，这种说法通常都是对的。

问题：我的程序不会动了，我认为系统工具 X 有问题

回答：你完全有可能是第一个注意到被成千上万用户反复使用的系统调用与函数库文件有明显缺陷的人，更有可能的是你完全没有根据。不同凡响的说法需要不同凡响的证据，当你这样声称时，你必须有清楚而详尽的缺陷说明文件作后盾。

问题：我在安装 Linux（或者 X ）时有问题，你能帮我吗？

回答：不能，我只有亲自在你的电脑上动手才能找到毛病。还是去找你当地的 Linux 使用群组者寻求实际的指导吧（你能在这儿找到用户群组的清单）。

注意：如果安装问题与某 Linux 的发行版有关，在它的邮件列表、论坛或本地用户群组中提问也许是恰当的。此时，应描述问题的准确细节。在此之前，先用 Linux 和所有被怀疑的硬件作关键词仔细搜索。

问题：我怎么才能破解 root 帐号/窃取 OP 特权/读别人的邮件呢？

回答：想要这样做，说明了你是个卑鄙小人；想找个黑客帮你，说明你是个白痴！

好问题与蠢问题

最后，我将透过举一些例子，来说明怎样聪明的提问；同一个问题的两种问法被放在一起，一种是愚蠢的，另一种才是明智的。

蠢问题：

我可以在哪儿找到关于 Foonly Flurbamatic 的资料？

这种问法无非想得到 STFW 这样的回答。

聪明问题：

我用 Google 搜索过 “Foonly Flurbamatic 2600”，但是没找到有用的结果。谁知道上哪儿去找对这种设备编程的资料？

这个问题已经 STFW 过了，看起来他真的遇到了麻烦。

蠢问题：

我从 foo 项目找来的源码没法编译。它怎么这么烂？

他觉得都是别人的错，这个傲慢自大的提问者。

聪明问题：

foo 项目代码在 Nulix 6.2 版下无法编译通过。我读过了 FAQ，但里面没有提到跟 Nulix 有关的问题。这是我编译过程的记录，我有什么做的不对的地方吗？

提问者已经指明了环境，也读过了 FAQ，还列出了错误，并且他没有把问题的责任推到别人头上，他的问题值得被关注。

蠢问题：

我的主机板有问题了，谁来帮我？

某黑客对这类问题的回答通常是：好的，还要帮你拍拍背和换尿布吗？，然后按下删除键。

聪明问题：

我在 S2464 主机板上试过了 X 、 Y 和 Z ，但没什么作用，我又试了 A 、 B 和 C 。请注意当我尝试 C 时的奇怪现象。显然 florbish 正在 grommicking，但结果出人意料。通常在 Athlon MP 主机板上引起 grommicking 的原因是什么？有谁知道接下来我该做些什么测试才能找出问题？

这个家伙，从另一个角度来看，值得去回答他。他表现出了解决问题的能力，而不是坐等天上掉答案。

在最后一个问题中，注意告诉我答案和给我启示，指出我还应该做什么诊断工作之间微妙而又重要的区别。

事实上，后一个问题源自于 2001 年 8 月在 Linux 内核邮件列表（lkml）上的一个真实的提问。我（Eric）就是那个提出问题的人。我在 Tyan S2464 主板上观察到了这种无法解释的锁定现象，列表成员们提供了解决这一问题的重要信息。

通过我的提问方法，我给了别人可以咀嚼玩味的东西；我设法让人们很容易参与并且被吸引进来。我显示了自己具备和他们同等的能力，并邀请他们与我共同探讨。通过告诉他们我所走过的弯路，以避免他们再浪费时间，我也表明了对他们宝贵时间的尊重。

事后，当我向每个人表示感谢，并且赞赏这次良好的讨论经历的时候，一个 Linux 内核邮件列表的成员表示，他觉得我的问题得到解决并非由于我是这个列表中的名人，而是因为我用了正确的方式来提问。

黑客从某种角度来说是拥有丰富知识但缺乏人情味的家伙；我相信他是对的，如果我像个乞讨者那样提问，不论我是谁，一定会惹恼某些人或者被他们忽视。他建议我记下这件事，这直接导致了本指南的出现。

如果得不到回答

如果仍得不到回答，请不要以为我们觉得无法帮助你。有时只是看到你问题的人不知道答案罢了。没有回应不代表你被忽视，虽然不可否认这种差别很难区分。

总的来说，简单地重复张贴问题是个很糟的点子。这将被视为无意义的喧闹。有点耐心，知道你问题答案的人可能生活在不同的时区，可能正在睡觉，也有可能你的问题一开始就没有组织好。

你可以通过其他渠道获得帮助，这些渠道通常更适合初学者的需要。

有许多网上的以及本地的用户群组，由热情的软件爱好者（即使他们可能从没亲自写过任何软件）组成。通常人们组建这样的团体来互相帮助并帮助新手。

另外，你可以向很多商业公司寻求帮助，不论公司大还是小。别为要付费才能获得帮助而感到沮丧！毕竟，假使你的汽车发动机汽缸密封圈爆掉了 —— 完全可能如此 —— 你还得把它送到修车铺，并且为维修付费。就算软件没花费你一分钱，你也不能强求技术支持总是免费的。

对像是 Linux 这种大众化的软件，每个开发者至少会对应到上万名用户。根本不可能由一个人来处理来自上万名用户的求助电话。要知道，即使你要为这些协助付费，和你所购买的同类软件相比，你所付出的也是微不足道的（通常封闭源代码软件的技术支持费用比开源软件的要高得多，且内容也没那么丰富）。

如何更好地回答问题

态度和善一点。 问题带来的压力常使人显得无礼或愚蠢，其实并不是这样。

对初犯者私下回复。 对那些坦诚犯错之人没有必要当众羞辱，一个真正的新手也许连怎么搜索或在哪找常见问题都不知道。

如果你不确定，一定要说出来！ 一个听起来权威的错误回复比没有还要糟，别因为听起来像个专家很好玩，就给别人乱指路。要谦虚和诚实，给提问者与同行都树个好榜样。

如果帮不了忙，也别妨碍他。 不要在实际步骤上开玩笑，那样也许会毁了提问者的设置 —— 有些可怜的呆瓜会把它当成真的指令。

试探性的反问以引出更多的细节。 如果你做得好，提问者可以学到点东西 —— 你也可以。试试将蠢问题转变成好问题，别忘了我们都曾是新手。

尽管对那些懒虫抱怨一声 RTFM 是正当的，但能给出文档的链接（即使只是建议个 Google 搜索关键词）会更好。

如果你决定回答，就请给出好的答案。 当别人正在用错误的工具或方法时别建议笨拙的权宜之计（workaround），应推荐更好的工具，重新界定问题。

正面地回答问题！ 如果这个提问者已经很深入的研究而且也表明已经试过 X 、 Y 、 Z 、 A 、 B 、 C 但没得到结果，回答 试试看 A 或是 B 或者 试试 X 、 Y 、 Z 、 A 、 B 、 C 并附上一个链接一点用都没有。

帮助你的社区从问题中学习。 当回复一个好问题时，问问自己如何修改相关文件或常见问题文件以免再次解答同样的问题？，接着再向文件维护者发一份补丁。

如果你在研究一番后才作出了回答，展现你的技巧而不是直接端出结果。毕竟授人以鱼不如授人以渔。

鸣谢

Evelyn Mitchel 贡献了一些愚蠢问题例子并启发了编写如何更好地回答问题这一节， Mikhail Ramendik 贡献了一些特别有价值的建议和改进。

给你的网页右下角添加个可拖拽弹跳的石蒜模拟器

Sun, 30 Jul 2023 21:39:03 GMT

大家好

不小心在别人博客那看到了个Sakana! Widget，就是在你的网页右下角添加个可拉着玩的小组件

自己试了下，用起来不错

就分享一下怎么弄的吧

先看这里-> Github Here,如果你只想弄上面预设的这两个小人的话，引用一下上面网站里现成代码即可，以下为做一个自己的方法

看看我的组件效果

第一步

(先说明一下，本人使用的方法可能和Github上写的有点不一样，毕竟它上面的看不太懂…)

先创建一个js文件在你的public/js文件夹里，我这里取名为sakana-init.js

输入以下代码

function initSakanaWidget() {  
  const xxx = SakanaWidget.getCharacter("chisato");  
  xxx.image = "url";  
  SakanaWidget.registerCharacter("xxx", xxx);  
  
  new SakanaWidget({  
    character: "xxx",
    controls: true,
    initialState: { i: 1, r: 10 }
  }).mount("#sakana-widget");  
}

里面的xxx即为你想给你的组件小人取的名，没多大用，

xxx.image里输入你的图片链接即可（要透明且大小为宽高比例1：1的图片）

character和control,initialState等下面会说明其用处

当然在后面得加上一个网页加载时自动执行initSakanaWidget()的代码以及引入所需要的js，在这引入比在head标签前要好一点
我这找ChatGPT生成了一个，自己能用

document.addEventListener("DOMContentLoaded", () => {  
  const script = document.createElement("script");  
  script.src = "https://cdn.jsdelivr.net/npm/sakana-widget@2.5.0/lib/sakana.min.js";  
  script.onload = () => {  
    initSakanaWidget();
  };  
  document.body.appendChild(script);  
});

第二步

在你的css文件里引入以下css:

#sakana-widget {
  position: fixed;  
  right: 20px;  
  bottom: 20px;  
}

位置可以随便弄，你甚至也可以加上”z-index: -1;“让它成为背景

第三步

inject你的js和css以及这个组件原本所需要的css等，js最好放在body前，css可以放在head前

# 组件需要的css
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/sakana-widget@2.5.0/lib/sakana.min.css">  
# 你的js和css
<script src="xxx/sakana-init.js"></script>  
<link rel="stylesheet" href="xxx/mycss.css">

再在body里把你的组件容器放上去即可

<div id="sakana-widget"></div>

这样一个简单的石蒜模拟器网页小组件就完成了

其它配置

这个组件有很多的可配置的地方，详细的可以看Github

这里复制一下它的类型定义和构造函数选项

# 类型定义
export interface SakanaWidgetState {  
  /**  
   * 惯性  
   */  
  i: number;  
  /**  
   * 粘性  
   */  
  s: number;  
  /**  
   * 衰减  
   */  
  d: number;  
  /**  
   * 角度  
   */  
  r: number;  
  /**  
   * 高度  
   */  
  y: number;  
  /**  
   * 垂直速度  
   */  
  t: number;  
  /**  
   * 水平速度  
   */  
  w: number;  
}  

export interface SakanaWidgetCharacter {  
  image: string;  
  initialState: SakanaWidgetState;  
}  

# 构造函数选项
export interface SakanaWidgetOptions {  
  /**  
   * 组件大小，默认 `200`  
   */  
  size?: number;  
  /**  
   * 自动适应容器大小 (最小 120px)，默认 `false`  
   */  
  autoFit?: boolean;  
  /**  
   * 角色，默认 `chisato`  
   */  
  character?: 'chisato' | 'takina';  
  /**  
   * 控制栏，默认 `true`  
   */  
  controls?: boolean;  
  /**  
   * 展示支撑杆，默认 `true`  
   */  
  rod?: boolean;  
  /**  
   * 可拖动，默认 `true`  
   */  
  draggable?: boolean;  
  /**  
   * canvas 线条设置，默认 `#b4b4b4` & `10`  
   */  
  stroke?: {  
    color?: string;
    width?: number;
  };  
  /**  
   * 停止动画的阈值，默认 `0.1`  
   */  
  threshold?: number;  
  /**  
   * 旋转角度，默认 `0`  
   */  
  rotate?: number;  
}

具体怎么用呢

看看第一步的这个代码

  new SakanaWidget({  
    character: "xxx",
    controls: true,
    initialState: { i: 1, r: 10 }
  }).mount("#sakana-widget");  
}

把你想添加的依次加上就行了

这样你的网页应该就会有个可拖拽弹跳的石蒜模拟器了！

在你的html或文章里运行python

Sun, 23 Jul 2023 17:02:19 GMT

前言

这里是2025年的天影大侠，这不知道从哪找的个东西，都忘了自己弄过这个。

问候

大家好

发文章的时候总是只能发代码，不能运行
现在发现了一个东西，可以在你的文章中直接运行python
它就是pyscript，来看看吧

[官方文档](PyScript — PyScript documentation)在这<—

第一步

想要在你的文章中运行python代码，请先在前引入pyscript的css和js

<link rel="stylesheet" href="https://pyscript.net/latest/pyscript.css" />  
<script defer src="https://pyscript.net/latest/pyscript.js"></script>

第二步

在你的文章body里添加，并在标签前插入你的python代码
比如

<py-script>  
    print('Hello World!')
</py-script>

当然，也可以先在style标签前修改一下pyscript输出的样式，这里随便改一下

<style>  
    py-script {
        width: 100%;
        height: 100%;
        font-size: 20px;
        text-align: center;
        position: absolute;
    }
</style>

运行结果如下;

第三步

运行是没有问题，但每次打开网页时都要加载一段时间来下载pyodide

下载太慢了，毕竟没人想进入一个网页还得加载好半天吧

根据文档，在body里引入以下代码:

    <py-config>
      [[interpreters]]
        src = "XXX"
        name = "pyodide-0.23.4"
        lang = "python"
    </py-config>

之后你就可以在标签前写上自己的python代码来运行了

其它

这只是最基本的print用法，你也可以在标签前引入其他python包，此标签应放在标签前，如

<py-env>  
 - numpy  
 - matplotlib  
</py-env>

即引入了numpy和matplotlib
也可以直接引入.whl，如

<py-env>  
 - 'http://xxx.com/xxx.whl'  
</py-env>

那要怎么放在文章里呢？
其实可以直接把html写在文章的index.md里，它在网页上会正常显示的

废话

这个pyscript自己用起来觉得还是不如js
毕竟加载的太慢了，要下载Pyodide的文件
更多更详细的教程还请移步[官方文档](PyScript — PyScript documentation)

【失效】网易云音乐搜索分享

Sun, 16 Jul 2023 14:53:20 GMT

做了网易云音乐搜索的网站，我的世界风格
用的Vercel部署网易云音乐api ，域名是国内的，访问可能会有点慢
目前只有搜索音乐的功能，制作简陋
但做起来图一乐

在博客右上角里可以看到

给你的网站添加个页面加载进度条

Sat, 15 Jul 2023 15:23:59 GMT

大家好
无意中发现了一个能制作自动页面加载进度条的网页
测试了一下，效果不错
发来给大家试试
网站在这：https://codebyzach.github.io/pace/
进入后会有一个既炫酷又平平无奇的加载动画

向下翻可以看到预设的一些加载动画
先选择颜色，再选择样式
样式随便选一个，就loading bar吧

点击DOWNLOAD
然后将它放在你的网站上，我就放在https://skyshadowhero.github.io/css/loading-bar.css里的
然后复制网站中Get Start里中间的的代码，并将红色方框里的路径改为你所放的css文件路径

然后将编辑好的代码放进html文件里的标签前即可

如果使用的Hexo+Butterfly搭建博客的话可以直接将此两行代码放在_config.butterfly.yml里的相关位置

在bash中输入hexo g -d后进入网页，你的页面加载进度条就出现了
效果如下图：

【过时】拥有一个动态透明的QQ头像（非小世界）

Fri, 14 Jul 2023 18:50:51 GMT

已过时，用模块可以更快捷

大家好！
今天发一下QQ透明和动态头像的教程
为了方便，这里就用一个透明动态头像来进行演示！

如上图，就这个滑稽脸

Step1:

下载软件：
就1.2MB的小软件，不要害怕: (
下载Link
当然了，建议进群下载，群链接在软件右下角可看到

Step2:

登录QQ并打开软件：
登录QQ，新版旧版都行，亲测TIM也可以
双击下载的透明头像.exe
如果报错“无法成功完成操作，因为文件包含病毒或潜在的垃圾软件”就前往知乎看看
打开后应是这样

Step3：

点击上传图片，在文件类型中选择.gif(看你要上传什么头像，我这是gif的)
选择我们的gif

点击打开(

Step4：

在上方选择你登录的QQ号后，点击修改头像
自此，你的透明动态头像就上传成功了！
如图：（当然它是在动的）

如果有问题可点击软件上的加群
当然可以直接上传透明图片
图片如下（你不会看不到吧..）

图片在上：）

图片最大只能1MB
如果没有电脑的话，听说用模块也可以达到同样的效果
要不就直接用QQ小世界吧

分享：一个Python桌面时钟

Sat, 04 Feb 2023 16:13:00 GMT

前言

这里是2025年的天影大侠，这东西是网课的时候做的，把钉钉放着，自己却在翻python文档，好神奇。

正文

分享用Python做的一个桌面时钟

代码如下，有注释，一目了然：

#引入一些东西
import tkinter as tk  
from tkinter import messagebox  
import time  
#设置主窗口
root = tk.Tk()  
#设置窗口标题
root.title('桌面时钟')  
#设置窗口透明度
root.attributes("-alpha",0.95)  
#设置窗口置顶
root.attributes('-topmost', True)  
#设置一些有用的变量
#size,color,font可自行修改
size = 40  
width = size/4*25  
height = size/4*8  
color = "black"  
font = "微软雅黑"  
#将窗口显示到屏幕正中央并设置窗口大小
screenwidth = root.winfo_screenwidth()  
screenheight = root.winfo_screenheight()  
size_geo = '%dx%d+%d+%d' % (width, height, (screenwidth-width)/2, (screenheight-height)/2)  
root.geometry(size_geo)  
root.resizable(0,0)  
# 获取时间的函数
def gettime():  
    # 获取当前时间
    dstr.set(time.strftime("%H:%M:%S"))
    # 每隔 1s 调用一次 gettime()函数来获取时间
    root.after(1000, gettime)
# 生成动态字符串
dstr = tk.StringVar()  
# 利用 textvariable 来实现文本变化
lb = tk.Label(root,textvariable=dstr,fg=color,font=(font,size))  
#把时钟放上窗口
lb.pack()  
# 调用生成时间的函数
gettime()  
# 显示窗口
root.mainloop()

拿着用用没问题

【过时】做一个我的世界风格的Logo！

Thu, 26 Jan 2023 20:19:47 GMT

前言

这里是2025年的天影大侠，这好像是我的第一篇文章，或许有用，但会的大佬可以用ps或blender，就当个分享吧

前言

已过时！用blockbench更快捷。
大家好，看看下面这张独特的404图片，是不是自己也想做一个Minecraft风格的Logo呢？

教程这就来了！（由一个叫MrBrose的大佬原创，点这里去他的主页）

第一步！

下载我的世界动画制作器（Mine-imator）

这个软件呢就是一个专门制作我的世界动画的东西
点击下边这个大大的按钮下载

下载好后，你就能做一般的我的世界动画了
但我们要做的是我的世界风格的Logo
这时就需要第二步

第二步！

下载由ShinyGHASTTear大佬制作的我的世界字母模型

点击下面这个小小的文字下载
下载！
下载好后，打开Mine-imator，进入第三步，可自由发挥

第三步！

进入Mine-imator后，点击这个New Project
之后Name（名字），Author（制作者），Description（介绍），随便填
创好后应该会进入这个界面
看到左上角那个工作台了没，点它
圈起来的就是要用的

点击地形，点击Scenery，“Import from world”就是从我的世界官方默认路径里的地图里抠出来一点地形（也可以用其他路径的地图）
“Browse”就是从一些地形文件里导入，有预设的，也可以自己从我的世界地图里扣

我这里就用预设的演示，按住右键并用WASD来移动！控制鼠标也行。
光源的话自己琢磨，不用也没啥大问题
然后点击自定义模型

这时候解压你下载的字体模型包

导入你所想做的模型和想要的材质样式（只有字母数字和一些标点。。），这里用A字母做演示（苦力怕脸在A的背面，将Y旋转180度即可）

在右下角选择A（父节点），控制箭头来移动字母，旋转Rotation中的X轴来使字母向上偏转
偷偷加个光源
然后添加摄像头，将摄像头的Parent设置为A（父节点的A），如果有多个字母就设置为最中间那个字母为Parent，主要是让Logo出现在摄像机的中间，自己控制XYX也行，控制Position中的YZ来移动摄像头，控制Rotation中的X来让摄像头向上偏转

之后点击这个按钮[

再点击保存

第四步！

看看你的图片，右下角怎么会有水印？
可以点击右上角那个小黄星来Upgrade，它会然你去一个网页

选择I’d rather not donate后点击Get Key，将它弹出的Key复制到Mine-imator即可！再次保存，就没有水印了

分享：一些VBS小资源

Wed, 18 Jan 2023 15:52:19 GMT

前言

这里是2025年的天影大侠，这是网课期间上网找的，当个分享吧

正文

VBS是什么?
VBS是基于Visual Basic的脚本语言。VBS的全称是：Microsoft Visual Basic Script Edition。（微软公司可视化BASIC脚本版）。
大家可以百度查查关于vbs的其他信息，天影大侠这里贴心地准备了百度百科链接…
当然了，和你们一样，我只是一个新手，碰vbs都是为了整蛊好友们
所以，这里就分享天影大侠在网上找到的一些vbs资源
中文部分可自行修改

一个问题，如不选择”是”，则永不能退出！

do  
a =msgbox("问题内容！！！",vbYesNoCancel,"问题标题")  
if a =vbYes then  
msgbox "Yes回答内容",,"标题"  
exit do  
elseif a =vbNo then  
b =msgbox("你完了",vbYesNo,"你完了。")  
if b =vbYes then  
msgbox "你完了！",,"你完了！！！"  
else  
msgbox "你完了！！！",,"你完了。。。"  
end if  
else  
d =msgbox("你完了！！！",vbYesNo,"你完了——")  
if d =vbYes then  
msgbox "你完了！",,"你完了！！！"  
else  
msgbox "你完了。。。",,"你完了！！！"  
end if  
end if  
loop

你完了，无论点击什么都不会关闭，可在任务管理器里关闭

do  
a =msgbox("你完了。。。",vbYesNoCancel,"你完了")  
if a =vbYes then  
    b =msgbox("你完了",vbYesNo,"你完了。")
    if b =vbYes then
    msgbox "你完了！",,"你完了！！！"
    else
    msgbox "你完了！！！",,"你完了。。。"
    end if

elseif a =vbNo then  
    b =msgbox("你完了",vbYesNo,"你完了。")
    if b =vbYes then
    msgbox "你完了！",,"你完了！！！"
    else
    msgbox "你完了！！！",,"你完了。。。"
    end if
else  
    d =msgbox("你完了！！！",vbYesNo,"你完了——")
    if d =vbYes then
    msgbox "你完了！",,"你完了！！！"
    else
    msgbox "你完了。。。",,"你完了！！！"
    end if

end if  
loop

打开有惊喜，无限弹窗！关机即可解决

do  
wscript.createobject("wscript.shell").run "mshta vbscript:msgbox(""惊喜"")(windows.close)",vhide  
loop

看到了吧，领一个去整蛊朋友多是一件美事…