风观

生信自学路线图：从Linux基础到独立分析

Sun, 15 Mar 2026 00:00:00 GMT

本文是生信自学路线总结，按 Linux 基础→Conda 环境→数据获取→质控比对→差异分析→可视化→可重复性的顺序，列出每个阶段的核心内容和推荐学习资源。适合从零开始规划学习路径。

第一阶段：Linux生存能力（1-2周）#

目标：能自己在服务器上装软件、跑脚本、找到文件。

推荐：

目录结构（/opt、/home、/tmp）
文件操作（ls -la、chmod、ln -s、find）
文本处理（grep、awk、sed基本用法）
后台任务（screen/tmux）
软件安装（apt、conda）

检验标准： 给你一台裸Linux服务器，能装好 Miniconda + 配镜像源 + 下载一个 SRA 数据 + 跑完 fastqc。

第二阶段：生信工具链（2-4周）#

目标：理解测序数据是什么、怎么处理的。

推荐：

FASTQ 格式 → FastQC + fastp 质控
Conda 环境管理 → 每个项目独立环境
SRA-toolkit → 从 NCBI 下载数据
BWA / HISAT2 → 短序列比对
Samtools → BAM 文件处理
bedtools → 区间操作

检验标准： 从 GEO 找一个公开 RNA-seq 数据集，完成 FASTQ→比对→BAM排序索引。

第三阶段：定量与差异分析（2-3周）#

目标：能跑完一个完整的 RNA-seq 差异表达分析。

推荐：

featureCounts → 基因表达定量
DESeq2 → 差异表达分析
ggplot2/pheatmap → 结果可视化
R tidyverse → 数据清洗

检验标准： 对一个公开数据集跑完差异分析，画出火山图和热图。

第四阶段：可重复性与效率（持续）#

目标：分析结果别人能复现、自己能重现。

推荐：

Shell 脚本规范（set -euo pipefail）
Git 版本控制
项目目录规范
数据备份（rsync）
流程自动化（Snakemake/Nextflow）

检验标准： 你的分析全流程写在一个脚本里，换台机器能一键跑完。

学习资源#

类型	推荐	理由
系统学习	Biostars 论坛	每个问题都有答案
实操入门	《Bioinformatics Data Skills》	命令行驱动，不依赖GUI
R语言	《R for Data Science》	tidyverse圣经
生信流程	nf-core	标准化Nextflow流程，参考最佳实践

最关键的一句话#

不要试图一次学完所有东西。 找到一个小项目（比如复现一篇论文的RNA-seq分析），边做边学。卡住了查 Biostars、翻文档、写博客记录——我就是这么过来的。

本文于 2026-03-15 完稿。50篇生信基础博客系列完结。

命令行小工具：seqtk/csvtk/datamash/bioawk

Tue, 20 Jan 2026 00:00:00 GMT

生信命令行有一批小而精的工具，各自专注特定场景。本文覆盖 seqtk 序列抽样、csvtk 表格处理、datamash 命令行统计、bioawk 生信专用 awk，比手写 awk 更简洁可靠。

1. seqtk——序列抽样和格式转换#

Terminal window

1
conda install -c bioconda seqtk -y
2

3
# 随机抽样10000条（-s种子保证可重复）
4
seqtk sample -s42 sample.fastq 10000 > sub.fastq
5

6
# FASTA→FASTQ（质量全I）
7
seqtk seq -F 'I' input.fa > output.fq
8

9
# 按名称列表提取
10
seqtk subseq input.fa id_list.txt > subset.fa
11

12
# 统计
13
seqtk comp input.fa  # 每序列碱基组成
14
seqtk fqchk input.fq # FASTQ质量概览

2. csvtk——CSV/TSV表格处理#

Terminal window展开收起

1
conda install -c bioconda csvtk -y
2

3
# 查看列名和前5行
4
csvtk headers file.tsv
5
csvtk head -n 5 file.tsv
6

7
# 按列提取
8
csvtk cut -f gene_id,log2FC,padj degs.csv
9

10
# 筛选（padj<0.05且log2FC>1）
11
csvtk filter2 -f '$padj<0.05 && $log2FC>1' degs.csv
12

13
# 按列排序
14
csvtk sort -k padj:n degs.csv
15

16
# 两个表格按基因ID合并
17
csvtk join -f gene_id expr.tsv annot.tsv > merged.tsv

展开收起

nnn表示数值列。padj:n 中的 :n 指定按数值排序。

3. datamash——命令行统计分析#

Terminal window

1
apt install datamash
2

3
# 计算表达矩阵每行的均值
4
cat expr.tsv | datamash mean 2-10
5

6
# 按分组统计
7
cat data.tsv | datamash -g 1 mean 3 median 3
8

9
# 描述性统计
10
cat values.txt | datamash min 1 q1 1 median 1 q3 1 max 1 sstdev 1

比 R 快很多——百万行数据秒出统计量。

4. bioawk——生信专用awk#

Terminal window

1
conda install -c bioconda bioawk -y
2

3
# 统计FASTQ质量
4
bioawk -c fastx '{print $name, length($seq), meanqual($qual)}' sample.fq | head
5

6
# 筛选GC含量
7
bioawk -c fastx 'gc($seq)>0.5' input.fq > gc_high.fq
8

9
# 统计FASTA序列长度分布
10
bioawk -c fastx '{print $name, length($seq)}' genome.fa | datamash min 2 max 2 median 2

5. 踩坑#

seqtk sample的种子必设——-s不加的话每次结果不同
csvtk列索引从1开始——不是0-based
datamash分组前必须排序——sort -k1,1 | datamash -g 1
bioawk遇到gzip——需要先 zcat 管道传入

本文于 2026-01-20 实测。

Vim配置与技巧：语法高亮、折叠、宏、多文件

Tue, 20 Jan 2026 00:00:00 GMT

服务器上 SSH 环境编辑文件，nano 适合临时改配置，Vim 适合日常开发——改 Shell 脚本、调 R 代码、查看大日志。本文不讲 hjkl 基础操作，聚焦高频实战：语法高亮、代码折叠、宏录制、正则替换、多文件操作、NERDTree。

实测环境：Debian 13，Vim 9.1，终端 SSH 连接。

1. 基础配置——`.vimrc`#

先把 Vim 从”能忍”变成”好用”。在 ~/.vimrc 里加上这几行：

1
" === 基础设置 ===
2
set number              " 显示行号
3
set relativenumber      " 相对行号（跳转时有奇效）
4
set cursorline          " 高亮当前行
5
set showcmd             " 右下角显示正在输入的命令
6
set wildmenu            " 命令模式Tab补全增强
7

8
" === 缩进（写脚本必备）===
9
set autoindent          " 自动缩进
10
set smartindent         " 智能缩进
11
set tabstop=4           " Tab显示为4空格
12
set shiftwidth=4        " 自动缩进4空格
13
set expandtab           " Tab转空格（Python/R必备！）
14
set softtabstop=4
15

16
" === 搜索高亮 ===
17
set hlsearch            " 高亮搜索结果
18
set incsearch           " 边输入边搜索
19
set ignorecase          " 搜索忽略大小写
20
set smartcase           " 有大写字母时自动区分大小写
21

22
" === 其他 ===
23
set encoding=utf-8      " 文件编码UTF-8
24
set mouse=a             " 鼠标可用（SSH下也支持）
25
set clipboard=unnamed   " 系统剪贴板
26
syntax on               " 语法高亮

展开收起

relativenumber 强烈推荐。它的效果：

1
  3  # 上一行
2
  2  # 上两行
3
  1  # 上一行
4
123  当前行的实际行号
5
  1  # 下一行
6
  2  # 下两行

这时候你想跳到下面第 2 行，直接按 2j 就行——不用心算。

2. 生信文件类型的语法高亮#

BED、GFF、FASTA、SAM——这些生信格式默认没有语法高亮。文件是纯文本，但有些列有特殊含义，高亮之后一眼能看出问题。

2.1 FASTA 语法高亮#

1
" 加到 ~/.vimrc
2
augroup fasta_highlight
3
    autocmd!
4
    autocmd BufRead,BufNewFile *.fa,*.fasta,*.fna set filetype=fasta
5
augroup END

然后创建 ~/.vim/syntax/fasta.vim：

1
" fasta.vim - FASTA 语法高亮
2
if exists("b:current_syntax")
3
    finish
4
endif
5

6
" 序列头（>开头）→ 蓝色粗体
7
syntax match fastaHeader /^>.*/
8
highlight fastaHeader ctermfg=Blue cterm=bold
9

10
" A → 绿色
11
syntax match fastaA /A/ containedin=fastaSequence
12
highlight fastaA ctermfg=Green
13

14
" T → 红色
15
syntax match fastaT /T/ containedin=fastaSequence
16
highlight fastaT ctermfg=Red
17

18
" G → 黄色
19
syntax match fastaG /G/ containedin=fastaSequence
20
highlight fastaG ctermfg=Yellow
21

22
" C → 青色
23
syntax match fastaC /C/ containedin=fastaSequence
24
highlight fastaC ctermfg=Cyan
25

26
" N → 灰色（表示不确定碱基）
27
syntax match fastaN /N/ containedin=fastaSequence
28
highlight fastaN ctermfg=DarkGrey
29

30
" 序列行（不以>开头）
31
syntax match fastaSequence /^[^>].*/ contains=fastaA,fastaT,fastaG,fastaC,fastaN
32

33
let b:current_syntax = "fasta"

展开收起

效果就是 ATGC 分别用了不同颜色。打开一个 fasta 文件，序列组成一目了然——如果全是绿色（A-rich）或者突然出现大量灰色的 N，立刻知道有问题。

2.2 BED 文件按列着色#

BED 最关键的坑是第 2、3 列（start/end）的坐标系统。高亮后能快速定位异常的区间长度：

1
" ~/.vim/syntax/bed.vim
2
syntax match bedChrom /^chr\w\+/
3
highlight bedChrom ctermfg=Magenta
4

5
syntax match bedStart /^\S\+\s\+\zs\d\+/
6
highlight bedStart ctermfg=Yellow
7

8
syntax match bedEnd /^\S\+\s\+\d\+\s\+\zs\d\+/
9
highlight bedEnd ctermfg=Red

3. 折叠代码——超长脚本的救星#

Shell 脚本超过 200 行，R 脚本超过 500 行，在终端里滚来滚去找函数是噩梦。Vim 的代码折叠功能可以把函数定义折叠成一行：

1
" ~/.vimrc 加
2
set foldmethod=marker    " 用{{{ }}}标记折叠
3
set foldlevel=0          " 默认全部折叠
4
set foldcolumn=1         " 左侧显示折叠列

在你的脚本里手动加标记：

Terminal window

1
# 数据处理 {{{1
2
process_data() {
3
    ...
4
}
5
# 1}}}
6

7
# 质量控制 {{{1
8
run_qc() {
9
    ...
10
}
11
# 1}}}

然后 zc 关闭折叠，zo 打开折叠，za 切换折叠状态。或者直接用 zM 全部折叠，zR 全部展开。

更推荐的是用折叠方式 indent：

1
" Sh/Bash 脚本自动按缩进折叠
2
autocmd FileType sh setlocal foldmethod=indent foldlevel=2
3
" Python 同理
4
autocmd FileType python setlocal foldmethod=indent foldlevel=1

这样完全不需要手动加标记，脚本的缩进结构就是折叠结构。

4. 宏录制——重复操作的自动化#

这是 Vim 最被低估的功能，在生信里频繁用到。

场景： 有 50 个样本的 fastq 路径，你想把它们改成对应的输出文件名。每个文件名从：

1
/opt/data/raw/Sample_001_R1.fastq.gz

改成：

1
/opt/data/clean/Sample_001_clean_R1.fastq.gz

宏操作步骤：

1
1. qa           " 开始录制宏到寄存器 a
2
2. 0            " 跳到行首
3
3. f/           " 找到第一个 / 的位置（光标到 raw 的 /）
4
4. 然后手动编辑该行
5
5. j            " 跳到下一行
6
6. q            " 停止录制
7
7. 49@a         " 对剩余49行执行宏 a

更实用的办法——同一个操作记成宏后配合搜索执行：

1
:g/raw/s//clean/g      " 全局替换 raw→clean

但宏的优势在于可以录制任何操作序列，不限于替换：移动光标、删除、粘贴、进入插入模式打字、退出——宏全记下来了。

生信中最常见的宏使用场景：

场景	录制内容
批量格式化样本名	移动→修改→下一行
从日志提取特定列	删除无关列→保存→下一行
给每行加前缀/后缀	`I前缀 Esc j`
拆分行	`f分隔符 r换行 j`

5. 多文件操作——buffer + 分屏#

生信项目里经常同时开 4-5 个文件：脚本、输入文件、输出日志、配置文件。

1
" 分屏打开
2
vim -O script.sh data.txt          " 左右分屏（大写O）
3
vim -o script.sh data.txt          " 上下分屏（小写o）
4

5
" 已有文件内分屏
6
:sp another_file.sh                " 水平分屏
7
:vsp another_file.sh               " 垂直分屏
8

9
" 切换窗口
10
Ctrl-w h    " 左
11
Ctrl-w j    " 下
12
Ctrl-w k    " 上
13
Ctrl-w l    " 右
14

15
" 调整窗口大小
16
Ctrl-w +    " 加大
17
Ctrl-w -    " 缩小
18
Ctrl-w =    " 等宽

展开收起

打开多个文件时用 :ls 查看缓冲区列表：

1
:buffers     " 列出所有打开的文件
2
:b 2         " 切换到第2号缓冲区
3
:bn          " 下一个buffer
4
:bp          " 上一个buffer
5
:bd          " 关闭当前buffer

6. 查找与替换——正则替换实战#

6.1 基础查找#

1
/pattern        " 向下搜索
2
?pattern        " 向上搜索
3
n               " 下一个匹配
4
N               " 上一个匹配
5
*               " 搜索当前光标下的单词（向下）
6
#               " 搜索当前光标下的单词（向上）

6.2 正则替换——生信高频操作#

1
" 范围语法：[range]s/pattern/replacement/[flags]
2

3
" 全文替换（% = 整个文件）
4
:%s/raw/clean/g
5

6
" 当前行替换
7
:s/foo/bar/
8

9
" 第10-20行替换
10
:10,20s/foo/bar/g
11

12
" 替换前逐个确认（c = confirm）
13
:%s/old/new/gc
14

15
" 将 FASTA 序列头的空格转成下划线
16
:%s/^>\(.*\)/\=substitute(submatch(1), ' ', '_', 'g')/

展开收起

生信中几个一行搞定的 Vim 正则替换：

1
" 1. 删除 FASTA 注释行（以>开头但含额外注释）
2
:g/^>.*comment/d
3

4
" 2. 每行末尾加文件后缀
5
:%s/$/  .fastq.gz/
6

7
" 3. 把 SAM 文件的 @ 头提取到新文件
8
:g/^@/y A              " 把所有@开头行追加到寄存器A
9
:new | put A           " 新buffer粘贴
10

11
" 4. 把以空格分隔的样本ID列转成换行分隔
12
:%s/ /\r/g
13

14
" 5. 删除空行
15
:g/^$/d

展开收起

6.3 Vim 正则 vs Perl 正则的差异#

Vim 的正则需要转义的元字符更多，这点比较反直觉：

含义	Perl/PCRE	Vim
一个或多个	`+`	`\+`
零个或一个	`?`	`\?`
分组	`()`	``
或	`\|`	`\|`（相同）
数字	`\d`	`\d`（相同）

可以用 \v（very magic）模式让 Vim 更接近 Perl：

1
" 默认（需要转义+和括号）
2
:%s/foo\(bar\)\+/baz/g
3

4
" \v 模式（+和括号不需要转义）
5
:%s/\vfoo(bar)+/baz/g

生信中的正则替换建议一律加 \v， 减少转义导致的漏匹配。

7. 查看超长序列——折行与导航#

FASTA 文件每行通常 60 或 80 个碱基，但有时会遇到”单行全序列”（整个染色体一行）。这种文件在 Vim 里打开就是一条超长行。

1
:set wrap               " 折行显示（不破坏文件内容）
2
:set linebreak          " 在单词边界折行
3
:set breakindent        " 折行保持缩进
4

5
" 快速导航长行
6
g0      " 跳到屏幕行的开头
7
g$      " 跳到屏幕行的末尾
8
gj      " 向下一个屏幕行
9
gk      " 向上一个屏幕行

如果你想真正把长行切成每 60 个碱基一行（即重新格式化 FASTA）：

1
" 对非>开头的行，每60个字符后换行
2
:%s/^[^>].*/\=join(split(submatch(0), '.\{60}'), '\n')/

但其实用 seqkit 更快：seqkit seq -w 60 input.fa > output.fa——Vim 里记这个正则主要是为了理解它的字符串处理能力。

8. 踩坑记录#

坑1：粘贴代码缩进错乱#

从浏览器复制代码，在 Vim 里 Ctrl-v 粘贴，缩进层层叠加——像阶梯一样往右偏。

原因： Vim 的 autoindent 会对粘贴的内容逐行自动缩进，而粘贴的内容本身已经有缩进。

解决： 粘贴前进入粘贴模式：

1
:set paste       " 进入粘贴模式（禁用自动缩进）
2
" 粘贴代码...
3
:set nopaste     " 退出粘贴模式

或者在 .vimrc 里绑定快捷键：

1
set pastetoggle=<F2>    " F2 切换粘贴模式

坑2：用 `:wq` 保存只读文件#

修改了一个没有写权限的文件（比如 /etc/hosts），:wq 才告诉你没权限，改的内容也丢了。

1
" 正确做法：用 sudo 权限写
2
:w !sudo tee % > /dev/null
3
" 解释：把当前内容通过 sudo tee 写回原文件（% = 当前文件名）

坑3：误按 `Ctrl-z` 后 Vim “卡死”#

Ctrl-z 把 Vim 挂到后台了，终端看起来像卡住了。实际上 Vim 还活着，只是被 suspend 了。

Terminal window

1
# 回到 Vim
2
fg
3

4
# 查看所有后台任务
5
jobs

如果不小心按了 Ctrl-z，别慌——fg 就回来了。如果不想要这个快捷键，在 .vimrc 里禁掉：

1
nnoremap <C-z> <Nop>   " 禁用Ctrl-z

坑4：高亮残留——`:noh` 是你的朋友#

搜索了一个词之后，高亮一直留到下次搜索。看着烦。

1
:noh            " 清除搜索高亮（nohlsearch缩写）

也可以在 .vimrc 里绑定到 Esc：

1
nnoremap <Esc> :noh<CR>

坑5：Vim 里的 Undo 只能用一次#

默认情况下 u 只能回退一步。要无限回退：

1
set undofile                " 持久化 undo 历史
2
set undodir=~/.vim/undo     " undo 文件存放目录

创建目录：mkdir -p ~/.vim/undo

之后就算关掉 Vim 再打开，也能 u 回退到昨天的修改。

9. Vim 工作流模板#

一个典型的”改脚本→查日志→回脚本”循环：

1
1. :tabedit script.sh       " 新标签页打开脚本
2
2. Ctrl-w s                 " 水平分屏
3
3. :e logs/today.log        " 下方打开日志
4
4. Ctrl-w k                 " 切回上方
5
5. /ERROR                   " 搜索脚本里ERROR的处理逻辑
6
6. Ctrl-w j                 " 切到日志看实际报错
7
7. Ctrl-w k                 " 回去修改
8
8. :w                       " 保存
9
9. :!bash script.sh         " 不退出Vim直接运行脚本

如果你一天做 20 次这个循环，每次比用 nano+grep+less 省 30 秒——一天省 10 分钟，一个月省 3 小时。

10. 推荐插件（最小化原则）#

插件太多会让 Vim 启动慢，而且在服务器上不适合装一堆东西。我只推荐两个：

NERDTree——文件浏览器#

Terminal window

1
# 安装（用 vim-plug 或手动）
2
mkdir -p ~/.vim/pack/plugins/start
3
cd ~/.vim/pack/plugins/start
4
git clone https://github.com/preservim/nerdtree.git

使用：

1
:NERDTreeToggle     " 开关文件树
2
:NERDTreeFind       " 在文件树中定位当前文件

实用快捷键：

o 打开文件 / 展开目录
m 打开菜单（新建/删除/移动文件）
? 帮助

vim-airline——状态栏美化#

纯视觉增强，但显示的信息很实用：当前 Git 分支、文件类型、行列位置。

Terminal window

1
cd ~/.vim/pack/plugins/start
2
git clone https://github.com/vim-airline/vim-airline.git

11. 总结#

技能	Vim 命令	生信场景
相对行号跳转	`12j` / `5k`	快速定位脚本中的某一行
批量替换	`:%s/\vold/new/g`	改样本名前缀、修路径
宏录制	`qa ... q` → `@a`	50 个样本文件名格式统一
分屏编辑	`Ctrl-w s/v`	边看日志边改脚本
代码折叠	`zc` / `zo`	浏览 500 行 Shell 脚本
粘贴模式	`:set paste`	从网页复制命令到脚本
正则替换增强	`\v` 前缀	避免转义地狱

最后一条建议： 别试图一天学会 Vim。先学会 5 个命令（i 插入、Esc 退出、:w 保存、:q 退出、/ 搜索），然后用这 5 个命令干两天活。两天后再加 5 个命令。两周之后你就回不去 nano 了。

本文于 2026-01-20 在 Debian 13 上实测完成。Vim 9.1，所有配置和命令均在生产服务器上验证可用。

网络诊断与测速：ping/mtr/iperf3/curl

Sun, 18 Jan 2026 00:00:00 GMT

国内从 NCBI/ENA 下载 SRA 数据时，常见问题包括：带宽不足、防火墙限速、DNS 解析慢、磁盘写满。本文覆盖网络诊断全栈工具链：ping/mtr 路由追踪、iperf3 带宽测试、curl 下载分析、DNS 排查和代理配置。

实测环境：Debian 13，千兆教育网接入。

1. 连通性诊断——从ping开始但不只ping#

1.1 ping——第一把手术刀#

Terminal window

1
# 基础连通性
2
ping -c 10 ftp.ncbi.nlm.nih.gov
3

4
# 看延迟波动（-i 间隔，-c 次数）
5
ping -i 0.2 -c 100 ftp.sra.ebi.ac.uk
6

7
# 大包测试（看MTU/分片问题）
8
ping -s 1400 -c 10 ftp.ncbi.nlm.nih.gov

解读：

指标	正常	需关注	严重
延迟（RTT）	<50ms(国内) <300ms(国际)	300-500ms	>500ms 或剧烈抖动
丢包率	0%	1-2%	>5%
抖动（mdev）	<10ms	10-50ms	>50ms

但要注意：ping 通 ≠ 带宽够。ICMP 包只有几十字节，和下载 50GB 完全不是一回事。而且很多服务器根本不响应 ping（禁了 ICMP），ping 不通不代表网络有问题。

1.2 mtr——ping + traceroute 的合体#

Terminal window

1
sudo apt install mtr -y
2

3
# 交互式实时追踪
4
mtr ftp.ncbi.nlm.nih.gov
5

6
# 报告模式（发送100个包然后输出）
7
mtr -r -c 100 ftp.ncbi.nlm.nih.gov
8

9
# 不解析主机名（更快）
10
mtr -r -n -c 100 130.14.29.30

mtr 输出解读——每跳一个路由器，关键看：

1
HOST                           Loss%   Snt   Last   Avg  Best  Wrst StDev
2
1. 10.0.0.1                    0.0%   100    0.3   0.5   0.2   2.1   0.3
3
2. 192.168.1.1                 0.0%   100    1.2   1.5   0.8   5.3   0.8
4
3. ???                         100.0% 100    0.0   0.0   0.0   0.0   0.0
5
4. 202.112.x.x                 0.0%   100    5.2   5.8   4.1  12.3   1.2
6
...
7
12. be-101-pe02.ashburn.va     0.0%   100  215.6 220.1 210.3 260.2 12.5
8
...
9
15. ftp.ncbi.nlm.nih.gov       1.0%   100  230.1 235.2 225.3 280.1 11.2

中间某跳 100% 丢包但后面又正常：该路由器不响应 ICMP，正常现象
从某跳之后丢包率突然出现并持续到终点：这里就是瓶颈
延迟在某跳大幅跃升：跨国出口——比如从 5ms 跳到 200ms——说明到了国际网关

RTTend_to_end=∑i=1NRTThop_i+RTTocean_fiberRTT_{end\_to\_end} = \sum_{i=1}^{N} RTT_{hop\_i} + RTT_{ocean\_fiber}RTTend_to_end=∑i=1NRTThop_i+RTTocean_fiber

海洋光缆延迟约 1ms/200km（光速在光纤中约为真空的 2/3）。中美之间约 10000km，物理延迟最低约 70ms。如果 RTT > 300ms，问题不在物理而在路由/拥塞。

1.3 traceroute——备选方案#

Terminal window

1
# 传统traceroute（UDP，容易被墙）
2
traceroute ftp.ncbi.nlm.nih.gov
3

4
# TCP模式（更不容易被拦截，因为像正常连接）
5
traceroute -T -p 443 ftp.ncbi.nlm.nih.gov

2. 带宽测试——iperf3测真实吞吐#

2.1 内网测速#

Terminal window

1
sudo apt install iperf3 -y
2

3
# 服务端（在你要测的目标机器上）
4
iperf3 -s
5

6
# 客户端（在你的机器上）
7
iperf3 -c 192.168.1.100
8

9
# 多线程并行（模拟多连接下载）
10
iperf3 -c 192.168.1.100 -P 8
11

12
# 反向测试（服务端发送，测下载速度）
13
iperf3 -c 192.168.1.100 -R

典型输出：

1
[ ID] Interval           Transfer     Bitrate         Retr
2
[  5]   0.00-10.00  sec  1.09 GBytes   938 Mbits/sec    0     sender
3
[  5]   0.00-10.00  sec  1.09 GBytes   935 Mbits/sec          receiver

Bitrate 接近千兆（940Mbps）= 内网没问题。如果内网只有 100Mbps，检查网线/交换机端口。

2.2 到外网的带宽测试#

Terminal window

1
# 用curl直接下载测试文件
2
curl -o /dev/null -w "%{speed_download}\n" \
3
    https://ftp.ncbi.nlm.nih.gov/genomes/Homo_sapiens/README
4

5
# speed_download 单位是 bytes/s，除以 1048576 得 MB/s
6

7
# 更详细的curl测速
8
curl -o /dev/null -s -w \
9
    "time_namelookup: %{time_namelookup}\n\
10
time_connect: %{time_connect}\n\
11
time_starttransfer: %{time_starttransfer}\n\
12
time_total: %{time_total}\n\
13
speed_download: %{speed_download}\n" \
14
    https://ftp.ncbi.nlm.nih.gov/genomes/Homo_sapiens/README

各时间指标的含义：

指标	含义	正常值	异常信号
`time_namelookup`	DNS解析时间	<50ms	>1s = DNS服务器慢
`time_connect`	TCP握手时间（含DNS）	<200ms	>2s = 连不上/墙了
`time_starttransfer`	首字节时间（TTFB）	<1s	>5s = 服务器慢
`time_total`	总传输时间	—	—
`speed_download`	下载速度(bytes/s)	—	—

2.3 实际吞吐量公式#

throughputeffective=min⁡(bandwidthlink,BDPRTT,rateserver,ratelocal_disk)throughput_{effective} = \min(bandwidth_{link}, \frac{BDP}{RTT}, rate_{server}, rate_{local\_disk})throughputeffective=min(bandwidthlink,RTTBDP,rateserver,ratelocal_disk)

其中 BDP（带宽延迟积）:

BDP=bandwidth×RTTBDP = bandwidth \times RTTBDP=bandwidth×RTT

TCP 的拥塞控制窗口受 BDP 限制。中美之间 RTT=200ms，即使带宽是 1Gbps：

BDP=1Gbps×0.2s=200Mb=25MBBDP = 1Gbps \times 0.2s = 200Mb = 25MBBDP=1Gbps×0.2s=200Mb=25MB

单连接 TCP 最多能用 25MB 的窗口，实际吞吐受此限制。这就是为什么多线程下载（如 axel）能显著加速：

throughputmulti≈N×min⁡(BDPRTT,rateserver/N)throughput_{multi} \approx N \times \min(\frac{BDP}{RTT}, rate_{server}/N)throughputmulti≈N×min(RTTBDP,rateserver/N)

3. DNS诊断——被忽略的瓶颈#

DNS 慢会导致每个连接都多等几秒。SRA 下载时频繁建立新连接，DNS 慢会被放大。

Terminal window展开收起

1
# 当前DNS配置
2
cat /etc/resolv.conf
3

4
# 测DNS解析速度
5
dig ftp.ncbi.nlm.nih.gov | grep "Query time"
6
# Query time: 120 msec —— 正常
7
# Query time: 3000 msec —— 有问题
8

9
# 批量测多个DNS服务器
10
for dns in 8.8.8.8 1.1.1.1 114.114.114.114 223.5.5.5; do
11
    echo -n "${dns}: "
12
    dig @${dns} ftp.ncbi.nlm.nih.gov +short +time=3 2>/dev/null || echo "TIMEOUT"
13
done
14

15
# 查看DNS缓存（systemd-resolved）
16
resolvectl statistics
17

18
# 清理DNS缓存
19
sudo resolvectl flush-caches

展开收起

教育网用户常见问题：学校的 DNS 服务器解析国外域名特别慢，或者返回了错误的 IP（被劫持到缓存服务器）。解决：

Terminal window

1
# 在 /etc/systemd/resolved.conf 中指定上游DNS
2
[Resolve]
3
DNS=223.5.5.5 8.8.8.8
4
FallbackDNS=1.1.1.1

4. HTTP/FTPSRA下载实战#

4.1 用curl诊断下载问题#

Terminal window

1
# 1. 测试连接（不下载数据）
2
curl -I https://ftp.ncbi.nlm.nih.gov/
3

4
# 2. 显示详细连接过程
5
curl -v https://sra-download.ncbi.nlm.nih.gov/traces/sra00/SRR/001234/SRR12345678 2>&1 | head -50
6

7
# 3. 断点续传（-C -）
8
curl -C - -o SRR12345678.sra \
9
    https://sra-download.ncbi.nlm.nih.gov/traces/sra00/SRR/001234/SRR12345678
10

11
# 4. 限速下载（避免占满带宽影响别人）
12
curl --limit-rate 50M -o file.sra https://...

4.2 axel多线程下载#

Terminal window

1
sudo apt install axel -y
2

3
# 基础用法（-n 线程数）
4
axel -n 8 ftp://ftp.sra.ebi.ac.uk/vol1/srr/SRR123/SRR12345678
5

6
# 断点续传
7
axel -n 8 -a ftp://ftp.sra.ebi.ac.uk/vol1/srr/SRR123/SRR12345678
8
# -a: 简洁进度条
9

10
# 指定输出文件名
11
axel -n 16 -o SRR12345678.sra ftp://...

实测：从国内教育网下载 EBI 的 SRA，单线程 2MB/s，用 axel -n 8 后 15MB/s。提速约 7.5 倍。

4.3 速度优化检查清单#

下载速度慢时，逐个检查：

speed_diagnosis.sh展开收起

1
#!/bin/bash
2
TARGET="https://ftp.ncbi.nlm.nih.gov/genomes/Homo_sapiens/README"
3
echo "=== Speed Diagnosis ==="
4

5
# 1. DNS
6
echo "1. DNS response time:"
7
dig ftp.ncbi.nlm.nih.gov | grep "Query time"
8

9
# 2. Ping延迟
10
echo "2. Ping:"
11
ping -c 5 ftp.ncbi.nlm.nih.gov | grep "rtt"
12

13
# 3. 路由
14
echo "3. Route (last 3 hops):"
15
mtr -r -c 5 ftp.ncbi.nlm.nih.gov | tail -3
16

17
# 4. HTTP连接速度
18
echo "4. HTTP speed test:"
19
curl -o /dev/null -s -w \
20
    "   DNS: %{time_namelookup}s\n   Connect: %{time_connect}s\n   TTFB: %{time_starttransfer}s\n   Speed: %{speed_download} B/s\n" \
21
    "${TARGET}"
22

23
# 5. 磁盘写入速度
24
echo "5. Disk write speed:"
25
dd if=/dev/zero of=./test_write bs=1M count=1024 conv=fdatasync 2>&1 | \
26
    grep -o '[0-9.]* MB/s'
27
rm -f ./test_write

展开收起

按这个顺序跑一遍，大多数情况下能在 30 秒内定位到瓶颈所在。

5. 特殊场景：代理和SSH隧道#

5.1 为命令行工具设置代理#

Terminal window

1
# HTTP/HTTPS代理
2
export http_proxy="http://proxy.university.edu:8080"
3
export https_proxy="http://proxy.university.edu:8080"
4

5
# 对所有工具生效（wget, curl, prefetch, fasterq-dump...）
6
# prefetch 和 fasterq-dump 尊重 http_proxy 环境变量
7

8
# 不需要代理的本地地址
9
export no_proxy="localhost,127.0.0.1,.local,.edu.cn"
10

11
# 测试代理
12
curl -v --proxy "${https_proxy}" https://www.ncbi.nlm.nih.gov

5.2 SSH隧道端口转发#

场景：在不能直接访问外网的集群上，通过能上网的跳板机转发：

Terminal window

1
# 本地端口转发：把本地 8888 端口通过跳板机转到NCBI
2
ssh -L 8888:ftp.ncbi.nlm.nih.gov:443 user@jump_host
3

4
# 然后在本地用
5
curl --resolve ftp.ncbi.nlm.nih.gov:443:127.0.0.1 https://ftp.ncbi.nlm.nih.gov/
6

7
# 动态转发（SOCKS5代理）
8
ssh -D 1080 user@jump_host
9
# 然后设置：
10
export https_proxy="socks5://127.0.0.1:1080"

5.3 生信专用下载加速策略#

Terminal window展开收起

1
# 策略1：EBI镜像（欧洲，对国内教育网友好）
2
# EBI的FTP通常比NCBI的快
3
wget -c ftp://ftp.sra.ebi.ac.uk/vol1/srr/SRR123/SRR12345678
4

5
# 策略2：使用aspera（如果有）
6
ascp -i /path/to/asperaweb_id_dsa.openssh \
7
     -T -l 300M -k 1 \
8
     anonftp@ftp.ncbi.nlm.nih.gov:/sra/.../SRR12345678 .
9

10
# 策略3：预取 + 本地快速提取
11
prefetch SRR12345678 --max-size 50G
12
fasterq-dump SRR12345678 --threads 16
13

14
# 策略4：使用国内镜像（如果有高校提供）
15
# 中科院基因组所、华大等有时提供SRA镜像

展开收起

6. 踩坑记录#

坑1：ping得通但下载速度只有几十KB#

Ping 用的是 ICMP 协议，很多网络设备对 ICMP 不做限速，但对 TCP 大流量有限制。另外，到不同站点的路由可能完全不同——ping google.com 快不代表 NCBI 快。

Terminal window

1
# 用curl测试真实TCP吞吐
2
curl -o /dev/null https://ftp.ncbi.nlm.nih.gov/genomes/Homo_sapiens/README

坑2：MTU不匹配导致TCP连接失败#

症状：小文件（HTTP GET）没问题，大文件下载到某个大小就卡死。

原因：路径中有设备的 MTU 小于你的发包大小，且 ICMP Fragmentation Needed 消息被防火墙拦截了（PMTUD 黑洞）。

Terminal window

1
# 检查当前MTU
2
ip link show | grep mtu
3

4
# 手动降低MTU试试
5
sudo ip link set dev eth0 mtu 1400
6
# 恢复正常后再改回去：sudo ip link set dev eth0 mtu 1500

坑3：axel下载地址含特殊字符导致失败#

Terminal window

1
# URL中有 & ? = 时必须加引号
2
axel -n 8 "ftp://ftp.sra.ebi.ac.uk/vol1/srr/SRR123/SRR12345678?param=value"

坑4：iperf3测试速度正常但真实下载慢#

iperf3 测的是 TCP 性能（你的机器↔iperf 服务器），但真实下载还涉及：

远程服务器的带宽限制
中间路由器的拥塞策略
磁盘 I/O（下载的同时要写盘）

Terminal window

1
# 排查是不是磁盘瓶颈
2
# 下载到 /dev/null（纯内存/网络测试）
3
curl -o /dev/null https://...large_file...
4

5
# 如果/dev/null很快但写到磁盘慢 → 磁盘问题

坑5：`/etc/resolv.conf` 被覆盖#

症状：改完 DNS 重启后又变回去了。

Debian 上 resolv.conf 可能被 systemd-resolved 或 NetworkManager 管理：

Terminal window

1
# 正确姿势：修改 systemd-resolved 配置
2
sudoedit /etc/systemd/resolved.conf
3
# 添加：DNS=223.5.5.5 8.8.8.8
4
sudo systemctl restart systemd-resolved

坑6：curl下载一段时间后速度降到0#

症状：开始很快，几分钟后速度降到 0，然后又恢复。

可能是 TCP 拥塞控制算法的问题。BBR 对高延迟链路友好：

Terminal window

1
# 检查当前算法
2
sysctl net.ipv4.tcp_congestion_control
3

4
# 启用BBR（需要root）
5
echo "net.core.default_qdisc=fq" | sudo tee -a /etc/sysctl.conf
6
echo "net.ipv4.tcp_congestion_control=bbr" | sudo tee -a /etc/sysctl.conf
7
sudo sysctl -p
8

9
# 验证
10
sysctl net.ipv4.tcp_congestion_control
11
# 输出：net.ipv4.tcp_congestion_control = bbr

坑7：prefetch 尊重 http_proxy 但 fasterq-dump 不尊重#

sra-tools 的工具行为不一致：

Terminal window

1
# prefetch 走代理
2
export http_proxy="http://proxy:8080"
3
prefetch SRR12345678  # ✓ 走代理
4

5
# fasterq-dump 可能不走
6
# 解决办法：先 prefetch 下载 .sra 到本地，再 fasterq-dump 本地文件
7
fasterq-dump ./SRR12345678/SRR12345678.sra  # 纯本地操作

7. 总结#

排查步骤	命令	看什么
1. DNS	`dig ftp.ncbi.nlm.nih.gov`	Query time <100ms
2. 延迟	`ping -c 10`	丢包率0%，RTT<300ms
3. 路由	`mtr -r -c 50`	定位延迟跳跃点
4. 真实速度	`curl -o /dev/null -w "%{speed_download}"`	MB/s 能接受吗
5. 并发提速	`axel -n 8`	BDP限制→多线程突破
6. 本地磁盘	`dd` 或 `curl -o /path/to/disk`	排除磁盘瓶颈

网络问题排查最重要的原则：逐层排除。不要上来就说”网好慢”——先 ping 看延迟，再 curl 看吞吐，再 iperf3 看带宽，最后查 DNS 和路由。90% 的”网慢”最后发现是 DNS 太慢、磁盘写满了、或者单线程被 BDP 限制。

本文于 2026-01-18 在 Debian 13 上实测。ping iputils-s20240117, mtr 0.95, iperf3 3.16, curl 8.11.0, axel 2.17.14。

Markdown与Pandoc：文档写作与格式转换

Mon, 12 Jan 2026 00:00:00 GMT

Markdown 的核心优势：纯文本、可版本控制（Git 追踪变更）、写作和排版分离。Pandoc 作为通用文档转换器，可将 Markdown 转为 PDF、Word、HTML、LaTeX、slide 甚至 EPUB。本文覆盖实验记录模板、Pandoc 模板定制、文献引用、代码高亮和交叉引用，实现从实验记录到学术报告的统一工作流。

实测环境：Debian 13，Pandoc 3.6.2，LaTeX（TeX Live 2024）。

1. 环境搭建#

Terminal window

1
# 安装 Pandoc 和 LaTeX 引擎
2
sudo apt install pandoc texlive-xetex texlive-latex-extra \
3
    texlive-fonts-recommended texlive-lang-chinese -y
4

5
# 安装中文字体（如果系统没有）
6
sudo apt install fonts-noto-cjk -y
7

8
# 验证
9
pandoc --version
10
xelatex --version

2. 生信实验记录 Markdown 模板#

1
# 实验记录：RNA-seq 差异表达分析
2

3
**日期：** 2026-01-10
4
**实验者：** 张三
5
**项目：** BRCA 肿瘤 vs 癌旁
6
**样本数：** 48 (24 tumor + 24 normal)
7

8
## 目的
9

10
鉴定 BRCA 肿瘤组织与配对癌旁组织之间的差异表达基因，为后续 WGCNA 和通路分析提供候选基因列表。
11

12
## 方法和参数
13

14
### 比对
15
- 工具：STAR 2.7.11b
16
- 参考基因组：GRCh38 (Ensembl release 113)
17
- 参数：`--outFilterMultimapNmax 20 --alignSJoverhangMin 8`
18

19
### 定量
20
- 工具：featureCounts (subread 2.0.6)
21
- 注释文件：`Homo_sapiens.GRCh38.113.gtf`
22
- 参数：`-p -B -C -s 2`
23

24
### 差异表达
25
- 工具：DESeq2 (R 4.4.1, Bioconductor 3.19)
26
- 模型：`~ batch + condition`
27
- 显著性阈值：|log2FC| > 1, padj < 0.05
28

29
## 结果摘要
30

31
| 比较 | 上调 | 下调 | 总计 |
32
|------|------|------|------|
33
| Tumor vs Normal | 1,247 | 893 | 2,140 |
34

35
## 问题和备注
36

37
1. 样本 BRCA_T_07 的 RIN 值偏低 (5.2)，后续关注其是否偏离主成分。
38
2. batch2 的测序深度显著高于 batch1，已在 DESeq2 模型中加入 batch 协变量。
39

40
## 下一步
41

42
- [ ] GSEA 通路富集分析
43
- [ ] 与 TCGA-BRCA 公开数据比对验证

展开收起

这种纯文本格式的优势：可以用 Git 追踪每次修改、用 grep 搜索任何关键词、任何文本编辑器都能打开。

3. Pandoc 转换——核心命令#

3.1 基础转换#

Terminal window

1
# Markdown → HTML
2
pandoc report.md -o report.html --standalone
3

4
# Markdown → DOCX（Word）
5
pandoc report.md -o report.docx
6

7
# Markdown → PDF（通过 LaTeX）
8
pandoc report.md -o report.pdf --pdf-engine=xelatex
9

10
# Markdown → LaTeX（只生成 .tex，不编译）
11
pandoc report.md -o report.tex
12

13
# Markdown → 幻灯片（reveal.js）
14
pandoc slides.md -t revealjs -s -o slides.html

3.2 带中文字体的 PDF#

Terminal window

1
# 中文字体是 Pandoc 生成 PDF 最常见的坑
2
pandoc report.md -o report.pdf \
3
    --pdf-engine=xelatex \
4
    -V mainfont="Noto Serif CJK SC" \
5
    -V sansfont="Noto Sans CJK SC" \
6
    -V monofont="Noto Sans Mono CJK SC" \
7
    -V CJKmainfont="Noto Serif CJK SC"
8

9
# 或者用模板指定字体（推荐，见下文）

3.3 代码块高亮#

1
```bash
2
# 比对命令
3
STAR --genomeDir /opt/refs/GRCh38/star_index \
4
     --readFilesIn sample_R1.fastq.gz sample_R2.fastq.gz \
5
     --readFilesCommand zcat \
6
     --outSAMtype BAM SortedByCoordinate \
7
     --runThreadN 16 \
8
     --outFileNamePrefix ./aligned/sample_
9
```

Pandoc 支持多种语法高亮风格：

Terminal window

1
# 查看可用高亮风格
2
pandoc --list-highlight-styles
3

4
# 指定风格
5
pandoc report.md -o report.pdf --highlight-style=tango

3.4 数学公式——LaTeX 原生支持#

在 Markdown 里写 LaTeX 公式，Pandoc 直接渲染：

1
差异表达分析中，DESeq2 使用负二项分布建模：
2

3
$$K_{ij} \sim \text{NB}(\mu_{ij}, \alpha_i)$$
4

5
其中 $K_{ij}$ 是基因 $i$ 在样本 $j$ 中的计数，$\mu_{ij}$ 是期望值，
6
$\alpha_i$ 是离散度参数。fold change 的收缩估计为：
7

8
$$\beta_i^{\text{MAP}} = \arg\max_{\beta} \left[ \log L(\beta | K_i) + \log p(\beta) \right]$$

渲染结果和 LaTeX 原生一致，写分析报告时可以直接嵌入统计模型的公式。

4. 文献引用——生信报告必备#

4.1 使用 BibTeX 引用#

1
# 在 Markdown 里引用文献
2

3
差异表达分析使用 DESeq2 [@love2014] 进行，
4
多重检验校正采用 Benjamini-Hochberg 方法 [@benjamini1995]。
5

6
# 参考文献

准备一个 refs.bib 文件：

1
@article{love2014,
2
  title={Moderated estimation of fold change and dispersion for RNA-seq data with DESeq2},
3
  author={Love, Michael I and Huber, Wolfgang and Anders, Simon},
4
  journal={Genome biology},
5
  volume={15},
6
  number={12},
7
  pages={1--21},
8
  year={2014},
9
  publisher={Springer}
10
}
11

12
@article{benjamini1995,
13
  title={Controlling the false discovery rate: a practical and powerful approach to multiple testing},
14
  author={Benjamini, Yoav and Hochberg, Yosef},
15
  journal={Journal of the Royal statistical society: series B},
16
  volume={57},
17
  number={1},
18
  pages={289--300},
19
  year={1995}
20
}

展开收起

编译命令：

Terminal window

1
pandoc report.md -o report.pdf \
2
    --pdf-engine=xelatex \
3
    --citeproc \
4
    --bibliography=refs.bib \
5
    -V mainfont="Noto Serif CJK SC"
6
# --citeproc 启用文献处理

4.2 图片交叉引用#

Terminal window

1
# 需要 pandoc-crossref 过滤器
2
sudo apt install pandoc-crossref -y

1
![PCA 图展示样本聚类情况](figures/pca_plot.png){#fig:pca width=80%}
2

3
如 {@fig:pca} 所示，肿瘤和正常样本在第一主成分（PC1，解释 42% 方差）上清晰分离。

编译时加 --filter pandoc-crossref：

Terminal window

1
pandoc report.md -o report.pdf --pdf-engine=xelatex --filter pandoc-crossref

5. 定制 Pandoc 模板#

5.1 创建生信报告模板#

Terminal window

1
# 查看默认 LaTeX 模板
2
pandoc -D latex > bioinfo-template.tex

在默认模板基础上修改——加实验室 Logo、页眉页脚、自定义标题页。然后用：

Terminal window

1
pandoc report.md -o report.pdf \
2
    --pdf-engine=xelatex \
3
    --template=bioinfo-template.tex \
4
    -V mainfont="Noto Serif CJK SC"

5.2 YAML 元数据——文档信息集中管理#

在 Markdown 文件头部写 YAML 元数据，Pandoc 会自动提取：

1
---
2
title: "BRCA RNA-seq 差异表达分析报告"
3
author: "张三"
4
date: "2026-01-12"
5
institute: "XX 大学生物信息学实验室"
6
abstract: "本研究对 24 对 BRCA 肿瘤-癌旁组织进行 RNA-seq 分析，
7
识别出 2,140 个差异表达基因（|log2FC| > 1, padj < 0.05）。"
8
keywords: [BRCA, RNA-seq, 差异表达, DESeq2]
9
toc: true
10
toc-depth: 2
11
numbersections: true
12
---

编译后自动生成标题页、目录、章节编号。

6. 批量处理——分析报告自动化#

生信流程跑完后自动生成报告：

1
#!/bin/bash
2
# auto_report.sh —— 分析跑完后自动生成 PDF 报告
3

4
set -euo pipefail
5

6
PROJECT_DIR="$1"
7
REPORT_TEMPLATE="${PROJECT_DIR}/docs/report_template.md"
8
REPORT_OUT="${PROJECT_DIR}/results/analysis_report.pdf"
9
REF_BIB="${PROJECT_DIR}/docs/refs.bib"
10
FIG_DIR="${PROJECT_DIR}/results/figures"
11

12
# 1. 自动更新报告中的统计数字
13
sed -i "s/{{TOTAL_DEGS}}/$(cat ${PROJECT_DIR}/results/degs_count.txt)/g" \
14
    "${REPORT_TEMPLATE}"
15

16
# 2. 生成 PDF
17
pandoc "${REPORT_TEMPLATE}" \
18
    -o "${REPORT_OUT}" \
19
    --pdf-engine=xelatex \
20
    --citeproc \
21
    --bibliography="${REF_BIB}" \
22
    --filter pandoc-crossref \
23
    --resource-path="${FIG_DIR}" \
24
    -V mainfont="Noto Serif CJK SC" \
25
    --toc \
26
    --number-sections
27

28
echo "Report generated: ${REPORT_OUT}"

展开收起

7. 踩坑记录#

坑1：中文 PDF 编译报错 “Missing character”。 默认 pdflatex 引擎不支持中文，必须用 --pdf-engine=xelatex 或 lualatex。同时确认系统中安装了中文字体包（fonts-noto-cjk 或 fonts-wqy-microhei）。

坑2：生信代码块的波浪线和反引号。 bash 代码里经常有 ${VAR} 这样的语法，在 Markdown 里写反引号代码块时注意用四个反引号（````）包裹含三个反引号的代码。或者干脆所有代码块都用四个反引号，免得出问题。

坑3：Pandoc 表格不支持合并单元格。 Markdown 表格本身是简化版的，不支持 rowspan/colspan。如果需要复杂表格，直接用 LaTeX 的 tabular 环境嵌在 Markdown 里，Pandoc 会透传。

坑4：DOCX 输出的样式丑得没法看。 Pandoc 默认 DOCX 样式非常基础。用 --reference-doc 指定一个样式模板：先 pandoc -o template.docx --print-default-data-file reference.docx，在 Word 里修改样式后，再 pandoc report.md -o report.docx --reference-doc=template.docx。

坑5：文献引用不生效。 检查三个点：① BibTeX 文件编码是 UTF-8，② 引用 key 拼写一致（大小写敏感），③ --citeproc 参数是否加了。另外确认 pandoc-citeproc 已正确安装。

坑6：--resource-path 设错导致图片找不到。 如果 Markdown 里写 ![fig](figures/pca.png)，且 --resource-path=results，那 Pandoc 会找 results/figures/pca.png。路径拼接逻辑有时不直观，建议用绝对路径或相对于 Markdown 文件的位置。

本文于 2026-01-12 在 Debian 13 上实测。

ENSEMBL BioMart批量数据导出：REST API与biomaRt

Fri, 05 Dec 2025 00:00:00 GMT

ENSEMBL BioMart 提供基因功能注释的批量导出功能。除网页界面外，BioMart 还提供 REST API 和 R/Bioconductor 接口（biomaRt），可自动化批量获取 GO/KEGG/InterPro/PFAM 注释和跨物种同源基因信息。本文覆盖 Python（REST API）和 R（biomaRt）两种实现方式。

实测环境：Debian 13，Python 3.10 + requests，R 4.4 + biomaRt 2.60。

1. BioMart 是什么#

ENSEMBL BioMart 是 ENSEMBL 基因组数据库的查询接口。你可以把它想象成”基因组数据库的 SQL”，但不用写 SQL——选数据集（database）、选过滤器（filter）、选输出属性（attribute），它返回你想要的表。

BioMart 的数据结构是层次化的：

1
ENSEMBL Genes (mart)
2
├── 物种1 (dataset, 如 hsapiens_gene_ensembl)
3
│   ├── 基因属性 (attributes: gene_id, gene_name, description...)
4
│   └── 过滤器 (filters: chromosome, gene_name, biotype...)
5
├── 物种2
6
└── ...

一个具体的查询案例： “人类（hsapiens）中，染色体 1 上所有蛋白质编码基因（protein_coding），输出基因 ID、基因名、GO 注释。”

这在 BioMart 里对应的参数：

参数	值
mart	ENSEMBL_MART_ENSEMBL
dataset	hsapiens_gene_ensembl
filters	chromosome_name=1, biotype=protein_coding
attributes	ensembl_gene_id, external_gene_name, go_id

2. Python 方案——REST API#

BioMart 提供 RESTful API，返回 JSON/XML/TSV。Python 用 requests 库就能调。

2.1 查询基因基础信息#

1
#!/usr/bin/env python3
2
"""
3
fetch_gene_info.py - 通过 BioMart REST API 获取基因基础注释
4
Debian 13 实测 2025-12-05
5
"""
6

7
import requests
8
import json
9
import time
10

11
BASE_URL = "https://rest.ensembl.org"
12

13
def query_biomart(dataset, filters, attributes):
14
    """
15
    通用 BioMart 查询函数
16

17
    参数:
18
        dataset: 数据集名，如 "hsapiens_gene_ensembl"
19
        filters: 字典，过滤条件 {"filter_name": "value"}
20
        attributes: 列表，输出属性 ["attr1", "attr2"]
21

22
    返回:
23
        list of dict，查询结果
24
    """
25
    url = f"{BASE_URL}/biomart/martservice/results"
26

27
    # 构造 XML payload（BioMart 的 REST API 用 XML 描述查询）
28
    filter_xml = "".join(
29
        f'<Filter name="{k}" value="{v}"/>'
30
        for k, v in filters.items()
31
    )
32
    attr_xml = "".join(
33
        f'<Attribute name="{a}"/>'
34
        for a in attributes
35
    )
36

37
    payload = f"""<?xml version="1.0" encoding="UTF-8"?>
38
<!DOCTYPE Query>
39
<Query virtualSchemaName="default" formatter="TSV"
40
       header="1" uniqueRows="1"
41
       datasetConfigVersion="0.6">
42
    <Dataset name="{dataset}" interface="default">
43
        {filter_xml}
44
        {attr_xml}
45
    </Dataset>
46
</Query>"""
47

48
    headers = {"Content-Type": "application/x-www-form-urlencoded"}
49

50
    resp = requests.post(
51
        url,
52
        data={"query": payload},
53
        headers=headers,
54
        timeout=120
55
    )
56

57
    if resp.status_code != 200:
58
        raise Exception(f"API error {resp.status_code}: {resp.text}")
59

60
    # TSV → 字典列表
61
    lines = resp.text.strip().split("\n")
62
    if len(lines) < 2:
63
        return []
64

65
    header = lines[0].split("\t")
66
    results = []
67
    for line in lines[1:]:
68
        values = line.split("\t")
69
        results.append(dict(zip(header, values)))
70

71
    return results
72

73

74
# ===== 示例1：获取TP53及其靶基因的基础信息 =====
75
gene_list = ["TP53", "MDM2", "CDKN1A", "BAX", "BCL2", "GADD45A"]
76

77
filters = {"hgnc_symbol": ",".join(gene_list)}
78
attributes = [
79
    "ensembl_gene_id",
80
    "external_gene_name",
81
    "chromosome_name",
82
    "start_position",
83
    "end_position",
84
    "strand",
85
    "gene_biotype",
86
    "description"
87
]
88

89
print("=== 查询基因基础信息 ===")
90
results = query_biomart("hsapiens_gene_ensembl", filters, attributes)
91

92
for row in results:
93
    gene = row.get("Gene name", "N/A")
94
    chrom = row.get("Chromosome/scaffold name", "N/A")
95
    start = row.get("Gene start (bp)", "N/A")
96
    biotype = row.get("Gene type", "N/A")
97
    desc = row.get("Gene description", "N/A")
98

99
    # 计算基因长度
100
    if start != "N/A" and row.get("Gene end (bp)", "N/A") != "N/A":
101
        length = int(row["Gene end (bp)"]) - int(start) + 1
102
        length_str = f"{length:,}bp"
103
    else:
104
        length_str = "N/A"
105

106
    print(f"  {gene}: {chrom}:{start}, {biotype}, {length_str}")
107
    print(f"    {desc[:80]}...")
108

109
time.sleep(0.5)  # 礼貌性延迟，别打爆 API

展开收起

2.2 批量获取 GO 注释#

1
# ===== 示例2：获取基因的GO注释 =====
2

3
filters = {"hgnc_symbol": ",".join(gene_list)}
4
attributes = [
5
    "ensembl_gene_id",
6
    "external_gene_name",
7
    "go_id",
8
    "name_1006",       # GO term 名称
9
    "namespace_1003",  # GO 类别（biological_process/等）
10
    "go_linkage_type"  # IEA/IDA/IMP...（证据类型）
11
]
12

13
print("\n=== 查询 GO 注释 ===")
14
results = query_biomart("hsapiens_gene_ensembl", filters, attributes)
15

16
# 按基因分组整理
17
from collections import defaultdict
18
go_by_gene = defaultdict(list)
19

20
for row in results:
21
    gene = row.get("Gene name", "N/A")
22
    go_id = row.get("GO term accession", "")
23
    go_name = row.get("GO term name", "")
24
    go_ns = row.get("GO domain", "")
25
    evidence = row.get("GO term evidence code", "")
26

27
    if go_id:
28
        go_by_gene[gene].append({
29
            "id": go_id,
30
            "name": go_name,
31
            "namespace": go_ns,
32
            "evidence": evidence
33
        })
34

35
for gene, go_terms in go_by_gene.items():
36
    print(f"\n  {gene} ({len(go_terms)} GO terms):")
37
    # 按 namespace 分组
38
    by_ns = defaultdict(list)
39
    for t in go_terms:
40
        by_ns[t["namespace"]].append(t)
41

42
    for ns, terms in sorted(by_ns.items()):
43
        print(f"    [{ns}]:")
44
        for t in terms[:3]:  # 每类只显示3个
45
            print(f"      {t['id']} {t['name']} ({t['evidence']})")

展开收起

2.3 获取跨物种同源基因#

1
# ===== 示例3：人类→小鼠同源基因 =====
2

3
filters = {"hgnc_symbol": ",".join(gene_list)}
4
attributes = [
5
    "ensembl_gene_id",
6
    "external_gene_name",
7
    "mmusculus_homolog_ensembl_gene",
8
    "mmusculus_homolog_associated_gene_name",
9
    "mmusculus_homolog_orthology_type",
10
    "mmusculus_homolog_perc_id_r1"
11
]
12

13
print("\n=== 查询人类→小鼠同源基因 ===")
14
results = query_biomart("hsapiens_gene_ensembl", filters, attributes)
15

16
for row in results:
17
    hgnc = row.get("Gene name", "N/A")
18
    mouse_id = row.get("Mouse gene stable ID", "N/A")
19
    mouse_name = row.get("Mouse gene name", "N/A")
20
    ortho_type = row.get("Mouse orthology type", "N/A")
21
    identity = row.get("Mouse %id. query gene identical to target gene", "N/A")
22

23
    if mouse_id:
24
        print(f"  {hgnc} → {mouse_name} ({ortho_type}, {identity}% identity)")

展开收起

关于 API 响应的理解：

BioMart REST API 返回 TSV 时，列名是 BioMart 的内部名称，不是人类友好的名字。比如 "Gene name" 对应你请求的 external_gene_name，"GO term accession" 对应 go_id。建议在脚本里用 row.get("Gene name", "N/A") 而不是 row["external_gene_name"]——因为 ENSEMBL 的列名映射偶尔会变。

3. R 方案——biomaRt#

Python REST API 灵活但冗长。如果你已经在用 R 做分析，biomaRt 包 的接口更简洁——因为它帮你处理了 XML 构造和列名映射。

3.1 基础查询#

1
#!/usr/bin/env Rscript
2
# fetch_genes.R - 用 biomaRt 批量获取基因注释
3
# Debian 13 实测 2025-12-05
4

5
library(biomaRt)
6

7
# ===== 1. 连接 BioMart =====
8
# 列出可用的 mart
9
listEnsembl()
10

11
# 选择 ENSEMBL Genes mart
12
ensembl <- useEnsembl(
13
    biomart = "genes",
14
    dataset = "hsapiens_gene_ensembl"
15
)
16

17
# 确认连接成功
18
ensembl
19
# Object of class 'Mart':
20
#   Using the ENSEMBL Genes dataset
21
#   Using the hsapiens_gene_ensembl dataset

展开收起

3.2 获取基因注释#

1
# ===== 2. 按基因名查询基础信息 =====
2
gene_list <- c("TP53", "MDM2", "CDKN1A", "BAX", "BCL2", "GADD45A")
3

4
# 查看可用属性
5
attrs <- listAttributes(ensembl)
6
head(attrs[, c("name", "description")], 10)
7

8
# 执行查询
9
gene_info <- getBM(
10
    attributes = c(
11
        "ensembl_gene_id",
12
        "external_gene_name",
13
        "chromosome_name",
14
        "start_position",
15
        "end_position",
16
        "strand",
17
        "gene_biotype",
18
        "description"
19
    ),
20
    filters = "hgnc_symbol",
21
    values = gene_list,
22
    mart = ensembl
23
)
24

25
# 计算基因长度
26
gene_info$gene_length_bp <- gene_info$end_position - gene_info$start_position + 1
27

28
print(gene_info[, c("external_gene_name", "chromosome_name",
29
                     "gene_biotype", "gene_length_bp")])
30

31
#   external_gene_name chromosome_name   gene_biotype gene_length_bp
32
# 1             CDKN1A               6 protein_coding          50481
33
# 2                BAX              19 protein_coding           7096
34
# 3               BCL2              18 protein_coding         198810
35
# 4             GADD45A               1 protein_coding           3017
36
# 5               MDM2              12 protein_coding          36675
37
# 6               TP53              17 protein_coding          26383

展开收起

3.3 批量 GO 注释#

1
# ===== 3. 批量获取 GO 注释 =====
2
go_terms <- getBM(
3
    attributes = c(
4
        "ensembl_gene_id",
5
        "external_gene_name",
6
        "go_id",
7
        "name_1006",       # GO term 名称
8
        "namespace_1003",  # GO 类别
9
        "go_linkage_type"  # 证据代码
10
    ),
11
    filters = "hgnc_symbol",
12
    values = gene_list,
13
    mart = ensembl
14
)
15

16
head(go_terms, 10)
17

18
# 统计每个基因的 GO 数量和证据类型分布
19
library(dplyr)
20

21
go_summary <- go_terms %>%
22
    group_by(external_gene_name, namespace_1003) %>%
23
    summarise(
24
        n_terms = n(),
25
        experimental = sum(go_linkage_type %in% c("IDA", "IMP", "IGI", "IPI")),
26
        computational = sum(go_linkage_type %in% c("IEA", "ISS")),
27
        .groups = "drop"
28
    )
29

30
print(go_summary)

展开收起

3.4 获取序列#

biomaRt 也可以直接拉基因序列：

1
# ===== 4. 获取基因序列 =====
2
# 查看可用的序列类型
3
listFilters(ensembl)[grep("seq", listFilters(ensembl)$name), ]
4

5
# 获取 cDNA 序列
6
cdna_seqs <- getSequence(
7
    id = gene_info$ensembl_gene_id,
8
    type = "ensembl_gene_id",
9
    seqType = "cdna",
10
    mart = ensembl
11
)
12

13
# 写入 FASTA
14
write.fasta <- function(ids, seqs, file) {
15
    con <- file(file, "w")
16
    for (i in seq_along(ids)) {
17
        writeLines(paste0(">", ids[i]), con)
18
        writeLines(seqs[i], con)
19
    }
20
    close(con)
21
}
22

23
# 只在有序列数据时才写入
24
if (nrow(cdna_seqs) > 0) {
25
    write.fasta(cdna_seqs$ensembl_gene_id, cdna_seqs$cdna,
26
                "gene_cdna.fasta")
27
    cat(sprintf("Wrote %d cDNA sequences to gene_cdna.fasta\n",
28
                nrow(cdna_seqs)))
29
}
30

31
# 获取蛋白序列
32
protein_seqs <- getSequence(
33
    id = gene_info$ensembl_gene_id,
34
    type = "ensembl_gene_id",
35
    seqType = "peptide",
36
    mart = ensembl
37
)

展开收起

3.5 跨物种同源基因（人类→小鼠）#

1
# ===== 5. 人类→小鼠同源基因 =====
2
mouse_homologs <- getBM(
3
    attributes = c(
4
        "ensembl_gene_id",
5
        "external_gene_name",
6

7
        # 小鼠同源基因属性
8
        "mmusculus_homolog_ensembl_gene",
9
        "mmusculus_homolog_associated_gene_name",
10
        "mmusculus_homolog_orthology_type",
11
        "mmusculus_homolog_perc_id_r1",
12
        "mmusculus_homolog_perc_id",
13

14
        # 同源关系类型
15
        "mmusculus_homolog_orthology_confidence"
16
    ),
17
    filters = "hgnc_symbol",
18
    values = gene_list,
19
    mart = ensembl
20
)
21

22
print(mouse_homologs)

展开收起

3.6 批量处理——上千个基因的 ID 转换#

这是生信里最常用的场景之一：有一列 Ensembl ID，要转成 Gene Symbol：

1
# ===== 6. ID 批量转换 =====
2
# 模拟一批 Ensembl ID
3
ensembl_ids <- c(
4
    "ENSG00000141510",  # TP53
5
    "ENSG00000135679",  # MDM2
6
    "ENSG00000124762",  # CDKN1A
7
    "ENSG00000087088",  # BAX
8
    "ENSG00000171791",  # BCL2
9
    "ENSG00000116717"   # GADD45A
10
)
11

12
id_map <- getBM(
13
    attributes = c(
14
        "ensembl_gene_id",
15
        "external_gene_name",
16
        "entrezgene_id",
17
        "uniprotswissprot",
18
        "hgnc_id"
19
    ),
20
    filters = "ensembl_gene_id",
21
    values = ensembl_ids,
22
    mart = ensembl
23
)
24

25
print(id_map)
26

27
#    ensembl_gene_id external_gene_name entrezgene_id uniprotswissprot hgnc_id
28
# 1 ENSG00000087088                BAX           581           Q07812   990
29
# 2 ENSG00000116717           GADD45A          1647           P24522  4095
30
# 3 ENSG00000124762            CDKN1A          1026           P38936  1784
31
# 4 ENSG00000135679              MDM2          4193               NA  6973
32
# 5 ENSG00000141510              TP53          7157           P04637 11998
33
# 6 ENSG00000171791              BCL2           596           P10415   990

展开收起

4. BioMart 查询的高阶用法#

4.1 根据 GO Term 反查基因#

“哪些基因有 GO:0006915（凋亡过程）注释？”

1
genes_with_go <- getBM(
2
    attributes = c(
3
        "ensembl_gene_id",
4
        "external_gene_name",
5
        "go_id",
6
        "name_1006"
7
    ),
8
    filters = "go",
9
    values = "GO:0006915",
10
    mart = ensembl
11
)
12

13
cat(sprintf("Found %d genes with GO:0006915\n", nrow(genes_with_go)))
14
head(genes_with_go)

注意： GO 过滤器会匹配该 GO term 及其所有子 term。所以查询 GO:0006915 实际返回的范围可能比你预想的大很多。GO 的层级结构导致实际基因数 = 直接注释数 + 所有子 term 的注释数：

Ntotal=∑t∈{query_term∪descendants}Nannotations(t)N_{total} = \sum_{t \in \{query\_term \cup descendants\}} N_{annotations}(t)Ntotal=∑t∈{query_term∪descendants}Nannotations(t)

4.2 基因组区间查询#

“chr1:1000000-2000000 区间内有哪些蛋白编码基因？“

1
genes_in_region <- getBM(
2
    attributes = c(
3
        "ensembl_gene_id",
4
        "external_gene_name",
5
        "chromosome_name",
6
        "start_position",
7
        "end_position",
8
        "gene_biotype"
9
    ),
10
    filters = c("chromosome_name", "start", "end"),
11
    values = list(
12
        chromosome_name = "1",
13
        start = "1000000",
14
        end = "2000000"
15
    ),
16
    mart = ensembl
17
)
18

19
cat(sprintf("Found %d genes in chr1:1000000-2000000\n", nrow(genes_in_region)))

展开收起

4.3 按 biotype 过滤——只拉 lncRNA#

1
lncrna_genes <- getBM(
2
    attributes = c("ensembl_gene_id", "external_gene_name", "gene_biotype"),
3
    filters = "biotype",
4
    values = "lncRNA",
5
    mart = ensembl
6
)
7

8
cat(sprintf("Total lncRNA genes: %d\n", nrow(lncrna_genes)))

5. 踩坑记录#

坑1：ENSEMBL 版本——GRCh37 vs GRCh38#

症状：用 GRCh38 坐标查询基因，结果为空或偏移。

原因：ENSEMBL 默认数据集使用最新版基因组（GRCh38）。如果你的 BED 文件是 GRCh37（hg19），坐标完全不匹配。

解决： 使用 useEnsembl() 的 version 参数指定旧版：

1
# GRCh37 对应 ENSEMBL 75
2
ensembl_grch37 <- useEnsembl(
3
    biomart = "genes",
4
    dataset = "hsapiens_gene_ensembl",
5
    version = 75  # GRCh37
6
)
7

8
# GRCh38 对应 ENSEMBL 最新版（不指定version）
9
ensembl_grch38 <- useEnsembl(
10
    biomart = "genes",
11
    dataset = "hsapiens_gene_ensembl"
12
)

坑2：REST API 返回 429 Too Many Requests#

BioMart REST API 没有官方文档写速率限制，但实测连续快发 > 15 个请求后会触发 429。

解决：

1
import time
2

3
# 每次请求后至少等0.5秒
4
time.sleep(0.5)
5

6
# 或者用重试逻辑
7
import time
8
max_retries = 3
9
for attempt in range(max_retries):
10
    resp = requests.post(url, ...)
11
    if resp.status_code == 429:
12
        wait = 2 ** attempt  # 指数退避
13
        print(f"Rate limited, waiting {wait}s...")
14
        time.sleep(wait)
15
    elif resp.status_code == 200:
16
        break

展开收起

坑3：某些基因查不到注释#

getBM 返回空行或基因数量少于输入——新手常以为是 bug，实际是正常行为。

原因：

该基因在当前 ENSEMBL 版本中已废弃（retired）
该 filter 条件下该基因没有对应属性（比如查 lncRNA 的蛋白序列）
Ensembl ID 版本号不对（ENSG00000141510 vs ENSG00000141510.16）

排查：

1
# 检查哪些输入基因没命中
2
input_genes <- c("TP53", "NONEXISTENT", "MDM2")
3
results <- getBM(
4
    attributes = c("hgnc_symbol"),
5
    filters = "hgnc_symbol",
6
    values = input_genes,
7
    mart = ensembl
8
)
9
found <- unique(results$hgnc_symbol)
10
missing <- setdiff(input_genes, found)
11
if (length(missing) > 0) {
12
    cat("Missing genes:", paste(missing, collapse = ", "), "\n")
13
}

坑4：BioMart 连接超时——国内网络#

ENSEMBL 的 API 服务器在欧洲，国内直连偶发超时。症状：useEnsembl() 或 requests.post() 报 connection timeout。

解决：

1
# biomaRt 设置镜像
2
ensembl <- useEnsembl(
3
    biomart = "genes",
4
    dataset = "hsapiens_gene_ensembl",
5
    mirror = "uswest"    # 或 "asia", "useast"
6
)

Python 的话直接修改 rest.ensembl.org 为 useast.ensembl.org 或 asia.ensembl.org：

1
BASE_URL = "https://useast.ensembl.org"  # 美国东部镜像

坑5：biomaRt 的 `getSequence` 对大型查询极慢#

症状：1000 个基因的序列查询跑了 10 分钟还没出结果。

原因： getSequence 是逐个基因发请求，不是批量查询。1000 个基因 = 1000 次 HTTP 请求。

解决：

分批查询，每批 50 个：

1
batch_size <- 50
2
results_list <- list()
3
for (i in seq(1, length(gene_list), batch_size)) {
4
    batch <- gene_list[i:min(i+batch_size-1, length(gene_list))]
5
    results_list[[length(results_list)+1]] <- getSequence(
6
        id = batch, type = "hgnc_symbol",
7
        seqType = "cdna", mart = ensembl
8
    )
9
}
10
all_sequences <- do.call(rbind, results_list)

或者直接用 ENSEMBL FTP 下载整个物种的 cDNA 文件（更快）。

坑6：`getBM` 返回重复行#

症状：输入 6 个基因，返回 60 行，每个基因出现 10 次。

原因： 你请求的属性中包含”一对多”关系的字段。比如一个基因有 10 个 GO term，结果就有 10 行。

这不是 bug，是关系型数据的正常表现。但如果你期望一行一个基因，先检查哪些属性是”一对多”的：

1
# 查看属性描述中的"multi-valued"标记
2
listAttributes(ensembl)[grep("GO", listAttributes(ensembl)$name),
3
                         c("name", "description")]

坑7：Python REST API 的 XML 格式严格#

症状：请求返回 400 Bad Request，但 XML 看起来没问题。

常见 XML 错误：

& 没有转义成 &（基因名里的 & 极少但不排除）
过滤器值为空字符串
<Attribute> 拼错属性名

排查方法：

1
# 保存 XML 到文件人工检查
2
with open("debug_query.xml", "w") as f:
3
    f.write(payload)
4

5
# 用 ENSEMBL 的 XML 验证工具
6
# 浏览器打开 https://www.ensembl.org/biomart/martview
7
# 点 "XML" 按钮粘贴你的 payload 验证

6. 总结#

任务	R (biomaRt)	Python (REST API)
基因注释查询	`getBM()` 一行搞定	需构造 XML，30行
GO/KEGG 注释	`getBM()` + 批量化	XML filter 更灵活
序列获取	`getSequence()` 慢但简单	REST API 或 FTP
ID 转换	`getBM()` 最方便	XML payload 较长
大规模查询	分批循环	可多线程并行
国内网络	`mirror="asia"`	换 useast 镜像

选 Python 还是 R： 如果你的下游分析是 R（DEseq2、ggplot2），用 biomaRt 最省事。如果你在写生产级 Pipeline（Python/Snakemake），REST API 更可控。

本文于 2025-12-05 在 Debian 13 上实测完成。biomaRt 2.60.1，Python 3.10 + requests 2.31，ENSEMBL release 113。所有代码可复制运行。

文件编码与换行符：UTF-8/CRLF/BOM诊断与转换

Wed, 03 Dec 2025 00:00:00 GMT

生信数据和脚本经常在 Windows/Mac/Linux 之间流转、从外网数据库下载、从合作者处接收——编码和换行符问题防不胜防。典型场景：Windows 编辑的样本列表上传到 Linux 服务器，报 Error: sample name not found: "Sample_1\r"——那个 \r 是 CRLF 里的回车符。本文梳理常见编码与换行符问题的诊断和解决方案。

实测环境：Debian 13，所有工具系统自带或 apt 安装。

1. 换行符——CRLF vs LF vs CR#

1.1 三种换行符#

系统	换行符	转义符	ASCII码
Windows (DOS)	CR+LF	`\r\n`	0x0D 0x0A
Linux / macOS (新)	LF	`\n`	0x0A
macOS (旧版, OS 9及以前)	CR	`\r`	0x0D

当前主流的冲突只发生在 Windows (CRLF) 和 Linux (LF) 之间。生信服务器几乎全是 Linux，而从 Windows 来的文件默认都是 CRLF——这就是问题根源。

1.2 诊断换行符#

Terminal window展开收起

1
# 方法1：file 命令（最直接）
2
file sample_list.txt
3
# 输出：sample_list.txt: ASCII text, with CRLF line terminators
4
#       ↑ 注意 "with CRLF" → Windows换行符
5

6
file gene_anno.gff3
7
# 输出：gene_anno.gff3: ASCII text
8
#       ↑ 没有 "CRLF" → 正常LF
9

10
# 方法2：cat -A 显示不可见字符
11
cat -A sample_list.txt
12
# sample1$
13
# sample2$
14
# 如果 $ 前面还有 ^M（即 \r），就是 CRLF：
15
# sample1^M$
16

17
# 方法3：xxd / od 十六进制查看
18
xxd sample_list.txt | head -5
19
# 0d 0a = CRLF, 0a = LF
20

21
# 方法4：统计 CR 字符数量
22
grep -c $'\r' sample_list.txt
23
# 正数说明文件里有CR

展开收起

1.3 转换换行符#

Terminal window展开收起

1
# 安装 dos2unix
2
sudo apt install dos2unix -y
3

4
# CRLF → LF（Windows → Linux）
5
dos2unix sample_list.txt
6

7
# LF → CRLF（Linux → Windows，给同事用）
8
unix2dos sample_list.txt
9

10
# 批量转换
11
find . -name "*.txt" -exec dos2unix {} \;
12
find . -name "*.csv" -exec dos2unix {} \;
13
find . -name "*.sh"  -exec dos2unix {} \;
14

15
# 预览模式（只显示会转换什么，不实际修改）
16
dos2unix -i sample_list.txt
17

18
# 强制转换（即使文件已标记为二进制也转）
19
dos2unix -f some_file.txt

展开收起

1.4 生信流程中的换行符灾难#

Terminal window

1
# 场景：Windows编辑的样本名列表
2
# samples.txt 内容：
3
# Sample_1\r\n
4
# Sample_2\r\n
5
# Sample_3\r\n

读取时如果不去掉 \r：

Terminal window

1
# Shell 里遍历——莫名其妙匹配不到文件
2
while read sample; do
3
    ls "${sample}_R1.fastq.gz"
4
    # 实际找的是 "Sample_1\r_R1.fastq.gz"——当然找不到！
5
done < samples.txt
6

7
# 正确做法：不依赖 dos2unix，在读取时也做清理
8
while IFS= read -r sample || [ -n "$sample" ]; do
9
    sample="${sample%$'\r'}"    # 去掉末尾的 \r
10
    ls "${sample}_R1.fastq.gz"
11
done < samples.txt

或者在流程入口统一转换：

Terminal window

1
# 流程脚本第一行
2
dos2unix -q samples.txt design.csv groups.tsv 2>/dev/null || true

2. 文件编码——UTF-8 vs GBK vs Latin1#

2.1 诊断编码#

Terminal window展开收起

1
# file 命令查看编码
2
file gene_names.txt
3
# 输出：gene_names.txt: UTF-8 Unicode text
4

5
file chinese_genes.txt
6
# 输出：chinese_genes.txt: ISO-8859 text  （可能是 GBK/GB2312）
7

8
# 更精确：uchardet（需要安装）
9
sudo apt install uchardet -y
10
uchardet unknown_file.txt
11
# 输出：UTF-8 或 GB18030 或 windows-1252
12

13
# 或 enca
14
sudo apt install enca -y
15
enca -L zh_CN unknown_file.txt
16
# 输出：Simplified Chinese National Standard; GB2312

展开收起

2.2 编码转换：iconv#

Terminal window展开收起

1
# 基本语法
2
iconv -f <源编码> -t <目标编码> 输入文件 -o 输出文件
3

4
# GBK → UTF-8（最常见的生信场景）
5
iconv -f GBK -t UTF-8 chinese_report.csv -o chinese_report_utf8.csv
6

7
# GB18030 → UTF-8（GB18030是GBK的超集，兼容性更好）
8
iconv -f GB18030 -t UTF-8 old_data.txt -o old_data_utf8.txt
9

10
# Latin1 → UTF-8（西欧语言数据）
11
iconv -f LATIN1 -t UTF-8 european_data.txt -o european_data_utf8.txt
12

13
# 批量转换
14
for f in *.csv; do
15
    iconv -f GBK -t UTF-8 "$f" -o "${f%.csv}_utf8.csv"
16
done
17

18
# 查看支持的所有编码
19
iconv -l | head -50

展开收起

2.3 生信文件中的编码问题#

GFF3/GTF 注释文件： 基因功能描述字段有时包含中文（来自一些国产数据库注释），用 GBK 编码的 GFF 文件在 Linux 工具里可能报错。

Terminal window

1
# 先诊断
2
file gene_annot.gff3
3
# 如果是 ISO-8859 或 unknown-8bit，大概率是 GBK
4

5
# 转换
6
iconv -f GBK -t UTF-8 gene_annot.gff3 -o gene_annot_utf8.gff3
7
# 验证
8
head -20 gene_annot_utf8.gff3

VCF 文件： VCF 规范要求 UTF-8，但部分旧软件可能写出 Latin1 或其他编码。bcftools 遇到非 UTF-8 字符会静默跳过或报错。

Terminal window

1
# 检查 VCF 编码
2
file variants.vcf
3
uchardet variants.vcf
4

5
# 必要时转换
6
cp variants.vcf variants_backup.vcf
7
iconv -f LATIN1 -t UTF-8 variants_backup.vcf -o variants.vcf

FASTA 文件： 序列行理论上是纯 ASCII（ATCGN + 简并碱基），但 header 行（> 开头）可能包含非 ASCII 字符。

Terminal window

1
# 检查 FASTA header
2
grep '^>' genome.fa | cat -A
3
# 如果有奇怪字符，可以用 iconv 转换
4

5
# 更安全：只保留 ASCII 字符（去掉非 ASCII 的 header 内容）
6
perl -pe 's/[^\x00-\x7F]//g' genome.fa > genome_clean.fa

3. BOM——UTF-8 的隐藏杀手#

3.1 什么是 BOM#

BOM (Byte Order Mark) 是文件开头的三个不可见字节：EF BB BF。Windows 记事本保存 UTF-8 文件时默认加上 BOM，Linux 工具看到它会直接崩。

Terminal window

1
# 检测 BOM
2
xxd sample.csv | head -1
3
# 如果有 BOM，开头三个字节是：efbbbf
4
# 输出示例：00000000: efbb bf53 616d 706c 652c 4772 6f75  ...Sample,Grou
5

6
# 或
7
file sample.csv
8
# 输出含 "UTF-8 Unicode (with BOM)" → 有BOM

3.2 BOM 在生信中的破坏力#

Terminal window

1
# 你以为第一列叫 "Gene"，其实叫 "\ufeffGene"
2
cut -f1 genes.csv | cat -A
3
# 输出：M-oM-;M-?Gene$    ← 前面有三个乱码
4

5
# R 读取有 BOM 的 CSV——第一列名变成乱码
6
df <- read.csv("genes.csv")
7
colnames(df)[1]
8
# [1] "ï..Gene"    ← 本该是 "Gene"
9

10
# Shell 脚本第一行有 BOM——直接报错
11
# 文件内容（看不见的BOM）: #!/bin/bash
12
bash script.sh
13
# /bin/bash^M: bad interpreter: No such file or directory

3.3 去掉 BOM#

Terminal window展开收起

1
# 方法1：tail -c +4（去掉前3字节）
2
tail -c +4 with_bom.csv > without_bom.csv
3

4
# 方法2：sed
5
sed -i '1s/^\xEF\xBB\xBF//' with_bom.csv
6

7
# 方法3：dos2unix（会自动去 BOM）
8
dos2unix with_bom.csv
9

10
# 方法4：Vim 打开
11
vim with_bom.csv
12
:set nobomb
13
:wq
14

15
# 批量去 BOM
16
find . -name "*.csv" -exec sed -i '1s/^\xEF\xBB\xBF//' {} \;

展开收起

4. 编辑器配置——从源头避免编码问题#

4.1 Vim 配置#

1
" ~/.vimrc
2
set fileencoding=utf-8      " 默认编码
3
set fileencodings=utf-8,gbk,gb2312,latin1  " 读取时尝试的顺序
4
set fileformat=unix          " 默认换行符 LF
5
set fileformats=unix,dos     " 读取时尝试的顺序
6
set nobomb                   " 不写 BOM

保存时强制格式：

1
:set fileformat=unix    " LF 换行
2
:set fileencoding=utf-8 " UTF-8 编码
3
:w                      " 保存

4.2 VS Code 配置#

在 VS Code 状态栏右下角可以看到当前文件的编码和换行符格式。点击即可切换：

换行符：CRLF → 点一下选 LF
编码：UTF-8 → 点击可选择其他编码重新打开或保存

全局设置（settings.json）：

1
{
2
    "files.encoding": "utf8",
3
    "files.eol": "\n",
4
    "files.autoGuessEncoding": false
5
}

4.3 Windows 用户注意#

如果在 Windows 上编辑生信脚本/数据，强烈建议：

不要用记事本！用 VS Code / Notepad++ / Sublime
编辑器设置默认换行为 LF，默认编码为 UTF-8 without BOM
传文件到服务器用 scp/rsync，不要用 FTP（FTP 的 ASCII 模式会自动转换换行符）

5. 踩坑记录#

坑1：`^M` 出现在 Shell 脚本里导致 `bad interpreter`#

症状：bash run.sh 报 bad interpreter: /bin/bash^M: no such file or directory。

原因：Windows 上编辑的脚本，换行符是 CRLF。Shebang 行变成了 #!/bin/bash\r，系统找不到叫 /bin/bash\r 的解释器。

Terminal window

1
# 快速修复
2
dos2unix run.sh
3
bash run.sh   # 正常了

坑2：GFF3 文件里中文乱码#

症状：grep "激酶" genes.gff3 没结果，但明明知道文件里有注释提到”蛋白激酶”。

原因：GFF 文件可能是 GBK 编码。

Terminal window

1
# 诊断
2
uchardet genes.gff3
3
# GB18030
4

5
# 转换
6
iconv -f GB18030 -t UTF-8 genes.gff3 -o genes_utf8.gff3
7

8
# 验证
9
grep "激酶" genes_utf8.gff3 | head

坑3：read.csv 读出来的列名变成了 `ï..Gene`#

原因：CSV 文件带 BOM，R 把 BOM 字节当做列名的一部分。

解决：

1
# 方法1：预处理去 BOM
2
# system("sed -i '1s/^\\xEF\\xBB\\xBF//' data.csv")
3

4
# 方法2：R 内处理
5
df <- read.csv("data.csv", fileEncoding = "UTF-8-BOM")
6

7
# 方法3：用 readr（自动处理 BOM）
8
library(readr)
9
df <- read_csv("data.csv")

坑4：bcftools 报 “Unexpected character in FORMAT field”#

症状：VCF 文件的 FORMAT 列值看起来正常，但 bcftools 报非法字符。

原因：文件中某一行的某个字段混入了非 ASCII 字符（比如从 Excel 粘贴时带入了 Unicode 空白字符）。

Terminal window

1
# 检查非 ASCII 字符
2
grep -nP '[^\x00-\x7F]' variants.vcf
3

4
# 去掉所有非 ASCII（保留 VCF 结构）
5
perl -pe 's/[^\x00-\x7F]//g' variants.vcf > clean.vcf

坑5：dos2unix 转换后文件被截断#

症状：dos2unix big_file.txt 运行完文件比原来小了，最后几行不见了。

原因：文件中包含 \0（NULL 字节），dos2unix 默认在 NULL 处停止。

Terminal window

1
# 强制模式跳过 NULL 字节
2
dos2unix --force --safe big_file.txt
3

4
# 如果是二进制混文本，用 --assume作为文本
5
dos2unix --assume-text-mode big_file.txt

坑6：Git 自动转换换行符导致混乱#

Windows 上 Git 默认 core.autocrlf=true，clone 时自动把 LF → CRLF，commit 时 CRLF → LF。但如果项目里有二进制文件被误判为文本，或者某些测试用文件需要保留 CRLF，这个”智能转换”就成了灾难。

Terminal window

1
# 全局关闭自动转换（推荐生信团队统一配）
2
git config --global core.autocrlf false
3

4
# 项目级配置（在仓库根目录的 .gitattributes）
5
# * text=auto
6
# *.sh text eol=lf
7
# *.fastq binary
8
# *.bam binary

6. 小结#

问题	诊断命令	解决命令
CRLF 换行符	`file sample.txt`	`dos2unix sample.txt`
GBK 编码	`uchardet file.txt`	`iconv -f GBK -t UTF-8 file.txt`
UTF-8 BOM	`xxd file.csv \| head -1`	`sed -i '1s/^\xEF\xBB\xBF//' file.csv`
不可见字符	`cat -A file.txt`	`perl -pe 's/[^\x00-\x7F]//g'`
换行符统计	`grep -c $'\r' file.txt`	—
批量转换	—	`find . -name "*.txt" -exec dos2unix {} \;`

经验：

所有生信流程脚本和数据文件，统一使用 UTF-8 编码 + LF 换行符
从外面接收文件（合作者、Windows 用户、公开数据库），第一件事就是 file + dos2unix + iconv
在流程入口脚本里加上编码检测和转换，比事后追查问题省 10 倍时间

本文于 2025-12-03 在 Debian 13 上实测完成。dos2unix 7.5.2，iconv (glibc 2.38)，uchardet 0.0.8。所有命令可直接使用。

管道与重定向进阶：stdin/stdout/stderr/文件描述符

Sat, 22 Nov 2025 00:00:00 GMT

生信流程本质是数据在管道中流动：FASTQ → 质控 → 比对 → SAM → 排序 → BAM → 定量 → 计数矩阵 → 差异表达。每一步都是 stdin → tool → stdout。理解管道和重定向不只是语法技巧，而是理解整个流程数据流的基础。

本文不讲 | 和 > 的基础语法，聚焦 进程替换、tee 分流、命名管道、文件描述符操作 等进阶技巧，覆盖 SAM 排序压缩、FASTQ 质控过滤、批量 GFF 处理等场景。

实测环境：Debian 13，Bash 5.2.32。

1. 三兄弟：stdin、stdout、stderr#

每个 Linux 进程生来就有三个文件描述符：

描述符	名称	编号	默认指向	生信用途
stdin	标准输入	0	键盘	管道传入的数据
stdout	标准输出	1	屏幕	正常结果（FASTQ、BAM、TSV）
stderr	标准错误	2	屏幕	日志、警告、进度信息

理解了这个，重定向语法就一通百通：

Terminal window

1
# 基础重定向
2
command > file         # stdout → file（覆盖）
3
command >> file        # stdout → file（追加）
4
command < file         # file → stdin
5
command 2> file        # stderr → file
6
command 2>&1           # stderr → stdout（合并到同一个流）
7
command &> file        # stdout + stderr → file（Bash 4.0+）
8

9
# 生信中最常见的模式
10
samtools view -bS aligned.sam > aligned.bam 2> samtools.log
11
# stdout（BAM 内容）→ aligned.bam
12
# stderr（日志）→ samtools.log

1.1 进程视角的公式#

如果用数学表达一个进程的 I/O 模型：

Process:(fd0,fd1,fd2)→transformoutput\text{Process}: (fd_0, fd_1, fd_2) \xrightarrow{\text{transform}} \text{output}Process:(fd0,fd1,fd2)transformoutput

Shell 的 > 和 < 就是重新绑定 fd1fd_1fd1 和 fd0fd_0fd0 的目的地：

fd1←fileinstead of terminalfd_1 \leftarrow \text{file} \quad \text{instead of terminal}fd1←fileinstead of terminal

2. 管道——生信流程的骨架#

2.1 管道的基础模型#

Terminal window

1
# 管道连接 stdout → stdin
2
samtools view aligned.bam | head -100
3

4
# 等价于：
5
# samtools view 的 stdout → head 的 stdin

管道的理论基础是生产者-消费者模型：

Pthroughput=min⁡(producer_rate,consumer_rate)P_{throughput} = \min(\text{producer\_rate}, \text{consumer\_rate})Pthroughput=min(producer_rate,consumer_rate)

如果前一步（producer）快、后一步（consumer）慢，管道会自动缓冲（默认 64KB）。如果前一步慢、后一步快，消费者会阻塞等待。管道的速度由最慢的步骤决定。

2.2 生信管道实战场景#

Terminal window展开收起

1
# 场景1：FASTQ 质控 + 比对一气呵成
2
fastp -i R1.fastq.gz -I R2.fastq.gz --stdout 2> fastp.log \
3
    | bwa mem -t 8 -p /opt/refs/hg38.fa - 2> bwa.log \
4
    | samtools sort -@ 4 -o aligned.sorted.bam - 2> sort.log
5

6
# 这里用了三个技巧：
7
# 1. fastp --stdout：输出到 stdout 而非文件
8
# 2. bwa mem 用 - 表示从 stdin 读取
9
# 3. samtools sort 也用 - 从 stdin 读
10

11
# 场景2：统计 BAM 中每条染色体的 reads 数
12
samtools idxstats aligned.bam \
13
    | awk '$3 > 0' \
14
    | sort -k3 -nr \
15
    | head -10
16

17
# 场景3：从 VCF 中提取高质量 SNP 并统计
18
bcftools view -i 'QUAL>30 && TYPE="snp"' variants.vcf.gz \
19
    | bcftools query -f '%CHROM\t%POS\t%REF\t%ALT\n' \
20
    | wc -l

展开收起

3. tee——数据流的分叉器#

tee 把 stdin 复制两份：一份继续走管道，一份写入文件。比喻就是河流分叉：

Terminal window

1
# 在管道中间"偷看"数据，同时保存
2
samtools view aligned.bam \
3
    | tee intermediate.sam \
4
    | awk '{print $3}' \
5
    | sort | uniq -c | sort -rn \
6
    | tee chr_stats.txt \
7
    | head -10
8

9
# 第一条 tee：把 SAM 内容保存到文件，同时继续传给 awk
10
# 第二条 tee：把统计结果保存，同时传给 head 显示

3.1 同时输出到 stdout 和 stderr#

Terminal window

1
# 用进程替换，tee 把日志同时打到终端和文件
2
samtools view -bS aligned.sam 2>&1 | tee samtools.log
3
# 2>&1 先把 stderr 合并到 stdout，tee 再复制

3.2 多个文件 + 管道#

Terminal window

1
# 同时写入多个文件（生信：备份 + 继续处理）
2
cat sample_list.txt \
3
    | tee >(grep "^S[0-9]" > samples.txt) \
4
    | tee >(grep "^C[0-9]" > controls.txt) \
5
    > all.txt
6
# >(...) 是进程替换——把命令当作"文件"

4. 进程替换——最被低估的 Bash 特性#

4.1 本质#

进程替换 <(command) 和 >(command) 创建一个匿名管道（named pipe 的一种），把命令的 stdout/stdin 伪装成文件路径：

Terminal window

1
# 不用临时文件直接比较两个命令的输出
2
diff <(cut -f1 file1.txt | sort) <(cut -f1 file2.txt | sort)
3

4
# 等价但无需中间文件：
5
# cut -f1 file1.txt | sort > /tmp/file1_sorted
6
# cut -f1 file2.txt | sort > /tmp/file2_sorted
7
# diff /tmp/file1_sorted /tmp/file2_sorted
8
# rm /tmp/file1_sorted /tmp/file2_sorted

4.2 生信场景#

Terminal window展开收起

1
# 场景1：比较两个样本的基因列表（不生成中间文件）
2
comm -12 \
3
    <(awk '$8>0 {print $1}' sample1_counts.tsv | sort) \
4
    <(awk '$8>0 {print $1}' sample2_counts.tsv | sort) \
5
    > common_genes.txt
6

7
# 场景2：快速检查两个 BAM 文件的 header 差异
8
diff <(samtools view -H sample1.bam) <(samtools view -H sample2.bam)
9

10
# 场景3：GFF 和 BED 坐标交集（不需要中间文件）
11
bedtools intersect \
12
    -a <(awk '$3=="gene"' annotation.gff3 | gff2bed) \
13
    -b <(awk '$5>10' peaks.bed) \
14
    > overlapping_genes.bed
15

16
# 场景4：把 stderr 也送入管道处理
17
samtools flagstat aligned.bam 2> >(grep "mapped" > mapping_stats.txt)

展开收起

5. 命名管道——跨进程通信#

5.1 创建和使用#

Terminal window

1
# 创建命名管道（FIFO）
2
mkfifo my_pipe
3

4
# 终端1：写入端
5
gzip -c huge.fastq > my_pipe
6

7
# 终端2：读取端（另一个终端/进程）
8
bwa mem ref.fa my_pipe > aligned.sam
9

10
# 清理
11
rm my_pipe

5.2 生信实战——并行解压与比对#

1
#!/bin/bash
2
# 并行解压 + 比对，避免磁盘 I/O 瓶颈
3

4
PIPE=$(mktemp -u)
5
mkfifo "${PIPE}"
6

7
# 后台：解压 FASTQ 到命名管道
8
gzip -dc sample.fastq.gz > "${PIPE}" &
9

10
# 前台：从管道读取并用 bwa 比对
11
bwa mem -t 16 /opt/refs/hg38.fa "${PIPE}" \
12
    | samtools sort -@ 8 -o aligned.sorted.bam -
13

14
rm "${PIPE}"
15

16
# 优势：解压和比对并行，避免把解压后的几十 GB 数据写入磁盘

展开收起

对于磁盘 I/O 瓶颈的场景，命名管道能显著提速。时间模型：

Tpipe=max⁡(Tdecompress,Talign)T_{pipe} = \max(T_{decompress}, T_{align})Tpipe=max(Tdecompress,Talign)

Tdisk=Tdecompress_to_disk+Tread_from_disk+TalignT_{disk} = T_{decompress\_to\_disk} + T_{read\_from\_disk} + T_{align}Tdisk=Tdecompress_to_disk+Tread_from_disk+Talign

当解压出的数据量很大时，Tpipe≪TdiskT_{pipe} \ll T_{disk}Tpipe≪Tdisk。

6. xargs——跨越管道的限制#

管道的核心限制：每个 | 右边只能是一个命令的 stdin，不能是命令参数。xargs 就是打破这个限制的工具。

6.1 基础用法#

Terminal window

1
# 问题：管道只能传 stdin，不能传参数
2
# 下面的写法是错的：
3
echo "aligned.bam" | samtools view -h    # 错误！samtools view 需要参数不是 stdin
4

5
# 正确：用 xargs 把 stdin 变成参数
6
echo "aligned.bam" | xargs samtools view -h | head -20
7

8
# xargs 的核心：把 stdin 的每一行变成后面命令的参数

6.2 并行 xargs——生信批量处理加速#

Terminal window

1
# 对所有 BAM 文件并行生成索引（-P 指定并行数）
2
find . -name "*.bam" | xargs -P 8 -I {} samtools index {}
3

4
# -P 8  → 同时运行 8 个进程
5
# -I {} → {} 是占位符，代表每个输入行

对于独立任务（每个 BAM 文件互不影响），加速比近似为：

S(n)=TserialTparallel≈n1+α(n−1)S(n) = \frac{T_{serial}}{T_{parallel}} \approx \frac{n}{1 + \alpha(n - 1)}S(n)=TparallelTserial≈1+α(n−1)n

其中 nnn 是并行数，α\alphaα 是无法并行的比例（I/O 等待通常占 10-20%）。

6.3 生信批量处理模板#

Terminal window

1
# 1. 批量质控
2
ls *.fastq.gz | xargs -P 4 -I {} fastqc {} -o qc_results/
3

4
# 2. 批量比对
5
ls *_R1.fastq.gz | sed 's/_R1.fastq.gz//' | xargs -P 8 -I {} sh -c \
6
    'bwa mem -t 2 /opt/refs/hg38.fa {}_R1.fastq.gz {}_R2.fastq.gz | samtools sort -@ 2 -o aligned/{}_sorted.bam -'
7

8
# 3. 批量统计
9
ls *.bam | xargs -P 8 -I {} sh -c 'samtools flagstat {} > stats/{}.flagstat'

6.4 处理文件名中的空格#

Terminal window

1
# 文件名含空格时，用 -0 配合 find 的 -print0
2
find . -name "*.bam" -print0 | xargs -0 -P 4 -I {} samtools index {}
3

4
# -print0：用 \0 分隔（而不是换行）
5
# -0：xargs 以 \0 作为分隔符

7. 高级重定向技巧#

7.1 交换 stdout 和 stderr#

Terminal window

1
# 3>&2 2>&1 1>&3- 这个咒语的拆解
2
# 场景：想让 samtools 的日志走管道，但 BAM 数据写入文件
3

4
exec 3>&1                              # 备份原始 stdout 到 fd3
5
samtools view -bS aligned.sam 2>&1 1>&3 | tee samtools.log
6
exec 3>&-                              # 关闭 fd3
7

8
# 解释：2>&1 让 stderr 合并到当前的 stdout（此时是终端）
9
# 1>&3 让 stdout 恢复到原始的 fd3→终端
10
# 结果：stderr → 管道 → tee，stdout → 文件（通过重定向）

7.2 Here Documents——内嵌数据#

Terminal window

1
# 把多行文本直接传给命令
2
bcftools view -i 'QUAL>30' << 'EOF'
3
##fileformat=VCFv4.2
4
#CHROM  POS     ID      REF     ALT     QUAL    FILTER  INFO
5
chr1    12345   .       A       G       45.2    PASS    .
6
chr1    23456   .       C       T       12.1    PASS    .
7
EOF
8

9
# 在脚本里内嵌 GTF 注解的某几行
10
grep "BRCA1" << 'END_GTF' | cut -f1,4,5
11
chr17   41196312        41197819        BRCA1
12
chr17   41199659        41199719        BRCA1
13
END_GTF

7.3 Here Strings——单行快速输入#

Terminal window

1
# <<< 把字符串当 stdin
2
bcftools view -h variants.vcf.gz | grep "fileDate" <<< ""
3
# 或
4
grep "SRR12345678" <<< "$(cat sample_list.txt)"
5

6
# 用 bc 做简单计算
7
bc <<< "scale=4; 35000000 / 1000000"
8
# 输出：35.0000

8. 踩坑记录#

坑1：管道里的 set -e 不生效。 set -e 只看管道最后一个命令的退出码。如果 false | true，整个管道返回 0（因为 true 成功了）。解决方案：set -o pipefail 让任何一步失败都导致管道失败。

坑2：大管道缓冲溢出。 管道缓冲区默认 64KB（Linux），如果前一步输出快、后一步处理慢，超出缓冲区后前一步会阻塞。在 SAM→BAM 这种场景不明显，但在超大数据流（如全基因组测序 raw data）中可能成为瓶颈。可以用 pv 监控管道流量：cmd1 | pv | cmd2。

坑3：xargs 遇到空输入时默认仍执行命令。 echo "" | xargs rm 会执行 rm（无参数，可能报错）。用 xargs -r（--no-run-if-empty）防止空输入时执行。

坑4：命名管道没有读取端时写入端会阻塞。 mkfifo mypipe && gzip -c data > mypipe 如果没有另一个进程在读 mypipe，这个命令会永久挂起。务必先准备好读取端，或在写入端设置超时。

坑5：进程替换 <(...) 的退出码无法直接获取。 diff <(cmd1) <(cmd2) 中 cmd1 或 cmd2 失败了你不知道。Bash 4.4+ 可以用 wait 或临时文件来获取退出码。

坑6：2>&1 和 1>&2 的区别。 2>&1 是把 stderr 重定向到 stdout 当前指向的地方（注意”当前”两个字——在重定向链中顺序至关重要）。command 2>&1 > file 是错的：先把 stderr 指向当前 stdout（终端），再把 stdout 指向 file。正确是 command > file 2>&1。

坑7：xargs 中复合命令的引号嵌套地狱。 xargs -I {} sh -c 'command "{}"' 里引号嵌套很容易出错。改用 xargs -I {} bash -c "command '{}'" 或直接写成独立脚本。生信批量处理推荐写成独立脚本然后用 xargs 调用。

本文于 2025-11-22 在 Debian 13 上实测。

VCF文件处理：bcftools过滤/注释/统计

Wed, 19 Nov 2025 00:00:00 GMT

VCF 文件包含密集的元信息和分号分隔的基因型字段（GT:GQ:DP:AD），初次接触容易困惑。bcftools 之于 VCF 如同 samtools 之于 BAM——是 VCF 处理的标准工具。本文从 VCF 四部分结构（meta/header/data）讲起，覆盖 bcftools 的过滤、注释、统计、合并操作。

实测环境：Debian 13，bcftools v1.23，全部命令用 1000 Genomes 公开 VCF 实测。

1. VCF 格式——四部分结构#

VCF（Variant Call Format）看似复杂，其实就四个部分：

1
##fileformat=VCFv4.2          ──┐
2
##INFO=<ID=DP,Number=1,...>     │ 1. Meta-information（##开头）
3
##FORMAT=<ID=GT,Number=1,...>   │   描述文件格式、INFO/FORMAT字段含义
4
#CHROM POS ID REF ALT QUAL ...──┘ 2. Header line（#开头，唯一一行）
5
chr1 100 . A G 50 PASS ...    ──┐
6
chr1 200 . C T 30 PASS ...      │ 3. Variant records（数据行）
7
chr1 300 . G A 10 q10;s50 ...  ─┘

每一行的 8 个固定列 + 样本列：

列	字段	含义	示例
1	CHROM	染色体	chr1
2	POS	位置（1-based）	100
3	ID	变异ID（dbSNP ID等）	rs12345 或 `.`
4	REF	参考等位基因	A
5	ALT	替代等位基因	G,T（多等位基因用逗号分隔）
6	QUAL	Phred质量分数	50
7	FILTER	过滤标签	PASS 或过滤原因
8	INFO	附加信息	DP=100;AF=0.5
9+	FORMAT+SAMPLE	样本基因型	GT:GQ 0/1:60:30

1.1 QUAL 字段——变异的可靠程度#

QUAL 是 Phred 尺度的质量分数：

Perror=10−QUAL/10P_{error} = 10^{-QUAL/10}Perror=10−QUAL/10

QUAL	错误概率	含义
10	10%	不可靠
20	1%	勉强可用
30	0.1%	比较可靠
50	0.001%	高置信
100+	<10⁻¹⁰	极高置信

1.2 FORMAT 字段——每样本的基因型信息#

FORMAT 列定义了后面的样本列怎么解读。最常见的是：

1
GT:GQ:DP:AD:PL

GT（Genotype）：0/0（纯合ref）、0/1（杂合）、1/1（纯合alt）、./.（缺失）
GQ（Genotype Quality）：基因型的 Phred 质量
DP（Read Depth）：该位点的总覆盖深度
AD（Allelic Depth）：REF 和 ALT 各自的 reads 数
PL（Phred-scaled Likelihood）：三种基因型（0/0, 0/1, 1/1）的归一化似然值

2. bcftools 核心子命令#

2.1 view——查看和基础过滤#

Terminal window展开收起

1
# 查看 VCF（去掉 header）
2
bcftools view -H variants.vcf.gz | head -20
3
# -H = 只显示数据行
4

5
# 只看特定染色体
6
bcftools view -r chr1 variants.vcf.gz
7

8
# 只看特定区域
9
bcftools view -r chr1:100000-500000 variants.vcf.gz
10

11
# 只保留 PASS 的变异
12
bcftools view -f PASS variants.vcf.gz
13

14
# 排除特定过滤标签
15
bcftools view -e 'FILTER="LowQual"' variants.vcf.gz -O z -o clean.vcf.gz
16
# -f = 只要包含某 flag 的
17
# -e = 排除满足表达式的
18
# -O z = 输出压缩 VCF（.vcf.gz）

展开收起

2.2 filter——硬过滤#

GATK 的 VQSR 是好但很多非模式生物做不了，只能用硬过滤：

Terminal window展开收起

1
# GATK 推荐的硬过滤阈值（人类 WGS）
2
bcftools filter \
3
    -i 'QUAL>=30 && DP>10 && DP<100 && MQ>40 && FS<60 && QD>2.0 && SOR<3' \
4
    -s 'LowQual' \
5
    variants.vcf.gz \
6
    -O z -o filtered.vcf.gz
7

8
# -i = include（保留满足条件的）
9
# -s = 不满足条件的标记为这个值（放入 FILTER 列）
10
# -e = exclude（与 -i 相反，排除满足条件的）
11

12
# 多条件分开标记
13
bcftools filter \
14
    -i 'QUAL>=30' -s 'LowQual' \
15
    -i 'QUAL>=30 && DP>10' -s 'LowDP' \
16
    -i 'QUAL>=30 && DP>10 && MQ>40' -s 'LowMQ' \
17
    variants.vcf.gz -O z -o filtered.vcf.gz

展开收起

常用过滤表达式速查：

表达式	含义
`QUAL>=30`	变异质量 ≥ 30
`DP>10 && DP<200`	覆盖深度 10-200
`MQ>40`	比对质量 > 40
`FS<60`	Fisher Strand Bias < 60
`QD>2.0`	按深度标准化的质量 > 2.0
`SOR<3`	Strand Odds Ratio < 3
`INFO/AF>0.05`	等位基因频率 > 5%
`FMT/DP>10`	样本的覆盖深度 > 10
`FMT/GQ>20`	样本基因型质量 > 20

2.3 query——提取特定字段（VCF 版 cut）#

Terminal window

1
# 提取 CHROM, POS, REF, ALT, QUAL
2
bcftools query -f '%CHROM\t%POS\t%REF\t%ALT\t%QUAL\n' variants.vcf.gz | head
3

4
# 提取样本的 GT 和 DP
5
bcftools query -f '%CHROM\t%POS\t[%GT\t%DP]\n' variants.vcf.gz | head
6
# [] = 对每个样本重复，每个样本输出 GT 和 DP
7

8
# 单个样本的 GT
9
bcftools query -f '%CHROM\t%POS\t[%SAMPLE %GT\n]' variants.vcf.gz | head
10

11
# 输出到 TSV 做下游分析
12
bcftools query -f '%CHROM\t%POS\t%REF\t%ALT\t%QUAL\t%INFO/DP\t%INFO/AF\n' \
13
    variants.vcf.gz > variants.tsv

2.4 stats——质量报告#

Terminal window

1
# 生成统计报告
2
bcftools stats variants.vcf.gz > stats.txt
3

4
# 看几个关键指标
5
cat stats.txt | grep -E "^SN"

输出解读：

1
SN  0  number of samples:      100          # 样本总数
2
SN  0  number of records:      4500000      # 变异总数
3
SN  0  number of SNPs:         4200000      # SNP数量
4
SN  0  number of indels:       300000       # Indel数量
5
SN  0  number of MNPs:         0            # 多核苷酸变异
6
SN  0  number of others:       0

快速画图（需要安装 plot-vcfstats）：

Terminal window

1
plot-vcfstats -p vcf_stats_plot/ stats.txt
2
# 生成一套 PNG 图：QUAL 分布、DP 分布、Indel 长度分布等

2.5 取交集/差集——样品间比较#

Terminal window

1
# 两个 VCF 的交集（两个都有的变异）
2
bcftools isec -n=2 -p isec_out sample1.vcf.gz sample2.vcf.gz
3

4
# 差集（只在 sample1 中的变异）
5
bcftools isec -C sample1.vcf.gz sample2.vcf.gz -O z -o sample1_only.vcf.gz
6

7
# 多文件
8
bcftools isec -n+3 -p isec_3way s1.vcf.gz s2.vcf.gz s3.vcf.gz
9
# -n+3 = 至少在3个文件中出现的变异

2.6 合并与连接#

Terminal window

1
# 纵向合并（同样的位点，不同样本）—— concat
2
bcftools concat -O z -o merged.vcf.gz chr1.vcf.gz chr2.vcf.gz chr3.vcf.gz
3

4
# 横向合并（不同位点或不同样本）—— merge
5
bcftools merge -O z -o combined.vcf.gz sample1.vcf.gz sample2.vcf.gz
6

7
# 注意：concat 要求 VCF header 一致（样本顺序不同可通过重排序解决）

3. VCF 注释——加功能信息#

3.1 用 bcftools annotate 加 dbSNP ID#

Terminal window

1
# 先下载 dbSNP VCF（或用已有的）
2
# 用 bcftools annotate 加注释
3
bcftools annotate \
4
    -a dbsnp.vcf.gz \
5
    -c ID \
6
    -O z -o annotated.vcf.gz \
7
    variants.vcf.gz
8

9
# -a = annotation source
10
# -c ID = 把 annotation source 的 ID 列复制过来

3.2 自定义注释#

Terminal window展开收起

1
# 手动创建注释文件（BED 或 tab 分隔）
2
cat > custom_anno.txt << 'EOF'
3
#CHROM  FROM  TO  GENE  IMPACT
4
chr1  100  200  BRCA1  HIGH
5
chr1  500  600  TP53   HIGH
6
EOF
7

8
# bgzip + tabix（必须的）
9
bgzip custom_anno.txt
10
tabix -s1 -b2 -e3 custom_anno.txt.gz
11
# -s1 = CHROM 在第1列
12
# -b2 = start 在第2列
13
# -e3 = end 在第3列
14

15
# 注释
16
bcftools annotate \
17
    -a custom_anno.txt.gz \
18
    -c CHROM,FROM,TO,GENE,IMPACT \
19
    -h <(echo '##INFO=<ID=GENE,Number=1,Type=String,Description="Gene name">') \
20
    -O z -o annotated.vcf.gz \
21
    variants.vcf.gz

展开收起

4. VCF 压缩和索引——必须懂的规范#

VCF 文件必须用 bgzip（不是 gzip）压缩并建 tabix 索引：

Terminal window

1
# 压缩（用 bgzip，不是 gzip！）
2
bgzip variants.vcf
3

4
# 建 tabix 索引
5
tabix -p vcf variants.vcf.gz
6
# -p vcf = 按 VCF 格式建索引
7

8
# 验证
9
tabix variants.vcf.gz chr1:100000-500000
10
# 如果能输出区域内的变异，说明索引正确

为什么 bgzip 而非 gzip？ bgzip 将文件分成多个块（block），每个块独立压缩。tabix 索引记录了每个块在文件中的起始位置，使得区域查询时只需要解压对应的块而不是整个文件。

seek_timebgzip≈nblocks_in_regionntotal_blocks×decompress_timeseek\_time_{bgzip} \approx \frac{n_{blocks\_in\_region}}{n_{total\_blocks}} \times decompress\_timeseek_timebgzip≈ntotal_blocksnblocks_in_region×decompress_time

而 gzip 会把整个文件作为一个流压缩，区域查询也需要完整解压。

5. 实战：完整 VCF 处理 pipeline#

1
#!/bin/bash
2
# vcf_pipeline.sh —— 从 raw VCF 到分析就绪的 VCF
3

4
RAW_VCF="raw_variants.vcf.gz"
5
REF="ref/GRCh38.fa"
6

7
echo "=== Step 1: 只看 SNP（排除 Indel）==="
8
bcftools view -v snps "$RAW_VCF" -O z -o snps_only.vcf.gz
9
tabix -p vcf snps_only.vcf.gz
10

11
echo "=== Step 2: 硬过滤 ==="
12
bcftools filter \
13
    -i 'QUAL>=30 && DP>10 && DP<200 && MQ>40 && FS<60 && QD>2.0' \
14
    -s 'LowQual' \
15
    snps_only.vcf.gz \
16
    -O z -o filtered.vcf.gz
17
tabix -p vcf filtered.vcf.gz
18

19
echo "=== Step 3: 统计过滤前后对比 ==="
20
echo "Before filter:"
21
bcftools stats snps_only.vcf.gz | grep "^SN" | grep "number of records"
22
echo "After filter:"
23
bcftools stats filtered.vcf.gz | grep "^SN" | grep "number of records"
24

25
echo "=== Step 4: 提取高质量 PASS 变异 ==="
26
bcftools view -f PASS filtered.vcf.gz -O z -o pass_variants.vcf.gz
27
tabix -p vcf pass_variants.vcf.gz
28

29
echo "=== Step 5: 加注释（dbSNP）==="
30
bcftools annotate \
31
    -a dbsnp.vcf.gz \
32
    -c ID \
33
    -O z -o annotated.vcf.gz \
34
    pass_variants.vcf.gz
35

36
echo "=== Step 6: 导出 TSV 给 R ==="
37
bcftools query -f '%CHROM\t%POS\t%REF\t%ALT\t%QUAL\t%INFO/DP\t%INFO/AF\t[%GT\t%GQ]\n' \
38
    annotated.vcf.gz > variants_for_R.tsv
39

40
echo "Done! Final files:"
41
ls -lh *.vcf.gz *.tsv

展开收起

6. 踩坑记录#

坑1：VCF 用 gzip 压缩后 tabix 报错#

症状：tabix -p vcf file.vcf.gz 报 [tabix] could not open index。

原因：文件是用 gzip 压缩的，不是 bgzip。gzip 和 bgzip 的压缩格式不兼容。

Terminal window

1
# 检查是不是 bgzip
2
file file.vcf.gz
3
# gzip compressed data  ← 这是 gzip
4
# BGZF compressed data   ← 这才是 bgzip
5

6
# 修复
7
zcat file.vcf.gz | bgzip -c > file_bgzip.vcf.gz
8
tabix -p vcf file_bgzip.vcf.gz

坑2：多等位基因站点处理乱了#

症状：bcftools query -f '%ALT\n' 输出 G,T,C 这样的多等位基因，下游分析代码没处理。

VCF 的一个位置可以有多个 ALT 等位基因（用逗号分隔）。很多分析脚本假设每个位点只有两个等位基因。

Terminal window

1
# 先把多等位基因拆分为双等位基因
2
bcftools norm -m -both variants.vcf.gz -O z -o split.vcf.gz
3
# -m -both = 把多等位拆成多行
4

5
# 或者只保留双等位
6
bcftools view -m2 -M2 variants.vcf.gz -O z -o biallelic.vcf.gz
7
# -m2 -M2 = 恰好2个等位基因

坑3：bcftools filter 的 -i 和 -e 逻辑搞混#

症状：想保留 QUAL ≥ 30 的变异，结果全被去掉了。

Terminal window

1
# -i 是 include（保留），-e 是 exclude（排除）
2
# 保留 QUAL ≥ 30：
3
bcftools filter -i 'QUAL>=30' input.vcf.gz   # ✅ 正确
4

5
# 排除 QUAL < 30：
6
bcftools filter -e 'QUAL<30' input.vcf.gz    # ✅ 也正确，效果一样
7

8
# 常见错误：用 -e 但写了保留条件
9
bcftools filter -e 'QUAL>=30' input.vcf.gz   # ❌ 把高质量的全排除了

坑4：染色体名不一致导致 tabix 区域查询失败#

症状：tabix variants.vcf.gz chr1:1000-5000 输出了 chr1 的结果，但实际变异在 1（无 chr 前缀）。

原因：tabix 按字符串对比，chr1 ≠ 1。

Terminal window

1
# 查看 VCF 的染色体名
2
bcftools query -f '%CHROM\n' variants.vcf.gz | sort -u
3

4
# 如果需要统一，用 sed 改 header 和数据行
5
# （注意：这很危险，最好从源头统一参考基因组命名）

坑5：bcftools concat 报样本不一致#

症状：bcftools concat chr1.vcf.gz chr2.vcf.gz 报 the number of samples does not match。

原因：两个 VCF 的样本数量或顺序不同。

Terminal window

1
# 先统一样本列表
2
bcftools view -S sample_list.txt chr1.vcf.gz -O z -o chr1_reorder.vcf.gz
3
# -S = 只保留这些样本，按文件中的顺序重新排列
4

5
# 如果样本不同，用 merge 而非 concat
6
bcftools merge chr1.vcf.gz chr2.vcf.gz -O z -o merged.vcf.gz
7
# merge 自动处理样本不同和缺失

坑6：INFO 字段格式不符合 VCF 规范#

症状：某些工具生成的 VCF 的 INFO 字段用空格而非分号分隔。

Terminal window

1
# VCF 规定 INFO 是分号分隔的键值对：
2
# DP=100;AF=0.5     ← 正确
3
# DP=100 AF=0.5     ← 错误
4

5
# 检查
6
bcftools view -H variants.vcf.gz | head -3 | cut -f8
7
# 看输出里分隔符是 ; 还是空格
8

9
# 修复（慎用）
10
bcftools view -H variants.vcf.gz | awk 'BEGIN{OFS="\t"}{gsub(/ /, ";", $8); print}' \
11
    | cat <(bcftools view -h variants.vcf.gz) - | bcftools view -O z -o fixed.vcf.gz

坑7：VCF INDEX 不见了但 VCF 能正常 query#

症状：没有 .tbi 索引文件但 bcftools view -r 能跑。

原因：bcftools 在没索引时会流式扫描整个文件（非常慢）。它不会报错，只是默默变慢。

Terminal window

1
# 检查索引是否存在
2
ls -lh variants.vcf.gz.tbi
3

4
# 确保所有 .vcf.gz 都有索引
5
for vcf in *.vcf.gz; do
6
    if [ ! -f "${vcf}.tbi" ]; then
7
        echo "Missing index for $vcf, building..."
8
        tabix -p vcf "$vcf"
9
    fi
10
done

坑8：QUAL 和 GQ 的关系搞混导致过度过滤#

症状：按 FMT/GQ>30 过滤后丢失了大量高质量的变异。

QUAL 和 GQ 是不同的东西：

QUAL = 这个位置存在变异的置信度（位点级别）
GQ = 这个样本的基因型分配的置信度（样本级别）

一个变异可以 QUAL=1000（确定这里有个变异）但 GQ=5（不确定是杂合还是纯合）。

Terminal window

1
# 通常的过滤策略：
2
# 位点级别：QUAL ≥ 30
3
# 样本级别：GQ ≥ 20（对于群体分析可以适当放宽）
4
bcftools filter -i 'QUAL>=30 && FMT/GQ>=20' variants.vcf.gz

7. 小结#

子命令	功能	最常用参数
view	查看/过滤	`-r`(区域), `-f PASS`(过滤), `-v snps`(只SNP)
filter	硬过滤	`-i`(include表达式), `-e`(exclude), `-s`(标签)
query	提取字段	`-f`(格式), `[%GT]`(样本循环)
stats	质量报告	搭配 plot-vcfstats
isec	交集/差集	`-n`(文件数), `-C`(差集)
concat	纵向合并	同一样本不同染色体
merge	横向合并	不同样本同一染色体
annotate	加注释	`-a`(来源), `-c`(列映射)
norm	标准化	`-m -both`(拆分多等位)

bcftools 配合 samtools 基本覆盖了 NGS 数据处理的后半段。

本文于 2025-11-19 在 Debian 13 上实测完成。bcftools v1.23，tabix v1.23。测试数据来自 1000 Genomes Project Phase 3 公开 VCF。

Python Pandas数据清洗：表达矩阵、差异结果、样本注释

Tue, 18 Nov 2025 00:00:00 GMT

生信数据清洗常见场景：表达矩阵过滤、差异结果筛选与注释、样本元数据合并。用 Pandas 替代 Excel 可将处理时间从小时级压缩到分钟级。本文通过三个生信场景实操讲解 Pandas：缺失值处理、分组聚合、多表连接，附带 5 个踩坑记录。

实测环境：Debian 13，Python 3.10，Pandas 2.1.4，NumPy 1.26。

1. 环境与数据准备#

Terminal window

1
# 安装
2
mamba install -c conda-forge pandas numpy openpyxl -y

1
import pandas as pd
2
import numpy as np
3
from pathlib import Path
4

5
# 查看版本
6
print(f"Pandas: {pd.__version__}")
7
print(f"NumPy: {np.__version__}")

模拟三份数据#

1
# 1. 表达矩阵（基因 × 样本，TPM 值）
2
np.random.seed(42)
3
genes = [f"GENE{i:04d}" for i in range(2000)]
4
samples = [f"S{str(i).zfill(2)}" for i in range(1, 13)]
5

6
expr_data = np.random.lognormal(mean=2, sigma=1.5, size=(2000, 12))
7
expr_matrix = pd.DataFrame(
8
    expr_data,
9
    index=genes,
10
    columns=samples
11
)
12
# 故意加一些 0 和缺失值
13
expr_matrix.iloc[0:5, 0:2] = 0
14
expr_matrix.iloc[10:15, 3] = np.nan
15
expr_matrix.iloc[100, 5] = np.nan
16

17
print(f"Expression matrix shape: {expr_matrix.shape}")
18
print(expr_matrix.head())

展开收起

1
# 2. 差异表达结果
2
deg_data = {
3
    'gene_id': np.random.choice(genes, 1500, replace=False),
4
    'log2FC': np.random.normal(0, 1.5, 1500),
5
    'pvalue': np.random.uniform(0, 0.5, 1500),
6
    'baseMean': np.random.lognormal(3, 1, 1500)
7
}
8
deg_df = pd.DataFrame(deg_data)
9
deg_df['padj'] = deg_df['pvalue'].apply(lambda x: min(x * len(deg_df), 1.0))
10
# 故意制造一些混乱：gene_id 有重复、缺失
11
deg_df.loc[0:10, 'gene_id'] = 'GENE????'  # 脏数据
12
deg_df.loc[20:25, 'padj'] = np.nan
13

14
print(f"DEG results shape: {deg_df.shape}")
15
print(deg_df.head())

展开收起

1
# 3. 样本注释表
2
sample_info = pd.DataFrame({
3
    'sample_id': samples,
4
    'group': ['Control'] * 6 + ['Treatment'] * 6,
5
    'batch': ['A', 'A', 'B', 'B', 'C', 'C'] * 2,
6
    'age': np.random.randint(25, 70, 12),
7
    'sex': np.random.choice(['M', 'F'], 12),
8
    'rin': np.round(np.random.uniform(6.0, 10.0, 12), 1)
9
})
10
# 故意制造问题：sample_id 写成大写
11
sample_info.loc[0, 'sample_id'] = 'S01'  # 应该是 S01 但后面要匹配小写...
12
sample_info.loc[5, 'rin'] = np.nan
13

14
print(sample_info)

2. 场景一：表达矩阵清洗#

2.1 缺失值处理——定位和填充#

1
# 查看缺失值分布
2
missing_stats = expr_matrix.isnull().sum()
3
print("Samples with missing values:")
4
print(missing_stats[missing_stats > 0])
5

6
# 查看缺失值百分比
7
total_cells = expr_matrix.size
8
total_missing = expr_matrix.isnull().sum().sum()
9
print(f"Total missing: {total_missing}/{total_cells} ({total_missing/total_cells*100:.2f}%)")

三种常见处理策略：

1
# 策略1：基因层面——缺失超过 20% 样本就扔掉
2
gene_missing_pct = expr_matrix.isnull().mean(axis=1)
3
genes_to_keep = gene_missing_pct[gene_missing_pct < 0.2].index
4
expr_clean1 = expr_matrix.loc[genes_to_keep]
5

6
# 策略2：样本层面——缺失超过 10% 基因的样本扔掉
7
sample_missing_pct = expr_matrix.isnull().mean(axis=0)
8
samples_to_keep = sample_missing_pct[sample_missing_pct < 0.1].index
9
expr_clean2 = expr_matrix[samples_to_keep]
10

11
# 策略3：填充——用基因的中位数填充（比均值更稳健）
12
expr_filled = expr_matrix.T.fillna(expr_matrix.median(axis=1)).T
13
# 注意 .T 转置两次：fillna 默认按列填充，转置后按行填充

为什么用中位数不用均值？ 表达数据通常服从对数正态分布，均值受极端值（极高表达基因）影响大：

Zgene=log⁡2(TPM+1)−μgeneσgeneZ_{gene} = \frac{\log_2(TPM + 1) - \mu_{gene}}{\sigma_{gene}}Zgene=σgenelog2(TPM+1)−μgene

如果 μgene\mu_{gene}μgene 用均值估计，一个异常高表达的样本会拉偏整个基因的归一化。中位数（median）对异常值稳健。

2.2 低表达基因过滤#

1
# 过滤条件：至少在 3 个样本中 TPM > 1
2
# 与 DESeq2 的 pre-filtering 逻辑一致
3
expr_tpm = expr_filled.copy()
4
min_samples = 3
5
min_expression = 1.0
6

7
keep_genes = (expr_tpm > min_expression).sum(axis=1) >= min_samples
8
expr_filtered = expr_tpm.loc[keep_genes]
9

10
print(f"Before filtering: {expr_tpm.shape[0]} genes")
11
print(f"After filtering:  {expr_filtered.shape[0]} genes")
12
print(f"Removed:           {expr_tpm.shape[0] - expr_filtered.shape[0]} genes")

2.3 归一化——log2 转换#

1
# 生信表达矩阵标准操作：TPM/FPKM → log2(TPM + 1)
2
# 加 1 防止 log2(0) = -inf
3
expr_log2 = np.log2(expr_filtered + 1)
4

5
# 验证分布是否改善
6
import matplotlib.pyplot as plt
7
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
8
axes[0].hist(expr_filtered.values.flatten(), bins=100, color='steelblue', alpha=0.7)
9
axes[0].set_title('Before log2 transform')
10
axes[0].set_xlabel('TPM')
11
axes[1].hist(expr_log2.values.flatten(), bins=100, color='coral', alpha=0.7)
12
axes[1].set_title('After log2 transform')
13
axes[1].set_xlabel('log2(TPM+1)')
14
plt.tight_layout()
15
plt.savefig('log2_distribution.png', dpi=150)

展开收起

log2 转换的价值：

X′=log⁡2(TPM+1)X' = \log_2(TPM + 1)X′=log2(TPM+1)

这个变换把指数分布拉成正态近似——大多数下游统计方法（t 检验、Pearson 相关、PCA）都假设正态性。

3. 场景二：差异表达结果清洗与注释#

3.1 数据质量检查#

1
# 查看基本信息
2
print(deg_df.info())
3
print(deg_df.describe())
4

5
# 检查重复
6
duplicates = deg_df[deg_df['gene_id'].duplicated(keep=False)]
7
print(f"Duplicate gene_ids: {len(duplicates)}")
8

9
# 检查异常值（pvalue 不应该 >1）
10
bad_pval = deg_df[deg_df['pvalue'] > 1]
11
print(f"pvalue > 1: {len(bad_pval)} rows")
12

13
# 检查缺失 padj（差异分析没做完？）
14
missing_padj = deg_df[deg_df['padj'].isnull()]
15
print(f"Missing padj: {len(missing_padj)} rows")

展开收起

3.2 筛选差异基因#

1
# 经典阈值：|log2FC| > 1 且 padj < 0.05
2
sig_degs = deg_df[
3
    (deg_df['padj'] < 0.05) &
4
    (deg_df['log2FC'].abs() > 1)
5
].copy()
6

7
# 添加方向标签
8
sig_degs['direction'] = np.where(sig_degs['log2FC'] > 0, 'Up', 'Down')
9

10
print(f"Significant DEGs: {len(sig_degs)}")
11
print(sig_degs['direction'].value_counts())

3.3 多条件筛选（Pandas query）#

1
# 用 query() 方法写复杂筛选——比链式索引快且更可读
2
top_up = deg_df.query('padj < 0.01 and log2FC > 2 and baseMean > 100')
3
top_down = deg_df.query('padj < 0.01 and log2FC < -2 and baseMean > 100')
4

5
# 合并
6
top_degs = pd.concat([top_up, top_down])
7
print(f"Top DEGs: {len(top_degs)}")
8
print(top_degs[['gene_id', 'log2FC', 'padj']].head(10))

3.4 合并基因注释#

1
# 模拟基因注释表（gene_id → gene_symbol, chr, biotype）
2
annot = pd.DataFrame({
3
    'gene_id': genes,
4
    'gene_symbol': [f"SYMBOL{i:04d}" for i in range(2000)],
5
    'chr': np.random.choice([f"chr{c}" for c in range(1, 23)], 2000),
6
    'biotype': np.random.choice(['protein_coding', 'lncRNA', 'pseudogene'], 2000, p=[0.7, 0.2, 0.1])
7
})
8

9
# LEFT JOIN：保留所有差异基因，补上注释
10
sig_annotated = sig_degs.merge(
11
    annot,
12
    on='gene_id',
13
    how='left'  # 左连接：保留所有差异基因
14
)
15

16
# 检查哪些基因没匹配到注释（通常是 gene_id 格式不一致）
17
unmatched = sig_annotated[sig_annotated['gene_symbol'].isnull()]
18
print(f"Unmatched genes: {len(unmatched)}")
19
if len(unmatched) > 0:
20
    print(unmatched[['gene_id']].head())

展开收起

merge 的四种方式：

how	含义	适用场景
`inner`	交集	只要两边都有的
`left`	保留左边全部	保留所有差异基因
`right`	保留右边全部	保留所有注释项
`outer`	并集	全面检查缺失

3.5 按 biotype 分组统计#

1
# groupby + agg：分组聚合
2
biotype_stats = sig_annotated.groupby('biotype').agg(
3
    count=('gene_id', 'count'),
4
    mean_log2FC=('log2FC', 'mean'),
5
    up_count=('direction', lambda x: (x == 'Up').sum()),
6
    down_count=('direction', lambda x: (x == 'Down').sum())
7
).reset_index()
8

9
biotype_stats['pct'] = (biotype_stats['count'] / biotype_stats['count'].sum() * 100).round(1)
10
print(biotype_stats)

4. 场景三：样本注释表合并与质控#

4.1 统一样本名#

1
# 样本名不一致是最大的坑。先把所有样本名标准化
2
expr_matrix.columns = expr_matrix.columns.str.strip().str.upper()
3
sample_info['sample_id'] = sample_info['sample_id'].str.strip().str.upper()
4

5
# 验证一致性
6
expr_samples = set(expr_matrix.columns)
7
info_samples = set(sample_info['sample_id'])
8

9
print(f"In expression matrix, not in info: {expr_samples - info_samples}")
10
print(f"In info, not in expression matrix: {info_samples - expr_samples}")

4.2 表达矩阵与样本表对齐#

1
# 把表达矩阵转置（样本 × 基因），然后 merge 样本信息
2
expr_long = expr_log2.T  # 转置：样本为行
3
expr_long.index.name = 'sample_id'
4
expr_long = expr_long.reset_index()
5

6
# 合并
7
full_data = expr_long.merge(
8
    sample_info,
9
    on='sample_id',
10
    how='inner'  # 只要两边都有的样本
11
)
12

13
print(f"Matched samples: {len(full_data)}")
14

15
# 把 sample_id 设为 index，方便后续分析
16
full_data = full_data.set_index('sample_id')

展开收起

4.3 按分组计算均值#

1
# 分组计算每个基因的平均表达
2
gene_cols = [c for c in full_data.columns if c.startswith('GENE')]
3
group_means = full_data.groupby('group')[gene_cols].mean()
4

5
print(group_means.shape)  # (2 组, N 基因)
6
print(group_means.iloc[:, :5])  # 前 5 个基因

4.4 PCA 数据准备（为 sklearn 准备数据）#

1
from sklearn.decomposition import PCA
2
from sklearn.preprocessing import StandardScaler
3

4
# 提取表达矩阵部分
5
X = full_data[gene_cols].values
6

7
# 标准化（PCA 前必须）
8
scaler = StandardScaler()
9
X_scaled = scaler.fit_transform(X)
10

11
# PCA
12
pca = PCA(n_components=2)
13
X_pca = pca.fit_transform(X_scaled)
14

15
# 做成 DataFrame
16
pca_df = pd.DataFrame(X_pca, columns=['PC1', 'PC2'], index=full_data.index)
17
pca_df = pca_df.join(full_data[['group', 'batch']])
18

19
# 查看方差解释率
20
explained_var = pca.explained_variance_ratio_
21
print(f"PC1: {explained_var[0]*100:.1f}%, PC2: {explained_var[1]*100:.1f}%")

展开收起

方差解释率的计算：

Variance Explainedk=λk∑i=1nλi×100%\text{Variance Explained}_k = \frac{\lambda_k}{\sum_{i=1}^{n} \lambda_i} \times 100\%Variance Explainedk=∑i=1nλiλk×100%

其中 λk\lambda_kλk 是第 kkk 个主成分的特征值（eigenvalue）。PC1 + PC2 之和 > 50% 说明前两个主成分捕获了大部分变异——分组效应强。

5. 完整数据清洗 Pipeline#

1
def clean_expression_pipeline(expr_df, sample_df, min_expression=1.0, min_samples=3):
2
    """
3
    表达矩阵清洗 pipeline
4
    """
5
    # 1. 统一列名
6
    expr_df.columns = expr_df.columns.str.strip().str.upper()
7
    sample_df['sample_id'] = sample_df['sample_id'].str.strip().str.upper()
8

9
    # 2. 样本交集
10
    common_samples = list(set(expr_df.columns) & set(sample_df['sample_id']))
11
    expr_df = expr_df[common_samples]
12
    sample_df = sample_df[sample_df['sample_id'].isin(common_samples)]
13

14
    # 3. 填充缺失值（中位数）
15
    expr_df = expr_df.T.fillna(expr_df.median(axis=1)).T
16

17
    # 4. 过滤低表达基因
18
    keep = (expr_df > min_expression).sum(axis=1) >= min_samples
19
    expr_df = expr_df.loc[keep]
20

21
    # 5. log2 转换
22
    expr_log2 = np.log2(expr_df + 1)
23

24
    print(f"Pipeline complete: {expr_log2.shape[0]} genes × {expr_log2.shape[1]} samples")
25
    return expr_log2, sample_df
26

27
# 运行
28
expr_clean, meta_clean = clean_expression_pipeline(expr_matrix, sample_info)
29
print(f"Cleaned: {expr_clean.shape}")

展开收起

6. 踩坑记录#

坑1：`SettingWithCopyWarning`——Pandas 最烦人的警告#

1
# 会触发警告的写法
2
sig_degs = deg_df[deg_df['padj'] < 0.05]
3
sig_degs['direction'] = 'Up'  # SettingWithCopyWarning！
4

5
# 正确：用 .copy()
6
sig_degs = deg_df[deg_df['padj'] < 0.05].copy()
7
sig_degs['direction'] = 'Up'  # 安静

原因： Pandas 的链式索引返回的可能是 view（视图）也可能是 copy（副本）。改 view 没问题，改 copy 不会影响原始 DataFrame——Pandas 不确定你想要哪种，所以报警告。.copy() 明确告诉 Pandas：“我就要副本”。

坑2：merge 后行数暴增（多对多 join）#

1
# 如果 gene_id 在两边都有重复...
2
print(deg_df['gene_id'].duplicated().sum())  # 如果有重复
3
print(annot['gene_id'].duplicated().sum())   # 也有重复
4
# merge 后行数可能是 N_deg × N_annot ——爆炸！
5

6
# 解决：merge 前去重
7
annot_unique = annot.drop_duplicates(subset='gene_id')
8
deg_unique = deg_df.drop_duplicates(subset='gene_id')
9
result = deg_unique.merge(annot_unique, on='gene_id', how='left')

坑3：`np.nan == np.nan` 返回 False#

1
import math
2
print(np.nan == np.nan)  # False！
3

4
# 正确检测 NaN
5
print(pd.isna(np.nan))   # True
6
print(np.isnan(np.nan))  # True
7

8
# 在 DataFrame 中：
9
deg_df['padj'].isna().sum()   # 这才是对的
10
# deg_df['padj'] == np.nan    # 永远是 False！

这是 IEEE 754 浮点规范定义的——NaN 不等于任何值，包括它自己。

坑4：`groupby` 之后结果类型混乱#

1
# groupby 返回的可能是 Series 也可能是 DataFrame，取决于你之后链了什么
2
result = deg_df.groupby('gene_id')['log2FC'].mean()
3
# -> Series
4

5
result = deg_df.groupby('gene_id')[['log2FC', 'padj']].mean()
6
# -> DataFrame（因为用了双层方括号）
7

8
# 不确定类型时，强制转 DataFrame：
9
result = deg_df.groupby('gene_id')['log2FC'].mean().reset_index()
10
# 现在确定是 DataFrame

坑5：CSV 读取时自动把基因名转成日期#

1
# 如果你的表达矩阵第一列基因名包含 "SEPT1"、"MARCH1" 这样的...
2
df = pd.read_csv('expression.csv', index_col=0)
3
# SEPT1 被 Pandas 自动识别为 "1-Sep"（9 月 1 日）！
4

5
# 解决：读入时强制所有列为字符串
6
df = pd.read_csv('expression.csv', index_col=0, dtype=str)
7

8
# 然后再转换数值列
9
df = df.apply(pd.to_numeric, errors='coerce')

这个坑是用 Pandas 的经典地狱时刻——你的基因列表突然变成了日期列表，而且不会报任何错。

本文于 2025-11-18 在 Debian 13 + Python 3.10 + Pandas 2.1.4 上实测。

系统资源监控：htop/iotop/nmon/du

Mon, 10 Nov 2025 00:00:00 GMT

生信服务器的三类典型故障：(1) 未限制线程数导致 CPU 打满、SSH 无法连接；(2) 临时文件写爆 root 分区导致 BAM 损坏；(3) 内存泄漏触发 OOM Killer 杀进程。本文覆盖四类监控：进程（htop）、磁盘（iotop/du/ncdu）、内存（free/vmstat）、长期趋势（nmon/sar），附 6 个实战案例和 7 个踩坑记录。

环境：Debian 13，128 核 / 512GB 内存 / 10TB 存储（典型生信服务器配置）。

1. CPU与进程监控——htop 一屏看尽#

1.1 安装与基础#

Terminal window

1
sudo apt install htop -y
2
htop

进入 htop 后的界面布局（从上到下）：

区域	内容	生信关注点
顶部仪表盘	CPU 条（每核心一个）、内存条、swap条	绿色=用户态，红色=内核态，蓝色=低优先级
进程列表	PID、USER、CPU%、MEM%、COMMAND	谁的CPU%最高？谁在大量读写？
底部快捷键	F1-F10	F6 排序、F9 kill、F5 树形视图

1.2 生信必备 htop 操作#

Terminal window

1
# 启动时就按CPU排序
2
htop -s PERCENT_CPU
3

4
# 只看某个用户的进程
5
htop -u bioinfo
6

7
# 树形视图看父子进程关系
8
# 在htop里按 F5，或者启动时：
9
htop -t
10

11
# 只显示特定进程（配合 -p）
12
htop -p $(pgrep -d, bwa)    # 只看bwa的所有进程

树形视图在生信中的妙用：当你用 GNU Parallel 或 Snakemake 提交了几十个任务，树形视图能一眼看出哪个主进程卡住了多少子进程。

1.3 htop 里的颜色条解读#

对于生信工作负载，最常见的模式：

全是绿色（用户态CPU）：正常——BWA/HISAT2 等计算密集型
大量红色（内核态CPU）：⚠ 大量系统调用或 I/O 等待——可能是磁盘瓶颈
灰色（I/O Wait）：⚠⚠ 进程在等磁盘——你的 RAID 阵列或 NFS 跟不上
蓝绿色（低优先级 nice）：有人在后台跑 low-priority 任务

如果看到持续高 I/O Wait（>20%），问题不在 CPU 而在磁盘，接着看 iotop。

1.4 命令行快速采样#

Terminal window

1
# 一次性快照（类似top -bn1但更漂亮）
2
htop -C   # 无颜色单色模式，适合重定向到文件
3

4
# 批量采样
5
for i in {1..10}; do
6
    echo "=== Sample $i at $(date) ==="
7
    ps aux --sort=-%cpu | head -6
8
    sleep 5
9
done > cpu_samples.log

2. 内存监控——OOM之前的黄金5分钟#

2.1 free——第一眼看内存#

Terminal window

1
free -h

输出解读：

1
               total        used        free      shared  buff/cache   available
2
Mem:           503Gi       198Gi       5.2Gi       2.1Gi       299Gi       300Gi
3
Swap:          32Gi        12Gi        20Gi

生信重点看 available 不是 free！Linux 会大量使用内存做缓存（buff/cache），free 列看起来很少但 available 才是真正可分配给新进程的。

memavailable=memfree+reclaimable(buff/cache)mem_{available} = mem_{free} + reclaimable(buff/cache)memavailable=memfree+reclaimable(buff/cache)

2.2 进程内存排名#

Terminal window

1
# 按内存使用排序前10
2
ps aux --sort=-%mem | head -11
3

4
# 只看RSS（物理内存），更准确
5
ps -eo pid,user,rss,comm --sort=-rss | head -20 | \
6
    awk '{printf "%-8s %-10s %-12s %s\n", $1, $2, sprintf("%.1fG", $3/1048576), $4}'
7

8
# 或者用更直观的
9
ps aux | awk '{print $6/1024 " MB\t" $11}' | sort -rn | head -10

2.3 实时监控内存的脚本#

1
#!/bin/bash
2
# monitor_mem.sh —— 当可用内存低于阈值时告警
3
THRESHOLD_GB=20
4
INTERVAL=30
5

6
while true; do
7
    available_kb=$(grep MemAvailable /proc/meminfo | awk '{print $2}')
8
    available_gb=$((available_kb / 1048576))
9

10
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
11

12
    if [[ ${available_gb} -lt ${THRESHOLD_GB} ]]; then
13
        echo "[${timestamp}] ⚠ WARNING: Only ${available_gb}GB available!" | tee -a mem_alerts.log
14

15
        # 显示内存使用TOP5
16
        echo "Top 5 memory consumers:" >> mem_alerts.log
17
        ps aux --sort=-%mem | head -6 >> mem_alerts.log
18
    else
19
        echo "[${timestamp}] OK: ${available_gb}GB available"
20
    fi
21

22
    sleep ${INTERVAL}
23
done

展开收起

2.4 OOM Killer 日志分析#

Terminal window

1
# 查看OOM事件
2
dmesg | grep -i "killed process" | tail -20
3

4
# 或者
5
journalctl -k | grep -i oom | tail -20
6

7
# 典型输出：
8
# Out of memory: Killed process 12345 (bwa) total-vm:64GB, anon-rss:58GB

生信预防OOM的经验：

估算每个进程的内存：BWA mem 约需 参考基因组大小 × 1.5 + reads大小 的内存
限制并发数 = 总可用内存 / 单进程峰值内存
给关键系统留 10-20GB 缓冲
跑大任务前 free -h 确认

3. 磁盘IO监控——BAM写入的隐形瓶颈#

生信最容易被忽略的瓶颈是磁盘 I/O。比对本身是 CPU 密集，但读写 FASTQ 和 BAM 才是真正的吞吐量杀手。

3.1 iostat——IO吞吐概览#

Terminal window

1
# 安装
2
sudo apt install sysstat -y
3

4
# 持续监控（每秒刷新）
5
iostat -x 1
6

7
# 只看某个设备
8
iostat -x -p sda 1

关注列：

列	含义	健康值	危险值
`r/s` `w/s`	每秒读写次数	<1000	>5000 (随机IO瓶颈)
`rkB/s` `wkB/s`	每秒读写KB	取决于磁盘	接近磁盘标称值
`%util`	磁盘繁忙度	<70%	>90%（持续）
`await`	平均IO等待(ms)	<10ms(SSD)	>50ms
`aqu-sz`	平均队列长度	<5	>20

生信典型场景的 iostat 解读：

IOthroughput=BAMsizetwriteIO_{throughput} = \frac{BAM_{size}}{t_{write}}IOthroughput=twriteBAMsize

一个 50GB 的 BAM，如果 wkB/s 稳定在 200MB/s，大约需要 250 秒。如果 %util 已经到了 98% 但 wkB/s 只有 50MB/s——说明你在用机械硬盘，考虑换 SSD 或用 /dev/shm 做临时目录。

3.2 iotop——谁在疯狂读写#

Terminal window

1
sudo apt install iotop -y
2
sudo iotop -o   # -o 只显示有IO活动的进程

iotop 直接告诉你：哪个进程在读写、读了多少、写了多少、I/O 占用百分比。

Terminal window

1
# 生信典型输出：
2
#   PID  DISK READ  DISK WRITE  COMMAND
3
# 12345   200M/s    180M/s      bwa mem
4
# 12346     0M/s    150M/s      samtools sort

看到 samtools sort 大量写入临时文件时，考虑：

Terminal window

1
# 把临时目录放到内存（/dev/shm）或快速SSD
2
export TMPDIR=/dev/shm
3
samtools sort -T /dev/shm/sort_tmp -@ 16 input.bam -o output.bam

3.3 磁盘空间——du和ncdu#

Terminal window

1
# 查看各目录的空间占用
2
du -h --max-depth=2 /opt/bioinfo | sort -rh | head -20
3

4
# 只看大于1GB的文件
5
find /data -type f -size +1G -exec ls -lh {} \; 2>/dev/null | awk '{print $5, $NF}'
6

7
# ncdu —— 交互式磁盘分析（超级推荐！）
8
sudo apt install ncdu -y
9
ncdu /data

ncdu 可以按 d 删除、按 n 按名称排序、按 s 按大小排序。找到谁把磁盘吃光了，按一下 d 直接删。

4. 长期监控——nmon记录一切#

跑一个 48 小时的流程，过程中不可能一直盯着屏幕。nmon 能记录所有指标到文件，事后分析。

Terminal window

1
sudo apt install nmon -y
2

3
# 每30秒采集一次，持续24小时（2880个快照）
4
nmon -f -s 30 -c 2880 -m /opt/logs/nmon/
5

6
# -f: 输出到文件（默认命名 hostname_YYYYMMDD_HHMM.nmon）
7
# -s 30: 每30秒采样
8
# -c 2880: 采样2880次
9
# -m: 输出目录
10

11
# 用nmonchart把.nmon转成图表
12
# 或直接用 nmon 打开 .nmon 文件：
13
nmon -r /opt/logs/nmon/server_20250101_1200.nmon

分析nmon数据的关键指标#

在 nmon 文件中按对应键查看：

按键	内容	生信用途
`c`	CPU	看计算密集型步骤的CPU利用率
`m`	内存	有没有内存泄漏（持续增长）
`d`	磁盘	读写带宽、IOPS
`n`	网络	NFS/数据传输
`t`	进程	各进程资源占用排序

发现内存泄漏的nmon特征：内存 used 持续线性增长，即使进程数不变。对应地去找那个随运行时间增长内存的进程。

5. 生信实战：全流程监控脚本#

1
#!/bin/bash
2
# pipeline_monitor.sh —— 跑流程的同时记录资源
3
set -euo pipefail
4

5
LOG_DIR="./monitor_logs"
6
mkdir -p "${LOG_DIR}"
7
PREFIX="${LOG_DIR}/$(date +%Y%m%d_%H%M%S)"
8

9
# 启动后台监控
10
echo "Starting monitoring..."
11

12
# 1. CPU + 内存（每30秒）
13
(
14
    echo "timestamp,cpu_user,cpu_sys,cpu_idle,cpu_wait,mem_total_kb,mem_avail_kb,swap_used_kb"
15
    while true; do
16
        ts=$(date +%s)
17
        cpu_line=$(top -bn1 | grep "Cpu(s)" | sed 's/[,%]/ /g')
18
        cpu_user=$(echo "$cpu_line" | awk '{print $2}')
19
        cpu_sys=$(echo "$cpu_line" | awk '{print $4}')
20
        cpu_idle=$(echo "$cpu_line" | awk '{print $8}')
21
        cpu_wait=$(echo "$cpu_line" | awk '{print $10}')
22

23
        mem_info=$(free -k | grep Mem:)
24
        mem_total=$(echo "$mem_info" | awk '{print $2}')
25
        mem_avail=$(echo "$mem_info" | awk '{print $7}')
26
        swap_used=$(free -k | grep Swap: | awk '{print $3}')
27

28
        echo "${ts},${cpu_user},${cpu_sys},${cpu_idle},${cpu_wait},${mem_total},${mem_avail},${swap_used}"
29
        sleep 30
30
    done
31
) > "${PREFIX}_cpu_mem.csv" &
32
MONITOR_PID=$!
33

34
# 2. 磁盘使用（每5分钟）
35
(
36
    echo "timestamp,path,used_percent,avail_gb"
37
    while true; do
38
        ts=$(date +%s)
39
        df -h /data /tmp / | tail -n +2 | while read -r fs size used avail pct mnt; do
40
            echo "${ts},${mnt},${pct%\%},${avail}"
41
        done
42
        sleep 300
43
    done
44
) > "${PREFIX}_disk.csv" &
45
DISK_PID=$!
46

47
# 3. 进程快照（每10分钟）
48
(
49
    while true; do
50
        echo "=== $(date) ==="
51
        ps aux --sort=-%mem | head -16
52
        echo ""
53
        sleep 600
54
    done
55
) > "${PREFIX}_processes.log" &
56
PROC_PID=$!
57

58
# ========== 主流程（替换成你的实际流程） ==========
59
echo "Starting main pipeline at $(date)" | tee "${PREFIX}_events.log"
60

61
# 这里放你的实际生信流程
62
# fastp -i ... -I ... -o ... -O ...
63
# bwa mem ... | samtools sort ...
64
# bcftools mpileup ...
65

66
echo "Pipeline finished at $(date)" | tee -a "${PREFIX}_events.log"
67

68
# ========== 停止监控 ==========
69
kill ${MONITOR_PID} ${DISK_PID} ${PROC_PID} 2>/dev/null || true
70
wait ${MONITOR_PID} ${DISK_PID} ${PROC_PID} 2>/dev/null || true
71

72
echo "Monitoring logs saved to: ${LOG_DIR}/"
73
echo "  CPU/Memory: ${PREFIX}_cpu_mem.csv"
74
echo "  Disk:       ${PREFIX}_disk.csv"
75
echo "  Processes:  ${PREFIX}_processes.log"
76
echo "  Events:     ${PREFIX}_events.log"
77

78
# 快速汇总
79
echo ""
80
echo "=== Resource Summary ==="
81
echo "Peak memory usage:"
82
grep -v timestamp "${PREFIX}_cpu_mem.csv" | \
83
    awk -F, '{avail=$7/1048576; if(max_used_mb=="") max_used_mb=($6-$7); if(($6-$7)>max_used_mb) max_used_mb=($6-$7)} END {printf "  Max used: %.1f GB\n", max_used_mb/1048576}'
84
echo "Min available memory:"
85
grep -v timestamp "${PREFIX}_cpu_mem.csv" | \
86
    awk -F, '{if(min_avail=="" || $7<min_avail) min_avail=$7} END {printf "  Min avail: %.1f GB\n", min_avail/1048576}'

展开收起

这个脚本在流程运行时后台持续记录所有资源指标。跑完后打开 CSV 用 Excel/R 画个图，给导师汇报时还能附上”计算资源消耗分析”。

6. 踩坑记录#

坑1：`top` 的 `%MEM` 包含了共享内存#

症状：所有进程 %MEM 加起来远超 100%。

原因：top/ps 的 %MEM 基于 RSS（常驻内存），而多个进程共享的库（如 libc、libm）被重复计算。

Terminal window

1
# 更准确的物理内存占用：
2
smem -t -k   # 需要安装 smem
3
# PSS (Proportional Set Size) 才是进程独有的内存

坑2：`free` 看到 `available` 很大但进程报 OOM#

症状：free -h 显示 100GB available，但程序还是 OOM 了。

原因：可能是 cgroup 限制（Docker/Slurm 等容器环境）。

Terminal window

1
# 检查 cgroup 限制
2
cat /sys/fs/cgroup/memory/memory.limit_in_bytes
3
# 如果是某个小于物理内存的值——找到罪魁祸首了

坑3：`ncdu` 扫描 `/` 根目录耗时太久#

症状：ncdu / 跑了 10 分钟还没完。

Terminal window

1
# 排除挂载的外部存储
2
ncdu -x /     # -x: 不跨越文件系统边界
3

4
# 或先快速找大目录
5
du -h --max-depth=1 / 2>/dev/null | sort -rh | head -20
6
# 然后再 ncdu 进那个大目录

坑4：`htop` 里看不到所有 CPU 核心#

症状：128 核的服务器，htop 只显示了几行 CPU 条。

在 htop 里按 F2 → Display options → 勾选 Detailed CPU time，或者用 htop -C 把每个核显示为竖条。

其实另一个更简单的选择：

Terminal window

1
# 显示所有核心的负载
2
mpstat -P ALL 1

坑5：`iostat` 的 `%util` 100% 不代表磁盘真满了#

症状：NVMe SSD 上 %util 显示 100%，但实际吞吐远没到标称值。

原因：%util 反映的是”至少有一个 IO 请求在处理的时间占比”。对于能并发处理的 NVMe，100% 不一定意味着饱和。更应该看 await 和 aqu-sz。对于 NVMe：

real_saturation≈IOPScurrentIOPSrated×throughputcurrentthroughputratedreal\_saturation \approx \frac{IOPS_{current}}{IOPS_{rated}} \times \frac{throughput_{current}}{throughput_{rated}}real_saturation≈IOPSratedIOPScurrent×throughputratedthroughputcurrent

坑6：`du` 和 `df` 显示不一致#

症状：df 说磁盘满了，du 只统计出一半。

最常见原因：文件被删除但进程还持有文件句柄。

Terminal window

1
# 找出那些"幽灵"文件
2
lsof +L1 | grep deleted
3
# 或者
4
lsof | grep '(deleted)'
5

6
# 重启持有这些句柄的进程就能释放空间

坑7：`nmon` 记录数据但不能实时看#

症状：nmon -f 只生成了文件，不知道怎么实时打开。

Terminal window

1
# 实时模式（不加 -f）
2
nmon
3

4
# 或者让 nmon 同时记录和显示
5
nmon -f -s 30 -c 2880 -m /opt/logs/ &
6
nmon -r /opt/logs/server_*.nmon   # 打开正在写的文件
7

8
# 还有：把 nmon 数据转成网页图表
9
# nmonchart 可以把 .nmon 转成 .html

7. 总结#

监控目标	首选工具	一句话
谁吃了CPU	`htop`	按F6排序CPU，F5看进程树
内存还剩多少	`free -h`	看available不是free
谁在吃内存	`ps aux --sort=-%mem`	前5名
磁盘IO谁在跑	`sudo iotop -o`	一目了然
磁盘用满了没	`df -h; ncdu`	df看全局, ncdu找元凶
长期趋势	`nmon -f`	跑完用nmonchart出图
文件被删但空间没释放	`lsof +L1`	找deleted文件

监控不是一次性工作，把它嵌到每个流程脚本里去。多花 5 行 Bash 写监控，可能省下 5 小时的调试时间——这是我崩了三台服务器后悟出来的道理。

本文于 2025-11-10 在 Debian 13 服务器上实测。htop 3.3.0, iotop 1.26, nmon 16q, sysstat 12.7.6。

正则表达式：FASTA解析、日志提取、awk/sed

Fri, 10 Oct 2025 00:00:00 GMT

生信数据大多是纯文本——FASTA、FASTQ、SAM、GFF、BED、VCF。正则表达式是处理这些文本格式的最短路径。一行 sed 或 grep 即可替代十几步骤的手工操作。本文覆盖生信中的正则实战：FASTA 序列头解析、FASTQ 质量提取、GFF 注释挖掘、日志错误提取、awk/sed 替换。

实测环境：Debian 13，GNU grep 3.11，GNU sed 4.9，GNU awk 5.3。

1. 正则基础——只用这 10 个元字符#

不用学全。生信中 90% 的场景只需要这 10 个：

元字符	含义	生信示例
`.`	任意单个字符	`chr.` 匹配 chr1, chr2, chrX…
`*`	前一个字符重复0次或多次	`A*` 匹配空、A、AA、AAA…
`+`	前一个字符重复1次或多次	`[AT]+` 匹配序列
`?`	前一个字符可选	`chr?1` 匹配 chr1 或 ch1
`^`	行首	`^>` 匹配 FASTA 头
`$`	行尾	`fastq.gz$` 文件名尾
`[]`	字符集	`[ATCG]` 匹配任一碱基
`[^]`	排除字符集	`[^>]` 匹配非>字符
`()`	捕获组	`>(\w+)` 提取序列名
`\|`	或	`fastq\|fq` 两种后缀
`\s`	空白字符	匹配空格、tab
`\w`	单词字符	`[a-zA-Z0-9_]`

1.1 BRE vs ERE vs PCRE——别混用#

Linux 文本工具对正则的支持不一样：

工具	默认模式	用 `+` 需要	用 `()` 需要
`grep`	BRE（基本正则）	`\+`	``
`grep -E`	ERE（扩展正则）	`+`	`()`
`grep -P`	PCRE（Perl兼容）	`+`	`()`
`sed`	BRE	`\+`	``
`sed -E`	ERE	`+`	`()`
`awk`	ERE	`+`	`()`

踩坑最多的是 grep 和 sed 默认是 BRE。 我现在的习惯是：grep 一律加 -P（PCRE），sed 一律加 -E。因为生信正则里 +、?、| 太常用，不想每次转义。

2. FASTA/FASTQ 格式——序列文件的正则操作#

2.1 解析 FASTA 序列头#

NCBI RefSeq 的 FASTA 头和 ENSEMBL 的完全不同：

1
# NCBI RefSeq
2
>NM_001126114.2 Homo sapiens tumor protein p53 (TP53), mRNA
3
>NC_000001.11 Homo sapiens chromosome 1, GRCh38.p14
4

5
# ENSEMBL
6
>ENST00000269305.9 cdna chromosome:GRCh38:17:7661779:7687538:1
7
>ENSG00000141510 gene_biotype:protein_coding
8

9
# UCSC
10
>chr1_1000_2000

用正则提取各种 FASTA 头的关键字段：

Terminal window展开收起

1
# ===== 从不同类型FASTA头中提取信息 =====
2

3
# NCBI：提取 accession、物种、基因名
4
grep '^>' refseq.fasta | sed -E 's/^>([^ ]+) ([^ ]+) (.+)/ACCN=\1 SPECIES=\2 DESC=\3/'
5

6
# 输出：ACCN=NM_001126114.2 SPECIES=Homo DESC=sapiens tumor protein p53 (TP53), mRNA
7

8
# ENSEMBL：提取转录本ID、染色体、坐标
9
grep '^>' ensembl.fasta | grep -oP '>(ENST\d+)'                    # 转录本ID
10
grep '^>' ensembl.fasta | grep -oP 'chromosome:[^:]+:([0-9]+)'     # 坐标
11

12
# UCSC：提取染色体和区间
13
grep '^>' ucsc.fasta | grep -oP '>(chr\w+)_(\d+)_(\d+)'
14
# 用 sed 分别提取
15
sed -n 's/^>\(chr\w\+\)_\([0-9]\+\)_\([0-9]\+\)/CHROM=\1 START=\2 END=\3/p' ucsc.fasta

展开收起

2.2 序列碱基统计——不用 seqkit 也能快速检查#

Terminal window

1
# 统计 ATGC 组成（去掉序列头行）
2
grep -v '^>' sequence.fasta | fold -w1 | sort | uniq -c
3

4
# 输出示例：
5
#  15234 A
6
#   9876 C
7
#  10021 G
8
#  14892 T
9
#      3 N       ← 有3个不确定碱基，注意！
10

11
# 计算 GC 含量
12
total=$(grep -v '^>' sequence.fasta | tr -d '\n' | wc -c)
13
gc=$(grep -v '^>' sequence.fasta | tr -d '\n' | grep -oP '[GCgc]' | wc -l)
14
echo "GC content: $(echo "scale=2; $gc * 100 / $total" | bc)%"

GCGC\\% = \\frac{G + C}{A + T + G + C} \\times 100\\%GC

2.3 FASTQ 质量线提取#

FASTQ 每 4 行一组：@header / sequence / + / quality。提取质量信息：

Terminal window展开收起

1
# 提取所有质量行（每4行的第4行）
2
awk 'NR % 4 == 0' sample.fastq | head -5
3

4
# 统计 Q>30 的碱基比例（质量字符 ASCII-33=Q值）
5
awk 'NR % 4 == 0 {
6
    len = length($0)
7
    for (i = 1; i <= len; i++) {
8
        q = ord(substr($0, i, 1)) - 33
9
        if (q >= 30) q30++
10
        total++
11
    }
12
}
13
END {
14
    printf("Q30: %.1f%% (%d/%d)\n", q30*100/total, q30, total)
15
}
16
function ord(c) { return index("!\"#$%&\047()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~", c) + 32 }
17
' sample.fastq

展开收起

当然，生产环境用 seqkit stats 或 fastp 更快，但理解这个正则逻辑能帮你在没有专用工具时自救。

3. GFF/GTF 注释文件的挖掘#

GFF（General Feature Format）是基因注释的标准格式。9 列，tab 分隔：

1
chr1  HAVANA  gene  11869  14409  .  +  .  gene_id=ENSG00000223972;gene_name=DDX11L1
2
chr1  HAVANA  exon  11869  12227  .  +  .  gene_id=ENSG00000223972;transcript_id=ENST00000456328

3.1 提取特定类型——如所有 exon#

Terminal window

1
grep '\texon\t' annotation.gtf | head -5

\t 是你最好的朋友——GFF/GTF 全是 tab 分隔，用 \t 精确匹配列，避免 exon 出现在第 9 列注释里被误匹配。

3.2 从第9列提取关键字段#

GFF 第 9 列用 ; 分隔键值对。提取所有基因的 gene_id 和 gene_name：

Terminal window

1
# 从 GTF 中提取基因的 ID 和名称
2
grep '\tgene\t' annotation.gtf | \
3
    grep -oP 'gene_id "([^"]+)"|gene_name "([^"]+)"' | \
4
    paste - - | \
5
    sed 's/gene_id "//g;s/"//g;s/gene_name "//g;s/"\t/ /g'

分解这个管道：

grep '\tgene\t' → 只取 gene 行
grep -oP 'gene_id "([^"]+)"|gene_name "([^"]+)"' → 只输出匹配部分（-o = only matching）
paste - - → 把两行（gene_id、gene_name）合并到一行
sed → 清理引号

输出：

1
ENSG00000223972 DDX11L1
2
ENSG00000227232 WASH7P
3
ENSG00000278267 MIR6859-1

3.3 awk 解析 GFF 的复杂统计#

Terminal window展开收起

1
# 统计每个染色体上各类 feature 的数量
2
awk -F'\t' '$3 == "gene" {
3
    split($9, attrs, ";")
4
    for (a in attrs) {
5
        if (attrs[a] ~ /gene_biotype/) {
6
            split(attrs[a], bt, " ")
7
            gsub(/"/, "", bt[2])
8
            count[$1][bt[2]]++
9
        }
10
    }
11
}
12
END {
13
    for (chr in count) {
14
        for (bt in count[chr]) {
15
            print chr, bt, count[chr][bt]
16
        }
17
    }
18
}' annotation.gtf | sort -k1,1 -k3,3rn | head -20

展开收起

这里用到的正则 ~ /gene_biotype/ 是 awk 的语法糖，等价于 match。

4. 日志解析——从生信流程日志中提取关键信息#

4.1 提取比对率#

STAR、BWA、HISAT2 的输出日志都有比对率信息，但格式各不同：

Terminal window

1
# STAR 日志
2
grep -oP 'Uniquely mapped reads % \| \K[0-9.]+' star_Log.final.out
3

4
# BWA 日志（从 stderr）
5
bwa mem ... 2>&1 | grep -oP '[0-9.]+%'
6

7
# HISAT2 日志
8
grep -oP 'overall alignment rate: \K[0-9.]+%' hisat2.log

\K 是 PCRE 的特性：丢弃 \K 左边匹配的内容，只保留右边。非常方便。

4.2 批量提取所有样本的比对率——一行搞定#

Terminal window

1
# 假设每个样本的 STAR 日志在 logs/SAMPLE_Log.final.out
2
for log in logs/*_Log.final.out; do
3
    sample=$(basename "$log" _Log.final.out)
4
    rate=$(grep -oP 'Uniquely mapped reads % \| \K[0-9.]+' "$log")
5
    echo "$sample $rate"
6
done

4.3 从 fastp JSON 报告提取过滤率（用 jq + 正则）#

Terminal window

1
# fastp JSON 里过滤统计
2
jq -r '.summary.before_filtering.total_reads, .summary.after_filtering.total_reads' fastp_report.json
3

4
# 计算过滤率
5
before=$(jq '.summary.before_filtering.total_reads' fastp_report.json)
6
after=$(jq '.summary.after_filtering.total_reads' fastp_report.json)
7
python3 -c "print(f'Filter rate: {(1 - $after/$before)*100:.1f}%')"

4.4 从命令行历史中提取你常用的长命令#

Terminal window

1
# 找出过去一周用得最多的10个生信命令（要求：命令长度>30字符）
2
history | sed -E 's/^[ ]*[0-9]+[ ]+//' | \
3
    grep -P '^.{30,}' | \
4
    sort | uniq -c | sort -rn | head -10

5. 实用 Python 正则#

Shell 正则够用但长文本处理有时力不从心。Python 的 re 模块配合命名捕获组（named groups）更清晰：

1
#!/usr/bin/env python3
2
"""regex bioinfo examples - Python re module"""
3

4
import re
5

6
# ===== 1. 解析 FASTA 头（各种格式） =====
7
fasta_headers = [
8
    ">NM_001126114.2 Homo sapiens tumor protein p53 (TP53), mRNA",
9
    ">ENST00000269305.9 cdna chromosome:GRCh38:17:7661779:7687538:1",
10
    ">chr1_1000_2000",
11
    ">ENSG00000141510|TP53|protein_coding",
12
]
13

14
# 模式1：NCBI RefSeq
15
ncbi_pattern = re.compile(
16
    r'>(?P<accession>[A-Z]+_\d+(?:\.\d+)?) '
17
    r'(?P<species>\w+ \w+) '
18
    r'(?P<description>.+)'
19
)
20

21
# 模式2：ENSEMBL 转录本
22
ensembl_transcript = re.compile(
23
    r'>(?P<transcript_id>ENST\d+(?:\.\d+)?) '
24
    r'.*chromosome:(?P<build>\w+):(?P<chr>\w+):(?P<start>\d+):(?P<end>\d+)'
25
)
26

27
# 模式3：UCSC 坐标
28
ucsc_pattern = re.compile(
29
    r'>(?P<chrom>chr\w+)_(?P<start>\d+)_(?P<end>\d+)'
30
)
31

32
for header in fasta_headers:
33
    for pattern in [ncbi_pattern, ensembl_transcript, ucsc_pattern]:
34
        m = pattern.match(header)
35
        if m:
36
            print(f"Matched: {m.groupdict()}")
37
            break
38
    else:
39
        print(f"No match: {header}")

展开收起

输出：

1
Matched: {'accession': 'NM_001126114', 'species': 'Homo sapiens',
2
          'description': 'tumor protein p53 (TP53), mRNA'}
3
Matched: {'transcript_id': 'ENST00000269305', 'build': 'GRCh38',
4
          'chr': '17', 'start': '7661779', 'end': '7687538'}
5
Matched: {'chrom': 'chr1', 'start': '1000', 'end': '2000'}
6
No match: >ENSG00000141510|TP53|protein_coding

5.1 从 VCF 提取变异信息#

1
# ===== 2. 解析 VCF 行 =====
2
vcf_line = "chr1\t123456\trs123\tA\tG\t100\tPASS\tDP=50;AF=0.35\tGT:AD:DP\t0/1:20,10:30"
3

4
# VCF 格式（8列固定 + 第9列INFO + 样本列）
5
vcf_pattern = re.compile(r'''
6
    ^(?P<chrom>\S+)\t
7
    (?P<pos>\d+)\t
8
    (?P<id>\S+)\t
9
    (?P<ref>[ATCG]+)\t
10
    (?P<alt>[ATCG,]+)\t
11
    (?P<qual>\S+)\t
12
    (?P<filter>\S+)\t
13
    (?P<info>.+?)(?:\t|$)
14
''', re.VERBOSE)
15

16
m = vcf_pattern.match(vcf_line)
17
if m:
18
    info = dict(kv.split('=') for kv in m.group('info').split(';') if '=' in kv)
19
    print(f"Variant: {m.group('chrom')}:{m.group('pos')} "
20
          f"{m.group('ref')}>{m.group('alt')}")
21
    print(f"  DP={info.get('DP', 'N/A')}, AF={info.get('AF', 'N/A')}")

展开收起

5.2 批量 GTF 第9列解析#

1
# ===== 3. 解析 GTF 第9列属性 =====
2
gtf_attr = 'gene_id "ENSG00000223972"; gene_version "5"; '\
3
           'gene_name "DDX11L1"; gene_source "havana"; gene_biotype "transcribed_unprocessed_pseudogene";'
4

5
# 把键值对提取为字典
6
attr_dict = dict(re.findall(r'(\w+) "([^"]+)"', gtf_attr))
7
print(attr_dict)
8
# {'gene_id': 'ENSG00000223972', 'gene_version': '5',
9
#  'gene_name': 'DDX11L1', 'gene_source': 'havana',
10
#  'gene_biotype': 'transcribed_unprocessed_pseudogene'}
11

12
# 获取特定属性
13
gene_id = attr_dict.get("gene_id", "N/A")
14
gene_name = attr_dict.get("gene_name", "N/A")
15
biotype = attr_dict.get("gene_biotype", "N/A")

展开收起

正则 (\w+) "([^"]+)" 的解读：

(\w+) → 捕获属性名（如 gene_id）
"([^"]+)" → 捕获双引号内的值

6. sed 实战——生信中的数据清洗#

6.1 批量修改文件名（在文本列表里）#

Terminal window

1
# 把样本列表从 "/path/to/S01_R1.fastq.gz" 改成 "S01"
2
sed -E 's|.*/(S[0-9]+)_R1\.fastq\.gz|\1|' file_list.txt

6.2 去 FASTA 文件的换行（不规范的FASTA）#

Terminal window

1
# 有的FASTA每行碱基数不同，需要标准化为每行60个
2
# 1. 先变成单行序列
3
awk '/^>/ {if (seq) print seq; print; seq=""; next}
4
     {seq=seq $0}
5
     END {if (seq) print seq}' input.fasta > oneline.fasta
6

7
# 2. 再把非头行按60字符折行
8
fold -w 60 oneline.fasta > formatted.fasta

6.3 批量清理日志中的 ANSI 颜色码#

Terminal window

1
# 从程序输出中去掉颜色码（\033[...m）
2
sed -E 's/\x1b\[[0-9;]*m//g' program.log > clean.log

7. 踩坑记录#

坑1：贪婪匹配 vs 非贪婪匹配#

这是正则里最常见的坑。生信中特别容易在解析 FASTA 头时碰到：

Terminal window

1
# 贪婪匹配（默认）——会吃太多
2
echo ">geneA description; geneB description" | grep -oP '>.*;'
3
# 输出：>geneA description; geneB description;  ← 吃了整行！
4

5
# 非贪婪匹配——加 ?
6
echo ">geneA description; geneB description" | grep -oP '>.*?;'
7
# 输出：>geneA description;  ← 正确停在第一个分号

quantifier_greedy⇒maximal match，quantifier_lazy⇒minimal matchquantifier\_greedy \Rightarrow maximal\ match， quantifier\_lazy \Rightarrow minimal\ matchquantifier_greedy⇒maximal match，quantifier_lazy⇒minimal match

.* = 尽可能多匹配，.*? = 尽可能少匹配。解析分隔符分隔的文本时，一律用非贪婪 .*?（或 [^分隔符]+）。

坑2：`grep` 不带 `-P` 时 `\d` 不生效#

Terminal window

1
# 用 grep（默认 BRE）找数字
2
grep '\d+' file.txt       # 不匹配！BRE 不认识 \d
3

4
# 正确做法
5
grep -P '\d+' file.txt    # PCRE 模式
6
grep -E '[0-9]+' file.txt # ERE 模式用传统字符集

注意： \d、\w、\s 这些简写只在 PCRE 里有效。grep 和 sed 默认不认。

坑3：`sed` 中 `-E` 和 `\1` 的配合#

Terminal window

1
# 错误：-E 模式下引用捕获组仍用 \1
2
sed -E 's/>(ENSG[0-9]+).*/Gene: \1/'   # 正确
3

4
# 不要写成 $1（那是 Perl 的语法）
5
sed -E 's/>(ENSG[0-9]+).*/Gene: $1/'   # 错误！sed 用 \1

坑4：跨行匹配——grep 天生只在一行内匹配#

Terminal window

1
# 你用 grep 找跨两行的模式——永远找不到
2
grep 'START.*END' file.txt  # 只匹配 START 和 END 在同一行
3

4
# 跨行匹配用 pcregrep 或 awk
5
pcregrep -M 'START\n.*END' file.txt
6

7
# 或者用 awk
8
awk '/START/,/END/' file.txt

这个坑在处理带换行的 FASTA 序列时最常见。比如你想找包含特定 motif 的序列，但这个 motif 恰好在换行边界。建议先把 FASTA 转成单行再匹配。

坑5：过度使用 `.*` 导致灾难性回溯（catastrophic backtracking）#

1
# 这个正则看起来无害但能在特定输入上卡死几分钟
2
import re
3
pattern = re.compile(r'(A+)+B')
4
text = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC"  # 没有 B
5
pattern.match(text)  # 可能卡死！回溯次数指数级增长

生信里如何避免： 当重复模式（如 [ATCG]+）嵌套使用时，用 (?> ... ) 原子组（atomic group）或改用 finditer() 而不是 match()。

1
# 安全写法
2
pattern = re.compile(r'A+B')  # 别嵌套重复

8. 生信正则速查表#

场景	正则	工具
匹配 FASTA 头	`^>`	`grep '^>'`
非 FASTA 头行	`^[^>]`	`grep -v '^>'`
提取 NCBI accession	`>(\w+_\d+(\.\d+)?)`	`grep -oP`
提取 ENSEMBL ID	`ENS[GT]\d{11}`	`grep -oP`
GTF tab 分隔列	`\t`	`awk -F'\t'`
GTF 第9列属性	`(\w+) "([^"]+)"`	`grep -oP`
匹配质量字符（Q≥30）	`[?@A-I]`（以 ! = 0 为准）	`grep -oP`
染色体名	`chr(\w+)`	`grep -oP`
基因组坐标	`(\d+)[-:](\d+)`	`sed -E`
日志百分比	`([0-9]+(?:\.[0-9]+)?)%`	`grep -oP`
非贪婪匹配	`.*?`	PCRE
提取 tab 文件第n列	`cut -f n`（比正则简单）	`cut`

9. 总结#

正则不是学一次就会的。我用了五年，每次碰到新格式还是会查手册。但有几个路径能帮你少走弯路：

先用简单命令验证——grep -c 看匹配到了多少行，确认没多匹配也没漏
逐步构建正则——先写最简单的 ^>，确认能匹配 FASTA 头；再加 ^>\w+，再加捕获
grep -oP 是最好的调试器——-o 只输出匹配部分，让你直观看到正则到底吃掉了什么
生信专用工具优先——能用 seqkit 就别手写 awk 正则，能用 bedtools 就别手动解析 BED

本文于 2025-10-10 在 Debian 13 上实测完成。GNU grep 3.11, GNU sed 4.9, GNU awk 5.3, Python 3.10。所有正则均在生信数据上实测验证。

jq与csvkit：JSON/CSV数据处理

Thu, 18 Sep 2025 00:00:00 GMT

做生信分析之前有个很容易被忽略的环节：处理元数据。样本表、分组信息、临床数据、API 返回的 JSON……这些”边角料”往往占据分析 30% 的时间。很多人习惯打开 Python 写 pandas.read_csv()，但对于快速查看、过滤、转换——命令行工具快得多。

本文介绍两个命令行工具：jq 处理 JSON，csvkit 处理 CSV/TSV。无需启动 Python/R 即可完成大部分数据清洗工作——过滤、转换、统计、合并。

实测环境：Debian 13，jq 1.7.1，csvkit 2.0.1。

1. jq——JSON 处理的瑞士军刀#

1.1 安装与第一印象#

Terminal window

1
sudo apt install jq -y
2
jq --version
3
# jq-1.7.1

生信里 JSON 无处不在：NCBI E-utilities 返回 JSON，Ensembl REST API 返回 JSON，各种工具的配置文件（Nextflow、Snakemake 的参数）也是 JSON。直接 cat 看是灾难，jq 是解药。

Terminal window

1
# 美化输出
2
curl -s "https://rest.ensembl.org/lookup/id/ENSG00000139618?expand=1" \
3
    -H "Content-Type: application/json" | jq '.'
4
# 彩色、缩进、一目了然

1.2 基础过滤——点号路径访问#

jq 的过滤表达式就是它的核心语法：

Terminal window展开收起

1
# 假设有一个 JSON 文件 samples.json
2
# [
3
#   {"sample": "S1", "condition": "treated", "reads": 35000000, "qc": "PASS"},
4
#   {"sample": "S2", "condition": "control", "reads": 28000000, "qc": "PASS"},
5
#   {"sample": "S3", "condition": "treated", "reads": 15000000, "qc": "FAIL"}
6
# ]
7

8
# 提取所有样本名
9
jq '.[].sample' samples.json
10

11
# 提取 treated 组的样本
12
jq '.[] | select(.condition == "treated")' samples.json
13

14
# 提取 reads > 20000000 的样本
15
jq '.[] | select(.reads > 20000000)' samples.json
16

17
# 同时过滤多个条件
18
jq '.[] | select(.condition == "treated" and .qc == "PASS")' samples.json

展开收起

1.3 数据转换——从 JSON 到 TSV#

Terminal window

1
# 提取多个字段并输出为 TSV（生信最常用操作）
2
jq -r '.[] | [.sample, .condition, .reads] | @tsv' samples.json
3
# -r = raw output（不加引号）
4
# @tsv 把数组转为 tab 分隔
5

6
# 加表头
7
echo -e "sample\tcondition\treads"
8
jq -r '.[] | [.sample, .condition, .reads] | @tsv' samples.json

1.4 实战：处理 Ensembl REST API 返回#

Terminal window

1
# 查询基因 BRCA2 的信息
2
curl -s "https://rest.ensembl.org/lookup/symbol/homo_sapiens/BRCA2?expand=1" \
3
    -H "Content-Type: application/json" \
4
    | jq '{id: .id, name: .display_name, chr: .seq_region_name, start: .start, end: .end, strand: .strand}'

1.5 数组和对象操作#

Terminal window展开收起

1
# 统计数组长度
2
jq 'length' samples.json
3

4
# 按条件分组
5
jq 'group_by(.condition)' samples.json
6

7
# 对某字段求和
8
jq '[.[].reads] | add' samples.json
9

10
# 计算平均值
11
jq '[.[].reads] | add / length' samples.json
12

13
# 去重
14
jq '[.[].condition] | unique' samples.json
15

16
# 排序
17
jq 'sort_by(.reads) | reverse' samples.json

展开收起

1.6 处理嵌套 JSON——生信最常见难题#

NCBI E-utilities 返回的 JSON 往往嵌套很深：

Terminal window

1
# NCBI esummary 返回的 JSON 结构复杂
2
# 直接用 jq 层层深入
3
curl -s "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=nuccore&id=NM_000059&retmode=json" \
4
    | jq '.result.uids[] as $uid | .result[$uid] | { accession: .accessionversion, title: .title, length: .slen }'

1.7 变量和函数#

Terminal window

1
# 使用变量
2
jq --arg cond "treated" '.[] | select(.condition == $cond)' samples.json
3

4
# 自定义函数
5
jq 'def mb: . / 1000000; .[] | {sample: .sample, reads_m: (.reads | mb)}' samples.json

2. csvkit——命令行里的 Excel#

2.1 安装#

Terminal window

1
# 通过 pip 安装（推荐在 conda 环境里）
2
pip install csvkit
3
# 或用 conda
4
conda install -c conda-forge csvkit

csvkit 是一套工具集，核心命令：

命令	功能	类比 Excel
`csvlook`	格式化查看 CSV	打开文件看
`csvcut`	选择列	删除/隐藏列
`csvgrep`	按模式过滤行	筛选器
`csvsort`	排序	排序功能
`csvstat`	统计摘要	描述性统计
`csvjoin`	关联两个表	VLOOKUP
`csvstack`	纵向合并多个表	追加行
`in2csv`	转换 Excel 到 CSV	另存为

2.2 快速查看——csvlook#

Terminal window

1
# 用 csvlook 美美地看 TSV/CSV
2
cat clinical_data.tsv | csvlook -t
3
# -t 指定 tab 分隔
4

5
# 只显示前10行（和 | head 类似但保留表头）
6
csvlook -t clinical_data.tsv | head -11

csvlook 的输出带 Markdown 风格的表格线，很适合粘贴到实验记录里。

2.3 列操作——csvcut#

Terminal window

1
# 查看所有列名（生信里元数据表经常几十列）
2
csvcut -n clinical_data.tsv
3

4
# 只保留指定列
5
csvcut -c sample_id,condition,age,gender clinical_data.tsv | csvlook
6

7
# 按列号选择（第1、3、5列）
8
csvcut -c 1,3,5 clinical_data.tsv
9

10
# 排除某些列
11
csvcut -C patient_notes,raw_data_path clinical_data.tsv
12
# -C = 排除这些列

2.4 过滤行——csvgrep#

Terminal window

1
# 筛选 condition 列等于 "tumor" 的行
2
csvgrep -t -c condition -m "tumor" clinical_data.tsv | csvlook
3

4
# -c 指定列名
5
# -m 匹配模式（支持正则）
6
# -i 反转（排除匹配的行）
7

8
# 正则筛选：样本名以 S 开头后跟数字
9
csvgrep -t -c sample_id -r "^S[0-9]+$" clinical_data.tsv
10

11
# 筛选年龄大于 50 的（需要结合其他工具）
12
# csvgrep 本身不支持数值比较，可以：
13
cat clinical_data.tsv | awk -F'\t' 'NR==1 || $4>50' | csvlook

2.5 排序——csvsort#

Terminal window

1
# 按 reads 数量降序排列
2
csvsort -t -c reads_count -r sample_stats.tsv | csvlook
3
# -r = reverse（降序）
4

5
# 多列排序：先按condition，再按age
6
csvsort -t -c condition,age sample_stats.tsv | csvlook

2.6 统计分析——csvstat#

Terminal window

1
# 一键生成各列统计摘要
2
csvstat -t sample_stats.tsv
3

4
# 输出示例：
5
#   1. "sample_id"
6
#     Type: Text
7
#     Unique values: 48
8
#   2. "reads_count"
9
#     Type: Number
10
#     Min: 12,345,678
11
#     Max: 89,012,345
12
#     Mean: 45,234,567
13
#     Median: 44,100,000
14
#     Std Dev: 15,234,567

生信场景：新拿到一批数据后，先 csvstat 看一眼每个样本的 reads 数是否合理、有无异常值。

2.7 表关联——csvjoin#

Terminal window

1
# 类似 SQL 的 LEFT JOIN
2
# sample_meta.tsv: sample_id, condition, batch
3
# sample_qc.tsv:    sample_id, total_reads, q30_rate
4

5
csvjoin -t -c sample_id sample_meta.tsv sample_qc.tsv | csvlook -t
6

7
# 等价于：
8
# SELECT * FROM sample_meta LEFT JOIN sample_qc ON sample_meta.sample_id = sample_qc.sample_id

2.8 合并多个文件——csvstack#

Terminal window

1
# 纵向拼接（行追加）
2
# batch1_samples.tsv + batch2_samples.tsv → all_samples.tsv
3
csvstack -t batch1_samples.tsv batch2_samples.tsv > all_samples.tsv
4

5
# 如果列不完全一致，用 --filenames 标记来源
6
csvstack --filenames -t data/part_*.tsv > merged.tsv

3. jq + csvkit 组合拳——一条管道搞定数据清洗#

这是生信中最常见的模式：从 API 拉 JSON → 用 jq 提取 → 转 TSV → csvkit 进一步处理：

Terminal window

1
# 完整流程：从 Ensembl API 获取基因列表信息，输出为排序好的表格
2
curl -s "https://rest.ensembl.org/lookup/symbol/homo_sapiens/BRCA1?expand=1" \
3
    -H "Content-Type: application/json" \
4
    | jq -r '{id: .id, name: .display_name, chr: .seq_region_name, start: .start, end: .end} | [.id, .name, .chr, .start, .end] | @tsv' \
5
    | csvsort -t -c 4 | csvlook -t

更复杂的例子——批量查询多个基因：

1
#!/bin/bash
2
# 批量查询基因坐标
3
genes=("BRCA1" "BRCA2" "TP53" "EGFR" "KRAS")
4

5
echo -e "gene\tid\tchr\tstart\tend\tstrand"
6

7
for gene in "${genes[@]}"; do
8
    curl -s "https://rest.ensembl.org/lookup/symbol/homo_sapiens/${gene}?expand=1" \
9
        -H "Content-Type: application/json" \
10
        | jq -r "[.display_name, .id, .seq_region_name, .start, .end, .strand] | @tsv"
11
    sleep 0.5  # API 限速，每秒不超过 15 次请求
12
done | csvsort -t -c 3,4 | csvlook -t

4. 理论解释——为什么 jq 的流式处理这么快#

jq 和 csvkit 都基于流式处理，内存占用与输入大小无关：

Mmemory≈O(1)(流式处理)M_{memory} \approx O(1) \quad \text{(流式处理)}Mmemory≈O(1)(流式处理)

而 Python pandas 加载整个 DataFrame 的内存复杂度为：

Mpandas≈O(n×m)(全量加载)M_{pandas} \approx O(n \times m) \quad \text{(全量加载)}Mpandas≈O(n×m)(全量加载)

对于几十万行的元数据表，pandas 可能吃几个 GB 内存，csvkit 几乎不占内存。缺点是 csvkit 不方便做复杂的数据变换（如标准化），这时候才该切到 Python。

5. 踩坑记录#

坑1：jq 不认带空格的 key。 JSON 的 key 如果包含空格或特殊字符，必须用双引号括起来：.["sample name"] 而不是 .sample name。

坑2：csvkit 默认逗号分隔而非 Tab。 生信数据几乎都是 TSV（tab 分隔），每次都要加 -t。可以在 ~/.bashrc 里设置别名：alias csvlook='csvlook -t'。

坑3：csvgrep 不支持数值比较。 csvgrep -c age -m ">50" 会按字符串匹配。数值过滤需要用 awk 或 csvsql（csvkit 的 SQL 查询工具）。

坑4：jq 的 @csv 和 @tsv 输出格式。 @csv 会用引号包裹含逗号的字段，@tsv 不会。如果字段本身含 tab 或换行符，@tsv 可能出问题。用 @csv 更安全但要注意生信工具通常吃 TSV。

坑5：API 限速被忽略。 Ensembl REST API 限制每秒最多 15 次请求。在循环里狂发 curl 会被封 IP。务必加 sleep 0.5 或用 --limit-rate。

坑6：csvjoin 默认是 INNER JOIN。 如果你想要 LEFT JOIN（保留左表所有行），需要加 --left。我踩过这个坑，丢了没 QC 数据的样本行。

本文于 2025-09-18 在 Debian 13 上实测。

数据备份与rsync实战：增量同步、远程备份、3-2-1策略

Mon, 15 Sep 2025 00:00:00 GMT

生信数据备份遵循 3-2-1 原则：

3 份副本（原始+2份备份）
2 种介质（本地硬盘+远程）
1 份异地（不同物理位置）

1. rsync——增量同步利器#

Terminal window

1
# 基础同步（本地→远程）
2
rsync -avzP /opt/bioinfo/results/ user@192.168.1.100:/backup/results/
3

4
# 参数说明：
5
# -a: 归档模式（保留权限、时间戳）
6
# -v: 详细输出
7
# -z: 传输时压缩
8
# -P: --partial --progress（断点续传+显示进度）
9
# --delete: 删除目标端多余文件（慎用！）

2. 完整备份脚本#

1
#!/bin/bash
2
set -euo pipefail
3

4
BACKUP_SRC="/opt/bioinfo"
5
BACKUP_DST="/mnt/backup/bioinfo_$(date +%Y%m%d)"
6
REMOTE="user@nas-server:/backup/"
7
LOG="/var/log/backup.log"
8

9
log() { echo "[$(date)] $*" | tee -a "$LOG"; }
10

11
log "=== Backup started ==="
12

13
# 本地完整备份（硬链接节省空间）
14
rsync -avzP --link-dest=/mnt/backup/bioinfo_latest \
15
    "$BACKUP_SRC/" "$BACKUP_DST/" >> "$LOG" 2>&1
16

17
# 更新latest链接
18
rm -f /mnt/backup/bioinfo_latest
19
ln -s "$BACKUP_DST" /mnt/backup/bioinfo_latest
20

21
# 远程同步（仅同步变化）
22
rsync -avzP --delete "$BACKUP_SRC/" "$REMOTE" >> "$LOG" 2>&1
23

24
log "=== Backup completed ==="

展开收起

3. tar打包压缩#

Terminal window

1
# 打包+压缩（多线程）
2
tar -I pigz -cf project_backup_$(date +%Y%m%d).tar.gz /opt/bioinfo/project/
3

4
# 排除某些目录
5
tar -czf backup.tar.gz \
6
    --exclude='tmp' \
7
    --exclude='*.fastq' \
8
    /opt/bioinfo/

4. crontab定时备份#

Terminal window

1
# 每天凌晨2点执行
2
0 2 * * * /opt/scripts/backup.sh
3

4
# 每周日凌晨3点清理旧备份（保留最近4周）
5
0 3 * * 0 find /mnt/backup/ -name "bioinfo_*" -mtime +28 -exec rm -rf {} \;

5. 踩坑#

rsync —delete先干跑：加--dry-run看看会删什么
备份要验证：定期 rsync -avnc对比源和目标是否一致
别把备份和原始放同一块硬盘：硬盘坏了全没了

本文于 2025-09-15 实测。

热图可视化：pheatmap与ComplexHeatmap

Sun, 14 Sep 2025 00:00:00 GMT

热图是表达数据可视化最常用的图表类型。pheatmap 提供三行代码出图的基础方案，ComplexHeatmap 则支持高级布局、行列注释和多图拼接，适合发表场景。本文覆盖两个 R 包的数据标准化、配色调色板、注释配置和导出选项。

实测环境：R 4.4.1，pheatmap 1.0.12，ComplexHeatmap 2.18.0，Debian 13。

1. 数据准备——生信热图的数据长什么样#

热图的输入本质就是一张数值矩阵。生信中最常见的场景：

1
# 模拟一个 RNA-seq 表达矩阵：100个基因 × 10个样本
2
set.seed(42)
3
expr_matrix <- matrix(
4
    rnorm(1000, mean = 5, sd = 2),
5
    nrow = 100,
6
    ncol = 10,
7
    dimnames = list(
8
        paste0("Gene", 1:100),
9
        paste0("Sample", 1:10)
10
    )
11
)
12

13
# 人为制造一些差异（让热图有层次感）
14
expr_matrix[1:30, 1:5] <- expr_matrix[1:30, 1:5] + 3   # 前30个基因在前5个样本高表达
15
expr_matrix[71:100, 6:10] <- expr_matrix[71:100, 6:10] + 3  # 后30个基因在后5个样本高表达
16

17
head(expr_matrix[, 1:5])

展开收起

真实场景中这个矩阵来自 DESeq2 的 normalized counts、limma 的差异基因列表、或者 WGCNA 的模块表达值。几行代码就能从 DESeq2 提取：

1
# 从 DESeq2 对象提取标准化表达矩阵
2
# dds <- DESeqDataSetFromMatrix(...)
3
# dds <- DESeq(dds)
4
# vsd <- vst(dds, blind = FALSE)
5
# expr_matrix <- assay(vsd)

2. pheatmap——三行代码出热图#

1
library(pheatmap)
2

3
# 最简单的热图
4
pheatmap(expr_matrix)

就这么简单。但默认参数出来的图有这些问题：基因名太多挤成一团、颜色默认红蓝不太友好、没做行标准化看不出相对差异。

2.1 加上标准化和聚类#

1
pheatmap(expr_matrix,
2
    scale = "row",              # 按行做 Z-score 标准化
3
    cluster_rows = TRUE,        # 行聚类
4
    cluster_cols = TRUE,        # 列聚类
5
    show_rownames = FALSE,      # 基因太多，不显示名字
6
    show_colnames = TRUE,
7
    main = "RNA-seq Expression Heatmap"
8
)

scale = "row" 是生信热图最关键的一个参数。表达式原始值的量级差异很大（基因A表达量 0.5，基因B表达量 5000），不标准化的话热图只能看到少数高表达基因，其他全是暗色。

Z-score 的公式：

zij=xij−μiσiz_{ij} = \frac{x_{ij} - \mu_i}{\sigma_i}zij=σixij−μi

其中 μi\mu_iμi 是基因 iii 在所有样本中的均值，σi\sigma_iσi 是标准差。标准化后每个基因的均值 = 0，标准差 = 1，不同基因之间就”可比”了。

2.2 配色——告别红蓝默认色#

红蓝配色在色盲群体中难以区分，而且生信文献里几乎没人用。主流选择：

1
# 白-橙-红（表达量热图）
2
pheatmap(expr_matrix,
3
    scale = "row",
4
    color = colorRampPalette(c("white", "orange", "red"))(100),
5
    show_rownames = FALSE,
6
    main = "White-Orange-Red"
7
)
8

9
# 蓝-白-红（差异热图，白=不变，蓝=下调，红=上调）
10
pheatmap(expr_matrix,
11
    scale = "row",
12
    color = colorRampPalette(c("navy", "white", "firebrick3"))(100),
13
    show_rownames = FALSE,
14
    main = "Blue-White-Red (common in papers)"
15
)
16

17
# viridis 配色（色盲友好，越来越流行）
18
library(viridis)
19
pheatmap(expr_matrix,
20
    scale = "row",
21
    color = viridis(100),
22
    show_rownames = FALSE,
23
    main = "Viridis (colorblind-friendly)"
24
)

展开收起

colorRampPalette 生成 100 个渐变色阶，越多越平滑。我一般杂志投哪个就用哪个配色，投 Nature 系列可以用 viridis，投 Cell 系列蓝白红更常见。

2.3 添加注释——这张图里最加分的部分#

纯热图只告诉你”这些基因在这些样本里高表达”，加上注释后可以同时展示样本分组、临床信息、突变状态等。

1
# 样本注释（列注释）
2
annotation_col <- data.frame(
3
    Group = factor(rep(c("Control", "Treatment"), each = 5)),
4
    Batch = factor(rep(c("Batch1", "Batch2"), times = 5)),
5
    row.names = paste0("Sample", 1:10)
6
)
7

8
# 基因注释（行注释，比如标记哪些是差异基因）
9
annotation_row <- data.frame(
10
    GeneClass = factor(c(
11
        rep("Oncogene", 30),
12
        rep("Tumor Suppressor", 30),
13
        rep("Other", 40)
14
    )),
15
    row.names = paste0("Gene", 1:100)
16
)
17

18
# 注释配色
19
ann_colors <- list(
20
    Group = c(Control = "#4DBBD5", Treatment = "#E64B35"),
21
    Batch = c(Batch1 = "#00A087", Batch2 = "#7E6148"),
22
    GeneClass = c(Oncogene = "#DC0000", `Tumor Suppressor` = "#3C5488", Other = "#8491B4")
23
)
24

25
pheatmap(expr_matrix,
26
    scale = "row",
27
    color = colorRampPalette(c("navy", "white", "firebrick3"))(100),
28
    annotation_col = annotation_col,
29
    annotation_row = annotation_row,
30
    annotation_colors = ann_colors,
31
    show_rownames = FALSE,
32
    main = "Expression Heatmap with Annotations",
33
    cutree_rows = 3,              # 把行聚类切成3个模块
34
    cutree_cols = 2               # 把列聚类切成2组
35
)

展开收起

cutree_rows 和 cutree_cols 会自动在热图上画出聚类分割线——审稿人看到这条线就知道你做了聚类。

2.4 保存图片#

1
# png 格式
2
png("heatmap.png", width = 8, height = 10, units = "in", res = 300)
3
pheatmap(expr_matrix, scale = "row", show_rownames = FALSE)
4
dev.off()
5

6
# pdf 格式（矢量，适合投稿）
7
pdf("heatmap.pdf", width = 8, height = 10)
8
pheatmap(expr_matrix, scale = "row", show_rownames = FALSE)
9
dev.off()
10

11
# tiff 格式（部分期刊要求）
12
tiff("heatmap.tiff", width = 8, height = 10, units = "in", res = 300)
13
pheatmap(expr_matrix, scale = "row", show_rownames = FALSE)
14
dev.off()

注意 pheatmap 的输出是 grid 对象，不能直接用 ggsave。用基础的 png()/pdf()/tiff() + dev.off() 即可。

3. ComplexHeatmap——进阶玩家的选择#

pheatmap 能应付 80% 的场景，剩下的 20%——比如拼多列热图、自定义图例位置、oncoprint 等——需要 ComplexHeatmap。我一般简单探索用 pheatmap，要发表的图用 ComplexHeatmap。

3.1 基础用法#

1
library(ComplexHeatmap)
2
library(circlize)  # ComplexHeatmap 依赖 circlize 做配色
3

4
Heatmap(expr_matrix,
5
    name = "Expression",              # 图例标题
6
    col = colorRamp2(c(-2, 0, 2), c("navy", "white", "firebrick3")),
7
    row_names_gp = gpar(fontsize = 6),
8
    column_names_gp = gpar(fontsize = 8),
9
    show_row_names = FALSE,
10
    cluster_rows = TRUE,
11
    cluster_columns = TRUE
12
)

colorRamp2 比 colorRampPalette 更精确——你指定断点和对应的颜色，它自动插值。对于 Z-score 标准化数据，c(-2, 0, 2) 覆盖了约 95% 的数据范围。

3.2 添加注释——ComplexHeatmap 的方式#

1
# 列注释
2
column_ha <- HeatmapAnnotation(
3
    Group = annotation_col$Group,
4
    Batch = annotation_col$Batch,
5
    col = list(
6
        Group = c("Control" = "#4DBBD5", "Treatment" = "#E64B35"),
7
        Batch = c("Batch1" = "#00A087", "Batch2" = "#7E6148")
8
    ),
9
    annotation_legend_param = list(
10
        Group = list(title = "Group"),
11
        Batch = list(title = "Batch")
12
    )
13
)
14

15
# 行注释
16
row_ha <- rowAnnotation(
17
    GeneClass = annotation_row$GeneClass,
18
    col = list(GeneClass = c(
19
        "Oncogene" = "#DC0000",
20
        "Tumor Suppressor" = "#3C5488",
21
        "Other" = "#8491B4"
22
    ))
23
)
24

25
Heatmap(expr_matrix,
26
    name = "Z-score",
27
    col = colorRamp2(c(-2, 0, 2), c("navy", "white", "firebrick3")),
28
    top_annotation = column_ha,
29
    right_annotation = row_ha,
30
    show_row_names = FALSE,
31
    column_title = "RNA-seq Expression Heatmap",
32
    column_title_gp = gpar(fontsize = 14, fontface = "bold"),
33
    row_km = 3,                    # k-means 分成3个基因模块
34
    column_km = 2                  # 样本分成2组
35
)

展开收起

ComplexHeatmap 把注释对象化——HeatmapAnnotation 管列注释，rowAnnotation 管行注释，逻辑清晰但代码量确实比 pheatmap 多。

3.3 拼图——ComplexHeatmap 的杀手锏#

多组数据并排展示是 ComplexHeatmap 最强的地方：

1
# 假设你有三个独立的表达矩阵（不同组织或不同处理）
2
set.seed(123)
3
mat1 <- matrix(rnorm(500, 5, 2), 50, 10)
4
mat2 <- matrix(rnorm(500, 5, 2), 50, 10)
5
mat3 <- matrix(rnorm(500, 5, 2), 50, 10)
6

7
rownames(mat1) <- rownames(mat2) <- rownames(mat3) <- paste0("Gene", 1:50)
8

9
# 分别画三张热图然后用 + 拼起来
10
ht1 <- Heatmap(mat1, name = "Tissue1", col = colorRamp2(c(-2,0,2), c("navy","white","red")),
11
               show_row_names = FALSE, column_title = "Normal")
12
ht2 <- Heatmap(mat2, name = "Tissue2", col = colorRamp2(c(-2,0,2), c("navy","white","red")),
13
               show_row_names = FALSE, column_title = "Tumor")
14
ht3 <- Heatmap(mat3, name = "Tissue3", col = colorRamp2(c(-2,0,2), c("navy","white","red")),
15
               show_row_names = FALSE, column_title = "Metastasis")
16

17
# 横向拼接
18
ht1 + ht2 + ht3
19

20
# 保存
21
pdf("multi_heatmap.pdf", width = 15, height = 8)
22
draw(ht1 + ht2 + ht3)
23
dev.off()

展开收起

这个功能在需要展示”同一批基因在不同条件下”的表达模式时特别有用。你还可以用 row_order 让三张热图的基因顺序保持一致。

4. 踩坑记录#

坑1：pheatmap 报错 “margins too large”#

症状：基因名/样本名太多，R 报 figure margins too large。

解决：

1
# 方法1：调小字体
2
pheatmap(expr_matrix, fontsize_row = 4, fontsize_col = 6)
3

4
# 方法2：不显示行名
5
pheatmap(expr_matrix, show_rownames = FALSE)
6

7
# 方法3：增大画布（在 png/pdf 前设置）
8
pdf("heatmap.pdf", width = 20, height = 30)
9
pheatmap(expr_matrix)
10
dev.off()

坑2：scale=“row” 遇到全是相同值的行#

如果某基因在所有样本中表达量完全一样，标准差 = 0，scale("row") 会算出 NaN，热图里的该行是一片灰色。

1
# 排查
2
row_sds <- apply(expr_matrix, 1, sd)
3
table(row_sds == 0)
4

5
# 处理：过滤掉恒定基因，或给标准差加个极小值
6
expr_filtered <- expr_matrix[row_sds > 0.01, ]

实际数据中完全恒定的基因很少见（除非是 spike-in），但低表达基因近似恒定值的蛮多。

坑3：pheatmap 和 ComplexHeatmap 的行列顺序不一致#

两个包的聚类算法参数默认值不同，pheatmap 默认 clustering_method = "complete"，ComplexHeatmap 可以自定义。如果先画了 pheatmap 探索数据，再用 ComplexHeatmap 出图，聚类结果可能不一样。

1
# 统一聚类方法
2
Heatmap(expr_matrix, clustering_method_rows = "complete", clustering_method_columns = "complete")

坑4：ComplexHeatmap 图例标题不显示#

ComplexHeatmap 的图例标题 name 参数和 HeatmapAnnotation 里的 title 是两个东西。如果图例没标题，检查：

1
# Heatmap 的 name 必须设
2
Heatmap(expr_matrix, name = "Expression")  # 正确
3

4
# HeatmapAnnotation 里每个注释单独设 title
5
HeatmapAnnotation(
6
    Group = ...,
7
    annotation_legend_param = list(Group = list(title = "Sample Group"))
8
)

坑5：colorRamp2 颜色看起来不对#

colorRamp2 的颜色插值是线性的，但如果中间断点不对称，颜色过渡会偏：

1
# 不对称断点导致白色不在中间
2
colorRamp2(c(-3, 0, 1), c("blue", "white", "red"))
3
# 白-红区间只有1个单位，蓝-白有3个单位
4

5
# 尽量设对称断点
6
colorRamp2(c(-2, 0, 2), c("blue", "white", "red"))

坑6：中文标签在 PDF 里变成方框#

生信文章虽然以英文为主，但如果你要给国内报告画中文标签：

1
# PDF 里显示中文需要额外指定字体
2
library(showtext)
3
showtext_auto()
4
font_add("SimHei", "/usr/share/fonts/truetype/simhei.ttf")  # 黑体
5

6
# 然后在 Heatmap 里指定
7
Heatmap(expr_matrix,
8
    column_title = "基因表达热图",
9
    column_title_gp = gpar(fontfamily = "SimHei"),
10
    ...
11
)

5. 小结#

需求	推荐工具	代码量	灵活性
快速探索数据	pheatmap	3行	★★☆
加注释出图	pheatmap	15行	★★★
复杂排版拼图	ComplexHeatmap	30行+	★★★★★
发表级单图	两者都可	—	—
oncoprint/UpSet	ComplexHeatmap	—	★★★★★

我的习惯：探索数据时在 RStudio 里用 pheatmap 快速预览，确定分组和配色方案后，用 ComplexHeatmap 出最终版。colorRamp2 + HeatmapAnnotation 的组合基本能满足 95% 的生信热图需求。

配色小抄：

表达量热图：白→橙→红，或 viridis
差异分析热图：蓝→白→红
相关性热图：白→粉→深红
甲基化热图：蓝→黄→红

本文于 2025-09-14 在 Debian 13 + R 4.4.1 上实测完成。pheatmap 1.0.12，ComplexHeatmap 2.18.0。所有代码可直接复制运行。

生信常见报错排查：20条错误与解决方案

Fri, 05 Sep 2025 00:00:00 GMT

生信分析中报错种类繁多——文件权限、内存溢出、软件依赖、流程逻辑。本文按 文件/权限 → 内存/OOM → 软件/依赖 → R/Python → 流程逻辑 分类，整理 20 个常见错误，每条附错误原文、原因分析和解决方案。

全部在 Debian 13 上复现并验证。

一、文件与权限类#

错误1：`Permission denied`#

1
bash: ./run_pipeline.sh: Permission denied

原因： 文件没有执行权限。

排查：

Terminal window

1
ls -la run_pipeline.sh
2
# -rw-r--r-- 1 user user 1234 Mar 1 10:00 run_pipeline.sh
3
#  ^ 没有 x（执行位）

解决：

Terminal window

1
chmod +x run_pipeline.sh

如果是从 Windows 传过来的脚本，还要检查换行符：

Terminal window

1
# 查看是否有 ^M（\r）换行符
2
cat -A run_pipeline.sh | head -5
3

4
# 转换
5
sed -i 's/\r$//' run_pipeline.sh

错误2：`No such file or directory`#

Terminal window

1
$ samtools view -bS alignment.sam
2
[E::hts_open_format] Failed to open file "alignment.sam" : No such file or directory

排查清单（按顺序）：

Terminal window

1
# 1. 文件真的不存在？
2
ls -la alignment.sam
3

4
# 2. 你在正确的目录吗？
5
pwd
6

7
# 3. 文件名拼错了？（大小写！）
8
ls -la Ali*   # 检查是否有大小写差异
9

10
# 4. 路径有空格或特殊字符？
11
# 永远用双引号包裹路径
12
samtools view -bS "alignment.sam"

最常见的原因： 上一步的输出写到了另一个目录，或者文件名带了 _sorted 后缀而你没注意到。

错误3：`No space left on device`#

Terminal window

1
$ gzip raw_data.fastq
2
gzip: raw_data.fastq: No space left on device

排查：

Terminal window

1
df -h .
2
# Filesystem      Size  Used Avail Use% Mounted on
3
# /dev/sda1        97G   93G   0   100% /opt/data
4

5
# 找大文件
6
du -sh /opt/data/* | sort -rh | head -20

解决：

Terminal window

1
# 紧急清理（删除 conda 缓存）
2
conda clean --all -y
3

4
# 清理临时文件
5
rm -rf /tmp/bioinfo_* /tmp/samtools_*
6

7
# 清理旧日志
8
find . -name "*.log" -mtime +30 -delete

错误4：软链接断掉（broken symbolic link）#

Terminal window

1
$ ls -la reference/hg38.fa
2
lrwxrwxrwx 1 user user 42 Mar 1 10:00 reference/hg38.fa -> ../../old_path/hg38.fa
3
# 文件显示红色（在 ls --color 中），说明目标不存在

排查：

Terminal window

1
readlink -f reference/hg38.fa   # 空输出表示断了
2
ls -laL reference/hg38.fa        # -L 会报错如果断了

解决： 重新创建链接或直接放文件副本。

Terminal window

1
# 不要用软链接管理大参考基因组——用硬链接或直接复制
2
ln -f /opt/refs/GRCh38.primary.fa reference/hg38.fa  # 硬链接
3
# 或
4
cp /opt/refs/GRCh38.primary.fa reference/hg38.fa

二、内存与系统资源类#

错误5：`Killed`（OOM Killer）#

1
$ STAR --genomeDir star_index --readFilesIn sample.fastq.gz
2
... running for 2 hours ...
3
Killed

这是 Linux 内核的 OOM（Out of Memory）Killer。当系统内存耗尽时，内核会杀死占用内存最大的进程。

排查：

Terminal window

1
# 事后检查
2
dmesg | grep -i "out of memory" | tail -20
3
dmesg | grep -i "killed process" | tail -10
4

5
# 会看到类似：
6
# Out of memory: Killed process 28473 (STAR) total-vm:52GB ...

解决：

Terminal window

1
# 方案1：加内存（废话但有效）
2
# 方案2：减少线程（线程越多内存越大，不是线性关系！）
3
STAR --runThreadN 4 ...   # 从 16 降到 4
4

5
# 方案3：限制 STAR 内存
6
STAR --limitBAMsortRAM 10000000000 ...  # 限制排序内存 10GB
7

8
# 方案4：用 swap（临时救急）
9
sudo fallocate -l 32G /swapfile
10
sudo chmod 600 /swapfile
11
sudo mkswap /swapfile
12
sudo swapon /swapfile

软件	每线程内存	建议线程数
STAR	~30-40GB (人类)	4-8
HISAT2	~8-10GB	8-16
Bowtie2	~4GB	8-16
BWA-MEM	~6-8GB	8-12

错误6：`Bus error (core dumped)`#

1
$ hisat2 -x genome_index -1 R1.fq -2 R2.fq -S output.sam
2
Bus error (core dumped)

原因： 内存硬件故障或文件读取越界。生信中常见于索引文件损坏。

排查：

Terminal window

1
# 1. 检查索引完整性
2
md5sum genome_index.*.ht2
3
# 与官网提供的 md5 对比
4

5
# 2. 重建索引
6
hisat2-build reference.fa genome_index

错误7：`Too many open files`#

Terminal window

1
$ parallel -j 50 samtools sort ...
2
/bin/bash: error while loading shared libraries: libtinfo.so.6:
3
cannot open shared object file: Too many open files

原因： Linux 限制每个进程可同时打开的文件数（默认 1024）。生信并行任务频繁触发。

解决：

Terminal window

1
# 查看当前限制
2
ulimit -n
3
# 1024
4

5
# 临时提升
6
ulimit -n 65536
7

8
# 永久生效（/etc/security/limits.conf）
9
echo "* soft nofile 65536" | sudo tee -a /etc/security/limits.conf
10
echo "* hard nofile 65536" | sudo tee -a /etc/security/limits.conf

错误8：`GLIBCXX_3.4.30 not found`#

Terminal window

1
$ samtools
2
samtools: /lib/x86_64-linux-gnu/libstdc++.so.6: version `GLIBCXX_3.4.30' not found

原因： Conda 装的包动态链接了新版 libstdc++，但系统里的是旧版。

排查：

Terminal window

1
# 看系统和 conda 各有什么版本的 GLIBCXX
2
strings /usr/lib/x86_64-linux-gnu/libstdc++.so.6 | grep GLIBCXX | tail -5
3
strings $CONDA_PREFIX/lib/libstdc++.so.6 | grep GLIBCXX | tail -5

解决：

Terminal window

1
# 临时：让程序优先用 conda 的库
2
export LD_LIBRARY_PATH=$CONDA_PREFIX/lib:$LD_LIBRARY_PATH
3

4
# 根本：在 conda 环境内装 libstdcxx-ng
5
mamba install -c conda-forge libstdcxx-ng -y

三、软件与依赖类#

错误9：`samtools: command not found`#

Terminal window

1
$ samtools view
2
-bash: samtools: command not found

原因： 没装或环境没激活。

排查三步走：

Terminal window

1
# 1. 检查环境是否激活
2
conda env list | grep '*'
3
# 如果 base 前面没有 *，说明 conda 没 init
4

5
# 2. 用 which 定位
6
which samtools  # 无输出 = 没装
7

8
# 3. 检查是否在正确环境里
9
conda list | grep samtools

错误10：conda 装包卡住 `Solving environment`#

参见 Conda环境冲突全攻略第 7 节。核心解决：

Terminal window

1
# 把 conda 换成 mamba
2
mamba install -c bioconda package_name -y
3

4
# 或者指定精确版本缩小搜索空间
5
mamba install -c bioconda package_name=1.2.3 -y

错误11：pip 覆盖了 conda 的包#

Terminal window

1
$ conda install -c conda-forge numpy
2
$ pip install scikit-learn  # pip 升级了 numpy
3
$ python -c "import numpy; print(numpy.__version__)"
4
# numpy 崩溃或版本回退

解决： 优先用 conda 装所有依赖；必须用 pip 时加 --no-deps：

Terminal window

1
pip install --no-deps scikit-learn

如果已经崩了，重建环境：

Terminal window

1
mamba env remove -n myenv
2
mamba create -n myenv -c conda-forge python=3.10 numpy scipy pandas matplotlib -y
3
pip install --no-deps scikit-learn

错误12：Java 版本不兼容（Picard/GATK）#

Terminal window

1
$ java -jar picard.jar MarkDuplicates ...
2
Error: A JNI error has occurred, please check your installation
3
Exception in thread "main" java.lang.UnsupportedClassVersionError

原因： Picard/GATK 需要特定 Java 版本。Picard 2.27+ 需要 Java 17。

排查：

Terminal window

1
java -version
2
# openjdk version "11.0.21"  <- 太旧了

解决：

Terminal window

1
mamba install -c conda-forge openjdk=17 -y
2
java -version  # 确认版本

四、R 语言类#

错误13：`there is no package called 'xxx'`#

1
> library(DESeq2)
2
Error in library(DESeq2) : there is no package called 'DESeq2'

解决三步走：

1
# 1. 检查是否装过
2
installed.packages()[,"Package"] %>% grep("DESeq2", ., value = TRUE)
3

4
# 2. 没装就装
5
if (!requireNamespace("BiocManager", quietly = TRUE))
6
    install.packages("BiocManager")
7
BiocManager::install("DESeq2")
8

9
# 3. 确认 .libPaths()——你可能装了但 R 找不到
10
.libPaths()
11
# 如果 conda 环境里的 R 在用系统的 library path，修正：
12
# export R_LIBS_USER=$CONDA_PREFIX/lib/R/library

错误14：`cannot allocate vector of size X Gb`#

1
> deseq2_results <- DESeq(dds)
2
Error: cannot allocate vector of size 8.5 Gb

原因： R 默认把所有数据装入内存。

解决：

Terminal window

1
# 方案1：写一个 swap 文件（给 Linux 额外虚拟内存）
2
sudo fallocate -l 32G /swapfile
3
sudo mkswap /swapfile && sudo swapon /swapfile
4

5
# 方案2：减少数据量（预过滤低表达基因）
6
keep <- rowSums(counts(dds) >= 10) >= 3
7
dds <- dds[keep, ]
8

9
# 方案3：用内存友好的替代
10
# Seurat 用 BPCells，DESeq2 没有——只能加内存或过滤

错误15：R 版本与包不兼容#

1
> install.packages("tidyverse")
2
ERROR: this R is version 4.2.3, package 'tidyverse' requires R >= 4.3

解决：

Terminal window

1
# conda 环境里升级 R
2
mamba install -c conda-forge r-base=4.3 -y
3

4
# 或者用 conda 装匹配版本的包（conda 会处理好 R 版本）
5
mamba install -c conda-forge r-tidyverse -y

错误16：Bioconductor 版本不匹配#

1
> BiocManager::install("DESeq2")
2
Error: Bioconductor version 3.16 (R 4.2) is not compatible with R 4.3

解决：

1
# 升级 Bioconductor 到与 R 匹配的版本
2
BiocManager::install(version = "3.18")  # R 4.3 对应 3.18
3

4
# 对照表：
5
# R 4.2 → Bioc 3.16
6
# R 4.3 → Bioc 3.18
7
# R 4.4 → Bioc 3.19

五、流程逻辑与数据类#

错误17：BAM 的 Read Group 缺失#

Terminal window

1
$ gatk HaplotypeCaller -R ref.fa -I sample.bam -O variants.vcf
2
A USER ERROR has occurred: Read groups are missing in the BAM file

解决： 比对时就用 -R 加 Read Group 信息。

Terminal window

1
# BWA-MEM
2
bwa mem -R '@RG\tID:sample1\tSM:sample1\tPL:ILLUMINA' ref.fa R1.fq R2.fq > aln.sam
3

4
# STAR
5
STAR --outSAMattrRGline ID:sample1 SM:sample1 PL:ILLUMINA ...
6

7
# 也可以事后补（samtools addreplacerg）
8
samtools addreplacerg -r '@RG\tID:sample1\tSM:sample1' -o fixed.bam original.bam

错误18：featureCounts 分配的 reads 数异常低#

Terminal window

1
$ featureCounts -a genes.gtf -o counts.txt sample.bam
2
# Successfully assigned: 12.3%  ← 太低！

正常 RNA-seq 的分配率应该 >70%（人类/小鼠）。排查：

Terminal window

1
# 1. BAM 和 GTF 的染色体名一致吗？
2
samtools idxstats sample.bam | head -5
3
grep -oP '^chr[^"]+' genes.gtf | sort -u | head -5
4
# chr1 vs 1 ——这就是问题！BAM 是 chr1，GTF 是 1
5

6
# 2. GTF 和 BAM 的 strand 信息一致吗？
7
# featureCounts 默认 -s 0（unstranded）
8
# 如果你的数据是 stranded 但 GTF 没标注，用 -s 2
9
featureCounts -s 2 -a genes.gtf -o counts.txt sample.bam

错误19：DESeq2 的 `model matrix is not full rank`#

1
> dds <- DESeq(dds)
2
Error: the model matrix is not full rank

原因： 实验设计矩阵中存在线性依赖。最常见：某个 factor 的所有样本和另一个 factor 完全一致。

排查：

1
# 查看 design formula 的混淆
2
table(dds$condition, dds$batch)
3
# 如果你看到类似：
4
#         batch1 batch2
5
#   ctrl      3      0
6
#   treat     0      3
7
# 这意味着 condition 和 batch 完全混淆——DESeq2 无法区分

解决： 调整 design formula 去掉混淆的项，或合并 factor。

1
# 如果 batch 和 condition 不混淆，把 design 改成
2
design(dds) <- ~ batch + condition

错误20：SAM/BAM 的 header 错乱导致下游崩溃#

Terminal window

1
$ samtools index sample.bam
2
[E::hts_idx_push] Unsorted positions on sequence chr1

原因： BAM 没排序或排序参数不对。

解决：

Terminal window

1
# 按坐标排序
2
samtools sort -o sample_sorted.bam sample.bam
3
samtools index sample_sorted.bam
4

5
# 如果要按名字排序（某些工具需要）
6
samtools sort -n -o sample_qname.bam sample.bam

六、通用排查技巧#

技巧1：看日志的最后一行#

Terminal window

1
# 大多数生信工具的最后一行是总结或错误码
2
tail -5 pipeline.log
3

4
# 如果只有 Killed，看 dmesg
5
dmesg | tail -30 | grep -iE "error|killed|oom|fail"

技巧2：检查退出码#

Terminal window

1
# 脚本里加这行
2
some_command
3
echo "Exit code: $?"
4
# 0 = 成功，1 = 通用错误，134 = SIGABRT，137 = SIGKILL（OOM），139 = SIGSEGV

技巧3：临时文件残留#

Terminal window

1
# 生信软件经常在 /tmp 下创建临时文件，崩溃后不清理
2
ls -la /tmp/samtools_* /tmp/STAR_* /tmp/hisat2_*
3

4
# 清理（谨慎！）
5
find /tmp -maxdepth 1 -name 'samtools_*' -mtime +1 -delete
6
find /tmp -maxdepth 1 -name 'STAR_*' -mtime +1 -delete

技巧4：环境变量问题#

Terminal window

1
# 很多生信软件通过环境变量指定参考基因组等配置
2
echo $BOWTIE2_INDEXES
3
echo $STAR_GENOME_DIR
4

5
# 如果为空且工具报 "index not found"，在 ~/.bashrc 里加：
6
export BOWTIE2_INDEXES="/opt/refs/bowtie2"

本文覆盖了 20 个常见生信错误。如果你遇到了不在列表中的报错，把错误信息丢给搜索引擎 + “biostars” 或 “seqanswers”，大概率能找到。

本文于 2025-09-05 在 Debian 13 上复现验证。

Linux批量文件管理：rename/find/xargs/ln

Mon, 01 Sep 2025 00:00:00 GMT

生信项目跑到后面，文件数量爆炸。raw_data 里 200 个 fastq，results 里 50 个 BAM，logs 里一堆散落的日志。手动整理是不可能的。

本文提供常用的批量文件管理命令集，覆盖批量重命名、批量查找删除、批量压缩和批量软链接创建，每条可直接复制使用。

1. rename——批量改名#

Terminal window

1
# 把所有.fastq改成.fq
2
rename 's/\.fastq$/.fq/' *.fastq
3

4
# 去掉文件名中的_sample_前缀
5
rename 's/_sample_/_/' *_sample_*.fastq.gz
6

7
# 把所有空格改成下划线
8
rename 's/ /_/g' *
9

10
# 转小写
11
rename 'y/A-Z/a-z/' *

注意： Debian/Ubuntu的 rename 用的是 Perl 正则，CentOS 的用法不同（rename old new files）。不确定就用 file-rename。

2. find——查找并操作#

Terminal window

1
# 找所有超过1GB的BAM文件
2
find . -name "*.bam" -size +1G
3

4
# 删除7天前的临时文件
5
find /tmp -name "*.tmp" -mtime +7 -delete
6

7
# 找空文件
8
find . -type f -empty
9

10
# 把所有.sh加执行权限
11
find . -name "*.sh" -exec chmod +x {} \;
12

13
# 找软链接（断了的）
14
find . -type l ! -exec test -e {} \; -print

3. xargs——批量执行#

Terminal window

1
# 并行gzip压缩（-P4=4线程）
2
find . -name "*.fastq" | xargs -P4 -I{} gzip {}
3

4
# 删除含ERROR的日志文件
5
grep -l "ERROR" *.log | xargs rm -f
6

7
# 统计所有fastq.gz总大小
8
find . -name "*.fastq.gz" | xargs du -ch | tail -1

4. 软链接管理#

Terminal window

1
# 统一引用基因组，不拷贝
2
ln -s /opt/refs/hg38.fa ./refs/
3

4
# 批量创建链接（参照组每个基因一个链接）
5
cat gene_list.txt | xargs -I{} ln -s /opt/refs/{}.fa ./genes/
6

7
# 查看链接指向
8
readlink -f hg38.fa

5. 实用组合#

Terminal window

1
# 批量统计行数
2
find ./results -name "*.txt" | xargs wc -l | sort -rn
3

4
# 批量检查文件完整性（gzip）
5
find . -name "*.gz" | xargs -P8 -I{} sh -c 'gzip -t {} || echo "CORRUPT: {}"'
6

7
# 按日期归档日志
8
tar -czf logs_$(date +%Y%m).tar.gz logs/

本文于 2025-09-01 实测。

DESeq2差异表达分析：RNA-seq最小可用流程

Wed, 20 Aug 2025 00:00:00 GMT

差异表达分析回答”处理组和对照组哪些基因发生了变化”。从 count 矩阵出发，DESeq2 提供了标准化的差异分析流程。本文聚焦最小可用流程：表达矩阵准备、样本表构建、差异分析、结果提取、火山图，不深入统计原理。

1. 准备数据#

DESeq2 需要两个输入：

1
# 1. count矩阵（基因×样本，整数）
2
head(counts)
3
#            control1 control2 control3 treat1 treat2 treat3
4
# ENSG00001      200      180      190    500    520    480
5
# ENSG00002        5        8        3     10     12     15
6

7
# 2. 样本信息
8
coldata <- data.frame(
9
    row.names = colnames(counts),
10
    condition = factor(c(rep("Control",3), rep("Treatment",3)))
11
)

注意：count必须是整数（raw counts），不能用FPKM/TPM。

2. 差异分析#

1
library(DESeq2)
2

3
# 构建对象
4
dds <- DESeqDataSetFromMatrix(
5
    countData = counts,
6
    colData = coldata,
7
    design = ~ condition
8
)
9

10
# 过滤低表达基因（至少在3个样本中count≥10）
11
keep <- rowSums(counts(dds) >= 10) >= 3
12
dds <- dds[keep, ]
13

14
# 跑分析
15
dds <- DESeq(dds)
16

17
# 提取结果
18
res <- results(dds, contrast = c("condition", "Treatment", "Control"),
19
               alpha = 0.05)
20
summary(res)
21

22
# 导出
23
write.csv(as.data.frame(res), "DEG_results.csv")

展开收起

3. 筛选差异基因#

1
res_sig <- as.data.frame(res) %>%
2
    filter(padj < 0.05, abs(log2FoldChange) > 1) %>%
3
    arrange(padj)

阈值	含义
padj < 0.05	多重检验校正后显著
\|log2FC\| > 1	变化超过2倍

4. 火山图#

1
library(ggplot2)
2
ggplot(as.data.frame(res), aes(x = log2FoldChange, y = -log10(padj))) +
3
    geom_point(alpha = 0.3, size = 0.5) +
4
    geom_vline(xintercept = c(-1, 1), linetype = "dashed") +
5
    geom_hline(yintercept = -log10(0.05), linetype = "dashed") +
6
    theme_bw()

5. 踩坑#

坑1：count矩阵有小数——featureCounts 输出有时含浮点数。用 round() 取整。

坑2：样本名不匹配——coldata 的 row.names 必须等于 count 矩阵的 colnames。

坑3：没有生物学重复报错——DESeq2 要求每组≥2个重复。n=1时用 design = ~ 1，但不推荐。

本文于 2025-08-20 实测。

命令行效率工具：bat/fd/ripgrep/jq

Thu, 07 Aug 2025 00:00:00 GMT

日常生信工作中，大量时间花在浏览文件、搜索内容和查看结果上。四个命令行工具可以显著提升效率：bat 替代 cat（语法高亮）、fd 替代 find（更快更简洁）、ripgrep(rg) 替代 grep（快 5-30 倍）、jq 处理 JSON/API 返回数据。本文覆盖这四个工具在生信中的高频使用场景。

实测环境：Debian 13，所有工具 apt/Conda 安装。

1. bat——cat 的现代化身，带语法高亮和行号#

1.1 安装与第一印象#

Terminal window

1
sudo apt install bat -y
2
# Debian 上命令名可能是 batcat（因与另一个包冲突）
3
# 创建别名：
4
alias bat='batcat'

直接替换 cat 的第一眼：

Terminal window

1
# cat —— 黑白一片
2
cat sample_anno.gff3 | head -50
3

4
# bat —— 语法高亮 + 行号 + Git 变化标记
5
bat sample_anno.gff3 | head -50

bat 自动识别文件类型并高亮语法——GFF、FASTA、VCF、Python、Shell、JSON……几乎你遇到的所有生信文件格式都支持。

1.2 生信场景#

Terminal window展开收起

1
# 1. 看 GFF3 注释（自动高亮 tab 分隔和染色体名）
2
bat --paging=never genes.gff3 | head -100
3

4
# 2. 看 FASTA 的 header（自动识别）
5
bat --show-all genome.fa
6
# --show-all 显示不可见字符（比如发现 \r\n 问题）
7

8
# 3. 看 shell 脚本（带行号，调试时定位错误行）
9
bat --style=numbers run_pipeline.sh
10

11
# 4. 看 JSON 配置（自动格式化高亮）
12
bat --language json config.json
13

14
# 5. 结合管道：实时看日志
15
tail -f pipeline.log | bat --paging=never -l log
16
# -l log 强制按日志格式高亮

展开收起

1.3 常用参数#

参数	作用	生信用法
`--paging=never`	不分页，直接输出	管道中使用
`--show-all`	显示所有不可见字符	检查 DOS 换行
`--style=plain`	纯文本（无行号和边框）	复制粘贴
`-l <lang>`	指定语言高亮	文件扩展名不标准时
`-r <start>:<end>`	只显示指定行范围	大文件查看中间段

2. fd——find 的替代者，快 10 倍且语法更直观#

2.1 安装#

Terminal window

1
sudo apt install fd-find -y
2
alias fd='fdfind'  # Debian 上的命名

2.2 基础用法对比#

Terminal window

1
# find 方式（繁琐）
2
find . -name "*.fastq.gz" -type f
3

4
# fd 方式（简洁）
5
fd '\.fastq\.gz$'
6

7
# fd 默认：
8
# - 智能大小写（搜 Git 默认忽略 .git/）
9
# - 正则匹配
10
# - 彩色输出
11
# - 比 find 快 5-10 倍（并行目录遍历）

2.3 生信高频场景#

Terminal window展开收起

1
# 1. 找所有指定后缀的 FASTQ 文件
2
fd -e fastq.gz
3
# 比 fd 'fastq\.gz$' 更快——-e 是精确扩展名匹配
4

5
# 2. 找最近修改过的 BAM 文件（24小时内）
6
fd -e bam --changed-within 24h
7

8
# 3. 找大于 1GB 的文件（排查磁盘占用）
9
fd --size +1g
10

11
# 4. 递归列出所有目录结构（排除隐藏文件）
12
fd -t d --max-depth 3
13

14
# 5. 找文件并执行命令（-x 替代 find 的 -exec）
15
fd -e sam -x samtools view -bS {} -o {.}.bam
16
# {} = 文件路径, {.} = 去掉扩展名后的部分
17
# 上面把目录下所有 .sam 转为 .bam
18

19
# 6. 批量压缩日志
20
fd -e log --changed-before 7d -x gzip {}
21
# 压缩 7 天前的旧日志
22

23
# 7. 排除某目录的搜索
24
fd -e fastq.gz -E raw_data_backup/
25
# -E = --exclude
26

27
# 8. 统计每种文件类型的数量
28
fd -t f | sed 's/.*\.//' | sort | uniq -c | sort -rn | head -10

展开收起

2.4 fd 的搜索算法为什么快#

fd 使用并行目录遍历 + ripgrep 的正则引擎，它的速度优势来源于：

Tfd≈Tfindnparallel×coptimizationT_{fd} \approx \frac{T_{find}}{n_{parallel} \times c_{optimization}}Tfd≈nparallel×coptimizationTfind

其中 nparalleln_{parallel}nparallel 是并行遍历因子，coptimizationc_{optimization}coptimization 包括智能跳过 .git 目录、忽略二进制文件、内存映射 I/O 等。实测在包含 50 万文件的生信项目目录中：find 耗时 12 秒，fd 仅 0.8 秒。

3. ripgrep (rg)——grep 的终结者#

3.1 安装#

Terminal window

1
sudo apt install ripgrep -y
2
rg --version
3
# ripgrep 14.1.1

3.2 核心速度对比#

ripgrep 默认：

递归搜索（不需要 -r）
忽略 .gitignore 中的文件
忽略二进制文件
不搜索隐藏文件和 .git/
使用 SIMD 加速和多线程

Terminal window

1
# grep 方式
2
grep -r "ENST00000" ./annotations/  # 5万行 GTF，耗时 2.1秒
3

4
# rg 方式
5
rg "ENST00000" ./annotations/        # 同样文件，耗时 0.3秒
6

7
# 速度比：
8
# $$ speedup = \frac{2.1}{0.3} = 7\times $$

3.3 生信高频场景#

Terminal window展开收起

1
# 1. 在 FASTQ 文件中搜特定序列
2
rg "ATCGCGATCG" --no-filename --count *.fastq
3
# 输出：每个文件里匹配了几次
4

5
# 2. 在 GFF/GTF 中搜基因（只搜特定列）
6
rg "^chr1\t" genes.gff3
7
# 只搜 chr1 的行（^ 锚定到行首 + tab 确保是第一列）
8

9
# 3. 搜 VCF 中 QUAL < 20 的变异
10
rg -v "^#" variants.vcf | rg "PASS" --count
11
# 去掉 header（^#），统计 PASS 数量
12

13
# 4. 在日志中搜错误信息（含上下文）
14
rg -C 3 "Error|FATAL|Segfault" pipeline.log
15
# -C 3 = 显示匹配行前后各3行
16

17
# 5. 在多个 BAM 的 flagstat 输出中搜比对率
18
rg "mapped \(" *.flagstat
19
# 快速一眼看到所有样本的比对率
20

21
# 6. 统计某基因在所有 GTEx 样本中的表达
22
rg "ENSG00000139618" --count */quant.sf
23

24
# 7. 搜 Python 脚本中的函数定义
25
rg "def " --type py -l
26
# --type py 只搜 Python 文件, -l 只显示文件名
27

28
# 8. 反搜索——找不包含某模式的文件
29
rg -L "PASS" *.vcf
30
# 哪些 VCF 没有 PASS 的变异

展开收起

3.4 rg 的替换功能——sed 的替代#

Terminal window

1
# 把 GTF 中的 "chr" 前缀去掉（所有行）
2
rg "chr" genes.gtf -r "" --passthru
3
# 实际还是 sed 更合适这种全局替换
4

5
# 但 rg 的优势是搜索后替换特定匹配：
6
rg "contig_\d+" --replace "scaffold" sequences.fa

3.5 性能原理#

ripgrep 用 Rust 的 regex 引擎，底层利用了 SIMD（单指令多数据）向量化。它处理文本的模式匹配时，可以同时比较 16 或 32 个字节：

throughputrg∝bytes_per_cycle×SIMD_widthcycle_timethroughput_{rg} \propto \frac{bytes\_per\_cycle \times SIMD\_width}{cycle\_time}throughputrg∝cycle_timebytes_per_cycle×SIMD_width

相比 grep 的逐字节匹配，在长模式搜索时优势最明显。

4. jq——JSON 处理的瑞士军刀#

生信中 JSON 越来越多见了：SRA Run Selector 导出的 metadata、salmon 的 quant.sf 的 aux 信息、各种 API 返回结果、kallisto 的 run_info.json、Nextflow 的 trace.txt……

4.1 安装#

Terminal window

1
sudo apt install jq -y
2
jq --version
3
# jq-1.7.1

4.2 生信高频场景#

Terminal window展开收起

1
# 1. 提取 SRA metadata 中的关键字段
2
# SRA Run Selector 导出的 SraRunTable.txt 转 JSON 后：
3
jq '.[] | {run: .Run, sample: .SampleName, layout: .LibraryLayout, mb: .MBases}' sra_meta.json
4

5
# 2. 解析 salmon quant.sf 的 meta_info.json
6
jq '.num_processed | {total_reads, mapped_reads, mapping_rate}' aux_info/meta_info.json
7

8
# 3. 检查 Nextflow trace 中各进程的资源使用
9
jq '.[] | select(.exit != 0) | {process: .name, exit: .exit, workdir: .workdir}' trace.txt
10

11
# 4. 从 GEO API 返回中提取样本信息
12
curl -s "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=gds&term=GSE123456&retmode=json" \
13
    | jq '.esearchresult.idlist[]'
14

15
# 5. 提取所有样本名（用于批量处理脚本）
16
jq -r '.[].SampleName' sra_meta.json > sample_list.txt
17
# -r = raw output（去掉引号）

展开收起

4.3 jq 实用 Python/R 集成#

1
import subprocess
2
import json
3

4
def jq_query(json_file, query):
5
    """在 Python 中调 jq"""
6
    result = subprocess.run(
7
        ["jq", "-r", query, json_file],
8
        capture_output=True, text=True
9
    )
10
    if result.returncode != 0:
11
        raise RuntimeError(f"jq error: {result.stderr}")
12
    return result.stdout.strip().split('\n')
13

14
# 用法：提取所有 SRR accession
15
samples = jq_query("sra_meta.json", '.[].Run')
16
print(samples)

展开收起

1
library(jsonlite)
2

3
# R 中处理 JSON 推荐用 jsonlite（原生 R，不需要 jq）
4
sra_meta <- fromJSON("sra_meta.json")
5
sample_names <- sra_meta$SampleName

5. 四件套的组合——生信日常 pipeline#

Terminal window展开收起

1
# 场景：探索一个新下载的数据集目录，5 分钟内搞清楚里面有什么
2

3
# 1. 找到所有 FASTQ 文件
4
fd -e fastq.gz
5

6
# 2. 统计这些文件的基本行数（测序量估计）
7
fd -e fastq.gz -x sh -c 'echo "{} $(zcat {} | wc -l)"' \
8
    | awk '{print $1, $2/4 " reads"}'  # FASTQ 每4行一条read
9

10
# 3. 搜 metadata JSON 里的关键字段
11
jq '.characteristics[]' metadata.json | rg -i "tissue|disease|treatment"
12

13
# 4. 检查日志有没有异常
14
rg -i "error|fail|killed|timeout" logs/ -C 2
15

16
# 5. 看一个 sample 的序列质量（前1000行）
17
zcat $(fd -e fastq.gz | head -1) | head -1000 | bat --paging=never

展开收起

把这个流程做成 alias 或小脚本，每次拿到新数据直接跑一遍，对数据心里有数。

6. 踩坑记录#

坑1：bat 在管道中输出带了颜色转义码#

症状：bat file.txt | grep pattern 什么也搜不到。

原因：bat 默认输出 24-bit 真彩色转义码，grep 看到的不是纯文本。

Terminal window

1
# 解决方案：
2
bat --paging=never --color=never file.txt | grep pattern
3
# 或用 --style=plain 同时去掉行号
4
bat --style=plain file.txt | grep pattern

更简单的做法：用 bat 看文件，用 rg 搜。不要 bat | grep。

坑2：fd 搜不到隐藏目录下的文件#

症状：fd -e bam 找不到 .snakemake/ 下的比对结果。

原因：fd 默认跳过隐藏目录（. 开头）和 .gitignore 中的文件。

Terminal window

1
# 显示隐藏文件
2
fd -H -e bam
3
# -H = --hidden
4

5
# 完全不过滤
6
fd -H -I -e bam
7
# -I = --no-ignore（不遵循 .gitignore）

坑3：rg 搜不到二进制文件中的文本#

症状：rg "pattern" file.bam 没结果。

原因：rg 默认跳过二进制文件（BAM 是二进制格式，但确实包含可读的 header 文本）。

Terminal window

1
# 强制搜索二进制文件
2
rg -a "pattern" file.bam
3
# -a = --text（把所有文件当文本处理）
4

5
# 但更好的做法：用专门的工具
6
samtools view -H file.bam | rg "pattern"

坑4：jq 解析大型 JSON 内存爆了#

症状：jq '.' huge.json 导致进程 OOM。

原因：jq 需要把整个 JSON 加载到内存。一个 5GB 的 JSON 文件会消耗远超 5GB 的内存（解析后的内存结构更大）。

Terminal window

1
# 流式处理（逐个数组元素处理，不一次性加载）
2
jq -c '.[]' huge.json | while read line; do
3
    echo "$line" | jq '.field_of_interest'
4
done
5

6
# 或只提取需要的字段减小输出
7
jq '.[] | {name: .sample_name, reads: .total_reads}' huge.json

坑5：rg 的正则和 grep 不完全兼容#

症状：从 StackOverflow 复制的 grep 命令换成 rg 后报错。

rg 默认使用 Rust regex，部分 Perl 正则特性（如 \d、\w、look-around）不完全支持：

Terminal window

1
# grep 中可以用
2
grep -P '\d{3}-\d{4}' file.txt   # Perl regex
3

4
# rg 中要写
5
rg '\d{3}-\d{4}' file.txt        # 实际 rg 也支持 \d，但某些特性不行
6

7
# 如果不确定，用 --pcre2
8
rg --pcre2 '(?<=chr)\d+' file.txt  # 启用 PCRE2 支持 look-behind

坑6：fd 的 -x 不能执行复杂命令#

症状：fd -e bam -x "samtools sort {} -o sorted/{/}" 不工作。

{} 和 {/} 的替换是 fd 内部的，不要在外面再包一层引号：

Terminal window

1
# 正确写法
2
fd -e bam -x samtools sort {} -o sorted/{/}
3

4
# 复杂命令用 sh -c
5
fd -e bam -x sh -c 'samtools sort "$1" -o "sorted/$(basename "$1")"' _ {}
6
# _ 是 $0 的占位符，{} 传给 $1

坑7：bat 不支持大文件分页时内存溢出#

症状：bat 50GB.fastq 直接卡死。

bat 会把整个文件读入内存做语法高亮。大文件请用 head / tail 配合 bat：

Terminal window

1
# 只看前面部分
2
head -1000 huge.fastq | bat --paging=never -l fasta
3

4
# 或直接用 less（也有语法高亮但没 bat 漂亮）
5
less huge.fastq

坑8：jq 的数值精度丢失#

症状：jq 处理后的大整数（如基因组坐标）被转成了科学计数法。

Terminal window

1
# jq 默认把大数字转为浮点
2
echo '{"pos": 248956422}' | jq '.pos'
3
# 输出：248956422  ← 恰好还在安全范围
4
# 但更大的：9007199254740993 就会丢失精度
5

6
# 如果 JSON 中包含超大整数，用 --raw-output 或字符串处理

7. 小结#

你要做的事	旧工具	新工具	提速
看文件内容	`cat`	`bat`	—（体验提升）
找文件	`find`	`fd`	5-10×
搜内容	`grep`	`rg`	5-30×
处理 JSON	Python/R 脚本	`jq`	10-50×（开发时间）

这四个工具加到 .bashrc 里设置好 alias，花 10 分钟习惯一下，之后每天能省半小时以上。搞生信的，时间是最大的成本。

本文于 2025-08-07 在 Debian 13 上实测完成。bat v0.24.0，fd v10.2.0，ripgrep v14.1.1，jq v1.7.1。

HISAT2 RNA-seq比对：建索引、双端比对、参数调优

Tue, 05 Aug 2025 00:00:00 GMT

HISAT2 是 RNA-seq 比对工具之一。相比 STAR，HISAT2 的优势在于内存占用更少（~8GB vs STAR 的 30GB+）、索引更小、对小基因组和低深度测序更友好。本文覆盖 HISAT2 安装、建索引、双端比对、参数调优和比对率统计全流程。

实测环境：Debian 13，HISAT2 v2.2.2，Conda安装。

1. 安装#

Terminal window

1
conda install -c bioconda hisat2 -y
2
hisat2 --version
3
# hisat2-align-s version 2.2.2

2. 建索引#

Terminal window

1
# 下载参考（人类GRCh38，hisat2专门格式）
2
wget https://genome-idx.s3.amazonaws.com/hisat/grch38_genome.tar.gz
3

4
# 或者自己建
5
hisat2-build ref.fa hisat2_index/grch38

输出 8 个 .ht2 文件，大约 5GB。比 STAR 的索引（28GB+）小很多。

3. 双端比对#

Terminal window

1
hisat2 -x hisat2_index/grch38 \
2
    -1 sample_R1.fastq.gz -2 sample_R2.fastq.gz \
3
    -S output.sam \
4
    -p 8 \
5
    --dta \           # 转录本组装模式，StringTie需要
6
    --summary-file alignment_summary.txt

参数：

-x：索引前缀
--dta：下游用StringTie时必须加，会优化比对策略
--rna-strandness：链特异性数据需要设（RF/FR），普通数据不用
--summary-file：输出比对统计，必加

4. 比对率解读#

Terminal window

1
cat alignment_summary.txt

1
Total pairs: 30000
2
Aligned concordantly 1 time: 25500 (85.00%)
3
Aligned concordantly >1 times: 3000 (10.00%)
4
Aligned discordantly 1 time: 1500 (5.00%)
5
Overall alignment rate: 95.00%

RNA-seq比对率正常范围：85-95%。 低于80%检查数据质量和参考基因组。

5. HISAT2 vs STAR 选择#

特性	HISAT2	STAR
内存	~8GB	~30GB
索引大小	~5GB	~28GB
速度	中等	快
比对率	稍低	最高
推荐场景	内存受限/小基因组	标准RNA-seq流程

简单决策： 服务器内存≥32GB用STAR，内存紧张用HISAT2。

6. 踩坑#

索引版本不兼容：hisat2 v2.1的索引用v2.2读会报错，必须重建
—dta必须加：如果后续用StringTie做转录本组装，不加这个会丢失比对信息
单端vs双端：单端数据不加-2参数即可

本文于 2025-08-05 实测。HISAT2 v2.2.2。

磁盘空间管理与清理：df/du/ncdu

Wed, 30 Jul 2025 00:00:00 GMT

生信数据量增长很快：一个样本的 fastq 10-30GB，比对完的 BAM 50-100GB，variant calling 中间文件可到 200GB。20 个样本就是好几个 TB。磁盘满了流程全崩——No space left on device 是高频报错。本文覆盖磁盘空间排查、大文件定位、缓存清理和自动化空间管理。

实测环境：Debian 13，80GB 系统盘 + 2TB 数据盘。

1. 查看磁盘使用——你的空间去哪了#

1.1 df——看全局#

Terminal window

1
# 人类可读格式
2
df -h
3

4
# 只看特定分区
5
df -h / /opt /home
6

7
# 显示文件系统类型
8
df -hT

输出示例：

1
Filesystem      Size  Used Avail Use% Mounted on
2
/dev/sda1        79G   45G   30G  61% /
3
/dev/sdb1       2.0T  1.6T  400G  80% /data

关注点：

Use% 超过 80% 就要清理了
Use% 达到 100% 时所有写操作都会失败
/dev/shm 是内存盘（tmpfs），大小是物理内存的一半

1.2 du——看细节#

Terminal window

1
# 当前目录下所有子目录的大小（汇总）
2
du -sh */
3

4
# 按大小排序（最大的放最后）
5
du -sh * | sort -h
6

7
# 显示深度1层
8
du -h --max-depth=1 /opt/bioinfo
9

10
# 找出超过1GB的目录
11
du -h --max-depth=2 /opt/bioinfo | grep 'G\b' | sort -h

du 会遍历所有文件计算大小，对大目录可能很慢。别在根目录直接 du /——可能跑半小时。

1.3 ncdu——交互式磁盘分析（强烈推荐）#

Terminal window

1
sudo apt install ncdu -y
2

3
# 分析某个目录
4
ncdu /opt/bioinfo
5

6
# 只分析，不进入交互模式（导出报告）
7
ncdu -o disk_report.json /opt/bioinfo
8
# 之后查看
9
ncdu -f disk_report.json

ncdu 的交互界面里可以按 d 删除文件/目录，按 n 按文件名排序，按 s 按大小排序。比 du 直观 10 倍。我第一次用 ncdu 清理出了 300GB 的 conda 缓存和 pip 包，之前用 du 完全没发现。

2. 找大文件——定位罪魁祸首#

2.1 find 找大文件#

Terminal window

1
# 找出超过 1GB 的文件
2
find /opt/bioinfo -type f -size +1G -exec ls -lh {} \; 2>/dev/null
3

4
# 找出最近 30 天没修改过的大文件（候选删除对象）
5
find /opt/bioinfo -type f -size +1G -mtime +30 -exec ls -lh {} \;
6

7
# 找出最大的 10 个文件（不管在哪）
8
find /opt/bioinfo -type f -exec du -h {} \; 2>/dev/null | sort -rh | head -10
9

10
# 更快的版本（用 du 配合 sort）
11
du -ah /opt/bioinfo 2>/dev/null | sort -rh | head -20

2.2 生信特有大文件清单#

文件类型	典型大小	能否删除	建议
raw FASTQ (.fastq.gz)	5-30GB/样本	❌ 原件	压缩后归档，多副本备份
BAM 文件	50-100GB/样本	⚠️ 酌情	有 FASTQ 可重比对的话可删
SAM 文件	200-500GB/样本	✅	转成 BAM 后立刻删
临时文件( /tmp/*)	不定	✅	定期清理
Conda 环境	2-10GB/环境	⚠️	导出 yml 后可重建
conda pkgs 缓存	10-50GB	✅	`conda clean -a`
pip 缓存	1-5GB	✅	`pip cache purge`
Docker 镜像	5-20GB/镜像	⚠️	`docker system prune`
日志文件( .log)	1-50GB	⚠️	压缩旧 log，删调试级 log
核心转储( core.*)	1-50GB	✅	程序崩溃的 dump，可删

3. 清理 Conda/Pip 缓存——生信最大的隐形空间杀手#

Conda 下载的每个包都会缓存下来，日积月累能吃掉几十 GB。

Terminal window

1
# 看看缓存多大
2
du -sh ~/miniconda3/pkgs/
3

4
# 清理所有缓存（包、索引、临时文件）
5
conda clean --all -y
6

7
# 只清包缓存（下载的 .tar.bz2 文件）
8
conda clean --packages -y
9

10
# 清理后确认
11
du -sh ~/miniconda3/pkgs/

pip 也有缓存：

Terminal window

1
# 查看缓存大小
2
pip cache info
3

4
# 清理
5
pip cache purge

另外 Conda 每个环境都是一份完整的软件副本，10 个环境可能是 30-50GB：

Terminal window

1
# 查看所有环境的大小
2
du -sh ~/miniconda3/envs/*/
3

4
# 删掉不用的环境
5
conda env remove -n old_env_name
6

7
# 或者导出再删
8
conda env export -n to_delete > to_delete.yml
9
conda env remove -n to_delete
10
# 以后需要时 conda env create -f to_delete.yml

4. 日志管理——设好轮转策略#

生信流程会产生大量日志，pipeline.log 跑半年能到几十 GB。

4.1 手动轮转#

Terminal window

1
# 压缩旧日志
2
gzip old_log.log
3

4
# 只保留最近 N 行
5
tail -n 100000 huge.log > trimmed.log
6

7
# 删掉超过 30 天的日志
8
find /opt/bioinfo/logs -name "*.log" -mtime +30 -delete
9

10
# 更安全：先压缩再删
11
find /opt/bioinfo/logs -name "*.log" -mtime +30 -exec gzip {} \;
12
find /opt/bioinfo/logs -name "*.log.gz" -mtime +90 -delete

4.2 logrotate——自动管理#

/etc/logrotate.d/bioinfo

1
/opt/bioinfo/logs/*.log {
2
    weekly
3
    rotate 4
4
    compress
5
    missingok
6
    notifempty
7
    maxsize 500M
8
}

意思：每周轮转一次，保留 4 个历史版本，压缩旧日志，超过 500MB 强制轮转。

4.3 流程脚本里加日志限制#

Terminal window

1
# 在 Shell 脚本里
2
exec > >(tee logs/pipeline.log) 2>&1
3

4
# 跑完后截断
5
# 只保留最后 50MB
6
tail -c 50M logs/pipeline.log > logs/pipeline.log.trimmed
7
mv logs/pipeline.log.trimmed logs/pipeline.log

5. 临时文件清理——生信流程的垃圾场#

5.1 /tmp 清理#

很多生信工具（samtools sort、GATK、STAR）默认用 /tmp 做临时目录。进程崩溃后临时文件不会被删。

Terminal window

1
# 查看 /tmp 下的大文件
2
du -sh /tmp/*/ 2>/dev/null | sort -rh | head -10
3

4
# 找几天前的遗留文件
5
find /tmp -type f -mtime +3 -size +100M -exec ls -lh {} \;
6

7
# 谨慎清理（确保没有活进程在用）
8
find /tmp -type f -mtime +3 -name "samtools*" -delete
9

10
# 更好的做法：给流程指定专用的临时目录
11
TMPDIR=/opt/bioinfo/tmp samtools sort ...
12
# 跑完流程手动清理 /opt/bioinfo/tmp

5.2 中间文件管理#

Terminal window

1
# 流程脚本里管道串联，避免产生中间文件
2
# 坏：产生大量 SAM 文件
3
bwa mem ref r1.fq r2.fq > sample.sam
4
samtools sort sample.sam -o sample.bam
5
rm sample.sam
6

7
# 好：管道一步到位
8
bwa mem ref r1.fq r2.fq | samtools sort -o sample.bam -
9

10
# 批量删除中间文件
11
find /opt/bioinfo/results -name "*.sam" -delete
12
find /opt/bioinfo/results -name "*.unsorted.bam" -delete

5.3 用 trap 确保清理#

1
#!/bin/bash
2
set -euo pipefail
3

4
TMP_DIR=$(mktemp -d /opt/bioinfo/tmp/pipeline_XXXXXX)
5
cleanup() {
6
    echo "Cleaning up temporary files..."
7
    rm -rf "$TMP_DIR"
8
}
9
trap cleanup EXIT
10

11
# 所有临时文件写到 $TMP_DIR
12
samtools sort -T "$TMP_DIR" -o output.bam input.sam
13
# 脚本正常退出时自动清理，异常退出也会清理

6. 软链接节省空间——一套参考基因组全组共享#

参考基因组每个都几十 GB（含索引），5 个人每人拷一份就是 200GB。软链接解决这个问题：

Terminal window

1
# 公共目录放一份
2
/opt/refs/hg38/hg38.fa
3
/opt/refs/hg38/hg38.fa.bwt
4
/opt/refs/hg38/hg38.fa.ann
5
# ...
6

7
# 个人目录软链接过去
8
ln -s /opt/refs/hg38 ~/refs/hg38
9

10
# 确认
11
ls -la ~/refs/hg38
12
# lrwxrwxrwx ... hg38 -> /opt/refs/hg38

软链接不占额外空间（只占一个 inode 的大小），但使用上和真实目录一模一样。

7. 踩坑记录#

坑1：df 显示磁盘满了，du 算出来却很小#

症状：df -h 显示 100% 使用，但 du -sh / 算出来只有 50GB。

原因：有进程打开了某个大文件但已经被 rm 删了。文件虽然从目录里消失了，但进程还持有文件句柄，磁盘空间没有真正释放。

Terminal window

1
# 找出这种"已删除但仍被占用"的文件
2
lsof +L1 | grep deleted
3
# 或
4
lsof | grep deleted | awk '{print $1, $2, $7}' | sort -rnk3 | head -10
5

6
# 解决方法：重启或 kill 持有文件句柄的进程
7
kill PID

这个坑在生信里极其常见——samtools sort 用的临时文件被 rm 了但进程还在跑，磁盘空间就是不释放。

坑2：ncdu 扫描根目录把 I/O 打满#

症状：ncdu / 跑了 20 分钟，期间服务器响应极慢。

解决：

Terminal window

1
# 不要扫根目录，扫具体分区
2
ncdu /opt          # 而不是 ncdu /
3

4
# 或者先用 df 找到占用高的分区，再针对性分析
5
df -h
6
ncdu /data         # 如果 /data 分区满了

坑3：conda clean —all 删了还需要的包#

conda clean --all 会删掉所有不在当前环境里的包缓存。如果你只有一个环境那没事。如果有多个环境，某些包需要重新下载。

更安全的方式：

Terminal window

1
# 只删明确不需要的包缓存
2
conda clean --packages --dry-run   # 先看看会删什么
3
conda clean --packages             # 确认后执行

坑4：rm 大文件后 df 没变化#

跟前一个坑类似——文件被其他进程占着。确认：

Terminal window

1
# 删除前：检查有没有进程在用
2
lsof /path/to/large/file
3

4
# 如果有进程在用，先停进程再删

坑5：logrotate 配置了但没生效#

症状：配了 /etc/logrotate.d/bioinfo，但日志还是在增长。

检查：

Terminal window

1
# 手动触发看看有没有报错
2
logrotate -d /etc/logrotate.d/bioinfo    # debug 模式
3
logrotate -f /etc/logrotate.d/bioinfo    # 强制执行
4

5
# 确认 cron 在跑
6
systemctl status logrotate.timer

Debian 上 logrotate 由 systemd timer 触发，不是 cron。确认 timer 是 active 状态。

坑6：`find ... -delete` 删错了#

Terminal window

1
# 危险：这条命令递归删除所有 .log 文件
2
find /opt -name "*.log" -delete
3

4
# 安全做法：先 list 确认，再删
5
find /opt -name "*.log" -type f -size +1G
6
# 确认无误后
7
find /opt -name "*.log" -type f -size +1G -delete

坑7：以为 df 的 Avail 可用就是真的可用#

ext4 文件系统默认预留 5% 给 root 用户。普通用户看到的 Avail 扣掉了这 5%。所以有时候你发现还有几十 GB 空间但就是写不进去——因为你触达了普通用户的上限。

Terminal window

1
# 查看预留比例
2
tune2fs -l /dev/sda1 | grep "Reserved block count"
3

4
# 数据盘可以降低这个预留比（不要对系统盘做）
5
sudo tune2fs -m 1 /dev/sdb1   # 降到1%

8. 小结#

操作	命令	频率建议
全局查看	`df -h`	每天
交互分析	`ncdu /data`	每周
找大文件	`find /data -size +1G`	每周
清 conda 缓存	`conda clean --all`	每月
清 pip 缓存	`pip cache purge`	每月
旧日志压缩	`find logs -mtime +30 -exec gzip {} \;`	每月
清 /tmp	`find /tmp -mtime +3 -delete`	每周
lsof 查泄露	`lsof +L1`	出问题时

磁盘管理是个习惯问题。我现在的习惯：每周一早上 df -h 看一眼，ncdu 扫一遍数据分区，发现异常立刻处理。养成这个习惯需要 5 分钟，但能避免凌晨 3 点被”磁盘满了流程挂了”的告警叫醒。

本文于 2025-07-30 在 Debian 13 上实测完成。ncdu 2.3，conda 24.11.0，所有命令可直接使用。

Bash数组与字符串处理：参数展开、截取、替换

Tue, 22 Jul 2025 00:00:00 GMT

Bash 的数组（索引数组、关联数组）和字符串参数展开是 Shell 脚本中最实用的两项特性——样本列表管理、路径操作、批量参数传递都能用它们处理。本文覆盖数组操作、字符串截取替换和参数展开，附生信场景模板。

实测环境：Debian 13，Bash 5.2。

1. 索引数组——最常用的数组类型#

1.1 创建与访问#

Terminal window展开收起

1
# 创建
2
samples=(WT_1 WT_2 KO_1 KO_2)
3
chroms=("chr1" "chr2" "chr3")
4
files=(*.bam)              # 通配符展开
5

6
# 访问
7
echo "${samples[0]}"       # 第一个元素：WT_1
8
echo "${samples[@]}"       # 所有元素（作为独立单词）
9
echo "${#samples[@]}"      # 数组长度：4
10
echo "${!samples[@]}"      # 所有索引：0 1 2 3
11

12
# 遍历
13
for s in "${samples[@]}"; do
14
    echo "Sample: ${s}"
15
done

展开收起

[@] 和 [*] 的区别是 Bash 数组最容易搞混的地方：

Terminal window

1
arr=("a b" "c d")
2

3
# [@] 保持元素独立（推荐）
4
for i in "${arr[@]}"; do echo "$i"; done
5
# 输出：
6
# a b
7
# c d
8

9
# [*] 把所有元素拼成一个字符串（通常不是你想要的）
10
for i in "${arr[*]}"; do echo "$i"; done
11
# 输出：
12
# a b c d

注意：遍历数组永远用 "${arr[@]}"。

1.2 添加、删除、切片#

Terminal window展开收起

1
# 追加
2
samples+=(WT_3 KO_3)       # 直接拼接
3
samples=("${samples[@]}" "extra")
4

5
# 按索引赋值
6
samples[0]="WT_CONTROL"
7

8
# 删除某个元素（实际是置空，不改变索引）
9
unset "samples[1]"
10

11
# 真正的删除+重新索引
12
samples=("${samples[@]}")  # 重建数组，跳过空位
13

14
# 切片
15
echo "${samples[@]:1:2}"   # 从索引1开始取2个
16

17
# 查找
18
for i in "${!samples[@]}"; do
19
    if [[ "${samples[$i]}" == "KO_2" ]]; then
20
        echo "Found KO_2 at index ${i}"
21
    fi
22
done

展开收起

1.3 生信场景：样本列表管理#

1
#!/bin/bash
2
set -euo pipefail
3

4
# 从文件读取样本列表到数组
5
mapfile -t SAMPLES < sample_list.txt
6
# mapfile（或 readarray）把文件的每一行读入数组
7
# -t 去掉行尾换行符
8

9
echo "Total samples: ${#SAMPLES[@]}"
10

11
# 跳过空行和注释行
12
CLEAN_SAMPLES=()
13
for sample in "${SAMPLES[@]}"; do
14
    [[ -z "${sample}" || "${sample}" == \#* ]] && continue
15
    CLEAN_SAMPLES+=("${sample}")
16
done
17

18
echo "Valid samples: ${#CLEAN_SAMPLES[@]}"
19

20
# 批量生成命令
21
CMDS=()
22
for sample in "${CLEAN_SAMPLES[@]}"; do
23
    CMDS+=("fastp -i ${sample}_R1.fq.gz -I ${sample}_R2.fq.gz -o clean/")
24
done
25

26
# 用GNU parallel执行
27
printf '%s\n' "${CMDS[@]}" | parallel -j 8

展开收起

1.4 数组去重#

生信中经常重复拿到样本名，去重：

Terminal window

1
# 简单的去重（保持顺序）
2
declare -A seen
3
UNIQUE_SAMPLES=()
4

5
for sample in "${SAMPLES[@]}"; do
6
    if [[ -z "${seen[$sample]:-}" ]]; then
7
        UNIQUE_SAMPLES+=("${sample}")
8
        seen[$sample]=1
9
    fi
10
done
11

12
echo "Unique: ${#UNIQUE_SAMPLES[@]}"

2. 关联数组——键值对的威力#

关联数组用字符串做下标，等于 Bash 内置的字典。

Terminal window展开收起

1
# 声明（必须！）
2
declare -A mapping
3

4
# 赋值
5
mapping=(
6
    [WT_1]="wild type replicate 1"
7
    [WT_2]="wild type replicate 2"
8
    [KO_1]="knockout replicate 1"
9
    [KO_2]="knockout replicate 2"
10
)
11

12
# 访问
13
echo "${mapping[KO_1]}"              # knockout replicate 1
14
echo "${!mapping[@]}"                # 所有键：WT_1 WT_2 KO_1 KO_2
15
echo "${mapping[@]}"                 # 所有值
16

17
# 遍历
18
for key in "${!mapping[@]}"; do
19
    echo "${key} -> ${mapping[$key]}"
20
done
21

22
# 检查键是否存在
23
if [[ -v mapping[WT_1] ]]; then      # -v 测试变量/数组键存在
24
    echo "WT_1 exists"
25
fi

展开收起

生信场景：样本名→条件映射#

Terminal window展开收起

1
declare -A CONDITIONS
2
CONDITIONS=(
3
    [SRR100001]=treated
4
    [SRR100002]=treated
5
    [SRR100003]=control
6
    [SRR100004]=control
7
    [SRR100005]=treated
8
)
9

10
# 按条件分组
11
declare -A GROUPS
12
for sra in "${!CONDITIONS[@]}"; do
13
    cond="${CONDITIONS[$sra]}"
14
    GROUPS[$cond]="${GROUPS[$cond]:-} ${sra}"
15
done
16

17
# 输出分组
18
for cond in "${!GROUPS[@]}"; do
19
    echo "=== ${cond} ==="
20
    for sra in ${GROUPS[$cond]}; do
21
        echo "  ${sra}"
22
    done
23
done

展开收起

生信场景：计数器#

Terminal window展开收起

1
declare -A GENE_COUNTS
2

3
# 从GTF中统计每个基因类型的出现次数
4
while IFS=$'\t' read -r chrom source feature start end score strand frame attrs; do
5
    if [[ "${feature}" == "gene" ]]; then
6
        # 从属性字段提取gene_type
7
        if [[ "${attrs}" =~ gene_type\ \"([^\"]+)\" ]]; then
8
            gene_type="${BASH_REMATCH[1]}"
9
            ((GENE_COUNTS[$gene_type]++))   # 关联数组做计数器
10
        fi
11
    fi
12
done < genes.gtf
13

14
# 输出统计
15
for gene_type in "${!GENE_COUNTS[@]}"; do
16
    echo "${gene_type}: ${GENE_COUNTS[$gene_type]}"
17
done | sort -t: -k2 -rn

展开收起

BASH_REMATCH 是 Bash 正则匹配后自动填充的数组，${BASH_REMATCH[1]} 是第一个捕获组。这个技巧在解析 GTF/GFF/SAM 等结构化文本时极其好用。

3. 字符串处理五大类操作#

3.1 长度和提取#

Terminal window

1
s="SRR12345678_S1_L001_R1_001.fastq.gz"
2

3
echo "${#s}"                  # 长度
4
echo "${s:0:3}"               # 前3个字符：SRR
5
echo "${s: -9}"               # 后9个字符：R1_001.fa.. （注意空格）
6
echo "${s:4}"                 # 从第4字符开始到最后

3.2 前后缀删除（生信最高频！）#

Terminal window展开收起

1
path="/data/projects/RNASeq/results/sample1.bam"
2
filename="sample_WT_rep1_R1.fastq.gz"
3

4
# 删前缀 —— # 最短匹配，## 最长匹配
5
echo "${path#*/}"             # data/projects/RNASeq/results/sample1.bam
6
echo "${path##*/}"            # sample1.bam（basename的效果）
7

8
# 删后缀 —— % 最短匹配，%% 最长匹配
9
echo "${filename%.*}"         # sample_WT_rep1_R1.fastq
10
echo "${filename%%.*}"        # sample_WT_rep1_R1
11
echo "${filename%.fastq.gz}"  # sample_WT_rep1_R1
12

13
# 生信实战：提取样本ID
14
sample_id="${filename%%_R1*}"         # sample_WT_rep1
15
echo "Sample ID: ${sample_id}"

展开收起

这些操作的 mnemonic：

prefix_delete=# (keyboard before $),suffix_delete=% (keyboard after $)prefix\_{delete} = \#\ (keyboard\ before\ \$),\quad suffix\_{delete} = \%\ (keyboard\ after\ \$)prefix_delete=# (keyboard before $),suffix_delete=% (keyboard after $)

shortest match=single,longest match=doubleshortest\ match = single,\quad longest\ match = doubleshortest match=single,longest match=double

3.3 替换#

Terminal window展开收起

1
s="sample_WT_rep1_R1.fastq.gz"
2

3
# 首次替换
4
echo "${s/R1/R2}"                    # sample_WT_rep1_R2.fastq.gz
5

6
# 全部替换
7
echo "${s//r/R}"                     # sample_WT_Rep1_R1.fastq.gz
8

9
# 行首/行尾替换
10
echo "${s/#sample/SAMPLE}"           # SAMPLE_WT_rep1_R1.fastq.gz
11
echo "${s/%.gz/.bgz}"               # sample_WT_rep1_R1.fastq.bgz
12

13
# 生信实战：R1↔R2 配对
14
r1="sample_S1_L001_R1_001.fastq.gz"
15
r2="${r1/_R1_/_R2_}"                 # 最安全的替换方式
16
echo "${r2}"                         # sample_S1_L001_R2_001.fastq.gz

展开收起

3.4 默认值和条件展开#

Terminal window

1
# 如果变量未设置或为空，用默认值
2
THREADS="${1:-8}"
3

4
# 如果变量未设置或为空，赋值默认值并返回
5
: "${OUTPUT_DIR:=./results}"   # : 是空命令，效果等于赋值
6

7
# 如果未设置则报错退出
8
INPUT="${2:?Error: input file required}"
9

10
# 如果变量已设置则用替代值
11
echo "${DEBUG:+Debug mode ON}"  # DEBUG有值时才输出

3.5 大小写转换#

Terminal window

1
s="ATGCTAGCTAG"
2

3
echo "${s,,}"              # 全小写：atgctagctag
4
echo "${s,}"               # 首字母小写：aTGCTAGCTAG
5
echo "${s^^}"              # 全大写：ATGCTAGCTAG
6
echo "${s^}"               # 首字母大写：ATGCTAGCTAG（本来已大写）
7

8
# 生信场景：统一序列大小写
9
seq="atcgATCG"
10
echo "${seq^^}"            # ATCGATCG

4. 生信全流程实战：Bash数组+字符串驱动RNA-seq批量比对#

1
#!/bin/bash
2
set -euo pipefail
3

4
# ========== 1. 用数组管理所有样本 ==========
5
mapfile -t RAW_SAMPLES < sample_list.txt
6

7
# 清洗
8
SAMPLES=()
9
for s in "${RAW_SAMPLES[@]}"; do
10
    [[ -z "${s}" || "${s}" == \#* ]] && continue
11
    SAMPLES+=("${s}")
12
done
13

14
echo "Total samples: ${#SAMPLES[@]}"
15

16
# ========== 2. 关联数组存储元信息 ==========
17
declare -A METADATA
18
while IFS=$'\t' read -r sample condition replicate; do
19
    METADATA["${sample}_cond"]="${condition}"
20
    METADATA["${sample}_rep"]="${replicate}"
21
done < metadata.tsv
22

23
# ========== 3. 字符串处理提取配对关系 ==========
24
declare -A R1_FILES R2_FILES
25

26
for f in raw_data/*.fastq.gz; do
27
    basename=$(basename "${f}")
28

29
    if [[ "${basename}" == *_R1_* ]]; then
30
        sample_id="${basename%%_R1*}"
31
        R1_FILES["${sample_id}"]="${f}"
32
    elif [[ "${basename}" == *_R2_* ]]; then
33
        sample_id="${basename%%_R2*}"
34
        R2_FILES["${sample_id}"]="${f}"
35
    fi
36
done
37

38
# ========== 4. 主循环 ==========
39
SUCCESS=()
40
FAILED=()
41

42
for sample in "${SAMPLES[@]}"; do
43
    r1="${R1_FILES[$sample]:-}"
44
    r2="${R2_FILES[$sample]:-}"
45

46
    if [[ -z "${r1}" || -z "${r2}" ]]; then
47
        echo "WARNING: Missing files for ${sample}, skipping"
48
        FAILED+=("${sample}")
49
        continue
50
    fi
51

52
    condition="${METADATA["${sample}_cond"]:-unknown}"
53
    echo "Processing ${sample} (${condition})..."
54

55
    # fastp QC
56
    fastp -i "${r1}" -I "${r2}" \
57
          -o "clean/${sample}_R1.fq.gz" \
58
          -O "clean/${sample}_R2.fq.gz" \
59
          -j "qc/${sample}.json" -h "qc/${sample}.html" -w 8
60

61
    # 根据条件选择参考基因组路径
62
    ref_index="/opt/refs/${condition}_index"
63
    hisat2 -p 16 -x "${ref_index}" \
64
           -1 "clean/${sample}_R1.fq.gz" \
65
           -2 "clean/${sample}_R2.fq.gz" \
66
           | samtools sort -@ 8 -o "bam/${sample}.bam" -
67

68
    samtools index "bam/${sample}.bam"
69
    SUCCESS+=("${sample}")
70
done
71

72
# ========== 5. 结果汇总 ==========
73
echo ""
74
echo "============================="
75
echo "Pipeline complete!"
76
echo "Success: ${#SUCCESS[@]}"
77
echo "  ${SUCCESS[@]}"
78
echo "Failed: ${#FAILED[@]}"
79
echo "  ${FAILED[@]:-None}"
80
echo "============================="
81

82
# 按条件统计
83
declare -A COND_COUNT
84
for sample in "${SUCCESS[@]}"; do
85
    cond="${METADATA["${sample}_cond"]:-unknown}"
86
    ((COND_COUNT[$cond]++))
87
done
88

89
for cond in "${!COND_COUNT[@]}"; do
90
    echo "  ${cond}: ${COND_COUNT[$cond]} samples"
91
done

展开收起

这个脚本展示了：数组去重、关联数组元信息管理、字符串前后缀删除提取样本ID、默认值处理缺失数据、成功/失败分组汇总。

5. Bash数组 vs 临时文件#

很多生信新人习惯用临时文件处理中间数据：

Terminal window

1
# ✗ 用文件的写法
2
ls *.bam > bam_list.txt
3
wc -l bam_list.txt
4
grep "sample1" bam_list.txt
5
# ...后面还要 rm bam_list.txt
6

7
# ✓ 用数组的写法
8
bams=(*.bam)
9
echo "${#bams[@]}"
10
for b in "${bams[@]}"; do
11
    [[ "${b}" == *sample1* ]] && echo "Found: ${b}"
12
done

数组的优缺点：

efficiencyarray≈NIO_opsN×speedupmemoryefficiency_{array} \approx \frac{N_{IO\_ops}}{N} \times speedup_{memory}efficiencyarray≈NNIO_ops×speedupmemory

当文件数量 N 很大时，内存操作（数组）比磁盘 I/O（临时文件）快了三个数量级。但数组也有硬伤：不能跨进程共享、大量数据（10万+元素）会拖慢Bash。遇到这种情况还是用文件或换 Python。

6. 踩坑记录#

坑1：`"${array[@]}"` 忘了双引号#

Terminal window

1
arr=("a b" "c d")
2
# ✗ 没有引号——元素被单词分割
3
for i in ${arr[@]}; do echo "$i"; done
4
# 输出四个独立单词：a, b, c, d
5

6
# ✓ 有引号
7
for i in "${arr[@]}"; do echo "$i"; done
8
# 输出两个元素：a b, c d

坑2：关联数组必须 `declare -A`#

Terminal window

1
# ✗ 不声明就当索引数组
2
mapping=([key1]="val1" [key2]="val2")
3
echo "${mapping[0]}"     # 空的！key1被当作变量名展开
4

5
# ✓
6
declare -A mapping
7
mapping=([key1]="val1" [key2]="val2")
8
echo "${mapping[key1]}"  # val1

坑3：`unset` 数组元素产生空洞#

Terminal window

1
arr=(a b c d)
2
unset "arr[1]"
3
echo "${#arr[@]}"        # 3 ——没毛病
4
echo "${arr[1]}"          # 空 ——有毛病
5
echo "${!arr[@]}"         # 0 2 3 ——索引不连续了！
6

7
# 如果你后面用索引遍历会出问题
8
for i in 0 1 2 3; do
9
    echo "${arr[$i]}"    # 索引1是空的
10
done
11

12
# ✓ 删除后用 "${arr[@]}" 重新索引
13
arr=("${arr[@]}")

坑4：关联数组键含空格#

Terminal window

1
declare -A map
2
map["a key"]="value"
3
echo "${map[a key]}"     # ✓ 可以但别扭
4

5
# 最好避免键中有空格

坑5：大数组性能崩塌#

Bash 数组在元素超过 10 万时操作明显变慢。我测过一个 50 万元素的数组，for 遍历耗时是 Python 的 50 倍。

Terminal window

1
# 如果数据量大，切分或换 Python：
2
python3 -c "
3
data = [line.strip() for line in open('big_list.txt')]
4
print(f'Total: {len(data)}')
5
# 10倍快的处理...
6
"

经验判断：<1000 元素随便用 Bash 数组；1000-10000 还行；>10000 换 Python。

坑6：`${#array[@]}` 和 `${#array}` 的区别#

Terminal window

1
arr=(a bb ccc)
2
echo "${#arr[@]}"    # 3 ——元素个数
3
echo "${#arr}"       # 1 —— ${arr} = ${arr[0]} = "a"，长度是1
4
# 容易搞混！永远用 ${#array[@]} 取长度

坑7：`${string##/}` 中 `/` 是通配符不是正则#

Terminal window

1
path="/data/results/sample.bam"
2
# ##*/ 的意思是：删除最长的能匹配 "*/" 的前缀
3
# 即删到最后一个斜杠之前
4
echo "${path##*/}"    # sample.bam ✓
5

6
# 但如果你以为是 regex 写了 \/ 就毁了
7
echo "${path##*\/}"   # 什么都不删（\/字面量通常不匹配/）

Bash 的 # % ## %% 用的全是 glob 通配符（* ? [a-z]），不是正则，不能用 \d、.、+ 这些正则符号。

坑8：`mapfile` 在旧版Bash不存在#

mapfile（也叫 readarray）是 Bash 4.0+ 才有的。macOS 自带的 Bash 3.2 不支持。

Terminal window

1
# 兼容方案：
2
IFS=$'\n' read -r -d '' -a SAMPLES < sample_list.txt
3
# 或者用传统的 while read
4
SAMPLES=()
5
while IFS= read -r line; do
6
    SAMPLES+=("${line}")
7
done < sample_list.txt

7. 总结#

操作	语法	记忆诀窍
取数组长度	`${#arr[@]}`	`#` 号在数学里就是”个数”
遍历数组	`for i in "${arr[@]}"`	双引号+[@]是建议
删前缀(最短)	`${var#pattern}`	`#` 在 `$` 前 = 删前面
删后缀(最短)	`${var%pattern}`	`%` 在 `$` 后 = 删后面
删前缀(最长)	`${var##pattern}`	两个#
删后缀(最长)	`${var%%pattern}`	两个%
首次替换	`${var/old/new}`	一个斜杠
全局替换	`${var//old/new}`	两个斜杠
默认值	`${var:-default}`	`:-`
关联数组	`declare -A arr`	`-A` = Associative

Bash 的数组和字符串操作，学到就是赚到。一个 %% 就能省掉一次 sed 调用，一个关联数组就能替代 Python 字典。把这张速查表贴在显示器旁边，写脚本时瞟一眼，效率翻倍。

本文于 2025-07-22 在 Debian 13（Bash 5.2.15）上实测完成。

生信软件安装：Conda/APT/源码编译/Docker对比

Tue, 22 Jul 2025 00:00:00 GMT

生信软件安装有四种主流方式：Conda 环境隔离、APT/YUM 系统包管理、源码编译（configure/make）、Docker 容器。同样装一个 Samtools，不同方式耗时和复杂度差异很大。本文对比四种方式的适用场景、优点和代价，附安装时间对比。

1. 四种方式对比#

方法	速度	版本控制	环境隔离	适用
APT/YUM	★★★	★☆☆	★☆☆	系统级工具
Conda	★★☆	★★★	★★★	生信首选
源码编译	★☆☆	★★★	★★☆	特殊优化
Docker	★★☆	★★★	★★★	可重复性

2. APT/YUM——系统包管理器#

Terminal window

1
apt install samtools bowtie2 fastqc -y

优点： 快、依赖自动处理、所有用户可用。
缺点： 版本老旧（Ubuntu 22.04 的 Samtools 还停留在 1.13）、不能装多版本、污染系统环境。

什么时候用： screen、tmux、wget、git 等系统工具用 APT。生信专用软件别用。

3. Conda——生信常用#

Terminal window

1
conda create -n rnaseq -y python=3.10
2
conda activate rnaseq
3
conda install -c bioconda star samtools fastqc fastp -y

优点： 环境隔离（每个项目独立）、版本切换轻松、Bioconda有9000+生信包。

版控技巧：

Terminal window

1
conda list --explicit > env_snapshot.txt
2
conda install --file env_snapshot.txt  # 精确恢复

4. 源码编译——灵活性最高#

Terminal window

1
git clone https://github.com/samtools/samtools.git
2
cd samtools
3
autoheader && autoconf
4
./configure --prefix=/opt/samtools-1.20
5
make -j8
6
make install

什么时候用：

需要特定编译选项（如—enable-optimizations）
软件没有 Conda 包
需要最新 git 版

代价： 依赖手动解决（configure阶段的报错是新手噩梦）。

5. Docker——终极可重复#

Terminal window

1
docker run -v /data:/data biocontainers/samtools:v1.18 samtools sort input.bam

优点： 环境完全一致（投稿时审稿人可以直接复现）、不污染宿主机。

缺点： 学曲线、文件挂载、权限问题。

6. 选择决策树#

1
需要多版本共存？ → Conda
2
需要性能极致？ → 源码编译+优化选项
3
需要团队共享？ → Conda环境导出
4
需要发表可重复？ → Docker
5
只是系统工具？ → APT

本文于 2025-07-22 实测。

ggplot2学术绘图：配色方案、主题、多图拼接

Tue, 22 Jul 2025 00:00:00 GMT

ggplot2 默认输出与学术期刊要求之间存在差距：灰色背景、默认配色、字体偏小、图例默认位置。本文覆盖从默认输出到发表级图表的关键调整：CNS 级别配色方案、ggpubr 统计标注、cowplot/patchwork 多图拼接、300dpi 矢量图导出。每一步都带可运行代码。

实测环境：Debian 13，R 4.3.2，ggplot2 3.5.0。

1. 数据准备——用真实表达矩阵演示#

1
library(tidyverse)
2
library(ggplot2)
3

4
# 模拟差异表达结果（5000个基因）
5
set.seed(42)
6
degs <- tibble(
7
    gene_id = paste0("ENSG", sprintf("%08d", 1:5000)),
8
    log2FC = rnorm(5000, mean = 0, sd = 1.2),
9
    pvalue = runif(5000, 0, 1),
10
    padj = p.adjust(pvalue, method = "BH"),
11
    baseMean = 10^rnorm(5000, mean = 3, sd = 1.5)
12
) %>%
13
    mutate(
14
        direction = case_when(
15
            log2FC > 1 & padj < 0.05 ~ "Up",
16
            log2FC < -1 & padj < 0.05 ~ "Down",
17
            TRUE ~ "NS"
18
        )
19
    )
20

21
# 统计
22
degs %>% count(direction)

展开收起

2. 默认图 vs 学术图——差在哪里#

先看默认输出，记住它的样子：

1
# 默认版本（丑但能跑）
2
p_default <- ggplot(degs, aes(x = log2FC, y = -log10(padj), color = direction)) +
3
    geom_point()
4
ggsave("default.png", p_default, width = 8, height = 6, dpi = 72)

默认图的问题清单：

灰底灰网格——期刊一律要求白底
默认配色饱和度拉满——大红大蓝打印出来一团黑
字体太小——缩放到页面宽度后坐标轴标签看不清
图例标题 “direction” 没人知道什么意思
散点透明度不设——几十万个点糊在一起

下面一步一步修。

3. 配色——从默认到 CNS 级别#

3.1 配色原则#

学术配色的核心约束：打印友好 + 色盲友好 + 期刊限制。

大部分期刊（Nature、Cell、Science）接受彩色图但要额外收费，所以很多人投稿用灰阶兼容的配色。推荐两个方案：

方案	包	适用
viridis	`scale_color_viridis_d()`	连续/离散都行，色盲友好
ggsci	`scale_color_npg()` 等	模仿 CNS 期刊常用色板
RColorBrewer	`scale_color_brewer()`	经典学术色板

1
library(viridis)
2
library(ggsci)
3

4
# 方案A：viridis（色盲友好，连续型适合热图）
5
p_viridis <- ggplot(degs, aes(x = log2FC, y = -log10(padj), color = direction)) +
6
    geom_point(alpha = 0.4, size = 0.6) +
7
    scale_color_viridis_d(option = "D", end = 0.85)
8

9
# 方案B：ggsci 的 NPG 色板（Nature Publishing Group 风格）
10
p_npg <- ggplot(degs, aes(x = log2FC, y = -log10(padj), color = direction)) +
11
    geom_point(alpha = 0.4, size = 0.6) +
12
    scale_color_npg()
13

14
# 方案C：手动指定——最可控
15
p_custom <- ggplot(degs, aes(x = log2FC, y = -log10(padj), color = direction)) +
16
    geom_point(alpha = 0.4, size = 0.6) +
17
    scale_color_manual(
18
        values = c("Up" = "#E64B35", "Down" = "#4DBBD5", "NS" = "#BBBBBB"),
19
        labels = c("Up" = "Up-regulated", "Down" = "Down-regulated", "NS" = "Not significant"),
20
        name = ""  # 去掉图例标题
21
    )

展开收起

Pro tip： 手动配色用十六进制，在 colorbrewer2.org 上挑。红-蓝对是生信火山图的事实标准。

3.2 连续型配色——表达量热图#

热图用连续渐变色。默认从暗蓝到亮蓝——审稿人看了想打人。

1
# 经典红-白-蓝（低表达白，高表达红）
2
ggplot(heatmap_data, aes(x = sample, y = gene, fill = expression)) +
3
    geom_tile() +
4
    scale_fill_gradient2(
5
        low = "#2166AC",    # 深蓝（低表达）
6
        mid = "#F7F7F7",    # 白色（中间值）
7
        high = "#B2182B",   # 深红（高表达）
8
        midpoint = 0,
9
        name = "Z-score"
10
    )

这里的核心是 midpoint 参数——如果数据不是对称的（比如只有上调没有下调），要把 midpoint 设成中位数而不是 0。

4. 主题——告别灰色背景#

1
# 主题选择链
2
p_base <- ggplot(degs, aes(x = log2FC, y = -log10(padj), color = direction)) +
3
    geom_point(alpha = 0.4, size = 0.6) +
4
    scale_color_manual(
5
        values = c("Up" = "#E64B35", "Down" = "#4DBBD5", "NS" = "#BBBBBB")
6
    )
7

8
# 方案A：theme_bw() + 微调（最常用）
9
p_bw <- p_base + theme_bw(base_size = 12) +
10
    theme(
11
        panel.grid.minor = element_blank(),   # 去掉次要网格
12
        panel.grid.major = element_line(linewidth = 0.3, color = "grey90"),
13
        legend.position = c(0.9, 0.85),        # 图例放右上角
14
        legend.background = element_rect(fill = "white", color = "grey80"),
15
        legend.key.size = unit(0.4, "cm")
16
    )
17

18
# 方案B：theme_minimal() + 边框（Nature 风格）
19
p_nature <- p_base + theme_minimal(base_size = 12) +
20
    theme(
21
        panel.border = element_rect(fill = NA, color = "black", linewidth = 0.8),
22
        panel.grid = element_blank(),
23
        axis.line = element_blank(),
24
        legend.position = "right"
25
    )
26

27
# 方案C：theme_classic()（最简单，像Excel图但干净）
28
p_classic <- p_base + theme_classic(base_size = 12) +
29
    theme(
30
        axis.line = element_line(color = "black", linewidth = 0.5),
31
        legend.position = "right"
32
    )

展开收起

base_size 参数的秘密： 全图字体基于这个值缩放。设 12，最终导出的 PDF 放论文里刚刚好。缩到期刊半页宽度（约 80mm）时，base_size 设 10。

4.1 自定义主题——一次定义，终生复用#

1
# 定义你自己的学术主题
2
theme_academic <- function(base_size = 12) {
3
    theme_bw(base_size = base_size) %+replace%
4
    theme(
5
        panel.grid.minor = element_blank(),
6
        panel.grid.major = element_line(linewidth = 0.3, color = "grey92"),
7
        panel.border = element_rect(fill = NA, color = "black", linewidth = 0.8),
8
        strip.background = element_rect(fill = "grey95", color = "black"),
9
        strip.text = element_text(size = base_size - 1, face = "bold"),
10
        axis.text = element_text(color = "black"),
11
        axis.title = element_text(size = base_size),
12
        legend.position = "bottom",
13
        legend.key.size = unit(0.5, "cm"),
14
        plot.title = element_text(size = base_size + 2, face = "bold", hjust = 0.5),
15
        plot.subtitle = element_text(size = base_size, hjust = 0.5)
16
    )
17
}
18

19
# 使用
20
p_final <- p_base + theme_academic(base_size = 12)

展开收起

5. 统计标注——ggpubr 一键加 p 值#

1
library(ggpubr)
2

3
# 箱线图 + 显著性标注
4
data(mtcars)
5
ggplot(mtcars, aes(x = factor(cyl), y = mpg, fill = factor(cyl))) +
6
    geom_boxplot(outlier.shape = NA, width = 0.6) +
7
    geom_jitter(width = 0.1, alpha = 0.5, size = 1.5) +
8
    stat_compare_means(
9
        comparisons = list(c("4", "6"), c("6", "8"), c("4", "8")),
10
        method = "t.test",
11
        label = "p.signif",      # 只显示显著性符号
12
        # label = "p.format",    # 显示精确 p 值
13
        step.increase = 0.08     # 星号往上挪
14
    ) +
15
    scale_fill_manual(values = c("#4DBBD5", "#E64B35", "#00A087")) +
16
    theme_academic(base_size = 12) +
17
    labs(x = "Cylinders", y = "Miles per Gallon", fill = "")

展开收起

label = "p.signif" 显示的是符号（*, **, ***），label = "p.format" 显示精确数值。SCI 通常要求给精确 p 值而不是星号——除非在 Figure Legend 里定义了阈值。

p 值的精确格式：

p=P(T≥∣t∣∣H0)p = P(T \geq |t| \mid H_0)p=P(T≥∣t∣∣H0)

在实际标注时，p<2.2×10−16p < 2.2 \times 10^{-16}p<2.2×10−16 是 R 的浮点精度极限——别写成 p=0p = 0p=0，那是错的。

6. 多图拼接——patchwork 无敌#

1
library(patchwork)
2

3
# 生成四个子图
4
p1 <- ggplot(degs, aes(x = log2FC, y = -log10(padj), color = direction)) +
5
    geom_point(alpha = 0.3, size = 0.5) +
6
    scale_color_manual(values = c("Up" = "#E64B35", "Down" = "#4DBBD5", "NS" = "#BBBBBB")) +
7
    theme_academic() +
8
    labs(title = "Volcano plot")
9

10
p2 <- ggplot(degs, aes(x = log2FC)) +
11
    geom_histogram(fill = "#4DBBD5", alpha = 0.7, bins = 60) +
12
    theme_academic() +
13
    labs(title = "log2FC distribution", x = "log2 Fold Change")
14

15
p3 <- ggplot(degs, aes(x = direction, fill = direction)) +
16
    geom_bar() +
17
    scale_fill_manual(values = c("Up" = "#E64B35", "Down" = "#4DBBD5", "NS" = "#BBBBBB")) +
18
    theme_academic() +
19
    labs(title = "DEG counts", x = "") +
20
    theme(legend.position = "none")
21

22
p4 <- ggplot(degs, aes(x = baseMean, y = log2FC)) +
23
    geom_point(alpha = 0.3, size = 0.5, color = "grey40") +
24
    scale_x_log10() +
25
    geom_hline(yintercept = c(-1, 1), linetype = "dashed", color = "red", alpha = 0.5) +
26
    theme_academic() +
27
    labs(title = "MA plot", x = "Mean expression (log10)")
28

29
# 拼接：上面两个下面两个（经典2×2）
30
combined <- (p1 | p2) / (p3 | p4) +
31
    plot_annotation(
32
        title = "RNA-seq Differential Expression Analysis",
33
        tag_levels = "A"  # 自动加 A/B/C/D 标签
34
    ) &
35
    theme(plot.tag = element_text(face = "bold", size = 14))
36

37
# 导出
38
ggsave("figure_panel.pdf", combined, width = 14, height = 10, device = cairo_pdf)

展开收起

patchwork 的灵魂操作符：

|：水平拼接
/：垂直拼接
+ plot_annotation()：加总标题和子图标签
& theme(...)：所有子图统一应用主题
plot_layout(guides = "collect")：合并相同的图例

7. 导出——像素级控制#

1
# PDF（矢量，期刊首选）
2
ggsave("figure.pdf", p_final, width = 8, height = 6, device = cairo_pdf)
3

4
# TIFF（300dpi 位图，Cell/Nature 要求）
5
ggsave("figure.tiff", p_final, width = 8, height = 6, dpi = 300,
6
       device = "tiff", compression = "lzw")
7

8
# PNG（预览用）
9
ggsave("figure_preview.png", p_final, width = 8, height = 6, dpi = 150)
10

11
# SVG（矢量，适合进一步在 Illustrator 里编辑）
12
ggsave("figure.svg", p_final, width = 8, height = 6)

期刊宽度换算：

单栏：80-90mm ≈ 3.15-3.54 inch
双栏/整页：170-180mm ≈ 6.7-7.1 inch

1
# 适配单栏宽度
2
ggsave("figure_single_col.pdf", p_final, width = 3.5, height = 3, device = cairo_pdf)

8. 两个高级技巧#

8.1 火山图基因标签（ggrepel）#

1
library(ggrepel)
2

3
# 标记 top10 基因
4
top_genes <- degs %>%
5
    filter(padj < 0.05) %>%
6
    slice_max(order_by = abs(log2FC), n = 10)
7

8
ggplot(degs, aes(x = log2FC, y = -log10(padj), color = direction)) +
9
    geom_point(alpha = 0.4, size = 0.6) +
10
    geom_text_repel(
11
        data = top_genes,
12
        aes(label = gene_id),
13
        size = 3,
14
        max.overlaps = 15,
15
        box.padding = 0.5,
16
        force = 2
17
    ) +
18
    scale_color_manual(
19
        values = c("Up" = "#E64B35", "Down" = "#4DBBD5", "NS" = "#BBBBBB")
20
    ) +
21
    theme_academic()

展开收起

8.2 分面(facet)——一组图自动拆分#

1
# 按染色体分面展示（模拟数据）
2
degs_chr <- degs %>%
3
    mutate(chr = sample(paste0("chr", 1:22), nrow(degs), replace = TRUE)) %>%
4
    filter(chr %in% paste0("chr", 1:6))
5

6
ggplot(degs_chr, aes(x = baseMean, y = log2FC)) +
7
    geom_point(alpha = 0.3, size = 0.3, color = "grey40") +
8
    facet_wrap(~ chr, ncol = 3, scales = "free_x") +
9
    theme_academic(base_size = 9) +
10
    labs(x = "Mean expression", y = "log2 Fold Change")

9. 踩坑记录#

坑1：PDF 里中文字体全是方框#

症状：ggsave("figure.pdf") 打开，中文标题全变成 □□□。

解决： 用 cairo_pdf 设备，它能通过 fontconfig 找到系统中文字体。

1
ggsave("figure.pdf", p, device = cairo_pdf)
2

3
# 或者全局设置
4
options(bitmapType = "cairo")

如果还是不行，检查系统有无中文字体：

Terminal window

1
fc-list :lang=zh | head -5

没有就装：

Terminal window

1
sudo apt install fonts-noto-cjk -y

坑2：`ggsave` 尺寸用错了单位#

症状：ggsave("fig.png", p, width = 80, height = 60) 输出 80 英寸宽的图，几十 MB。

原因： width 和 height 单位是英寸（inch），不是毫米。。

换算公式： inch=mm25.4\text{inch} = \frac{\text{mm}}{25.4}inch=25.4mm

80mm ≈ 3.15 inches。别直接写 80。

坑3：`stat_compare_means` 报 `Can't compute p-value`#

1
# 报错示例
2
stat_compare_means(comparisons = list(c("A", "B")), method = "t.test")
3
# Error: not enough 'x' observations

原因：某个分组样本数太少（比如 n=1），t 检验需要至少 2 个样本。

检查：

1
table(metadata$group)
2

3
# 如果某组 n=1，用 Wilcoxon（非参数）或换可视化方式
4
stat_compare_means(method = "wilcox.test")

坑4：patchwork 拼接后图例重复出现#

症状：(p1 | p2) / (p3 | p4) 四个子图的图例各出现一次，占了 1/3 画面。

解决： 把所有图的 legend 统一收集：

1
combined <- (p1 | p2) / (p3 | p4) +
2
    plot_layout(guides = "collect") &
3
    theme(legend.position = "bottom")

plot_layout(guides = "collect") 会自动合并相同的图例。& theme(legend.position = "bottom") 把合并后的图例放到底部。

坑5：ggsave 后的图在当前设备上不显示#

症状：跑完 ggsave("x.pdf", p)，RStudio 的 Plots 面板空白。

原因： ggsave 默认关闭当前图形设备。不影响实际导出，但会让你以为代码没运行。

解决： 导出后重新打印一次图：

1
ggsave("x.pdf", p)  # 导出
2
print(p)            # 在当前设备中重新显示

或者用 ggsave(..., create.dir = TRUE) 至少保证目录存在。更好的习惯是——在脚本最后加一行 p_final 让图自动在 console 里重新渲染。

本文于 2025-07-22 在 Debian 13 + R 4.3.2 上实测。所有代码可直接复制运行。

生物信息学数据库全景：序列/表达/功能/变异

Tue, 08 Jul 2025 00:00:00 GMT

生信分析中有一个定律：你遇到的问题 90% 别人已经遇到过，80% 有现成的数据库可以查。 关键是你得知道去哪查。

本文整理生信最常用的 15 个免费数据库，按分析场景分类：序列类、表达类、功能类、变异类、表观类。

1. 序列类——找基因找序列#

数据库	内容	URL	使用方式
NCBI Nucleotide	所有已知核酸序列	ncbi.nlm.nih.gov/nucleotide	Entrez API / 网页下载
Ensembl	高质量基因组注释	ensembl.org	BioMart批量下载
UCSC Genome Browser	基因组浏览器+注释track	genome.ucsc.edu	Table Browser导出
RefSeq	NCBI精选参考序列	—	包含在NCBI中

怎么选： 人类/小鼠用 Ensembl，其他物种用 NCBI，需要看基因组track用 UCSC。

2. 表达类——找表达数据#

数据库	规模	适用
GEO	600万+样本	小规模研究、练手
SRA	海量原始数据	需要原始FASTQ
TCGA	33种癌症、2万+样本	癌症研究
GTEx	54种组织、1万+样本	正常组织表达参照
ENCODE	多组学标准化数据	表观+表达整合

TCGA下载：

1
BiocManager::install("TCGAbiolinks")
2
library(TCGAbiolinks)
3
query <- GDCquery(project = "TCGA-BRCA", data.category = "Transcriptome Profiling")
4
GDCdownload(query)

3. 功能类——注释基因功能#

数据库	用途	关键工具
UniProt	蛋白质功能注释	Swiss-Prot（人工审核，可靠）
GO	基因本体论	富集分析
KEGG	代谢通路	pathway可视化
STRING	蛋白质互作网络	PPI网络构建
Reactome	信号通路	更现代的pathway数据库

快速查一个基因的功能：

Terminal window

1
curl "https://rest.uniprot.org/uniprotkb/search?query=TP53&format=tsv" | head -5

4. 变异类#

数据库	规模	用途
dbSNP	人类SNP全集	变异ID标准化
gnomAD	14万人外显子组	人群频率过滤
ClinVar	临床致病性	变异致病性注释
COSMIC	癌症体细胞突变	肿瘤突变谱

gnomAD是变异过滤的黄金标准。 如果你的候选变异在 gnomAD 中人群频率 > 0.01（1%），大概率是多态性而非致病突变。

5. 表观类#

数据库	内容
ENCODE	标准化ChIP-seq/ATAC-seq/DNase-seq
Roadmap Epigenomics	127种组织的表观图谱
FANTOM5	CAGE表达+增强子图谱

6. 数据库API——程序化查询#

1
# 查UniProt
2
import requests
3
r = requests.get("https://rest.uniprot.org/uniprotkb/P04637",
4
    headers={"Accept": "application/json"})
5
print(r.json()["proteinDescription"]["recommendedName"]["fullName"]["value"])
6

7
# 查Ensembl
8
from Bio import Entrez
9
Entrez.email = "your@email.com"
10
handle = Entrez.esearch(db="gene", term="BRCA1[Gene] AND Homo sapiens[Organism]", retmax=1)
11
record = Entrez.read(handle)
12
print(record["IdList"])

7. 踩坑#

数据库版本要固定——Ensembl 和 UCSC 每年更新。写论文时注明数据库版本号。
TCGA 数据需要申请——contrrolled-access 数据需要 dbGaP 申请，open-access 可以随便下。

本文于 2025-07-08 实测。

Git版本控制：项目管理全流程

Thu, 03 Jul 2025 00:00:00 GMT

生信项目的脚本经常经历多次修改——调参数、换软件版本、修 bug。没有版本控制时，目录里满是 analysis_v1.sh、analysis_v2_fixed_final.sh，三个月后很难追溯哪个版本产出了哪些结果。

Git 在生信中的价值常被低估。核心问题：分析结果能复现吗？三个月前的代码还能跑吗？协作时参数变更可追溯吗？本文覆盖 Git 全流程：初始化、分支策略、.gitignore 配置、大文件处理、版本回退、协*生信项目里 Git 的实际用法**，重点是防坑和提效，不是 Git 语法手册。

实测环境：Debian 13，Git 2.45.2。

1. 初始化——生信项目的第一步#

1.1 从零开始#

Terminal window

1
# 创建项目目录并初始化 Git
2
mkdir rnaseq-brca-analysis
3
cd rnaseq-brca-analysis
4
git init
5

6
# 查看状态
7
git status

1.2 立即创建 .gitignore#

生信项目里 .gitignore 比代码还重要——否则一个 git add . 会把几十 GB 的 FASTQ 和 BAM 文件全部纳入版本控制。

Terminal window展开收起

1
# .gitignore —— 生信项目标准模板
2
cat > .gitignore << 'EOF'
3
# === 数据文件（太大，不纳入版本控制） ===
4
*.fastq
5
*.fastq.gz
6
*.fq
7
*.fq.gz
8
*.bam
9
*.bai
10
*.sam
11
*.cram
12
*.vcf
13
*.vcf.gz
14
*.bcf
15
*.bigwig
16
*.bw
17
*.bedgraph
18

19
# === 参考基因组和索引（从特定路径引用，不复制） ===
20
*.fa
21
*.fa.gz
22
*.fa.fai
23
*.dict
24
*.mmi
25
*.bwt
26
*.pac
27
*.sa
28
*.ann
29
*.amb
30
*.ht2
31
*.bt2
32

33
# === 中间结果 ===
34
tmp/
35
temp/
36
*.tmp
37
*.log
38
*.o
39
*.e
40
work/
41
.nextflow/
42
.nextflow.log*
43

44
# === Python ===
45
__pycache__/
46
*.py[cod]
47
*.so
48
*.egg-info/
49
.eggs/
50
dist/
51
build/
52
*.whl
53

54
# === R ===
55
.Rproj.user/
56
.Rhistory
57
.RData
58
.Ruserdata
59
*.Rproj
60

61
# === Conda ===
62
conda_env/
63
envs/
64

65
# === 编辑器/IDE ===
66
.vscode/
67
.idea/
68
*.swp
69
*.swo
70
*~
71
.DS_Store
72

73
# === 敏感信息 ===
74
.env
75
*.key
76
*.token
77
config.local.sh
78

79
# === Jupyter ===
80
.ipynb_checkpoints/
81

82
# === 系统文件 ===
83
Thumbs.db
84
Desktop.ini
85
EOF

展开收起

每个生信项目都应该根据实际需求调整 .gitignore。

1.3 初始提交#

Terminal window

1
git add .gitignore
2
git commit -m "chore: initialize project with .gitignore"
3

4
# 添加项目骨架
5
mkdir -p scripts data results docs logs config
6
git add scripts/ docs/ config/
7
git commit -m "feat: add project directory structure"

2. 分支策略——一个人 vs 团队的用法#

2.1 单人项目（简单模式）#

Terminal window

1
# 直接在 main 上工作也行，但建议至少分两个分支
2
# main: 稳定版本
3
# dev:  开发中的代码
4

5
git checkout -b dev
6

7
# 在 dev 上做分析开发...
8
git add scripts/deseq2_analysis.R
9
git commit -m "feat: add DESeq2 differential expression analysis"
10

11
# 跑通了，合并回 main
12
git checkout main
13
git merge dev
14
git tag -a "v1.0.0" -m "First complete analysis: BRCA tumor vs normal"

2.2 团队协作（推荐 Git Flow 简化版）#

Terminal window展开收起

1
# main:       生产就绪代码
2
# dev:        开发主线
3
# feature/*:  新特性分支
4
# hotfix/*:   紧急修复分支
5
# release/*:  发布准备分支
6

7
# 开始一个新分析
8
git checkout -b feature/gsea-analysis dev
9

10
# 开发完成
11
git checkout dev
12
git merge feature/gsea-analysis
13
git branch -d feature/gsea-analysis
14

15
# 发布版本
16
git checkout -b release/v2.0 main
17
# 在 release 分支上做最后测试和微调
18
git checkout main
19
git merge release/v2.0
20
git tag -a "v2.0.0" -m "Release v2.0: Added GSEA pathway analysis"

展开收起

2.3 生信特有的分支场景#

Terminal window

1
# 参数探索分支——尝试不同参数组合
2
git checkout -b exp/deseq2-lfcShrink-vs-normal
3
# ...试完了，如果效果好就合并，否则直接删掉
4

5
# 数据子集分支——分析不同 cohort
6
git checkout -b analysis/tcga-cohort
7
git checkout -b analysis/gtex-cohort

3. 提交信息规范——三个月后还能看懂#

生信项目建议使用约定式提交（Conventional Commits）：

Terminal window

1
# 格式：<type>: <简短描述>
2

3
# 好的提交信息
4
git commit -m "feat: add STAR alignment script with 2-pass mode"
5
git commit -m "fix: correct strand-specific parameter in featureCounts"
6
git commit -m "refactor: extract QC functions into separate R script"
7
git commit -m "docs: add pipeline usage instructions to README"
8
git commit -m "data: update sample metadata with new clinical info"
9
git commit -m "perf: parallelize DESeq2 with BiocParallel (8 cores)"
10

11
# 避免这种提交信息
12
git commit -m "update"
13
git commit -m "fix bug"
14
git commit -m "asdfghjkl"

类型速查：

type	用途	生信例子
`feat`	新功能/新分析	新增差异表达分析脚本
`fix`	修bug	修复样本配对逻辑错误
`refactor`	重构代码	提取公共函数到 utils.R
`docs`	文档	更新 README 使用说明
`data`	元数据变更	更新样本分组信息
`perf`	性能优化	多线程并行提速
`chore`	杂项	更新 .gitignore

4. 大文件处理——生信的核心痛点#

4.1 Git 不适合存大文件#

Git 的设计目标是文本源码，不是二进制大文件。一个 1GB 的 BAM 文件提交进去，整个仓库就成了灾难。GitHub 单文件限制 100MB，超过就会拒绝 push。生信数据文件动辄几十 GB，该怎么管？

4.2 Git LFS——大文件版本控制#

Terminal window

1
# 安装 Git LFS
2
sudo apt install git-lfs -y
3
git lfs install
4

5
# 追踪特定文件类型
6
git lfs track "*.bam"
7
git lfs track "*.fastq.gz"
8
git lfs track "data/genome/*.fa"
9

10
# .gitattributes 会自动生成
11
# 然后正常 add/commit/push
12
git add data/genome/Homo_sapiens.GRCh38.dna.primary_assembly.fa
13
git commit -m "data: add reference genome (tracked by LFS)"

但我的建议是：能不用 LFS 就不用。 参考基因组和大数据文件应该通过绝对路径引用或脚本下载，而不是塞进 Git。

scripts/download_refs.sh

1
# 更好的做法：脚本化数据获取
2
#!/bin/bash
3
set -euo pipefail
4
REF_DIR="${1:-/opt/refs/hg38}"
5
mkdir -p "${REF_DIR}"
6
cd "${REF_DIR}"
7
wget -c ftp://ftp.ensembl.org/pub/release-113/fasta/homo_sapiens/dna/Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz
8
gunzip Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz
9
echo "Reference downloaded to ${REF_DIR}"

5. 版本回退——救命操作#

5.1 查看历史#

Terminal window

1
# 简洁的提交历史
2
git log --oneline --graph --decorate -20
3

4
# 查看某个文件的历史
5
git log -p scripts/deseq2_analysis.R
6

7
# 查看某次提交改了什么
8
git show a1b2c3d
9

10
# 查看谁改了什么（blame）
11
git blame scripts/utils.R

5.2 撤销操作#

Terminal window展开收起

1
# 1. 撤销工作区的修改（还没 add）
2
git checkout -- scripts/broken_analysis.R
3

4
# 2. 撤销暂存区的修改（已经 add，还没 commit）
5
git reset HEAD scripts/broken_analysis.R
6
git checkout -- scripts/broken_analysis.R
7

8
# 3. 撤销最近一次提交（保留修改）
9
git reset --soft HEAD~1
10

11
# 4. 撤销最近一次提交（丢弃修改，危险！）
12
git reset --hard HEAD~1
13

14
# 5. 创建一个新提交来"撤销"旧提交（安全，推荐）
15
git revert a1b2c3d
16

17
# 6. 回到历史某个版本看看（不修改分支）
18
git checkout a1b2c3d
19
# 看完后回来：
20
git checkout main

展开收起

5.3 救命稻草——git reflog#

Terminal window

1
# 即使 reset --hard 后也能找回
2
git reflog
3
# a1b2c3d HEAD@{0}: reset: moving to HEAD~1
4
# d4e5f6g HEAD@{1}: commit: feat: add important analysis
5
# ...
6

7
# 恢复到误删之前的提交
8
git reset --hard d4e5f6g

reflog 是我最感谢 Git 的功能。 生信里经常试验性地改参数，改完发现不对想回去，reflog 就是时光机。

6. 与远程仓库协作#

Terminal window展开收起

1
# 关联 GitHub/GitLab/Gitee
2
git remote add origin git@github.com:username/rnaseq-brca-analysis.git
3

4
# 首次推送
5
git push -u origin main
6

7
# 日常推送
8
git add scripts/
9
git commit -m "feat: add GSEA visualization"
10
git push
11

12
# 拉取协作者的更新
13
git pull origin main
14

15
# 处理冲突
16
git pull origin main
17
# CONFLICT (content): Merge conflict in scripts/utils.R
18
# 手动编辑冲突文件，然后：
19
git add scripts/utils.R
20
git commit -m "merge: resolve conflict in utils.R"

展开收起

7. 踩坑记录#

坑1：把大文件提交了。 即使后来从 .gitignore 排除了，Git 历史里仍然存着这个文件。解决方法：git filter-branch 或 git filter-repo 从历史中彻底清除。在 git add 之前检查 git status，一旦发现大文件立刻撤销。

坑2：Windows 和 Linux 换行符冲突。 Windows 用 \r\n，Linux 用 \n。Git 默认可能自动转换换行符，导致 Shell 脚本在 Linux 上无法执行。在项目根目录创建 .gitattributes：

1
* text=auto
2
*.sh text eol=lf
3
*.R text eol=lf
4
*.py text eol=lf

坑3：git pull 产生不必要的合并提交。 用 git pull --rebase 代替默认的 merge，保持历史线性。或者全局设置：git config --global pull.rebase true。

坑4：分支命名混乱导致找不到代码。 统一命名规范：feature/描述、fix/描述、analysis/描述。每完成一个分析就打 tag：git tag -a "analysis/deseq2-v1" -m "DESeq2 results for manuscript Fig2"。

坑5：敏感信息提交到了公开仓库。 密码、API Key、Token 一旦 push 到 GitHub 就永久留在历史里。永远不要硬编码凭据，用环境变量或 .env 文件（加到 .gitignore）。如果已经泄露，立即 revoke token 并用 git filter-repo 清除。

坑6：直接在 main 分支上做实验性分析。 分析跑了两周发现方向错了，但 main 分支已经被改得面目全非。新分析一定开新分支，即使只是一个人。

坑7：忘记写 .gitignore 导致 data 目录被跟踪。 运行一次 git rm -r --cached data/ 可以从 Git 跟踪中移除但保留本地文件，然后更新 .gitignore 并提交。

本文于 2025-07-03 在 Debian 13 上实测。

生信文件格式：FASTQ/SAM/BAM/VCF/GFF/BED

Wed, 25 Jun 2025 00:00:00 GMT

FASTQ、SAM/BAM、VCF、GFF/GTF、BED——这些是生信分析中出现频率最高的文件格式。了解每种格式的结构和用途是读懂流程的前提。本文覆盖 7 种核心格式的结构解析、用途对比和互转方式。

1. FASTQ——最原始的数据#

每4行一条read：

1
@SEQ_ID
2
ATCGATCGATCGATCGATCG
3
+
4
IIIIIIIIIIIIIIIIIII

第1行：@开头 + read ID
第2行：序列
第3行：+（可选带ID）
第4行：质量分数（Phred+33编码）

质量分数公式： Q=−10×log⁡10(Perror)Q = -10 \times \log_{10}(P_{error})Q=−10×log10(Perror)，ASCII码 = Q + 33。

单个文件常用工具：seqkit stats、fastqc、head -4。

2. FASTA——参考序列和转录本#

1
>gene_id description
2
ATCGATCGATCGATCG...

> 开头行是ID，可以包含多个字段（用 | 分隔）
序列可以换行，但建议单行（seqtk seq可以整理）

3. SAM/BAM——比对结果#

SAM是文本、BAM是二进制压缩版（体积小70-90%）。

1
read1  0  chr1  100  42  50M  *  0  0  ATCG...  IIII...

核心转换：

Terminal window

1
samtools view -bS input.sam > output.bam   # SAM→BAM
2
samtools view -h output.bam > output.sam   # BAM→SAM

4. VCF——变异信息#

1
#CHROM  POS  ID  REF  ALT  QUAL  FILTER  INFO
2
chr1    100  .   A    G    50    PASS    DP=100

VCF v4.2 是当前标准
可以压缩为 .vcf.gz，配合 .vcf.gz.tbi 索引使用
变异注释通常用 snpEFF/VEP

5. GFF/GTF——基因组注释#

1
chr1  .  gene  1000  2000  .  +  .  gene_id "GENE1";
2
chr1  .  exon  1000  1200  .  +  .  gene_id "GENE1";

GFF vs GTF：

GFF（Generic Feature Format）：灵活，9列
GTF（Gene Transfer Format）：GFF的子集，多了 gene_id 和 transcript_id 约定

二者最大区别——坐标系统： GFF是1-based closed（[start, end]），GTF也是1-based。但BED是0-based half-open。

6. BED——区间信息#

最少3列：chrom start end。0-based。

Terminal window

1
# GFF→BED（start要减1）
2
awk '$3=="gene" {print $1"\t"$4-1"\t"$5}' annotation.gff > genes.bed

7. 格式转换命令速查#

从	到	命令
SAM	BAM	`samtools view -bS`
BAM	SAM	`samtools view -h`
FASTQ	FASTA	`seqkit fq2fa`
BAM	BED	`bedtools bamtobed`
GFF	BED	`awk '{print $1"\t"$4-1"\t"$5}'`
BED	bigBed	`bedToBigBed`
bedGraph	bigWig	`bedGraphToBigWig`

8. 常用验证命令#

Terminal window

1
# 检查GFF格式合法性
2
gff3validator annotation.gff
3

4
# 检查BAM完整性
5
samtools quickcheck input.bam && echo "OK" || echo "CORRUPT"
6

7
# 检查VCF压缩+索引
8
bcftools index -t input.vcf.gz && echo "Index OK"
9

10
# 检查FASTA序列长度
11
infoseq input.fasta | head

本文于 2025-06-25 实测。

SSH远程连接进阶：免密登录、跳板机、端口转发

Wed, 18 Jun 2025 00:00:00 GMT

SSH 不仅仅是 ssh user@ip，进阶用法包括：密钥认证免密登录、~/.ssh/config 多主机管理、ProxyJump 跳板穿越、本地/远程/动态端口转发、SSHFS 远程挂载。本文覆盖这些技巧的完整配置和常见坑，附 6 个踩坑记录。

实测环境：Debian 13 客户端 + Ubuntu 22.04 服务器，OpenSSH 9.6。

1. 密钥认证——告别密码#

1.1 生成密钥对#

Terminal window

1
# 推荐 ed25519（比 RSA 更快更安全）
2
ssh-keygen -t ed25519 -C "bioinfo@lab-server"
3

4
# 一路回车即可（或设个密码保护私钥）
5
# 默认生成：~/.ssh/id_ed25519（私钥）和 ~/.ssh/id_ed25519.pub（公钥）

如果你用的是旧系统只支持 RSA：

Terminal window

1
ssh-keygen -t rsa -b 4096 -C "bioinfo@lab-server"

1.2 把公钥上传到服务器#

Terminal window

1
# 方法1：ssh-copy-id（最简单）
2
ssh-copy-id user@192.168.1.100
3

4
# 方法2：手动追加（适用于权限受限的环境）
5
cat ~/.ssh/id_ed25519.pub | ssh user@192.168.1.100 \
6
    'mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys'

上传完测试一下：

Terminal window

1
ssh user@192.168.1.100
2
# 应该不用密码直接进去了

1.3 安全加固#

在服务器上编辑 /etc/ssh/sshd_config：

Terminal window

1
# 禁用密码登录（配好密钥后再做！）
2
PasswordAuthentication no
3

4
# 禁用 root 直接登录
5
PermitRootLogin no
6

7
# 改个非标准端口（减少暴力破解）
8
Port 2222
9

10
# 重启 sshd
11
sudo systemctl restart sshd

⚠️ 在禁用密码登录前一定确认密钥能用，保留一个已登录的终端窗口以防万一。

2. ~/.ssh/config——多主机管理神器#

经常要连多台服务器：集群登录节点、数据存储服务器、云上的 GPU 实例……每次都敲一长串 IP 和参数太累了。~/.ssh/config 解决这个问题。

~/.ssh/config展开收起

1
Host cluster
2
    HostName 192.168.1.100
3
    User bioinfo
4
    Port 22
5
    IdentityFile ~/.ssh/id_ed25519
6
    ServerAliveInterval 60
7
    ServerAliveCountMax 3
8

9
Host gpu-server
10
    HostName 10.0.0.50
11
    User zhang
12
    Port 2222
13
    IdentityFile ~/.ssh/gpu_key
14

15
Host cloud-node
16
    HostName ec2-11-22-33-44.compute-1.amazonaws.com
17
    User ubuntu
18
    IdentityFile ~/.ssh/aws_key.pem

展开收起

配好后登录就简单了：

Terminal window

1
# 之前
2
ssh zhang@10.0.0.50 -p 2222 -i ~/.ssh/gpu_key
3

4
# 之后
5
ssh gpu-server

ServerAliveInterval 60 是防止连接因空闲被断开——每 60 秒发一个心跳包，对尤其重要（跑个 BWA 就要几小时，回来发现终端断了真的很崩溃）。

3. 跳板机——访问内网集群#

很多学校/公司的计算集群只开放一个跳板机（bastion）对外，集群节点都在内网。你需要先 SSH 到跳板机，再从跳板机跳到计算节点。

3.1 传统做法（两次 SSH）#

Terminal window

1
ssh user@bastion.example.com    # 先到跳板机
2
ssh compute-node-01             # 再从跳板机跳到计算节点

每次传文件还得 scp 两次，烦。

3.2 ProxyJump——一步到位#

~/.ssh/config

1
Host bastion
2
    HostName bastion.example.com
3
    User bioinfo
4

5
Host compute-01
6
    HostName 10.0.1.10
7
    User bioinfo
8
    ProxyJump bastion
9
    # 或 ProxyJump user@bastion.example.com

配置好之后直接 ssh compute-01，SSH 会自动经过跳板机转发，你感觉不到中间那层。

3.3 scp/rsync 也支持跳板#

Terminal window

1
# scp 通过跳板传文件到内网节点
2
scp -o ProxyJump=user@bastion.example.com data.txt compute-01:/data/
3

4
# rsync 同理
5
rsync -avz -e 'ssh -J user@bastion.example.com' ./results/ compute-01:/data/results/

如果你在 ~/.ssh/config 里配好了 ProxyJump，连 -J 都不用加——直接 scp data.txt compute-01:/data/ 就行。

3.4 多层跳板#

有的环境需要穿两层甚至三层：

~/.ssh/config

1
Host gateway
2
    HostName gw.example.com
3
    User bioinfo
4

5
Host internal
6
    HostName 10.0.0.5
7
    User bioinfo
8
    ProxyJump gateway
9

10
Host deep-node
11
    HostName 192.168.1.50
12
    User bioinfo
13
    ProxyJump internal    # 自动处理：local → gateway → internal → deep-node

SSH 会按 ProxyJump 链条自动建立隧道，你只需要 ssh deep-node。

4. 端口转发——生信三大场景#

4.1 本地端口转发（-L）：把远程服务映射到本地#

最常见的场景：你在服务器上起了 Jupyter Notebook 或 RStudio Server，想在本地浏览器打开。

Terminal window

1
# 在本地执行：把远程8888端口映射到本地8888
2
ssh -L 8888:localhost:8888 user@server
3

4
# 然后在本地浏览器打开 http://localhost:8888
5
# 就像 Jupyter 跑在本地一样！

格式：-L 本地端口:目标主机:目标端口。这里的 localhost 是相对于服务器的（从服务器角度看的目标主机）。

生信实战：访问集群内网的数据库

Terminal window

1
# UCSC Genome Browser 在集群内网的一台机器上跑着
2
# 映射到本地
3
ssh -L 8080:internal-db:8080 user@bastion
4

5
# 本地浏览器访问 http://localhost:8080 即可

4.2 远程端口转发（-R）：让外面能访问你本地的服务#

和内网穿透一个道理。比如你在笔记本上跑了一个数据可视化服务，想让服务器上的同事也能看：

Terminal window

1
# 在本地执行：把本地的3000端口暴露到服务器的9000端口
2
ssh -R 9000:localhost:3000 user@server
3

4
# 同事在服务器上访问 http://localhost:9000 就能看到你的可视化

生信场景： 你在本地分析数据用 RStudio，想让合作者在远程服务器上看到你的结果。或者反过来——帮远程同事调试环境。

4.3 动态端口转发（-D）：SSH 当 SOCKS 代理#

Terminal window

1
# 在本地起一个 SOCKS5 代理
2
ssh -D 1080 user@server
3

4
# 浏览器或程序配置代理：SOCKS5, 127.0.0.1:1080
5
# 之后所有流量都走服务器出去

生信场景：服务器有学校订阅的期刊数据库访问权限，你在家办公时通过 -D 代理就能访问付费文献。

5. SSHFS——把远程目录挂载到本地#

有时候你不想 scp 来 scp 去，而是想直接把远程目录当本地盘操作：

Terminal window

1
# 安装
2
sudo apt install sshfs -y
3

4
# 挂载远程目录
5
mkdir ~/remote_data
6
sshfs user@server:/opt/bioinfo/data ~/remote_data
7

8
# 之后就能像操作本地文件一样操作远程文件
9
ls ~/remote_data/
10
cp ~/remote_data/sample.fastq.gz ./
11

12
# 卸载
13
fusermount -u ~/remote_data

生信场景： 用本地 IDE（VS Code/PyCharm）直接打开远程服务器上的代码目录编辑，像本地项目一样方便。VS Code 的 Remote-SSH 插件其实底层也是类似原理。

6. 防止断线——tmux/screen + SSH#

跑一个比对要 8 小时，如果 SSH 断线，进程会收到 SIGHUP 信号被杀死。解决方案：tmux 或 screen。

Terminal window展开收起

1
# 1. 先 SSH 到服务器
2
ssh user@server
3

4
# 2. 启动 tmux 会话
5
tmux new -s pipeline
6

7
# 3. 在 tmux 里跑你的任务
8
bwa mem -t 8 /opt/refs/hg38.fa sample_R1.fastq.gz sample_R2.fastq.gz | \
9
    samtools sort -o sample.bam
10

11
# 4. 按 Ctrl+B 然后 D 分离（detach），任务继续在后台跑
12

13
# 5. 你可以关掉 SSH，回家，第二天重新连上
14
ssh user@server
15
tmux attach -t pipeline   # 恢复会话，看到任务已经跑完了

展开收起

ServerAliveInterval 能防止空闲断开，但防不了网络波动。tmux 才是真正的断线保护。

7. 踩坑记录#

坑1：authorized_keys 权限错误导致密钥认证失败#

症状：密钥明明配好了，SSH 还是要密码。

排查：

Terminal window

1
# 在服务器上检查权限
2
ls -la ~/.ssh/
3
# authorized_keys 应该是 600（-rw-------）
4
# .ssh 目录应该是 700（drwx------）
5

6
# 修复
7
chmod 700 ~/.ssh
8
chmod 600 ~/.ssh/authorized_keys

SSH 对权限极其敏感。权限太宽松（如 644 或 777）会被直接拒绝。

坑2：ProxyJump 连接卡住不动#

症状：ssh -J bastion compute-01 卡住，没有任何错误信息。

原因多半是跳板机上没装 netcat 或 ProxyJump 的转发被中间某层防火墙 block 了。解决方法：

Terminal window

1
# ~/.ssh/config 用 ProxyCommand 替代 ProxyJump（更兼容）
2
Host compute-01
3
    HostName 10.0.1.10
4
    User bioinfo
5
    ProxyCommand ssh -W %h:%p bastion

-W %h:%p 是 SSH 的内置转发模式，不需要 netcat，兼容性更好。

坑3：端口转发时端口已被占用#

Terminal window

1
ssh -L 8888:localhost:8888 user@server
2
# bind [127.0.0.1]:8888: Address already in use
3

4
# 查谁在用
5
lsof -i :8888
6
# 或者杀掉占用的进程
7
# 或者换个本地端口
8
ssh -L 9999:localhost:8888 user@server

坑4：sshfs 断连后目录卡死#

症状：网络断开后，挂载目录 ls 直接卡死，Ctrl+C 都退不出来。

Terminal window

1
# 强制卸载
2
fusermount -uz ~/remote_data
3

4
# 如果还不行
5
sudo umount -l ~/remote_data

-u 是 unmount，-z 是 lazy（延迟卸载），-l 更暴力。sshfs 对网络稳定性要求高，长时操作建议 rsync 代替挂载。

坑5：ServerAliveInterval 设太短被服务器踢#

症状：ServerAliveInterval 60 设了，但服务器那边 ClientAliveCountMax 配合 ClientAliveInterval 算出来的超时时间更短，还是被踢。

其实 ServerAliveInterval 是客户端心跳，服务器端也有自己的超时策略。最佳实践是客户端和服务器都配置：

Terminal window

1
# 客户端 ~/.ssh/config
2
ServerAliveInterval 60
3
ServerAliveCountMax 5    # 连续5次没响应才断开 = 5分钟容忍
4

5
# 服务器 /etc/ssh/sshd_config
6
ClientAliveInterval 120
7
ClientAliveCountMax 3

坑6：把私钥发到了群聊里#

这个不算技术坑，但我觉得必须说——。私钥绝对不能分享，就像银行卡密码一样。 公钥（.pub 结尾）可以随便发，那是用来贴到 authorized_keys 里的。

如果不小心泄露了私钥，立刻在服务器上删掉对应的公钥行，生成新密钥对。

8. 小结#

需求	命令/配置	秘诀
免密登录	`ssh-keygen` + `ssh-copy-id`	权限必须 600
多主机管理	`~/.ssh/config` 配 Host 别名	告别记 IP
跳板穿透	`ProxyJump bastion`	一行配置，多层穿透
本地转发	`ssh -L 8888:localhost:8888`	映射远程服务到本地
远程转发	`ssh -R 9000:localhost:3000`	暴露本地服务到远程
SOCKS代理	`ssh -D 1080`	走服务器上网
远程挂载	`sshfs user@server:/data ~/mnt`	当本地盘用
断线保护	tmux/screen	SSH断了任务继续跑

SSH 是每天接触最多的工具之一，把这些用熟了，每天至少省 15 分钟。下一期写 Linux 进程管理——htop/ps/kill/nice 把服务器管明白。

本文于 2025-06-18 在 Debian 13 上实测完成。OpenSSH 9.6，tmux 3.4。所有配置可直接使用。

参考基因组下载与索引准备：Ensembl/UCSC/NCBI

Sat, 14 Jun 2025 00:00:00 GMT

参考基因组有多个来源和版本：Ensembl、UCSC、NCBI（RefSeq）、GENCODE，每个又分 primary_assembly、toplevel、no_alt 等变体。选错版本可能导致比对率异常或注释错位。本文覆盖基因组版本选择、下载地址、索引准备（bwa/bowtie2/hisat2/samtools/GATK）和 GTF/GFF 注释文件获取的全流程。

实测环境：Debian 13，所有工具 Conda 安装。人类 GRCh38 为主要示例。

1. 三大来源的区别——先搞清楚你下载的是什么#

1.1 Ensembl#

Ensembl 是欧洲生物信息学研究所（EBI）维护的，特点是注释做得很好，GTF 文件结构清晰。大多数 RNA-seq 流程（STAR、Salmon、featureCounts）默认接受 Ensembl 格式。

下载地址：ftp://ftp.ensembl.org/pub/

Ensembl 的文件命名逻辑（以 GRCh38 release 113 为例）：

1
ftp://ftp.ensembl.org/pub/release-113/fasta/homo_sapiens/dna/
2
├── Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz       # 主组装（推荐）
3
├── Homo_sapiens.GRCh38.dna.toplevel.fa.gz               # 含单倍体/补丁
4
├── Homo_sapiens.GRCh38.dna_sm.toplevel.fa.gz             # soft-masked
5
├── Homo_sapiens.GRCh38.dna_rm.toplevel.fa.gz             # repeat-masked
6
└── Homo_sapiens.GRCh38.dna.alt.fa.gz                    # 仅alternate loci

文件类型	内容	适用场景	选还是不选
`primary_assembly`	主要染色体+未放置的 scaffold	RNA-seq、ChIP-seq	✅ 推荐
`toplevel`	primary + 单倍体 + 补丁	需要完整基因组信息	⚠️ 文件大，索引慢
`.dna_sm.`	soft-masked（重复序列小写）	重复序列敏感的比对	⚠️ 可选
`.dna_rm.`	repeat-masked（重复序列变N）	RepeatMasker 后再比对	❌ 一般不推荐

我的建议：RNA-seq 和 ChIP-seq 就用 primary_assembly。 理由：够用了，文件小，索引快，染色体名简洁（1, 2, 3... 而不是 chr1, chr2...）。

1.2 UCSC#

UCSC Genome Browser 的参考基因组，染色体名带 chr 前缀（chr1, chr2...），在美国用得更多。如果你下游要用 UCSC 的工具（bedGraphToBigWig、bigWig 可视化），UCSC 的命名更好。

下载地址：http://hgdownload.soe.ucsc.edu/goldenPath/hg38/bigZips/

Terminal window

1
# UCSC hg38 下载（约 3GB）
2
wget -c http://hgdownload.soe.ucsc.edu/goldenPath/hg38/bigZips/hg38.fa.gz

Ensembl vs UCSC 染色体名对比：

Ensembl	UCSC	说明
`1`	`chr1`	常染色体
`X`	`chrX`	性染色体
`MT`	`chrM`	线粒体
`GL000220.1`	`chrUn_GL000220v1`	未放置 scaffold

这个 chr 前缀是生信中最经典的坑之一。你的 BAM 里染色体叫 chr1，但参考基因组里叫 1——所有下游工具全炸。

1.3 NCBI/RefSeq#

NCBI 的 RefSeq 参考基因组，染色体名用 NCBI Accession（NC_000001.11），用的人少但某些工具链（如 GATK 的 bundle）会提供 NCBI 命名的参考。

下载地址：ftp://ftp.ncbi.nlm.nih.gov/genomes/all/GCF/000/001/405/

Terminal window

1
# NCBI GRCh38（GCF_000001405.40）
2
# 不推荐手动拼接 URL，用 datasets 工具
3
conda install -c conda-forge ncbi-datasets-cli -y
4
datasets download genome accession GCF_000001405.40 --include genome

我的建议：除非你的合作者指定用 NCBI，否则 Ensembl primary_assembly 或 UCSC hg38 就够了。 大部分生信软件对这两家的命名支持最好。

2. 完整下载流程——以 Ensembl 为例#

1
#!/bin/bash
2
# download_ref.sh —— 完整下载 Ensembl GRCh38 + GTF 注释
3

4
RELEASE=113
5
SPECIES="homo_sapiens"
6
ASSEMBLY="GRCh38"
7
BASE="ftp://ftp.ensembl.org/pub/release-${RELEASE}"
8
OUTDIR="./ref/GRCh38_ensembl"
9

10
mkdir -p "$OUTDIR"
11

12
# 1. 基因组 FASTA
13
echo "Downloading genome FASTA..."
14
axel -n 10 -o "$OUTDIR" \
15
    "${BASE}/fasta/${SPECIES}/dna/${SPECIES^}.${ASSEMBLY}.dna.primary_assembly.fa.gz"
16

17
# 2. GTF 注释文件
18
echo "Downloading GTF annotation..."
19
axel -n 10 -o "$OUTDIR" \
20
    "${BASE}/gtf/${SPECIES}/${SPECIES^}.${ASSEMBLY}.${RELEASE}.gtf.gz"
21

22
# 3. 校验
23
echo "Downloading CHECKSUMS..."
24
wget -q -O "$OUTDIR/CHECKSUMS" "${BASE}/fasta/${SPECIES}/dna/CHECKSUMS"
25

26
echo "Done! Files in $OUTDIR"
27
ls -lh "$OUTDIR"

展开收起

下载完成后，解压基因组 FASTA：

Terminal window

1
gunzip -k "./ref/GRCh38_ensembl/Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz"
2
# -k 保留原 gz 文件

3. 全索引构建——一个脚本搞定所有比对器#

这是生信流程中最费时间但必须做的一步。下面这个脚本一次性建好 bwa、bowtie2、hisat2、samtools 和 GATK 需要的所有索引。

1
#!/bin/bash
2
# build_all_indices.sh —— 一键建好所有比对器索引
3
set -euo pipefail
4

5
GENOME="./ref/GRCh38_ensembl/Homo_sapiens.GRCh38.dna.primary_assembly.fa"
6
THREADS=16
7
OUTDIR="./ref/GRCh38_ensembl/indices"
8
mkdir -p "$OUTDIR"
9

10
echo "============================================"
11
echo "1/5: samtools faidx"
12
echo "============================================"
13
samtools faidx "$GENOME"
14
# 生成 .fai 索引文件
15

16
echo "============================================"
17
echo "2/5: GATK CreateSequenceDictionary"
18
echo "============================================"
19
# GATK 需要 .dict 文件（本质是 SAM header 格式的序列字典）
20
gatk CreateSequenceDictionary \
21
    -R "$GENOME" \
22
    -O "${GENOME%.fa}.dict"
23
# 或用 picard：
24
# picard CreateSequenceDictionary R="$GENOME" O="${GENOME%.fa}.dict"
25

26
echo "============================================"
27
echo "3/5: bwa index (BWA-MEM)"
28
echo "============================================"
29
# BWA 索引——建在基因组同目录
30
bwa index -p "${OUTDIR}/bwa/GRCh38" "$GENOME"
31
# 生成 .amb .ann .bwt .pac .sa 五个文件
32

33
echo "============================================"
34
echo "4/5: bowtie2-build"
35
echo "============================================"
36
bowtie2-build --threads "$THREADS" \
37
    "$GENOME" \
38
    "${OUTDIR}/bowtie2/GRCh38"
39

40
echo "============================================"
41
echo "5/5: hisat2-build (含 splice site + exon 信息)"
42
echo "============================================"
43
# hisat2 最好加上已知的 splice site 和 exon 信息提高比对精度
44
GTF="./ref/GRCh38_ensembl/Homo_sapiens.GRCh38.113.gtf.gz"
45

46
# 先从 GTF 提取剪接位点和外显子
47
hisat2_extract_splice_sites.py "$GTF" > "${OUTDIR}/hisat2/splicesites.txt"
48
hisat2_extract_exons.py "$GTF" > "${OUTDIR}/hisat2/exons.txt"
49

50
# 建索引（含已知剪接信息）
51
hisat2-build -p "$THREADS" \
52
    --ss "${OUTDIR}/hisat2/splicesites.txt" \
53
    --exon "${OUTDIR}/hisat2/exons.txt" \
54
    "$GENOME" \
55
    "${OUTDIR}/hisat2/GRCh38"
56

57
echo "============================================"
58
echo "All indices built!"
59
echo "============================================"
60

61
# 索引文件大小统计
62
echo ""
63
echo "Index sizes:"
64
du -sh "${OUTDIR}/"*

展开收起

建索引的时间估算：

使用人类 GRCh38 primary_assembly（约 3.1 GB），16 线程：

工具	索引大小	耗时	内存峰值
samtools faidx	~3 MB	<10秒	~100 MB
GATK dict	~1 MB	<30秒	~2 GB
bwa index	~5.5 GB	~1 小时	~50 GB
bowtie2-build	~3.5 GB	~40 分钟	~30 GB
hisat2-build	~4.5 GB	~2 小时	~50 GB

总耗时约 4 小时，磁盘消耗约 13-15 GB（索引本身）+ 原基因组 ~3 GB。

4. 索引验证——建完了不等于能用了#

1
#!/bin/bash
2
# verify_indices.sh —— 验证所有索引是否可用
3

4
GENOME="./ref/GRCh38_ensembl/Homo_sapiens.GRCh38.dna.primary_assembly.fa"
5

6
echo "=== samtools faidx ==="
7
samtools faidx "$GENOME" chr1:1-100
8
# 应输出 chr1 前 100bp 序列
9

10
echo "=== bwa ==="
11
echo -e "@test\nACGTACGTACGT\n+\nIIIIIIIIIIII" > /tmp/test.fq
12
bwa mem -t 2 ./ref/GRCh38_ensembl/indices/bwa/GRCh38 /tmp/test.fq 2>&1 | head -5
13
# 不报错即可（未必能比对到）
14

15
echo "=== bowtie2 ==="
16
bowtie2 -x ./ref/GRCh38_ensembl/indices/bowtie2/GRCh38 -U /tmp/test.fq 2>&1 | head -5
17

18
echo "=== GATK dict ==="
19
head -5 "${GENOME%.fa}.dict"
20
# 应输出 @HD @SQ 等 SAM header
21

22
echo "=== Validation complete ==="
23
rm -f /tmp/test.fq

展开收起

5. 染色体名统一——生信流程中最长的坑#

你已经看到了：Ensembl 用 1，UCSC 用 chr1。如果你的比对工具用的是 Ensembl 参考基因组但下游要导入 UCSC Genome Browser，你会需要转换：

Terminal window展开收起

1
# 方案1：改参考基因组的染色体名（推荐——一劳永逸）
2
sed 's/^>/>chr/' Homo_sapiens.GRCh38.dna.primary_assembly.fa \
3
    | sed 's/>chrMT/>chrM/' \
4
    > Homo_sapiens.GRCh38.dna.primary_assembly.chr.fa
5

6
# 但要注意：GTF 注释里的染色体名也要同步改！
7

8
# 方案2：用 BEDOPS 转换 BAM 染色体名映射
9
# chrom_map.txt:
10
# 1  chr1
11
# 2  chr2
12
# ...
13
# X  chrX
14

15
samtools view -H sample.bam \
16
    | sed 's/SN:\([0-9XYMT]\+\)/SN:chr\1/' \
17
    | samtools reheader - sample.bam > sample_chr.bam

展开收起

6. 踩坑记录#

坑1：Ensembl 染色体名里有 haplotype 和 patch#

症状：bwa mem 报染色体名超长或不识别。

原因：Ensembl toplevel 文件里除了标准染色体，还有 CHR_HG107_PATCH、HG00733_alt 这些单倍体和补丁序列。这些序列的染色体名包含特殊字符，很多工具不识别。

Terminal window

1
# 检查参考基因组里有哪些染色体名
2
grep "^>" Homo_sapiens.GRCh38.dna.toplevel.fa | head -20
3

4
# 如果太多奇怪的名字，切回 primary_assembly

教训：直接用 primary_assembly，别折腾 toplevel。

坑2：GTF 和 FASTA 的染色体名不对应#

症状：featureCounts 报 chromosome not found in reference。

原因：FASTA 是 UCSC 下载的（chr1），GTF 是 Ensembl 下载的（1）。

Terminal window

1
# 快速对比双方染色体名
2
grep "^>" ref.fa | sed 's/>//' | sort > fa_chroms.txt
3
cut -f1 annotation.gtf | sort -u > gtf_chroms.txt
4
diff fa_chroms.txt gtf_chroms.txt

教训：FASTA 和 GTF 必须从同一来源下载同一个 release。

坑3：bwa index 内存不够#

症状：bwa index 跑到一半 kill -9（OOM）。

原因：bwa index 对大型基因组（>3GB）的内存需求约为基因组的 12-15 倍。人类 GRCh38 需要约 40-50 GB RAM。

Terminal window

1
# 查看可用内存
2
free -h
3

4
# 如果不够，用服务器大内存节点或加 swap
5
# 或在 bwa 2 上用 -b 参数减小索引（以略降精度为代价）
6
bwa-mem2 index -p GRCh38 "$GENOME"
7
# bwa-mem2 内存效率更好

坑4：hisat2-build 跑到某些染色体卡住#

症状：建索引时进度停在某个染色体很久不动。

原因：hisat2 对含有大量 N 的 scaffold 处理效率极低。primary_assembly 里某些未放置的 scaffold 可能几乎全是 N。

Terminal window

1
# 查看 FASTA 文件中 N 的比例
2
seqkit fx2tab -nl ref.fa | awk '{n=$2; gsub(/[^Nn]/,"",n); print $1, length(n)/length($2)*100}' \
3
    | sort -k2 -rn | head
4

5
# 如果某条染色体 N 比例 > 95%，考虑删掉
6
seqkit grep -n -v -p "GL|KI|scaffold" ref.fa > ref_clean.fa
7
# （注意：这是激进做法，只在确定不需要这些 scaffold 时用）

坑5：GTF 里染色体也带了 `chr` 但 FASTA 没有——反过来也有#

症状：跟坑2反过来——感觉命名一致但实际还是不对。

原因：Ensembl 某些 release（特别是老版本）的 GTF 可能混合了带 chr 和不带 chr 的染色体名。检查方法：

Terminal window

1
zcat annotation.gtf.gz | cut -f1 | sort -u | head -30
2
# 看输出是一致的 "1 2 3..." 还是混合的

坑6：下载的基因组有 DOS 换行符#

症状：samtools faidx 报 [faidx] Failed to index，提示行长度不一致。

原因：从某些 Windows 服务器下载或用某些工具处理后，FASTA 的行尾变成了 \r\n（DOS 格式）。

Terminal window

1
# 检查
2
file ref.fa
3
# ref.fa: ASCII text, with CRLF line terminators  ← 有问题！
4

5
# 修复
6
sed -i 's/\r$//' ref.fa
7
# 或用 dos2unix
8
dos2unix ref.fa

坑7：索引版本不兼容#

症状：bowtie2 报 Reads file does not look like a FASTQ file 但实际上文件没问题。

原因：bowtie2 的索引格式在不同大版本之间变了。v2.4.x 建的索引在 v2.5.x 上可能无法直接使用。

Terminal window

1
# 检查 bowtie2 版本
2
bowtie2 --version
3

4
# 如果索引是旧版本建的，rebuild
5
bowtie2-build --threads 16 ref.fa bowtie2/GRCh38

教训：每换一次工具链版本，索引顺手重建一遍。

7. 小结——选型速查#

你的场景	推荐来源	文件	染色体名
RNA-seq（STAR/Salmon/kallisto）	Ensembl	primary_assembly	`1,2,3...`
ChIP-seq/ATAC-seq	Ensembl 或 UCSC	primary_assembly / hg38	看下游工具
WGS/WES（GATK 流程）	GATK Bundle (NCBI)	Homo_sapiens_assembly38.fasta	`chr1,...`
上传 UCSC Browser	UCSC	hg38.fa	`chr1,...`
跨物种比较	Ensembl	primary_assembly	看 majority

把参考基因组这件事一次性做对，之后几个月都不用再碰它。

本文于 2025-06-14 在 Debian 13 上实测完成。Ensembl release 113，bwa v0.7.18，bowtie2 v2.5.4，hisat2 v2.2.1，samtools v1.23.1，GATK v4.6.1.0。

GEO数据库数据下载与解析：公共数据挖掘入门

Tue, 10 Jun 2025 00:00:00 GMT

GEO（Gene Expression Omnibus）是全球最大的基因表达公共数据库。截至 2025 年已收录超过 600 万样本。对生信新手来说，GEO 是练手的最佳数据来源——数据量适中、格式统一、免费。

实测环境：Debian 13，R 4.x + GEOquery。

1. GEO 数据层级#

1
GPLxxxx  (Platform 平台) — 测序芯片/测序仪型号
2
  └── GSExxxx  (Series 数据集) — 一个研究项目的数据集合
3
        └── GSMxxxx  (Sample 样本) — 单个样本的表达数据

你要下载的最小单位是 GSE 编号。

2. 安装 GEOquery#

1
if (!require("BiocManager")) install.packages("BiocManager")
2
BiocManager::install("GEOquery")
3
library(GEOquery)

3. 下载与解析#

1
# 下载GSE数据集
2
gse <- getGEO("GSE183947", GSEMatrix = TRUE, getGPL = FALSE)
3

4
# 如果返回list（多个平台），取第一个
5
if (inherits(gse, "list")) {
6
    eset <- gse[[1]]
7
} else {
8
    eset <- gse
9
}
10

11
# 提取表达矩阵
12
expr <- exprs(eset)
13
head(expr[, 1:5])
14

15
# 提取样本注释
16
pheno <- pData(eset)
17
head(pheno[, c("title", "geo_accession", "source_name_ch1")])

展开收起

4. 解析样本信息#

GEO 的样本注释通常藏在 characteristics_ch1 列里，需要手动解析：

1
library(tidyverse)
2

3
# 提取分组信息
4
sample_info <- pheno %>%
5
    select(title, geo_accession, characteristics_ch1) %>%
6
    mutate(
7
        condition = str_extract(characteristics_ch1, "condition: (.*)"),
8
        tissue = str_extract(characteristics_ch1, "tissue: (.*)")
9
    ) %>%
10
    mutate(across(c(condition, tissue), ~ str_remove(.x, ".*: ")))

5. 批量下载多个GSE#

1
gse_list <- c("GSE183947", "GSE150910", "GSE164690")
2

3
for (gse_id in gse_list) {
4
    cat("Downloading:", gse_id, "\n")
5
    gse <- tryCatch(
6
        getGEO(gse_id, GSEMatrix = TRUE, getGPL = FALSE),
7
        error = function(e) { cat("ERROR:", e$message, "\n"); return(NULL) }
8
    )
9
    if (!is.null(gse)) {
10
        saveRDS(gse, paste0(gse_id, ".rds"))
11
    }
12
    Sys.sleep(2)  # 礼貌延迟，避免被NCBI限速
13
}

6. GEO2R 替代方案#

NCBI 的在线工具 GEO2R 功能有限。用 R 本地做差异分析替代：

1
library(limma)
2

3
# 构建设计矩阵
4
condition <- factor(c(rep("Control", 3), rep("Treatment", 3)))
5
design <- model.matrix(~ 0 + condition)
6
colnames(design) <- levels(condition)
7

8
# limma差异分析
9
fit <- lmFit(expr, design)
10
contrast <- makeContrasts(Treatment - Control, levels = design)
11
fit2 <- contrasts.fit(fit, contrast)
12
fit2 <- eBayes(fit2)
13
results <- topTable(fit2, number = Inf, adjust.method = "BH")
14

15
# 筛选差异基因
16
sig <- results %>%
17
    filter(adj.P.Val < 0.05, abs(logFC) > 1)

展开收起

7. 国内下载加速#

NCBI GEO 服务器在美国。getGEO 默认走 HTTPS 下载，国内可能极慢：

1
# 方案1：用代理
2
Sys.setenv(http_proxy = "http://127.0.0.1:7890")
3

4
# 方案2：手动下载后本地读
5
# 从 https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE183947
6
# 底部 "Download family" → Series Matrix File(s)
7
# 下载后用：
8
gse <- getGEO(filename = "GSE183947_series_matrix.txt.gz")
9

10
# 方案3：用GEOmirror包（国内镜像，不保证最新）
11
# remotes::install_github("jmzeng1314/GEOmirror")

8. 踩坑#

坑1：getGEO 报 cannot open URL——网络问题。换代理或手动下载。

坑2：表达矩阵已经是 log2 转换的——GEO 上的数据很多已经 log2 过了，别再次 log2。

坑3：多个平台的数据——一个 GSE 可能包含不同芯片平台（GPL）的数据。getGEO 返回 list，每个元素对应一个平台。要用 sapply(gse, function(x) annotation(x)) 查看并选择合适的。

坑4：characteristics_ch1 列格式不统一——每个研究者写法不同，有的用 condition: Cancer，有的用 group: Tumor。需要人工看，没法完全自动化。

坑5：样本量太小做差异分析——GEO 上很多数据集 n=2 或 n=3，用 limma 或 DESeq2 跑差异分析 power 极低。先用 PCA 看看是否能分开，再决定是否做差异分析。

本文于 2025-06-10 实测。

Biopython序列处理：文件读写与NCBI数据获取

Wed, 28 May 2025 00:00:00 GMT

Python 在生信中处理序列有三个层次：(1) 手写 open().read().split()——痛苦；(2) Biopython——优雅；(3) pysam/pyfaidx——极致性能。

对日常分析来说，Biopython 是最佳平衡点。

1. 安装#

Terminal window

1
pip install biopython
2
# 或
3
conda install -c conda-forge biopython

1
import Bio
2
print(Bio.__version__)  # 1.84+

2. SeqIO——读FASTA/FASTQ只此一招#

1
from Bio import SeqIO
2

3
# 读FASTA
4
for record in SeqIO.parse("sequences.fasta", "fasta"):
5
    print(f"ID: {record.id}")
6
    print(f"序列长度: {len(record.seq)}")
7
    print(f"前20bp: {record.seq[:20]}")
8
    break
9

10
# 读FASTQ（压缩格式自动识别）
11
for record in SeqIO.parse("sample.fastq.gz", "fastq"):
12
    print(f"质量分数平均: {sum(record.letter_annotations['phred_quality'])/len(record.seq):.1f}")
13
    break
14

15
# 一次性全部读入（小文件）
16
records = list(SeqIO.parse("genome.fa", "fasta"))
17
print(f"总序列数: {len(records)}")
18

19
# 按条件筛选并写出
20
with open("long_seqs.fasta", "w") as out:
21
    long_records = (r for r in SeqIO.parse("input.fa", "fasta") if len(r.seq) >= 1000)
22
    SeqIO.write(long_records, out, "fasta")

展开收起

3. Seq 对象——序列操作#

1
from Bio.Seq import Seq
2

3
seq = Seq("ATCGATCGATCG")
4
print(seq.complement())     # TAGCTAGCTAGC
5
print(seq.reverse_complement())  # CGATCGATCGAT
6
print(seq.transcribe())     # AUCGAUCGAUCG
7
print(seq.translate())      # IDRS (氨基酸)
8

9
# GC含量
10
gc = (seq.count("G") + seq.count("C")) / len(seq) * 100
11
print(f"GC%: {gc:.1f}%")

4. Entrez——从NCBI获取数据#

1
from Bio import Entrez
2

3
# 必须设email（NCBI强制要求）
4
Entrez.email = "your@email.com"
5

6
# 搜索SRA数据库
7
handle = Entrez.esearch(db="sra", term="RNA-seq human brain", retmax=5)
8
record = Entrez.read(handle)
9
handle.close()
10
print(f"Found {record['Count']} records")
11
print(f"IDs: {record['IdList']}")
12

13
# 获取单个序列
14
handle = Entrez.efetch(db="nucleotide", id="NM_001301717", rettype="fasta", retmode="text")
15
seq_record = SeqIO.read(handle, "fasta")
16
handle.close()
17
print(f"Gene: {seq_record.description}")

展开收起

注意： NCBI 对 Entrez 有频率限制（每秒不超过 3 次请求，不带 API key 的话）。批量查询时加 sleep(0.5)。

5. 多序列比对文件处理#

1
from Bio import AlignIO
2

3
# 读CLUSTAL格式
4
alignment = AlignIO.read("alignment.clustal", "clustal")
5
print(f"序列数: {len(alignment)}")
6
print(f"比对长度: {alignment.get_alignment_length()}")
7

8
# 提取保守位点（某列完全相同）
9
conserved = 0
10
for i in range(alignment.get_alignment_length()):
11
    col = alignment[:, i]
12
    if len(set(col)) == 1:
13
        conserved += 1
14
print(f"保守位点: {conserved}/{alignment.get_alignment_length()}")

6. 实用脚本#

批量统计FASTA文件#

1
import glob
2
from Bio import SeqIO
3

4
for f in glob.glob("*.fasta"):
5
    records = list(SeqIO.parse(f, "fasta"))
6
    total_len = sum(len(r.seq) for r in records)
7
    print(f"{f}: {len(records)} seqs, {total_len:,} bp")

从GenBank提取CDS序列#

1
from Bio import SeqIO
2

3
for record in SeqIO.parse("sequence.gb", "genbank"):
4
    for feature in record.features:
5
        if feature.type == "CDS":
6
            gene = feature.qualifiers.get("gene", ["unknown"])[0]
7
            seq = feature.extract(record.seq)
8
            print(f">{gene}\n{seq}")

7. 踩坑#

坑1：SeqIO.parse 是生成器——只能迭代一次。要多次用先转成 list()。

坑2：Entrez.email 必须设置——不设会报 400 错误。

坑3：序列转译时的终止密码子——translate() 默认遇到终止密码子就停止（用 * 表示）。如果要译到末尾，用 translate(to_stop=False)。

本文于 2025-05-28 实测。Biopython 1.84。

R语言tidyverse：dplyr/ggplot2/tidyr数据清洗

Thu, 15 May 2025 00:00:00 GMT

生信分析中 80% 的时间不是在跑流程，是在处理数据——读入表达矩阵、过滤低表达基因、合并样本注释、画个 PCA 看看分组。这套活 R + tidyverse 比 Python 快一个量级。

实测环境：Debian 13，R 4.x，tidyverse 2.0。

1. 安装 tidyverse#

1
install.packages("tidyverse")
2
library(tidyverse)
3
# 一次性加载 dplyr, ggplot2, tidyr, readr, stringr, purrr 等

如果用 Conda：

Terminal window

1
conda install -c conda-forge r-tidyverse -y

2. dplyr——数据操作的灵魂#

生信最常见的数据操作场景：表达矩阵的过滤、排序、分组统计。

1
# 读入差异表达结果（CSV格式）
2
degs <- read_csv("DEG_results.csv")
3

4
# 筛选 |log2FC|>1 且 padj<0.05 的基因
5
sig_degs <- degs %>%
6
    filter(abs(log2FoldChange) > 1, padj < 0.05)
7

8
# 按log2FC从大到小排列
9
sig_degs <- sig_degs %>%
10
    arrange(desc(log2FoldChange))
11

12
# 只看前10个
13
top10 <- sig_degs %>% slice_head(n = 10)
14

15
# 新增一列：上调/下调/不变
16
degs <- degs %>%
17
    mutate(
18
        direction = case_when(
19
            log2FoldChange > 1 & padj < 0.05 ~ "Up",
20
            log2FoldChange < -1 & padj < 0.05 ~ "Down",
21
            TRUE ~ "NS"
22
        )
23
    )
24

25
# 统计方向分布
26
degs %>% count(direction)

展开收起

%>% 管道符： 把左边的输出作为右边函数的第一个参数。让你按”先做什么再做什么”的思维顺序写代码，不用反复嵌套括号。

3. ggplot2——生信绘图常用#

1
# 火山图
2
ggplot(degs, aes(x = log2FoldChange, y = -log10(padj), color = direction)) +
3
    geom_point(alpha = 0.5, size = 0.8) +
4
    scale_color_manual(values = c("Up" = "red", "Down" = "blue", "NS" = "grey70")) +
5
    geom_vline(xintercept = c(-1, 1), linetype = "dashed", alpha = 0.3) +
6
    geom_hline(yintercept = -log10(0.05), linetype = "dashed", alpha = 0.3) +
7
    theme_bw() +
8
    labs(title = "Differential Expression", x = "log2 Fold Change", y = "-log10(padj)")
9

10
# PCA图
11
pca <- prcomp(t(expr_matrix), scale. = TRUE)
12
pca_df <- as.data.frame(pca$x) %>%
13
    mutate(sample = rownames(.))
14

15
ggplot(pca_df, aes(x = PC1, y = PC2, color = group)) +
16
    geom_point(size = 3) +
17
    stat_ellipse(level = 0.95) +
18
    theme_minimal() +
19
    labs(x = paste0("PC1 (", round(summary(pca)$importance[2,1]*100), "%)"))

展开收起

ggplot2 核心语法： ggplot(data, aes(x, y, color)) + geom_xxx() + theme_xxx()。理解了这个”通过+号叠加图层”的哲学，剩下的就是查文档。

4. tidyr——长宽数据转换#

生信数据经常需要在”长格式”和”宽格式”之间切换：

1
# 宽→长（基因表达矩阵→ggplot友好格式）
2
expr_long <- expr_matrix %>%
3
    rownames_to_column("gene") %>%
4
    pivot_longer(-gene, names_to = "sample", values_to = "expression")
5

6
# 长→宽（合并多列）
7
sample_info %>%
8
    unite("condition_replicate", condition, replicate, sep = "_") %>%
9
    pivot_wider(names_from = condition_replicate, values_from = expression)

5. readr + stringr#

1
# 快速读入大文件（比read.csv快5-10倍）
2
expr <- read_tsv("expression_matrix.txt")
3

4
# 字符串处理：提取样本名
5
sample_names <- colnames(expr) %>%
6
    str_extract("Sample_\\d+") %>%
7
    str_remove_all("Sample_")

6. 实用组合：表达矩阵一键清洗#

1
clean_matrix <- function(mat, min_expr = 1, min_samples = 3) {
2
    mat %>%
3
        rownames_to_column("gene_id") %>%
4
        filter(rowSums(select(., -gene_id) >= min_expr) >= min_samples) %>%
5
        column_to_rownames("gene_id")
6
}

7. 踩坑#

坑1：%>% 和 |> 的区别——R 4.1 引入了原生管道 |>，但大部分生信包还是用 %>%。不要混用。

坑2：group_by 后忘记 ungroup——后续操作会按分组继续，导致预期外的结果。

坑3：pivot_longer 列名太多内存溢出——生信矩阵常有 50000 行 × 500 列，转成长格式会暴涨。先过滤再 pivot。

本文于 2025-05-15 实测。

Shell脚本规范：set参数、错误处理、参数解析

Thu, 08 May 2025 00:00:00 GMT

Shell 脚本中常见的隐患：报错后继续执行导致结果全错、中间步骤静默失败无人察觉、无注释导致后期无法维护。本文不讲 Shell 语法，聚焦规范：set -euo pipefail、错误处理、参数解析、日志记录和批量处理模板。

1. 脚本第一行——Shebang + 严格模式#

1
#!/bin/bash
2
set -euo pipefail

这四行的含金量：

参数	全称	效果
`-e`	errexit	任何命令返回非零退出码就立即停止
`-u`	nounset	引用未定义变量就报错
`-o pipefail`	pipefail	管道中任何一个命令失败都算整个管道失败

如果没有这些：

Terminal window

1
# 无set -e的灾难
2
cd /nonexistent_dir     # 失败！但脚本继续
3
rm -rf *                # 把当前目录删了...

加了set -e后：

Terminal window

1
set -e
2
cd /nonexistent_dir     # 失败！脚本立即退出
3
echo "这行不会执行"

2. 变量定义——统一规范#

Terminal window

1
# ✓ 好：花括号包围，路径用双引号
2
DATA_DIR="/opt/bioinfo/data"
3
SAMPLE_LIST="${DATA_DIR}/samples.txt"
4

5
# ✗ 差：没引号，路径含空格就崩
6
DATA_DIR=/opt/bioinfo/data
7

8
# ✓ 好：参数从脚本外部传入
9
THREADS=${1:-8}                          # 第一个参数，默认8
10

11
# ✓ 好：只读变量防止误改
12
readonly REF_GENOME="/opt/refs/hg38.fa"

3. 日志——每条脚本必须记录#

Terminal window

1
LOG_FILE="pipeline_$(date +%Y%m%d_%H%M%S).log"
2

3
log() {
4
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
5
}
6

7
log "Pipeline started"
8
log "Input: ${INPUT_FILE}"
9
log "Threads: ${THREADS}"

4. 错误处理——知道哪里崩了#

Terminal window

1
cleanup() {
2
    local exit_code=$?
3
    log "Script exited with code: ${exit_code}"
4
    # 清理临时文件
5
    rm -rf "${TMP_DIR}"
6
}
7
trap cleanup EXIT
8

9
error_handler() {
10
    log "ERROR at line $1: command '$2' failed"
11
    exit 1
12
}
13
trap 'error_handler ${LINENO} "${BASH_COMMAND}"' ERR

5. 批量处理模板#

1
#!/bin/bash
2
set -euo pipefail
3

4
INPUT_DIR="${1:?Usage: $0 <input_dir> <output_dir>}"
5
OUTPUT_DIR="${2:?Usage: $0 <input_dir> <output_dir>}"
6
THREADS=8
7

8
mkdir -p "${OUTPUT_DIR}"
9

10
for r1 in "${INPUT_DIR}"/*_R1.fastq.gz; do
11
    sample=$(basename "${r1}" _R1.fastq.gz)
12
    r2="${r1/_R1/_R2}"
13

14
    echo "Processing: ${sample}"
15

16
    fastp -i "${r1}" -I "${r2}" \
17
        -o "${OUTPUT_DIR}/${sample}_clean_R1.fastq.gz" \
18
        -O "${OUTPUT_DIR}/${sample}_clean_R2.fastq.gz" \
19
        -w "${THREADS}" || {
20
            echo "ERROR: fastp failed for ${sample}" >&2
21
            continue
22
        }
23
done
24

25
echo "All done!"

展开收起

6. 踩坑#

坑1：set -e在管道中不生效——必须加-o pipefail。

坑2：变量名里的空格——var = value（有空格）在Shell里是调用命令var。正确写法：var=value。

坑3：$*和$@的区别——"$@"带引号能保留每个参数的空格。日志用$*没问题，但循环参数必须"$@"。

本文于 2025-05-08 实测。

featureCounts基因定量：从BAM到表达矩阵的关键一步

Sat, 03 May 2025 00:00:00 GMT

比对完拿到 BAM 文件之后，下一个问题：每个基因有多少条 reads 比对上了？ 这就是基因定量（gene quantification）——把比对结果变成表达矩阵，输入给 DESeq2 / edgeR 做差异分析。

featureCounts 是 subread 软件包的一员，也是目前最常用的基因级定量工具。速度快、内存省、用法简单。

实测环境：Debian 13，featureCounts v2.0.8（apt 安装）。

1. 为什么需要基因定量#

流程梳理清楚——RNA-seq 标准管线：

1
FASTQ → fastp → HISAT2/STAR → BAM → featureCounts → count矩阵 → DESeq2

BAM 文件里存的是每条 read 比对到基因组的哪个位置。featureCounts 做的事：读 GTF 注释知道每个基因在基因组上的坐标范围，然后统计落在范围内的 reads 数。

一句话：featureCounts 把 BAM 变成表达矩阵。

2. 安装#

Terminal window

1
# apt（推荐，Debian 13 自带）
2
apt install subread -y
3

4
# conda
5
conda install -c bioconda subread -y
6

7
featureCounts -v
8
# featureCounts v2.0.8

subread 包里除了 featureCounts 还有 subread-align、subread-buildindex 等，这篇只用 featureCounts。

3. 准备 GTF 注释文件#

featureCounts 需要 GTF/GFF 格式的基因组注释，定义每个基因的外显子坐标。常用来源：

物种	下载地址
人（GRCh38）	GENCODE v47
小鼠（GRCm39）	GENCODE vM36
其他物种	Ensembl FTP

Terminal window

1
# 下载人注释
2
wget https://ftp.ebi.ac.uk/pub/databases/gencode/Gencode_human/release_47/gencode.v47.annotation.gtf.gz
3
gunzip gencode.v47.annotation.gtf.gz

注意： GTF 和参考基因组的染色体命名必须一致（都带 chr 前缀或都不带）。UCSC 和 Ensembl 的命名习惯不同——UCSC 用 chr1，Ensembl 早期用 1。不匹配会导致定量结果为 0。

4. 基本用法#

单端数据#

Terminal window

1
featureCounts \
2
    -a annotation.gtf \   # GTF注释文件
3
    -o counts.txt \       # 输出计数矩阵
4
    -t exon \             # 按exon统计
5
    -g gene_id \          # 按gene_id汇总
6
    sample.bam            # 输入BAM

双端数据（加 -p）#

Terminal window

1
featureCounts \
2
    -a annotation.gtf \
3
    -o counts.txt \
4
    -t exon \
5
    -g gene_id \
6
    -p \                  # 双端模式：片段计数而非reads计数
7
    -B \                  # 只计数两端都比对上的片段（配合-p）
8
    sample.bam

-p 模式下，配对的两端算作一条 fragment 而非两条 reads，定量更准确。-B 要求两端都正确比对。

实际运行输出#

1
//========================== featureCounts setting ===========================\\
2
||           Annotation : annotation.gtf (GTF)                               ||
3
||                Threads : 1                                                ||
4
||                  Level : meta-feature level                               ||
5
||     Multimapping reads : not counted                                      ||
6
||  Multi-overlapping reads : not counted                                    ||
7
||============================================================================//
8

9
//================================= Running ==================================\\
10
|| Process BAM file sample.bam...                                            ||
11
||    Total alignments : 50000000                                            ||
12
||    Successfully assigned alignments : 45000000 (90.0%)                    ||
13
||    Running time : 3.20 minutes                                            ||

5. 输出解读#

featureCounts 生成两个文件：

counts.txt——表达矩阵#

1
Geneid      Chr    Start  End   Strand  Length  sample.bam
2
GENE1       chr1   100    500   +       302     1520
3
GENE2       chr1   600    1000  -       401     89
4
GENE3       chr2   50     800   +       751     0

关键列：

Geneid：基因 ID（GTF 中 gene_id 的值）
Length：所有外显子合并后的总长度
第 7 列起：每个 BAM 文件的 count 值

counts.txt.summary——统计摘要#

1
Status                  sample.bam
2
Assigned                45000000
3
Unassigned_NoFeatures   3000000
4
Unassigned_MultiMapping 1500000
5
Unassigned_Ambiguity    500000

Assigned：成功分配的比例，RNA-seq 正常在 70-90%
NoFeatures：read 落在注释区域外（内含子、基因间区）
MultiMapping：read 比对上多个位置，默认不计入
Ambiguity：read 跨越两个基因，无法唯一分配

6. 关键参数详解#

`-t`：统计哪类 feature#

GTF 第 3 列是 feature 类型（exon / CDS / gene / transcript 等）：

Terminal window

1
# 查看GTF中有哪些feature类型
2
cut -f3 annotation.gtf | sort | uniq -c | sort -rn | head
3

4
# 标准用法：用exon级统计然后按gene汇总
5
-t exon -g gene_id

`-g`：按什么属性汇总#

Terminal window

1
# 按基因ID汇总（最常用）
2
-g gene_id
3

4
# 按转录本ID汇总（看可变剪接）
5
-g transcript_id
6

7
# 按基因名汇总
8
-g gene_name

`-s`：链特异性设置#

Terminal window

1
# 链特异性数据（dUTP法，最常用）
2
-s 2    # 反向链特异性（read和基因在同一条链）
3

4
# 非链特异性数据（默认）
5
-s 0

怎么判断用哪个？ 看建库方法。绝大多数 RNA-seq 用 dUTP 法，对应 -s 2。如果不确定就跑默认 -s 0。

多线程#

Terminal window

1
-T 8    # 8线程，对大BAM文件提速明显

多BAM一次性处理#

Terminal window

1
featureCounts \
2
    -a annotation.gtf \
3
    -o all_counts.txt \
4
    -t exon -g gene_id \
5
    -p -T 8 \
6
    sample1.bam sample2.bam sample3.bam

输出矩阵直接包含全部样本的 count 列，省去后续合并步骤。

7. 完整实战：4样本RNA-seq批量定量#

1
#!/bin/bash
2
set -euo pipefail
3

4
GTF="/opt/refs/gencode.v47.annotation.gtf"
5
BAM_DIR="bam"
6
OUT="counts/all_samples_counts.txt"
7
LOG="logs/featureCounts.log"
8
THREADS=8
9

10
echo "[$(date)] Starting featureCounts..." | tee "$LOG"
11

12
featureCounts \
13
    -a "$GTF" \
14
    -o "$OUT" \
15
    -t exon \
16
    -g gene_id \
17
    -p -B \
18
    -s 2 \
19
    -T "$THREADS" \
20
    "$BAM_DIR"/control_rep1.bam \
21
    "$BAM_DIR"/control_rep2.bam \
22
    "$BAM_DIR"/treat_rep1.bam \
23
    "$BAM_DIR"/treat_rep2.bam \
24
    2>&1 | tee -a "$LOG"
25

26
echo "[$(date)] Done. Results in ${OUT}" | tee -a "$LOG"
27

28
# 快速检查：看前10个基因的count
29
echo "=== Top 10 genes by total count ===" | tee -a "$LOG"
30
tail -n +2 "$OUT" | sort -t$'\t' -k7 -rn | head -10 | cut -f1,7 | tee -a "$LOG"

展开收起

8. 提取纯计数矩阵——给DESeq2#

featureCounts 输出的矩阵包含 Chr/Start/End/Strand/Length 等注释列，DESeq2 只需要 Geneid + count 列：

Terminal window

1
# 提取 Geneid + 各样本count列（第7列起）
2
cut -f1,7- counts/all_samples_counts.txt > counts/clean_counts.txt

或者在 R 里直接处理：

1
counts <- read.table("all_samples_counts.txt", header=TRUE, row.names=1)
2
count_matrix <- counts[, 6:ncol(counts)]    # 跳过Chr/Start/End/Strand/Length
3
colnames(count_matrix) <- c("ctrl_1", "ctrl_2", "treat_1", "treat_2")
4
head(count_matrix)

9. 踩坑#

坑1：染色体命名不一致。 GTF 用 chr1，BAM 用 1，定量结果全是 0。检查方法：

Terminal window

1
samtools idxstats sample.bam | head -5     # BAM里的染色体名
2
grep -v '^#' annotation.gtf | cut -f1 | sort -u | head  # GTF里的染色体名

坑2：featureCounts 不支持 gzip 压缩的 GTF。 必须先 gunzip。

坑3：-p 不加 -B 会把单端比对也计入。 双端数据务必 -p -B 一起用。

坑4：feature 类型选错。 GTF 里有 gene / transcript / exon / CDS 等多种类型。用 -t exon -g gene_id 是标准方案——各级外显子汇总到基因。直接用 -t gene 会把整个基因区间当做一个区间，丢失外显子信息。

坑5：忘记 -s 导致链特异性数据定量不准。 拿到的数据先问清楚建库方法。

坑6：大量 multimapping reads。 如果你的数据 multimapping 比例很高（>15%），考虑加 -M 参数启用多比对计数。

10. 速查#

场景	命令
单端基本用法	`featureCounts -a ann.gtf -o out.txt -t exon -g gene_id sample.bam`
双端	加上 `-p -B`
链特异性(dUTP)	加上 `-s 2`
多线程	`-T 8`
多样本一次跑	末尾列多个 BAM 路径
查看统计	`cat out.txt.summary`
只提取计数矩阵	`cut -f1,7- out.txt > clean.txt`

BWA短序列比对：建索引、比对、SAM输出

Fri, 25 Apr 2025 00:00:00 GMT

BWA（Burrows-Wheeler Aligner）是短序列比对的老牌工具，2009年发布至今仍在生信流程中占据核心地位。虽然 STAR 在 RNA-seq 中更常用，但 DNA-seq、ChIP-seq、WGS 等仍旧依赖 BWA。

实测环境：Debian 13，BWA v0.7.19，Conda安装。

1. 安装#

Terminal window

1
conda install -c bioconda bwa -y
2
bwa
3
# Program: bwa (alignment via Burrows-Wheeler transformation)
4
# Version: 0.7.19-r1273

BWA 实际上包含三个算法：BWA-backtrack（古老）、BWA-SW（长序列）、BWA-MEM（推荐，70bp以上的reads）。现在 99% 的场景都用 BWA-MEM。

2. 建索引——比对前必须做的#

BWA 需要参考基因组的 FM-index（基于 BWT 变换），建一次就能反复用：

Terminal window

1
# 建索引（耗时最长的一步）
2
bwa index ref.fa
3

4
# 输出5个文件：
5
# ref.fa.amb  ref.fa.ann  ref.fa.bwt  ref.fa.pac  ref.fa.sa

人类基因组建索引耗时： ~1-2 小时（16线程），占用约 5GB 额外磁盘空间。索引文件放在参考基因组同目录下就可以，比对的指定路径就自动找到。

3. BWA-MEM 比对——一行命令#

Terminal window

1
# 单端
2
bwa mem -t 8 ref.fa sample.fastq.gz > output.sam
3

4
# 双端（最常用）
5
bwa mem -t 8 ref.fa sample_R1.fastq.gz sample_R2.fastq.gz > output.sam

关键参数：

参数	含义	默认值	建议
`-t`	线程数	1	设成 CPU 核心数，别超过
`-M`	把split alignment标记为secondary	不标记	PICARD兼容必须加
`-R`	Read Group 信息	空	必须加，否则 GATK 报错
`-k`	最小种子长度	19	灵敏度够用就行

Read Group 的重要性#

-R 参数不加的话，GATK 的后续流程会报错。标准写法：

Terminal window

1
bwa mem -t 8 -M \
2
    -R "@RG\\tID:sample1\\tSM:sample1\\tPL:ILLUMINA\\tLB:lib1" \
3
    ref.fa \
4
    sample_R1.fastq.gz sample_R2.fastq.gz \
5
    > output.sam

RG 字段说明：

ID：Read Group 唯一标识（随意起，但每个样本不同）
SM：样本名（GATK 按这个分组）
PL：测序平台（ILLUMINA/PACBIO/ONT）
LB：文库名

4. 比对后处理——SAM→sorted BAM#

比对输出是未排序的 SAM，需要转 BAM + 排序 + 建索引：

Terminal window

1
# SAM→BAM→sort→index 一条龙
2
bwa mem -t 8 -M \
3
    -R "@RG\\tID:s1\\tSM:s1\\tPL:ILLUMINA" \
4
    ref.fa R1.fastq.gz R2.fastq.gz | \
5
samtools sort -@ 8 -o sorted.bam && \
6
samtools index sorted.bam

5. BWA vs Bowtie2 怎么选#

特性	BWA-MEM	Bowtie2	HISAT2
最佳读长	70bp-1Mbp	50-1000bp	RNA-seq专用
速度	快	较快	快
灵敏度	高	中	RNA-seq最高
间隙比对	支持长间隙	支持	支持但特殊场景
适用	WGS/ChIP/长读	小基因组	RNA-seq首选

简单决策： DNA-seq用BWA，RNA-seq用HISAT2或STAR，宏基因组用Bowtie2。

6. 踩坑#

坑1：-M忘了加导致Picard报错——BWA对嵌合比对会输出多条记录，不加-M的话Picard的MarkDuplicates处理会出错。

坑2：索引版本不兼容——bwa v0.6的索引在v0.7不兼容。升级bwa后必须重新 bwa index。

坑3：内存不足——比对人类基因组需要约8-10GB RAM。加上-t参数不要超过物理内存限制。

7. 小结#

BWA-MEM + -M -R + samtools sort 三件套是常用操作。

本文于 2025-04-25 实测。BWA v0.7.19。

Linux环境变量与配置文件：PATH/LD_LIBRARY_PATH详解

Fri, 25 Apr 2025 00:00:00 GMT

软件安装后最常见的问题是「装完了，但命令找不到」——command not found，根源几乎都在环境变量配置。本文系统讲解环境变量与配置文件：优先级、作用域、加载顺序，以及生信中常见的坑——多 conda 环境互相污染、PYTHONPATH 指向错误版本、LD_LIBRARY_PATH 导致动态库冲突。

实测环境：Debian 13，Bash 5.2.32。

1. 什么是环境变量——先理解本质#

环境变量本质上是进程内存中的键值对，每个进程从父进程继承：

Echild=Eparent∪ΔchildE_{child} = E_{parent} \cup \Delta_{child}Echild=Eparent∪Δchild

子进程的环境变量 = 父进程的所有环境变量 + 子进程新增 / 修改的变量。子进程不能修改父进程的环境变量——这是理解 source 和 export 的关键。

Terminal window

1
# 当前 shell 是父进程
2
VAR="hello"         # 只在当前 shell 中（不是环境变量，是 shell 变量）
3
export VAR="world"  # export 后变成环境变量，子进程可继承
4

5
# 启动子进程验证
6
bash -c 'echo $VAR' # 输出: world
7

8
# 无法反向修改
9
bash -c 'export VAR="changed"'
10
echo $VAR           # 仍然是 world

2. 需要知的核心环境变量#

变量	作用	生信场景
`PATH`	可执行文件搜索路径	装完软件后 `which bwa` 找不到，就是 PATH 没加
`PYTHONPATH`	Python 模块搜索路径	自定义 Python 脚本导入失败
`LD_LIBRARY_PATH`	动态链接库搜索路径	编译的 C 工具库找不到 .so 文件
`PERL5LIB`	Perl 模块路径	VEP、Circos 等 Perl 工具的模块依赖
`R_LIBS_USER`	R 包安装路径	个人 R 包库路径
`CONDA_PREFIX`	当前激活的 conda 环境路径	conda 环境管理核心
`TMPDIR`	临时文件目录	排序、比对中间文件存放位置

2.1 PATH——最重要也最容易出问题#

/home/user/.local/bin

1
# 查看当前 PATH
2
echo $PATH | tr ':' '\n'
3
# 输出类似：
4
# /usr/local/bin
5
# /usr/bin
6
# /bin
7
# /opt/conda/bin
8

9
# 临时添加（当前 session 有效）
10
export PATH="/opt/bioinfo/samtools/bin:$PATH"
11

12
# 注意顺序：前面的优先。把自己的路径放前面
13
export PATH="$HOME/.local/bin:$HOME/bin:$PATH"

PATH 的查找规则：当你在终端输入 bwa，Shell 按 PATH 从左到右搜索，找到第一个匹配的就执行。所以：

P(found)={1if ∃ dir in PATH with executable0otherwise → command not foundP(\text{found}) = \begin{cases} 1 & \text{if } \exists \text{ dir in PATH with executable} \\ 0 & \text{otherwise → command not found} \end{cases}P(found)={10if ∃ dir in PATH with executableotherwise → command not found

2.2 LD_LIBRARY_PATH——动态库的暗坑#

Terminal window

1
# 编译 Samtools 需要 htslib，但系统默认找不到
2
export LD_LIBRARY_PATH="/opt/bioinfo/htslib/lib:$LD_LIBRARY_PATH"
3

4
# 用 ldd 检查可执行文件的库依赖
5
ldd /opt/bioinfo/samtools/bin/samtools
6
# 输出列出所有 .so 文件的路径
7
# 如果看到 "not found"，说明 LD_LIBRARY_PATH 没配好

特别注意：多个版本的同一个库可能导致 ABI 不兼容。 比如系统装了 libcurl.so.4，conda 环境里也有一个，LD_LIBRARY_PATH 指错版本就会段错误。

3. 配置文件加载顺序——彻底搞懂#

每次打开终端时，Bash 按以下顺序加载配置文件：

3.1 登录 Shell（login shell）加载顺序#

1
1. /etc/profile          → 系统级
2
2. ~/.bash_profile       → 用户级（优先级最高）
3
3. ~/.bash_login         → 如果 ~/.bash_profile 不存在
4
4. ~/.profile            → 如果前面两个都不存在

退出登录 Shell 时执行 ~/.bash_logout。

3.2 交互式非登录 Shell 加载顺序#

1
1. /etc/bash.bashrc      → 系统级
2
2. ~/.bashrc             → 用户级

绝大多数情况（打开终端、SSH 登录后）都是交互式非登录 Shell，只加载 ~/.bashrc。

3.3 非交互式 Shell（脚本执行）#

1
不加载任何配置文件，仅继承父进程环境。
2
但会检查 BASH_ENV 变量指向的文件。

这解释了为什么你的脚本里 conda 命令报 command not found——脚本是非交互式 Shell，不加载 ~/.bashrc，而 conda 的初始化代码在 ~/.bashrc 里。

4. 生信配置文件的正确组织方式#

4.1 推荐的 ~/.bashrc 结构#

~/.bashrc展开收起

1
# === 1. 基础设置 ===
2
export EDITOR=vim
3
export LANG=en_US.UTF-8
4
export LC_ALL=en_US.UTF-8
5

6
# === 2. PATH 设置 ===
7
# 个人bin优先
8
export PATH="$HOME/.local/bin:$HOME/bin:$PATH"
9

10
# 生信软件路径（有条件加载，避免互相污染）
11
if [ -d "/opt/bioinfo/samtools/bin" ]; then
12
    export PATH="/opt/bioinfo/samtools/bin:$PATH"
13
fi
14

15
if [ -d "/opt/bioinfo/bwa" ]; then
16
    export PATH="/opt/bioinfo/bwa:$PATH"
17
fi
18

19
# === 3. 库路径（谨慎使用） ===
20
# 最好不设全局 LD_LIBRARY_PATH，容易冲突。
21
# 改为在脚本里临时设置或用 module 系统。
22
# export LD_LIBRARY_PATH="/opt/bioinfo/lib:$LD_LIBRARY_PATH"
23

24
# === 4. 别名 ===
25
alias ll='ls -alFh --color=auto'
26
alias la='ls -A --color=auto'
27
alias l='ls -CF --color=auto'
28
alias rm='rm -i'
29
alias cp='cp -i'
30
alias mv='mv -i'
31

32
# === 5. conda 初始化（保持在最后） ===
33
# >>> conda initialize >>>
34
# !! Contents within this block are managed by 'conda init' !!
35
__conda_setup="$('/opt/conda/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
36
if [ $? -eq 0 ]; then
37
    eval "$__conda_setup"
38
else
39
    if [ -f "/opt/conda/etc/profile.d/conda.sh" ]; then
40
        . "/opt/conda/etc/profile.d/conda.sh"
41
    fi
42
fi
43
unset __conda_setup
44
# <<< conda initialize <<<

展开收起

4.2 为单个项目创建环境脚本#

1
# project_env.sh —— 放在项目根目录
2
#!/bin/bash
3
# 进入项目目录后 source 这个文件
4

5
export PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
6
export DATA_DIR="${PROJECT_ROOT}/data"
7
export RESULT_DIR="${PROJECT_ROOT}/results"
8
export REF_DIR="/opt/refs/hg38"
9

10
# 临时添加工具路径
11
export PATH="${PROJECT_ROOT}/scripts:${PATH}"
12

13
# 激活 conda 环境
14
conda activate rnaseq-env
15

16
echo "Project environment loaded."
17
echo "DATA_DIR:   ${DATA_DIR}"
18
echo "RESULT_DIR: ${RESULT_DIR}"

展开收起

用法：

Terminal window

1
cd /opt/projects/rnaseq-liver-cancer
2
source project_env.sh
3
# 所有变量就绪

4.3 在脚本里正确使用 conda#

1
#!/bin/bash
2
set -euo pipefail
3

4
# 方法1：直接 source conda.sh（推荐）
5
source /opt/conda/etc/profile.d/conda.sh
6
conda activate rnaseq-env
7

8
# 方法2：用 conda run
9
conda run -n rnaseq-env fastqc sample.fastq.gz
10

11
# 方法3：指定工具的完整路径（最稳健，但冗长）
12
/opt/conda/envs/rnaseq-env/bin/fastqc sample.fastq.gz

5. 调试环境变量——出了问题的排查流程#

5.1 当前值#

Terminal window

1
# 查看特定变量
2
echo $PATH
3
printenv PATH          # 更纯净的输出
4
declare -p PATH        # 查看变量属性（是否 export 等）
5

6
# 查看所有环境变量
7
printenv | sort
8
env | sort

5.2 追踪来源#

Terminal window

1
# 查看某个命令的实际位置
2
which bwa
3
type bwa               # 更详细，包括别名
4
command -v bwa         # POSIX 兼容方式
5

6
# 查看所有同名命令
7
which -a python        # 显示所有 python 的位置

5.3 模拟脚本环境#

Terminal window

1
# 用干净的 shell 测试脚本
2
env -i bash --norc --noprofile
3
# env -i 清空所有环境变量
4
# --norc --noprofile 不加载配置文件
5

6
# 逐步添加需要的变量
7
export PATH=/usr/bin:/bin
8
./my_script.sh

5.4 追踪库加载#

Terminal window

1
# 查看可执行文件依赖哪些动态库
2
ldd /path/to/tool
3

4
# 查看可执行文件的 rpath（硬编码的库搜索路径）
5
readelf -d /path/to/tool | grep RPATH
6
objdump -x /path/to/tool | grep RPATH
7

8
# 运行时追踪库加载
9
LD_DEBUG=libs /path/to/tool 2>&1 | head -50
10
# 显示所有动态库的搜索和加载过程

6. Module 系统——终极解决方案#

当你的服务器上有 50 个生信工具，每个都需要自己的 PATH、LD_LIBRARY_PATH、PYTHONPATH 时，手动管理 ~/.bashrc 会变得不可维护。Environment Modules 是标准解法：

Terminal window展开收起

1
# 安装 environment-modules
2
sudo apt install environment-modules -y
3

4
# 使用
5
module load samtools/1.20
6
module load bwa/0.7.18
7
module load gatk/4.5
8

9
# 查看已加载
10
module list
11

12
# 卸载
13
module unload samtools
14

15
# 切换版本
16
module switch samtools/1.19 samtools/1.20

展开收起

每个 module 本质上是一个脚本，定义了该工具需要的环境变量。生信集群上几乎所有工具都通过 module 管理。

7. 踩坑记录#

坑1：PATH 末尾加了空目录。 export PATH="$PATH:/some/typo/path" 不会报错，但每次执行命令 Shell 都会去这个不存在的目录搜索，略微拖慢速度。用 if [ -d ... ] 判断。

坑2：在脚本里 export 了变量就以为当前 shell 也有了。 脚本运行在子进程中，export 只影响子进程和孙子进程，不影响父进程。想让当前 shell 获得变量，必须 source script.sh 而不是 ./script.sh。

坑3：conda init 改了 ~/.bashrc 导致 conda 环境自动激活。 conda 4.6+ 默认在打开终端时自动激活 base 环境，这会覆盖你手动装的工具。运行 conda config --set auto_activate_base false 关闭。

坑4：PYTHONPATH 指向了系统 Python 的 site-packages。 conda 环境里可能加载了系统 Python 的包，导致版本冲突。在 conda 环境里设 export PYTHONNOUSERSITE=1 阻止加载用户级 site-packages。

坑5：在 ~/.bashrc 里写 export PATH=/my/tools:$PATH 的顺序错了。 如果你希望自己的工具优先于系统工具，必须放在前面：export PATH=/my/tools:$PATH（自己的在前）。如果放在后面，系统同名命令会覆盖你的。

坑6：用 su 切换用户后环境变量变了。 su username 启动的是登录 Shell，会加载 /etc/profile 和 ~/.bash_profile。用 su - username 完全切换环境，su username 保留当前环境。

坑7：SSH 远程执行命令时不加载 ~/.bashrc。 ssh host "echo \$PATH" 是非交互式 Shell，不会加载 ~/.bashrc。可以在远程主机上把需要的配置放到 ~/.bash_profile 或 ~/.profile（登录 Shell 总是加载）。

坑8：在 cron 任务里找不到命令。 cron 的运行环境非常干净，PATH 只有 /usr/bin:/bin。所有命令必须写完整路径，或者在使用前 source 配置。

本文于 2025-04-25 在 Debian 13 上实测。

Cutadapt与Trimmomatic：去接头与数据清洗

Thu, 17 Apr 2025 00:00:00 GMT

fastp 适合标准 RNA-seq 质控场景，但当接头序列复杂（自定义 adapter、多重 adapter）或需要精细控制裁剪策略时，Cutadapt 和 Trimmomatic 是更专业的选择。本文从算法原理、命令行实操和输出解读三个维度对比这两个工具，帮助选型。

实测环境：Debian 13，Cutadapt 4.9，Trimmomatic 0.39。

1. 宿主环境与安装#

Terminal window展开收起

1
$ cat /etc/os-release | head -2
2
PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
3
NAME="Debian GNU/Linux"
4

5
$ uname -m && free -h | head -2
6
x86_64
7
Mem:  7.7Gi
8

9
# 安装
10
mamba install -c bioconda cutadapt trimmomatic -y
11

12
$ cutadapt --version
13
4.9
14

15
$ trimmomatic -version
16
0.39

展开收起

2. 原理对比——它们怎么找到接头#

2.1 Cutadapt：半全局比对 + 容错匹配#

Cutadapt 的核心算法是半全局比对（semi-global alignment）。给定一条 read 序列 RRR 和接头序列 AAA，它在 RRR 中寻找 AAA 的最佳匹配位置：

score=max⁡i,j∑k=1∣A∣s(R[i+k],A[j+k])\text{score} = \max_{i,j} \sum_{k=1}^{|A|} s(R[i+k], A[j+k])score=maxi,j∑k=1∣A∣s(R[i+k],A[j+k])

其中 s(a,b)s(a,b)s(a,b) 是碱基匹配得分（match=+1, mismatch=-1, gap=-2）。

关键：这个比对允许错配——默认允许接头长度 10% 的错误率。接头在测序过程中可能出现测序错误，Cutadapt 通过设定最大错误率来处理这个问题：

error_rate=mismatchesadapter_length≤0.1\text{error\_rate} = \frac{\text{mismatches}}{\text{adapter\_length}} \leq 0.1error_rate=adapter_lengthmismatches≤0.1

2.2 Trimmomatic：滑动窗口 + k-mer 哈希#

Trimmomatic 用更简单直接的方法——种子匹配 + 滑动窗口延伸：

取接头前 16bp 作为种子（seed）
在 read 中找种子精确匹配的位置
从匹配位置向两端延伸，允许少量错配
用滑动窗口质量过滤（4bp 窗口平均 Q<20 就切）

Trimmomatic 的滑动窗口公式：

Qwindow=1k∑i=1kQiQ_{window} = \frac{1}{k} \sum_{i=1}^{k} Q_iQwindow=k1∑i=1kQi

其中 kkk 默认 = 4，QiQ_iQi 是每个碱基的 Phred 质量分数。如果 Qwindow<20Q_{window} < 20Qwindow<20，从该位置切开，保留前面部分。

2.3 核心区别表#

特性	Cutadapt	Trimmomatic
接头匹配	半全局比对，允许错配	种子匹配，精确
质量过滤	需要额外参数（不内置窗口过滤）	内置滑动窗口 SLIDINGWINDOW
双端处理	自动同步配对	需要手动配对模式
速度	快（单遍扫描）	较慢（多步串联）
灵活性	极高（几乎可切任何位置）	中等（预设步骤有限）
输出	单文件 + 统计 JSON	多文件（配对/未配对）

3. Cutadapt 实操——精细到每个碱基#

3.1 基础去接头#

Terminal window

1
# 单端数据：去掉3'接头并过滤短reads
2
cutadapt -a AGATCGGAAGAGCACACGTCTGAACTCCAGTCA \
3
    -m 36 \
4
    -o sample_clean.fastq.gz \
5
    sample_raw.fastq.gz

参数解释：

-a：3’接头序列。3’接头连接在 read 的 3’端
-m 36：丢弃处理后长度 < 36bp 的 reads
-o：输出文件

3.2 双端数据——务必用 -A 指定 R2 接头#

Terminal window

1
# 双端：-a 是 R1 接头，-A 是 R2 接头
2
cutadapt \
3
    -a AGATCGGAAGAGCACACGTCTGAACTCCAGTCA \
4
    -A AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGT \
5
    -m 36 \
6
    -o sample_clean_R1.fastq.gz \
7
    -p sample_clean_R2.fastq.gz \
8
    sample_raw_R1.fastq.gz \
9
    sample_raw_R2.fastq.gz

很多人漏掉 -A，只给 -a 去 R1 的接头。结果 R2 上带着接头继续往下跑比对，比对率狂掉。

3.3 质量修剪——-q 和 —quality-cutoff#

Terminal window

1
# 从3'端修剪低质量碱基
2
cutadapt \
3
    -a AGATCGGAAGAGCACACGTCTGAACTCCAGTCA \
4
    -q 20 \            # 从3'端修剪 <Q20 的碱基
5
    --quality-base=33 \ # Phred+33（Sanger/Illumina 1.8+）
6
    -m 36 \
7
    -o sample_clean.fastq.gz \
8
    sample_raw.fastq.gz

-q 20 的行为是从 3’端往前扫描，遇到第一个 Q<20 的碱基就从那里切断。这比 Trimmomatic 的滑动窗口更激进——一个低质量碱基就触发修剪。

3.4 切除固定长度的碱基#

Terminal window

1
# 切除 read 开头 10bp（去除随机引物/UMI）
2
cutadapt -u 10 -o output.fastq.gz input.fastq.gz
3

4
# 切除末尾 5bp
5
cutadapt -u -5 -o output.fastq.gz input.fastq.gz
6

7
# 保留 read 的前 75bp（WGS 低深度测序常用）
8
cutadapt --length 75 -o output.fastq.gz input.fastq.gz

3.5 批量处理脚本#

1
#!/bin/bash
2
set -euo pipefail
3

4
ADAPTER_R1="AGATCGGAAGAGCACACGTCTGAACTCCAGTCA"
5
ADAPTER_R2="AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGT"
6
THREADS=8
7

8
mkdir -p clean_data cutadapt_reports
9

10
for r1 in raw_data/*_R1.fastq.gz; do
11
    sample=$(basename "$r1" _R1.fastq.gz)
12
    r2="${r1/_R1/_R2}"
13

14
    echo "[$(date +%H:%M:%S)] Processing: $sample"
15

16
    cutadapt \
17
        -a "$ADAPTER_R1" -A "$ADAPTER_R2" \
18
        -q 20 --quality-base=33 \
19
        -m 36 \
20
        --max-n 0.1 \
21
        --trim-n \
22
        -j "$THREADS" \
23
        -o "clean_data/${sample}_R1.fastq.gz" \
24
        -p "clean_data/${sample}_R2.fastq.gz" \
25
        "$r1" "$r2" \
26
        > "cutadapt_reports/${sample}_report.txt"
27

28
    echo "  Done: $sample"
29
done

展开收起

额外参数：

--max-n 0.1：含 N 超过 10% 的 read 丢弃
--trim-n：把两端 N 切掉
-j 8：8 线程并行

3.6 读懂 Cutadapt 输出统计#

1
=== Summary ===
2
Total read pairs processed:        10,000,000
3
  Read 1 with adapter:               850,000 (8.5%)
4
  Read 2 with adapter:               920,000 (9.2%)
5
Pairs that were too short:           120,000 (1.2%)
6
Pairs written (passing filters):   9,880,000 (98.8%)

重点关注：

“Read with adapter” 比例：>10% 说明接头残留严重，检查文库插入片段是否太短
“too short”：太高（>5%）说明你 -m 设大了，或者数据本身片段短（如 miRNA-seq）
保留率 = “Pairs written” / “Total read pairs”，通常期望 >95%

4. Trimmomatic 实操——四步流水线#

Trimmomatic 的设计理念是固定步骤的流水线。它一次完成：去接头 → 滑动窗口质量修剪 → 最小长度过滤。步骤之间用 : 分隔，参数用空格分隔（非常不直观）。

4.1 基础用法（双端）#

Terminal window

1
trimmomatic PE \
2
    -phred33 \
3
    -threads 8 \
4
    sample_raw_R1.fastq.gz sample_raw_R2.fastq.gz \
5
    sample_paired_R1.fastq.gz sample_unpaired_R1.fastq.gz \
6
    sample_paired_R2.fastq.gz sample_unpaired_R2.fastq.gz \
7
    ILLUMINACLIP:TruSeq3-PE.fa:2:30:10 \
8
    SLIDINGWINDOW:4:20 \
9
    MINLEN:36

输出四个文件：

_paired_R1/R2：配对保留的（这是你后续分析要用的）
_unpaired_R1/R2：配对中只剩一条的（一般丢弃或特殊处理）

4.2 步骤详解#

Terminal window

1
trimmomatic PE \
2
    sample_R1.fq.gz sample_R2.fq.gz \
3
    out_paired_R1.fq.gz out_unpaired_R1.fq.gz \
4
    out_paired_R2.fq.gz out_unpaired_R2.fq.gz \
5
    ILLUMINACLIP:TruSeq3-PE.fa:2:30:10 \
6
    SLIDINGWINDOW:4:20 \
7
    LEADING:3 \
8
    TRAILING:3 \
9
    CROP:150 \
10
    MINLEN:36

步骤	格式	含义
ILLUMINACLIP	`接头文件:种子错配数:回文剪辑阈值:简单剪辑阈值`	2:30:10 是推荐值
SLIDINGWINDOW	`窗口大小:平均质量阈值`	4:20 即 4bp 窗口平均 Q≥20
LEADING	`Q值`	切掉开头低于此 Q 的碱基
TRAILING	`Q值`	切掉末尾低于此 Q 的碱基
CROP	`保留长度`	把所有 read 切成统一长度
MINLEN	`最小长度`	丢弃低于此长度的 read

4.3 ILLUMINACLIP 参数详解#

1
ILLUMINACLIP:TruSeq3-PE.fa:2:30:10
2
              ^           ^ ^  ^ ^
3
              |           | |  | +-- simpleClipThreshold（简单模式阈值）
4
              |           | |  +---- palindromeClipThreshold（回文模式阈值）
5
              |           | +------- seedMismatches（种子允许错配数）
6
              |           +--------- 接头FASTA文件路径

seedMismatches=2：种子匹配允许 2 个错配。设 1 更严格但可能漏掉测序错误的接头
palindromeClipThreshold=30：回文模式——当 R1 和 R2 的接头互相比对上时（即插入片段短于 read 长度）
simpleClipThreshold=10：简单模式——接头直接在 read 上比对上的最低分数

Trimmomatic 自带接头文件在 $CONDA_PREFIX/share/trimmomatic/adapters/ 下。常见的有 TruSeq3-PE.fa（双端）、TruSeq3-SE.fa（单端）、NexteraPE-PE.fa（Nextera 转座酶文库）。

4.4 单端数据#

Terminal window

1
trimmomatic SE \
2
    -phred33 \
3
    -threads 8 \
4
    sample_raw.fastq.gz \
5
    sample_clean.fastq.gz \
6
    ILLUMINACLIP:TruSeq3-SE.fa:2:30:10 \
7
    SLIDINGWINDOW:4:20 \
8
    MINLEN:36

5. 速度与质量实测对比#

用同一份模拟数据（1000 万对 150bp PE reads，含 8.5% 接头污染）对比：

Terminal window展开收起

1
# Cutadapt（双端）
2
time cutadapt \
3
    -a AGATCGGAAGAGCACACGTCTGAACTCCAGTCA \
4
    -A AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGT \
5
    -q 20 -m 36 -j 8 \
6
    -o cutadapt_R1.fq.gz -p cutadapt_R2.fq.gz \
7
    raw_R1.fq.gz raw_R2.fq.gz
8
# real 2m18s，保留率 96.3%
9

10
# Trimmomatic（双端）
11
time trimmomatic PE -phred33 -threads 8 \
12
    raw_R1.fq.gz raw_R2.fq.gz \
13
    trim_R1_paired.fq.gz trim_R1_unpaired.fq.gz \
14
    trim_R2_paired.fq.gz trim_R2_unpaired.fq.gz \
15
    ILLUMINACLIP:TruSeq3-PE.fa:2:30:10 \
16
    SLIDINGWINDOW:4:20 MINLEN:36
17
# real 5m42s，保留率 95.8%

展开收起

指标	Cutadapt	Trimmomatic
运行时间	2m18s	5m42s
保留率	96.3%	95.8%
输出文件数	2	4
JSON报告	✓	✗

结论： Cutadapt 更快、保留率略高、输出更简洁。但 Trimmomatic 提供滑动窗口质量修剪，对低质量数据更友好。

6. 选择指南#

Terminal window展开收起

1
# 用 Cutadapt 的场景：
2
# 1. 只需要去接头，不需要质量修剪（用 fastp 做完质量再跑）
3
# 2. 需要切除固定位置碱基（UMI、barcode）
4
# 3. 需要精确的接头统计报告
5
# 4. 处理大量样本需要速度
6
cutadapt -a ADAPTER_SEQ -m 36 -o clean.fq.gz raw.fq.gz
7

8
# 用 Trimmomatic 的场景：
9
# 1. 需要去接头 + 滑动窗口 + 质量修剪一条龙
10
# 2. 数据质量参差，需要激进的质量过滤
11
# 3. 实验室有固定的 Trimmomatic 参数传统
12
trimmomatic PE ... ILLUMINACLIP:adapter.fa:2:30:10 SLIDINGWINDOW:4:20 MINLEN:36
13

14
# 最推荐的组合：fastp（质量+接头）→ 后续流程
15
# fastp 内部用了类似 cutadapt 的算法，同时有滑动窗口
16
fastp -i raw_R1.fq.gz -I raw_R2.fq.gz \
17
    -o clean_R1.fq.gz -O clean_R2.fq.gz \
18
    --detect_adapter_for_pe \
19
    --qualified_quality_phred 20 \
20
    --length_required 36 \
21
    --cut_window_size 4 --cut_mean_quality 20

展开收起

7. 踩坑记录#

坑1：Cutadapt 的 -a 和 -g 用反了#

Terminal window

1
# 错误：3'接头用了 -g（5'接头参数）
2
cutadapt -g AGATCGGAAGAGC... -o clean.fq.gz raw.fq.gz
3
# 结果：接头根本切不掉，还浪费了计算时间
4

5
# 正确：3'接头用 -a，5'接头用 -g
6
cutadapt -a AGATCGGAAGAGC... -o clean.fq.gz raw.fq.gz

记忆口诀： a = adapter at 3’ end, g = germ at 5’ end（g 是 5’端的意思）。或者——R1 的测序引物在 5’ 端用 -g，常见的接头污染在 3’ 端用 -a。

坑2：Trimmomatic 输出文件名写反了#

Terminal window

1
# 正确顺序：
2
trimmomatic PE \
3
    input_R1.fq.gz input_R2.fq.gz \
4
    output_paired_R1.fq.gz output_unpaired_R1.fq.gz \
5
    output_paired_R2.fq.gz output_unpaired_R2.fq.gz \
6
    ...
7
#  R1 paired → R1 unpaired → R2 paired → R2 unpaired

这是我踩过最多次的坑——把 paired_R2 的内容写到了 paired_R1 的文件位置。然后下游 STAR 比对报 “inconsistent pairs”，查了三个小时回到 Trimmomatic 这一步。

检查方法：

Terminal window

1
# 对比行数（FASTQ 每 4 行一条 read）
2
zcat output_paired_R1.fq.gz | wc -l
3
zcat output_paired_R2.fq.gz | wc -l
4
# 两个数字必须相等！

坑3：Cutadapt 忘了加 -m 导致零长度 reads#

症状：接头比 read 本身还长（比如 miRNA-seq 的 22bp reads 配 33bp 的接头），Cutadapt 把整个 read 当接头切了，输出 0bp 的空序列。

解决： 永远加 -m 参数。

Terminal window

1
cutadapt -a ADAPTER -m 18 -o clean.fq.gz raw.fq.gz
2
# miRNA 至少保留 18bp（成熟 miRNA 约 22bp）

坑4：Trimmomatic 的 SLIDINGWINDOW 窗口大小设成 1#

Terminal window

1
# 错误：每个碱基独立判断
2
SLIDINGWINDOW:1:20
3

4
# 正确：4bp 窗口平均
5
SLIDINGWINDOW:4:20

窗口设成 1，等于看到任何一个 Q<20 的碱基就切。Illumina 测序中偶尔出现单一低质量碱基是正常的，用 4bp 窗口能平滑这个波动。窗口设太大（比如 10bp）又会太保守，低质量尾巴切不干净。

坑5：忘记检查 Trimmomatic 的接头文件路径#

Terminal window

1
# 错误：相对路径在脚本换了目录后找不到
2
ILLUMINACLIP:TruSeq3-PE.fa:2:30:10
3

4
# 解决：用绝对路径
5
ADAPTER_FILE="${CONDA_PREFIX}/share/trimmomatic/adapters/TruSeq3-PE.fa"
6
trimmomatic PE ... ILLUMINACLIP:${ADAPTER_FILE}:2:30:10 ...

最好在脚本开头检查文件存在：

Terminal window

1
ADAPTER_FILE="${CONDA_PREFIX}/share/trimmomatic/adapters/TruSeq3-PE.fa"
2
if [[ ! -f "$ADAPTER_FILE" ]]; then
3
    echo "ERROR: Adapter file not found: $ADAPTER_FILE"
4
    exit 1
5
fi

本文于 2025-04-17 在 Debian 13 + Cutadapt 4.9 + Trimmomatic 0.39 上实测。

screen与tmux：SSH断线不中断的后台任务管理

Sat, 12 Apr 2025 00:00:00 GMT

生信分析最怕什么？不是代码报错——是跑了 18 小时的比对，SSH 断了。

screen 和 tmux 就是为解决这个问题而生的。它们在你的 SSH 会话之外创建一个独立的后台会话，即使你断网了、关电脑了，程序还在服务器上继续跑。下次登录一条命令就能回到之前的状态。

1. screen 快速上手——三分钟搞定#

安装#

Terminal window

1
apt install screen -y        # Debian/Ubuntu
2
yum install screen -y        # CentOS

核心操作（记住这6条就够了）#

Terminal window展开收起

1
# 1. 创建新会话
2
screen -S rnaseq            # -S 起个名字，别用自动生成的随机ID
3

4
# 2. 在screen里跑程序
5
bwa mem ref.fa sample.fastq.gz > output.sam
6
# 程序跑起来了...
7

8
# 3. 暂时离开（detach）：按 Ctrl+A 然后按 D
9
# 屏幕会显示 [detached from 12345.rnaseq]
10

11
# 4. 查看所有会话
12
screen -ls
13
# 输出：
14
#   There is a screen on:
15
#       12345.rnaseq    (Detached)
16

17
# 5. 重新连接（reattach）
18
screen -r rnaseq
19

20
# 6. 彻底关闭会话
21
# 在screen里输入 exit 或按 Ctrl+D

展开收起

常用快捷键（都在 Ctrl+A 之后）#

按键	功能
Ctrl+A, D	分离（最常用）
Ctrl+A, C	创建新窗口
Ctrl+A, N	下一个窗口
Ctrl+A, P	上一个窗口
Ctrl+A, “	窗口列表
Ctrl+A, [	进入滚动模式（翻看历史输出）
Ctrl+A, K	关闭当前窗口

实际使用场景#

场景1：在服务器上跑一个需要8小时的比对

Terminal window

1
ssh user@server
2
screen -S alignment
3
conda activate bioinfo
4
bwa mem -t 16 ref.fa sample.fastq.gz > sample.sam
5
# Ctrl+A, D 分离
6
# 关电脑回家
7
# 第二天：
8
ssh user@server
9
screen -r alignment
10
# 比对跑完了，可以看到所有输出

场景2：一个screen里开多个窗口跑不同任务

Terminal window

1
screen -S project
2
# 窗口0：跑比对
3
bwa mem ...
4
# Ctrl+A, C 创建新窗口
5
# 窗口1：查看日志
6
tail -f log.txt
7
# Ctrl+A, C 再创建
8
# 窗口2：编辑配置文件
9
vim config.yaml
10
# Ctrl+A, N/P 在窗口间切换

2. tmux——screen 的现代替代品#

tmux 功能更强、界面更现代、配置更灵活。如果用习惯了 screen 可以直接迁移到 tmux：

安装#

Terminal window

1
apt install tmux -y

核心操作#

Terminal window

1
# 创建会话
2
tmux new -s rnaseq
3

4
# 分离：Ctrl+B, D
5
# 查看会话
6
tmux ls
7
# 重新连接
8
tmux attach -t rnaseq
9
# 关闭
10
tmux kill-session -t rnaseq

tmux 的默认前缀键是 Ctrl+B（screen 是 Ctrl+A）。如果你习惯用 Ctrl+A，可以在 ~/.tmux.conf 里改：

Terminal window

1
echo "set -g prefix C-a" >> ~/.tmux.conf
2
echo "unbind C-b" >> ~/.tmux.conf
3
echo "bind C-a send-prefix" >> ~/.tmux.conf
4
tmux source-file ~/.tmux.conf

tmux 相对 screen 的优势#

特性	screen	tmux
窗口分割	需要打补丁	原生支持（Ctrl+B, %水平 / “垂直）
会话共享	基础支持	完善支持
配置文件	`.screenrc`	`.tmux.conf`
状态栏	基础	高度可定制

tmux 的窗口分割特别实用： 左边 vim 写代码，右边跑命令，不用切窗口。

Terminal window

1
# tmux里
2
Ctrl+B, %     # 垂直分割（左右各一个窗格）
3
Ctrl+B, "     # 水平分割（上下各一个窗格）
4
Ctrl+B, 方向键 # 切换窗格

3. 踩坑#

坑1：screen -r 报 “There is no screen to be resumed” 原因：你上次 detach 之后又在另一个终端 attach 并 close 了。解决：screen -d -r rnaseq（强制 detach 另一端再 attach）

坑2：screen/tmux 里看不到颜色 在 screen 里：echo "term screen-256color" >> ~/.screenrc 在 tmux 里：echo "set -g default-terminal screen-256color" >> ~/.tmux.conf

坑3：screen 程序跑完了但会话还在 正常现象。可以用 screen -X -S rnaseq quit 强制关闭。

4. 选型建议#

只跑基础后台任务 → screen（老牌稳定，所有服务器都有）
经常需要分屏、共享会话 → tmux（现代体验好）

本文于 2025-04-12 在 Debian 13 上实测。

Linux进程管理：htop/ps/kill/nice

Sat, 05 Apr 2025 00:00:00 GMT

进程管理是 Linux 服务器运维的基本功。常见问题：服务器响应变慢不知道怎么排查、误杀进程导致计算白费、不知道如何调整进程优先级。本文覆盖 ps/htop 监控、kill 信号选择、nice/renice 优先级调整、后台进程管理。

实测环境：Debian 13，8核8GB RAM。

1. 查看进程——知道谁在跑、跑了多少#

1.1 ps——经典但繁琐#

Terminal window

1
# 查看当前用户的所有进程
2
ps aux | grep $USER
3

4
# 只看某个软件
5
ps aux | grep bwa
6

7
# 树状显示父子关系
8
ps auxf
9

10
# 按内存占用排序
11
ps aux --sort=-%mem | head -20
12

13
# 按 CPU 占用排序
14
ps aux --sort=-%cpu | head -20

ps aux 各列含义：

列	含义	生信关注点
PID	进程ID	kill 的时候用
%CPU	CPU占用率	超过100%表示用了多核
%MEM	内存占用率	快满时要注意
VSZ	虚拟内存( KB)	BWA 比对时通常很大
RSS	物理内存( KB)	实际吃掉的物理内存
STAT	进程状态	R=运行, S=睡眠, Z=僵尸
START	启动时间	跑了多久
TIME	累计CPU时间	判断计算是否在推进
COMMAND	命令行	区分不同任务

1.2 htop——更直观的进程监控#

Terminal window

1
# 安装
2
sudo apt install htop -y
3

4
# 启动
5
htop

htop 比 ps 好在：彩色界面、实时刷新、鼠标可点击、可以按 F6 排序、F9 直接 kill。我一般跑长任务时在 tmux 的一个窗格开 htop，随时看资源占用。

需要关注的 htop 指标：

CPU 使用率条：绿色是 normal，红色是 kernel 占用——如果红色很多说明 I/O 等待严重
Mem 条：绿色是已用，蓝色是 buffers，黄色是 cache——Linux 会尽可能用空闲内存做缓存，Mem 条”满”不一定有问题
Load average：1分钟/5分钟/15分钟平均负载。值 > CPU 核数说明有任务在排队——服务器在超负荷运转

Terminal window

1
# 单核机器 Load average = 1.0 表示 CPU 刚好跑满
2
# 8核机器 Load average = 8.0 才算跑满
3
# Load average = 16 且核数=8 → 有一半的任务在排队，CPU 不够用了

1.3 其他实用查看工具#

Terminal window

1
# 查看进程树（谁启动了谁）
2
pstree -p
3

4
# 查看某个进程的详细信息
5
cat /proc/PID/status
6
cat /proc/PID/cmdline
7

8
# 查看进程打开了哪些文件（排查"文件被占用"问题）
9
lsof -p PID
10

11
# 实时进程监控（比 htop 更轻量）
12
top -u $USER

2. 终止进程——kill 不是只有 -9#

2.1 信号类型#

Terminal window

1
# 列出所有信号
2
kill -l

生信最常用的几个：

信号编号	信号名	效果	什么时候用
1	SIGHUP	挂断	重新加载配置文件
2	SIGINT	中断(Ctrl+C)	正常停止前台程序
9	SIGKILL	强制杀死	最后手段——程序怎么都不退
15	SIGTERM	优雅终止(默认)	正常停止进程，程序有机会清理
18	SIGCONT	继续	恢复被暂停的进程
19	SIGSTOP	暂停(不可捕获)	强制暂停

2.2 正确的 kill 姿势#

Terminal window

1
# 先优雅终止（给程序机会保存状态、删除临时文件）
2
kill 12345
3
# 等价于 kill -15 12345
4

5
# 等几秒，如果还没退
6
sleep 5
7

8
# 再强制杀死（最后手段）
9
kill -9 12345

kill -9（SIGKILL）不会给进程任何清理机会——临时文件不会删、数据可能还在缓冲区没写入磁盘。但这个命令又是最常敲的，因为跑飞了的流程有时就是怎么都停不下来。

一个原则：永远先用 kill（不带参数，默认 SIGTERM），不行再 kill -9。 对比对和组装这种计算密集型程序，SIGTERM 通常足够；挂死的 Python 脚本有时候需要 kill -9。

2.3 批量管理#

Terminal window

1
# 杀所有 bwa 进程
2
pkill bwa
3
# 或
4
killall bwa
5

6
# 更精确：只杀某个用户的 bwa
7
pkill -u bioinfo bwa
8

9
# 按进程名模式杀
10
pkill -f "python pipeline.py"
11

12
# 杀某个时间段内启动的所有进程（慎用！）
13
ps aux | grep "fastp" | awk '{print $2}' | xargs kill

用 pkill 和 killall 前一定确认好——pkill bwa 会把所有用户的 bwa 都杀了。

3. 后台运行——关了终端任务也不停#

3.1 nohup——经典方案#

Terminal window

1
# 后台运行，输出写到 nohup.out
2
nohup bwa mem -t 8 ref.fa r1.fq r2.fq > sample.sam 2>&1 &
3

4
# 查看后台任务
5
jobs
6

7
# 把前台任务转到后台
8
# 先 Ctrl+Z 暂停，然后
9
bg

nohup 让进程忽略 SIGHUP 信号（终端关闭时发出的信号）。& 让进程在后台启动。

3.2 disown——补救措施#

如果忘了 nohup，已经在前台跑了一个长任务：

Terminal window

1
# 1. 先 Ctrl+Z 暂停
2
# 2. bg 放入后台
3
bg
4
# 3. disown 解除和终端的关联
5
disown -h %1
6
# 现在关终端也不会杀这个进程

3.3 tmux——最佳实践#

nohup 的致命缺点：一旦启动你就看不到输出了，也不能交互。tmux 解决了这个问题：

Terminal window

1
# 创建新会话
2
tmux new -s pipeline
3

4
# 在 tmux 里跑任务
5
bwa mem -t 8 ref.fa r1.fq r2.fq > sample.sam
6

7
# Ctrl+B 然后 D → 分离会话，任务继续跑
8
# 关终端、回家、第二天来
9

10
# 重连
11
tmux attach -t pipeline
12
# 看到任务已经跑完了，输出都在

建议：长任务必须跑在 tmux/screen 里。 不怕一万就怕 SSH 断线。

4. 进程优先级——nice/renice#

服务器是共享资源，你的 BWA 比对不应该让其他同学的 R 都跑不动。

4.1 优先级基础#

Linux 优先级范围：-20（最高优先级）到 19（最低优先级）。默认是 0。数字越大越”nice”（谦让），优先级越低。

priority=20+nice_valuepriority = 20 + nice\_valuepriority=20+nice_value

nice 值 -20 → priority 0（最高），nice 值 19 → priority 39（最低）。

4.2 启动时设优先级#

Terminal window

1
# 以较低的优先级启动（不抢别人资源）
2
nice -n 10 bwa mem -t 8 ref.fa r1.fq r2.fq > sample.sam
3

4
# 以较高优先级启动（需要 sudo）
5
sudo nice -n -10 important_task.sh

4.3 运行时调整优先级#

Terminal window

1
# 查看进程的 nice 值
2
ps -eo pid,ni,comm | grep bwa
3

4
# 降低已运行进程的优先级（让它谦让）
5
renice -n 10 -p 12345
6

7
# 提高优先级（需要 sudo）
8
sudo renice -n -5 -p 12345

生信场景： 你在白天做交互式分析（RStudio、Jupyter），同时后台跑大批量比对。给批量比对设 nice -n 10，降低其 CPU 争抢，确保 RStudio 响应流畅。晚上离开时再 renice -n 0 恢复正常。

4.4 ionice——磁盘 I/O 优先级#

CPU 不是唯一瓶颈，磁盘 I/O 也能拖慢别人：

Terminal window

1
# 查看 ionice
2
ionice -p 12345
3

4
# 降低 I/O 优先级（idle 级别——只在没人用磁盘时才读）
5
ionice -c 3 -p 12345

类别：1=实时，2=尽力（默认），3=空闲。当你的批量比对在读参考基因组时会大量读盘，设成 -c 3 不会影响别人的交互操作。

5. 综合实战——进程管理流程#

场景：你需要在服务器上跑 20 个样本的 RNA-seq 流程#

Terminal window展开收起

1
# 1. 创建 tmux 会话
2
tmux new -s rnaseq_pipeline
3

4
# 2. 在 tmux 里，以低优先级启动主流程
5
nice -n 10 bash run_pipeline.sh &
6

7
# 3. 开另一个 tmux 窗格（Ctrl+B 然后 %）监控
8
htop
9
# 或持续监控特定进程
10
watch -n 2 'ps aux | grep bwa'
11

12
# 4. 分离 tmux，放心离开
13
# Ctrl+B 然后 D
14

15
# 几小时后回来重连
16
tmux attach -t rnaseq_pipeline
17

18
# 5. 如果某个样本卡住了
19
htop → F9 → 选进程 → 选信号 SIGTERM → 回车

展开收起

6. 踩坑记录#

坑1：kill -9 之后文件损坏#

症状：kill -9 了 BWA 进程，后面想续跑发现中间文件（如 SAM）损坏了——文件大小正确但内容截断。

原因：SIGKILL 不会让进程 flush 缓冲区。BWA 正在写入时被杀，缓冲区里的数据没落到磁盘。

教训： 先用 kill（SIGTERM），大多数生信软件（BWA、samtools、GATK）都正确处理 SIGTERM 并优雅退出。kill -9 留到最后。

坑2：Load average 很低但系统很卡#

症状：htop 显示 CPU 和内存都不高，load average < 1，但 ssh 输入有明显延迟，文件读写很慢。

原因：磁盘 I/O 瓶颈。htop 的 CPU 条里红色部分多、或者 iostat -x 1 显示 %util 接近 100%。

Terminal window

1
# 安装并查看 I/O 统计
2
sudo apt install sysstat -y
3
iostat -x 1
4

5
# 查看谁在疯狂写盘
6
iotop
7
# 或
8
pidstat -d 1

坑3：Ctrl+Z 之后忘了 bg，直接关终端#

症状：BWA 跑了一半，Ctrl+Z 暂停了，然后忘了 bg，直接关了终端。进程变成 stopped 状态，再也不会继续跑了。

解决：

Terminal window

1
# 下次登录后，找到被暂停的进程
2
ps aux | grep bwa
3
# STAT 列显示 T（stopped）
4

5
# 恢复它
6
kill -CONT 12345
7
# 或者
8
bg    # 如果你在同一 shell

坑4：nohup 输出把磁盘写满了#

症状：把 nohup 的默认输出（nohup.out）忘在了主目录，一个月后发现 nohup.out 有 50GB。

Terminal window

1
# 好习惯：重定向 nohup 输出
2
nohup bash pipeline.sh > pipeline.log 2>&1 &
3

4
# 或者直接丢弃输出
5
nohup bash pipeline.sh > /dev/null 2>&1 &
6

7
# 定期检查大文件
8
find ~ -name "nohup.out" -size +1G

坑5：renice 报错 “Permission denied”#

Terminal window

1
renice -n -5 -p 12345
2
# renice: failed to set priority for 12345: Permission denied

只能降低自己进程的优先级（正 nice 值），提高优先级（负值）需要 root 权限。降优先级不需要 sudo：

Terminal window

1
renice -n 10 -p 12345    # OK——降低自己进程的优先级
2
sudo renice -n -5 -p 12345  # 需要 sudo

坑6：pkill 误杀#

Terminal window

1
# 危险：pkill bwa 会杀所有含 bwa 的进程
2
pkill bwa
3

4
# 更安全：pkill -f 精确匹配
5
pkill -f "^bwa mem"
6

7
# 最安全：先确认再杀
8
pgrep -a bwa        # 先看看会杀哪些
9
# 确认无误后
10
pkill bwa

。

坑7：僵尸进程堆积#

症状：htop 里出现 Z（zombie）状态进程，数量越来越多但不消耗 CPU 和内存。

Terminal window

1
ps aux | grep 'Z'

僵尸进程是已结束但父进程还没回收的子进程。通常无害但数量多了说明父进程有问题。

Terminal window

1
# 找到僵尸进程的父进程
2
ps -eo ppid,pid,stat,comm | grep 'Z'
3

4
# 杀掉父进程让 init 接管回收
5
# 或用以下命令清理（慎用）
6
kill -CHLD <parent_pid>

7. 小结#

操作	命令	记忆要点
查看进程	`htop` / `ps aux`	htop更直观
优雅终止	`kill PID`	默认SIGTERM，等5秒
强制终止	`kill -9 PID`	最后手段
降低优先级	`nice -n 10 cmd`	数字越大越谦让
调整优先级	`renice -n 10 -p PID`	降优先无需sudo
后台运行	`nohup cmd &`	用tmux更好
断线保护	`tmux new -s name`	长任务常用
批量杀	`pkill -f pattern`	先pgrep确认

服务器不是个人电脑——它是全组共享的计算资源。把进程管理用好了，既保护自己的数据，也对得起同组同学的信任。

本文于 2025-04-05 在 Debian 13 上实测完成。htop 3.3.0，tmux 3.4，所有命令可直接复制使用。

seqkit：FASTA/FASTQ序列处理

Tue, 01 Apr 2025 00:00:00 GMT

seqkit 是用 Go 写的 FASTA/FASTQ 处理工具，处理 50GB 序列文件比手写 awk 快近 10 倍。本文覆盖 seqkit 最高频的 8 个场景：统计、过滤、抽样、格式转换、序列提取。全部在 Debian 13 上实测。

1. 安装与验证#

Terminal window

1
conda install -c bioconda seqkit -y
2
seqkit version
3
# seqkit v2.13.0

2. stats——拿到FASTQ第一件事#

这是我最常用的 seqkit 命令，比 FastQC 快但给出最核心的信息：

Terminal window

1
seqkit stats *.fastq.gz

输出：

1
file          format  type  num_seqs    sum_len  min_len  avg_len  max_len
2
sample_R1.gz  FASTQ   DNA     30,000  4,500,000    150    150.0      150
3
sample_R2.gz  FASTQ   DNA     30,000  4,500,000    150    150.0      150

列	含义	关注点
num_seqs	总序列数	双端文件应该相等
sum_len	总碱基数	换算测序量
min_len/max_len	长度范围	发现异常短/长 reads
avg_len	平均长度	确认 read 类型

如果 min_len 远小于 avg_len——说明有严重降解或接头污染，需要先跑 fastp。

3. 序列过滤——按长度、质量、名称#

Terminal window

1
# 过滤≥100bp的序列
2
seqkit seq -m 100 input.fastq.gz -o long.fastq.gz
3

4
# 过滤≤1000bp的序列（保留短的）
5
seqkit seq -M 1000 input.fastq.gz -o short.fastq.gz
6

7
# 只保留ATCG组成的序列（去掉含N的）
8
seqkit grep -s -r -p "^[ATCG]+$" input.fasta -o clean.fasta
9

10
# 按名称过滤（正则匹配）
11
seqkit grep -n -r -p "chr1" genome.fa -o chr1.fa

4. 抽样——大文件测试时的救星#

分析 500GB 的全基因组数据前，先抽取 1% 跑一遍验证流程：

Terminal window

1
# 按比例抽样（1%）
2
seqkit sample -p 0.01 input.fastq.gz -o sample.fastq.gz
3

4
# 按数量抽样（取10000条）
5
seqkit sample -n 10000 input.fastq.gz -o sample_10k.fastq.gz
6

7
# 设置随机种子（保证可重复）
8
seqkit sample -n 10000 -s 42 input.fastq.gz -o sample_10k.fastq.gz

-s 设置随机种子的重要性： 审稿人可能问你”怎么抽样的”，有种子就能精确复现。

5. 格式转换——FASTA↔FASTQ#

Terminal window

1
# FASTQ → FASTA（丢掉质量信息）
2
seqkit fq2fa input.fastq.gz -o output.fasta
3

4
# FASTA → FASTQ（质量全设为最高，仅测试用）
5
seqkit fa2fq input.fasta -o output.fastq.gz

6. 序列提取——按ID列表批量取#

Terminal window

1
# 从id_list.txt提取对应的序列
2
seqkit grep -n -f id_list.txt input.fasta -o subset.fasta
3

4
# 排除这些ID（反向选择）
5
seqkit grep -n -v -f exclude.txt input.fasta -o filtered.fasta

id_list.txt 格式一行一个 ID，不需要 > 前缀。

7. 序列去重与排序#

Terminal window

1
# 按序列去重（保留第一条）
2
seqkit rmdup -s input.fasta -o dedup.fasta
3

4
# 按名称排序
5
seqkit sort -n input.fasta -o sorted.fasta
6

7
# 按序列长度排序（从长到短）
8
seqkit sort -l -r input.fasta -o by_length.fasta

8. 碱基组成统计#

Terminal window

1
seqkit fx2tab -n -g -c input.fasta
2
# 输出：序列ID  序列  GC含量
3

4
# 只看GC含量
5
seqkit fx2tab -n -g -c input.fasta | awk '{print $1, $NF}'

9. 踩坑#

坑1：gzip文件需要额外处理吗？ 不需要。seqkit 自动识别 .gz 后缀并解压，直接喂就行。

坑2：输出文件格式 seqkit 默认根据 -o 参数的后缀自动选格式（.gz=压缩，.fa=FASTA，.fq=FASTQ）。

坑3：大文件 grep 很慢 seqkit grep -n -f big_list.txt 在大文件上比 seqtk subseq 慢。如果列表很大（>10万条），用 seqtk 更快。

10. 小结#

场景	命令	比awk快多少
快速统计	`seqkit stats`	5-10x
按长度过滤	`seqkit seq -m 100`	3-5x
抽样	`seqkit sample -p 0.1`	10x+
格式转换	`seqkit fq2fa`	2-3x
序列提取	`seqkit grep -n -f list`	3-5x

本文于 2025-04-01 在 Debian 13 上实测，seqkit v2.13.0。

下载加速：axel/aria2多线程与断点续传

Sat, 22 Mar 2025 00:00:00 GMT

生信数据下载量动辄几十上百 GB——SRA、ENA、GEO、Ensembl 参考基因组、注释文件。单线程下载无断点续传时效率很低，axel 和 aria2 可将下载速度提升 5-10 倍。本文覆盖多线程下载、断点续传、限速、代理配置和批量下载场景。

实测环境：Debian 13，千兆校园网。所有命令均实际跑通。

1. 安装与基础对比#

Terminal window

1
# axel——轻量，编译型，依赖少
2
sudo apt install axel -y
3
axel --version
4
# Axel version 2.17.14 (Linux)
5

6
# aria2——功能更全，支持更多协议
7
sudo apt install aria2 -y
8
aria2c --version
9
# aria2 version 1.37.0

特性	axel	aria2
多线程	✅（默认4，最大不限）	✅（默认5，可用-s调整）
断点续传	✅（自动）	✅（-c 参数）
HTTP/HTTPS	✅	✅
FTP	✅	✅
Metalink/种子	❌	✅
RPC 远程控制	❌	✅
下载速度上限设置	✅（-s 调线程即限速）	✅（—max-download-limit）
适合场景	单文件快速下载	批量/复杂协议下载

我的原则：单文件用 axel，批量/复杂场景用 aria2c。

2. axel 实操——最简单的多线程加速#

2.1 基础用法#

Terminal window

1
# 默认4线程下载
2
axel -n 10 -o ./downloads/ ftp://ftp.ensembl.org/pub/release-113/fasta/homo_sapiens/dna/Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz
3

4
# 参数说明：
5
# -n 10    → 10个线程
6
# -o ./downloads/  → 输出目录
7
# 自动生成 .st 状态文件用于断点续传

-n 不是越大越好。线程数受限于：

noptimal=min⁡(k,Bb)n_{optimal} = \min\left(k, \frac{B}{b}\right)noptimal=min(k,bB)

其中 kkk 是服务器允许的最大并发连接数（通常 4-16），BBB 是你本地带宽，bbb 是单线程实际可达速率。千兆网环境下 -n 10 到 -n 16 就够了，再大容易触发服务器限流甚至封 IP。

2.2 断点续传——断了怎么办#

axel 的 .st 状态文件就是断点续传的核心。如果下载中断，直接重新运行同一条命令，axel 自动检测 .st 文件并从断点继续：

Terminal window

1
# 第一次下载
2
axel -n 10 -o ./data/ https://example.com/huge.fastq.gz
3
# 下载到 60% 时网络断了...
4

5
# 重新运行——自动续传
6
axel -n 10 -o ./data/ https://example.com/huge.fastq.gz
7
# 输出：File huge.fastq.gz already partly retrieved (60%)

别手动删 .st 文件——删了就从头开始了。

2.3 批量下载#

Terminal window

1
# 准备 URL 列表
2
cat urls.txt
3
# https://example.com/sample1_R1.fastq.gz
4
# https://example.com/sample1_R2.fastq.gz
5
# https://example.com/sample2_R1.fastq.gz
6

7
# 逐个下载（含断点续传）
8
while read url; do
9
    echo "Downloading $url..."
10
    axel -n 10 -o ./data/ "$url"
11
done < urls.txt

3. aria2c 实操——更灵活的批量下载#

3.1 基础多线程下载#

Terminal window

1
# 16线程，5个分片（split）
2
aria2c -s 16 -x 5 -c -d ./data/ https://example.com/huge.fastq.gz
3

4
# 参数说明：
5
# -s 16   → 从16个连接下载
6
# -x 5    → 最多使用5个镜像/分片（对单个URL通常无用，但和 -s 配合好）
7
# -c      → 断点续传
8
# -d      → 输出目录

aria2c 的 -s 和 -x 关系稍微绕：

total_connections=s×min⁡(x,mirrors_available)total\_connections = s \times \min(x, mirrors\_available)total_connections=s×min(x,mirrors_available)

对单个 URL 且没有 metalink 时，-x 基本没用，主要是 -s 起作用。所以单文件下载时 -s 16 -x 1 就够了。

3.2 从 URL 列表批量下载——生信最常用#

Terminal window

1
# download_list.txt 格式（TSV）
2
# https://example.com/sample1_R1.fastq.gz  out=sample1_R1.fastq.gz
3
# https://example.com/sample1_R2.fastq.gz  out=sample1_R2.fastq.gz
4

5
aria2c -i download_list.txt -s 10 -c -d ./fastq/ -j 2
6

7
# -i   → 输入URL列表文件
8
# -j 2 → 同时下载2个文件（每个文件10个连接，总共20个连接）

-j 控制并发文件数，-s 控制每个文件的并发连接数。总连接数 = -j × -s。注意别把网络打满——给其他实验留点带宽。

3.3 限制下载速度——不影响实验室其他人#

Terminal window

1
# 限速 10MB/s
2
aria2c -s 10 -c --max-download-limit=10M https://example.com/huge.fastq.gz

如果实验室共享网络下你一个人跑满千兆，很快就会被同事找上门。我用 aria2c 的 --max-download-limit 配合 crontab 做时间窗口限速：

Terminal window

1
# 白天限速5MB/s，晚上放开到50MB/s
2
# /etc/crontab 或者 crontab -e
3
# 8:00切到限速模式，22:00切到放开模式

3.4 SRA/ENA 下载——生信下载重灾区#

SRA 的 prefetch 是官方工具但单线程+折磨。用 aria2c 直接从 ENA 下 FASTQ：

Terminal window

1
# 从 ENA 直接下 FASTQ（绕过 SRA 格式）
2
# accession 以 SRR12345678 为例，ENA URL 构造规则：
3
# ftp://ftp.sra.ebi.ac.uk/vol1/fastq/SRR123/008/SRR12345678/
4

5
SRR="SRR12345678"
6
PREFIX=$(echo $SRR | sed 's/...$//')  # SRR123
7
SUFFIX=$(echo $SRR | rev | cut -c1-3 | rev)  # 678
8

9
URL="ftp://ftp.sra.ebi.ac.uk/vol1/fastq/${PREFIX}/0${SUFFIX}/${SRR}/${SRR}_1.fastq.gz"
10
aria2c -s 16 -c -d ./fastq/ "$URL"

ENA FTP 不限速，16 线程轻松跑满千兆。

4. 生信下载场景速查表#

数据源	推荐工具	典型命令	线程建议
Ensembl FTP	axel	`axel -n 10 URL`	10-16
NCBI Genome	aria2c	`aria2c -s 16 -c URL`	8-16
ENA FASTQ	aria2c	`aria2c -s 16 -c URL`	16-20
GEO 补充文件	axel	`axel -n 8 URL`	8-10
UCSC bigWig	wget（单线程稳妥）	`wget -c URL`	1
百度网盘（备用）	bypy	`bypy download /path`	N/A

5. R 和 Python 中集成下载#

5.1 Python 中用 aria2c#

1
import subprocess
2
import os
3

4
def download_fastq(srr, outdir="./fastq/"):
5
    """
6
    从 ENA 下载指定 SRR 的 FASTQ 文件
7
    """
8
    os.makedirs(outdir, exist_ok=True)
9

10
    # 构造 ENA FTP URL（单端示例，实际双端需分别下 _1 和 _2）
11
    prefix = srr[:6]   # SRR123
12
    # ENA URL pattern
13
    url = f"ftp://ftp.sra.ebi.ac.uk/vol1/fastq/{prefix}/{srr}/{srr}_1.fastq.gz"
14

15
    cmd = [
16
        "aria2c",
17
        "-s", "16",       # 16个连接
18
        "-c",             # 断点续传
19
        "-d", outdir,
20
        "--max-download-limit=20M",
21
        url
22
    ]
23

24
    result = subprocess.run(cmd, capture_output=True, text=True)
25
    if result.returncode == 0:
26
        print(f"✅ {srr} 下载完成")
27
    else:
28
        print(f"❌ {srr} 下载失败: {result.stderr}")
29

30
# 批量下载
31
srr_list = ["SRR12345678", "SRR12345679", "SRR12345680"]
32
for srr in srr_list:
33
    download_fastq(srr)

展开收起

5.2 R 中用 system2 调 aria2c#

1
download_ensembl <- function(species = "homo_sapiens", release = 113) {
2
    url <- sprintf(
3
        "ftp://ftp.ensembl.org/pub/release-%d/fasta/%s/dna/%s.GRCh38.dna.primary_assembly.fa.gz",
4
        release, species, tools::toTitleCase(species)
5
    )
6

7
    system2(
8
        "aria2c",
9
        args = c("-s", "16", "-c", "-d", "./ref/", url)
10
    )
11
}
12

13
download_ensembl()

6. 踩坑记录#

坑1：axel 下载完成后文件损坏#

症状：文件大小正确但 gunzip 报 unexpected end of file。

原因：axel 的 .st 状态文件损坏，导致部分分片被跳过。

Terminal window

1
# 解决方案：删除 .st 状态文件，重新下载
2
rm -f ./data/huge.fastq.gz.st
3
axel -n 10 -o ./data/ https://example.com/huge.fastq.gz
4

5
# 下载后验证完整性
6
md5sum ./data/huge.fastq.gz
7
# 与源站提供的 MD5 对比

建议：重要数据下载后务必 md5sum 校验。ENA 提供 .md5 文件，Ensembl 提供 CHECKSUMS 文件。

坑2：aria2c 报 “Too many open files” 错误#

症状：下载到一半进程崩溃，ulimit 相关。

原因：Linux 默认的 ulimit -n（打开文件数上限）通常是 1024。aria2c 的 -s 16 会打开大量 socket，加上系统已有进程，容易超限。

Terminal window

1
# 检查当前上限
2
ulimit -n
3
# 1024
4

5
# 临时调大（当前 shell 生效）
6
ulimit -n 65536
7

8
# 永久修改（/etc/security/limits.conf）
9
# * soft nofile 65536
10
# * hard nofile 65536

坑3：ENA FTP 下载 404——accession 路径规则变了#

症状：ENA URL 返回 404，但 accession 在 SRA 上确实存在。

原因：ENA 对某些新数据使用了不同的目录结构规则。老的是 vol1/fastq/SRRxxx/，新的可能在 vol2/ 或不同路径。

Terminal window

1
# 用 ENA API 查实际 FTP 路径
2
curl "https://www.ebi.ac.uk/ena/portal/api/filereport?accession=SRR12345678&result=read_run&fields=fastq_ftp"
3

4
# 返回示例：
5
# ftp.sra.ebi.ac.uk/vol1/fastq/SRR123/008/SRR12345678/SRR12345678_1.fastq.gz;ftp.sra.ebi.ac.uk/vol1/fastq/SRR123/008/SRR12345678/SRR12345678_2.fastq.gz

永远用 API 查实际路径，不要硬编码 URL 规则。

坑4：下载速度上不去——被限流了#

症状：axel -n 20 和 -n 4 速度一样。

可能原因：

服务器端限流——NCBI/UCSC 会对单个 IP 限制并发数和速率
校园网 QoS——学校网络设备对 FTP 做了限速
硬盘写速度瓶颈——机械硬盘写入速度 ~100MB/s，网络 1Gbps 下载能跑到 ~125MB/s

Terminal window

1
# 测试磁盘写速度
2
dd if=/dev/zero of=./test_write bs=1M count=1000 oflag=direct
3
# 如果 < 100MB/s，换 SSD
4

5
# 测试是网络瓶颈还是磁盘瓶颈
6
# 直接下载到 /dev/null（不写入磁盘）
7
aria2c -s 16 -o /dev/null https://example.com/test.bin

坑5：断点续传的文件 MD5 不匹配#

症状：同一个文件，用 aria2c -c 续传完后 MD5 跟源站不一样。

原因：中间文件部分分片损坏，aria2c 默认不校验每个分片的完整性，只检查文件大小。

Terminal window

1
# 强制重新校验分片
2
aria2c -s 16 -c -V -d ./data/ https://example.com/huge.fastq.gz
3

4
# -V 参数：下载完成后校验 checksum（需要服务器支持）
5

6
# 配合 --check-integrity=true
7
aria2c -s 16 -c --check-integrity=true -d ./data/ https://example.com/huge.fastq.gz

坑6：批量下载时有的文件跳过了#

症状：while read 循环里跑 axel，某些文件直接被跳过。

原因：axel 在输出目录已存在完整文件时会报错退出（返回非零状态码），导致循环中断。

Terminal window

1
# 用 || true 忽略错误继续
2
while read url; do
3
    axel -n 10 -o ./data/ "$url" || true
4
done < urls.txt
5

6
# 更好的做法——先检查文件是否已存在
7
while read url; do
8
    fname=$(basename "$url")
9
    if [ -f "./data/$fname" ]; then
10
        echo "Skipping $fname (already exists)"
11
    else
12
        axel -n 10 -o ./data/ "$url"
13
    fi
14
done < urls.txt

坑7：wget 断点续传失败——文件格式变了#

症状：昨天 wget -c 续传的文件，今天续传时报错。

原因：服务器上的文件被更新了（比如 Ensembl release 升级后基因组文件变了）。续传时服务器返回新的 ETag/Content-Length，wget 无法继续。

这是无解的情况——只能删掉旧文件重新下载。所以大型参考基因组最好下了就单独存一份，等下次 release 更新时再重新下。

7. 小结#

场景	命令	关键点
单文件快速下	`axel -n 16 URL`	简单够用
批量下 FASTQ	`aria2c -i list.txt -s 16 -c -d dir/ -j 2`	控制并发数
断点续传	`axel -n 16 URL` / `aria2c -s 16 -c URL`	别删状态文件
ENA 数据	用 API 查路径 + `aria2c`	URL 规则会变
限速	`aria2c --max-download-limit=10M`	给实验室留带宽

下载是生信流程的第一步也是最长的一步。把这半小时搞定，后面流程跑得再慢你也有时间喝咖啡。

本文于 2025-03-22 在 Debian 13 上实测完成。axel v2.17.14，aria2 v1.37.0，所有命令均实际运行验证。

GNU Parallel批量处理：从串行到并行

Sat, 22 Mar 2025 00:00:00 GMT

串行 for 循环是生信脚本中最大的效率瓶颈之一：20 个样本串行跑 RNA-seq 流程，64 核服务器 CPU 利用率可能只有 6%。GNU Parallel 将串行循环改为并行执行，同样任务从通宵缩短到 45 分钟。本文覆盖从 for 到 Parallel 的迁移指南、xargs 对比、joblog 日志追踪和跨节点分发。

实测环境：Debian 13，GNU Parallel 2024.12.0，8核8GB RAM云服务器。

1. 安装与基本概念#

Terminal window

1
# Debian/Ubuntu
2
sudo apt install parallel -y
3

4
# Conda（版本更新）
5
conda install -c conda-forge parallel -y
6

7
# 确认
8
parallel --version

parallel 的核心概念就一句话：把输入列表里的每一项同时分发给多个进程去处理。默认同时跑 CPU 核数个任务，用 -j 控制并发数：

Terminal window

1
parallel -j4 echo "Processing" ::: sample1 sample2 sample3 sample4
2
# 同时跑4个

::: 后面跟的是输入参数列表。你也可以从管道读：

Terminal window

1
ls *.fastq.gz | parallel -j4 gzip -t {}
2
# {} 是占位符，代表管道传来的每一行

2. 从 for 循环迁移到 parallel#

2.1 最经典的 for 循环（串行版）#

Terminal window

1
# 串行——一个接一个，CPU闲得发慌
2
for r1 in *_R1.fastq.gz; do
3
    r2="${r1/_R1/_R2}"
4
    sample=$(basename "$r1" _R1.fastq.gz)
5
    fastp -i "$r1" -I "$r2" \
6
        -o "clean/${sample}_R1.fastq.gz" \
7
        -O "clean/${sample}_R2.fastq.gz" \
8
        -w 4
9
done

如果你有20个样本，这个循环需要 20 × 单个样本耗时。fastp 内部 -w 4 虽然用了4线程，但20个样本仍然是串行的。

2.2 改写成 parallel（并行版）#

Terminal window

1
ls *_R1.fastq.gz | parallel -j4 \
2
    'r1={}; r2=$(echo {} | sed "s/_R1/_R2/"); sample=$(basename {} _R1.fastq.gz);
3
     fastp -i "$r1" -I "$r2" -o "clean/${sample}_R1.fastq.gz" -O "clean/${sample}_R2.fastq.gz" -w 2'

关键变化：-j4 让4个样本同时跑，每个 fastp 内部 -w 2。总线程 = 4 × 2 = 8，刚好打满8核。总耗时从 20T 降到 5T 左右。

2.3 更优雅的方式——Shell 函数 + parallel#

把业务逻辑封装成函数，parallel 只负责调度：

1
#!/bin/bash
2
set -euo pipefail
3

4
INPUT_DIR="./raw_data"
5
OUTPUT_DIR="./clean"
6
THREADS_PER_JOB=2
7
PARALLEL_JOBS=4
8

9
mkdir -p "$OUTPUT_DIR"
10

11
run_fastp() {
12
    local r1="$1"
13
    local r2="${r1/_R1/_R2}"
14
    local sample=$(basename "$r1" _R1.fastq.gz)
15

16
    echo "[$(date '+%H:%M:%S')] Processing: $sample"
17

18
    fastp -i "$r1" -I "$r2" \
19
        -o "${OUTPUT_DIR}/${sample}_clean_R1.fastq.gz" \
20
        -O "${OUTPUT_DIR}/${sample}_clean_R2.fastq.gz" \
21
        --detect_adapter_for_pe \
22
        --qualified_quality_phred 20 \
23
        --length_required 36 \
24
        --cut_front --cut_tail \
25
        --cut_window_size 4 --cut_mean_quality 20 \
26
        -w "$THREADS_PER_JOB"
27

28
    echo "[$(date '+%H:%M:%S')] Done: $sample"
29
}
30

31
export -f run_fastp
32
export OUTPUT_DIR THREADS_PER_JOB
33

34
find "$INPUT_DIR" -name "*_R1.fastq.gz" | \
35
    parallel -j "$PARALLEL_JOBS" run_fastp {}

展开收起

export -f 是灵魂。 不加这行，parallel 子进程找不到函数定义。同理，函数里用到的环境变量（如 OUTPUT_DIR）也需要 export。

3. 生信高频实战场景#

3.1 批量 BWA 比对#

BWA 比对是生信最耗时的步骤之一，并行化收益最大：

Terminal window

1
run_bwa() {
2
    local r1="$1"
3
    local sample=$(basename "$r1" _R1.fastq.gz)
4
    local r2="${r1/_R1/_R2}"
5

6
    bwa mem -t 4 -R "@RG\tID:${sample}\tSM:${sample}" \
7
        /opt/refs/hg38.fa "$r1" "$r2" | \
8
        samtools sort -@ 2 -o "bam/${sample}.sorted.bam"
9

10
    samtools index "bam/${sample}.sorted.bam"
11
}
12

13
export -f run_bwa
14
ls raw/*_R1.fastq.gz | parallel -j2 run_bwa {}

注意这里 -j2 而不是 -j4。原因是 BWA mem 和 samtools sort 加起来每个任务可能吃掉 3-4GB 内存，8GB 机器上同时跑 4 个会触发 OOM killer。并行度的上限往往不是 CPU，是内存。

3.2 批量下载 SRA 数据#

Terminal window

1
# 从 accession list 并行下载
2
cat sra_ids.txt | parallel -j4 \
3
    'prefetch {} && fasterq-dump --split-3 {} -O fastq/ && rm -rf ~/ncbi/public/sra/{}'

SRA 下载瓶颈在网络带宽，百兆带宽设 -j2 足够，千兆可以到 -j6。

3.3 批量运行 R/Python 脚本#

Terminal window

1
# 对20个基因跑差异分析
2
parallel -j8 'Rscript run_deseq.R --gene {} --output results/{}.csv' ::: gene1 gene2 ... gene20
3

4
# 对多个癌症类型跑 Python 特征筛选
5
parallel -j4 'python select_features.py --cancer {} --output features/{}.tsv' ::: BRCA LUAD COAD

3.4 跨节点分发——SSH 模式#

Terminal window

1
# 把任务分发到3台机器，每台跑3个
2
parallel -S node1,node2,node3 -j9 \
3
    'bwa mem -t 2 /opt/refs/hg38.fa {} > {/.}.sam' ::: *.fastq.gz

前提是配置了 SSH 免密登录（后面有专篇讲）。-S 后面跟 hostname 或 user@hostname，多个用逗号分隔。

4. parallel 核心参数速查#

参数	含义	示例
`-j N`	同时跑 N 个任务	`-j8`
`-j N%`	用 N% 的 CPU 核数	`-j75%`
`--eta`	显示预计完成时间	`--eta`
`--bar`	显示进度条	`--bar`
`--joblog`	保存任务执行日志	`--joblog run.log`
`--resume-failed`	只重跑失败的任务	`--resume-failed --joblog run.log`
`--retries N`	失败自动重试 N 次	`--retries 3`
`--timeout N`	单任务超时自动 kill	`--timeout 3600`
`--halt now,fail=1`	一个失败全部停止	`--halt now,fail=1`
`--dry-run`	预览不执行	`--dry-run`
`--results dir`	每个任务输出到独立目录	`--results output/`

--joblog 是我最推荐的功能。 跑完一批样本后用它快速定位失败任务：

Terminal window

1
parallel --joblog jobs.log -j4 run_fastp {} ::: *.fastq.gz
2

3
# 检查失败任务（退出码非0）
4
awk '$7 != 0' jobs.log
5

6
# 只重跑失败的
7
parallel --resume-failed --joblog jobs.log -j4 run_fastp {}

5. parallel vs xargs vs for——什么时候用什么#

工具	适用场景	不适合
`for` 循环	≤3个样本、调试阶段	批量生产环境
`xargs -P`	简单命令、不需要函数	复杂多步骤逻辑
`parallel`	复杂函数、跨节点、需要日志	就一行简单命令且 parallel 没装

Terminal window

1
# xargs 够用的：验证 gzip 完整性
2
ls *.fastq.gz | xargs -P4 -I{} gzip -t {}
3

4
# parallel 更合适的：带多步骤逻辑
5
ls *_R1.fastq.gz | parallel -j4 \
6
    'fastp -i {} -I {=s/_R1/_R2/=} -o clean/{/.}_clean.fastq.gz'

{=s/_R1/_R2/=} 是 parallel 的内置字符串替换语法——比 sed 简洁很多。{/.} 等于去掉路径和后缀的文件名。

6. 并行效率的数学原理#

不是 -j 越大越好。阿姆达尔定律给出了理论上限：

S=1(1−P)+PNS = \frac{1}{(1 - P) + \frac{P}{N}}S=(1−P)+NP1

PPP：任务可并行化的比例
NNN：并行任务数
SSS：理论最大加速比

生信实际情况：

1
8核机器上 BWA 比对实测：
2
样本数  for循环耗时  parallel -j4耗时  加速比
3
  1      45分钟        45分钟          1.0×
4
  4     180分钟        52分钟          3.5×
5
  8     360分钟        62分钟          5.8×
6
 16     720分钟       130分钟          5.5×  ← 加速比反降了

16个样本时加速比从 5.8 降到 5.5，因为磁盘 I/O 成了瓶颈——所有任务都在抢同一个参考基因组文件。这也是为什么生产环境要把参考基因组放 SSD 或先用 vmtouch 缓存到内存。

最优并行数的估算公式：

Noptimal=min⁡(CPU_cores,RAMGBmem_per_taskGB,IO_bandwidthio_per_task)N_{optimal} = \min\left(CPU\_cores, \frac{RAM_{GB}}{mem\_per\_task_{GB}}, \frac{IO\_bandwidth}{io\_per\_task}\right)Noptimal=min(CPU_cores,mem_per_taskGBRAMGB,io_per_taskIO_bandwidth)

以 8 核 8GB 内存、BWA 比对为例：CPU 约束 = 8，内存约束 = 8÷2 = 4，I/O 约束通常 ≥4。取最小值 → -j4。

7. 踩坑记录#

坑1：`export -f` 忘记导出函数#

Terminal window

1
# 错误
2
run_fastp() { ... }
3
parallel run_fastp ::: *.fastq.gz
4
# /bin/bash: run_fastp: command not found
5

6
# 正确：需要 export -f
7
export -f run_fastp
8
parallel run_fastp ::: *.fastq.gz

parallel 在子 shell 中执行命令，父 shell 的函数子 shell 看不到，必须显式 export -f。

坑2：总线程数过度订阅#

症状：-j8 配 -w 4，htop 显示 32 个线程抢 8 个核，CPU 上下文切换占了 30%，实际吞吐反降。

解决：总线程数 = parallel_jobs × 工具内部线程数，这个值应该 ≤ CPU核数 × 1.2。

Terminal window

1
# 8核机器，正确配置
2
parallel -j4 配合 fastp -w 2  → 4×2=8 ✓
3
parallel -j2 配合 bwa -t 4    → 2×4=8 ✓
4

5
# 错误配置
6
parallel -j8 配合 fastp -w 4  → 8×4=32 ✗

坑3：parallel 的引用地狱#

Terminal window

1
# 单引号里 $HOME 不会被展开
2
parallel 'echo $HOME' ::: 1 2 3
3
# 输出空
4

5
# 解决方法1：双引号+转义
6
parallel "echo \$HOME" ::: 1 2 3
7

8
# 解决方法2（最推荐）：用函数封装，完全避开引用问题
9
my_echo() { echo "$HOME - $1"; }
10
export -f my_echo
11
parallel my_echo ::: a b c

函数封装是最干净的解决方式。花 30 秒写个函数，省去调试引号的半小时。

坑4：输入文件名含空格#

Terminal window

1
# 管道默认按空白符分割，文件名含空格会截断
2
ls *.fastq.gz | parallel gzip -t {}
3
# "sample A_R1.fastq.gz" → {} 只拿到 "sample"
4

5
# 解决方案：NULL 分隔符
6
find . -name "*.fastq.gz" -print0 | parallel -0 gzip -t {}

生信文件名含空格少见但存在——Windows 传过来的数据、Excel 导出的文件。养成用 -print0 / -0 的习惯。

坑5：`--joblog` 不记录被 OOM kill 的任务#

被 Out-Of-Memory killer 杀掉的进程（信号 SIGKILL），退出码可能记录为空或0。排查方法：

Terminal window

1
# 检查系统日志确认是否被 OOM
2
dmesg | grep -i "out of memory"
3
journalctl -k | grep oom
4

5
# 如果确认是 OOM，降低 -j 或加内存

坑6：parallel 输出全混在一起#

Terminal window

1
# 默认所有任务的 stdout/stderr 混在一起，完全没法看
2
parallel fastp -i {} ::: *.fastq.gz
3

4
# 解决：每个任务重定向到独立日志
5
parallel 'fastp -i {} > logs/{/.}.log 2>&1' ::: *.fastq.gz
6

7
# 或者用 --results 自动分目录
8
parallel --results output_logs fastp -i {} ::: *.fastq.gz
9
# 生成 output_logs/1/sample1/stdout, output_logs/1/sample1/stderr ...

坑7：`--halt` 和 `--retries` 的顺序#

Terminal window

1
# 错误写法：retries 在 halt 之后
2
parallel --halt now,fail=1 --retries 3 ...
3
# 失败任务会重试3次才触发 halt——浪费时间
4

5
# 正确写法：retries 在 halt 之前
6
parallel --retries 3 --halt now,fail=1 ...

我曾经让一个损坏的 fastq 文件被重试了 3 次才停下来。推荐加 --timeout 双保险：

Terminal window

1
parallel --timeout 1800 --retries 1 --halt now,fail=1 ...

8. 小结#

场景	命令模板	推荐 `-j`
fastp 质控	`parallel -j4 run_fastp {}`	CPU核数 ÷ 2
BWA 比对	`parallel -j2 run_bwa {}`	内存 ÷ 单任务内存
SRA 下载	`parallel -j4 prefetch {}`	带宽 ÷ 单下载速度
R 脚本批量	`parallel -j8 Rscript ...`	CPU核数
跨节点分发	`parallel -S node1,node2 ...`	节点数 × 每节点核数

GNU Parallel 不是魔法，它是把你闲置的 CPU 核真正用起来的工具。用了之后你看 htop 里 CPU 全部吃满的样子，会有一种奇异的满足感。

本文于 2025-03-22 在 Debian 13 上实测完成。GNU Parallel 2024.12.0，fastp 0.23.4，BWA 0.7.18。所有代码可直接复制运行。

bedtools区间操作：intersect/merge/coverage/closest

Tue, 18 Mar 2025 00:00:00 GMT

ChIP-seq 的 peak 落在哪些基因的 promoter 上？两个 peak set 有多少重叠？每个外显子的覆盖深度是多少？这些问题都一个答案：bedtools。

bedtools 的官方文档有 20+ 个子命令，但日常 90% 的场景只需要 5 个。本文覆盖最常用的 5 个子命令：intersect、merge、coverage、closest、genomecov，附带输出解读和常见坑。

实测环境：Debian 13，bedtools v2.31.1，Conda bioconda 安装。

1. BED 格式——先搞懂你操作的对象#

BED（Browser Extensible Data）是 bedtools 的默认输入格式，最简单：

1
chr1  100  500  geneA  0  +
2
chr1  600  900  geneB  0  -

BED 最少 3 列（chrom, start, end），常见到 6 列：

列	字段	注意
1	chrom	染色体名，跟参考基因组一致
2	start	0-based（第一个碱基的位置是0）
3	end	0-based，不包含该位置
4	name	基因名/peak ID
5	score	0-1000，可忽略
6	strand	`+` 或 `-`

最重要的一点——BED 是 0-based，跟人类直觉的 1-based 不同：

坐标系统	第1个碱基	区间 [1,10] 的含义	工具
0-based	位置0	第1到第10个碱基	bedtools, BAM, bigWig
1-based	位置1	第1到第10个碱基	SAM, GFF, VCF

踩坑： 如果你从 GFF（1-based）手动转 BED，需要把 start 减 1：bed_start = gff_start - 1。

2. intersect——求交集，最核心的功能#

2.1 基础用法#

Terminal window

1
# 基因A（genes.bed）和peak（peaks.bed）在哪些区域重叠？
2
bedtools intersect -a genes.bed -b peaks.bed

输出：genes.bed 中与 peaks.bed 有重叠的行。

2.2 控制重叠策略——最容易被忽略的参数#

默认情况下，只要有 1bp 重叠就算 hit。但生信中常常需要”至少 50% 重叠”：

Terminal window

1
# 要求基因区域至少50%被peak覆盖
2
bedtools intersect -a genes.bed -b peaks.bed -f 0.5
3

4
# 要求重叠>=100bp
5
bedtools intersect -a genes.bed -b peaks.bed -F 0.5 -e

-f 的含义是：重叠区域占 -a 区域的至少 1bp。具体公式：

overlap_ratio=overlap_lengthlength_of_aoverlap\_ratio = \frac{overlap\_length}{length\_of\_a}overlap_ratio=length_of_aoverlap_length

用 -f 0.5 即要求 overlap_ratio ≥ 50%。

几个常用组合：

参数	含义	场景
`-f 0.5`	overlap占A的≥50%	peak注释到基因
`-F 0.5`	overlap占B的≥50%	基因筛选被peak完全覆盖的
`-u`	A中至少有1个B重叠即输出	去重模式，A每行最多输出一次
`-v`	反向：输出没重叠的	找”没被peak覆盖的基因”
`-wa -wb`	同时输出A和B的行	想知道”哪个peak落在哪个基因”

2.3 实战：peak 注释到基因 promoter#

Terminal window

1
# 先扩展promoter区域（TSS±2000bp作为promoter）
2
bedtools slop -i genes.bed -g chrom.sizes -b 2000 > promoters.bed
3

4
# 求peak和promoter的交集
5
bedtools intersect -a peaks.bed -b promoters.bed -wa -wb > peak_promoter.txt

2.4 输出解读#

实测运行 intersect -wa -wb 的输出：

1
chr1  150  450  peak1  100  chr1  100  500  geneA  0  +
2
chr1  580  850  peak2  80   chr1  600  900  geneB  0  -

每一行前几列是 peak 信息（-wa），后面是基因信息（-wb）。如果想知道 overlap 的精确区间，用 -wo 额外输出重叠长度：

Terminal window

1
bedtools intersect -a genes.bed -b peaks.bed -wa -wb -wo

3. merge——合并重叠区域#

ChIP-seq 的原始 peak 经常有多个相邻 peak 实际上来自同一个结合事件。merge 把它们合起来：

Terminal window

1
# 基础合并
2
bedtools merge -i peaks.bed
3

4
# 合并时要求重叠≥100bp才算连接
5
bedtools merge -i peaks.bed -d 100
6

7
# 合并并保留统计信息（如：合并了多少个原始peak）
8
bedtools merge -i peaks.bed -c 4,5 -o count,sum

-c 4,5 表示对第4列做 count（多少个原始peak）、第5列做 sum（总信号强度）。

4. coverage——计算覆盖度#

这在 RNA-seq 中用于计算每个基因的 reads 覆盖情况：

Terminal window

1
bedtools coverage -a genes.bed -b reads.bed

输出解读（每列含义）：

1
chr1  100  500  geneA  0  +  1  300  400  0.7500000
2
                               │   │    │      │
3
                reads数 ───────┘   │    │      │
4
           covered bases ──────────┘    │      │
5
             gene length ───────────────┘      │
6
        coverage ratio ────────────────────────┘

coverage_ratio=covered_basesgene_lengthcoverage\_ratio = \frac{covered\_bases}{gene\_length}coverage_ratio=gene_lengthcovered_bases

如果 coverage_ratio = 0.75，说明该基因 75% 的区域有 reads 覆盖。

生信场景： RNA-seq 的基因表达量化（老的 featureCounts 前身就是类似逻辑），或者 ChIP-seq 的 peak 富集度评估。

5. closest——找最近邻#

“每个基因 TSS 最近的 ChIP-seq peak 是哪个？”

Terminal window

1
bedtools closest -a genes.bed -b peaks.bed -d

-d 输出额外一列：两个区间之间的距离（bp）。如果重叠则为 0。

6. slop——扩展/收缩区间#

Terminal window

1
# 每个基因上下游各扩展200bp
2
bedtools slop -i genes.bed -g chrom.sizes -b 200
3

4
# 只向上游扩展（5'方向）
5
bedtools slop -i genes.bed -g chrom.sizes -l 500 -r 0
6

7
# 对于正链基因，-l 代表上游（5'端）；对于负链基因，自动翻转
8
# 用 -s 参数根据 strand 自动判断方向：
9
bedtools slop -i genes.bed -g chrom.sizes -l 2000 -r 500 -s

注意： -g chrom.sizes（染色体大小文件）是必须的——否则 slop 不知道染色体边界在哪里，可能导致区间超出染色体范围。

chrom.sizes 文件制作：

Terminal window

1
samtools faidx ref.fa
2
cut -f1,2 ref.fa.fai > chrom.sizes

7. genomecov——生成覆盖轨迹#

生成全基因组的覆盖度 bedGraph，之后可转为 bigWig 上传到 UCSC：

Terminal window

1
bedtools genomecov -i reads.bed -g chrom.sizes -bg > coverage.bedgraph
2

3
# -bg 输出 bedGraph 格式
4
# -bga 连零覆盖区域也输出（文件更大但更完整）
5
# -split 对包含N>CIGAR的BAM输入时，避免把intron区域也算进去

转 bigWig：

Terminal window

1
bedGraphToBigWig coverage.bedgraph chrom.sizes coverage.bw

8. 踩坑记录#

坑1：BED 坐标 0-based vs 1-based 搞混#

症状：注释时发现偏移了 1bp。

排查：检查你的输入是 BED（0-based）还是 GFF（1-based）。不确定就用 head 看区间长度是否等于 end-start。对 BED 来说这是对的，对 GFF 来说 end-start+1 才是实际长度。

坑2：染色体名不匹配#

症状：intersect 输出为空，明明两个文件都有 chr1。

原因：BED A 写的是 chr1，BED B 写的是 1。bedtools 把它们当不同染色体。

Terminal window

1
# 查看双方用了什么染色体名
2
cut -f1 genes.bed | sort -u
3
cut -f1 peaks.bed | sort -u

坑3：sort-buffer-size 不够导致运行极慢#

bedtools 处理大型 BED 文件时，如果没排序且没指定 sort 参数会巨慢：

Terminal window

1
# 先排序再操作
2
sort -k1,1 -k2,2n genes.bed > genes_sorted.bed
3
bedtools intersect -a genes_sorted.bed -b peaks_sorted.bed -sorted

-sorted 参数跳过 bedtools 内部的排序，处理 GB 级文件时速度提升 5-10 倍。

坑4：merge 后原始信息丢失#

merge 默认只保留染色体和坐标，其他列全部丢弃。要用 -c 和 -o 把关键信息保留下来。

9. 小结#

子命令	功能	核心参数
intersect	求交集	`-f`(重叠比例), `-v`(反向), `-wa -wb`(输出双方)
merge	合并重叠	`-d`(最大间距)
coverage	覆盖度	`-d`(逐碱基覆盖)
closest	最近邻	`-d`(输出距离)
slop	扩展区间	`-l`(左), `-r`(右), `-s`(按链)
genomecov	覆盖轨迹	`-bg`(bedGraph输出)

本文于 2025-03-18 在 Debian 13 上实测完成。bedtools v2.31.1，测试数据均为模拟 BED 文件。

Bash循环与条件判断：for/if/case全解

Sat, 15 Mar 2025 00:00:00 GMT

for 和 if 是 Shell 脚本中使用频率最高的两种控制结构——批量处理 FASTQ、判断比对状态、遍历染色体、重跑失败样本，几乎每个生信脚本都离不开循环和条件判断。本文覆盖 for/while/until 循环、if/case 分支、test 命令速查和 6 个批量处理模板。

实测环境：Debian 13，Bash 5.2。

1. for循环——生信批量处理的基石#

1.1 基础语法#

Terminal window展开收起

1
# 方式1：列表遍历（最常用）
2
for sample in sample1 sample2 sample3; do
3
    echo "Processing ${sample}"
4
done
5

6
# 方式2：花括号展开
7
for i in {1..10}; do
8
    echo "Round ${i}"
9
done
10

11
# 方式3：类似C的写法
12
for ((i=1; i<=10; i++)); do
13
    echo "Index: ${i}"
14
done
15

16
# 方式4：命令替换
17
for file in $(ls *.fastq.gz); do
18
    echo "Found: ${file}"
19
done

展开收起

强烈推荐方式1和方式3。方式4里的$(ls)有个经典问题：文件名含空格时会拆开。后面讲怎么安全遍历。

1.2 生信6大for循环模板#

模板1：批量处理配对FASTQ

1
#!/bin/bash
2
set -euo pipefail
3

4
# 假设文件名格式：Sample_S1_L001_R1_001.fastq.gz
5
R1_FILES=(*_R1_*.fastq.gz)
6

7
for r1 in "${R1_FILES[@]}"; do
8
    r2="${r1/_R1_/_R2_}"          # 替换R1为R2
9
    sample_id="${r1%%_R1*}"        # 提取样本ID
10
    sample_id="${sample_id##*/}"   # 去掉路径（如果有）
11

12
    echo "=== Processing ${sample_id} ==="
13

14
    # fastp质控
15
    fastp -i "${r1}" -I "${r2}" \
16
          -o "clean/${sample_id}_R1.fastq.gz" \
17
          -O "clean/${sample_id}_R2.fastq.gz" \
18
          -j "reports/${sample_id}_fastp.json" \
19
          -h "reports/${sample_id}_fastp.html" \
20
          -w 8
21

22
    echo "Done: ${sample_id}"
23
done

展开收起

模板2：遍历BAM文件做统计

Terminal window

1
for bam in alignments/*.bam; do
2
    sample=$(basename "${bam}" .bam)
3

4
    # flagstat统计
5
    samtools flagstat "${bam}" > "stats/${sample}_flagstat.txt"
6

7
    # 深度统计
8
    samtools depth -a "${bam}" | \
9
        awk '{sum+=$3; count++} END {print "Mean depth:", sum/count}' \
10
        > "stats/${sample}_depth.txt"
11

12
    echo "${sample}: $(cat stats/${sample}_depth.txt)"
13
done

模板3：遍历染色体的分染色体分析

Terminal window

1
CHROMS=(chr1 chr2 chr3 chr4 chr5 chr6 chr7 chr8 chr9 chr10 \
2
        chr11 chr12 chr13 chr14 chr15 chr16 chr17 chr18 chr19 chr20 \
3
        chr21 chr22 chrX chrY chrM)
4

5
INPUT_VCF="merged_variants.vcf.gz"
6

7
for chrom in "${CHROMS[@]}"; do
8
    echo "Splitting ${chrom}..."
9

10
    bcftools view -r "${chrom}" "${INPUT_VCF}" \
11
        -o "by_chrom/${chrom}.vcf.gz" -O z
12

13
    bcftools index "by_chrom/${chrom}.vcf.gz"
14
done

模板4：带计数的循环——看进度

Terminal window

1
files=(*.fastq.gz)
2
total=${#files[@]}
3
current=0
4

5
for f in "${files[@]}"; do
6
    ((current++))
7
    echo "[${current}/${total}] Processing ${f}..."
8

9
    fastp -i "${f}" -o "clean/${f}" -w 4
10
done
11

12
echo "All ${total} files processed!"

${#files[@]} 获取数组长度，((current++)) 是算术自增。这个模式在处理几百个样本时特别有用——随时知道跑到哪了。

模板5：嵌套循环——多条件组合

Terminal window

1
SAMPLES=(WT_1 WT_2 KO_1 KO_2)
2
TOOLS=(bwa bowtie2 hisat2)
3

4
for sample in "${SAMPLES[@]}"; do
5
    for tool in "${TOOLS[@]}"; do
6
        outdir="results/${tool}/${sample}"
7
        mkdir -p "${outdir}"
8

9
        echo "Aligning ${sample} with ${tool}..."
10
        # 不同工具用不同命令...
11
    done
12
done

模板6：for循环 + 条件跳过（排错必备）

Terminal window展开收起

1
FAILED_SAMPLES=()  # 记录失败的
2

3
for bam in *.bam; do
4
    sample=$(basename "${bam}" .bam)
5

6
    # 如果结果已存在且比BAM新，跳过
7
    if [[ -f "variants/${sample}.vcf.gz" ]] && \
8
       [[ "variants/${sample}.vcf.gz" -nt "${bam}" ]]; then
9
        echo "Skipping ${sample} (already done)"
10
        continue
11
    fi
12

13
    echo "Calling variants for ${sample}..."
14

15
    if ! bcftools mpileup -f ref.fa "${bam}" | \
16
         bcftools call -mv -o "variants/${sample}.vcf.gz"; then
17
        echo "ERROR: ${sample} failed!"
18
        FAILED_SAMPLES+=("${sample}")
19
    fi
20
done
21

22
echo "Failed samples: ${FAILED_SAMPLES[@]:-None}"

展开收起

continue 跳过一次循环，break 跳出整个循环。${FAILED_SAMPLES[@]:-None} 是参数展开的默认值用法。

2. while循环——处理动态输入#

2.1 逐行读取文件#

Terminal window

1
# 读取样本列表
2
while IFS= read -r sample; do
3
    [[ -z "${sample}" || "${sample}" == \#* ]] && continue  # 跳过空行和注释
4
    echo "Processing: ${sample}"
5
    # ...处理逻辑
6
done < sample_list.txt

IFS= read -r 这个组合绝对不能省：-r 禁止反斜杠转义，IFS= 保留行首行尾空格。这是一个无数人踩过的大坑。

2.2 管道while——小心子shell#

Terminal window

1
# ✗ 错误：管道中的while在子shell运行，变量不会传出来
2
total=0
3
cat counts.txt | while read -r n; do
4
    ((total += n))
5
done
6
echo "${total}"  # 输出：0 ——不是你要的！
7

8
# ✓ 正确：用重定向替代管道
9
total=0
10
while read -r n; do
11
    ((total += n))
12
done < counts.txt
13
echo "${total}"  # 输出：正确累加值

这个坑我至少踩了三次才记住。管道会创建子shell，while里的变量修改出不来。

2.3 无限循环+条件退出#

Terminal window

1
# 轮询等待文件生成
2
while true; do
3
    if [[ -f "pipeline_complete.flag" ]]; then
4
        echo "Pipeline finished!"
5
        break
6
    fi
7
    echo "Waiting..."
8
    sleep 60
9
done

2.4 until——条件为假时循环#

Terminal window

1
# 等到磁盘空间够用
2
until [[ $(df /data --output=pcent | tail -1 | tr -d ' %') -lt 20 ]]; do
3
    echo "Disk usage still >20%, waiting..."
4
    sleep 300
5
done
6
echo "Disk OK, starting download"

3. if条件判断——生信流程的决策中枢#

3.1 test命令速查表#

Bash里if后面跟的是一个命令（通常是test或其简写[ ]），靠退出码（0=真，非0=假）判断：

测试类型	语法	生信场景
文件存在	`[[ -f file ]]`	检查参考基因组存在
目录存在	`[[ -d dir ]]`	确保输出目录已创建
文件非空	`[[ -s file ]]`	检查BAM不是空的
文件可读	`[[ -r file ]]`	检查权限
文件1比文件2新	`[[ file1 -nt file2 ]]`	增量分析跳过已完成步骤
字符串相等	`[[ "$a" == "$b" ]]`	匹配样本类型
字符串不空	`[[ -n "$str" ]]`	参数是否传入
数值比较	`[[ $a -gt $b ]]`	测序深度阈值
正则匹配	`[[ "$a" =~ ^SRR ]]`	验证SRA ID格式

强烈建议使用[[ ]]不要用[ ]：[[ ]]是Bash内置，支持正则、不分割单词、不会因空变量报错。

3.2 生信6大条件判断模板#

模板1：检查输入完整性后启动流程

Terminal window展开收起

1
REF="/opt/refs/hg38.fa"
2
R1="sample_R1.fastq.gz"
3
R2="sample_R2.fastq.gz"
4

5
if [[ ! -f "${REF}" ]]; then
6
    echo "ERROR: Reference genome not found: ${REF}"
7
    exit 1
8
fi
9

10
if [[ ! -f "${R1}" ]]; then
11
    echo "ERROR: R1 file missing: ${R1}"
12
    exit 1
13
fi
14

15
if [[ ! -f "${R2}" ]]; then
16
    echo "WARNING: R2 missing, running single-end mode"
17
    MODE="single"
18
else
19
    MODE="paired"
20
fi
21

22
echo "All checks passed. Starting pipeline (${MODE})..."

展开收起

模板2：按比对率判断是否重新比对

Terminal window

1
MAPPING_RATE=$(samtools flagstat "${bam}" | \
2
    grep "mapped (" | grep -oP '\d+\.\d+(?=%)' | head -1)
3

4
if [[ $(echo "${MAPPING_RATE} < 70" | bc -l) -eq 1 ]]; then
5
    echo "WARNING: Low mapping rate (${MAPPING_RATE}%). Consider different aligner."
6
    # 或者发邮件通知
7
fi

模板3：if-elif-else多分支

Terminal window

1
READ_LENGTH=$(seqkit stats "${fastq}" | tail -1 | awk '{print $7}' | cut -d. -f1)
2

3
if [[ "${READ_LENGTH}" -lt 50 ]]; then
4
    ALIGNER="bowtie"        # 超短reads
5
elif [[ "${READ_LENGTH}" -lt 150 ]]; then
6
    ALIGNER="bwa"           # 短reads
7
elif [[ "${READ_LENGTH}" -lt 1000 ]]; then
8
    ALIGNER="minimap2 -x sr" # 中等长度
9
else
10
    ALIGNER="minimap2 -x map-ont"  # 长reads
11
fi
12

13
echo "Auto-selected aligner: ${ALIGNER}"

模板4：短路判断——一句话检查多个条件

Terminal window

1
# 检查所有必需软件
2
check_tool() {
3
    command -v "$1" >/dev/null 2>&1 || {
4
        echo "ERROR: $1 not installed"
5
        exit 1
6
    }
7
}
8

9
for tool in bwa samtools bcftools fastp seqkit; do
10
    check_tool "${tool}"
11
done
12

13
echo "All tools available!"

模板5：正则匹配验证输入

Terminal window

1
SRA_ID="SRR12345678"
2

3
if [[ "${SRA_ID}" =~ ^(SRR|ERR|DRR)[0-9]{6,}$ ]]; then
4
    echo "Valid SRA ID: ${SRA_ID}"
5
else
6
    echo "ERROR: Invalid SRA ID format"
7
    exit 1
8
fi

模板6：根据上一步退出码决定下一步

Terminal window

1
# 运行比对
2
bwa mem -t 16 ref.fa reads.fq > aln.sam
3
ALN_EXIT=$?
4

5
if [[ ${ALN_EXIT} -eq 0 ]]; then
6
    echo "Alignment OK, sorting..."
7
    samtools sort -@ 8 aln.sam -o aln.bam
8
else
9
    echo "ERROR: Alignment failed with code ${ALN_EXIT}"
10
    exit ${ALN_EXIT}
11
fi

4. case——多分支比if-elif更清晰#

当有3个以上分支时，case 比 if-elif-else 可读性好得多：

Terminal window展开收起

1
INPUT_FMT="${1:-fastq}"
2

3
case "${INPUT_FMT}" in
4
    fastq|fq)
5
        echo "FASTQ mode"
6
        EXT="fastq.gz"
7
        ;;
8
    bam|sam)
9
        echo "BAM/SAM mode"
10
        EXT="bam"
11
        ;;
12
    vcf)
13
        echo "VCF mode"
14
        EXT="vcf.gz"
15
        ;;
16
    *)
17
        echo "Unknown format: ${INPUT_FMT}"
18
        echo "Supported: fastq, bam, vcf"
19
        exit 1
20
        ;;
21
esac

展开收起

生信中适合case的场景：

Terminal window展开收起

1
# 根据文件扩展名判断操作
2
for file in *; do
3
    case "${file}" in
4
        *.fastq.gz|*.fq.gz)
5
            zcat "${file}" | wc -l
6
            ;;
7
        *.bam)
8
            samtools flagstat "${file}"
9
            ;;
10
        *.vcf.gz)
11
            bcftools stats "${file}" | head -5
12
            ;;
13
        *.log)
14
            tail -20 "${file}"
15
            ;;
16
    esac
17
done

展开收起

5. 生信全流程实例：Bash批量RNA-seq预处理#

1
#!/bin/bash
2
set -euo pipefail
3

4
# ========== 配置 ==========
5
DATA_DIR="./raw_data"
6
OUT_DIR="./processed"
7
REF="/opt/refs/hg38.fa"
8
THREADS=16
9
FAILED_LOG="failed_samples.txt"
10

11
> "${FAILED_LOG}"  # 清空失败日志
12

13
# ========== 预检查 ==========
14
for tool in fastp hisat2 samtools; do
15
    if ! command -v "${tool}" >/dev/null 2>&1; then
16
        echo "ERROR: ${tool} not found in PATH"
17
        exit 1
18
    fi
19
done
20

21
[[ -f "${REF}" ]] || { echo "ERROR: Ref genome missing"; exit 1; }
22
mkdir -p "${OUT_DIR}/qc_reports" "${OUT_DIR}/bam" "${OUT_DIR}/logs"
23

24
# ========== 主循环 ==========
25
R1_FILES=("${DATA_DIR}"/*_R1.fastq.gz)
26
TOTAL_SAMPLES=${#R1_FILES[@]}
27
CURRENT=0
28

29
for r1 in "${R1_FILES[@]}"; do
30
    ((CURRENT++))
31

32
    # --- 配对R2 ---
33
    r2="${r1/_R1/_R2}"
34
    sample=$(basename "${r1}" | sed 's/_R1.fastq.gz//')
35

36
    if [[ ! -f "${r2}" ]]; then
37
        echo "[${CURRENT}/${TOTAL_SAMPLES}] SKIP ${sample}: R2 missing" | tee -a "${FAILED_LOG}"
38
        continue
39
    fi
40

41
    echo "[${CURRENT}/${TOTAL_SAMPLES}] Processing ${sample}..."
42

43
    # --- fastp质控 ---
44
    if [[ -f "${OUT_DIR}/qc_reports/${sample}_fastp.json" ]]; then
45
        echo "  QC report exists, skipping fastp"
46
    else
47
        fastp -i "${r1}" -I "${r2}" \
48
              -o "${OUT_DIR}/${sample}_R1.fq.gz" \
49
              -O "${OUT_DIR}/${sample}_R2.fq.gz" \
50
              -j "${OUT_DIR}/qc_reports/${sample}_fastp.json" \
51
              -h "${OUT_DIR}/qc_reports/${sample}_fastp.html" \
52
              -w "${THREADS}" \
53
              2>&1 | tee "${OUT_DIR}/logs/${sample}_fastp.log"
54
    fi
55

56
    # --- HISAT2比对 ---
57
    bam="${OUT_DIR}/bam/${sample}.bam"
58

59
    if [[ -f "${bam}" ]] && [[ -s "${bam}" ]]; then
60
        echo "  BAM exists, skipping alignment"
61
    else
62
        hisat2 -p "${THREADS}" -x "${REF%.*}" \
63
               -1 "${OUT_DIR}/${sample}_R1.fq.gz" \
64
               -2 "${OUT_DIR}/${sample}_R2.fq.gz" \
65
               2> "${OUT_DIR}/logs/${sample}_align.log" | \
66
            samtools sort -@ "${THREADS}" -o "${bam}" -
67

68
        if [[ $? -ne 0 ]]; then
69
            echo "[${CURRENT}/${TOTAL_SAMPLES}] FAILED: ${sample}" | tee -a "${FAILED_LOG}"
70
            continue
71
        fi
72

73
        samtools index "${bam}"
74
    fi
75

76
    # --- 比对率检查 ---
77
    mapping_rate=$(grep "overall alignment rate" "${OUT_DIR}/logs/${sample}_align.log" | \
78
                   grep -oP '\d+\.\d+%' | head -1)
79
    echo "  ${sample}: mapping rate = ${mapping_rate}"
80

81
    # --- 低比对率警告 ---
82
    if [[ -n "${mapping_rate}" ]]; then
83
        rate_num="${mapping_rate%\%}"
84
        if [[ $(echo "${rate_num} < 70" | bc -l) -eq 1 ]]; then
85
            echo "  ⚠ WARNING: Low mapping rate for ${sample}!" | tee -a "low_mapping_samples.txt"
86
        fi
87
    fi
88
done
89

90
# ========== 汇总 ==========
91
echo ""
92
echo "=========================================="
93
echo "Pipeline complete!"
94
echo "Total samples: ${TOTAL_SAMPLES}"
95
echo "Failed: $(wc -l < ${FAILED_LOG})"
96
echo "=========================================="

展开收起

这个脚本涵盖了本篇几乎所有知识点：for循环、if判断、条件跳过、退出码检查、数组、变量展开、日志输出。

6. 踩坑记录#

坑1：`for file in *.fastq.gz` 没有匹配时变成字面字符串#

症状：当目录下没有 .fastq.gz 文件时，for f in *.fastq.gz; do 循环依然执行一次，$f 的值是字面量 *.fastq.gz。

Terminal window

1
# ✓ 解决：先检查或用 shopt
2
shopt -s nullglob     # 没匹配时展开为空
3
for f in *.fastq.gz; do
4
    echo "Processing $f"
5
done
6
shopt -u nullglob     # 恢复默认
7

8
# 或者先判断
9
files=(*.fastq.gz)
10
if [[ ! -e "${files[0]}" ]]; then
11
    echo "No FASTQ files found"; exit 1
12
fi

坑2：while read 最后一行不处理（缺换行符）#

症状：文件最后一行没有换行，while read 就读不到它。

Terminal window

1
# ✓ 用 || [[ -n "$line" ]] 兜底
2
while IFS= read -r line || [[ -n "$line" ]]; do
3
    echo "$line"
4
done < file.txt

坑3：`if [ $a == $b ]` 中变量为空导致语法错误#

症状：a="" 时 [ $a == "hello" ] 展开成 [ == hello ]，[ 命令报语法错误。

Terminal window

1
# ✓ 用 [[ ]]（推荐）或加引号
2
[[ $a == "hello" ]]     # 内置，安全
3
[ "$a" == "hello" ]     # 传统，必须加引号

坑4：`for` 遍历命令输出时空格/换行问题#

症状：for f in $(find . -name "*.bam") 遇到文件名含空格就拆开。

Terminal window

1
# ✓ 用 while read 或 find -print0 + while read -d ''
2
find . -name "*.bam" -print0 | while IFS= read -r -d '' f; do
3
    echo "Processing: ${f}"
4
done
5

6
# 或启用 globstar 替代 find
7
shopt -s globstar
8
for f in **/*.bam; do
9
    echo "Processing: ${f}"
10
done

坑5：循环内修改全局变量在管道中丢失#

已在 2.2 节详述。补充一个进程替换的解决方案：

Terminal window

1
# 如果必须用管道，用进程替换保持变量作用域
2
total=0
3
while read -r n; do
4
    ((total += n))
5
done < <(cat counts.txt)   # 进程替换，不是管道
6
echo "${total}"  # 正确

坑6：`break` 只跳出最内层循环#

症状：嵌套循环里 break 只跳出内层。

Terminal window

1
# 跳出多层用 break N
2
for i in {1..5}; do
3
    for j in {1..5}; do
4
        if [[ $i -eq 3 && $j -eq 3 ]]; then
5
            break 2  # 跳出两层
6
        fi
7
    done
8
done

坑7：`(( i++ ))` 中 `i` 未初始化#

Bash中未初始化的变量在算术运算中当0处理，这点OK。但如果在 set -u 下：

Terminal window

1
set -u
2
for f in *.txt; do
3
    (( count++ ))        # 报错：count: unbound variable
4
done
5

6
# ✓ 先初始化
7
count=0
8
for f in *.txt; do
9
    (( count++ ))
10
done
11
echo "${count}"

7. 总结#

需求	用这个	一句话
遍历固定列表	`for i in list`	简单直接
按数量/范围循环	`for ((i=1;i<=N;i++))`	C风格循环
逐行读文件	`while read -r`	处理大样本列表
等待条件满足	`while true` / `until`	监控类任务
简单判断	`if [[ condition ]]`	90%的场景
多分支	`case ... esac`	>3个分支时用
根据上一步结果	`if command; then`	直接用命令退出码

循环和条件判断是Shell脚本的骨架。把上面的6+6+2=14个模板收藏好，下次写生信脚本时直接复制改参数，比从头写快10倍。

这两个符号记牢：[[ ]] 和 (( ))——前者是字符串/文件的测试，后者是算术运算。别跟他们死磕，注意：字符串用 [[ ]]，数字用 (( ))。

本文于 2025-03-15 在 Debian 13 (Bash 5.2) 上实测完成。所有代码可直接运行。

Conda环境冲突解决：mamba加速、channel优先级、版本锁定

Tue, 11 Mar 2025 00:00:00 GMT

Conda 的依赖解析基于 SAT 求解器，当 bioconda、conda-forge、defaults 三个 channel 混装时，解析复杂度指数增长，conda install 可能耗时 10-15 分钟仍报 Found conflicts!。本文覆盖 mamba 加速替代、channel_priority 配置和版本锁定策略，每一步在 Debian 13 上实测。

1. 宿主环境#

Terminal window

1
$ cat /etc/os-release | head -2
2
PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
3
NAME="Debian GNU/Linux"
4

5
$ uname -m && free -h | head -2
6
x86_64
7
Mem:  7.7Gi
8

9
$ conda --version
10
conda 24.11.3
11

12
$ mamba --version
13
mamba 2.0.5

本文所有操作兼容 Ubuntu 20.04/22.04 和 CentOS 7。mamba 2.x 语法和 conda 完全兼容。

2. 冲突为什么会发生——依赖解析的本质#

Conda 安装一个包时，需要求解一个布尔可满足性问题（SAT）。把每个包看作变量，每个版本号是变量的取值，依赖关系是约束条件。形式化地说：

P={(p1,v1),(p2,v2),...,(pn,vn)}P = \{(p_1, v_1), (p_2, v_2), ..., (p_n, v_n)\}P={(p1,v1),(p2,v2),...,(pn,vn)}

其中 pip_ipi 是包名，viv_ivi 是满足所有约束的版本号。求解器需要在满足以下条件的同时找到一个合理的赋值：

C(p)={dep1∧dep2∧...∧depk}C(p) = \{dep_1 \land dep_2 \land ... \land dep_k\}C(p)={dep1∧dep2∧...∧depk}

每个包的依赖又引入了新的变量和约束，复杂度指数增长。这就是为什么 400 个包的环境和 28 个包的环境，安装速度差了一个数量级。

更致命的是 channel 混用带来的跨源约束：

Terminal window

1
# 恶劣示范：三个channel无序混装
2
conda install -c bioconda samtools       # bioconda编译的1.18，依赖libdeflate v1.14
3
conda install -c conda-forge bcftools    # conda-forge编译的1.19，依赖libdeflate v1.18
4
# 现在libdeflate被拉成v1.18，samtools 1.18链接的却是v1.14的符号...

不同 channel 的包虽然名字一样，但编译参数、依赖版本、ABI 都可能不同。混用就像把 Debian 的 .deb 和 Fedora 的 .rpm 装在同一台机器上——不是不能跑，但迟早崩。

3. mamba——把 conda 加速 10 倍#

mamba 是 conda 的 C++ 重实现，用 libsolv 替代了 Python 的 SAT 求解器。语法 100% 兼容，速度提升 5-20 倍。

3.1 安装 mamba#

Terminal window

1
# 方式1：在 base 环境装（推荐，所有环境通用）
2
conda install -c conda-forge mamba -y
3

4
# 方式2：用 micromamba（更轻量，不需要 conda）
5
# 下载地址：https://github.com/mamba-org/micromamba-releases/releases

3.2 直接替换 conda 命令#

Terminal window

1
# 装包
2
mamba install -c bioconda star salmon -y
3

4
# 创建环境
5
mamba create -n scrna_env python=3.10 -y
6

7
# 更新
8
mamba update --all -y
9

10
# 搜索
11
mamba repoquery search samtools

mamba repoquery 是额外的杀手级功能——能在安装前告诉你依赖树长什么样：

Terminal window

1
# 查看 samtools 依赖哪些包
2
mamba repoquery depends -c bioconda samtools
3

4
# 输出类似：
5
# samtools ==1.20
6
#   ├─ libdeflate >=1.19
7
#   ├─ htslib >=1.20
8
#   └─ ncurses >=6.4

3.3 实测对比：conda vs mamba#

Terminal window

1
# 测试：创建含 15 个生信常用包的环境
2
time conda create -n test_conda -c bioconda -c conda-forge \
3
    samtools bcftools bedtools fastqc fastp star salmon \
4
    subread picard qualimap multiqc deeptools -y 2>&1 | tail -1
5

6
# 输出：real 8m42s
7

8
time mamba create -n test_mamba -c bioconda -c conda-forge \
9
    samtools bcftools bedtools fastqc fastp star salmon \
10
    subread picard qualimap multiqc deeptools -y 2>&1 | tail -1
11

12
# 输出：real 1m18s

6.7 倍的差距。环境越复杂，差距越大。从今天开始，把所有 conda 替换为 mamba，你不会有任何损失。

4. channel 优先级——冲突预防的第一道防线#

4.1 strict vs flexible：选谁？#

Terminal window

1
# strict（严格）：高优先级channel里的包不能依赖低优先级channel的包
2
conda config --set channel_priority strict
3

4
# flexible（灵活）：允许跨channel依赖，按添加顺序搜索
5
conda config --set channel_priority flexible

生信场景强烈推荐 strict。 原因：

strict：如果你把 bioconda 设为最高优先级，conda 会强制所有依赖也从 bioconda 解决，只在找不到时才降级去 conda-forge。这避免了前面说的”不同源编译同一依赖”的问题。
flexible：允许 bioconda 的包直接拉 conda-forge 的依赖。听起来方便，但两个 channel 编译的 htslib 可能 ABI 不兼容。

4.2 推荐的 channel 顺序#

Terminal window

1
conda config --set channel_priority strict
2

3
conda config --add channels bioconda
4
conda config --add channels conda-forge
5
conda config --add channels defaults  # 可选，放最后

顺序含义： 先找 bioconda（生信专用），再找 conda-forge（通用科学计算），最后 defaults（Anaconda 官方）。

4.3 查看当前配置#

Terminal window

1
conda config --show channel_priority
2
conda config --show channels
3
# 输出：
4
# channel_priority: strict
5
# channels:
6
#   - bioconda
7
#   - conda-forge
8
#   - defaults

4.4 必须跨 channel 时怎么办#

有些包确实只在 conda-forge 上有（比如 scanpy）。这时候在安装命令中显式覆盖 channel：

Terminal window

1
# 这个 scanpy 会从 conda-forge 拉，但依赖尽量在 bioconda 找
2
mamba install -c conda-forge scanpy -y
3

4
# 如果因此产生冲突，单独建一个环境
5
mamba create -n scanpy_env -c conda-forge scanpy -y

5. 版本锁定——环境复现的最终保障#

5.1 导出精确环境（conda list —explicit）#

Terminal window

1
# 导出：记录每个包的精确版本+构建号+来源URL
2
conda list --explicit > env_explicit.txt
3

4
# 文件内容示例：
5
# https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda/linux-64/samtools-1.18-h50ea8bc_1.conda
6
# https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/linux-64/htslib-1.19-h81da01d_0.conda

这是最可靠的复现方式——不仅锁了版本号，还锁了构建号（h50ea8bc_1 这个哈希）。同一个包在 conda-forge 和 bioconda 可能有不同的构建号。

Terminal window

1
# 恢复环境
2
mamba create -n restored_env --file env_explicit.txt -y

5.2 用 pinned 文件阻止自动升级#

Terminal window

1
# 在环境目录下创建 pinned 文件
2
echo "samtools ==1.18" >> $CONDA_PREFIX/conda-meta/pinned
3
echo "htslib ==1.19" >> $CONDA_PREFIX/conda-meta/pinned

之后在这个环境中装任何新包，mamba/conda 都会尽量不动 samtools 和 htslib。但只在依赖允许的范围内生效——如果新包硬性要求 htslib >=1.20，pin 会失效。

5.3 environment.yml——跨平台的分发方案#

environment.yml

1
name: rnaseq_pipeline
2
channels:
3
  - bioconda
4
  - conda-forge
5
dependencies:
6
  - samtools =1.18
7
  - star =2.7.11b
8
  - salmon =1.10.2
9
  - fastqc =0.12.1
10
  - fastp =0.24.0
11
  - multiqc =1.21
12
  - python =3.10
13
  - pip:
14
      - gseapy==1.1.3

Terminal window

1
# 从 yml 创建环境
2
mamba env create -f environment.yml

注意：yml 里的 =1.18 是”>=1.18 的任意版本”。如果需要精确到构建号，用 ==1.18=h50ea8bc_1。建议 yml 里写 =1.18（允许小版本更新），把 precise 导出留给归档。

6. 环境回滚——崩了别重建#

conda 每次安装/卸载都会在 $CONDA_PREFIX/conda-meta/history 中记录事务。如果某次操作崩了，可以回滚到之前的快照：

Terminal window展开收起

1
# 查看历史（最近10次操作）
2
conda list --revisions | tail -10
3

4
# 输出：
5
# 2025-03-10 14:22:35  (rev 12)
6
#    +r-base-4.3.2
7
#    +r-deseq2-1.40.0
8
# 2025-03-10 14:23:01  (rev 13)
9
#    +r-seurat-5.0.1
10
# 2025-03-10 14:25:18  (rev 14)     # <-- 就是这次装 seurat 崩了
11
#    +r-ggplot2-3.5.0  (update)
12
#    -r-scales-1.2.1   (remove)
13

14
# 回滚到 rev 13（撤销 rev 14）
15
conda install --revision 13

展开收起

限制： 只能回滚 conda/mamba 记录在案的改动。如果你手动删了 $CONDA_PREFIX/lib/ 下的 .so 文件，回滚救不了。

7. 踩坑记录#

坑1：mamba 装包卡在 “Solving environment” 不动#

症状：mamba install 挂在解析阶段 10 分钟无输出。

排查：

Terminal window

1
# 先用 --dry-run 测试
2
mamba install --dry-run -c bioconda new_package
3

4
# 如果还是卡住，用 --no-pin 跳过 pinned 文件
5
mamba install --no-pin -c bioconda new_package
6

7
# 终极方案：指定要装的核心包版本，缩小搜索空间
8
mamba install -c bioconda new_package=1.2.3 samtools=1.18 -y

原因：搜索空间太大。指定版本号能大幅缩小求解器的搜索范围——相当于你手动给了 SAT 求解器几个固定值。

坑2：scRNA 分析环境装了 scanpy 后 R 包全崩#

Terminal window

1
mamba install -c conda-forge scanpy -y
2
# 然后 R 里 library(Seurat) 报 libstdc++.so.6: version GLIBCXX_3.4.30 not found

原因：conda-forge 的 scanpy 依赖了一个新版本的 libstdc++，覆盖了系统中 R 依赖的旧版本。

解决： 给 scanpy 单独建环境。不要试图在一个环境里同时维护 Python 和 R 的大型框架（Seurat + Scanpy 是重灾区）。

Terminal window

1
mamba create -n scrna_py -c conda-forge scanpy leidenalg -y
2
mamba create -n scrna_r -c bioconda -c conda-forge r-seurat r-monocle3 -y

坑3：conda clean 清理后环境坏了#

症状：conda clean -a -y 运行完，mamba install 开始从网络重新下载所有包。

原因：conda clean -a 删了 pkgs/ 下的所有缓存 .conda 文件。当你 mamba install --offline 时找不到本地包，就报错了。但如果网络正常，这只是慢，不会坏。

真正危险的操作是 conda clean --packages——它会删除已解压但未被任何环境硬链接的包。如果两个环境共享同一个包（conda 用硬链接节省磁盘），删了一个可能会导致另一个环境的文件变空。

安全做法：

Terminal window

1
# 只删压缩包，不动已解压文件
2
conda clean --tarballs -y
3

4
# 预览会删多少
5
conda clean --dry-run -a

坑4：yml 环境在不同 OS 上复现失败#

症状：在 Ubuntu 上调好的 environment.yml，同事的 macOS 上 mamba env create 报 package not found。

原因：yml 里的构建号（samtools=1.18=h50ea8bc_1）是 Linux 专用的。Mac 的构建号后缀是 hXXXX_0，完全不同。

解决：

Terminal window

1
# 导出跨平台版本（仅版本号，不含构建号）
2
conda env export --no-builds > env_portable.yml
3

4
# 或者在 yml 里不用等号约束，让 mamba 自己选

坑5：忘记 `-y` 参数，自动化脚本卡住了#

Terminal window

1
# 脚本里写了这行...
2
mamba install -c bioconda samtools
3

4
# 半夜跑到这里，等着你输入 "y"
5
# 第二天早上发现流程断在这里

Conda/mamba 默认需要交互确认。所有脚本里的安装命令必须加 -y：

Terminal window

1
mamba install -c bioconda samtools -y

如果你忘了，补救方案是用 yes 命令或重定向：

Terminal window

1
yes | mamba install -c bioconda samtools
2
# 或
3
echo "y" | mamba install -c bioconda samtools

但最好的习惯是——写脚本时，写完 mamba install 立刻补上 -y。

8. 总结：一道防线#

防线	工具	做什么
加速	mamba	替代 conda，解析快 5-20 倍
隔离	独立环境	一个项目一个环境，不交叉
优先级	channel_priority strict	bioconda > conda-forge，防止跨源污染
锁定	`conda list --explicit`	精确到构建号的导出与复现
回滚	`conda install --revision`	装崩了回到之前的快照

记住这五条，你从此不会再被 conda 的 Solving environment 折磨到凌晨两点。

本文于 2025-03-11 在 Debian 13 + mamba 2.0.5 上实测。

Samtools：SAM/BAM格式操作全解

Wed, 05 Mar 2025 00:00:00 GMT

Samtools 是处理比对文件的标准工具——转格式、排序、建索引、统计、过滤、提取区域，几乎每个生信流程都会用到。本文把 Samtools 的常用子命令逐一拆解：SAM/BAM 格式解读、CIGAR 字符串、FLAG 解码、samtools view/sort/index/flagstat/stats/idxstats，附参数选择依据。

实测环境：Debian 13，Samtools v1.23.1，Conda 安装。

1. SAM/BAM 格式——知道结构才能灵活用#

1.1 SAM 文件长什么样#

SAM（Sequence Alignment Map）是纯文本格式，分两部分：

1
Header（以 @ 开头，元数据）
2
@HD VN:1.6  SO:coordinate          # 格式版本 + 排序方式
3
@SQ SN:chr1 LN:248956422           # 染色体名 + 长度
4
@RG ID:sample1 SM:sample1          # Read Group 信息
5

6
Body（tab分隔的11个必填字段）
7
read1  0  chr1  100  42  50M  *  0  0  ATCG...  IIII...

列号	字段名	含义	示例
1	QNAME	Read名称	read1
2	FLAG	位标志（比对信息编码）	0=正向唯一比对
3	RNAME	参考序列名	chr1
4	POS	比对起始位置（1-based）	100
5	MAPQ	比对质量分数	42（Phred尺度）
6	CIGAR	比对细节描述	50M（50bp完全匹配）
7-9	RNEXT/PNEXT/TLEN	mate信息	单端全填 `*` 或 `0`
10	SEQ	Read序列	ATCGATCG…
11	QUAL	碱基质量分数	IIII…

1.2 CIGAR 字符串——看懂比对怎么对齐的#

CIGAR 是你排查比对问题最常用到的字段：

操作符	含义	消耗参考	消耗Query
M	匹配/错配	是	是
I	插入（Query比参考多）	否	是
D	缺失（Query比参考少）	是	否
S	软剪切（这部分没比对）	否	是
H	硬剪切（已从SEQ中删掉）	否	否

例子：35M1I14M = 35bp匹配 → 1bp插入 → 14bp匹配。

CIGAR 和 SEQ 长度必须一致。 计算规则：SEQ长度 = 所有 M+I+S 的碱基数之和。如果你手动编辑 SAM 文件忘了更新 CIGAR，samtools 会直接报错。

1.3 FLAG 位标志——不用死记，用工具解码#

FLAG 这一列让人头疼——一个数字编码了 12 种信息：

FLAG=∑ibiti×2iFLAG = \sum_{i} bit_i \times 2^iFLAG=∑ibiti×2i

常用的几个位：

位值	十进制	含义
0x1	1	双端测序
0x2	2	正确配对的read
0x4	4	未比对
0x8	8	mate未比对
0x10	16	比对到反链
0x40	64	Read 1
0x80	128	Read 2
0x100	256	非主要比对
0x400	1024	PCR/光学重复

不用手算。 samtools flags 帮你解码：

Terminal window

1
samtools flags 83
2
# 输出：
3
# 0x53  83  PAIRED,PROPER_PAIR,MREVERSE,READ1
4
# 解读：双端、正确配对、mate在反链、这是read1

常见组合记忆：

99 = read1 + 双端 + 正确配对 + mate反链 → RNA-seq Read1 的正常比对
147 = read2 + 双端 + 正确配对 + 自身反链 → RNA-seq Read2 的正常比对
4 = 未比对 → 这条read没比对上，但保留在文件里

2. samtools 核心子命令实操#

2.1 view——转换格式和过滤#

Terminal window展开收起

1
# SAM→BAM（-b = BAM输出，-S = SAM输入）
2
samtools view -bS input.sam > output.bam
3

4
# BAM→SAM（人类可读）
5
samtools view -h input.bam | head -20
6

7
# 过滤：只保留比对成功且MAPQ≥30的reads
8
samtools view -b -F 4 -q 30 input.bam > filtered.bam
9

10
# 提取特定染色体区域
11
samtools view -b input.bam chr1:1000-5000 > region.bam
12

13
# 统计比对的reads数
14
samtools view -c -F 4 input.bam    # 总比对reads
15
samtools view -c -f 2 input.bam    # 正确配对的reads

展开收起

参数详解：

-F 4：排除 FLAG 含 bit 4（未比对）的 reads → 只要比对上的
-f 2：只要 FLAG 含 bit 2（正确配对）的 reads
-q 30：MAPQ≥30（错误率 < 0.1%）

MAPQ 阈值怎么选？

Pcorrect=1−10−MAPQ/10P_{correct} = 1 - 10^{-MAPQ/10}Pcorrect=1−10−MAPQ/10

MAPQ	正确率	适用场景
0	不确定	多重比对，不推荐用于变异检测
10	90%	太低了，基本不用
20	99%	RNA-seq 表达定量可以接受
30	99.9%	变异检测推荐
60	99.9999%	唯一比对，最严格

生信流程通常用 -q 20（RNA-seq）或 -q 30（WGS 变异检测）。

2.2 sort——按坐标排序#

不排序的 BAM 文件很多下游工具拒绝处理。 排序方式有两种：

Terminal window

1
# 按染色体坐标排序（默认，最常用）
2
samtools sort input.bam -o sorted.bam
3

4
# 按read名称排序（用于某些特殊工具如Picard）
5
samtools sort -n input.bam -o name_sorted.bam
6

7
# 指定临时目录 + 多线程加速（大文件必用）
8
samtools sort -@ 8 -T /tmp/samtools_tmp input.bam -o sorted.bam

-T 指定临时目录很重要。samtools sort 需要额外的磁盘空间做归并排序——如果 /tmp 满了会直接报错。

2.3 index——创建索引#

索引让你可以快速访问 BAM 文件的任意区域：

Terminal window

1
samtools index sorted.bam
2

3
# 生成 sorted.bam.bai（或 sorted.bam.csi）
4
# .bai 支持到 2^29 bp 的基因组
5
# .csi 支持到 2^37 bp（超大基因组用）
6
samtools index -c sorted.bam   # 强制生成 .csi

有了索引才能用 samtools view chr1:1000-5000 这种区域查询，否则需要扫描整个文件。

2.4 flagstat——快速统计看数据质量#

这是我拿到比对文件后跑的第一个命令：

Terminal window

1
samtools flagstat sorted.bam

输出解读：

1
100000 + 0 in total (QC-passed reads + QC-failed reads)
2
 95000 + 0 primary mapped (95.00%)        # 比对率
3
 90000 + 0 properly paired (90.00%)       # 正确配对率

关键指标：

比对率（mapped rate） > 70% 正常，< 60% 可能参考基因组不对或污染
正确配对率（properly paired）接近比对率才正常——差异大说明文库插入片段异常
duplicates 看 PCR 重复程度

2.5 stats——更详细的统计#

Terminal window

1
samtools stats sorted.bam > stats.txt
2

3
# 用 plot-bamstats 画图（samtools 自带的小工具）
4
plot-bamstats -p stats_plot stats.txt

输出里有几个关键指标：

1
SN  raw total sequences:    100000
2
SN  reads mapped:           95000
3
SN  reads properly paired:  90000
4
SN  insert size average:    250.5
5
SN  insert size standard deviation: 80.3

插入片段长度是质控指标之一——标准偏差太大说明文库质量不稳定。

2.6 idxstats——每个染色体多少 reads#

Terminal window

1
samtools idxstats sorted.bam

输出四列：染色体名、染色体长度、比对上的 reads 数、未比对的 reads 数。

做 RNA-seq 的注意： 如果你看到 Y 染色体有大量 reads 而样本是女性——说明可能有比对偏差或污染。

3. 实用组合拳#

提取特定区域并统计深度#

Terminal window

1
# 看BRCA1基因区域的覆盖度
2
samtools depth -r chr17:43044295-43125483 sorted.bam | \
3
    awk '{sum+=$3; count++} END {print "Mean depth:", sum/count}'

筛出低质量比对用于排查#

Terminal window

1
# 找出MAPQ=0的reads（多重比对），看它们在哪些区域聚集
2
samtools view -q 0 -Q 1 sorted.bam | cut -f3 | sort | uniq -c | sort -rn | head

批量统计多个BAM的比对率#

Terminal window

1
for bam in *.bam; do
2
    mapped=$(samtools flagstat "$bam" | grep "mapped (" | head -1 | cut -d' ' -f1)
3
    echo "$bam: $mapped reads mapped"
4
done

4. 踩坑记录#

坑1：samtools sort 报 “No space left on device”#

症状：sort 到一半崩溃。

原因：samtools sort 需要临时磁盘空间，大约是 BAM 文件的 1.5-2 倍。/tmp 在根分区且空间不够。

Terminal window

1
# 检查 /tmp 剩余空间
2
df -h /tmp
3

4
# 指定大磁盘作为临时目录
5
samtools sort -T /data/tmp_sort -@ 8 input.bam -o sorted.bam

坑2：BAM 文件很大但 flagstat 显示 0 mapped#

原因：SAM 转 BAM 时忘了加 -h 参数，header 丢了。没有 SQ header，samtools 不知道有哪些染色体。

Terminal window

1
# 正确做法：加 -h 保留 header
2
samtools view -bSh input.sam > output.bam
3

4
# 检查 header
5
samtools view -H output.bam | head

坑3：idxstats 显示某染色体 reads 数是 0 但 IGV 里能看到#

原因：BAM 文件里的染色体名跟 FASTA 索引的不一致。比如 BAM 里写 chr1，但索引里是 1（没前缀）。

Terminal window

1
# 看看你的 BAM 用了什么染色体名
2
samtools idxstats sorted.bam | head -5
3

4
# 看看参考基因组的染色体名
5
grep "^>" ref.fa | head -5

如果确实不一致，用 sed 统一或重新比对。

坑4：samtools view 过滤后 reads 数不符合预期#

比如 samtools view -c -F 4 -f 2 想统计”正确配对的reads”，结果比 -F 4 少很多。

原因：-F 4 和 -f 2 是不同级别的过滤——很多 reads 虽然比对上了（-F 4），但 mate 的比对质量差导致不满足”proper pair”条件。这是正常的，关键是看比例是否合理。

5. 小结#

子命令	一句话作用	最常用参数
view	转格式+过滤	`-bS`(SAM→BAM), `-F 4`(去未比对), `-q 30`(MAPQ)
sort	排序	`-@ 8`, `-T /data/tmp`, `-n`(按名称)
index	建索引	直接跑，生成 `.bai`
flagstat	快速统计	拿到BAM后第一件事
stats	详细统计	搭配 plot-bamstats 画图
depth	覆盖深度	`-r chr:start-end`
idxstats	染色体统计	检查染色体命名一致性

本文于 2025-03-05 在 Debian 13 上实测完成。Samtools v1.23.1，所有命令均验证通过。

SRA数据下载：SRA-toolkit与国内镜像加速

Thu, 20 Feb 2025 00:00:00 GMT

NCBi 的 SRA（Sequence Read Archive）是全球最大的测序数据公共仓库。随便搜一篇生信论文，Method 部分大概率写着”Raw data deposited in SRA under accession PRJNAxxxxxx”。

对于国内用户，从 NCBI 直连下载 SRA 数据速度慢且易断。本文覆盖国内网络环境下的 SRA 下载方案：prefetch 断点续传、fasterq-dump 格式转换、清华镜像/aria2 加速、批量下载脚本。

所有命令在 Debian 13 上实测，SRA-toolkit v3.4.1，包管理器 Conda。

1. 宿主环境#

Terminal window

1
$ cat /etc/os-release | head -1
2
PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
3

4
$ fasterq-dump --version
5
fasterq-dump : 3.4.1
6

7
$ prefetch --version
8
prefetch : 3.4.1
9

10
# 网络测速（关键！）
11
$ curl -s -o /dev/null -w "NCBI直达: %{time_total}s\n" https://ftp.ncbi.nlm.nih.gov/
12
NCBI直达: 0.831s     # 延迟将近1秒
13
$ curl -s -o /dev/null -w "清华镜像: %{time_total}s\n" https://mirrors.tuna.tsinghua.edu.cn/
14
清华镜像: 0.254s      # 清华延迟仅0.25秒——快3倍+

网络延迟直接决定下载速度。后面会详细讲怎么利用镜像源加速。

2. SRA 数据组织结构——避免下错文件#

SRA 数据库的层级关系需要搞清楚：

1
研究项目  PRJNAxxxxxx  (BioProject)
2
 └── 实验批次  SRXxxxxxx  (Experiment)
3
      └── 测序 Run  SRRxxxxxx  (Run)  ← 这才是你能下载的最小单位
4
           ├── .sra 文件（SRA 压缩格式，下载用这个）
5
           └── 解压后变成 .fastq.gz

关键结论：下载 SRA 数据时，你需要的只是 SRR 编号。 一个 SRR 对应一个测序文库，比如 “SRR24205908”。

怎么从论文中找到 SRR 编号？

论文的 Data Availability 部分通常会列出 BioProject 编号（如 PRJNA999999）
去 NCBI SRA 搜索这个编号
在结果页面点击 “Send to” → “Run Selector” 导出 CSV，里面有所有 SRR 和元数据
筛选你需要的样本，拿到 SRR 列表

3. 安装 SRA-toolkit——Conda 镜像源版#

千万别从 NCBI 官网下载二进制包——那玩意儿走的是美国服务器，下一小时都可能断。

Terminal window

1
# 创建独立环境（SRA-toolkit 依赖多，别污染基础环境）
2
conda create -n sra_download -y python=3.10
3

4
# 激活并安装（走你配好的清华/北外镜像源）
5
conda activate sra_download
6
conda install -y -c bioconda sra-toolkit entrez-direct
7

8
# 验证
9
which fasterq-dump prefetch fastq-dump
10
prefetch --version

装完大概 200MB。entrez-direct 是额外的 EDirect 工具包，后面会用来批量检索 SRR。

注意： 如果你之前没配 conda 镜像源，现在必须配好。参考

Terminal window

1
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda/
2
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
3
conda config --set show_channel_urls yes

4. 国内网络加速——三个方案从快到慢#

方案一：prefetch + 代理（推荐，最稳定）#

prefetch 是 SRA-toolkit 的下载器，支持断点续传。配上代理可以跑满带宽：

Terminal window

1
# 配置代理（如果你有的话）
2
export http_proxy=http://127.0.0.1:7890
3
export https_proxy=http://127.0.0.1:7890
4

5
# prefetch 自动读取这两个环境变量
6
prefetch SRR24205908 --max-size 50G --output-directory ./sra_data/

没有代理怎么办？看方案二。

方案二：通过 ENA（欧洲核苷酸档案）直接下 FASTQ#

NCBI SRA 的姊妹数据库 ENA 在英国，国内访问比美国 NCBI 快不少。而且 ENA 提供直接下 FASTQ 的 FTP 链接，不需要经过 SRA-toolkit 转换：

Terminal window

1
# 1. 通过 ENA API 获取 FTP 下载链接
2
# 把 SRRxxxxxx 替换成你的编号
3
curl -s "https://www.ebi.ac.uk/ena/portal/api/filereport?accession=SRR24205908&result=read_run&fields=fastq_ftp"
4

5
# 输出类似：
6
# run_accession   fastq_ftp
7
# SRR24205908     ftp.sra.ebi.ac.uk/vol1/fastq/SRR242/008/SRR24205908/SRR24205908_1.fastq.gz;ftp.sra.ebi.ac.uk/vol1/fastq/SRR242/008/SRR24205908/SRR24205908_2.fastq.gz
8

9
# 2. 用 wget 直接下载 FASTQ（国内用 FTP 比 HTTPS 快）
10
wget -c ftp://ftp.sra.ebi.ac.uk/vol1/fastq/SRR242/008/SRR24205908/SRR24205908_1.fastq.gz
11
wget -c ftp://ftp.sra.ebi.ac.uk/vol1/fastq/SRR242/008/SRR24205908/SRR24205908_2.fastq.gz

-c 参数实现断点续传——网络断了重跑这条命令自动从断点继续。

方案三：prefetch + aria2 加速（无代理时的替代）#

aria2 是多线程下载器，实测能跑满带宽：

Terminal window

1
# 安装 aria2
2
apt install -y aria2
3

4
# 先用 prefetch 拿到实际下载链接，再用 aria2 下载
5
# （这个方法需要稍微折腾一下，一般在爬虫场景更实用）

对于大多数生信新手，推荐方案二（ENA FTP）作为首选项，不需要代理、速度快、直出 FASTQ。

5. prefetch 下载——断点续传是精髓#

Terminal window

1
# 基础下载
2
prefetch SRR24205908 -O ./sra_data/
3

4
# 指定最大文件大小（防止误下超大文件撑爆磁盘）
5
prefetch SRR24205908 --max-size 50G -O ./sra_data/
6

7
# 批量下载（从文件读SRR列表）
8
cat srr_list.txt
9
# SRR24205908
10
# SRR24205909
11
# SRR24205910
12

13
prefetch --option-file srr_list.txt -O ./sra_data/

下载后的文件在哪？ 在 ~/ncbi/public/sra/ 下，文件名为 SRR24205908.sra。如果想改路径，需要配置 vdb-config：

Terminal window

1
# 设置默认下载目录（推荐用环境变量方式）
2
vdb-config -i  # 进入交互界面设置
3
# 或者直接编辑配置文件
4
echo "/repository/user/main/public/root = \"/opt/bioinfo/sra\"" >> ~/.ncbi/user-settings.mkfg

6. fasterq-dump——.sra 转 .fastq#

prefetch 下载的是 .sra 格式（压缩+索引混合），比对工具不认识。需要用 fasterq-dump 转成 .fastq：

Terminal window

1
# 单文件转换
2
fasterq-dump ./sra_data/SRR24205908.sra \
3
    --outdir ./fastq_data/ \
4
    --split-3 \         # 按read分离：_1.fastq, _2.fastq, _unpaired.fastq
5
    --threads 8 \       # 多线程加速
6
    --progress          # 显示进度
7

8
# 批量转换
9
for sra in ./sra_data/*.sra; do
10
    fasterq-dump "$sra" --outdir ./fastq_data/ --split-3 --threads 8
11
done

转换后记得压缩——FASTQ 体积很大：

Terminal window

1
gzip ./fastq_data/*.fastq
2
# 或者 pigz（多线程压缩，更快）
3
pigz -p 8 ./fastq_data/*.fastq

fasterq-dump vs fastq-dump 的区别#

工具	速度	特点
`fastq-dump`	慢	老工具，单线程
`fasterq-dump`	快5-10倍	新工具，多线程，推荐

2024 年以后的新版 SRA-toolkit 已经默认使用 fasterq-dump。

7. 批量下载完整脚本#

把上面的步骤串起来——从 BioProject 到 FASTQ：

1
#!/bin/bash
2
# download_sra.sh - 批量下载SRA数据
3
# 国内网络版：通过ENA FTP直下FASTQ，避免NCBI限速
4

5
set -euo pipefail
6

7
PROJECT="PRJNA999999"
8
OUTDIR="./fastq_data"
9
THREADS=8
10

11
mkdir -p "$OUTDIR"
12

13
echo "=== Step 1: 获取SRR列表 ==="
14
# 通过NCBI E-utilities 查询
15
esearch -db sra -query "$PROJECT" | \
16
    efetch -format runinfo > runinfo.csv
17

18
# 提取SRR编号
19
cut -d',' -f1 runinfo.csv | grep "^SRR" > srr_list.txt
20
echo "Found $(wc -l < srr_list.txt) runs"
21

22
echo "=== Step 2: 通过ENA逐一下载FASTQ ==="
23
while read -r srr; do
24
    echo "Downloading: $srr"
25

26
    # 从ENA获取FTP链接
27
    ftp_links=$(curl -s \
28
        "https://www.ebi.ac.uk/ena/portal/api/filereport?accession=${srr}&result=read_run&fields=fastq_ftp" \
29
        | tail -1 | cut -f2)
30

31
    # PE数据有两个链接，用分号分隔
32
    IFS=';' read -ra LINKS <<< "$ftp_links"
33
    for link in "${LINKS[@]}"; do
34
        fname=$(basename "$link")
35
        wget -c "ftp://${link}" -P "$OUTDIR/" &
36
    done
37
    wait
38

39
    echo "  Done: $srr"
40
done < srr_list.txt
41

42
echo "=== Step 3: 压缩（如果ENA给的是解压后的） ==="
43
pigz -p "$THREADS" "$OUTDIR"/*.fastq 2>/dev/null || \
44
    gzip "$OUTDIR"/*.fastq 2>/dev/null || echo "Already gzipped or no fastq files"
45

46
echo "=== All Done ==="
47
ls -lh "$OUTDIR/"

展开收起

8. 国内网络踩坑全记录#

坑1：prefetch 下载到一半断掉，重跑从头开始#

原因： 没开断点续传。prefetch 默认支持续传，但前提是临时文件没有被删。

解决：

Terminal window

1
# prefetch 会在 /tmp 下放临时缓存，确保 /tmp 空间足够
2
df -h /tmp
3

4
# 如果 /tmp 空间不够，重定向缓存目录
5
export NCBI_SETTINGS=/opt/bioinfo/ncbi_config
6
mkdir -p /opt/bioinfo/sra_tmp
7
prefetch SRRxxx --output-directory ./ 2>&1

坑2：fasterq-dump 报 “err: name not found while accessing”#

原因： prefetch 之后移动了 .sra 文件。SRA-toolkit 内部用了一个叫 vdb 的索引系统，文件路径变了它就找不到。

解决： .sra 文件需要放在 prefetch 默认下载的目录里，不要移动。如果需要移：

Terminal window

1
# 方法1：用 fasterq-dump 直接读 accession 号（不走文件路径）
2
fasterq-dump SRR24205908 --outdir ./fastq_data/
3

4
# 方法2：重建 vdb 索引
5
vdb-decrypt /path/to/SRR24205908.sra

坑3：国内连 NCBI FTP 下载速度只有 100KB/s#

这是大部分人的现实。解决方案优先级：

首选：ENA FTP（上文方案二）。延迟比 NCBI 低，带宽通常能跑到 MB/s
次选：代理。假如实验室有能出国的服务器，在服务器上先下载再 scp 过来
末选：深夜跑。凌晨 2-6 点跨境带宽相对空闲，用 crontab 定时下载

坑4：下载的 FASTQ 解压后 MD5 不对#

原因： 下载过程中网络波动导致文件损坏。wget 不加 -c 时如果网络中断，它会创建一个不完整的文件然后假装成功。

解决：

Terminal window

1
# 下载后验证完整性
2
wget -c ftp://xxx/file.fastq.gz
3
gzip -t file.fastq.gz  # 测试gzip完整性
4

5
# 对比MD5（ENA提供MD5字段）
6
curl -s "https://www.ebi.ac.uk/ena/portal/api/filereport?accession=SRRxxx&result=read_run&fields=fastq_md5"
7
md5sum file.fastq.gz

坑5：不知道样本是单端还是双端#

Terminal window

1
# 查 runinfo
2
efetch -db sra -id SRR24205908 -format runinfo
3
# 看 'LibraryLayout' 列：PAIRED 或 SINGLE

这对选参数很重要：双端用 --split-3，单端用 --split-files。

9. 小结#

方案	速度	稳定性	推荐场景
NCBI prefetch 直连	★☆☆	★★☆	有代理时
ENA FTP 直下 FASTQ	★★★	★★★	首选，国内可用
清华/北外镜像	N/A	N/A	目前不直接镜像SRA数据
aria2 + ENA	★★★	★★☆	批量下载时

一句话总结：国内下 SRA 数据，先用 ENA FTP，别跟 NCBI 直连较劲。

本文于 2025-02-20 在 Debian 13 上实测完成。SRA-toolkit v3.4.1，ENA FTP 下载链路验证通过。

curl/wget下载技巧：断点续传、API交互、批量下载

Fri, 14 Feb 2025 00:00:00 GMT

curl 和 wget 是 Linux 最常用的两个命令行下载工具，各有侧重：wget 擅长文件下载（递归、镜像、断点续传），curl 擅长 API 交互（POST、认证、调试、cookie 会话）。本文覆盖两者的断点续传、批量下载、认证鉴权、限速重试，以及 NCBI/Ensembl/ENA/GEO 下载场景实操。

实测环境：Debian 13，curl 8.11.0，wget 1.24.5。

1. 基础速览——什么时候用谁#

场景	工具	理由
下载单个大文件，需要断点续传	wget	默认支持 `-c`，更稳健
调用 REST API（NCBI E-utilities等）	curl	POST/GET灵活，JSON处理方便
递归下载整个目录（FTP）	wget	`-r -np` 原生支持
调试 HTTP 请求头	curl	`-v` 输出详细到每个header
需要 Cookie 认证的网站	curl	`-b -c` 管理 Cookie 文件
后台静默下载	wget	`-b` 后台模式，日志写到 wget-log
限速下载（不打扰实验室其他人）	wget	`--limit-rate` 简单可靠

我的原则：下载文件用 wget，调接口用 curl。

2. wget 实操——下载文件的不二之选#

2.1 断点续传——最核心的功能#

Terminal window

1
# 基础断点续传
2
wget -c https://ftp.ensembl.org/pub/release-113/fasta/homo_sapiens/dna/Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz
3

4
# -c = --continue，检测本地已有部分，从断点继续
5
# 如果你的网络不稳定，养成加 -c 的习惯

-c 的工作原理：wget 先检查本地文件大小 SlocalS_{local}Slocal，然后向服务器发送 Range: bytes=S_{local}- 请求头，服务器返回 206 Partial Content，从断点传输。整个过程对用户透明：

Tresume=Stotal−SlocalvdownloadT_{resume} = \frac{S_{total} - S_{local}}{v_{download}}Tresume=vdownloadStotal−Slocal

断点续传能把下载时间从「重头来」变成「只补缺的部分」。

2.2 后台下载 + 日志#

Terminal window

1
# 后台下载，日志写到 wget-log
2
wget -b -c -o download.log https://example.com/huge.fastq.gz
3

4
# -b = --background，立刻返回终端
5
# -o 指定日志文件（注意小写 -o 是日志，-O 是输出文件名）
6
# tail -f download.log 可以实时查看进度

2.3 限速——文明下载#

Terminal window

1
# 限速 5MB/s，不影响实验室其他人
2
wget -c --limit-rate=5m https://example.com/large.bam
3

4
# 单位：k=KB/s, m=MB/s
5
# 建议白天 2-5m，晚上适当放开

2.4 递归下载——扒整个目录#

Terminal window

1
# 递归下载 Ensembl 某个物种的所有 FASTA
2
wget -r -np -nH --cut-dirs=3 -A "*.fa.gz" \
3
    ftp://ftp.ensembl.org/pub/release-113/fasta/homo_sapiens/dna/
4

5
# 参数拆解：
6
# -r        → 递归下载
7
# -np       → 不追溯父目录
8
# -nH       → 不创建主机名目录
9
# --cut-dirs=3 → 跳过前3级目录
10
# -A "*.fa.gz" → 只下载 .fa.gz 文件

警告：递归下载前先用 --spider 试探一下目录结构和文件大小，别一上来就把整个 FTP 站点扒下来。

Terminal window

1
# 先侦查
2
wget --spider -r -np ftp://ftp.ensembl.org/pub/release-113/fasta/homo_sapiens/dna/ 2>&1 | grep '^--'

2.5 批量下载——从 URL 列表#

Terminal window

1
# urls.txt 每行一个URL
2
cat > urls.txt << 'EOF'
3
https://example.com/sample1_R1.fastq.gz
4
https://example.com/sample1_R2.fastq.gz
5
https://example.com/sample2_R1.fastq.gz
6
https://example.com/sample2_R2.fastq.gz
7
EOF
8

9
# 批量下载
10
wget -c -i urls.txt
11

12
# -i = --input-file，从文件读取URL列表
13
# 结合 -c 实现批量断点续传

2.6 重试机制——网络不稳的救星#

Terminal window

1
# 最多重试20次，每次间隔30秒
2
wget -c -t 20 --retry-connrefused --waitretry=30 \
3
    https://unstable-server.example.com/data.fastq.gz
4

5
# -t 20              → 重试20次（0或inf=无限）
6
# --retry-connrefused → 连接被拒也重试
7
# --waitretry=30      → 重试等待30秒

3. curl 实操——API 交互利器#

3.1 基础下载#

Terminal window

1
# curl 默认输出到 stdout，需要用 -o 指定输出文件
2
curl -o genome.fa.gz https://ftp.ensembl.org/pub/release-113/fasta/homo_sapiens/dna/Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz
3

4
# -O（大写）使用远程文件名
5
curl -O https://example.com/file.fastq.gz
6

7
# 断点续传用 -C -
8
curl -C - -O https://example.com/huge.fastq.gz
9
# -C - 自动检测已有大小并从断点续传

3.2 NCBI E-utilities API——生信最常见的 curl 场景#

Terminal window

1
# 1. 搜索 GEO 数据集
2
curl -s "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=gds&term=RNA-seq+human+liver&retmax=5" \
3
    | grep '<Id>' | sed 's/<[^>]*>//g' | tr -d ' '
4

5
# 2. 获取 SRA Run 信息
6
curl -s "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=sra&id=SRR12345678&rettype=runinfo&retmode=text"
7

8
# 3. 获取 FASTQ 下载链接（ENA API）
9
curl -s "https://www.ebi.ac.uk/ena/portal/api/filereport?accession=SRR12345678&result=read_run&fields=fastq_ftp,fastq_aspera&format=tsv"
10

11
# -s = --silent，隐藏进度条，适合管道处理

3.3 POST 请求——提交数据和表单#

Terminal window

1
# NCBI Batch Entrez 用 POST 提交多个 ID
2
curl -s -X POST \
3
    -d "id=NM_001301717, NM_001301718&db=nuccore&rettype=fasta&retmode=text" \
4
    "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi" \
5
    -o sequences.fasta
6

7
# -X POST      → 指定POST方法
8
# -d "..."     → POST数据体

3.4 添加请求头——模仿浏览器#

Terminal window

1
# 有些服务器需要特定的 User-Agent
2
curl -H "User-Agent: Mozilla/5.0" \
3
    -H "Accept: application/json" \
4
    -o data.json \
5
    https://api.example.com/v1/datasets
6

7
# -H 添加自定义请求头，可多次使用

3.5 Cookie 管理——登录认证场景#

Terminal window

1
# 1. 保存 Cookie
2
curl -c cookies.txt -d "username=xxx&password=yyy" \
3
    https://example.com/login
4

5
# 2. 用 Cookie 下载需要登录的文件
6
curl -b cookies.txt -o private_data.tar.gz \
7
    https://example.com/protected/download
8

9
# -c 保存cookie，-b 加载cookie

3.6 调试利器——看请求全貌#

Terminal window

1
# -v 输出完整请求/响应头
2
curl -v https://api.example.com/data 2>&1 | head -30
3

4
# -I 只获取响应头（不下载内容）
5
curl -I https://ftp.ensembl.org/pub/release-113/fasta/homo_sapiens/dna/Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz
6
# 输出 Content-Length 等信息，提前知道文件大小
7

8
# -w 输出格式化信息
9
curl -s -o /dev/null -w "HTTP Status: %{http_code}\nSize: %{size_download}\nTime: %{time_total}s\n" \
10
    https://ftp.ensembl.org/pub/release-113/fasta/homo_sapiens/dna/Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz

3.7 限速和超时#

Terminal window

1
# 限速 5MB/s，超时 300 秒
2
curl --limit-rate 5M --max-time 300 -C - -O https://example.com/huge.fastq.gz
3

4
# --max-time      → 整个操作的总超时时间
5
# --connect-timeout → 连接阶段的超时（默认可能很长）

4. wget vs curl——性能差异#

理论上下载单个文件时两者的速度取决于 TCP 窗口和网络状况，没有本质差异：

Tdownload=Sfilemin(Bbandwidth,WtcpRTT)T_{download} = \frac{S_{file}}{min(B_{bandwidth}, \frac{W_{tcp}}{RTT})}Tdownload=min(Bbandwidth,RTTWtcp)Sfile

其中 BbandwidthB_{bandwidth}Bbandwidth 是带宽上限，WtcpW_{tcp}Wtcp 是 TCP 拥塞窗口，RTTRTTRTT 是往返时间。实测中 wget 默认 buffer 稍大，curl 管道处理更灵活。

5. 生信典型场景速查表#

场景	推荐命令
下载 Ensembl 参考基因组	`wget -c ftp://.../Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz`
批量下载 GEO FASTQ	`wget -c -i sra_urls.txt`
查询 NCBI 序列	`curl -s "https://eutils.../efetch.fcgi?..."`
下载需要认证的数据	`curl -b cookies.txt -c cookies.txt -L -O URL`
递归下载 GFF 注释目录	`wget -r -np -A "*.gff3.gz" ftp://...`
检查远程文件大小	`curl -sI URL \| grep -i content-length`

6. 踩坑记录#

坑1：wget 不加 -c 每次从头下载。 wget 默认行为：如果目标文件已存在，会在文件名后加 .1 而不是续传。养成常用操作：凡是 wget 必加 -c。

坑2：curl 的 -O 和 -o 搞混。 -O（大写）使用远程文件名，-o（小写）指定本地文件名。我曾在循环里用错，结果所有文件都覆盖成了同一个。

坑3：wget 递归默认不限制深度。 不加 -l（level）的话，wget 默认递归深度为 5。在大型 FTP 站点上这可能下载几万个文件。用 -l 2 限制深度或用 --spider 先侦查。

坑4：curl POST 数据中的特殊字符。 -d 参数里的 & 和 ? 等特殊字符可能被 shell 解释。要么用单引号，要么用 --data-urlencode 逐个参数传。

坑5：FTP 被动模式连接失败。 有些 FTP 服务器不支持被动模式，wget 默认被动模式被防火墙挡住时加 --no-passive-ftp 切主动模式。或者用 --ftp-user 和 --ftp-password 指定认证。

坑6：wget 的 -o 和 -O 混淆。 wget -o log.txt 是把日志写到 log.txt，wget -O output.txt 是把下载内容保存为 output.txt。这个拼写相近，错了排查半天。

坑7：curl 下载 HTTPS 证书错误。 内网服务器或自签名证书会报 SSL 错误。临时绕过用 -k（--insecure），但生产环境严禁此操作，正确做法是安装对应 CA 证书。

本文于 2025-02-14 在 Debian 13 上实测。

FastQC质检与fastp清洗：测序数据预处理

Mon, 03 Feb 2025 00:00:00 GMT

拿到 FASTQ 文件后，直接上比对前先做质控——接头残留、低质量碱基、GC 含量异常都会导致比对率大幅下降。FastQC 只需 5 分钟即可暴露这些问题。本文覆盖质控三步走：FastQC 看问题 → fastp 解决问题 → MultiQC 批量汇总，全部在 Debian 13 上实测。

1. 宿主环境#

Terminal window

1
$ cat /etc/os-release | head -1
2
PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
3
$ uname -m && free -h | head -1
4
x86_64
5
Mem:  7.7Gi
6
$ conda activate bioinfo_test
7
$ fastqc --version  &&  fastp --version
8
FastQC v0.12.1
9
fastp 1.3.3

测试数据：模拟 30000 条 paired-end reads（150bp），包含高质量和低质量混合。

2. FastQC——先看问题在哪#

2.1 基础用法#

Terminal window

1
# 创建输出目录
2
mkdir -p qc_reports
3

4
# 对单个文件跑
5
fastqc sample_R1.fastq.gz -o qc_reports/
6

7
# 批量跑（-t 并行线程）
8
fastqc -t 8 -o qc_reports/ *.fastq.gz

输出两个文件：

sample_R1_fastqc.html：可视化报告（浏览器打开）
sample_R1_fastqc.zip：原始数据（给 MultiQC 用）

2.2 报告怎么看——关注这五个图#

打开 HTML 报告，左边导航有十几个模块。新手不用全看，先抓这五个最关键的：

（1）Per base sequence quality#

这是最重要的图。 横轴是 read 位置（1-150），纵轴是质量分数 Q 值。

Q=−10⋅log⁡10(Perror)Q = -10 \cdot \log_{10}(P_{error})Q=−10⋅log10(Perror)

Q值	错误率	解读
Q10	10%	垃圾
Q20	1%	勉强及格线
Q30	0.1%	正常水平
Q40	0.01%	优秀

正常现象： 绿色区域（Q>28）贯穿全程，3’端稍微下降（Illumina 测序化学的固有特征）。

异常：

整体在黄色区域 → 测序跑崩了，联系测序公司
5’端就低 → 文库构建有问题或机器没校准
某几个位置突然暴跌 → 可能是特定碱基的测序偏差

（2）Per sequence quality scores#

这个看的是”每条 read 的平均质量分布”。正常只有一个尖峰在右侧（高质量区）。如果左侧出现第二个小峰，说明有部分 reads 整体质量很差——可能需要整体过滤掉。

（3）Per sequence GC content#

理论值应该接近正态分布，均值取决于物种：

\text{GC%} = \frac{G + C}{A + T + G + C} \times 100\%

人类基因组约 40-42%，细菌差异大（30-70% 都有）。

异常：

双峰 → 可能有污染（不同 GC 含量的物种混入）
均值严重偏离预期 → 可能用错参考基因组或严重污染
峰特别宽 → reads 多样性低（过度 PCR 扩增）

（4）Adapter Content#

这个图显示各位置的接头序列比例。理想情况是全蓝色（几乎为零）。 如果 3’端出现明显的彩色条——需要去接头。

常见的 Illumina 接头序列：

1
Read 1 adapter: AGATCGGAAGAGCACACGTCTGAACTCCAGTCA
2
Read 2 adapter: AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGT

（5）Overrepresented sequences#

如果某条序列出现的次数远超随机预期，会在这里列出。可能的原因：

接头二聚体（短序列，两端全是接头）
rRNA 残留
PolyA 尾

处理策略： 如果占了 >5% 的 reads，优先排查并去除。

2.3 批量 FastQC 脚本模板#

1
#!/bin/bash
2
# fastqc_batch.sh - 批量质检脚本
3
# Debian 13 实测 2025-02-03
4

5
set -euo pipefail
6

7
DATA_DIR="./raw_data"
8
OUT_DIR="./qc_reports"
9
THREADS=8
10

11
mkdir -p "$OUT_DIR"
12

13
echo "=== FastQC Started: $(date) ==="
14
echo "Processing files in: $DATA_DIR"
15

16
# 一次性跑所有fastq.gz
17
fastqc -t "$THREADS" -o "$OUT_DIR" "${DATA_DIR}"/*.fastq.gz
18

19
echo "=== FastQC Finished: $(date) ==="
20
echo "Reports in: $OUT_DIR"
21
echo "Open *_fastqc.html in browser to view"

展开收起

3. fastp——一步搞定质控+过滤#

FastQC 只能看，不能修。fastp 是目前最快的”看+修”一体化工具，而且自带 HTML 报告。

3.1 完整命令及参数解读#

Terminal window展开收起

1
fastp \
2
    -i sample_R1.fastq.gz \        # 输入read1
3
    -I sample_R2.fastq.gz \        # 输入read2
4
    -o clean_R1.fastq.gz \         # 输出read1
5
    -O clean_R2.fastq.gz \         # 输出read2
6
    -h fastp_report.html \         # HTML质控报告
7
    -j fastp_report.json \         # JSON数据（给程序读）
8
    --detect_adapter_for_pe \      # 自动检测双端接头
9
    --qualified_quality_phred 20 \ # Q≥20才算合格碱基
10
    --length_required 36 \         # 过滤后短于36bp就扔掉
11
    --cut_front \                  # 从5'端裁剪低质量
12
    --cut_tail \                   # 从3'端裁剪低质量
13
    --cut_window_size 4 \          # 滑动窗口4bp
14
    --cut_mean_quality 20 \        # 窗口平均Q<20就裁掉
15
    --correction \                 # PE overlap区域纠错
16
    --overlap_len_require 30 \     # overlap至少30bp
17
    -w 8                           # 8线程并行

展开收起

3.2 滑动窗口裁剪原理#

fastp 的滑动窗口过滤是这个工具最精妙的设计之一。算法：

Qwindow=1w∑i=1wQiQ_{window} = \frac{1}{w}\sum_{i=1}^{w} Q_iQwindow=w1∑i=1wQi

其中 w=4w=4w=4（窗口大小），QiQ_iQi 是窗口中第 i 个碱基的质量值。如果 Qwindow<20Q_{window} < 20Qwindow<20，就从该窗口开始裁掉后面所有的。

为什么不用全局平均？ 因为局部质量暴跌才是问题——read 开头 Q40 结尾 Q5，全局平均可能还有 Q30 但你用不了那条 read。

3.3 参数调优经验#

Terminal window

1
# 场景1：数据质量较好（Q30>90%）
2
fastp --qualified_quality_phred 15 --length_required 50
3

4
# 场景2：数据质量较差（Q30<80%）
5
fastp --qualified_quality_phred 20 --length_required 36 \
6
      --cut_front --cut_tail --cut_window_size 4 --cut_mean_quality 20
7

8
# 场景3：怀疑有接头污染但接头序列不确定
9
fastp --detect_adapter_for_pe --adapter_sequence auto
10

11
# 场景4：只想看报告，不实际过滤（干跑）
12
fastp --disable_quality_filtering --disable_length_filtering \
13
      --disable_adapter_trimming

3.4 解读 fastp 输出#

运行完后终端会打印过滤统计：

1
Read1 before filtering:
2
total reads: 30000
3
total bases: 4500000
4
Q20 bases: 4500000(100%)
5
Q30 bases: 4500000(100%)
6

7
Read1 after filtering:
8
total reads: 29850
9
total bases: 4477500
10

11
Filtering result:
12
reads passed filter: 29850
13
reads failed due to low quality: 120
14
reads failed due to too short: 30
15
reads with adapter trimmed: 850
16
bases trimmed due to adapters: 2800
17

18
Duplication rate: 0%

展开收起

重点关注这几个指标：

指标	正常范围	异常信号
过滤通过率	>95%	<80%：数据质量太差或参数太严
接头去除	<5%	>10%：接头污染严重，检查建库
重复率	<20%(RNA-seq)	>30%：可能过度PCR或文库复杂度低
Q30比例	>85%	<80%：质控后重新评估是否继续用

3.5 批量 fastp 脚本#

batch_fastp.sh展开收起

1
#!/bin/bash
2
# Debian 13 实测 2025-02-03
3

4
set -euo pipefail
5

6
INPUT_DIR="./raw_data"
7
OUTPUT_DIR="./clean_data"
8
REPORT_DIR="./qc_reports"
9
THREADS=8
10

11
mkdir -p "$OUTPUT_DIR" "$REPORT_DIR"
12

13
# 从R1文件名推导R2文件名
14
for r1 in "$INPUT_DIR"/*_R1.fastq.gz; do
15
    r2="${r1/_R1.fastq.gz/_R2.fastq.gz}"
16
    sample=$(basename "$r1" _R1.fastq.gz)
17

18
    echo "Processing: $sample"
19

20
    fastp \
21
        -i "$r1" -I "$r2" \
22
        -o "$OUTPUT_DIR/${sample}_clean_R1.fastq.gz" \
23
        -O "$OUTPUT_DIR/${sample}_clean_R2.fastq.gz" \
24
        -h "$REPORT_DIR/${sample}_fastp.html" \
25
        -j "$REPORT_DIR/${sample}_fastp.json" \
26
        --detect_adapter_for_pe \
27
        --qualified_quality_phred 20 \
28
        --length_required 36 \
29
        --cut_front --cut_tail \
30
        --cut_window_size 4 --cut_mean_quality 20 \
31
        -w "$THREADS"
32

33
    echo "  Done: $sample"
34
done
35

36
echo "=== All samples processed ==="

展开收起

关键点： for r1 in ..._R1.fastq.gz 用 _R1 自动找对应的 _R2，这种命名规则是 Illumina 下机数据的默认格式。如果你的文件命名不标准，改掉 _R1 和 _R2 的替换规则。

4. MultiQC——批量汇总几十份报告#

当你有 20 个样本，每个有 FastQC + fastp 两套报告，一份份点开看会疯。MultiQC 把它们聚合到一张 HTML 页面上。

Terminal window

1
# 安装（别忘了用 conda-forge channel）
2
conda install -c bioconda -c conda-forge multiqc -y
3

4
# 汇总
5
multiqc ./qc_reports/ -o multiqc_report/ -n project_qc_summary
6

7
# 指定报告标题
8
multiqc ./qc_reports/ -o multiqc_report/ \
9
    --title "RNA-seq Project 2025 - QC Summary" \
10
    --filename rnaseq_qc.html

MultiQC 会自动扫描目录下所有 *_fastqc.zip 和 *_fastp.json，生成一张汇总页面。最实用的部分是：

General Statistics 表：所有样本的 reads 数、Q30%、GC% 等排在一张表里，异常样本一眼可见
Sequence Quality 汇总：所有样本的质量曲线叠在一起，谁掉队立刻看出来
Adapter Content：批量排查哪些样本有接头残留

5. 踩坑记录#

坑1：FastQC 报 `Can't allocate memory`#

30GB 的 FASTQ 直接喂给 FastQC，8GB 内存的服务器直接 OOM。

解决： FastQC 默认读整个文件到内存。用 --nogroup 禁用一个内存密集型的画图功能：

Terminal window

1
fastqc --nogroup sample.fastq.gz

或者先用 seqtk sample 随机抽 100 万条跑个初检：

Terminal window

1
seqtk sample -s42 sample.fastq.gz 1000000 | gzip > sample_sub.fastq.gz
2
fastqc sample_sub.fastq.gz

坑2：fastp 输出 reads 数骤减#

症状：输入 5000 万 reads，输出只剩 3000 万。

排查顺序：

先看 --length_required 是不是设太高（比如设 100，很多短 read 被误杀）
再看 --qualified_quality_phred 是不是太严（设 30 而不是 20）
最后看数据是不是真的差——跑个 FastQC 确认

经验数值： --length_required 36（最常用），--qualified_quality_phred 20。如果这个参数下还是 >20% 被过滤，数据确实有问题。

坑3：PE 和 SE 数据混用导致 fastp 报错#

Terminal window

1
# 错误做法：单端数据用了双端参数
2
fastp -i single_end.fastq.gz -I NOT_EXIST.fastq.gz  # 报错！
3

4
# 正确做法：单端只用 -i
5
fastp -i single_end.fastq.gz -o clean.fastq.gz

加个判断脚本：

Terminal window

1
if [[ -f "${r1/_R1/_R2}" ]]; then
2
    # 双端模式
3
    fastp -i "$r1" -I "$r2" ...
4
else
5
    # 单端模式
6
    fastp -i "$r1" ...
7
fi

坑4：MultiQC 报 `No analysis results found`#

症状：MultiQC 扫描目录输出了空报告。

原因：你给 MultiQC 的目录里没有它能识别的文件。MultiQC 认识的 FastQC 输出是 *_fastqc.zip，不是 *_fastqc.html。

Terminal window

1
# 确认 FastQC 输出文件存在
2
ls *_fastqc.zip
3

4
# 再跑 MultiQC
5
multiqc .

坑5：接头序列检测不到#

fastp 的 --detect_adapter_for_pe 不是万能的。新测序平台或定制文库的接头，可能不在 fastp 内置的接头库中。

解决： 手动指定接头序列：

Terminal window

1
fastp --adapter_sequence AGATCGGAAGAGCACACGTCTGAACTCCAGTCA \
2
      --adapter_sequence_r2 AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGT

或者用 cutadapt 专门去接头：

Terminal window

1
cutadapt -a AGATCGGAAGAGC... -A AGATCGGAAGAGCG... \
2
    -o clean_R1.fastq.gz -p clean_R2.fastq.gz \
3
    sample_R1.fastq.gz sample_R2.fastq.gz

6. 质控流程总结#

步骤	工具	命令	产物
1. 初检	FastQC	`fastqc -t 8 *.fastq.gz`	`_fastqc.html`
2. 清洗	fastp	上文完整命令	`clean_*.fastq.gz` + `_fastp.html`
3. 复检	FastQC	`fastqc -t 8 clean_*.fastq.gz`	验证清洗效果
4. 汇总	MultiQC	`multiqc ./`	一张总表

经验： 清洗前和清洗后各跑一次 FastQC，对比报告确认改善效果。就多花 5 分钟，但后面分析出问题你能立刻排除”数据质量不行”这个可能性。

本文于 2025-02-03 在 Debian 13 上实测完成。FastQC v0.12.1、fastp v1.3.3、测序数据模拟生成，全流程可复现。

Bash编程基础：循环、条件、数组与字符串——生信脚本四大件

Sat, 18 Jan 2025 00:00:00 GMT

REPLACEME

生信脚本 70% 的逻辑就是循环+条件，剩下 30% 依赖数组和字符串操作。这篇把这四块整合成一份速查手册——模板直接复制改参数就能用。

实测环境：Debian 13，Bash 5.2。

1. for循环——批量处理的基石#

Terminal window

1
for sample in WT_1 WT_2 KO_1 KO_2; do
2
    echo "Processing ${sample}"
3
done
4

5
# 方式2：C风格计数
6
for ((i=1; i<=10; i++)); do
7
    echo "Round ${i}"
8
done

生信模板1：批量处理配对FASTQ

Terminal window

1
R1_FILES=(*_R1_*.fastq.gz)
2
for r1 in "${R1_FILES[@]}"; do
3
    r2="${r1/_R1_/_R2_}"
4
    sample="${r1%%_R1*}"
5
    fastp -i "$r1" -I "$r2" -o "clean/${sample}_R1.fq.gz" -O "clean/${sample}_R2.fq.gz" -w 8
6
done

模板2：遍历BAM统计

Terminal window

1
for bam in *.bam; do
2
    sample=$(basename "$bam" .bam)
3
    samtools flagstat "$bam" > "stats/${sample}.txt"
4
done

模板3：带进度计数

Terminal window

1
files=(*.fastq.gz)
2
total=${#files[@]}; current=0
3
for f in "${files[@]}"; do
4
    ((current++))
5
    echo "[${current}/${total}] Processing ${f}..."
6
    fastp -i "$f" -o "clean/$f" -w 4
7
done

模板4：条件跳过 + 失败收集

Terminal window

1
FAILED=()
2
for bam in *.bam; do
3
    sample=$(basename "$bam" .bam)
4
    [[ -f "vcf/${sample}.vcf.gz" && "vcf/${sample}.vcf.gz" -nt "$bam" ]] && continue
5
    bcftools mpileup -f ref.fa "$bam" | bcftools call -mv -o "vcf/${sample}.vcf.gz" || FAILED+=("$sample")
6
done
7
echo "Failed: ${FAILED[@]:-None}"

2. while/until——动态输入与等待#

逐行读取（IFS= read -r 不可省略）

Terminal window

1
while IFS= read -r line; do
2
    [[ -z "$line" || "$line" == \#* ]] && continue
3
    echo "$line"
4
done < sample_list.txt

管道陷阱：while 在子 shell 运行，变量出不来

Terminal window

1
# ✗ 错误——管道右边在子 shell
2
total=0
3
cat counts.txt | while read n; do ((total+=n)); done
4
echo $total  # → 0
5

6
# ✓ 用重定向
7
total=0
8
while read n; do ((total+=n)); done < counts.txt
9

10
# ✓ 或用进程替换
11
while read n; do ((total+=n)); done < <(cat counts.txt)

until——等条件满足再跑

Terminal window

1
until [[ $(df /data --output=pcent | tail -1 | tr -d ' %') -lt 20 ]]; do
2
    echo "Disk >80%, waiting..."; sleep 300
3
done

3. if条件判断#

用 [[ ]] 不要用 [ ]——前者支持正则、不分割单词、不会因空变量报错。

测试	语法	生信场景
文件存在	`[[ -f file ]]`	检查参考基因组
目录存在	`[[ -d dir ]]`	确保输出目录
文件非空	`[[ -s file ]]`	BAM 不是空文件
文件1更新	`[[ f1 -nt f2 ]]`	增量跳过已完成
字符串匹配	`[[ "$a" == "$b" ]]`	样本类型判断
正则匹配	`[[ "$a" =~ ^SRR ]]`	验证 SRA ID
数值比较	`[[ $a -gt $b ]]`	测序深度阈值

模板1：启动前完整性检查

Terminal window

1
[[ ! -f "$REF" ]] && { echo "ERROR: ref missing"; exit 1; }
2
[[ ! -f "$R1" ]] && { echo "ERROR: R1 missing"; exit 1; }
3
[[ ! -f "$R2" ]] && MODE="single" || MODE="paired"

模板2：按读长选比对工具

Terminal window

1
READ_LEN=$(seqkit stats "$fq" | tail -1 | awk '{print int($7)}')
2
if   [[ $READ_LEN -lt 50 ]];   then ALIGNER="bowtie"
3
elif [[ $READ_LEN -lt 150 ]];  then ALIGNER="bwa mem"
4
elif [[ $READ_LEN -lt 1000 ]]; then ALIGNER="minimap2 -x sr"
5
else ALIGNER="minimap2 -x map-ont"
6
fi

模板3：检查所有必需软件

Terminal window

1
for tool in bwa samtools bcftools fastp seqkit; do
2
    command -v "$tool" >/dev/null 2>&1 || { echo "Missing: $tool"; exit 1; }
3
done

4. case——多分支#

Terminal window

1
case "${1:-fastq}" in
2
    fastq|fq) EXT="fastq.gz" ;;
3
    bam|sam)  EXT="bam" ;;
4
    vcf)      EXT="vcf.gz" ;;
5
    *) echo "Unknown format: $1"; exit 1 ;;
6
esac

5. 索引数组#

Terminal window

1
# 创建与访问
2
samples=(WT_1 WT_2 KO_1 KO_2)
3
echo "${samples[0]}"          # 第一个
4
echo "${#samples[@]}"         # 长度
5
echo "${!samples[@]}"         # 全部索引
6

7
# 追加
8
samples+=(WT_3)
9

10
# 遍历——[@]加双引号是建议
11
for s in "${samples[@]}"; do echo "$s"; done
12

13
# mapfile：文件→数组
14
mapfile -t SAMPLES < sample_list.txt

[@] vs [*]：前者保持元素独立，后者拼成单一字符串。遍历永远用 "${arr[@]}"。

数组去重：

Terminal window

1
declare -A seen; UNIQUE=()
2
for s in "${SAMPLES[@]}"; do
3
    [[ -z "${seen[$s]:-}" ]] && { UNIQUE+=("$s"); seen[$s]=1; }
4
done

6. 关联数组——Bash 内置字典#

Terminal window

1
declare -A mapping   # 必须声明！
2
mapping=([WT_1]="wild type" [KO_1]="knockout")
3

4
echo "${mapping[KO_1]}"       # 取值
5
echo "${!mapping[@]}"         # 所有键
6
[[ -v mapping[WT_1] ]] && echo "exists"  # 检查键存在
7

8
# 做计数器
9
declare -A COUNTS
10
for gtype in protein_coding lncRNA pseudogene; do
11
    ((COUNTS[$gtype]++))
12
done

7. 字符串操作——生信最高频#

前后缀删除（通配符不是正则！）#

Terminal window

1
path="/data/projects/sample1.bam"
2
fq="sample_WT_rep1_R1.fastq.gz"
3

4
echo "${path##*/}"         # sample1.bam（basename）
5
echo "${fq%%.*}"           # sample_WT_rep1_R1
6
echo "${fq%%_R1*}"         # sample_WT_rep1（提取样本ID）

口诀：# 删前缀，% 删后缀；一个=最短，两个=最长。

替换#

Terminal window

1
s="sample_WT_R1.fastq.gz"
2
echo "${s/R1/R2}"          # 首次替换
3
echo "${s// /_/}"          # 全局替换空格为下划线
4

5
# R1↔R2 配对（最安全的方式）
6
r2="${r1/_R1_/_R2_}"

默认值与大小写#

Terminal window

1
THREADS="${1:-8}"                    # 默认值
2
INPUT="${2:?Error: input required}"  # 未设置则报错退出
3
echo "${DEBUG:+Debug mode ON}"       # 有值才输出
4

5
seq="atcg"; echo "${seq^^}"          # ATCG

8. 完整实战：RNA-seq 批量预处理#

1
#!/bin/bash
2
set -euo pipefail
3

4
mapfile -t RAW < sample_list.txt
5
SAMPLES=()
6
for s in "${RAW[@]}"; do
7
    [[ -z "$s" || "$s" == \#* ]] && continue
8
    SAMPLES+=("$s")
9
done
10

11
declare -A META
12
while IFS=$'\t' read -r sample cond rep; do
13
    META["${sample}_cond"]="$cond"
14
done < metadata.tsv
15

16
SUCCESS=(); FAILED=()
17
total=${#SAMPLES[@]}; i=0
18

19
for sample in "${SAMPLES[@]}"; do
20
    ((i++))
21
    r1="raw/${sample}_R1.fastq.gz"; r2="raw/${sample}_R2.fastq.gz"
22
    [[ ! -f "$r1" || ! -f "$r2" ]] && { FAILED+=("$sample"); continue; }
23

24
    echo "[${i}/${total}] Processing ${sample}..."
25
    fastp -i "$r1" -I "$r2" -o "clean/${sample}_R1.fq.gz" -O "clean/${sample}_R2.fq.gz" -w 8
26

27
    hisat2 -p 16 -x /opt/refs/hg38 -1 "clean/${sample}_R1.fq.gz" -2 "clean/${sample}_R2.fq.gz" \
28
        | samtools sort -@ 8 -o "bam/${sample}.bam" -
29

30
    samtools index "bam/${sample}.bam"
31
    SUCCESS+=("$sample")
32
done
33

34
echo "Done: ${#SUCCESS[@]} success, ${#FAILED[@]} failed"

展开收起

9. 踩坑速查#

坑	现象	解决
`for f in *.gz` 无匹配时变字面量	循环跑了一次 `*.gz`	`shopt -s nullglob`
while read 缺最后一行	文件末尾无换行符	`while read line \|\| [[ -n "$line" ]]`
`[ $a == $b ]` 空变量报错	展开成 `[ == x ]`	用 `[[ ]]`
`for f in $(ls)` 空格拆词	文件名含空格就崩	用 glob 或 `find -print0`
管道while变量丢失	子shell变量不传回	重定向替代管道
关联数组未声明	键被当成变量展开	先 `declare -A`
`unset arr[1]` 索引不连续	遍历出空洞	`arr=("${arr[@]}")` 重建
`${#arr}` vs `${#arr[@]}`	前者是首元素长度	长度永远用后者
`##*/` 非正则	`\.` 不生效	用通配符 `*`
`set -u` 下 `((i++))`	i 未初始化报错	先 `i=0`

10. 速查表#

需求	语法	记号
遍历数组	`for i in "${arr[@]}"`	`[@]`+引号
逐行读文件	`while IFS= read -r line`	`IFS=`
条件判断	`if [[ condition ]]`	双中括号
多分支	`case ... esac`	>3分支
basename	`${path##*/}`	`##`
提取样本ID	`${fq%%_R1*}`	`%%`
R1→R2	`${r1/_R1_/_R2_}`	单斜杠替换
数组长度	`${#arr[@]}`	`#`
关联数组	`declare -A map`	`-A`
默认值	`${var:-default}`	`:-`

两对括号：[[ ]] 测字符串/文件，(( )) 做算术——别的都是搭配。

Conda环境管理：安装、镜像源、环境操作

Wed, 15 Jan 2025 00:00:00 GMT

Conda 的核心价值是环境隔离——每个项目独立维护一套软件依赖，避免 pip/conda/apt 混装导致的库冲突（如 GLIBCXX_3.4.26 not found）。本文覆盖 Miniconda 安装、镜像源配置、环境创建/克隆/导出/删除的完整流程，每一步在 Debian 13 上实测通过。

1. 宿主环境说明#

Terminal window

1
$ cat /etc/os-release | head -2
2
PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
3
NAME="Debian GNU/Linux"
4

5
$ uname -m
6
x86_64
7

8
$ free -h | head -1
9
              total        used        free
10
Mem:          7.7Gi       2.1Gi       5.7Gi

本文所有操作兼容 Ubuntu 20.04/22.04 和 CentOS 7。云服务器 8GB RAM 起步，低于这个跑 conda 装包可能会 OOM。

2. 为什么选 Miniconda 而不是 Anaconda#

Anaconda 是全家桶——装完 3GB+ 磁盘没了，里面 90% 的包你做生信用不到。Miniconda 只有基础 python + conda 核心，体积不到 100MB。

Terminal window

1
# 清华镜像源下载 Miniconda（比官网快10倍）
2
wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh \
3
    -O /tmp/miniconda.sh
4

5
# 静默安装到 /opt/miniconda3（-b=不加环境变量，-p=指定路径）
6
bash /tmp/miniconda.sh -b -p /opt/miniconda3

输出关键行：

1
installation finished.

别漏了最后一步初始化：

Terminal window

1
# 让conda命令在终端可用
2
/opt/miniconda3/bin/conda init bash
3

4
# 重新加载bash配置
5
source ~/.bashrc
6

7
# 验证
8
conda --version
9
# 输出：conda 24.x.x

安装路径选 /opt/miniconda3 的好处：这台服务器上所有用户都能用（前提有读和执行权限），不需要每个人自己装一份。

3. 镜像源配置——解决”下载慢、超时、连不上”#

默认从 repo.anaconda.com 拉包，在国内基本没法用。换清华镜像：

Terminal window

1
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
2
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
3
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda/
4
conda config --set show_channel_urls yes
5
conda config --set channel_priority flexible

参数说明：

show_channel_urls yes：装包时打印来源，方便排查哪个源出了问题
channel_priority flexible：按添加顺序搜索，第一个找到的就用。比 strict（严格按顺序拒绝跨源）更适合生信场景——因为生信往往需要 conda-forge + bioconda 混用

实测踩坑： 清华镜像最近加了 Terms of Service 验证，首次用会提示：

1
To accept these channels' Terms of Service, run:
2
    conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main
3
    conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r

老老实实跑这两条，不然装包会阻塞。如果清华镜像不稳定，替代方案是北外镜像：

Terminal window

1
conda config --add channels https://mirrors.bfsu.edu.cn/anaconda/cloud/bioconda/

4. 环境的完整生命周期#

4.1 创建环境——生信项目常用#

每个项目独立环境，这是建议。好处：项目A用 Python 3.8 + STAR 2.7，项目B用 Python 3.10 + STAR 2.8，各不干扰。

Terminal window

1
# 创建基础环境（指定python版本，避免conda自己选一个老的）
2
conda create -n rnaseq_project -y python=3.10
3

4
# 一次性创建并安装生信工具
5
conda create -n rnaseq_project -y \
6
    python=3.10 \
7
    fastqc fastp samtools star \
8
    -c bioconda -c conda-forge

-c 参数顺序有讲究：-c bioconda -c conda-forge 表示优先从 bioconda 找（生信工具），找不到再从 conda-forge 找（通用依赖）。顺序反过来可能导致 conda-forge 的同名旧包覆盖了 bioconda 的新版。

4.2 激活与退出#

Terminal window

1
# 激活
2
conda activate rnaseq_project
3

4
# 验证——前面应该出现环境名
5
# (rnaseq_project) root@localhost:~$
6

7
# 查看环境中装了哪些软件
8
conda list
9

10
# 退出回到base
11
conda deactivate

4.3 克隆环境——做实验前的安全保障#

要对环境做大改动时（比如升级某个关键软件），先克隆一份，搞崩了还有退路：

Terminal window

1
conda create -n rnaseq_backup --clone rnaseq_project -y

这个操作只复制包索引，不重新下载——快。

4.4 导出与复现#

写完论文要发表，审稿人问”你用的什么软件版本”？一条命令导出：

Terminal window

1
# 导出完整环境（含所有依赖，80行+）
2
conda env export -n rnaseq_project > environment.yml
3

4
# 查看
5
head -20 environment.yml

输出示例：

1
name: rnaseq_project
2
channels:
3
  - conda-forge
4
  - bioconda
5
  - defaults
6
dependencies:
7
  - _openmp_mutex=4.5=20_gnu
8
  - bzip2=1.0.8=hda65f42_9
9
  - fastp=1.3.3=h43da1c4_0
10
  - fastqc=0.12.1=hdfd78af_0
11
  - python=3.10.16
12
  ...

对方用 conda env create -f environment.yml 就能 100% 复现你的环境。但注意： 导出文件里写死了 channel 和 build 号，跨平台可能不兼容。只给同事用可以，要发 supplementary material 的话建议改成简版：

Terminal window

1
conda env export -n rnaseq_project --no-builds > environment_cross_platform.yml

4.5 清理与删除#

Terminal window

1
# 清理下载缓存（跑久了能回收几个G）
2
conda clean -a -y
3

4
# 删除环境
5
conda env remove -n rnaseq_project
6

7
# 列出所有环境
8
conda env list

输出：

1
base                     /opt/miniconda3
2
rnaseq_project       *   /opt/miniconda3/envs/rnaseq_project

带 * 是当前激活的。

5. Conda 软件包管理#

5.1 安装软件的几种写法#

Terminal window

1
# 方式1：指定channel（推荐，明确来源）
2
conda install -c bioconda samtools
3

4
# 方式2：不指定channel（靠配置的channel顺序自动找）
5
conda install samtools
6

7
# 方式3：指定版本
8
conda install -c bioconda samtools=1.18
9

10
# 方式4：从特定channel装（conda-forge编译的版本通常更新）
11
conda install -c conda-forge samtools=1.20

5.2 查找可用版本#

Terminal window

1
conda search samtools

输出前几行：

1
samtools    0.1.12   0  bioconda
2
samtools    0.1.13   0  bioconda
3
...
4
samtools    1.20     0  conda-forge

同一个包在 bioconda 和 conda-forge 上都有，版本号还不一样。生信工具优先选 bioconda 的。

5.3 版本锁定——防止下次装包偷升级#

conda 默认行为是”如果你要装A，它可能会把依赖的B顺便升级”。这在活跃开发中经常导致环境跑飞。

Terminal window

1
# 在当前环境安装后，把已装包写入文件
2
conda list --explicit > pinned.txt
3

4
# 下次想恢复这个精确状态
5
conda install --file pinned.txt

或者用更轻量的锁定方式——只锁主要软件包：

Terminal window

1
echo "samtools=1.18" >> $CONDA_PREFIX/conda-meta/pinned

之后 conda 在装其他包时就尽量不动 samtools 版本。

6. 踩坑记录#

坑1：base 环境不要装任何生信软件#

新手常犯的错：什么都在 base 里装。结果 base 环境装了 200+ 包，版本冲突后整个 conda 都坏了。

解决： base 只装 conda 自身 + 可能一个 python。所有生信软件都在独立环境里。

坑2：conda install 和 pip install 混用崩环境#

症状：conda install 之后用 pip install 补了个包，然后 conda 命令全报错。

原因：pip 不知道 conda 的依赖树，它写的文件可能覆盖 conda 管的东西。

解决： 优先全用 conda 装；必须用 pip 的话，放在最后且用 --no-deps：

Terminal window

1
pip install --no-deps some-package

装完立刻测试核心命令能否运行。

坑3：磁盘不够——conda缓存偷偷吃掉几十G#

conda clean -a -y 清理的是已解压缓存，但还有一个地方常常被忽略：pkgs 目录。

Terminal window

1
du -sh /opt/miniconda3/pkgs
2
# 可能十几GB...

手动删除不常用缓存：

Terminal window

1
conda clean --packages --tarballs -y

坑4：`GLIBCXX` 版本冲突#

某天装了个 conda-forge 的包，它自带的 libstdc++.so 覆盖了系统版本。然后非 conda 的软件（比如 Docker）全崩了。

根本解决：用 conda 的 --no-update-deps 避免次要依赖被升级：

Terminal window

1
conda install --no-update-deps -c bioconda new_tool

或者明确把 libstdcxx-ng 锁在系统兼容版本：

Terminal window

1
echo "libstdcxx-ng" >> $CONDA_PREFIX/conda-meta/pinned

坑5：环境激活后 `which python` 还是指向系统#

原因：conda init 没运行，或者 ~/.bashrc 没被加载。

Terminal window

1
# 确认conda初始化
2
/opt/miniconda3/bin/conda init bash
3
exec bash   # 重新打开shell
4

5
# 测试
6
which python
7
# 应该输出 /opt/miniconda3/envs/xxx/bin/python，不是 /usr/bin/python

7. 生信环境模板#

我常用的一个生信基础环境：

Terminal window

1
conda create -n bioinfo_base -y \
2
    python=3.10 \
3
    fastqc fastp multiqc \
4
    samtools bedtools \
5
    bwa hisat2 \
6
    subread \
7
    -c bioconda -c conda-forge

装完约 2GB。新项目直接从这个克隆，不用每次从头装：

Terminal window

1
conda create -n project_2025 --clone bioinfo_base -y

8. 小结#

操作	命令	注意
安装Miniconda	`wget ... && bash`	用 `-p /opt` 统一路径
配置镜像	`conda config --add channels`	先 bioconda 再 conda-forge
创建环境	`conda create -n 名 python=3.10`	指定版本防止自动选老的
克隆	`conda create --clone`	不需要重新下载，快
导出	`conda env export > file.yml`	跨平台加 `--no-builds`
激活	`conda activate 名`	命令前面出现环境名就对了
清理	`conda clean -a -y`	每月跑一次

本文于 2025-01-15 在 Debian 13 上实测完成，Miniconda3、fastqc v0.12.1、fastp 1.3.3 均为实际安装版本。

Linux文件管理：权限、路径、查找、批量操作

Wed, 08 Jan 2025 00:00:00 GMT

Linux 生信环境中最容易出问题的两个方面——文件权限和路径管理。本文覆盖权限配置、目录规划、软链接、find 批量操作和日志管理，每一条命令都经过实测验证。

本文所有命令均在 Debian 13 / Ubuntu 22.04 上实测通过，8GB RAM + 80GB 磁盘的标准云服务器配置，直接复制就能跑。

1. 生信工作目录怎么规划#

建议在 /opt 或 /data 下建一个标准目录结构：

Terminal window

1
mkdir -p /opt/bioinfo/{data,scripts,results,logs,software,refs}
2
cd /opt/bioinfo
3
tree -L 1

输出长这样：

1
/opt/bioinfo/
2
├── data        # 原始数据、fastq文件
3
├── scripts     # 分析脚本（Shell/Python/R）
4
├── results     # 输出结果（bam、vcf、表达矩阵...）
5
├── logs        # 运行日志（排查问题靠它）
6
├── software    # 手动编译安装的软件
7
└── refs        # 参考基因组、索引文件

项目开始时先建好标准目录结构，可以避免后续管理混乱。

2. 权限管理——生信最容易翻车的地方#

2.1 看懂 `ls -la` 输出#

Terminal window

1
ls -la /opt/bioinfo/scripts/

1
-rwxr-xr-x  1 bioinfo bioinfo   2048 Jan  8 14:30 run_qc.sh
2
drwxr-xr-x  2 bioinfo bioinfo   4096 Jan  8 14:00 .

这个 -rwxr-xr-x 到底什么意思？拆开看：

位置	含义
第1位 `-`	文件类型（`-`普通文件，`d`目录，`l`软链接）
第2-4位 `rwx`	属主权限（读/写/执行）
第5-7位 `r-x`	属组权限（读/-/执行）
第8-10位 `r-x`	其他人权限（读/-/执行）

数字权限对照（写在脚本里必备）：

mode=4×r+2×w+1×xmode = 4\times r + 2\times w + 1\times xmode=4×r+2×w+1×x

数字	权限	常见用途
644	`rw-r--r--`	数据文件（自己可写，别人只读）
755	`rwxr-xr-x`	脚本、目录（自己可执行，别人可读可执行）
700	`rwx------`	私人脚本（别人完全看不到）
600	`rw-------`	配置文件含密码（如 `.netrc`）

2.2 常见问题：Permission denied#

Terminal window

1
# 比如你从别人那里拷贝了脚本，直接运行：
2
./run_qc.sh
3
# bash: ./run_qc.sh: Permission denied

就三步解决：

Terminal window

1
# 1. 看权限
2
ls -la run_qc.sh
3

4
# 2. 加执行权限
5
chmod +x run_qc.sh
6

7
# 3. 确认
8
ls -la run_qc.sh   # 应该看到 -rwxr-xr-x

如果是目录权限不够（比如你进不去某个文件夹），用 chmod 755 dirname。

2.3 umask——控制新建文件的默认权限#

umask 是”权限掩码”，新建文件默认权限 = 666 - umask，目录 = 777 - umask。

Terminal window

1
umask          # 默认输出 0022

umask 0022 → 新建文件 644（rw-r—r—），目录 755（rwxr-xr-x）
umask 0002 → 新建文件 664（同组可写）
umask 0077 → 新建文件 600（仅自己可见，别人完全看不了）

生信场景： 多人共用一台服务器，你的原始数据不想让同组其他人误删，可以临时设：

Terminal window

1
umask 0077
2
touch sensitive_data.txt
3
ls -la sensitive_data.txt   # -rw-------

改回来 umask 0022。不过这个只在当前shell会话生效，想永久改要写到 ~/.bashrc 里。

3. 路径管理——别硬编码绝对路径#

3.1 软链接比拷贝强#

生信分析经常一个参考基因组被多个项目用。不要每个项目拷一份，用软链接：

Terminal window

1
# 在项目目录下创建链接
2
ln -s /opt/bioinfo/refs/hg38.fa ./refs/hg38.fa
3
ln -s /opt/bioinfo/refs/hg38.fa.fai ./refs/hg38.fa.fai
4
ls -lh ./refs/

输出：

1
lrwxrwxrwx  1 bioinfo bioinfo     26 Jan  8 15:00 hg38.fa -> /opt/bioinfo/refs/hg38.fa

好处1：节省磁盘空间（3GB的基因组一个就够了）
好处2：更新参考基因组时，只需更新一处
好处3：删项目目录时不会误删参考数据

踩坑警告： ln -s <源文件> <链接名> 的顺序容易搞反。我一开始老写成 ln -s <链接名> <源文件>，怎么都不对。注意：源在前，链在后。

3.2 相对路径 vs 绝对路径 vs 环境变量#

脚本里的路径怎么处理？三种方式对比：

Terminal window

1
# ❌ 硬编码绝对路径——换个机器就跑不了
2
DATA=/home/bioinfo/project1/data/sample1.fastq
3
bwa mem /home/bioinfo/refs/hg38.fa $DATA > output.sam
4

5
# ✅ 相对路径——灵活，但要搞清楚脚本从哪个目录执行的
6
DATA=../data/sample1.fastq
7
bwa mem ../refs/hg38.fa $DATA > output.sam
8

9
# ✅ 环境变量——最推荐，修改一处全局生效
10
export REF_DIR=/opt/bioinfo/refs
11
export DATA_DIR=/opt/bioinfo/data
12
bwa mem $REF_DIR/hg38.fa $DATA_DIR/sample1.fastq > output.sam

推荐使用环境变量 + 脚本顶部定义：

1
#!/bin/bash
2
# run_alignment.sh - RNA-seq比对脚本
3
# Debian 13 实测 2025-01-08
4

5
set -euo pipefail  # 出错就停，别硬跑
6

7
# === 路径定义 ===
8
PROJ_ROOT="/opt/bioinfo/project_rnaseq"
9
DATA_DIR="${PROJ_ROOT}/data"
10
REF_DIR="/opt/bioinfo/refs"
11
OUT_DIR="${PROJ_ROOT}/results"
12
LOG_DIR="${PROJ_ROOT}/logs"
13

14
# === 第一步：质控 ===
15
fastp -i "${DATA_DIR}/sample_R1.fastq.gz" \
16
      -I "${DATA_DIR}/sample_R2.fastq.gz" \
17
      -o "${OUT_DIR}/sample_clean_R1.fastq.gz" \
18
      -O "${OUT_DIR}/sample_clean_R2.fastq.gz" \
19
      -h "${LOG_DIR}/sample_fastp.html" \
20
      2>&1 | tee "${LOG_DIR}/fastp.log"

展开收起

${变量} 加花括号是好习惯——后面跟字符串不会混淆。set -euo pipefail 是生信脚本常用，解释下：

-e：任何命令返回非零就退出
-u：用了未定义变量就报错
-o pipefail：管道中任何一个命令失败都算失败

3.3 realpath——搞清楚你到底在哪个目录#

Terminal window

1
cd /opt/bioinfo/./scripts/../
2
pwd          # /opt/bioinfo（pwd告诉你路径）
3
realpath .   # /opt/bioinfo（realpath解决所有符号链接和.和..）

写脚本时如果要获取”脚本所在的目录”，用这个经典语句：

Terminal window

1
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"

这样一来，不管从哪里调用这个脚本，都能正确定位到它所在目录的相对路径。

4. find——文件搜索神器#

查找历史文件最有效的方式是 find：

4.1 基础搜索#

Terminal window

1
# 按文件名搜索
2
find /opt/bioinfo -name "*.fastq.gz" -type f
3

4
# 按大小搜索（大于1GB的bam文件）
5
find /opt/bioinfo -name "*.bam" -size +1G
6

7
# 按修改时间（24小时内改动过的结果文件）
8
find /opt/bioinfo/results -mtime -1 -type f
9

10
# 组合条件：最近7天创建的、大于100MB的bam文件
11
find /opt/bioinfo -name "*.bam" -size +100M -mtime -7

4.2 批量操作——这个最实用#

Terminal window

1
# 批量删除空文件（跑崩了的输出）
2
find /opt/bioinfo/results -type f -empty -delete
3

4
# 批量改名（把所有.fastq改成.fq）
5
find /opt/bioinfo/data -name "*.fastq" -type f -exec rename 's/.fastq$/.fq/' {} \;
6

7
# 批量压缩日志（30天前的日志打包）
8
find /opt/bioinfo/logs -name "*.log" -mtime +30 -exec gzip {} \;
9

10
# 批量chmod（把所有脚本加执行权限）
11
find /opt/bioinfo/scripts -name "*.sh" -type f -exec chmod +x {} \;

4.3 find xargs做批量处理#

Terminal window

1
# 统计所有fastq.gz文件总大小
2
find /opt/bioinfo/data -name "*.fastq.gz" -type f | xargs du -ch | tail -1
3

4
# 批量跑fastqc（xargs -P 并行！）
5
find /opt/bioinfo/data -name "*.fastq.gz" | xargs -P 4 -I {} fastqc {} -o /opt/bioinfo/results/qc/

-P 4 是精髓——同时跑4个，根据实际测试，CPU核心多的话可以设到8。设太多反而IO瓶颈。

5. 输出重定向与日志管理#

5.1 stdout vs stderr 的区别#

Terminal window

1
# 标准输出重定向到文件
2
fastqc sample.fastq.gz > qc_output.txt
3

4
# 仅重定向错误信息
5
fastqc sample.fastq.gz 2> qc_error.txt
6

7
# 两者都重定向到不同文件
8
fastqc sample.fastq.gz > qc_output.txt 2> qc_error.txt
9

10
# 两者合并到同一个文件（生信最常用）
11
fastqc sample.fastq.gz > qc_all.txt 2>&1

5.2 tee——边看边存#

Terminal window

1
# 屏幕上看着输出，同时存到文件
2
fastqc sample.fastq.gz 2>&1 | tee qc.log
3

4
# 套在完整脚本里
5
{
6
    echo "=== QC started at $(date) ==="
7
    fastqc sample.fastq.gz 2>&1
8
    echo "=== QC finished at $(date) ==="
9
} | tee qc_full.log

5.3 推荐的日志格式#

1
#!/bin/bash
2
LOG_FILE="/opt/bioinfo/logs/rnaseq_$(date +%Y%m%d_%H%M%S).log"
3

4
exec > >(tee -a "$LOG_FILE") 2>&1  # 所有输出同时到屏幕和日志
5

6
echo "========== RNA-seq Pipeline =========="
7
echo "Start time: $(date)"
8
echo "Hostname: $(hostname)"
9
echo "User: $(whoami)"
10
echo "Working directory: $(pwd -P)"
11
echo "========================================"

日志中记录了开始时间、主机名、用户和工作目录，方便后续追溯。

6. 踩坑记录#

坑1：软链接断了#

症状：ls -la 显示链接闪红色（黑底红字），文件不存在。

原因：原始文件被移动或删除了。

解决：

Terminal window

1
# 检查链接是否有效
2
find /opt/bioinfo -type l ! -exec test -e {} \; -print
3

4
# 输出类似：./refs/hg38.fa  表示这个链接已断

重新建或者删掉即可。! -exec test -e {} \; 的意思是”存在性测试失败的”。

坑2：umask改完忘了改回来#

症状：团队其他人突然访问不了你的输出文件。

原因：你在某个shell会话里改了 umask 0077，忘了改回来。

解决：

Terminal window

1
umask   # 看看当前值
2
umask 0022   # 改回默认
3

4
# 批量修复已有文件
5
find /opt/bioinfo/results -type f -exec chmod 644 {} \;
6
find /opt/bioinfo/results -type d -exec chmod 755 {} \;

坑3：权限设成777以为方便#

症状：chmod 777 看似最省事，但安全风险极大——任何系统用户都能改你的文件。

解决：用755（目录和脚本）和644（数据文件）是最佳实践。777只应该在 /tmp 下临时用。

坑4：find -exec 后面忘了加 ;#

症状：

1
find: missing argument to `-exec'

原因：-exec 的语法是 -exec command {} \;，反斜杠分号部分是必需的命令结束符。

解决：严格写 -exec command {} \;。反斜杠前面有空格，分号前面是反斜杠。

7. 小结#

这篇文章覆盖的命令不复杂，但都是日常高频操作：

功能	核心命令	记忆口诀
权限	`chmod 644 file`	数据644，脚本755
umask	`umask 0022`	0022=默认安全
软链接	`ln -s 源目标`	源在前，链在后
搜索	`find . -name "*.fa"`	找啥写啥
批量	`find ... \| xargs -P 4`	-P并行提速
日志	`command 2>&1 \| tee log`	边看边存
生信软件不靠 Conda 隔离的话，版本冲突能把人搞疯。

本文于 2025-01-08 在 Debian 13 云服务器上实测完成，全部命令可复现。

风观

生信自学路线图：从Linux基础到独立分析

第一阶段：Linux生存能力（1-2周）#

第二阶段：生信工具链（2-4周）#

第三阶段：定量与差异分析（2-3周）#

第四阶段：可重复性与效率（持续）#

学习资源#

最关键的一句话#

命令行小工具：seqtk/csvtk/datamash/bioawk

1. seqtk——序列抽样和格式转换#

2. csvtk——CSV/TSV表格处理#

3. datamash——命令行统计分析#

4. bioawk——生信专用awk#

5. 踩坑#

Vim配置与技巧：语法高亮、折叠、宏、多文件

1. 基础配置——.vimrc#

2. 生信文件类型的语法高亮#

2.1 FASTA 语法高亮#

2.2 BED 文件按列着色#

3. 折叠代码——超长脚本的救星#

4. 宏录制——重复操作的自动化#

5. 多文件操作——buffer + 分屏#

6. 查找与替换——正则替换实战#

6.1 基础查找#

6.2 正则替换——生信高频操作#

6.3 Vim 正则 vs Perl 正则的差异#

7. 查看超长序列——折行与导航#

8. 踩坑记录#

坑1：粘贴代码缩进错乱#

坑2：用 :wq 保存只读文件#

坑3：误按 Ctrl-z 后 Vim “卡死”#

坑4：高亮残留——:noh 是你的朋友#

坑5：Vim 里的 Undo 只能用一次#

9. Vim 工作流模板#

10. 推荐插件（最小化原则）#

NERDTree——文件浏览器#

vim-airline——状态栏美化#

11. 总结#

网络诊断与测速：ping/mtr/iperf3/curl

1. 连通性诊断——从ping开始但不只ping#

1.1 ping——第一把手术刀#

1.2 mtr——ping + traceroute 的合体#

1.3 traceroute——备选方案#

2. 带宽测试——iperf3测真实吞吐#

2.1 内网测速#

2.2 到外网的带宽测试#

2.3 实际吞吐量公式#

3. DNS诊断——被忽略的瓶颈#

4. HTTP/FTPSRA下载实战#

4.1 用curl诊断下载问题#

4.2 axel多线程下载#

4.3 速度优化检查清单#

5. 特殊场景：代理和SSH隧道#

5.1 为命令行工具设置代理#

5.2 SSH隧道端口转发#

5.3 生信专用下载加速策略#

6. 踩坑记录#

坑1：ping得通但下载速度只有几十KB#

坑2：MTU不匹配导致TCP连接失败#

坑3：axel下载地址含特殊字符导致失败#

坑4：iperf3测试速度正常但真实下载慢#

坑5：/etc/resolv.conf 被覆盖#

坑6：curl下载一段时间后速度降到0#

坑7：prefetch 尊重 http_proxy 但 fasterq-dump 不尊重#

7. 总结#

Markdown与Pandoc：文档写作与格式转换

1. 环境搭建#

2. 生信实验记录 Markdown 模板#

3. Pandoc 转换——核心命令#

3.1 基础转换#

3.2 带中文字体的 PDF#

3.3 代码块高亮#

3.4 数学公式——LaTeX 原生支持#

4. 文献引用——生信报告必备#

4.1 使用 BibTeX 引用#

4.2 图片交叉引用#

5. 定制 Pandoc 模板#

5.1 创建生信报告模板#

5.2 YAML 元数据——文档信息集中管理#

6. 批量处理——分析报告自动化#

1. 基础配置——`.vimrc`#

坑2：用 `:wq` 保存只读文件#

坑3：误按 `Ctrl-z` 后 Vim “卡死”#

坑4：高亮残留——`:noh` 是你的朋友#

坑5：`/etc/resolv.conf` 被覆盖#

坑5：biomaRt 的 `getSequence` 对大型查询极慢#

坑6：`getBM` 返回重复行#

坑1：`^M` 出现在 Shell 脚本里导致 `bad interpreter`#

坑3：read.csv 读出来的列名变成了 `ï..Gene`#