硫磺皂的技术站

gFortran编译器使用指南

Thu, 16 Jul 2026 00:00:00 GMT

终端 gFortran#

使用conda-forge中发布的gfortran编译器

下面为一套 gfortran 常用命令速查表，按“最常用 → 进阶 → 调试/排错”来分。

0. 环境配置#

使用conda环境配置gfortran编译器。建议先创建虚拟环境配置fortran编译器，虚拟环境创建方法见[[终端Conda]]

以下是配置方法：进入虚拟环境后，从conda-forge中下载gFortran编译器，conda-forge中更新更快，版本更全

1
conda install -c conda-forge gfortran

此时已经完成gfortran编译器的安装，需要一个编辑器，这里选择VS code。在VS code中安装modern Fortran插件，按照文档配置fortls、fprettify 提供代码补全和语法检查。详细配置方法见 Bilibili BV1WfNCz8EzE

1. 最基本的编译命令#

1.1 编译并链接生成可执行文件#

Terminal window

1
gfortran main.f90 -o main

如果有多个源文件：

Terminal window

1
gfortran a.f90 b.f90 c.f90 -o app

1.2 只编译，不链接#

生成 .o 文件：

Terminal window

1
gfortran -c main.f90

多个文件：

Terminal window

1
gfortran -c a.f90 b.f90

1.3 指定输出文件名#

Terminal window

1
gfortran main.f90 -o myprog

2. 处理不同格式/预处理#

2.1 强制自由格式#

Terminal window

1
gfortran -ffree-form file.f -o file

2.2 强制固定格式#

Terminal window

1
gfortran -ffixed-form legacy.f90 -o legacy

2.3 开启预处理#

会链接成exe文件

Terminal window

1
gfortran -cpp main.F90 -o main

只预处理为f90文件

Terminal window

1
gfortran -cpp -E main.F90 -o main.f90

2.4 关闭预处理#

Terminal window

1
gfortran -nocpp main.F90 -o main

一般来说：

.f/.for/.ftn：常按固定格式

.f90：自由格式

.F90：通常预处理 + 自由格式

3. 常用警告和检查选项#

3.1 打开常见警告#

Terminal window

1
gfortran -Wall main.f90 -o main

3.2 更严格一些#

Terminal window

1
gfortran -Wall -Wextra main.f90 -o main

3.3 检查运行时错误#

Terminal window

1
gfortran -fcheck=all main.f90 -o main

常用于调试：

数组越界
未初始化访问
一些运行时错误

4. 调试相关#

4.1 加调试信息#

Terminal window

1
gfortran -g main.f90 -o main

4.2 适合调试的组合#

Terminal window

1
gfortran -g -O0 -Wall -Wextra -fcheck=all main.f90 -o main

说明：

-g：生成调试符号
-O0：关闭优化，便于调试
-fcheck=all：运行时检查
-Wall -Wextra：尽量多提示问题

5. 常用优化选项#

5.1 常规优化#

Terminal window

1
gfortran -O2 main.f90 -o main

5.2 更高优化#

Terminal window

1
gfortran -O3 main.f90 -o main

5.3 发布版常见组合#

Terminal window

1
gfortran -O2 -march=native main.f90 -o main

说明：

-O2：常用平衡优化
-O3：更激进优化
-march=native：针对当前机器优化

6. 数值/浮点相关#

6.1 启用浮点异常检查#

Terminal window

1
gfortran -ffpe-trap=invalid,zero,overflow main.f90 -o main

适合抓：

除零
非法浮点
溢出

6.2 保留未优化的浮点行为#

有时为了调试数值问题，会减少激进优化：

Terminal window

1
gfortran -O0 -g main.f90 -o main

7. 生成预处理后的源码#

7.1 只看预处理结果#

Terminal window

1
gfortran -cpp -E main.F90

这会输出预处理后的代码，适合排查：

#include
#ifdef
宏展开

8. 模块和头文件搜索路径#

8.1 指定模块/包含文件搜索路径#

Terminal window

1
gfortran -I./include -c main.f90

如果 .mod 或 include 文件在别的目录，这个很常用。

9. 生成汇编代码#

9.1 输出汇编文件#

Terminal window

1
gfortran -S main.f90

会生成 .s 文件，适合做底层分析。

10. 查看版本和帮助#

10.1 查看版本#

Terminal window

1
gfortran --version

10.2 查看帮助#

Terminal window

1
gfortran --help

11. 常见编译模板#

11.1 新手调试模板#

Terminal window

1
gfortran -g -O0 -Wall -Wextra -fcheck=all -cpp main.F90 -o main

11.2 正式编译模板#

Terminal window

1
gfortran -O2 -march=native -Wall main.f90 -o main

11.3 多文件项目模板#

Terminal window

1
gfortran -c mod1.f90
2
gfortran -c mod2.f90
3
gfortran -c main.f90
4
gfortran mod1.o mod2.o main.o -o app

12. 常见问题对应命令#

12.1 文件里用了 `#include`，但没生效#

Terminal window

1
gfortran -cpp main.f90 -o main

12.2 老代码扩展名不对，但内容是固定格式#

Terminal window

1
gfortran -ffixed-form legacy.f90 -o legacy

12.3 老代码扩展名不对，但内容是自由格式#

Terminal window

1
gfortran -ffree-form code.f -o code

12.4 想查数组越界#

Terminal window

1
gfortran -fcheck=all -g -O0 main.f90 -o main

13. 最实用的一条总结#

如果你平时只想记住几条，先记这几个：

Terminal window

1
gfortran main.f90 -o main
2
gfortran -c main.f90
3
gfortran -g -O0 -Wall -Wextra -fcheck=all main.f90 -o main
4
gfortran -cpp main.F90 -o main
5
gfortran -I./include -c main.f90

conda使用指南

Thu, 16 Jul 2026 00:00:00 GMT

Conda 命令#

虚拟环境#

查看虚拟环境列表

1
conda env list

创建指定版本虚拟环境

1
conda create -n myenv
2
# 指定python版本
3
conda create -n myenv python=3.10

进入/退出虚拟环境

1
conda activate myenv
2
conda deactivate

删除虚拟环境

1
conda remove -n myenv --all

复制环境

1
conda create -n newenv --clone myenv

迁移备份虚拟环境

1
# 导出当前环境到 yml 文件（进入该环境）
2
conda env export > environment.yml
3
# 指定环境导出
4
conda env export -n myenv > myenv.yml

从配置文件中加载环境

1
# 从配置文件创建环境
2
conda env create -f environment.yml

换源#

查看源

1
conda info

修改 .condarc 文件#

.condarc 文件默认是没有的，需要自己创建
需要在路径 C:\Users\<用户名>\ 下面手动创建一个 .condarc 文件

.condarc 文件内容：

清华大学开源软件镜像站

1
channels:
2
 - defaults
3
show_channel_urls: true
4
channel_alias: https://mirrors.tuna.tsinghua.edu.cn/anaconda
5
default_channels:
6
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
7
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free
8
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
9
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/pro
10
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
11
custom_channels:
12
 conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
13
 msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
14
 bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
15
 menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
16
 pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
17
 simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud

展开收起

阿里巴巴开源软件镜像站

1
channels:
2
 - defaults
3
show_channel_urls: true
4
default_channels:
5
 - http://mirrors.aliyun.com/anaconda/pkgs/main
6
 - http://mirrors.aliyun.com/anaconda/pkgs/r
7
 - http://mirrors.aliyun.com/anaconda/pkgs/msys2
8
custom_channels:
9
 conda-forge: http://mirrors.aliyun.com/anaconda/cloud
10
 msys2: http://mirrors.aliyun.com/anaconda/cloud
11
 bioconda: http://mirrors.aliyun.com/anaconda/cloud
12
 menpo: http://mirrors.aliyun.com/anaconda/cloud
13
 pytorch: http://mirrors.aliyun.com/anaconda/cloud
14
 simpleitk: http://mirrors.aliyun.com/anaconda/cloud

通过命令行修改#

一条一条输入

主仓库

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/pkgs/r
3
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2

conda-forge仓库

1
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge

其他通道

1
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch
2
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/menpo
3
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda
4
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2

Jupyter 相关#

安装Jupyter

1
conda install jupyter

使用Jupyter（注册内核）

1
pip install ipykernel
2
python -m ipykernel install --user --name myenv --display-name "myenv"

库管理#

查看库

1
conda list

查找库

1
# 在当前channel中查找库
2
conda search numpy
3
# 在指定channel中查找库
4
conda search -c conda-forge numpy
5
conda search -c conda-forge *numpy*   #查找包含该字符串的库

安装库

1
conda install numpy
2
# 指定版本
3
conda install numpy=1.23.5
4
# 从conda-forge中安装
5
conda install -c conda-forge numpy=1.23.5

删除库

1
conda remove numpy

在不得不使用pip安装库时，使用以下指令

1
python -m pip install numpy

使用python -m指定使用该环境下的pip模块安装库，防止安装到其他环境中

git使用指南

Thu, 16 Jul 2026 00:00:00 GMT

Git命令#

初次使用#

1
git config --global user.name "你的名字"
2
git config --global user.email "你的邮箱"
3
git config --list

仓库#

克隆仓库

需要修改别人项目时，需要先Fork项目到自己的仓库中，再克隆自己的仓库

1
# 克隆到当前文件夹
2
git clone https://github.com/liuhuangz/Codes.git
3
# 查看远程仓库
4
git remote -v

初始化仓库

1
git init

将本地仓库推送到远程仓库

需要再GitHub或者Gitee中先创建一个仓库

1
# 连接到远程仓库
2
git remote add origin https://github.com/liuhuangz/Codes.git

暂存/提交更改#

暂存

1
# 添加到暂存区
2
git add . #所有更改
3
git add <文件名>
4
#从暂存区移除
5
git reset #移除所有暂存区
6
git reset <文件名>
7
# 查看暂存区状态
8
git status

提交

1
# 提交更改，添加提交信息
2
git commit -m "Initial commit"

分支#

初始化的新仓库需要第一次提交才能创建新分支
一次提交默认为main分支

1
# 列出分支
2
git branch
3
# 创建新分支
4
git branch <branch-name>
5
# 删除分支
6
git branch -d <branch-name>
7
# 切换分支
8
git switch <branch-name>
9
git checkout main # 老版本使用
10
# 合并分支到目前分支
11
git merge <branch-name>

拉取与推送#

1
# 拉取最新更改
2
git pull origin <分支名>
3
# 推送更改
4
git push origin <分支名>

版本回滚#

查看版本号

1
# 查看提交的版本号，之后输入q退出
2
git log
3
# 查看暂存区状态
4
git status

撤销版本

已经提交，但还没push

1
# 撤销提交，文件还在暂存区
2
git reset --soft <版本号>
3
# 撤销提交和暂存
4
git reset --mixed <版本号>

已经提交，已经push

1
# 直接撤销这一次提交
2
git reset --hard <版本号>
3
# 将前一个版本作为新的更改重新提交
4
git revert <版本号>

sacpy使用指南

Thu, 16 Jul 2026 00:00:00 GMT

sacpy 文档合集#

安装

1
pip install sacpy

注意：必须用pip，该库没有发布在conda-forge中

经验正交函数（EOF）分析#

导入#

1
import numpy as np
2
import xarray as xr
3
from sacpy import EOF

`class EOF`#

EOF（经验正交函数）分析类，用于将时空场分解为空间模态和时间系数。

`EOF(data, weights=None)`#

作用：初始化 EOF 分析对象。

参数	类型	默认值	说明
`data`	`np.ndarray` / `xr.DataArray`	必需	输入数据，形状 `(time, *space)`
`weights`	`np.ndarray` / `None`	`None`	空间权重，形状可广播至空间维度。常见用法：纬度余弦平方根权重 `np.sqrt(cos(lat))`

注意：若传入 xr.DataArray，内部会转为 numpy 数组。

`solve(method="eig", st=False, dim_min=10, chunks=None)`#

作用：求解 EOF，得到特征值和特征向量。

参数	类型	默认值	说明
`method`	`str`	`"eig"`	求解方法： - `"eig"`：协方差矩阵特征分解 - `"svd"`：SVD 分解（适合 time < space 的情况） - `"dask_svd"`：使用 Dask 的 SVD（需 dask 库）
`st`	`bool`	`False`	是否打印求解起止时间
`dim_min`	`int`	`10`	eig 模式下的最小维度（SVD 模式自动取 min(time, space)）
`chunks`	`tuple` / `None`	`None`	dask_svd 模式的块大小，必须提供

无返回值，结果保存在对象属性中。

使用示例：

1
# 准备数据（异常场）
2
sst = xr.open_dataset('sst.nc')['sst']
3
sst_anom = sst - sst.groupby('time.month').mean('time')
4

5
# 纬度权重
6
coslat = np.cos(np.deg2rad(sst_anom['lat'].values))
7

8
# EOF 分析
9
eof_obj = EOF(sst_anom, weights=np.sqrt(coslat))
10
eof_obj.solve(method="eig")

`get_eign(npt=4)`#

作用：获取前 n 个特征值（未缩放）。

参数	类型	默认值	说明
`npt`	`int`	`4`	返回的特征值数量

返回：np.ndarray，形状 (npt,)

使用示例：

1
eign = eof_obj.get_eign(npt=3)

`get_varperc(npt=None)`#

作用：返回各模态解释的方差比例（0~1）。

参数	类型	默认值	说明
`npt`	`int` / `None`	`None`	返回数量。`None` 返回所有

公式：var_perc[i] = eigenvalue[i] / sum(variance_of_all_space_points)

返回：np.ndarray，形状 (npt,)

使用示例：

1
vf = eof_obj.get_varperc(npt=5)
2
print(vf)  # 前5个模态的方差解释比例

`north_test(npt=10, perc=False, ddof=None)`#

作用：使用 North et al. (1982) 方法计算特征值的典型误差。

参数	类型	默认值	说明
`npt`	`int`	`10`	检验的模态数量
`perc`	`bool`	`False`	是否按总方差缩放（True 时误差尺度同 `get_varperc`）
`ddof`	`int` / `None`	`None`	自由度。`None` 默认使用 `time_length`

返回：np.ndarray，形状 (npt,)

使用示例：

1
errors = eof_obj.north_test(npt=5)
2
evals = eof_obj.get_eign(5)
3

4
# 判断是否显著分离
5
for i in range(4):
6
    if evals[i] - errors[i] > evals[i+1] + errors[i+1]:
7
        print(f"模式 {i+1} 与 {i+2} 分离良好")

`get_pc(npt=None, scaling="std")`#

作用：获取主成分时间序列（PCs）。

参数	类型	默认值	说明
`npt`	`int` / `None`	`None`	返回的 PC 数量。`None` 返回所有
`scaling`	`str`	`"std"`	缩放方式： - `None`：不缩放（原始 PC） - `"std"`：除以标准差，使每个 PC 方差为 1 - `"DSE"`：除以 `sqrt(特征值)` - `"MSE"`：乘以 `sqrt(特征值)`

返回：np.ndarray，形状 (npt, time)

使用示例：

1
# 获取前3个标准化 PC
2
pcs = eof_obj.get_pc(npt=3, scaling="std")
3

4
# 获取所有未缩放 PC
5
pcs_raw = eof_obj.get_pc(scaling=None)
6

7
# 获取第1个 PC（E 型缩放）
8
pc1 = eof_obj.get_pc(npt=1, scaling="MSE")

`get_pt(npt=None, scaling="mstd")`#

作用：获取空间模态（patterns / EOFs）。

参数	类型	默认值	说明
`npt`	`int` / `None`	`None`	返回的模式数量
`scaling`	`str`	`"mstd"`	缩放方式： - `None`：不缩放（原始特征向量） - `"std"`（即 `"mstd"`）：乘以 PC 的标准差 - `"DSE"`：除以特征值 - `"MSE"`：乘以特征值

返回：np.ndarray，形状 (npt, *origin_space_shape)

使用示例：

1
# 获取前3个空间模态（与标准化PC匹配）
2
patterns = eof_obj.get_pt(npt=3, scaling="mstd")
3

4
# 获取原始特征向量（不缩放）
5
patterns_raw = eof_obj.get_pt(npt=3, scaling=None)

`correlation_map(npt)`#

作用：计算每个 EOF 模式对应的空间相关系数图（PC 与原始场每个格点的相关系数）。

参数	类型	默认值	说明
`npt`	`int`	必需	计算的模式数量

返回：np.ndarray，形状 (npt, *origin_space_shape)，值域 [-1, 1]

使用示例：

1
corr_maps = eof_obj.correlation_map(npt=3)
2
# corr_maps[0] 为第1模态的相关系数空间分布

`projection(proj_field, npt=None, scaling="std")`#

作用：将新场投影到已有的 EOF 空间模态上，得到伪 PC。

参数	类型	默认值	说明
`proj_field`	`np.ndarray`	必需	待投影场，形状 `(time, *space)`
`npt`	`int` / `None`	`None`	投影到前几个模态
`scaling`	`str`	`"std"`	PC 缩放方式（同 `get_pc` 的 `scaling`）

返回：np.ndarray，形状 (npt, proj_time)

使用示例：

1
# 将新的海温场投影到前3个 EOF 上
2
new_sst = xr.open_dataset('new_sst.nc')['sst'].values
3
pseudo_pcs = eof_obj.projection(new_sst, npt=3)

`decoder(pcs)`#

作用：用给定的 PC 和已有的空间模态重构原始场。

参数	类型	默认值	说明
`pcs`	`np.ndarray`	必需	PC 序列，形状 `(*time, pc_num)`

返回：np.ndarray，形状 (*time, *origin_space_shape)。若初始化时提供了 weights，重构时会自动除以权重。

使用示例：

1
# 用第1个 PC 重构场
2
pc1 = eof_obj.get_pc(npt=1, scaling="std")
3
recon = eof_obj.decoder(pc1.T)  # 注意 transpose
4
# recon 形状：(time, lat, lon)

`load_pt(patterns)`#

作用：从外部加载空间模态（用于解码等操作）。

参数	类型	默认值	说明
`patterns`	`np.ndarray`	必需	空间模态，形状 `(npt, *space)`

使用示例：

1
eof_obj.load_pt(precomputed_patterns)

完整示例：EOF 分析+绘图#

1
import numpy as np
2
import xarray as xr
3
import matplotlib.pyplot as plt
4
import cartopy.crs as ccrs
5
from sacpy import EOF
6

7
# 1. 数据准备
8
da = xr.open_dataset('sst.nc')['sst']
9
da_anom = da.groupby('time.month') - da.groupby('time.month').mean('time')
10

11
# 2. EOF 分析
12
coslat = np.cos(np.deg2rad(da_anom['lat'].values))
13
eof = EOF(da_anom, weights=np.sqrt(coslat))
14
eof.solve()
15
vf = eof.get_varperc()
16
print(f"EOF1 方差解释: {vf[0]:.2%}")
17

18
# 3. 获取结果
19
pc1 = eof.get_pc(npt=1, scaling="std")       # (1, time)
20
pt1 = eof.get_pt(npt=1, scaling="mstd")       # (1, lat, lon)
21
corr_map = eof.correlation_map(npt=1)          # (1, lat, lon)
22

23
# 4. 绘图（使用 sacpy 的绘图扩展）
24
import sacpy.Map  # 注册 GeoAxesSubplot 扩展方法
25

26
ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=190))
27
c = ax.scontourf(da_anom['lon'], da_anom['lat'], corr_map[0],
28
                 cmap='RdBu_r')
29
ax.init_map(coastlines=True)
30
plt.colorbar(c, label='Correlation')
31
plt.title('EOF1 Correlation Map')
32
plt.show()

展开收起

奇异值分解（SVD）/ 最大协方差分析（MCA）#

导入#

1
import numpy as np
2
import xarray as xr
3
from sacpy import SVD, MCA  # MCA 是 SVD 的别名

`class SVD`#

SVD（奇异值分解）分析类，用于研究两个场之间的耦合关系。MCA 是其别名。

`SVD(data1, data2, complex=False)`#

作用：初始化 SVD 分析对象。

参数	类型	默认值	说明
`data1`	`np.ndarray` / `xr.DataArray`	必需	左场数据，形状 `(time, *space1)`
`data2`	`np.ndarray` / `xr.DataArray`	必需	右场数据，形状 `(time, *space2)`
`complex`	`bool`	`False`	是否使用复数类型

注意：data1 和 data2 的时间维度必须相等。

`solve()`#

作用：求解 SVD，计算协方差矩阵并分解。

无参数，无返回值。结果保存在对象属性中。

使用示例：

1
svd_obj = SVD(sst_anom, precip_anom)
2
svd_obj.solve()

`get_eign()`#

作用：返回协方差矩阵的奇异值。

返回：np.ndarray

使用示例：

1
eign = svd_obj.get_eign()

`get_varperc(npt)`#

作用：返回各 SVD 模态的方差解释比例（基于奇异值平方的占比）。

参数	类型	默认值	说明
`npt`	`int`	必需	返回的模式数量

公式：var_perc[i] = eign[i]^2 / sum(eign^2)

返回：np.ndarray，形状 (npt,)

使用示例：

1
vf = svd_obj.get_varperc(npt=5)

`get_pc(npt, norm="std")`#

作用：获取左场和右场的时间系数（expansion coefficients）。

参数	类型	默认值	说明
`npt`	`int`	必需	返回的模式数量
`norm`	`str`	`"std"`	标准化方式： - `"std"`：除以各自的标准差 - 其他值：不做标准化

返回：(pc_left, pc_right)，均为 np.ndarray，形状 (npt, time)

使用示例：

1
pc_left, pc_right = svd_obj.get_pc(npt=3, norm="std")

`get_pt(npt, norm="std")`#

作用：获取左场和右场的空间模态（SVD patterns）。

参数	类型	默认值	说明
`npt`	`int`	必需	返回的模式数量
`norm`	`str`	`"std"`	标准化方式。`"std"` 时乘以对应 PC 的标准差

返回：(patterns_left, patterns_right)，形状分别为 (npt, *space1) 和 (npt, *space2)

使用示例：

1
pt_left, pt_right = svd_obj.get_pt(npt=3)
2
# pt_left 形状: (3, lat1, lon1)
3
# pt_right 形状: (3, lat2, lon2)

`get_homogeneous_map(npt=3, norm="std")`#

作用：获取齐次相关图（homogeneous correlation map）—— 每个 SVD 模态的 PC 与自身场之间的线性回归图。

参数	类型	默认值	说明
`npt`	`int`	`3`	计算的模式数量
`norm`	`str`	`"std"`	标准化方式

返回：(map_left, map_right)，形状同 get_pt

使用示例：

1
homo_left, homo_right = svd_obj.get_homogeneous_map(npt=3)

`get_heterogeneous_map(npt=3, norm="std")`#

作用：获取非齐次相关图（heterogeneous correlation map）—— 左场 PC 与右场数据的回归图，以及右场 PC 与左场数据的回归图。

参数	类型	默认值	说明
`npt`	`int`	`3`	计算的模式数量
`norm`	`str`	`"std"`	标准化方式

返回：(map_left, map_right)

使用示例：

1
hetero_left, hetero_right = svd_obj.get_heterogeneous_map(npt=3)

注意：当前实现中 get_homogeneous_map 和 get_heterogeneous_map 逻辑相同，均返回 PC 与对应原始场的回归系数图。

`get_var_contribution(npt=3)`#

作用：计算各 SVD 模态对左场和右场总方差的贡献比例。

参数	类型	默认值	说明
`npt`	`int`	`3`	计算的模式数量

返回：(left_var, right_var)，均为 np.ndarray，形状 (npt,)

公式：var[i] = sum(PC_i^2) / sum(data^2)

使用示例：

1
left_contrib, right_contrib = svd_obj.get_var_contribution(npt=3)
2
print(f"SVD1 对左场方差贡献: {left_contrib[0]:.2%}")
3
print(f"SVD1 对右场方差贡献: {right_contrib[0]:.2%}")

完整示例：SVD 分析#

1
import numpy as np
2
import xarray as xr
3
import matplotlib.pyplot as plt
4
import cartopy.crs as ccrs
5
from sacpy import SVD, get_anom
6

7
# 1. 数据准备
8
sst = xr.open_dataset('sst.nc')['sst']
9
precip = xr.open_dataset('precip.nc')['precip']
10

11
sst_anom = get_anom(sst)         # (time, lat, lon)
12
precip_anom = get_anom(precip)   # (time, lat, lon)
13

14
# 2. SVD 分析
15
svd = SVD(sst_anom, precip_anom)
16
svd.solve()
17

18
# 3. 获取结果
19
pc_left, pc_right = svd.get_pc(npt=3, norm="std")
20
hetero_left, hetero_right = svd.get_heterogeneous_map(npt=2)
21

22
# 4. 绘图 - 第1 SVD 模态的非齐次相关图
23
import sacpy.Map
24

25
fig, axes = plt.subplots(1, 2, subplot_kw={
26
    'projection': ccrs.PlateCarree(central_longitude=190)
27
})
28

29
ax = axes[0]
30
c = ax.scontourf(sst_anom['lon'], sst_anom['lat'], hetero_left[0],
31
                 cmap='RdBu_r', extent='both')
32
ax.init_map(coastlines=True)
33
ax.set_title('Heterogeneous Map (SST ← Precip PC)')
34

35
ax = axes[1]
36
c = ax.scontourf(precip_anom['lon'], precip_anom['lat'], hetero_right[0],
37
                 cmap='RdBu_r', extent='both')
38
ax.init_map(coastlines=True)
39
ax.set_title('Heterogeneous Map (Precip ← SST PC)')
40

41
plt.show()

展开收起

线性回归#

导入#

1
import numpy as np
2
import xarray as xr
3
from sacpy import LinReg, MultLinReg
4
# 或直接使用底层函数
5
from sacpy.linger_cal import linear_reg, multi_linreg, multi_corr, partial_corr

`class LinReg`#

一元线性回归类。

`LinReg(x, y, neff=None)`#

作用：进行一元线性回归 y = slope * x + intercept。

参数	类型	默认值	说明
`x`	`np.ndarray` / `xr.DataArray`	必需	自变量（预测因子），形状 `(time,)`
`y`	`np.ndarray` / `xr.DataArray`	必需	因变量（响应变量），形状 `(time, *space)`
`neff`	`int` / `None`	`None`	有效自由度（用于 T 检验）。`None` 时使用 `time-2`

属性：

属性	类型	说明
`slope`	`np.ndarray` / `xr.DataArray`	回归斜率，形状 `(*space)`
`intcpt`	`np.ndarray` / `xr.DataArray`	截距，形状 `(*space)`
`corr`	`np.ndarray` / `xr.DataArray`	相关系数，形状 `(*space)`，值域 `[-1, 1]`
`p_value`	`np.ndarray` / `xr.DataArray`	p 值（双尾 T 检验），形状 `(*space)`

使用示例：

1
# 对 ENSO 指数与海温场做回归
2
enso_idx = enso_idx  # shape: (time,)
3
reg = LinReg(enso_idx, sst_anom)
4

5
# 获取回归系数
6
slope_map = reg.slope   # shape: (lat, lon)
7
corr_map = reg.corr     # 相关系数
8
pval_map = reg.p_value  # 显著性
9

10
# 若输入为 xr.DataArray，输出自动保留坐标

`LinReg.mask(threshold=0.05)`#

作用：按 p 值阈值掩码不显著区域。

参数	类型	默认值	说明
`threshold`	`float`	`0.05`	p 值阈值，超过此值的格点设为 NaN

无返回值，生成三个新属性：slope1、intcpt1、corr1。

使用示例：

1
reg.mask(threshold=0.05)
2
# 使用 reg.slope1 / reg.corr1 获取仅显著区域的回归图

`class MultLinReg`#

多元线性回归类。

`MultLinReg(x, y, cal_sim=True)`#

作用：进行多元线性回归 y = slope[0]*x[0] + slope[1]*x[1] + ... + intercept。

参数	类型	默认值	说明
`x`	`np.ndarray` / `xr.DataArray`	必需	因子矩阵，形状 `(time, N_factor)`
`y`	`np.ndarray` / `xr.DataArray`	必需	因变量，形状 `(time, *space)`
`cal_sim`	`bool`	`True`	是否在初始化时自动计算回归结果

属性：

属性	类型	说明
`slope`	`np.ndarray`	回归系数，形状 `(N_factor, *space)`
`intcpt`	`np.ndarray`	截距，形状 `(*space)`
`R`	`np.ndarray`	复相关系数，形状 `(*space)`
`pv_all`	`np.ndarray`	整体 F 检验 p 值，形状 `(*space)`
`pv_i`	`np.ndarray`	各因子 F 检验 p 值，形状 `(N_factor, *space)`

使用示例：

1
# 三个因子对海温的多元回归
2
factors = np.column_stack([enso, pdo, amo])  # (time, 3)
3
reg_m = MultLinReg(factors, sst_anom)
4

5
# ENSO 单独的回归系数场
6
enso_slope = reg_m.slope[0]     # 第1个因子的斜率场
7
enso_pval = reg_m.pv_i[0]       # 第1个因子的 p 值场

`MultLinReg.cal_corr()`#

作用：计算所有因子与因变量之间的相关系数矩阵。

返回：np.ndarray，形状 (*space, N_factor+1, N_factor+1)，最后两个维度为相关矩阵。

`MultLinReg.cal_paritial_corr(idx)`#

作用：计算第 idx 个因子与因变量的偏相关系数（排除其他因子影响）。

参数	类型	默认值	说明
`idx`	`int`	必需	因子的索引（0-based）

返回：np.ndarray，形状 (*space)

使用示例：

1
# 计算 ENSO 的偏相关（排除 PDO 和 AMO 的影响）
2
reg_m.cal_corr()  # 先计算相关系数矩阵
3
partial_r = reg_m.cal_paritial_corr(idx=0)

`class M2mLinReg`#

多变量对多变量的相关分析类。

`M2mLinReg(x, y)`#

作用：计算两组多变量时间序列之间的相关系数矩阵。

参数	类型	默认值	说明
`x`	`np.ndarray`	必需	形状 `(time, N_factor)`
`y`	`np.ndarray`	必需	形状 `(time, M_factor)`

属性：

属性	类型	说明
`corr`	`np.ndarray`	相关系数矩阵，形状 `(N_factor, M_factor)`
`p_value`	`np.ndarray`	p 值矩阵，形状 `(N_factor, M_factor)`

使用示例：

1
m2m = M2mLinReg(factors, pcs)  # factors: (time, 3), pcs: (time, 5)
2
print(m2m.corr)     # (3, 5) 相关系数矩阵
3
print(m2m.p_value)  # 显著性矩阵

`class SpaceCorr`#

空间相关类。

`SpaceCorr(x, y)`#

作用：计算两个同形状空间场之间的逐点相关系数。

参数	类型	默认值	说明
`x`	`np.ndarray`	必需	形状 `(time, *space)`
`y`	`np.ndarray`	必需	形状 `(time, *space)`

属性：

属性	类型	说明
`corr`	`np.ndarray`	逐点相关系数，形状 `(*space)`

底层函数#

这些函数是 LinReg 和 MultLinReg 的底层实现，可直接调用。

`linear_reg(x, y, neff=None)`#

等同 LinReg(x, y, neff)。返回 (slope, intcpt, corr, p_value)。

`multi_linreg(x, y)`#

等同 MultLinReg(x, y)。返回 (slope, intcpt, R, pv_all, pv_i)。

`partial_corr(x, y, idx, mul_corr=None)`#

等同 MultLinReg.cal_paritial_corr(idx)。

`multi_corr(x, y)`#

等同 MultLinReg.cal_corr()。

完整示例#

1
import numpy as np
2
import xarray as xr
3
import matplotlib.pyplot as plt
4
import cartopy.crs as ccrs
5
from sacpy import LinReg, MultLinReg
6
import sacpy.Map
7

8
# 一元回归 + 绘图
9
da = xr.open_dataset('sst.nc')['sst']
10
enso = np.random.randn(da.shape[0])
11

12
reg = LinReg(enso, da)
13
reg.mask(0.05)
14

15
ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=190))
16
c = ax.scontourf(da['lon'], da['lat'], reg.slope1, cmap='RdBu_r')
17
ax.sig_plot(da['lon'], da['lat'], reg.p_value, marker='..')
18
ax.init_map(coastlines=True)
19
plt.colorbar(c, label='Regression slope')
20
plt.title('ENSO Regression on SST (p<0.05 dotted)')
21
plt.show()

展开收起

显著性检验#

导入#

1
import numpy as np
2
import xarray as xr
3
from sacpy import STMV
4
# 或直接使用底层函数
5
from sacpy.SigTest import one_mean_test, two_mean_test

`class STMV`#

均值的显著性 T 检验类（Significance Test of Mean Value）。自动判断单样本或双样本检验。

`STMV(data1, data2=None, wrap=True, *param, **kwargs)`#

作用：对数据执行 T 检验。

参数	类型	默认值	说明
`data1`	`np.ndarray` / `xr.DataArray`	必需	第一组数据，形状 `(time, *space)`
`data2`	`np.ndarray` / `xr.DataArray` / `None`	`None`	第二组数据。`None` 时进行单样本 T 检验（与 0 比较）；否则进行双样本 T 检验
`wrap`	`bool`	`True`	是否将结果包装为 `xr.DataArray`（需输入为 DataArray）
`*param`	-	-	传递给 `scipy.stats.ttest_1samp` 或 `ttest_ind` 的额外参数

属性：

属性	类型	说明
`mean`	`np.ndarray` / `xr.DataArray`	单样本时为 `data1` 均值，双样本时为 `mean(data1) - mean(data2)`
`p_value`	`np.ndarray` / `xr.DataArray`	p 值，形状 `(*space)`

使用示例：

1
# 单样本检验：检验异常场是否显著偏离 0
2
stmv = STMV(sst_anom)
3
print(stmv.mean)     # 时间平均场
4
print(stmv.p_value)  # 显著性水平
5

6
# 双样本检验：两组数据均值差检验
7
stmv2 = STMV(sst_early, sst_late)
8
print(stmv2.mean)     # 均值差（late - early？实际是 early - late）
9
print(stmv2.p_value)  # 显著性

`STMV.get_original_data()`#

作用：获取原始输入数据。

返回：单样本时返回 data1，双样本时返回 (data1, data2)

`one_mean_test(data, expected_mean=None, *param)`#

作用：单样本 T 检验（底层函数）。检验 data 的均值是否等于 expected_mean。

参数	类型	默认值	说明
`data`	`np.ndarray` / `xr.DataArray`	必需	待检验数据，形状 `(time, *space)`
`expected_mean`	`np.ndarray` / `None`	`None`	期望均值。`None` 表示与 0 比较
`*param`	-	-	传递给 `scipy.stats.ttest_1samp`

返回：(origin_mean, pvalue)，origin_mean 为数据均值。

使用示例：

1
mean, pval = one_mean_test(sst_anom)

`two_mean_test(data1, data2, *param)`#

作用：双样本独立 T 检验（底层函数）。检验两组数据均值是否相等。

参数	类型	默认值	说明
`data1`	`np.ndarray` / `xr.DataArray`	必需	第一组数据，形状 `(time1, *space)`
`data2`	`np.ndarray` / `xr.DataArray`	必需	第二组数据，形状 `(time2, *space)`
`*param`	-	-	传递给 `scipy.stats.ttest_ind`

返回：(mean_diff, pvalue)，mean_diff = mean(data1) - mean(data2)。

使用示例：

1
mean_diff, pval = two_mean_test(sst_1950_1980, sst_1980_2010)

完整示例：年代际差异检验+绘图#

1
import numpy as np
2
import xarray as xr
3
import matplotlib.pyplot as plt
4
import cartopy.crs as ccrs
5
from sacpy import STMV, get_anom
6
import sacpy.Map
7

8
# 数据
9
sst = xr.open_dataset('sst.nc')['sst']
10
early = sst.sel(time=slice('1950', '1980'))
11
late = sst.sel(time=slice('1985', '2015'))
12

13
# 双样本 T 检验
14
stmv = STMV(late, early)
15

16
# 绘图
17
ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=190))
18
c = ax.scontourf(sst['lon'], sst['lat'], stmv.mean, cmap='RdBu_r')
19
ax.sig_plot(sst['lon'], sst['lat'], stmv.p_value, marker='..')
20
ax.init_map(coastlines=True)
21
plt.colorbar(c, label='SST Difference (late - early)')
22
plt.title('SST Change between 1950-1980 and 1985-2015')
23
plt.show()

展开收起

谱分析#

导入#

1
import numpy as np
2
from sacpy import Spectral, CrossSpectral

`class Spectral`#

单变量功率谱分析类（基于 Welch 方法 / WOSA）。

`Spectral(x, M_length, overlap=0.5, remove_trend=True, remove_annual=True, normalize_series=True, prewhiten=False)`#

作用：初始化谱分析对象并预处理时间序列。

参数	类型	默认值	说明
`x`	`np.ndarray`	必需	一维时间序列
`M_length`	`int`	必需	WOSA 分段长度，最好为 2 的幂
`overlap`	`float`	`0.5`	分段重叠比例。若数据按季节分割，建议设为 `0`
`remove_trend`	`bool`	`True`	是否去除线性趋势
`remove_annual`	`bool`	`True`	是否去除年循环（harmonic fit）
`normalize_series`	`bool`	`True`	是否标准化序列（方差=1）
`prewhiten`	`bool`	`False`	是否预白化处理

属性：

属性	类型	说明
`dfn`	`float`	谱的保守自由度估计（分子）
`dfd`	`float`	零假设的分母自由度
`ac_x`	`float`	预处理后序列的自相关系数

使用示例：

1
# 准备一维时间序列
2
ts = monthly_sst.mean(dim=('lon', 'lat')).values  # 长度为 N
3

4
# 初始化（保留趋势但去除年循环）
5
spec = Spectral(ts, M_length=64, remove_annual=True, remove_trend=False)

`Spectral.get_spectra(normalize_spectrum=True, detrend='linear', **kwargs)`#

作用：计算功率谱。

参数	类型	默认值	说明
`normalize_spectrum`	`bool`	`True`	是否将谱除以均值（便于比较）
`detrend`	`str`	`'linear'`	Welch 方法的去趋势设置
`**kwargs`	-	-	传递给 `scipy.signal.welch` 的额外参数

返回：(f, Pxx) — 频率数组和功率谱。

使用示例：

1
f, Pxx = spec.get_spectra()

`Spectral.get_red_noise(method='fit_theory')`#

作用：拟合红噪声谱。

参数	类型	默认值	说明
`method`	`str`	`'fit_theory'`	拟合方法： - `'fit_theory'`：基于自相关系数理论计算 - `'fit_data'`：对观测谱做曲线拟合

返回：np.ndarray，红噪声谱。

使用示例：

1
red_noise = spec.get_red_noise(method='fit_theory')

`Spectral.get_rs_sig(p_crit=0.99)`#

作用：获取基于红噪声理论的显著性水平曲线。

参数	类型	默认值	说明
`p_crit`	`float`	`0.99`	显著性水平（F 检验）

返回：np.ndarray，显著谱值阈值曲线。

使用示例：

1
sig_level = spec.get_rs_sig(p_crit=0.95)
2
# 功率谱高于 sig_level 的频率段为显著

`class CrossSpectral(Spectral)`#

交叉谱分析类，继承自 Spectral。

`CrossSpectral(x, y, M_length, overlap=0.5, ...)`#

作用：对两个时间序列进行交叉谱分析。

参数	类型	默认值	说明
`x`	`np.ndarray`	必需	第一组一维时间序列
`y`	`np.ndarray`	必需	第二组一维时间序列

其余参数同 Spectral.__init__。

新增属性：ac_y（y 序列的自相关系数）。

`CrossSpectral.get_spectra(normalize_spectrum=True, detrend='linear', **kwargs)`#

作用：计算两个序列各自的功率谱。

返回：(f, Pxx, Pyy)

`CrossSpectral.get_red_noise(method='fit_theory')`#

作用：拟合两个序列的红噪声谱。

返回：(rsx, rsy)

`CrossSpectral.get_rs_sig(p_crit=0.99)`#

作用：获取两个序列的显著谱阈值。

返回：(rsx_sig, rsy_sig)

`CrossSpectral.get_cross_spectra(detrend='linear', **kwargs)`#

作用：计算交叉谱（协方差谱、相位谱、凝聚谱）。

返回：(covariance, phase, coherence)

返回值	说明
`covariance`	协方差谱（cross-spectrum 实部）
`phase`	相位谱（角度制）
`coherence`	凝聚谱（0~1）

使用示例：

1
cov, phase, coh = cross_spec.get_cross_spectra()

`CrossSpectral.get_coh_sig(p_crit=0.99)`#

作用：获取凝聚谱的显著性水平。

参数	类型	默认值	说明
`p_crit`	`float`	`0.99`	显著性水平

返回：float，凝聚谱显著性阈值。

辅助函数#

`autocorr(x)`#

作用：计算时间序列的滞后-1 自相关系数。

参数	类型	默认值	说明
`x`	`np.ndarray`	必需	一维时间序列

返回：float

1
from sacpy.spectral import autocorr
2
ac = autocorr(ts)

完整示例：单变量谱分析#

1
import numpy as np
2
import matplotlib.pyplot as plt
3
from sacpy import Spectral
4

5
# 准备数据
6
ts = sst_anom.mean(dim=('lat', 'lon')).values  # 区域平均 SSTA
7

8
# 谱分析
9
spec = Spectral(ts, M_length=64, remove_annual=True)
10

11
# 计算谱
12
f, Pxx = spec.get_spectra()
13
red = spec.get_red_noise()
14
sig = spec.get_rs_sig(p_crit=0.95)
15

16
# 绘图
17
plt.figure(figsize=(10, 4))
18
plt.semilogx(1/f, f*Pxx, 'b-', linewidth=1.5, label='Power Spectrum')
19
plt.semilogx(1/f, f*red, 'r--', label='Red Noise')
20
plt.semilogx(1/f, f*sig, 'r:', linewidth=0.5, label='95% Significance')
21
plt.xlabel('Period')
22
plt.ylabel('Frequency x Power')
23
plt.legend()
24
plt.title('Power Spectrum')
25
plt.show()

展开收起

完整示例：交叉谱分析#

1
import numpy as np
2
import matplotlib.pyplot as plt
3
from sacpy import CrossSpectral
4

5
# 两个时间序列
6
ts1 = enso_index
7
ts2 = precip_index
8

9
cross = CrossSpectral(ts1, ts2, M_length=64)
10
f, Pxx, Pyy = cross.get_spectra()
11
cov, phase, coh = cross.get_cross_spectra()
12
coh_sig = cross.get_coh_sig(p_crit=0.95)
13

14
fig, axes = plt.subplots(3, 1, figsize=(10, 8), sharex=True)
15

16
axes[0].semilogx(1/f, f*Pxx, label='x')
17
axes[0].semilogx(1/f, f*Pyy, label='y')
18
axes[0].set_ylabel('Power')
19
axes[0].legend()
20

21
axes[1].semilogx(1/f, coh)
22
axes[1].axhline(coh_sig, color='r', linestyle='--', label='95% Sig')
23
axes[1].set_ylabel('Coherence')
24
axes[1].set_ylim(0, 1)
25

26
axes[2].semilogx(1/f, phase)
27
axes[2].set_ylabel('Phase (°)')
28
axes[2].set_xlabel('Period')
29

30
plt.suptitle('Cross-Spectral Analysis')
31
plt.show()

展开收起

地图绘图#

导入#

绘图扩展通过 import sacpy.Map 即可自动注册到 GeoAxesSubplot 上：

1
import matplotlib.pyplot as plt
2
import cartopy.crs as ccrs
3
import cartopy.feature as cfeature
4
import numpy as np
5
import xarray as xr
6
import sacpy.Map  # 注册所有绘图扩展方法

同时也可直接使用工具函数：

1
from sacpy.Map import get_levels
2
from sacpy.settings import Map as MapSettings

绘图风格配置#

导入 sacpy.Map 时会自动设置：

字体：Times New Roman
默认 colormap：RdBu_r

如需自定义，可在导入后修改 matplotlib 的 rcParams。

`get_levels(data, percentile=98, num_level=13, zero_sym=True)`#

作用：根据数据分布自动生成等值线/填色层级。

参数	类型	默认值	说明
`data`	`np.ndarray`	必需	待绘制数据
`percentile`	`int`	`98`	最高/最低值的百分位数（截断极端值）
`num_level`	`int`	`13`	层级数量
`zero_sym`	`bool`	`True`	是否以零为中心对称

返回：np.ndarray，等间距的层级数组。

使用示例：

1
levels = get_levels(corr_map, percentile=95, num_level=11, zero_sym=True)

GeoAxesSubplot 扩展方法#

sacpy.Map 对 cartopy.mpl.geoaxes.GeoAxesSubplot 进行了 monkey-patch，新增以下方法：

`scontourf(*args, **kwargs)`#

作用：智能填色图（contourf）。自动处理层级、colormap 和坐标转换。

参数	类型	说明
`*args`	1~4 个参数	支持多种传入方式： - `(Z)`：仅数据（需后续设置坐标） - `(Z, levels)` - `(x, y, Z)`：经纬度+数据 - `(x, y, Z, levels)`

新增的 kwargs：

参数	类型	默认值	说明
`percentile`	`int`	`98`	自动层级时的百分位
`num_level`	`int`	`13`	自动层级时的层级数
`zero_sym`	`bool`	`True`	层级是否零对称
`extend`	`str`	`"both"`	色棒延伸方向
`cmap`	`str`	`"RdBu_r"`	colormap
`transform`	`crs`	`PlateCarree()`	数据坐标系统

返回：matplotlib.contour.QuadContourSet

使用示例：

1
ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=190))
2
c = ax.scontourf(lon, lat, sst_map)
3
# 或自动层级
4
c = ax.scontourf(lon, lat, sst_map, percentile=95, num_level=11)

`spcolormesh(*args, **kwargs)`#

作用：智能 pcolormesh。参数与 scontourf 类似，但使用 vmin/vmax 控制色彩范围。

返回：matplotlib.collections.QuadMesh

使用示例：

1
m = ax.spcolormesh(lon, lat, data, cmap='coolwarm')

`scontour(*args, **kwargs)`#

作用：智能等值线（contour）。自动添加 transform=ccrs.PlateCarree()。

返回：matplotlib.contour.QuadContourSet

`squiver(*args, **kwargs)`#

作用：智能风场图（quiver）。支持抽样步长。

新增 kwargs：

参数	类型	默认值	说明
`stepx`	`int`	`1`	x 方向抽样步长
`stepy`	`int`	`1`	y 方向抽样步长

使用示例：

1
# 每5个格点画一个箭头
2
ax.squiver(lon, lat, u, v, stepx=5, stepy=5)

`init_map(same_size=True, coastlines=True, draw_ticks=True, **kwargs)`#

作用：快速初始化地图（画海岸线 + 设置刻度 + 固定宽高比）。

参数	类型	默认值	说明
`same_size`	`bool`	`True`	是否设置 `set_aspect("auto")`
`coastlines`	`bool`	`True`	是否绘制海岸线
`draw_ticks`	`bool`	`True`	是否自动绘制刻度

额外传递给 draw_ticks 的 kwargs：

参数	类型	默认值	说明
`stepx`	`int` / `None`	自动	大刻度 X 步长
`stepy`	`int` / `None`	自动	大刻度 Y 步长
`smallx`	`int` / `None`	自动	小刻度 X 步长
`smally`	`int` / `None`	自动	小刻度 Y 步长

使用示例：

1
ax = plt.axes(projection=ccrs.PlateCarree())
2
ax.scontourf(lon, lat, data)
3
ax.init_map()  # 自动海岸线+刻度

`draw_ticks(extend, stepx=None, stepy=None, ...)`#

作用：为地图添加经纬度刻度。

参数	类型	默认值	说明
`extend`	`list`	必需	`[xmin, xmax, ymin, ymax]`
`stepx` / `stepy`	`int` / `None`	自动	大刻度步长
`smallx` / `smally`	`int` / `None`	自动	小刻度步长

使用示例：

1
ax.draw_ticks([-180, 180, -90, 90], stepx=30, stepy=15)

`sig_plot(x, y, pvalue, thrshd=0.05, marker="..", color=None)`#

作用：显著性打点（在显著区域叠加点/影线）。

参数	类型	默认值	说明
`x`	`np.ndarray`	必需	经度
`y`	`np.ndarray`	必需	纬度
`pvalue`	`np.ndarray`	必需	p 值场，形状同数据
`thrshd`	`float`	`0.05`	显著性阈值
`marker`	`str`	`".."`	影线样式（hatch pattern）
`color`	`str` / `None`	`None`	打点颜色

使用示例：

1
ax.scontourf(lon, lat, data)
2
ax.sig_plot(lon, lat, p_value, marker='..', color='k')

sig_plot 同样注册到了 matplotlib.axes.Axes（非地图 Axes 可用，不带 transform）。

`xr.DataArray.splot(ax=None, label=0, projection=None, kw1={}, kw2={})`#

作用：DataArray 的快速绘图方法（需 2D 数据）。

参数	类型	默认值	说明
`ax`	`Axes` / `None`	`None`	坐标轴。`None` 自动创建
`label`	`int`	`0`	经纬度命名：`0` = `lon`/`lat`，`1` = `longitude`/`latitude`
`projection`	`crs` / `None`	`None`	地图投影。`None` 自动使用 PlateCarree
`kw1`	`dict`	`{}`	传递给 `scontourf` 的参数
`kw2`	`dict`	`{}`	传递给 `init_map` 的参数

返回：(m, ax) — 填色图对象和坐标轴。

使用示例：

1
da = sst.isel(time=0)  # 2D: (lat, lon)
2
m, ax = da.splot(kw1={'cmap': 'coolwarm', 'extend': 'both'})
3
plt.title('SST')
4
plt.show()

`class Map`（配置）#

sacpy.settings.Map 提供了常用 cartopy 投影的字典：

1
from sacpy.settings import Map
2

3
proj = Map.projection_dict['Robinson'](central_longitude=180)
4
proj = Map.projection_dict['Orthographic'](central_longitude=-20, central_latitude=60)

支持的投影名称：Robinson, PlateCarree, Mollweide, Orthographic, Mercator, Miller, LambertConformal, NorthPolarStereo, SouthPolarStereo 等 30+ 种。

完整示例#

1
import numpy as np
2
import xarray as xr
3
import matplotlib.pyplot as plt
4
import cartopy.crs as ccrs
5
import cartopy.feature as cfeature
6
import sacpy.Map
7
from sacpy.Map import get_levels
8

9
# 准备数据
10
da = xr.open_dataset('sst.nc')['sst'].isel(time=0)  # 2D 场
11
lon, lat = da['lon'].values, da['lat'].values
12

13
# 创建地图
14
proj = ccrs.PlateCarree(central_longitude=180)
15
fig, axes = plt.subplots(2, 2, figsize=(14, 8),
16
                         subplot_kw={'projection': proj})
17
axes = axes.flatten()
18

19
# 子图1：智能填色 + 陆地 + 显著性打点
20
ax = axes[0]
21
c = ax.scontourf(lon, lat, da.values, cmap='RdBu_r',
22
                 percentile=98, num_level=13)
23
ax.add_feature(cfeature.LAND, facecolor='lightgray')
24
ax.init_map(coastlines=False)
25
plt.colorbar(c, ax=ax, label='SST')
26

27
# 子图2：pcolormesh
28
ax = axes[1]
29
m = ax.spcolormesh(lon, lat, da.values, cmap='coolwarm')
30
ax.init_map()
31
plt.colorbar(m, ax=ax)
32

33
# 子图3：使用 DataArray.splot
34
ax = axes[2]
35
m, _ = da.splot(ax=ax, kw1={'cmap': 'RdBu_r'})
36
ax.set_title('splot method')
37

38
# 子图4：不同投影
39
ax = axes[3]
40
proj2 = ccrs.Orthographic(central_longitude=180, central_latitude=0)
41
ax.remove()
42
ax = fig.add_subplot(2, 2, 4, projection=proj2)
43
c = ax.scontourf(lon, lat, da.values, cmap='RdBu_r')
44
ax.coastlines()
45
ax.set_global()
46
plt.colorbar(c, ax=ax, shrink=0.6)
47

48
plt.tight_layout()
49
plt.show()

展开收起

数据处理工具#

导入#

1
from sacpy import get_anom, spec_moth_dat, spec_moth_yrmean
2
from sacpy import convert_lon, reverse_lon, field_corr, autocorr, sig_scatter
3
from sacpy.Util import gradient_da, shp_mask, gradient_array, ddof, rewapper
4
from sacpy.linger_cal import linear_reg, multi_linreg, multi_corr, partial_corr

`get_anom(DaArray, method=0, freq="month", time_coords="time")`#

作用：计算气候数据的距平（anomaly）。

参数	类型	默认值	说明
`DaArray`	`xr.DataArray`	必需	输入数据，形状 `(time, *space)`
`method`	`int`	`0`	距平计算方法： - `0`：减去对应月份/日期的多年平均值 - `1`：去除对应月份/日期的线性趋势
`freq`	`str`	`"month"`	时间频率：`"month"` 或 `"day"`
`time_coords`	`str`	`"time"`	时间坐标名称

返回：xr.DataArray，距平场。

使用示例：

1
sst_anom = get_anom(sst, method=0, freq="month")

`spec_moth_dat(DaArray, months)`#

作用：提取特定月份的数据。

参数	类型	默认值	说明
`DaArray`	`xr.DataArray`	必需	输入数据
`months`	`list` / `str`	必需	月份列表 `[12, 1, 2]` 或季节名称 `"DJF"`, `"MAM"`, `"JJA"`, `"SON"`

返回：xr.DataArray，仅含指定月份的数据。

使用示例：

1
djf_sst = spec_moth_dat(sst, "DJF")       # 冬季数据
2
jja_sst = spec_moth_dat(sst, [6, 7, 8])   # 夏季数据

`spec_moth_yrmean(DaArray, months)`#

作用：提取特定月份数据并按年求平均。

参数	类型	默认值	说明
`DaArray`	`xr.DataArray`	必需	输入数据
`months`	`list` / `str`	必需	同 `spec_moth_dat`

返回：xr.DataArray，每年一个值（季节均值）。

使用示例：

1
djf_mean = spec_moth_yrmean(sst, "DJF")  # 每年一个冬季平均
2
# 时间坐标变为年份

`convert_lon(lon)`#

作用：将经度从 [0, 360] 转换为 [-180, 180]。

参数	类型	默认值	说明
`lon`	`np.ndarray`	必需	经度数组

返回：np.ndarray

`reverse_lon(lon)`#

作用：将经度从 [-180, 180] 转换为 [0, 360]。

`field_corr(field1, field2)`#

作用：计算两个时空场的逐空间点相关系数。

参数	类型	默认值	说明
`field1`	`np.ndarray`	必需	形状 `(time, *space)`
`field2`	`np.ndarray`	必需	形状 `(time, *space)`，时间维度须与 field1 相同

返回：np.ndarray，逐点相关系数，形状 (*space)。

使用示例：

1
corr_map = field_corr(sst, precip)

`autocorr(x, lags)`#

作用：计算多维数据的滞后自相关（2D 输入，第一维为时间）。

参数	类型	默认值	说明
`x`	`np.ndarray`	必需	形状 `(time, *space)`
`lags`	`int`	必需	滞后期数

返回：np.ndarray，形状 (*space)。

注意：此为 Util.autocorr（带 lags 参数的多维版本），与 spectral.autocorr（一维滞后-1）不同。

`sig_scatter(ax, x, y, p, threshold=0.05, **kwargs)`#

作用：绘制显著散点图，不显著的点被遮蔽。

参数	类型	默认值	说明
`ax`	`Axes`	必需	matplotlib 坐标轴
`x`	`np.ndarray`	必需	1D 数组
`y`	`np.ndarray`	必需	1D 数组
`p`	`np.ndarray`	必需	p 值数组
`threshold`	`float`	`0.05`	显著性阈值

返回：PathCollection（散点图对象）。

使用示例：

1
sig_scatter(ax, enso, precip, p_values, threshold=0.05, color='red', marker='o')

`gradient_da(da, dim, method=0, delta=None)`#

作用：计算 DataArray 沿某维度的梯度（差分）。

参数	类型	默认值	说明
`da`	`xr.DataArray`	必需	输入数据
`dim`	`str`	必需	求梯度的维度（如 `"lat"`, `"lon"`）
`method`	`int`	`0`	`0`：中心差分（默认）。`1`：前向差分
`delta`	`float` / `None`	`None`	网格间距（m）。`None` 时自动根据 `dim` 估算

返回：xr.DataArray。

使用示例：

1
dT_dy = gradient_da(sst, "lat")  # 经向梯度

`shp_mask(shp, Dataarray, lat='lat', lon='lon')`#

作用：用 shapefile 掩码 DataArray（保留多边形内部区域）。

参数	类型	默认值	说明
`shp`	`GeoDataFrame`	必需	geopandas 读入的 shapefile
`Dataarray`	`xr.DataArray`	必需	待掩码数据
`lat`	`str`	`"lat"`	纬度坐标名
`lon`	`str`	`"lon"`	经度坐标名

返回：xr.DataArray，区域外的格点设为 NaN。

需要：geopandas、rioxarray、shapely

使用示例：

1
import geopandas as gpd
2
shp = gpd.read_file('china.shp')
3
sst_china = shp_mask(shp, sst)

`rewapper(data, origin_dataarray, drop_dims=None)`#

作用：将计算结果重新包装为 xr.DataArray，保留原始坐标信息。

参数	类型	默认值	说明
`data`	`np.ndarray`	必需	待包装数据
`origin_dataarray`	`xr.DataArray`	必需	原始 DataArray（用于提取坐标和维度）
`drop_dims`	`str` / `list` / `None`	`None`	需删除的维度（如原始数据的 `time` 维已被压缩）

注意：此函数处于早期开发阶段，可能不够稳定。

完整示例：数据处理流水线#

1
import xarray as xr
2
import numpy as np
3
from sacpy import get_anom, spec_moth_dat, spec_moth_yrmean, convert_lon
4

5
# 加载数据
6
ds = xr.open_dataset('era5_monthly.nc')
7

8
# 经度转换（0-360 → -180~180）
9
ds = ds.assign_coords(lon=convert_lon(ds['lon'].values)).sortby('lon')
10

11
# 计算距平
12
t_anom = get_anom(ds['t2m'], method=0, freq='month')
13

14
# 提取冬季并计算年平均值
15
djf_t = spec_moth_yrmean(t_anom, "DJF")  # 每年冬季平均
16

17
# 提取夏季
18
jja_t = get_anom(spec_moth_dat(ds['t2m'], "JJA"))
19

20
print(djf_t)

展开收起

气象数据处理

Wed, 15 Jul 2026 00:00:00 GMT

数据处理方法参考#

本文档汇总了气象气候数据分析中常用的数据处理方法，包括 NetCDF 文件读写、xarray 数据集操作和常用统计计算。

一、NetCDF 文件读取#

1.1 使用 netCDF4 库#

1
from netCDF4 import Dataset, num2date
2

3
f = Dataset('sst.mnmean.nc')          # 打开文件
4
sst = f.variables['sst'][:]            # 读取变量数组
5
lon = f.variables['lon'][:]            # 读取经度
6
lat = f.variables['lat'][:]            # 读取纬度
7
time = f.variables['time']             # 获取时间变量对象
8
time = num2date(time[:], time.units, calendar='standard')
9
                                        # 将数值时间转为datetime对象

关键函数参数说明：

函数	参数	说明
`Dataset(path)`	`path`	NetCDF 文件路径（字符串）
`f.variables[name]`	`name`	变量名，可通过 `f.variables.keys()` 查看所有变量
`num2date(times, units, calendar)`	`times`	时间数值数组
	`units`	时间单位，如 `'days since 1800-01-01'`
	`calendar`	日历类型：`'standard'`, `'360_day'`, `'noleap'` 等

注意事项：

用 [:] 将所有数据加载到内存，大文件可能耗时
num2date 返回的是 datetime.datetime 对象列表，可转为 [dt.datetime(x.year,x.month,x.day) for x in time]

1.2 使用 xarray 库（推荐）#

1
import xarray as xr
2

3
ds = xr.open_dataset('sst.mnmean.nc')  # 打开数据集
4
sst = ds['sst']                         # 获取 DataArray
5
lon = ds['lon']                         # 坐标自动关联
6
lat = ds['lat']

xarray 的优势：

自动管理维度坐标，数据自带经纬度和时间标签
支持标签索引（.sel(), .loc[], .isel()）
支持分组运算（.groupby()）
惰性加载，节省内存

二、数据选取与切片#

2.1 xarray 时间选取#

1
# 按时间范围选取（字符串切片）
2
sst = ds['sst'].sel(time=slice('1950', '2020'))
3

4
# 按具体日期选取
5
sst.loc['1997-12-01', :, :]            # 选取某一时刻
6

7
# 按时间范围选取（等间距切片）
8
nino34.loc['1950-12-01':'2019-12-01':12]  # 每隔12步取一次

2.2 xarray 空间选取#

1
# 按经纬度范围选取
2
nino34 = ds.sst.loc[:, 5:-5, 190:240]   # lat: 5S~5N, lon: 190~240
3
TNA    = ds.sst.loc[:, 25:5, 290:350]   # lat: 5N~25N, lon: 290~350
4
sst_trop = sst.loc[30:-30, 120:300]     # 热带区域

2.3 垂直层级选取#

对于四维数据 (time, level, lat, lon)，如位势高度场，需先选取特定气压层：

1
hgt500 = hgt.sel(level=500)   # 选择 500 hPa 层

参数	说明
`level`	气压层级，常见值：1000, 850, 500, 200, 100 hPa 等

三维数据 (time, lat, lon) 如 SST、T2m 无此维度，跳过此步骤。

2.4 xarray 按月份/季节选取#

1
# 方法一：使用 time.month 布尔判断
2
hgt_jan = hgt_range.sel(time=hgt_range['time.month'] == 1)
3

4
# 方法二：使用 dt 访问器（推荐）
5
hgt_jan = hgt_range.sel(time=hgt_range.time.dt.month == 1)
6

7
# 方法三：跨月筛选（如冬季 12, 1, 2 月）
8
import numpy as np
9
SEASON = [12, 1, 2]
10
months = hgt500['time'].dt.month
11
winter_mask = np.isin(months, SEASON)
12
hgt_winter = hgt500.sel(time=winter_mask)
13

14
# 方法四：选取夏季并按年求平均
15
summer_months = [6, 7, 8]
16
summer_t2m = t2m.sel(time=t2m['time.month'].isin(summer_months))
17
summer_t2m = summer_t2m.groupby('time.year').mean(dim='time')

展开收起

方法	关键函数	说明
`['time.month'] == 1`	直接索引	按月份属性做布尔判断
`.time.dt.month`	dt 访问器	更规范的写法，IDE 支持自动补全
`np.isin(months, [12,1,2])`	numpy isin	跨月筛选，适合跨年季节

2.5 numpy 切片技巧#

1
# 等间距抽取（每12个月取一次，从第12个元素开始）
2
nino34_DJF = (np.array(nino34[11:-11:12]) +   # 12月 (索引11开始)
3
              np.array(nino34[12::12]) +       # 1月  (索引12开始)
4
              np.array(nino34[13::12])) / 3    # 2月  (索引13开始)

2.6 最近邻格点选取#

选取距离指定经纬度最近的格点值：

1
z55_20 = hgt500_jan.sel(lat=55, lon=20, method='nearest')

参数	说明
`lat=55, lon=20`	目标坐标
`method='nearest'`	选取最近邻格点（还支持 `'pad'`, `'bfill'`, `'ffill'` 等）

2.7 时间插值与多变量对齐#

当多个变量的时间轴不完全一致时，需要对齐：

1
# 插值到新时间坐标（将 hgt 插值到 index 的时间轴上）
2
hgt500 = hgt500.interp(time=index_da['time'])
3

4
# 按精确时间轴对齐两个 DataArray
5
hgt_winter, wp_winter = xr.align(hgt_winter, wp_winter, join='exact')
6

7
# 取时间交集
8
start_time = max(wp_da['time'].values[0], hgt500['time'].values[0])
9
end_time   = min(wp_da['time'].values[-1], hgt500['time'].values[-1])
10
wp_da   = wp_da.sel(time=slice(start_time, end_time))
11
hgt500  = hgt500.sel(time=slice(start_time, end_time))

函数	参数	说明
`.interp(time=...)`	`time`	目标时间坐标，将数据插值到新时间轴上
`xr.align(a, b, join)`	`a, b`	需要对齐的 DataArray
	`join='exact'`	只保留时间完全相同的部分；`'outer'`取并集，`'inner'`取交集

三、常用统计计算#

3.1 气候态与距平#

方法一：自定义 annave 函数（xarray）#

1
def annave(var):
2
    var = var.groupby('time.month')      # 按月份分组
3
    var_clim = var.mean(dim='time')      # 逐月气候态平均
4
    var_anom = var - var_clim            # 距平 = 原始值 - 气候态
5
    return var_anom, var_clim

步骤	函数/方法	参数	说明
分组	`var.groupby('time.month')`	`'time.month'`	按月份分组（1~12月）
均值	`.mean(dim='time')`	`dim='time'`	沿时间维求均值，得到12个月的气候态
距平	`var - var_clim`	—	xarray 自动按月份广播匹配

方法二：使用 sacpy 库#

1
import sacpy as scp
2

3
sst = scp.get_anom(sst, method=1)

参数	说明
`sst`	输入 DataArray（维度为 time × lat × lon）
`method=1`	方法1：逐月去气候态（去季节循环）

3.2 区域性平均（指数计算）#

1
# Nino3.4 指数：5°S–5°N, 170°W–120°W (即 190°E–240°E)
2
nino34 = sst.loc[:, 5:-5, 190:240].mean(dim=['lat', 'lon'])
3

4
# Nino1+2 指数：0°–10°S, 90°W–80°W (即 270°E–280°E)
5
nino12 = sst.loc[:, 10:0, 270:280].mean(dim=['lat', 'lon'])
6

7
# TNA 指数（热带北大西洋）：5°N–25°N, 70°W–10°W (即 290°E–350°E)
8
TNA = sst.loc[:, 25:5, 290:350].mean(dim=['lat', 'lon'])

.mean() 参数说明：

参数	说明
`dim=['lat', 'lon']`	沿经度和纬度方向求平均，得到一维时间序列

3.3 气候态极值#

1
clim_mean = nino34.groupby('time.month').mean('time')  # 逐月气候态均值
2
clim_max  = nino34.groupby('time.month').max('time')   # 逐月最大值
3
clim_min  = nino34.groupby('time.month').min('time')   # 逐月最小值
4

5
yerr_upper = clim_max - clim_mean   # 误差条上限
6
yerr_lower = clim_mean - clim_min   # 误差条下限

3.4 季节平均（处理跨年问题）#

冬季 DJF（12月、1月、2月）跨越两个年份，不能用 groupby('time.season') 简单处理。正确做法：

1
# 方法一：手动索引（推荐，最清晰）
2
nino34_DJF = (np.array(nino34.loc['1950-12-01':'2019-12-01':12]) +
3
              np.array(nino34.loc['1951-01-01':'2020-01-01':12]) +
4
              np.array(nino34.loc['1951-02-01':'2020-02-01':12])) / 3
5

6
# 方法二：按位置索引（需假设数据从1月开始，无缺测）
7
nino34_DJF = (np.array(nino34[11:-11:12]) +   # 12月
8
              np.array(nino34[12::12]) +       # 1月
9
              np.array(nino34[13::12])) / 3    # 2月
10

11
# 方法三：混合 groupby（取不同年份的月份再平均）
12
nino34_DJF_2 = (np.array(nino34.loc['1950':'2019'].groupby('time.month')[12]) +
13
                np.array(nino34.loc['1951':'2020'].groupby('time.month')[1]) +
14
                np.array(nino34.loc['1951':'2020'].groupby('time.month')[2])) / 3

注意方法二对索引位置有严格要求，方法一和方法三更稳健。

3.5 时间平均#

1
# xarray 方式
2
sst_mean = sst.mean(dim='time')
3

4
# numpy 方式
5
sst = np.mean(sst, axis=0)   # 沿第0轴（时间）求均值

3.6 纬度加权（EOF 面积权重）#

地球是球面，高纬度的格点面积更小，EOF 分析需进行面积加权：

1
coslat = np.cos(np.deg2rad(lat)).to_numpy()
2
wgts = np.sqrt(coslat)[..., np.newaxis]   # 权重矩阵 (lat, 1)
3

4
solver = Eof(ssta, weights=wgts)           # 传入权重

步骤	说明
`np.deg2rad(lat)`	纬度转弧度
`np.cos(...)`	计算余弦权重
`np.sqrt(...)`	开方（因为 EOF 会对变量本身做内积）
`[..., np.newaxis]`	增加一维以便广播 (lat) → (lat, 1)

3.7 纬向平均#

仅沿经度方向求平均，常用于分析物理量的南北分布：

1
zonal_mean = hgt.mean(dim='lon')   # 结果维度 (time, lat)

3.8 标准化 (z-score)#

将时间序列减去均值后除以标准差，使序列均值为 0、标准差为 1：

1
index_std = (index - index.mean(dim='time')) / index.std(dim='time')

步骤	说明
`index.mean(dim='time')`	时间均值
`index.std(dim='time')`	时间标准差
`(x - mean) / std`	标准化公式

3.9 DataArray 四则运算#

xarray 的 DataArray 之间可以直接进行加减乘除，维度自动对齐：

1
# 组合指数计算（如 EU 遥相关指数）
2
EU_index = -0.25 * z55_20 + 0.50 * z55_75 - 0.25 * z40_145
3

4
# 距平也可以直接用减法
5
hgt_anom = hgt - hgt.mean(dim='time')
6

7
# 纬向偏差
8
zonal_anom = hgt - hgt.mean(dim='lon')

四、线性回归#

4.1 手动实现（最小二乘法）#

1
import numpy as np
2

3
def LinearRegression(var, ts):
4
    s = var.shape                                    # (time, lat, lon)
5
    var = np.array(var).reshape(s[0], -1)            # → (time, npts)
6
    mask = np.isnan(np.mean(var, axis=0))            # 掩膜 NaN 点位
7
    X = np.vstack((ts, np.ones(len(ts)))).T          # 设计矩阵 (time, 2)
8
    r, *res = np.linalg.lstsq(X, var[:, ~mask], rcond=None)  # 最小二乘
9
    reg_map = np.zeros((2, s[1] * s[2])) * np.nan
10
    reg_map[:, ~mask] = r                            # 结果回填
11
    reg_map = np.reshape(reg_map, (2, s[1], s[2]))   # → (2, lat, lon)
12
    return reg_map                                   # [0]=斜率, [1]=截距

核心函数 np.linalg.lstsq 参数说明：

参数	说明
`X`	设计矩阵，形状 `(n_samples, n_features)`，第一列为指数，第二列为全1
`var[:, ~mask]`	目标变量（已去除 NaN 格点），形状 `(n_samples, n_points)`
`rcond=None`	奇异值截断阈值，`None` 使用默认机器精度

返回值： r[0, :] 为回归系数（斜率），r[1, :] 为截距。

注意：线性回归 Y = aX + b，X 的第一列为 ts，r[0] 是斜率 a。

4.2 使用 sacpy 库#

1
import sacpy as scp
2

3
LinReg = scp.LinReg(nino34, sst)
4
slope = LinReg.slope          # 回归系数场
5
p_value = LinReg.p_value      # p 值场

4.3 多元线性回归#

1
X = np.vstack((nino34, TNA, np.ones(len(nino34)))).T   # 两个自变量
2
r, *res = np.linalg.lstsq(X, y[:, ~mask], rcond=None)
3
# r[0] = Nino34 的回归系数, r[1] = TNA 的回归系数, r[2] = 截距

4.4 使用 scipy.stats.linregress 逐点回归#

比 linalg.lstsq 更简洁，一步返回斜率、截距、相关系数、p 值、标准误：

1
from scipy import stats
2

3
def linregress_1d(y, x):
4
    a, b, r, p, std = stats.linregress(x, y)
5
    return np.array([a, b, r, p, std])

返回值	说明
`a`	回归系数（斜率）
`b`	截距
`r`	相关系数
`p`	p 值（双尾）
`std`	斜率的标准误差

4.5 使用 xr.apply_ufunc 逐格点批量回归#

apply_ufunc 是 xarray 推荐的逐格点应用函数方式，支持 dask 并行：

1
reg = xr.apply_ufunc(
2
    linregress_1d,
3
    hgt_anom, index_da,
4
    input_core_dims=[['time'], ['time']],   # 沿 time 维做回归
5
    output_core_dims=[['stat']],            # 输出新维度 stat
6
    vectorize=True,                         # 逐格点向量化
7
    dask='parallelized',                    # dask 并行（可选）
8
    output_dtypes=[float],
9
    output_sizes={'stat': 5},               # stat 维度长度=5
10
)
11

12
beta = reg.sel(stat=0)     # 回归系数（斜率）
13
corr = reg.sel(stat=2)     # 相关系数
14
pval = reg.sel(stat=3)     # p 值
15
sig  = pval < 0.05          # 显著性检验

展开收起

参数	说明
`linregress_1d`	自定义的格点回归函数
`hgt_anom`	输入场 (time, lat, lon)
`index_da`	回归指数 (time,)
`input_core_dims`	指定沿哪些维度做回归，`[['time'], ['time']]` 表示第一个参数 hgt_anom 沿 time，第二个参数 index 也沿 time
`output_core_dims`	输出新维度名
`vectorize=True`	自动循环 lat, lon 维度
`output_sizes`	新维度的长度

五、合成分析与显著性检验#

5.1 合成分析（Composite Analysis）#

1
from scipy import stats
2

3
el_nino_years = [1983, 1987, 1992, 1995, 1998, 2010, 2016]
4
la_nina_years = [1985, 1989, 1999, 2000, 2008, 2011]
5

6
# 提取夏季数据
7
summer_months = [6, 7, 8]
8
summer_t2m = t2m.sel(time=t2m['time.month'].isin(summer_months)) \
9
                .groupby('time.year').mean(dim='time')
10

11
# 挑选年份并计算合成平均
12
el_nino_composite = summer_t2m.sel(year=el_nino_years).mean(dim='year')
13
la_nina_composite = summer_t2m.sel(year=la_nina_years).mean(dim='year')

5.2 单样本 t 检验 — stats.ttest_1samp#

检验合成距平是否显著偏离 0（零假设：总体均值为 0）：

1
from scipy import stats
2

3
_, p_values = stats.ttest_1samp(composite_data, popmean=0.0, axis=0)
4

5
alpha = 0.05
6
significant = p_values < alpha

stats.ttest_1samp 参数说明：

参数	说明
`composite_data`	样本数据，形状 `(n_samples, lat, lon)`
`popmean`	零假设的总体均值，检验距平时通常设为 `0.0`
`axis`	沿哪个轴做检验，`axis=0` 表示在第一个维度（样本）上检验

返回值：

返回值	类型	说明
`statistic`	ndarray	t 统计量
`pvalue`	ndarray	p 值（双尾），形状与输入除去 `axis` 一致

5.3 双样本 t 检验 — stats.ttest_ind#

比较两组样本的差异是否显著（如 El Nino vs La Nina 合成场）：

1
_, p_values = stats.ttest_ind(group1, group2, axis=0)

参数	说明
`group1`	第一组样本，形状 `(n1, lat, lon)`
`group2`	第二组样本，形状 `(n2, lat, lon)`
`axis`	沿哪个维度做检验

5.4 显著性可视化（地图打点）#

1
lon2d, lat2d = np.meshgrid(lon, lat)
2
ax.scatter(lon2d[significant], lat2d[significant],
3
           color='grey', s=2, transform=ccrs.PlateCarree())

六、数据重塑与掩膜#

6.1 reshape 二维数据#

1
sst = sst.to_numpy()
2
y = np.reshape(sst, (sst.shape[0], -1))   # (time, lat*lon)
3
# 回归计算后...
4
map = np.reshape(map, (sst.shape[1], sst.shape[2]))   # 恢复为 (lat, lon)

6.2 NaN 掩膜#

1
mask = np.isnan(np.mean(y, axis=0))       # 找出含 NaN 的格点
2
r, *res = np.linalg.lstsq(X, y[:, ~mask], rcond=None)  # 只对有效格点回归
3

4
# 创建全 NaN 数组，回填计算结果
5
reg_map = np.zeros((2, y.shape[1])) * np.nan
6
reg_map[:, ~mask] = r

6.3 条件掩膜（显著性过滤）#

1
# 将不显著的格点设为 NaN（绘图时不显示）
2
sst_tmp = np.where(map_sst.p_value >= 0.05, np.nan, map_sst.slope)
3
uwnd_tmp = np.where(map_uwnd.p_value >= 0.10, np.nan, map_uwnd.slope)

参数	说明
`condition`	条件表达式
`np.nan`	满足条件时的替换值
`map_sst.slope`	不满足条件时的原值

6.4 xarray 转 numpy 及回构#

1
# xarray → numpy
2
sst_np = sst.to_numpy()
3

4
# numpy → xarray（保留原维度坐标）
5
sst_xr = xr.DataArray(map, dims=sst.dims, coords=sst.coords)

七、pandas 日期生成#

1
from pandas import date_range
2

3
time_year = pd.date_range(start='1951-01-01', end='2020-01-01', freq='YS')

参数	说明
`start`	起始日期
`end`	结束日期
`freq='YS'`	频率：`'YS'`=年初, `'MS'`=月初, `'D'`=每日等

八、EOF 分析#

8.1 使用 eofs 库#

1
from eofs.standard import Eof
2

3
solver = Eof(ssta, weights=wgts)                        # 初始化
4
pt = solver.eofsAsCovariance(neofs=4)                    # 空间模态（协方差）
5
pc = solver.pcs(npcs=4, pcscaling=1)                     # 时间序列 PC
6
pcvar = solver.varianceFraction(neigs=4) * 100           # 解释方差百分比(%)

函数/方法	参数	说明
`Eof(data, weights)`	`data`	输入距平场 (time, lat, lon)
	`weights`	纬度权重，形状 (lat, 1)
`eofsAsCovariance(neofs)`	`neofs`	返回前 N 个模态（协方差形式）
`pcs(npcs, pcscaling)`	`npcs`	返回前 N 个 PC
	`pcscaling=1`	PC 标准差归一化
`varianceFraction(neigs)`	`neigs`	前 N 个模态的解释方差占比

8.2 使用 sacpy 库#

1
import sacpy as scp
2

3
eof = scp.EOF(ssta)
4
eof.solve()
5
pc = -eof.get_pc(npt=3)                 # PC（取负号可翻转符号，因人而异）
6
pt = -eof.get_pt(npt=3)                 # EOF 空间模态
7
pcvar = eof.get_varperc(npt=3) * 100    # 解释方差百分比(%)

九、时间处理与筛选#

1
import datetime as dt
2

3
# 时间范围筛选（netCDF4 方式）
4
def sel_time(year1, year2, time, dat):
5
    start_time = dt.datetime(year1, 1, 1)
6
    end_time = dt.datetime(year2, 12, 31)
7
    time_mask = (np.array(time) >= start_time) & (np.array(time) <= end_time)
8
    dat = dat[time_mask, :, :]
9
    time_dat = np.array(time)[time_mask]
10
    return time_dat, dat

温度单位转换#

1
dat = dat - 273.15    # 开尔文 → 摄氏度

风场强度计算#

1
wind_speed = np.sqrt(uwnd**2 + vwnd**2)

十、sacpy 库使用汇总#

sacpy 是复旦大学大气科学研究院开发的气象专用 Python 工具包，封装了距平计算、线性回归、EOF 分析等常用功能。

10.1 安装#

Terminal window

1
pip install sacpy

10.2 核心功能一览#

模块/类	功能	对应章节
`scp.get_anom()`	计算距平（去气候态）	3.1
`scp.LinReg()`	线性回归（同步输出斜率+p值）	4.2
`scp.EOF()`	EOF 分析（支持纬度加权）	8.2
`sacpy.Map`	地图绘图增强（scontourf, squiver, sig_plot 等）	cartopy.md / matplotlib.md

10.3 距平计算 — scp.get_anom#

1
import sacpy as scp
2

3
ssta = scp.get_anom(sst, method=1)

参数	说明
`sst`	xarray DataArray，维度 (time, lat, lon)
`method=1`	方法1：逐月去气候态（减去各月多年平均），详见 3.1 节

10.4 线性回归 — scp.LinReg#

1
LinReg = scp.LinReg(nino34, sst)
2
slope = LinReg.slope          # 回归系数场 (lat, lon)
3
p_value = LinReg.p_value      # p 值场 (lat, lon)

对比手动回归：

特点	手动 np.linalg.lstsq	sacpy.scp.LinReg
同步输出斜率+p值	需手算	自动提供
NaN 自动处理	需手动掩膜	自动处理
使用复杂度	高	低

详细用法见 4.2 节。

10.5 EOF 分析 — scp.EOF#

1
eof = scp.EOF(ssta)                  # 初始化
2
eof.solve()                          # 求解
3
pc = eof.get_pc(npt=3)               # 获取 PC (npt 个模态)
4
pt = eof.get_pt(npt=3)               # 获取特征向量（空间模态）
5
pcvar = eof.get_varperc(npt=3) * 100 # 解释方差百分比(%)

方法	参数	说明
`get_pc(npt)`	`npt`	返回前 npt 个 PC，形状 (npt, time)
`get_pt(npt)`	`npt`	返回前 npt 个空间模态，形状 (npt, lat, lon)
`get_varperc(npt)`	`npt`	返回前 npt 个模态的方差占比（小数，需 ×100 得百分比）

注意：PC 和 pattern 的符号可同时取反而不影响物理意义，这取决于求解器内部约定。详细用法见 8.2 节。

10.6 sacpy vs 手动实现对比#

功能	手动实现	sacpy
距平计算	`groupby('time.month').mean()` → 相减	`scp.get_anom(data, method=1)`
线性回归	`np.linalg.lstsq` + 手算p值	`scp.LinReg(index, field)`
EOF分析	`Eof(data, weights)` 逐步骤操作	`scp.EOF(data)` → `.solve()`

快速参考速查表#

需求	代码
打开 NC 文件	`xr.open_dataset(path)` 或 `Dataset(path)`
时间切片	`ds.sel(time=slice('1950','2020'))`
空间切片	`ds.loc[:, lat_min:lat_max, lon_min:lon_max]`
垂直层级选取	`hgt.sel(level=500)`
最近邻格点	`sel(lat=55, lon=20, method='nearest')`
月份筛选 (dt)	`sel(time=data.time.dt.month == 1)`
跨月筛选	`np.isin(data.time.dt.month, [12,1,2])`
时间插值	`.interp(time=target_time)`
多变量对齐	`xr.align(a, b, join='exact')`
去气候态 (手动)	`sst.groupby('time.month')` → `.mean()` → 相减
去气候态 (sacpy)	`scp.get_anom(sst, method=1)`
区域平均	`sst.loc[:, ...].mean(dim=['lat','lon'])`
纬向平均	`data.mean(dim='lon')`
标准化 (z-score)	`(x - x.mean()) / x.std()`
DataArray 运算	`-0.25a + 0.50b - 0.25*c`
线性回归 (手动)	`np.linalg.lstsq(X, y, rcond=None)`
线性回归 (sacpy)	`LinReg = scp.LinReg(index, field)`
逐点回归 (linregress)	`stats.linregress(x, y)` 返回 (a,b,r,p,std)
逐点回归 (apply_ufunc)	`xr.apply_ufunc(func, data, index, input_core_dims=[['time'],['time']], vectorize=True)`
EOF 分析 (eofs)	`Eof(ssta, weights=wgts)` → `eofsAsCovariance()`
EOF 分析 (sacpy)	`scp.EOF(ssta)` → `.solve()` → `.get_pc()` / `.get_pt()`
单样本 t 检验	`stats.ttest_1samp(data, popmean=0.0, axis=0)`
双样本 t 检验	`stats.ttest_ind(group1, group2, axis=0)`
数据重塑	`np.reshape(arr, (time, -1))`
NaN 掩膜	`np.isnan(np.mean(y, axis=0))`
条件替换	`np.where(condition, nan_val, orig_val)`
日期范围	`pd.date_range(start, end, freq='YS')`

cartopy气象绘图

Wed, 15 Jul 2026 00:00:00 GMT

Cartopy 地图绘制方法指南#

本文档整理了 cartopy 库在地图投影、海岸线、国界/省界/九段线、经纬度标记和区域选择等方面的使用方法。

一、地图投影 — Projection#

1.1 导入与基本设置#

1
import cartopy.crs as ccrs
2

3
# 等经纬度投影（最常用），central_longitude 设置中心经度
4
ax = fig.add_subplot(projection=ccrs.PlateCarree(central_longitude=180))
5

6
# 或用 subplots 方式
7
fig, ax = plt.subplots(subplot_kw={'projection': ccrs.PlateCarree(central_longitude=180)})

参数	说明
`central_longitude`	地图中心经度。`180` 表示太平洋为中心（气象常用），`0` 表示大西洋为中心。默认 `0`

1.2 其他常用投影#

1
ccrs.PlateCarree()                                                # 等经纬度（最常用）
2
ccrs.PlateCarree(central_longitude=180)                           # 太平洋中心
3
ccrs.Robinson()                                                   # Robinson（全球）
4
ccrs.Mollweide()                                                  # Mollweide（全球）
5
ccrs.Mercator()                                                   # 墨卡托（航海）
6
ccrs.LambertConformal()                                           # 兰伯特等角（中纬度）
7
ccrs.Orthographic(central_longitude=110, central_latitude=35)     # 正射投影（球面）
8
ccrs.NorthPolarStereo()                                           # 北极极射投影

投影	代码	适用场景
PlateCarree	`ccrs.PlateCarree(central_longitude=180)`	等距圆柱，气象最常用
Mercator	`ccrs.Mercator()`	墨卡托，低纬度/航海
LambertConformal	`ccrs.LambertConformal()`	兰勃特，中纬度地区
Robinson	`ccrs.Robinson()`	全球地图
Orthographic	`ccrs.Orthographic()`	球面视角
NorthPolarStereo	`ccrs.NorthPolarStereo()`	北极地区
Mollweide	`ccrs.Mollweide()`	全球等面积

除 central_longitude 外，PlateCarree 还支持 central_latitude 参数设定中心纬度。

二、坐标转换 — transform#

绘图时必须指定数据的坐标系，通常数据是等经纬度的，使用 ccrs.PlateCarree()：

1
ax.contourf(lon, lat, data, transform=ccrs.PlateCarree())
2
ax.quiver(lon, lat, u, v, transform=ccrs.PlateCarree())
3
ax.scatter(lon, lat, transform=ccrs.PlateCarree())
4
ax.plot(lon, lat, transform=ccrs.PlateCarree())

重要：几乎所有的数据绘制方法都需要加 transform=ccrs.PlateCarree()，否则 cartopy 无法正确将数据坐标映射到地图投影上。

三、海岸线 — coastlines#

1
ax.coastlines(resolution='110m', color='grey', linewidth=1.5, zorder=1)
2
ax.coastlines()                                      # 默认参数

参数	说明
`resolution`	精度：`'10m'`（最高）, `'50m'`, `'110m'`（最低，默认）
`color`	颜色
`linewidth` / `lw`	线宽
`zorder`	图层顺序，数值大的在上层

也可以通过 cfeature 方式指定分辨率：

1
ax.add_feature(cfeature.COASTLINE.with_scale('110m'), linewidth=0.8)

四、地图要素 — Features#

4.1 海洋/陆地遮罩#

遮罩陆地（只显示海洋数据）：

1
# 先画数据，再覆盖陆地
2
ax.contourf(lon, lat, data, levels, cmap='RdBu_r', transform=ccrs.PlateCarree())
3
ax.add_feature(cfeature.LAND, facecolor='white', edgecolor='none', zorder=10)

遮罩海洋（只显示陆地数据）：

1
ax.contourf(lon, lat, data, levels, cmap='RdBu_r', transform=ccrs.PlateCarree())
2
ax.add_feature(cfeature.OCEAN, facecolor='white', edgecolor='none', zorder=10)

参数	说明
`facecolor`	遮罩填充色，通常 `'white'` 或 `'lightgray'`
`edgecolor`	`'none'` 避免遮罩边界出现线条
`zorder`	必须设为 10（大于 contourf 的默认层级），确保遮罩覆盖在数据之上
`alpha`	透明度，可实现半透明遮罩效果

注意：cfeature.LAND/OCEAN 精度有限（基于 Natural Earth），对严格科研绘图推荐使用 陆地海洋 mask 文件 配合 np.ma.masked_where 实现精确遮罩。

常用 feature：

Feature	说明
`cfeature.OCEAN`	海洋区域
`cfeature.LAND`	陆地区域
`cfeature.COASTLINE`	海岸线
`cfeature.RIVERS`	河流
`cfeature.LAKES`	湖泊
`cfeature.BORDERS`	国界线（自然地球数据，不含中国标准）

注意：cfeature.BORDERS 使用的是 Natural Earth 数据，不包含中国主张的国界线。如需正确国界，请用下面的自定义方式。

五、中国地图要素#

5.1 直接读取 shp 文件画国界#

1
import cartopy.io.shapereader as shpreader
2

3
shp_dir = 'F:/SynologyDrive/Python_data/shpfile/'
4

5
# 读取国界 shp 文件
6
shps = shpreader.Reader(shp_dir + '国家矢量.shp')
7
ax.add_geometries(shps.geometries(), ccrs.PlateCarree(),
8
                  linewidth=0.5, edgecolor='k', facecolor='none')

add_geometries() 参数说明：

参数	说明
`geometries`	shapereader 读取的几何对象
`crs`	几何对象所在的坐标系（通常 `ccrs.PlateCarree()`）
`linewidth`	线宽
`edgecolor`	边界颜色
`facecolor`	填充颜色，`'none'` 表示透明（只画边界）

5.2 自定义 Feature 方式（推荐 — 可复用）#

1
import cartopy.feature as cfeature
2
import cartopy.io.shapereader as shpreader
3

4
def china_map_feature():
5
    provinces = cfeature.ShapelyFeature(
6
        shpreader.Reader(shp_dir + '2022省矢量.shp').geometries(),
7
        ccrs.PlateCarree(), edgecolor='k', facecolor='none')
8
    nine_lines = cfeature.ShapelyFeature(
9
        shpreader.Reader(shp_dir + '九段线.shp').geometries(),
10
        ccrs.PlateCarree(), edgecolor='k', facecolor='none')
11
    return provinces, nine_lines
12

13
provinces, nine_lines = china_map_feature()
14
ax.add_feature(provinces, linewidth=0.3, zorder=2)
15
ax.add_feature(nine_lines, linewidth=0.5, zorder=2)

展开收起

cfeature.ShapelyFeature 参数：

参数	说明
`geometries`	几何对象集合
`crs`	坐标系
`edgecolor`	边界颜色（默认 black）
`facecolor`	填充颜色（默认 steelblue）

ax.add_feature() 参数：

参数	说明
`feature`	Feature 对象
`linewidth`	线宽
`edgecolor`	边界颜色（可覆盖 Feature 默认值）
`facecolor`	填充颜色（可覆盖）
`zorder`	图层顺序

六、经纬度标记#

6.1 设置刻度位置#

1
# X 轴（经度）刻度
2
ax.set_xticks(range(0, 370, 60), crs=ccrs.PlateCarree())     # 每60度一个
3
ax.set_xticks([0, 60, 120, 180, 240, 300, 360], crs=ccrs.PlateCarree())
4
ax.set_xticks(np.arange(0, 361, 15), crs=ccrs.PlateCarree())  # 每15度一个
5

6
# Y 轴（纬度）刻度
7
ax.set_yticks(range(-90, 100, 30), crs=ccrs.PlateCarree())    # 每30度一个
8
ax.set_yticks([-90, -60, -30, 0, 30, 60, 90], crs=ccrs.PlateCarree())
9
ax.set_yticks(np.arange(-60, 61, 10), crs=ccrs.PlateCarree()) # 每10度一个

set_xticks() / set_yticks() 参数：

参数	说明
`ticks`	刻度位置列表
`crs`	必须指定 `ccrs.PlateCarree()` 表示刻度值对应的是经纬度坐标
`minor`	`True` 设置小刻度（不常用）

技巧：南北边界 range 需多设 1°（如 range(-90, 91, 30) 而非 range(-90, 90, 30)），否则地图最边缘的经纬度网格线不会显示。

6.2 格式化刻度标签（自动加 °E/°W、°N/°S）#

1
from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter
2

3
ax.xaxis.set_major_formatter(LongitudeFormatter())
4
ax.yaxis.set_major_formatter(LatitudeFormatter())

Formatter	效果
`LongitudeFormatter()`	经度格式：`0°`, `30°E`, `150°W`
`LatitudeFormatter()`	纬度格式：`0°`, `30°N`, `30°S`

高级参数：

参数	说明
`zero_direction_label=False`	0° 不显示方向（默认 `False`）
`dateline_direction_label=True`	180°（日期线）显示方向

6.3 调整刻度样式#

1
ax.tick_params(labelsize=12)               # 刻度标签字体大小
2
ax.tick_params(which='major', length=6)    # 主刻度线长度

6.4 坐标轴标签#

1
ax.set_xlabel("Longitude", fontsize=15)
2
ax.set_ylabel("Latitude", fontsize=15)

七、选定经纬度范围 — set_extent#

1
# 全球范围（太平洋中心）
2
ax.set_extent([0, 358, -80, 80], crs=ccrs.PlateCarree())
3

4
# 中国及周边
5
ax.set_extent([70, 140, 0, 60], crs=ccrs.PlateCarree())
6

7
# 热带区域
8
ax.set_extent([0, 360, -60, 60], crs=ccrs.PlateCarree())

参数格式： [lon_min, lon_max, lat_min, lat_max]

参数	说明
`extents`	`[west_lon, east_lon, south_lat, north_lat]`
`crs`	范围所采用的坐标系，通常 `ccrs.PlateCarree()`

注意：360 和 0 在等经纬度投影中是同一条经线，为避免显示异常，常用 358 作为右边界或在参数中使用 0~360 范围。

消除白边技巧：当数据格点不是整数经纬度时，地图边缘可能出现白边。解决方法：(1) 读取数据时在目标范围基础上多读一个格点；(2) set_extent 的边界值比目标范围多设 1°（如目标 30~180 则设为 [30, 181, ...]）。

八、网格线 — gridlines#

1
ax.gridlines()

九、sacpy.Map 地图增强方法#

sacpy.Map 在 cartopy 基础上提供了快捷的地图设置方法：

9.1 init_map — 初始化地图#

1
ax.init_map(stepx=50, stepy=20, smallx=10, smally=5)

参数	说明
`stepx`	经度主刻度间隔
`stepy`	纬度主刻度间隔
`smallx`	经度次刻度间隔
`smally`	纬度次刻度间隔

init_map 自动设置刻度位置、格式化长纬度标签、画海岸线等。

9.2 sig_plot — 显著性打点#

1
ax.sig_plot(lon, lat, p_value, thrshd=0.10, color='gray')

参数	说明
`lon, lat`	经纬度坐标
`p_value`	p 值数组
`thrshd`	显著性阈值（如 0.05, 0.10）
`color`	点颜色

sig_plot 会在 p 值小于阈值的格点上打点，表示通过显著性检验的区域。

9.3 scontourf + scontour — 增强填色图#

1
m = ax.scontourf(lon, lat, data, cmap='RdBu_r',
2
                 levels=np.arange(-1.2, 1.4, 0.2), extend='both')
3
ax.scontour(m, colors='black')

scontour 自动提取 m 的 levels 画等值线，比手动 contour 更简洁。

十、完整示例模板#

10.1 全球地图（太平洋中心）#

1
import cartopy.crs as ccrs
2
import cartopy.feature as cfeature
3
from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter
4

5
fig = plt.figure(figsize=(8, 5))
6
ax = fig.add_subplot(projection=ccrs.PlateCarree(central_longitude=180))
7

8
# 画数据
9
cf = ax.contourf(lon, lat, data, levels, cmap='RdBu_r',
10
                 extend='both', transform=ccrs.PlateCarree())
11

12
# 海岸线
13
ax.coastlines(lw=1.5, resolution='110m', color='grey', zorder=1)
14

15
# 经纬度刻度
16
ax.set_xticks([0, 60, 120, 180, 240, 300, 360], crs=ccrs.PlateCarree())
17
ax.set_yticks([-90, -60, -30, 0, 30, 60, 90], crs=ccrs.PlateCarree())
18
ax.xaxis.set_major_formatter(LongitudeFormatter())
19
ax.yaxis.set_major_formatter(LatitudeFormatter())
20
ax.set_extent([0, 356, -80, 80], crs=ccrs.PlateCarree())
21

22
# 色标
23
cb = fig.colorbar(cf, location='bottom', shrink=0.7)

展开收起

10.2 中国区域地图（含国界、省界、九段线）#

1
import cartopy.crs as ccrs
2
import cartopy.io.shapereader as shpreader
3
import cartopy.feature as cfeature
4

5
fig = plt.figure(figsize=(8, 5))
6
ax = fig.add_subplot(projection=ccrs.PlateCarree(central_longitude=180))
7

8
# 画数据
9
cf = ax.contourf(lon, lat, data, levels, cmap='RdBu_r',
10
                 extend='both', transform=ccrs.PlateCarree())
11

12
# 国界
13
shps = shpreader.Reader(shp_dir + '国家矢量.shp')
14
ax.add_geometries(shps.geometries(), ccrs.PlateCarree(),
15
                  linewidth=0.5, edgecolor='k', facecolor='none')
16

17
# 省界 & 九段线（自定义 Feature）
18
provinces = cfeature.ShapelyFeature(
19
    shpreader.Reader(shp_dir + '2022省矢量.shp').geometries(),
20
    ccrs.PlateCarree(), edgecolor='k', facecolor='none')
21
nine_lines = cfeature.ShapelyFeature(
22
    shpreader.Reader(shp_dir + '九段线.shp').geometries(),
23
    ccrs.PlateCarree(), edgecolor='k', facecolor='none')
24
ax.add_feature(provinces, linewidth=0.3, zorder=2)
25
ax.add_feature(nine_lines, linewidth=0.5, zorder=2)
26

27
# 海岸线 & 海洋填充
28
ax.coastlines(resolution='10m', color='k', linewidth=0.5, zorder=2)
29
ax.add_feature(cfeature.OCEAN, color='w', zorder=1)
30

31
# 经纬度刻度（精细）
32
ax.set_xticks(range(0, 370, 10), crs=ccrs.PlateCarree())
33
ax.set_yticks(range(-90, 100, 10), crs=ccrs.PlateCarree())
34
ax.xaxis.set_major_formatter(LongitudeFormatter())
35
ax.yaxis.set_major_formatter(LatitudeFormatter())
36
ax.set_extent([70, 140, 0, 60], crs=ccrs.PlateCarree())

展开收起

十一、完整绘图流程（中国区域）#

1
import xarray as xr
2
import numpy as np
3
import matplotlib.pyplot as plt
4
import cartopy.crs as ccrs
5
import cartopy.feature as cfeature
6
from cartopy.io import shapereader
7
from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter
8

9
# ========== 1. 中文字体 ==========
10
plt.rcParams['font.sans-serif'] = ['SimHei']
11
plt.rcParams['axes.unicode_minus'] = False
12

13
# ========== 2. 路径定义 ==========
14
shp_dir = 'F:/SynologyDrive/Python_data/shpfile/'
15
dat_dir = 'F:/SynologyDrive/Python_data/data/'
16

17
# ========== 3. 读取数据 ==========
18
ds = xr.open_dataset(dat_dir + 'air.2m.mon.mean.nc')
19
air = ds['air'].sel(time='2018-06-01')
20
lon, lat = air['lon'], air['lat']
21

22
# ========== 4. 中国地图要素函数 ==========
23
def china_map_feature():
24
    provinces = cfeature.ShapelyFeature(
25
        shapereader.Reader(shp_dir + '2022省矢量.shp').geometries(),
26
        ccrs.PlateCarree(), edgecolor='k', facecolor='none')
27
    nine_lines = cfeature.ShapelyFeature(
28
        shapereader.Reader(shp_dir + '九段线.shp').geometries(),
29
        ccrs.PlateCarree(), edgecolor='k', facecolor='none')
30
    return provinces, nine_lines
31

32
# ========== 5. 创建画布 ==========
33
fig = plt.figure(figsize=(14, 6))
34
ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=120))
35

36
# ========== 6. 绘制地图要素 ==========
37
shps = shapereader.Reader(shp_dir + '国家矢量.shp')
38
ax.add_geometries(shps.geometries(), ccrs.PlateCarree(),
39
                  linewidth=0.5, edgecolor='k', facecolor='none')
40
provinces, nine_lines = china_map_feature()
41
ax.add_feature(provinces, linewidth=0.3, zorder=2)
42
ax.add_feature(nine_lines, linewidth=0.5, zorder=2)
43
ax.coastlines(resolution='110m', linewidth=0.8)
44

45
# ========== 7. 地图范围与刻度 ==========
46
ax.set_extent([30, 182, -10, 81], crs=ccrs.PlateCarree())
47
ax.set_xticks(range(30, 182, 10), crs=ccrs.PlateCarree())
48
ax.set_yticks(range(-10, 81, 10), crs=ccrs.PlateCarree())
49
ax.tick_params(labelsize=12)
50
ax.xaxis.set_major_formatter(LongitudeFormatter())
51
ax.yaxis.set_major_formatter(LatitudeFormatter())
52

53
# ========== 8. 绘制数据 ==========
54
cf = ax.contourf(lon, lat, air,
55
                 levels=np.linspace(267, 317, 25),
56
                 cmap=plt.cm.RdBu_r,
57
                 transform=ccrs.PlateCarree(), extend='both')
58

59
# ========== 9. 色标 ==========
60
cbar = plt.colorbar(cf, ax=ax, orientation='horizontal', pad=0.05, shrink=0.85)
61
cbar.set_label('Temperature (K)')
62

63
# ========== 10. 标题与保存 ==========
64
ax.set_title('2m Air Temperature (2018-06-01)', fontsize=14)
65
plt.tight_layout()
66
plt.savefig('china_t2m.png', dpi=300, bbox_inches='tight')
67
plt.show()

展开收起

流程总结：字体 → 路径 → 读数据 → 定义要素函数 → 画布 → 地图要素 → 范围/刻度 → 数据 → 色标 → 保存。

十二、多子图示例（含陆地/海洋遮罩）#

1
fig, axes = plt.subplots(
2
    3, 1, figsize=(16, 18),
3
    subplot_kw={'projection': ccrs.PlateCarree(central_longitude=120)}
4
)
5

6
# 统一设置所有子图的地图要素
7
for ax in axes:
8
    shps = shapereader.Reader(shp_dir + '国家矢量.shp')
9
    ax.add_geometries(shps.geometries(), ccrs.PlateCarree(),
10
                      linewidth=0.5, edgecolor='k', facecolor='none')
11
    provinces, nine_lines = china_map_feature()
12
    ax.add_feature(provinces, linewidth=0.3, zorder=2)
13
    ax.add_feature(nine_lines, linewidth=0.5, zorder=2)
14
    ax.set_extent([30, 181, -10, 81], crs=ccrs.PlateCarree())
15
    ax.coastlines(resolution='110m', linewidth=0.8)
16
    ax.set_xticks(range(30, 181, 10), crs=ccrs.PlateCarree())
17
    ax.set_yticks(range(-10, 81, 10), crs=ccrs.PlateCarree())
18
    ax.tick_params(labelsize=12)
19
    ax.xaxis.set_major_formatter(LongitudeFormatter())
20
    ax.yaxis.set_major_formatter(LatitudeFormatter())
21

22
level = np.linspace(267, 317, 25)
23

24
# 子图 1：全图
25
cf1 = axes[0].contourf(lon, lat, air, levels=level,
26
                       cmap=plt.cm.RdBu_r, transform=ccrs.PlateCarree(), extend='both')
27
axes[0].set_title('Global Map', fontsize=14)
28

29
# 子图 2：遮罩陆地，只显示海洋
30
cf2 = axes[1].contourf(lon, lat, air, levels=level,
31
                       cmap=plt.cm.RdBu_r, transform=ccrs.PlateCarree(), extend='both')
32
axes[1].add_feature(cfeature.LAND, facecolor='white', edgecolor='none', zorder=10)
33
axes[1].set_title('Ocean Only (Land Masked)', fontsize=14)
34

35
# 子图 3：遮罩海洋，只显示陆地
36
cf3 = axes[2].contourf(lon, lat, air, levels=level,
37
                       cmap=plt.cm.RdBu_r, transform=ccrs.PlateCarree(), extend='both')
38
axes[2].add_feature(cfeature.OCEAN, facecolor='white', edgecolor='none', zorder=10)
39
axes[2].set_title('Land Only (Ocean Masked)', fontsize=14)
40

41
# 各子图独立 colorbar
42
for ax, cf in zip(axes, [cf1, cf2, cf3]):
43
    cbar = fig.colorbar(cf, ax=ax, orientation='horizontal', pad=0.08, shrink=0.5)
44
    cbar.set_label('Temperature (K)')
45

46
plt.tight_layout()
47
plt.show()

展开收起

多子图的关键：用 for ax in axes 循环统一设置地图要素，避免代码重复。

十三、注意事项#

Shapefile 来源：国界、省界、九段线必须使用官方标准数据（如自然资源部发布版本），cartopy 内置的 cfeature.BORDERS 不包含中国主张国界。
图层顺序（zorder）：
- 等值线填色图（contourf）：默认最底层（一般不设 zorder）
- 地图要素（国界、省界等）：zorder=2
- 陆地/海洋遮罩：zorder=10（必须在 contourf 之后绘制，且 zorder 大于数据图层）
transform 参数：contourf、contour、quiver、scatter、plot 等绘制数据时都必须指定 transform=ccrs.PlateCarree()，否则数据坐标与投影坐标不匹配。
add_geometries vs add_feature：
- add_geometries：直接传入 shapefile 几何对象，适合一次性使用
- add_feature：传入 cfeature.Feature 对象（含 cfeature.ShapelyFeature 封装），适合复用
避免重复 IO：当多个子图共用同一 shapefile 时，先用 china_map_feature() 函数封装，在循环中复用，避免每次重复读取硬盘。
海陆遮罩替代方案：cfeature.LAND/OCEAN 精度有限（基于 Natural Earth），对于严格科研绘图，推荐使用 陆地海洋 mask 文件 配合 np.ma.masked_where 实现精确遮罩。

快速参考速查表#

需求	代码
地图投影	`fig.add_subplot(projection=ccrs.PlateCarree(central_longitude=180))`
坐标系转换	`transform=ccrs.PlateCarree()`
海岸线	`ax.coastlines(resolution='110m', color='grey', lw=1.5)`
海岸线 (Feature)	`ax.add_feature(cfeature.COASTLINE.with_scale('110m'), lw=0.8)`
海洋填充	`ax.add_feature(cfeature.OCEAN, facecolor='white', edgecolor='none', zorder=10)`
陆地填充	`ax.add_feature(cfeature.LAND, facecolor='white', edgecolor='none', zorder=10)`
国界线(shp)	`ax.add_geometries(shps.geometries(), ccrs.PlateCarree(), ...)`
省界线	`cfeature.ShapelyFeature(...)` + `ax.add_feature(...)`
九段线	`cfeature.ShapelyFeature(...)` + `ax.add_feature(...)`
经度刻度	`ax.set_xticks(range(...), crs=ccrs.PlateCarree())`
纬度刻度	`ax.set_yticks(range(...), crs=ccrs.PlateCarree())`
刻度格式化	`ax.xaxis.set_major_formatter(LongitudeFormatter())`
设定范围	`ax.set_extent([w, e, s, n], crs=ccrs.PlateCarree())`
消除白边	读数据时多读一格，set_extent 多设 1°
网格线	`ax.gridlines()`
多子图统一设置	`for ax in axes: ...` + `china_map_feature()`
避免重复IO	封装 `china_map_feature()` 函数
init_map	`ax.init_map(stepx=50, stepy=20)`
显著性打点	`ax.sig_plot(lon, lat, p_value, thrshd=0.05)`
显著性打点	`ax.sig_plot(lon, lat, p_value, thrshd=0.05)`

matplotlib气象绘图

Wed, 15 Jul 2026 00:00:00 GMT

Matplotlib 绘图方法指南#

本文档系统整理了气象气候分析中常用的 matplotlib 绘图类型和多子图布局方法。

零、全局设置#

中文字体设置#

1
import matplotlib.pyplot as plt
2

3
plt.rcParams['font.sans-serif'] = ['SimHei']      # 使用黑体，解决中文乱码
4
plt.rcParams['axes.unicode_minus'] = False        # 解决负号显示为方块的问题

参数	说明
`font.sans-serif`	设置无衬线字体列表，`'SimHei'`=黑体, `'Microsoft YaHei'`=微软雅黑
`axes.unicode_minus`	`False` 避免负号 `-` 显示为乱码方块

一、画布与坐标轴创建#

1.1 figure + add_subplot（最常用）#

1
fig = plt.figure(figsize=(8, 5))
2
ax = fig.add_subplot(1, 1, 1)                          # 1行1列第1个
3
ax = fig.add_subplot(projection=ccrs.PlateCarree(central_longitude=180))  # 地图投影

参数	说明
`figsize=(w, h)`	画布宽高（英寸）
`nrows, ncols, index`	子图的行数、列数、当前索引（从1开始）
`projection`	地图投影（需配合 cartopy 使用）

1.2 plt.subplots（一行创建多子图）#

1
fig, ax = plt.subplots()                                # 单子图
2
fig, axs = plt.subplots(2, 1, figsize=(9, 10),         # 2行1列
3
                         subplot_kw={'projection': ccrs.PlateCarree(central_longitude=180)})
4
fig, ax = plt.subplots(nrows=3, figsize=(8, 11),        # 3行
5
                        subplot_kw={'projection': ccrs.PlateCarree(central_longitude=180)})

参数	说明
`nrows`	行数
`ncols`	列数（默认1）
`figsize`	画布尺寸
`subplot_kw`	传给每个子图的额外参数，常用于设置 `projection`

1.3 plt.axes（直接创建 axes）#

1
ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=180))

1.4 fig.add_axes（精确定位 colorbar）#

1
cb_ax = fig.add_axes([0.1, 0.06, 0.4, 0.02])           # [left, bottom, width, height]（相对坐标）
2
fig.colorbar(m1, cax=cb_ax, orientation='horizontal')

二、填色图 — contourf#

2.1 标准用法#

1
cf = ax.contourf(lon, lat, data, levels, cmap='RdBu_r',
2
                 extend='both', transform=ccrs.PlateCarree())

参数	说明
`lon, lat`	经纬度数组（1D或2D）
`data`	二维数据数组 (lat, lon)
`levels`	等值线层级，常用 `np.arange(start, stop, step)` 或 `np.linspace(start, stop, n)`
`cmap`	颜色映射，如 `'RdBu_r'`（白→红/蓝）、`'bwr'`、`'jet'` 等
`extend`	`'both'`=两侧超出范围用三角标记；`'max'` / `'min'` / `'neither'`
`transform`	坐标系转换（cartopy 地图投影时必加）

2.2 sacpy 增强版#

1
m = ax.scontourf(lon, lat, data, cmap='RdBu_r',
2
                 levels=np.arange(-1.2, 1.4, 0.2), extend='both')

scontourf 是 sacpy.Map 提供的增强 contourf，自动带等值线描边等特性。

三、等值线 — contour#

1
# 标准 contour
2
ax.contour(lon, lat, data, colors='grey', transform=ccrs.PlateCarree())
3

4
# sacpy 增强版：基于 contourf 对象自动添加黑边
5
ax.scontour(m, colors='black')

参数	说明
`lon, lat, data`	同 contourf
`colors`	等值线颜色
`linewidths`	线宽

scontour 需要传入一个 contourf 对象 m，自动使用 m 的 levels 来画等值线。

3.1 等值线标注 — clabel#

在等值线上直接标注数值：

1
cs = ax.contour(lon, lat, data, levels=levels_c,
2
                colors='k', linewidths=0.6)
3
ax.clabel(cs, inline=True, fontsize=8, fmt='%d')

参数	说明
`cs`	`contour()` 返回的对象
`inline`	`True` 表示标签打断等值线后嵌入显示
`fontsize`	标签字号
`fmt`	标签格式：`'%d'` 整数、`'%.1f'` 一位小数
`colors`	标签颜色（默认与等值线同色）

四、散点图 — scatter#

4.1 基本用法与常用参数#

1
ax.scatter(x, y,
2
           s=50,               # 点大小（面积，非直径）
3
           c='steelblue',      # 填充色
4
           marker='o',         # 形状
5
           alpha=0.7,          # 透明度
6
           edgecolors='k',     # 边缘色
7
           linewidths=0.3,     # 边缘线宽
8
           zorder=3)           # 图层叠放顺序

参数	说明
`x, y`	散点的 x、y 坐标
`s`	点大小（面积），标量或数组
`c` / `color`	颜色：`'r'`, `[0.5,0.5,0.5]`, `'tab:blue'`，或数组（配合 `cmap` 使用）
`marker`	形状：`'o'`圆, `'s'`方, `'^'`上三角, `'D'`菱形, `'*'`星, `'+'`十字, `'x'`叉
`alpha`	透明度 0~1
`edgecolors`	边缘颜色，`'none'` 隐藏边缘, `'k'` 黑色
`linewidths`	边缘线宽
`zorder`	图层顺序，数值越大越靠前

4.3 分组上色#

1
# 中间值灰色，高值红色，低值蓝色
2
ax.scatter(ONI, SOI, color=[0.5, 0.5, 0.5])           # 全部灰色打底
3
ax.scatter(ONI[ONI >= 1.5], SOI[ONI >= 1.5], color='r')  # 高值红色
4
ax.scatter(ONI[ONI <= -1.5], SOI[ONI <= -1.5], color='b') # 低值蓝色

4.4 显著性打点#

1
lon2d, lat2d = np.meshgrid(lon, lat)
2
ax.scatter(lon2d[significant], lat2d[significant],
3
           color='grey', s=2, transform=ccrs.PlateCarree())

条件索引 [significant] 只提取通过显著性检验的格点。

4.5 气泡图（Size + Color 双变量映射）#

通过 s 和 c 分别映射两个变量，同时展示数据的”大小”和”强度”：

1
sc = ax.scatter(x, y,
2
                s=z,                  # 点面积正比于 z 值
3
                c=c_array,            # 颜色映射到 c_array
4
                cmap='viridis',
5
                alpha=0.7,
6
                edgecolors='gray',
7
                linewidths=0.5)
8
cbar = plt.colorbar(sc, pad=0.02)
9
cbar.set_label('Color Variable')

参数	说明
`s=z`	点面积正比于数组 z，实现气泡大小映射
`c=c_array, cmap=...`	根据数组值映射颜色，`cmap` 选择色表
`cmap`	常用：`'viridis'`（感知均匀）, `'coolwarm'`（冷暖）, `'RdBu_r'`（红蓝）

4.6 散点图 + 回归拟合线 + R² 标注#

1
from scipy import stats
2

3
slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
4

5
# 散点
6
ax.scatter(x, y, s=40, c='steelblue', alpha=0.7, label='Data')
7

8
# 拟合线（x 需排序后才连线）
9
x_sorted = np.sort(x)
10
ax.plot(x_sorted, slope * x_sorted + intercept,
11
        color='red', linewidth=1.5,
12
        label=f'y={slope:.2f}x+{intercept:.2f}')
13

14
# R² 和 p 值文本框
15
ax.text(0.05, 0.95,
16
        f'$R^2$ = {r_value**2:.3f}\np = {p_value:.2e}',
17
        transform=ax.transAxes, fontsize=9,
18
        verticalalignment='top',
19
        bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))

展开收起

参数/函数	说明
`stats.linregress(x, y)`	一元线性回归，返回 (斜率, 截距, R, p, 标准误)
`r_value**2`	决定系数 R²
`ax.text(x, y, text, transform=ax.transAxes)`	在图中添加文本框，`transAxes` 使用相对坐标 (0~1)
`bbox=dict(boxstyle='round', facecolor='wheat')`	文本框样式：圆角 + 底色

五、折线图 — plot#

5.1 基本用法#

1
l1, = ax.plot(x, y, '-', c='tab:blue', linewidth=2)

参数	说明
`x, y`	坐标数据
`'-'`	线型：`'-'`实线, `'--'`虚线, `'-.'`点划线, `':'`点线
`c` / `color`	颜色
`linewidth` / `lw`	线宽
`marker`	数据点形状：`'o'`, `'s'`, `'^'`, `'*'`, `'.'` 等，`'None'` 不显示
`label`	图例标签（需配合 `legend()` 使用）

5.2 水平/垂直参考线#

1
ax.axhline(y=0, color='k', linestyle='-')            # 水平线
2
ax.axhline(y=0.5, color='k', linestyle='--')         # 水平虚线
3
ax.axvline(x=0, color='k', linestyle='-')            # 垂直线

参数	说明
`y`	水平线的 y 值
`x`	垂直线的 x 值
`color`	颜色
`linestyle`	线型
`linewidth`	线宽

5.3 条件上色#

1
ax.plot(time_year[nino34_DJF > 0.5], nino34_DJF[nino34_DJF > 0.5], 'ro')   # 高值红点
2
ax.plot(time_year[nino34_DJF < -0.5], nino34_DJF[nino34_DJF < -0.5], 'bo')  # 低值蓝点

5.4 滑动平均（平滑曲线）#

1
y_smooth13 = y.rolling(window=13, center=True).mean()   # 13点滑动平均
2
y_smooth5  = y.rolling(window=5, center=True).mean()    # 5点滑动平均
3

4
ax.plot(x, y_smooth13, color='black', linewidth=1.5, label='13-point smooth')
5
ax.plot(x, y_smooth5, color='yellowgreen', linewidth=1.2, label='5-point smooth')

参数	说明
`window`	滑动窗口大小（点数）
`center=True`	窗口居中（前后各取 window/2 个点）

5.5 趋势线（线性回归拟合）#

1
from scipy import stats
2

3
x_num = np.arange(len(y))             # 将时间转为数字索引
4
slope, intercept, r, p, std = stats.linregress(x_num, y)
5
y_fit = intercept + slope * x_num
6

7
ax.plot(x, y, color='grey', alpha=0.6, label='Raw')      # 原始数据
8
ax.plot(x, y_fit, color='red', linewidth=2, label='Trend') # 趋势线
9
ax.legend()

六、矢量图 — quiver / quiverkey#

6.1 quiver 基本用法#

1
x_int = 3    # 经度抽取间隔（每隔几个点取一个）
2
y_int = 3    # 纬度抽取间隔
3

4
qv = ax.quiver(lon_wnd[::x_int], lat_wnd[::y_int],
5
               uwnd[::y_int, ::x_int], vwnd[::y_int, ::x_int],
6
               transform=ccrs.PlateCarree())

参数	说明
`X, Y`	箭头起点坐标（1D或2D，通常需降采样）
`U, V`	纬向风、经向风分量
`scale`	箭头缩放因子，数值越大箭头越短（`None` 自动）
`width`	箭头杆宽度（坐标轴单位）
`headwidth`	箭头头部宽度倍数（相对杆，默认 3）
`headlength`	箭头头部长度倍数（相对杆，默认 5）
`headaxislength`	箭头头部在轴线方向的长度（默认 4.5）
`pivot`	旋转点：`'tail'`（尾部，默认）, `'mid'`（中间）, `'tip'`（头部）
`color`	箭头颜色
`alpha`	透明度
`transform`	坐标系转换

6.2 使用 np.meshgrid 生成 2D 网格#

从 xarray 降采样后，用 meshgrid 生成 quiver 需要的 2D 坐标：

1
step = 3
2
u_plot = u_data[::step, ::step]
3
v_plot = v_data[::step, ::step]
4

5
lon_1d = u_plot['lon'].values
6
lat_1d = u_plot['lat'].values
7
lon2d, lat2d = np.meshgrid(lon_1d, lat_1d)
8

9
qv = ax.quiver(lon2d, lat2d, u_plot.values, v_plot.values,
10
               scale=200, width=0.002, transform=ccrs.PlateCarree())

6.3 矢量遮罩（仅显示超过阈值的箭头）#

1
mask = (np.abs(U) < threshold) & (np.abs(V) < threshold)
2
U_masked = U.copy()
3
V_masked = V.copy()
4
U_masked[mask] = np.nan
5
V_masked[mask] = np.nan

6.4 图例箭头 — quiverkey#

1
ax.quiverkey(qv, X=0.9, Y=0.07, U=10, label='10 m/s',
2
             labelpos='S', labelsep=0.05, coordinates='axes')

参数	说明
`qv`	quiver 返回的对象
`X, Y`	图例位置（取决于 `coordinates`）
`U`	参考箭头代表的数值
`label`	图例文字
`labelpos`	文字位置：`'S'`南, `'N'`北, `'E'`东, `'W'`西
`labelsep`	文字与箭头的间距
`coordinates`	`'axes'`=相对坐标(0~1), `'data'`=数据坐标

6.5 风场图例框#

1
import matplotlib.patches as mpatches
2

3
w, h = 0.12, 0.12         # 矩形框尺寸
4
rect = mpatches.Rectangle((1-w, 0), w, h,
5
                          transform=ax.transAxes,
6
                          linewidth=1, ec='k', fc='w')
7
ax.add_patch(rect)
8
ax.quiverkey(qv, 1-w/2, 0.7*h, 10, '10 m/s',
9
             labelpos='S', labelsep=0.05, coordinates='axes')

mpatches.Rectangle 参数：

参数	说明
`(x, y)`	左下角坐标
`width, height`	宽高
`transform`	`ax.transAxes` 表示相对坐标
`ec` / `edgecolor`	边框颜色
`fc` / `facecolor`	填充颜色

6.6 sacpy 增强版 — squiver#

1
ax.squiver(uwnd.lon, uwnd.lat, uwnd_tmp, vwnd_tmp,
2
           stepx=4, stepy=2, width=0.004)

参数	说明
`lon, lat`	坐标
`u, v`	风速分量
`stepx, stepy`	经向/纬向抽样间隔
`width`	箭头宽度

七、误差棒图 — errorbar#

1
l1, = ax.plot(range(1, 13), clim_mean, '-', c='tab:blue', linewidth=2)
2
ax.errorbar(range(1, 13), clim_mean, yerr=[yerr_lower, yerr_upper],
3
            fmt='-o', capsize=5)

参数	说明
`x`	横坐标
`y`	纵坐标（均值）
`yerr`	误差范围：单个值对称误差 / `[lower, upper]` 不对称误差
`fmt`	格式字符串，如 `'-o'` 表示实线+圆点标记
`capsize`	误差条末端横线长度
`color`	颜色

八、填充面积图 — fill_between#

1
ax.fill_between(time, ts, where=(ts > 0), color='tab:red', alpha=0.8)
2
ax.fill_between(time, ts, where=(ts < 0), color='tab:blue', alpha=0.8)

参数	说明
`x`	横坐标
`y`	纵坐标
`where`	布尔条件，只填充满足条件的区域
`color`	填充颜色
`alpha`	透明度

常用于正负值分色填充（如 ENSO 指数暖事件红色、冷事件蓝色）。

九、矩形框标记 — 区域标注#

1
# Nino34 区域框
2
lon_min, lat_min = 190, -5
3
lon_max, lat_max = 240, 5
4
ax.plot([lon_min, lon_max], [lat_min, lat_min], linewidth=2, color='red',
5
        transform=ccrs.PlateCarree())
6
ax.plot([lon_min, lon_max], [lat_max, lat_max], linewidth=2, color='red',
7
        transform=ccrs.PlateCarree())
8
ax.plot([lon_min, lon_min], [lat_min, lat_max], linewidth=2, color='red',
9
        transform=ccrs.PlateCarree())
10
ax.plot([lon_max, lon_max], [lat_min, lat_max], linewidth=2, color='red',
11
        transform=ccrs.PlateCarree())

用 4 条 plot 线画出矩形框，标注特定区域（如 Nino3.4 区域）。

十、色标 — colorbar#

10.1 pyplot 模式（单图快捷）#

1
cbar = plt.colorbar(cf, pad=0.02)
2
cbar.set_label('SST (°C)')

10.2 绑定到坐标轴（子图推荐）#

1
cb = fig.colorbar(cf, ax=ax,
2
                  orientation='horizontal',
3
                  location='right',
4
                  pad=0.08,
5
                  shrink=0.85,
6
                  aspect=30,
7
                  extend='both',
8
                  ticks=np.arange(0, 36, 5))
9
cb.set_label('Temperature (°C)', fontsize=12)
10
cb.ax.tick_params(labelsize=12)

参数	说明
`cf`	contourf 等返回的 mappable 对象
`ax`	关联的子图
`cax`	精确指定色标 Axes（与 `ax` 二选一）
`orientation`	方向：`'vertical'`（默认）或 `'horizontal'`
`location`	`'right'`, `'left'`, `'top'`, `'bottom'`
`pad`	色标与主图的间距（相对主图尺寸的比例）
`shrink`	色标长度的缩放比例 (0~1)
`aspect`	色标长宽比（数值越大越细长）
`extend`	是否显示超出范围的三角箭头，默认与 contourf 一致：`'both'`/`'min'`/`'max'`/`'neither'`
`ticks`	手动指定刻度位置

10.3 精确定位（自定义位置）#

1
cb_ax = plt.axes([0.12, 0.00, 0.76, 0.04])   # [left, bottom, width, height]
2
cb = plt.colorbar(cf, cax=cb_ax, orientation='horizontal')
3
cb.set_label('Label', fontsize=8)
4
cb.ax.tick_params(labelsize=7)

plt.axes([l, b, w, h]) 使用图形相对坐标 (0~1) 创建色标专用 Axes。

十一、图标题与轴标签#

1
fig.suptitle('Title for whole figure', fontsize=20)       # 全图标题
2
ax.set_title('Subplot Title', fontsize=16)                 # 子图标题
3
ax.set_xlabel('X Label', fontsize=16)                      # X 轴标签
4
ax.set_ylabel('Y Label', fontsize=16)                      # Y 轴标签
5
ax.legend(['Line1', 'Line2'])                              # 图例

十二、刻度与格式#

12.1 自定义刻度#

1
ax.set_xticks(range(1, 13))                                # 设定刻度位置
2
ax.set_xticklabels(['Jan', 'Feb', ..., 'Dec'])             # 设定刻度标签文字

12.2 刻度样式#

1
ax.tick_params(labelsize=14)                               # 统一设置刻度标签大小
2
plt.xticks(fontsize=14)                                    # X 轴刻度字体
3
plt.yticks(fontsize=14)                                    # Y 轴刻度字体

12.3 cartopy 地图刻度格式化#

1
ax.xaxis.set_major_formatter(LongitudeFormatter())
2
ax.yaxis.set_major_formatter(LatitudeFormatter())

12.4 坐标轴范围#

1
ax.set_xlim([time[0], time[-1]])                           # X 轴范围
2
ax.set_ylim([-2, 2.5])                                     # Y 轴范围
3
ax.axis([-3.5, 3.5, -6.5, 6.5])                            # [xmin, xmax, ymin, ymax]

12.5 手动自定义经纬度标签#

不依赖 LongitudeFormatter，手动用 set_xticklabels 生成 120°E / 60°W 格式：

1
xticks = np.arange(0, 360, 30)
2
ax.set_xticks(xticks, crs=ccrs.PlateCarree())
3
ax.set_xticklabels([
4
    "0°" if x == 0
5
    else "180°" if x == 180
6
    else f"{int(x)}°E" if 0 < x < 180
7
    else f"{int(360 - x)}°W"
8
    for x in xticks
9
], fontsize=6)
10

11
yticks = np.arange(-90, 91, 30)
12
ax.set_yticks(yticks, crs=ccrs.PlateCarree())
13
ax.set_yticklabels([
14
    f"{int(abs(y))}°N" if y > 0
15
    else ("0°" if y == 0 else f"{int(abs(y))}°S")
16
    for y in yticks
17
], fontsize=6)

展开收起

十三、网格线#

1
ax.grid()                                                   # 普通网格
2
ax.gridlines()                                              # cartopy 地图网格

十四、多子图布局#

14.1 模式一：n 行 × 1 列#

1
fig, ax = plt.subplots(nrows=3, figsize=(8, 11),
2
                       subplot_kw={'projection': ccrs.PlateCarree(central_longitude=180)})
3
for i in range(3):
4
    ax[i].contourf(...)        # ax[i] 访问第 i 个子图

14.2 模式二：混合布局（左地图 + 右折线）#

1
fig = plt.figure(figsize=[9, 10])
2
for i in range(3):
3
    ax = fig.add_subplot(3, 2, 2*i+1,   # 第1,3,5 位置 — 地图
4
                         projection=ccrs.PlateCarree(central_longitude=180))
5
    # ... 画填色图 ...
6

7
    ax = fig.add_subplot(3, 2, 2*i+2)   # 第2,4,6 位置 — 折线图
8
    # ... 画时间序列 ...
9

10
cb_ax = fig.add_axes([0.1, 0.06, 0.4, 0.02])  # 底部色标
11
fig.colorbar(m1, cax=cb_ax, orientation='horizontal')

技巧：add_subplot(R, C, N) 中 N 从 1 开始，按行编号。地图和折线交替排列。

14.3 模式三：单行多子图（共用色标）#

1
fig, ax = fig.add_subplot(1, 1, 1)  # 单子图

14.4 子图间距调整#

1
plt.subplots_adjust(left=0.05, right=0.95, top=0.95, bottom=0.05,
2
                    hspace=0.4, wspace=0.3)

参数	说明
`left, right, top, bottom`	画布边距（相对值 0~1）
`hspace`	子图间垂直间距
`wspace`	子图间水平间距

十五、图片保存#

1
fig.savefig('output.png', dpi=300, format='png')
2
plt.savefig('output.png', dpi=300, format='png')

参数	说明
`fname`	输出文件名
`dpi`	分辨率（每英寸点数），300 适合出版级
`format`	格式：`'png'`, `'pdf'`, `'svg'`, `'jpg'` 等

十六、sacpy.Map 专用绘图方法汇总#

方法	功能	等效 matplotlib
`ax.scontourf(lon, lat, data, ...)`	增强填色图	`ax.contourf()`
`ax.scontour(m, colors=...)`	基于填色图的等值线	`ax.contour()`
`ax.squiver(lon, lat, u, v, ...)`	增强矢量图	`ax.quiver()`
`ax.sig_plot(lon, lat, p_value, thrshd, color)`	显著性打点	`ax.scatter()`
`ax.init_map(stepx, stepy, smallx, smally)`	初始化地图刻度和外观	组合设置

十七、柱状图 — bar#

1
plt.figure(figsize=(10, 3.5), dpi=150)
2

3
# 正值柱（红色）
4
plt.bar(x[y >= 0], y[y >= 0],
5
        width=30, color='lightcoral', edgecolor='none')
6

7
# 负值柱（蓝色）
8
plt.bar(x[y < 0], y[y < 0],
9
        width=30, color='lightblue', edgecolor='none')
10

11
plt.axhline(0, color='k', linewidth=0.8)   # 零线
12
plt.ylabel('WP Index')
13
plt.title('WP Index (1979–2025)')
14

15
# 自定义刻度标签
16
years = pd.date_range(start=x.min(), end=x.max(), freq='5YS')
17
plt.xticks(years, [d.year for d in years])
18
plt.tight_layout()

展开收起

参数	说明
`x`	柱子的 x 坐标（位置）
`height`（第二个位置参数）	柱子的高度（y 值）
`width`	柱子的宽度，单位与 x 轴相同
`color`	填充颜色
`edgecolor`	边框颜色，`'none'` 无边框
`align`	对齐方式：`'center'`（默认）/ `'edge'`
`bottom`	柱子的底部起始位置（堆叠柱状图用）

十八、显著性填色 — Hatching（影线）#

用影线图案标记通过显著性检验的区域（替代打点）：

1
# sig 为布尔数组（True = 通过检验）
2
ax.contourf(lon, lat, sig,
3
            levels=[0.5, 1.5],        # 区分 False(0) 和 True(1)
4
            hatches=['..'],            # 影线图案
5
            colors='none',             # 不填充颜色，仅显示影线
6
            transform=ccrs.PlateCarree())

参数	说明
`levels`	必须设为 `[0.5, 1.5]` 以区分布尔值
`hatches`	影线样式列表
`colors='none'`	填充透明，只显示影线

常用影线图案：

图案	效果	图案	效果
`'/'`	斜线	`'\\'`	反斜线
`'.'`	稀疏点	`'..'`	密点
`'x'`	叉号	`'+'`	加号
`'o'`	圆圈	`'*'`	星号

十九、图例 — legend#

1
# 自动图例（需在 plot/bar 时指定了 label）
2
ax.legend()
3

4
# 指定位置与样式
5
ax.legend(loc='upper right', frameon=False, fontsize=9,
6
          ncol=2, title='Legend Title', fancybox=True, shadow=True)

参数	说明
`loc`	位置：`'best'`, `'upper right'`, `'upper left'`, `'lower right'`, `'lower left'`, `'upper center'`, `'lower center'`, `'center'`, `'center left'`, `'center right'`
`frameon`	`True` 显示边框, `False` 隐藏
`fancybox`	是否圆角边框
`shadow`	是否显示阴影
`fontsize`	字体大小
`ncol`	图例列数（多列排列）
`title`	图例标题文字

二十、自动布局 — tight_layout#

1
plt.tight_layout()   # 自动调整子图间距，防止标签重叠

在多子图或图表元素较多时，调用 tight_layout() 可自动优化间距。

二十一、常用颜色映射表（cmap）#

色表名	适用场景
`'RdBu_r'` 或 `plt.cm.RdBu_r`	距平/异常场，红正蓝负（气象最常用）
`'RdBu'` 或 `plt.cm.RdBu`	蓝正红负
`'bwr'`	蓝-白-红，适合距平
`'coolwarm'`	冷暖色，适合温度
`'jet'`	彩虹色通用场
`'viridis'`	感知均匀，适合连续变量
`'seismic'`	蓝白红，适合相关/回归场
`'Spectral_r'`	光谱色，适合降水
`'gist_ncar'`	气象常用高对比彩色

二十二、完整绘图流程（柱状图示例）#

1
# ========== 1. 导入库 ==========
2
import numpy as np
3
import matplotlib.pyplot as plt
4

5
# ========== 2. 全局设置 ==========
6
plt.rcParams['font.sans-serif'] = ['SimHei']
7
plt.rcParams['axes.unicode_minus'] = False
8

9
# ========== 3. 准备数据 ==========
10
x = np.array(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
11
              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
12
y = np.array([2.1, 3.5, 5.8, 8.2, 12.0, 15.5,
13
              18.3, 17.0, 13.2, 8.8, 4.5, 2.8])
14

15
# ========== 4. 创建图形 ==========
16
fig, ax = plt.subplots(figsize=(8, 4), dpi=150)
17

18
# ========== 5. 绘制柱状图 ==========
19
colors = ['tab:red' if v > 10 else 'tab:blue' for v in y]
20
ax.bar(x, y, color=colors, edgecolor='k', linewidth=0.5)
21
ax.axhline(y=np.mean(y), color='k', linestyle='--',
22
           label=f'Mean = {np.mean(y):.1f}')
23

24
# ========== 6. 标签与标题 ==========
25
ax.set_xlabel('Month', fontsize=12)
26
ax.set_ylabel('Temperature (°C)', fontsize=12)
27
ax.set_title('Monthly Average Temperature', fontsize=14)
28
ax.legend(loc='upper left', frameon=False)
29
ax.tick_params(labelsize=10)
30
ax.grid(axis='y', alpha=0.3)
31

32
# ========== 7. 调整布局并保存 ==========
33
plt.tight_layout()
34
plt.savefig('monthly_temp.png', dpi=300, bbox_inches='tight')
35
plt.show()

展开收起

流程总结：导入 → 全局设置 → 准备数据 → 创建图形 → 绘图 → 标签/标题 → 布局调整 → 保存/显示。

快速参考速查表#

需求	函数/代码
中文支持	`plt.rcParams['font.sans-serif'] = ['SimHei']`
填色图	`ax.contourf(lon, lat, data, levels, cmap=...)`
等值线	`ax.contour(lon, lat, data, colors=...)`
等值线标注	`ax.clabel(cs, inline=True, fontsize=8, fmt='%d')`
散点图	`ax.scatter(x, y, c=..., s=..., marker='o')`
散点+回归+标注	`stats.linregress` + `ax.plot` + `ax.text`
气泡图	`ax.scatter(x, y, s=z, c=c_arr, cmap=...)`
折线图	`ax.plot(x, y, 'o-', c=..., marker=...)`
滑动平均	`y.rolling(window=13, center=True).mean()`
趋势线	`stats.linregress(x_num, y)` → `ax.plot`
柱状图	`ax.bar(x, y, width=..., color=...)`
水平线	`ax.axhline(y=0, color='k', linestyle='--')`
矢量图	`ax.quiver(X, Y, U, V, scale=..., transform=...)`
矢量图例	`ax.quiverkey(qv, X, Y, U, label, labelpos=...)`
误差棒	`ax.errorbar(x, y, yerr=[lo, hi], fmt='-o')`
填充面积	`ax.fill_between(x, y, where=..., color=...)`
显著性填色	`ax.contourf(lon, lat, sig, levels=[0.5,1.5], hatches=['..'], colors='none')`
色标	`fig.colorbar(cf, ax=ax, orientation=..., shrink=...)`
图例	`ax.legend(loc='best', frameon=False, ncol=2)`
标题	`ax.set_title('Title', fontsize=...)`
自动布局	`plt.tight_layout()`
手动经纬度标签	`ax.set_xticklabels([...])`
保存	`fig.savefig('out.png', dpi=300)`
间距调整	`plt.subplots_adjust(hspace=0.4, wspace=0.3)`

sacpy的简单用法

Wed, 15 Jul 2026 00:00:00 GMT

sacpy 使用方法指南#

本文档整理自 相关代码 目录中涉及 sacpy 的 Python 脚本，汇总了 sacpy 库在气象数据分析中的核心用法，包括距平计算、线性回归、EOF 分析及地图绘图增强。

一、安装#

Terminal window

1
pip install sacpy

二、距平计算 — scp.get_anom#

2.1 基本用法#

1
import sacpy as scp
2

3
ssta = scp.get_anom(sst, method=1)

2.2 参数说明#

参数	说明
`sst`	xarray DataArray，维度 (time, lat, lon)
`method=1`	方法1：逐月去气候态（减去各月多年平均），即去季节循环

2.3 完整示例（来源：ENSO_regression_sacpy.py<16>）#

1
import xarray as xr
2
import sacpy as scp
3

4
ds = xr.open_dataset('sst.mnmean.nc')
5
sst = ds['sst'].sel(time=slice('1950','2020'))
6
sst = scp.get_anom(sst, method=1)

2.4 多变量批量去距平（来源：Nino12_regression_sst_uv_sacpy.py<24-26>）#

1
sst  = scp.get_anom(sst,  method=1)
2
uwnd = scp.get_anom(uwnd, method=1)
3
vwnd = scp.get_anom(vwnd, method=1)

三、线性回归 — scp.LinReg#

3.1 基本用法#

1
LinReg = scp.LinReg(index, field)
2
slope   = LinReg.slope       # 回归系数场 (lat, lon)
3
p_value = LinReg.p_value     # p 值场 (lat, lon)

3.2 参数说明#

参数	说明
`index`	一维时间序列（如 Nino34 指数），形状 (time,)
`field`	二维或三维场（如 SST），形状 (time, lat, lon)

3.3 返回值属性#

属性	说明
`.slope`	回归系数场（斜率），形状与 field 的空间维度一致
`.p_value`	p 值场，形状与 slope 一致

3.4 完整示例（来源：ENSO_regression_sacpy.py<18-21>）#

1
# 计算 Nino34 指数
2
nino34 = sst.loc[:, 5:-5, 190:240].mean(dim=['lat', 'lon'])
3

4
# 线性回归：将 SST 场回归到 Nino34 指数
5
LinReg = scp.LinReg(nino34, sst)
6
slope   = LinReg.slope
7
p_value = LinReg.p_value

3.5 多变量逐个回归（来源：Nino12_regression_sst_uv_sacpy.py<28-35>）#

1
nino12 = sst.loc[:, 10:0, 270:280].mean(dim=['lat', 'lon'])
2

3
map_sst  = scp.LinReg(nino12, sst)
4
map_uwnd = scp.LinReg(nino12, uwnd)
5
map_vwnd = scp.LinReg(nino12, vwnd)

3.6 显著性过滤#

1
import numpy as np
2

3
# 将不显著的格点设为 NaN（绘图时不显示）
4
sst_tmp  = np.where(map_sst.p_value >= 0.05, np.nan, map_sst.slope)
5
uwnd_tmp = np.where(map_uwnd.p_value >= 0.10, np.nan, map_uwnd.slope)
6
vwnd_tmp = np.where(map_vwnd.p_value >= 0.10, np.nan, map_vwnd.slope)

参数	说明
`condition`	条件表达式，如 `p_value >= 0.05`
`np.nan`	满足条件时的替换值
`map.slope`	不满足条件时的原值

四、EOF 分析 — scp.EOF#

4.1 基本用法#

1
eof = scp.EOF(ssta)                      # 初始化
2
eof.solve()                              # 求解
3
pc    = eof.get_pc(npt=3)                # 获取 PC（时间序列）
4
pt    = eof.get_pt(npt=3)                # 获取空间模态
5
pcvar = eof.get_varperc(npt=3) * 100     # 解释方差百分比（%）

4.2 方法说明#

方法	参数	说明
`scp.EOF(data)`	`data`	输入距平场 (time, lat, lon)
`.solve()`	—	执行 EOF 分解
`.get_pc(npt)`	`npt`	返回前 npt 个主成分，形状 (npt, time)
`.get_pt(npt)`	`npt`	返回前 npt 个空间模态，形状 (npt, lat, lon)
`.get_varperc(npt)`	`npt`	返回前 npt 个模态的方差占比（小数，需 ×100 得百分比）

4.3 完整示例（来源：EOF_sst_sacpy.py<16-25>）#

1
import xarray as xr
2
import sacpy as scp
3

4
ds = xr.open_dataset('sst.mnmean.nc')
5
sst = ds['sst'].sel(time=slice('1950','2020')).loc[:, 30:-30, 90:300]
6

7
# 计算距平
8
ssta = scp.get_anom(sst, method=1)
9

10
# EOF 计算
11
eof = scp.EOF(ssta)
12
eof.solve()
13

14
# 获取 PC 和空间模态
15
pc = -eof.get_pc(npt=3)       # 取负号可翻转符号，视需求而定
16
pt = -eof.get_pt(npt=3)
17

18
# 获取解释方差百分比
19
pcvar = eof.get_varperc(npt=3) * 100

展开收起

注意：PC 和 pattern 的符号可同时取反而不会改变物理意义，这与求解器内部约定有关。

4.4 绘制 EOF 模态与 PC（来源：EOF_sst_sacpy.py<31-55>）#

1
import matplotlib.pyplot as plt
2
import cartopy.crs as ccrs
3
import sacpy.Map
4

5
fig = plt.figure(figsize=[9, 10])
6
for i in range(3):
7
    # EOF 空间模态
8
    ax = fig.add_subplot(3, 2, 2*i+1,
9
                         projection=ccrs.PlateCarree(central_longitude=180))
10
    m1 = ax.scontourf(lon, lat, pt[i, :, :], cmap='RdBu_r',
11
                      levels=np.linspace(-0.75, 0.75, 15), extend="both")
12
    ax.scontour(m1, colors="black")
13
    ax.init_map(smally=2.5)
14
    ax.set_title("EOF-{} ({:.2f}%)".format(i+1, pcvar[i]))
15

16
    # PC 时间序列
17
    ax = fig.add_subplot(3, 2, 2*i+2)
18
    ax.plot(sst.time, pc[i])
19
    ax.set_title("PC-{}".format(i+1))
20

21
# colorbar
22
cb_ax = fig.add_axes([0.1, 0.06, 0.4, 0.02])
23
fig.colorbar(m1, cax=cb_ax, orientation="horizontal")

展开收起

五、sacpy.Map 绘图增强#

sacpy.Map 在导入后会自动为 matplotlib/cartopy 的 Axes 对象注册扩展方法，无需额外初始化。

5.1 ax.scontourf — 填充等值线#

1
m = ax.scontourf(lon, lat, data, cmap='RdBu_r',
2
                 levels=np.arange(-1.2, 1.4, 0.2), extend="both")

参数	说明
`lon, lat`	经纬度坐标
`data`	二维数据数组 (lat, lon)
`cmap`	色标，如 `'RdBu_r'`
`levels`	等值线层级，可传入整数或 np.arange / np.linspace 生成的具体值
`extend`	色标延伸：`"both"` 两端延伸，`"min"`, `"max"`, `"neither"`

5.2 ax.scontour — 叠加等值线#

在已有填充等值线上叠加黑色等值线：

1
ax.scontour(m, colors="black")

参数	说明
`m`	`scontourf` 返回的对象，沿用其 levels
`colors`	等值线颜色，如 `"black"`

5.3 ax.init_map — 地图初始化#

自动添加海岸线、设置经纬度刻度：

1
ax.init_map(stepx=50, stepy=20, smallx=10, smally=5)

参数	说明
`stepx`	大刻度经度间隔（度）
`stepy`	大刻度纬度间隔（度）
`smallx`	小刻度经度间隔（度）
`smally`	小刻度纬度间隔（度）

init_map 等价于自动调用 ax.coastlines() + 经纬度刻度设置，简化了 cartopy 的绘图流程。

5.4 ax.sig_plot — 显著性打点#

在图上对通过显著性检验的格点打点标记：

1
ax.sig_plot(lon, lat, p_value, thrshd=0.05, color='gray')

参数	说明
`lon, lat`	经纬度坐标
`p_value`	p 值场 (lat, lon)
`thrshd`	显著性阈值，如 `0.05` 或 `0.10`
`color`	打点颜色，如 `'gray'`

工作原理：将 p_value < thrshd 的格点用指定颜色打点（散点），常用于回归图或合成图的显著性标记。

5.5 ax.squiver — 风场矢量图#

在地图上叠加风场箭头（矢量）：

1
ax.squiver(uwnd.lon, uwnd.lat, uwnd_tmp, vwnd_tmp,
2
           stepx=4, stepy=2, width=0.004)

参数	说明
`lon, lat`	风场格点的经纬度坐标
`u, v`	纬向风和经向风分量
`stepx`	经度方向间隔抽取（隔几个格点画一个箭头）
`stepy`	纬度方向间隔抽取
`width`	箭头线宽

squiver 自动处理间隔抽取，避免箭头过于密集。

5.6 绘图完整示例（来源：ENSO_regression_sacpy.py<24-32>）#

1
import sacpy.Map
2
import matplotlib.pyplot as plt
3
import cartopy.crs as ccrs
4

5
ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=180))
6

7
# 填充等值线
8
m = ax.scontourf(sst.lon, sst.lat, LinReg.slope, cmap='RdBu_r', extend="both")
9
# 叠加等值线
10
ax.scontour(m, colors="black")
11
# 地图初始化
12
ax.init_map(stepx=50, stepy=20, smallx=10, smally=5)
13
# 设置地图范围
14
ax.set_extent([0, 358, -60, 60])
15
# 显著性打点
16
ax.sig_plot(sst.lon, sst.lat, LinReg.p_value, thrshd=0.05, color='gray')
17
ax.set_title("Nino34 Regression Map", fontsize=18)

展开收起

5.7 SST + 风场叠加绘图示例（来源：Nino12_regression_sst_uv_sacpy.py<46-76>）#

1
fig = plt.figure(figsize=[9, 5])
2
ax = fig.add_subplot(projection=ccrs.PlateCarree(central_longitude=180))
3

4
# 填充等值线（SST 回归系数）
5
m1 = ax.scontourf(sst.lon, sst.lat, sst_tmp, cmap='RdBu_r',
6
                  levels=np.arange(-1.2, 1.4, 0.2), extend="both")
7
ax.init_map(stepx=50, stepy=20, smallx=10, smally=5)
8
ax.set_extent([0, 358, -60, 60])
9

10
# 显著性打点
11
ax.sig_plot(sst.lon, sst.lat, map_sst.p_value, thrshd=0.10, color='gray')
12

13
# 风场矢量叠加
14
ax.squiver(uwnd.lon, uwnd.lat, uwnd_tmp, vwnd_tmp,
15
           stepx=4, stepy=2, width=0.004)
16

17
ax.set_title("SSTA Regression Map (Nino1+2)", fontsize=20)
18

19
# colorbar
20
plt.colorbar(m1, orientation='horizontal', shrink=0.7)

展开收起

六、sacpy 与手动实现对比#

功能	手动实现	sacpy
距平计算	`groupby('time.month').mean()` → 相减	`scp.get_anom(data, method=1)`
线性回归	`np.linalg.lstsq` + 手算 p 值	`scp.LinReg(index, field)`
EOF 分析	`eofs.standard.Eof(data, weights)` 逐步骤操作	`scp.EOF(data)` → `.solve()`
地图填充	`ax.contourf()` + 手动 transform	`ax.scontourf()` 自动处理投影
显著性打点	手动 `np.where` + `scatter`	`ax.sig_plot()` 一行搞定
风场矢量	`ax.quiver()` + 手动抽取	`ax.squiver()` 自动抽取间隔

七、核心 API 速查表#

需求	代码
去气候态	`scp.get_anom(sst, method=1)`
线性回归	`LinReg = scp.LinReg(index, field)`
回归系数	`LinReg.slope`
回归 p 值	`LinReg.p_value`
EOF 初始化	`eof = scp.EOF(ssta)`
EOF 求解	`eof.solve()`
获取 PC	`pc = eof.get_pc(npt=3)`
获取模态	`pt = eof.get_pt(npt=3)`
方差占比	`pcvar = eof.get_varperc(npt=3) * 100`
填充等值线	`ax.scontourf(lon, lat, data, cmap='RdBu_r', extend="both")`
叠加等值线	`ax.scontour(m, colors="black")`
地图初始化	`ax.init_map(stepx=50, stepy=20)`
显著性打点	`ax.sig_plot(lon, lat, p_value, thrshd=0.05, color='gray')`
风场矢量	`ax.squiver(lon, lat, u, v, stepx=4, stepy=2)`

硫磺皂的技术站

gFortran编译器使用指南

终端 gFortran#

0. 环境配置#

1. 最基本的编译命令#

1.1 编译并链接生成可执行文件#

1.2 只编译，不链接#

1.3 指定输出文件名#

2. 处理不同格式/预处理#

2.1 强制自由格式#

2.2 强制固定格式#

2.3 开启预处理#

2.4 关闭预处理#

3. 常用警告和检查选项#

3.1 打开常见警告#

3.2 更严格一些#

3.3 检查运行时错误#

4. 调试相关#

4.1 加调试信息#

4.2 适合调试的组合#

5. 常用优化选项#

5.1 常规优化#

5.2 更高优化#

5.3 发布版常见组合#

6. 数值/浮点相关#

6.1 启用浮点异常检查#

6.2 保留未优化的浮点行为#

7. 生成预处理后的源码#

7.1 只看预处理结果#

8. 模块和头文件搜索路径#

8.1 指定模块/包含文件搜索路径#

9. 生成汇编代码#

9.1 输出汇编文件#

10. 查看版本和帮助#

10.1 查看版本#

10.2 查看帮助#

11. 常见编译模板#

11.1 新手调试模板#

11.2 正式编译模板#

11.3 多文件项目模板#

12. 常见问题对应命令#

12.1 文件里用了 #include，但没生效#

12.2 老代码扩展名不对，但内容是固定格式#

12.3 老代码扩展名不对，但内容是自由格式#

12.4 想查数组越界#

13. 最实用的一条总结#

conda使用指南

Conda 命令#

虚拟环境#

换源#

修改 .condarc 文件#

通过命令行修改#

Jupyter 相关#

库管理#

git使用指南

Git命令#

初次使用#

仓库#

暂存/提交更改#

分支#

拉取与推送#

版本回滚#

sacpy使用指南

sacpy 文档合集#

经验正交函数（EOF）分析#

导入#

class EOF#

EOF(data, weights=None)#

solve(method="eig", st=False, dim_min=10, chunks=None)#

get_eign(npt=4)#

get_varperc(npt=None)#

north_test(npt=10, perc=False, ddof=None)#

get_pc(npt=None, scaling="std")#

get_pt(npt=None, scaling="mstd")#

correlation_map(npt)#

projection(proj_field, npt=None, scaling="std")#

decoder(pcs)#

load_pt(patterns)#

完整示例：EOF 分析+绘图#

奇异值分解（SVD）/ 最大协方差分析（MCA）#

12.1 文件里用了 `#include`，但没生效#

`class EOF`#

`EOF(data, weights=None)`#

`solve(method="eig", st=False, dim_min=10, chunks=None)`#

`get_eign(npt=4)`#

`get_varperc(npt=None)`#

`north_test(npt=10, perc=False, ddof=None)`#

`get_pc(npt=None, scaling="std")`#

`get_pt(npt=None, scaling="mstd")`#

`correlation_map(npt)`#

`projection(proj_field, npt=None, scaling="std")`#

`decoder(pcs)`#

`load_pt(patterns)`#

`class SVD`#

`SVD(data1, data2, complex=False)`#

`solve()`#

`get_eign()`#

`get_varperc(npt)`#

`get_pc(npt, norm="std")`#

`get_pt(npt, norm="std")`#

`get_homogeneous_map(npt=3, norm="std")`#

`get_heterogeneous_map(npt=3, norm="std")`#

`get_var_contribution(npt=3)`#

`class LinReg`#

`LinReg(x, y, neff=None)`#

`LinReg.mask(threshold=0.05)`#

`class MultLinReg`#

`MultLinReg(x, y, cal_sim=True)`#

`MultLinReg.cal_corr()`#

`MultLinReg.cal_paritial_corr(idx)`#

`class M2mLinReg`#

`M2mLinReg(x, y)`#

`class SpaceCorr`#

`SpaceCorr(x, y)`#

`linear_reg(x, y, neff=None)`#

`multi_linreg(x, y)`#

`partial_corr(x, y, idx, mul_corr=None)`#

`multi_corr(x, y)`#

`class STMV`#

`STMV(data1, data2=None, wrap=True, *param, **kwargs)`#

`STMV.get_original_data()`#

`one_mean_test(data, expected_mean=None, *param)`#

`two_mean_test(data1, data2, *param)`#

`class Spectral`#

`Spectral(x, M_length, overlap=0.5, remove_trend=True, remove_annual=True, normalize_series=True, prewhiten=False)`#

`Spectral.get_spectra(normalize_spectrum=True, detrend='linear', **kwargs)`#

`Spectral.get_red_noise(method='fit_theory')`#

`Spectral.get_rs_sig(p_crit=0.99)`#

`class CrossSpectral(Spectral)`#

`CrossSpectral(x, y, M_length, overlap=0.5, ...)`#

`CrossSpectral.get_spectra(normalize_spectrum=True, detrend='linear', **kwargs)`#

`CrossSpectral.get_red_noise(method='fit_theory')`#

`CrossSpectral.get_rs_sig(p_crit=0.99)`#

`CrossSpectral.get_cross_spectra(detrend='linear', **kwargs)`#

`CrossSpectral.get_coh_sig(p_crit=0.99)`#

`autocorr(x)`#

`get_levels(data, percentile=98, num_level=13, zero_sym=True)`#

`scontourf(*args, **kwargs)`#

`spcolormesh(*args, **kwargs)`#

`scontour(*args, **kwargs)`#

`squiver(*args, **kwargs)`#

`init_map(same_size=True, coastlines=True, draw_ticks=True, **kwargs)`#

`draw_ticks(extend, stepx=None, stepy=None, ...)`#

`sig_plot(x, y, pvalue, thrshd=0.05, marker="..", color=None)`#

`xr.DataArray.splot(ax=None, label=0, projection=None, kw1={}, kw2={})`#