PixiPackageManagerSkill pixi-package-manager

pixi-package-manager 快速、可复现的科学Python环境，使用pixi - conda和PyPI统一

Pixi 包管理器用于科学Python

掌握 pixi，这个现代的包管理器统一了conda和PyPI生态系统，用于快速、可复现的科学Python开发。学习如何管理复杂的科学依赖项，创建隔离的环境，并使用pyproject.toml集成构建可复现的工作流。

官方文档：https://pixi.sh GitHub：https://github.com/prefix-dev/pixi

快速参考卡

设置

# 必须单独执行安装
# 在服务器上，如果尚未在路径中，则通过lmod加载
module load Dev/pixi

# 使用pyproject.toml初始化新项目
pixi init --format pyproject

# 初始化现有的Python项目
pixi init --format pyproject --import-environment

基本命令

# 添加依赖项
pixi add numpy scipy pandas              # conda包
pixi add --pypi pytest-cov               # 仅限PyPI的包
pixi add --feature dev pytest ruff       # 开发环境

# 安装所有依赖项
pixi install

# 在环境中运行命令
pixi run python script.py
pixi run pytest

# 激活环境的shell
pixi shell

# 添加任务
pixi task add test "pytest tests/"
pixi task add docs "sphinx-build docs/ docs/_build"

# 运行任务
pixi run test
pixi run docs

# 更新依赖项
pixi update numpy                         # 更新特定
pixi update                              # 更新全部

# 列出包
pixi list
pixi tree numpy                          # 显示依赖树

快速决策树：Pixi vs UV vs 两者

需要编译的科学库（NumPy、SciPy、GDAL）？
├─ 是 → 使用pixi（conda-forge有预构建的二进制文件）
└─ 否 → 考虑uv用于纯Python项目

需要多语言支持（Python + R、Julia、C++）？
├─ 是 → 使用pixi（支持conda生态系统）
└─ 否 → uv对Python-only足够

需要多个环境（开发、测试、生产、GPU、CPU）？
├─ 是 → 使用pixi功能进行环境管理
└─ 否 → 单一环境项目可以使用任一

需要跨平台可复现的环境？
├─ 至关重要 → 使用pixi（锁文件包括所有平台）
└─ 较不关键 → uv也提供锁文件

想同时使用conda-forge和PyPI包？
├─ 是 → 使用pixi（无缝集成）
└─ 仅限PYPI → uv更简单、更快

遗留的conda环境文件（environment.yml）？
├─ 是 → pixi可以导入和现代化
└─ 否 → 使用pixi或uv从头开始

使用此技能的时候

• 设置科学Python项目，具有复杂的编译依赖项（NumPy、SciPy、Pandas、scikit-learn、GDAL、netCDF4）
• 构建可复现的研究环境，在不同机器和平台上完全相同
• 管理多语言项目，结合Python与R、Julia、C++或Fortran
• 创建多个环境配置，用于不同的硬件（GPU/CPU）、测试场景或部署目标
• 用更快、更可靠的依赖关系解析替换conda/mamba工作流
• 开发依赖于conda-forge和PyPI包的包
• 从environment.yml或requirements.txt迁移到现代、可复现的工作流
• 运行自动化科学工作流，具有任务运行器和CI/CD集成
• 使用需要复杂C/Fortran依赖项的地理空间、气候或天文包

核心概念

1. 统一包管理（conda + PyPI）

Pixi解决来自conda-forge和PyPI的依赖项，在单个统一图中确保兼容性：

[project]
name = "my-science-project"
dependencies = [
    "numpy>=1.24",      # 来自conda-forge（优化构建）
    "pandas>=2.0",      # 来自conda-forge
]

[tool.pixi.pypi-dependencies]
my-custom-pkg = ">=1.0"        # 仅限PyPI的包

这对科学Python为什么重要：

• 从conda-forge获得优化的NumPy/SciPy构建（MKL、OpenBLAS）
• 使用在conda中不可用的PyPI包
• 单个锁文件确保所有依赖项兼容

2. 多平台锁文件

Pixi生成pixi.lock，包含所有平台（Linux、macOS、Windows、不同架构）的依赖项规范：

# pixi.lock包括：
# - linux-64
# - osx-64, osx-arm64
# - win-64

好处：

• 提交锁文件到git → 每个人都获得相同的环境
• 在合作者的不同操作系统上工作无需更改
• CI/CD使用与本地开发完全相同的版本

3. 基于特性的环境

使用特性创建多个环境，而不复制依赖项：

[tool.pixi.feature.test.dependencies]
pytest = ">=7.0"
pytest-cov = ">=4.0"

[tool.pixi.feature.gpu.dependencies]
pytorch-cuda = "11.8.*"

[tool.pixi.environments]
test = ["test"]
gpu = ["gpu"]
gpu-test = ["gpu", "test"]  # 组合特性

4. 任务自动化

将可重用的命令定义为任务：

[tool.pixi.tasks]
test = "pytest tests/ -v"
format = "ruff format src/ tests/"
lint = "ruff check src/ tests/"
docs = "sphinx-build docs/ docs/_build"
analyse = { cmd = "python scripts/analyze.py", depends-on = ["test"] }

5. 快速依赖关系解析

Pixi使用rattler（基于Rust的conda解析器）进行比conda快10-100倍的解析：

• 并行包下载
• 高效缓存
• 智能依赖求解器

6. pyproject.toml集成

Pixi从pyproject.toml读取标准Python项目元数据，实现：

• 项目配置的单一真实来源
• 与pip、uv等工具的兼容性
• 标准的Python打包工作流

快速开始

最小示例：数据分析项目

# 创建新项目
mkdir climate-analysis && cd climate-analysis
pixi init --format pyproject

# 添加科学栈
pixi add python=3.11 numpy pandas matplotlib xarray

# 添加开发工具
pixi add --feature dev pytest ipython ruff

# 创建分析脚本
cat > analyze.py << 'EOF'
import pandas as pd
import matplotlib.pyplot as plt

# 你的分析代码
data = pd.read_csv("data.csv")
data.plot()
plt.savefig("output.png")
EOF

# 在pixi环境中运行
pixi run python analyze.py

# 或激活shell
pixi shell
python analyze.py

示例：支持GPU的机器学习项目

# 初始化项目
pixi init ml-project --format pyproject
cd ml-project

# 添加基础依赖项
pixi add python=3.11 numpy pandas scikit-learn matplotlib jupyter

# 添加CPU PyTorch
pixi add --platform linux-64 --platform osx-arm64 pytorch torchvision cpuonly -c pytorch

# 创建GPU特性
pixi add --feature gpu pytorch-cuda=11.8 -c pytorch -c nvidia

# 添加开发工具
pixi add --feature dev pytest black mypy

# 在pyproject.toml中配置环境
cat >> pyproject.toml << 'EOF'

[tool.pixi.environments]
default = { solve-group = "default" }
gpu = { features = ["gpu"], solve-group = "default" }
dev = { features = ["dev"], solve-group = "default" }
EOF

# 安装并运行
pixi install
pixi run python train.py          # 使用默认（CPU）
pixi run --environment gpu python train.py  # 使用GPU

模式

模式1：将现有项目转换为Pixi

场景：您有一个现有项目，带有requirements.txt或environment.yml

解决方案：

# 从requirements.txt
cd existing-project
pixi init --format pyproject

# 从requirements.txt导入
while IFS= read -r package; do
    # 跳过注释和空行
    [[ "$package" =~ ^#.*$ ]] || [[ -z "$package" ]] && continue

    # 先尝试conda，回退到PyPI
    pixi add "$package" 2>/dev/null || pixi add --pypi "$package"
done < requirements.txt

# 从environment.yml
pixi init --format pyproject --import-environment environment.yml

# 验证安装
pixi install
pixi run python -c "import numpy, pandas, scipy; print('Success!')"

最佳实践：审查生成的pyproject.toml并组织依赖项：

• 核心运行时依赖项 → [project.dependencies]
• 仅限PyPI的包 → [tool.pixi.pypi-dependencies]
• 开发工具 → [tool.pixi.feature.dev.dependencies]

模式2：多环境科学工作流

场景：开发、测试、生产和GPU计算的不同环境

实现：

[project]
name = "research-pipeline"
version = "0.1.0"
dependencies = [
    "python>=3.11",
    "numpy>=1.24",
    "pandas>=2.0",
    "xarray>=2023.1",
]

# 开发工具
[tool.pixi.feature.dev.dependencies]
ipython = ">=8.0"
jupyter = ">=1.0"
ruff = ">=0.1"

[tool.pixi.feature.dev.pypi-dependencies]
jupyterlab-vim = ">=0.16"

# 测试工具
[tool.pixi.feature.test.dependencies]
pytest = ">=7.4"
pytest-cov = ">=4.1"
pytest-xdist = ">=3.3"
hypothesis = ">=6.82"

# GPU依赖项
[tool.pixi.feature.gpu.dependencies]
pytorch-cuda = "11.8.*"
cudatoolkit = "11.8.*"

[tool.pixi.feature.gpu.pypi-dependencies]
nvidia-ml-py = ">=12.0"

# 生产优化
[tool.pixi.feature.prod.dependencies]
python = "3.11.*"  # 固定确切版本

# 定义环境组合特性
[tool.pixi.environments]
default = { solve-group = "default" }
dev = { features = ["dev"], solve-group = "default" }
test = { features = ["test"], solve-group = "default" }
gpu = { features = ["gpu"], solve-group = "gpu" }
gpu-dev = { features = ["gpu", "dev"], solve-group = "gpu" }
prod = { features = ["prod"], solve-group = "prod" }

# 每个环境的任务
[tool.pixi.tasks]
dev-notebook = { cmd = "jupyter lab", env = { JUPYTER_CONFIG_DIR = ".jupyter" } }
test = "pytest tests/ -v --cov=src"
test-parallel = "pytest tests/ -n auto"
train-cpu = "python train.py --device cpu"
train-gpu = "python train.py --device cuda"
benchmark = "python benchmark.py"

用法：

# 开发
pixi run --environment dev dev-notebook

# 测试
pixi run --environment test test

# GPU训练
pixi run --environment gpu train-gpu

# 生产
pixi run --environment prod benchmark

模式3：科学库开发

场景：开发具有适当打包、测试和文档的科学Python包

结构：

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "mylib"
version = "0.1.0"
description = "科学计算库"
dependencies = [
    "numpy>=1.24",
    "scipy>=1.11",
]

[project.optional-dependencies]
viz = ["matplotlib>=3.7", "seaborn>=0.12"]

# 开发依赖项
[tool.pixi.feature.dev.dependencies]
ipython = "*"
ruff = "*"
mypy = "*"

# 测试依赖项
[tool.pixi.feature.test.dependencies]
pytest = ">=7.4"
pytest-cov = ">=4.1"
pytest-benchmark = ">=4.0"
hypothesis = ">=6.82"

# 文档依赖项
[tool.pixi.feature.docs.dependencies]
sphinx = ">=7.0"
sphinx-rtd-theme = ">=1.3"
numpydoc = ">=1.5"
sphinx-gallery = ">=0.14"

[tool.pixi.feature.docs.pypi-dependencies]
myst-parser = ">=2.0"

# 构建依赖项
[tool.pixi.feature.build.dependencies]
build = "*"
twine = "*"

[tool.pixi.environments]
default = { features = [], solve-group = "default" }
dev = { features = ["dev", "test", "docs"], solve-group = "default" }
test = { features = ["test"], solve-group = "default" }
docs = { features = ["docs"], solve-group = "default" }

# 开发工作流的任务
[tool.pixi.tasks]
# 开发
install-dev = "pip install -e ."
format = "ruff format src/ tests/"
lint = "ruff check src/ tests/"
typecheck = "mypy src/"

# 测试
test = "pytest tests/ -v"
test-cov = "pytest tests/ --cov=src --cov-report=html --cov-report=term"
test-fast = "pytest tests/ -x -v"
benchmark = "pytest tests/benchmarks/ --benchmark-only"

# 文档
docs-build = "sphinx-build docs/ docs/_build/html"
docs-serve = { cmd = "python -m http.server 8000 -d docs/_build/html", depends-on = ["docs-build"] }
docs-clean = "rm -rf docs/_build docs/generated"

# 构建和发布
build = "python -m build"
publish-test = { cmd = "twine upload --repository testpypi dist/*", depends-on = ["build"] }
publish = { cmd = "twine upload dist/*", depends-on = ["build"] }

# 组合工作流
ci = { depends-on = ["format", "lint", "typecheck", "test-cov"] }
pre-commit = { depends-on = ["format", "lint", "test-fast"] }

工作流：

# 初始设置
pixi install --environment dev
pixi run install-dev

# 开发周期
pixi run format        # 格式化代码
pixi run lint          # 检查样式
pixi run typecheck     # 类型检查
pixi run test          # 运行测试

# 或运行所有检查
pixi run ci

# 构建文档
pixi run docs-build
pixi run docs-serve    # 在http://localhost:8000查看

# 发布工作流
pixi run build
pixi run publish-test  # 在TestPyPI上测试
pixi run publish       # 发布到PyPI

模式4：Conda + PyPI依赖策略

场景：优化依赖源以提高性能和可用性

策略：

[project]
dependencies = [
    # 核心科学栈：优先选择conda-forge（优化构建）
    "numpy>=1.24",           # MKL或OpenBLAS优化
    "scipy>=1.11",           # 优化的BLAS/LAPACK
    "pandas>=2.0",           # 优化的pandas
    "matplotlib>=3.7",       # 编译组件
    "scikit-learn>=1.3",     # 优化算法

    # 地理空间/气候：conda-forge必备（C/Fortran依赖）
    "xarray>=2023.1",
    "netcdf4>=1.6",
    "h5py>=3.9",
    "rasterio>=1.3",         # GDAL依赖

    # 数据处理：优先选择conda-forge
    "dask>=2023.1",
    "numba>=0.57",           # LLVM依赖
]

[tool.pixi.pypi-dependencies]
# 纯Python包或仅限PyPI的包
my-custom-tool = ">=1.0"
experimental-lib = { git = "https://github.com/user/repo.git" }
internal-pkg = { path = "../internal-pkg", editable = true }

决策规则：

1. 使用conda-forge（pixi add）：

   • NumPy、SciPy、Pandas（优化构建）
   • 包含C/C++/Fortran扩展的包（GDAL、netCDF4、h5py）
   • 包含复杂系统依赖的包（Qt、OpenCV）
   • R、Julia或其他语言包

2. 使用PyPI（pixi add --pypi）：

   • 纯Python包或不在conda-forge中的包
   • conda-forge包装之前的领先版本
   • 内部/私有包
   • 开发中的可编辑本地包

模式5：可复现研究环境

场景：确保研究在时间和机器上可复现

实现：

[project]
name = "nature-paper-2024"
version = "1.0.0"
description = "自然论文2024分析"
requires-python = ">=3.11,<3.12"  # 固定Python版本范围

dependencies = [
    "python=3.11.6",      # 确切的Python版本
    "numpy=1.26.2",       # 确切版本以实现可复现性
    "pandas=2.1.4",
    "scipy=1.11.4",
    "matplotlib=3.8.2",
    "scikit-learn=1.3.2",
]

[tool.pixi.pypi-dependencies]
# 使用确切的哈希值以实现终极可复现性
seaborn = "==0.13.0"

# 分析环境
[tool.pixi.feature.analysis.dependencies]
jupyter = "1.0.0"
jupyterlab = "4.0.9"

[tool.pixi.feature.analysis.pypi-dependencies]
jupyterlab-vim = "0.16.0"

# 环境
[tool.pixi.environments]
default = { solve-group = "default" }
analysis = { features = ["analysis"], solve-group = "default" }

# 可复现任务
[tool.pixi.tasks]
# 数据处理流程
download-data = "python scripts/01_download.py"
preprocess = { cmd = "python scripts/02_preprocess.py", depends-on = ["download-data"] }
analyze = { cmd = "python scripts/03_analyze.py", depends-on = ["preprocess"] }
visualize = { cmd = "python scripts/04_visualize.py", depends-on = ["analyze"] }
full-pipeline = { depends-on = ["download-data", "preprocess", "analyze", "visualize"] }

# 笔记本执行
run-notebooks = "jupyter nbconvert --execute --to notebook --inplace notebooks/*.ipynb"

最佳实践：

# 生成锁文件
pixi install

# 提交锁文件到仓库
git add pixi.lock pyproject.toml
git commit -m "锁定环境以实现可复现性"

# 任何人都可以重新创建确切环境
git clone https://github.com/user/nature-paper-2024.git
cd nature-paper-2024
pixi install  # 从pixi.lock安装确切版本

# 运行完整流程
pixi run full-pipeline

# 长期保存归档
pixi list --export environment.yml  # 备份为conda格式

模式6：跨平台开发

场景：团队成员在Linux、macOS（Intel/ARM）和Windows上

配置：

[project]
name = "cross-platform-science"
dependencies = [
    "python>=3.11",
    "numpy>=1.24",
    "pandas>=2.0",
]

# 平台特定的依赖项
[tool.pixi.target.linux-64.dependencies]
# Linux特定的优化构建
mkl = "*"

[tool.pixi.target.osx-arm64.dependencies]
# Apple Silicon优化
accelerate = "*"

[tool.pixi.target.win-64.dependencies]
# Windows特定包
pywin32 = "*"

# 平台特定的任务
[tool.pixi.tasks]
test = "pytest tests/"

[tool.pixi.target.linux-64.tasks]
test-gpu = "pytest tests/ --gpu"

[tool.pixi.target.win-64.tasks]
test = "pytest tests/ --timeout=30"  # 在Windows CI上较慢

平台选择器：

# 支持的平台
[tool.pixi.platforms]
linux-64 = true
linux-aarch64 = true
osx-64 = true
osx-arm64 = true
win-64 = true

模式7：任务依赖和工作流

场景：具有数据依赖的复杂科学工作流

实现：

[tool.pixi.tasks]
# 数据获取
download-raw = "python scripts/download.py --source=api"
validate-raw = { cmd = "python scripts/validate.py data/raw/", depends-on = ["download-raw"] }

# 数据处理流程
clean-data = { cmd = "python scripts/clean.py", depends-on = ["validate-raw"] }
transform = { cmd = "python scripts/transform.py", depends-on = ["clean-data"] }
feature-engineering = { cmd = "python scripts/features.py", depends-on = ["transform"] }

# 分析
train-model = { cmd = "python scripts/train.py", depends-on = ["feature-engineering"] }
evaluate = { cmd = "python scripts/evaluate.py", depends-on = ["train-model"] }
visualize = { cmd = "python scripts/visualize.py", depends-on = ["evaluate"] }

# 每个阶段的测试
test-cleaning = "pytest tests/test_clean.py"
test-transform = "pytest tests/test_transform.py"
test-features = "pytest tests/test_features.py"
test-model = "pytest tests/test_model.py"

# 组合工作流
all-tests = { depends-on = ["test-cleaning", "test-transform", "test-features", "test-model"] }
full-pipeline = { depends-on = ["download-raw", "validate-raw", "clean-data", "transform", "feature-engineering", "train-model", "evaluate", "visualize"] }
pipeline-with-tests = { depends-on = ["all-tests", "full-pipeline"] }

# 尽可能并行执行
[tool.pixi.task.download-supplementary]
cmd = "python scripts/download_supplement.py"

[tool.pixi.task.process-all]
depends-on = ["download-raw", "download-supplementary"]  # 并行运行

运行工作流：

# 运行整个流程
pixi run full-pipeline

# 运行带有测试
pixi run pipeline-with-tests

# 检查将运行的内容
pixi task list --summary

# 可视化任务依赖
pixi task info full-pipeline

模式8：与UV集成，用于纯Python开发

场景：使用pixi处理复杂依赖项，uv处理快速纯Python工作流

混合方法：

[project]
name = "hybrid-project"
dependencies = [
    # 通过pixi/conda的重型科学依赖项
    "python>=3.11",
    "numpy>=1.24",
    "scipy>=1.11",
    "gdal>=3.7",           # 复杂的C++依赖项
    "netcdf4>=1.6",        # Fortran依赖项
]

[tool.pixi.pypi-dependencies]
# 纯Python包
requests = ">=2.31"
pydantic = ">=2.0"
typer = ">=0.9"

[tool.pixi.feature.dev.dependencies]
ruff = "*"
mypy = "*"

[tool.pixi.feature.dev.pypi-dependencies]
pytest = ">=7.4"

[tool.pixi.tasks]
# 使用uv进行快速纯Python操作
install-dev = "uv pip install -e ."
sync-deps = "uv pip sync requirements.txt"
add-py-dep = "uv pip install"

工作流：

# Pixi管理带有conda包的环境
pixi install

# 激活pixi环境
pixi shell

# 在pixi shell内部，使用uv进行快速纯Python操作
uv pip install requests httpx pydantic  # 快速纯Python安装
uv pip freeze > requirements-py.txt

# 或定义为任务
pixi run install-dev

何时使用此模式：

• 项目需要conda进行编译依赖项（GDAL、netCDF、HDF5）
• 但也需要快速迭代纯Python依赖项
• 想要uv的速度用于锁定/安装纯Python包
• 需要conda的求解器来处理复杂的科学依赖图

模式9：CI/CD集成

场景：在GitHub Actions、GitLab CI等中进行可复现的测试

GitHub Actions示例：

# .github/workflows/test.yml
name: Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]

    steps:
      - uses: actions/checkout@v4

      - name: Setup Pixi
        uses: prefix-dev/setup-pixi@v0.4.1
        with:
          pixi-version: latest
          cache: true

      - name: Install dependencies
        run: pixi install --environment test

      - name: Run tests
        run: pixi run test

      - name: Upload coverage
        uses: codecov/codecov-action@v3
        with:
          file: ./coverage.xml

  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: prefix-dev/setup-pixi@v0.4.1
      - run: pixi run format --check
      - run: pixi run lint

  docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: prefix-dev/setup-pixi@v0.4.1
      - run: pixi run --environment docs docs-build
      - uses: actions/upload-artifact@v3
        with:
          name: documentation
          path: docs/_build/html

GitLab CI示例：

# .gitlab-ci.yml
image: ubuntu:latest

before_script:
  - curl -fsSL https://pixi.sh/install.sh | bash
  - export PATH=$HOME/.pixi/bin:$PATH

stages:
  - test
  - build

test:
  stage: test
  script:
    - pixi run test
  cache:
    key: ${CI_COMMIT_REF_SLUG}
    paths:
      - .pixi/

lint:
  stage: test
  script:
    - pixi run lint
    - pixi run typecheck

docs:
  stage: build
  script:
    - pixi run --environment docs docs-build
  artifacts:
    paths:
      - docs/_build/html

模式10：本地开发与远程计算集成

场景：本地开发，远程GPU集群上运行重型计算

本地配置（pyproject.toml）：

[project]
dependencies = [
    "numpy>=1.24",
    "pandas>=2.0",
]

[tool.pixi.feature.dev.dependencies]
jupyter = "*"
matplotlib = "*"

[tool.pixi.feature.remote.dependencies]
# 仅远程的重型GPU依赖项
pytorch-cuda = "11.8.*"
tensorboard = "*"

[tool.pixi.environments]
default = { features = ["dev"], solve-group = "default" }
remote = { features = ["remote"], solve-group = "remote" }

[tool.pixi.tasks]
notebook = "jupyter lab"
sync-remote = "rsync -av --exclude='.pixi' . user@remote:~/project/"
remote-train = { cmd = "ssh user@remote 'cd ~/project && pixi run train'", depends-on = ["sync-remote"] }

工作流：

# 本地开发（无GPU依赖项）
pixi install
pixi run notebook

# 推送到远程并训练
pixi run remote-train

# 或手动
pixi run sync-remote
ssh user@remote
cd ~/project
pixi install --environment remote  # 在远程安装GPU依赖项
pixi run --environment remote train

最佳实践清单

项目设置

• [ ] 使用pixi init --format pyproject新建项目
• [ ] 设置明确的Python版本约束（python>=3.11,<3.13）
• [ ] 按来源组织依赖项（conda与PyPI）
• [ ] 为开发、测试、文档环境创建单独的特性
• [ ] 定义常用工作流的有用任务
• [ ] 设置.gitignore以排除.pixi/目录

依赖管理

• [ ] 优先选择conda-forge的编译科学包（NumPy、SciPy、GDAL）
• [ ] 仅对纯Python或不在conda中的包使用PyPI
• [ ] 为可复现的研究固定确切版本
• [ ] 为库使用版本范围（允许更新）
• [ ] 指定求解组以隔离独立环境
• [ ] 定期使用pixi update获取安全补丁

可复现性

• [ ] 提交pixi.lock到版本控制
• [ ] 在锁文件中包含所有平台，以适应跨平台团队
• [ ] 在README中记录环境重建步骤
• [ ] 使用确切版本固定发布研究
• [ ] 定期从头开始测试环境
• [ ] 为长期保存归档环境

性能

• [ ] 使用pixi的并行下载（自动）
• [ ] 在CI/CD中利用缓存（prefix-dev/setup-pixi操作）
• [ ] 保持环境最小（仅必要的依赖项）
• [ ] 使用求解组隔离独立环境
• [ ] 使用pixi clean cache清理旧包

开发工作流

• [ ] 为常见操作定义任务（测试、lint、格式化）
• [ ] 使用任务依赖进行复杂工作流
• [ ] 需要时创建环境特定任务
• [ ] 使用pixi shell进行交互式开发
• [ ] 使用pixi run进行自动化脚本和CI
• [ ] 在发布前在干净环境中测试

团队协作

• [ ] 在README中记录pixi安装
• [ ] 为新贡献者提供快速入门命令
• [ ] 使用一致的命名约定，用于特性和环境
• [ ] 设置预提交钩子与pixi任务
• [ ] 集成CI/CD以进行自动化测试
• [ ] 保持pyproject.toml清晰且有良好注释

安全

• [ ] 定期审计依赖项（pixi list）
• [ ] 使用受信任的渠道（conda-forge、PyPI）
• [ ] 在PR中审查pixi.lock更改
• [ ] 保持pixi更新到最新版本
• [ ] 使用虚拟环境（pixi自动）
• [ ] 扫描依赖项中的漏洞

资源

官方文档

• Pixi网站：https://pixi.sh
• 文档：https://pixi.sh/latest/
• GitHub仓库：https://github.com/prefix-dev/pixi
• 配置参考：https://pixi.sh/latest/reference/project_configuration/

社区与支持

• Discord：https://discord.gg/kKV8ZxyzY4
• GitHub讨论：https://github.com/prefix-dev/pixi/discussions
• 问题跟踪器：https://github.com/prefix-dev/pixi/issues

相关技术

• Conda-forge：https://conda-forge.org/
• Rattler：https://github.com/mamba-org/rattler（底层求解器）
• PyPI：https://pypi.org/
• UV包管理器：https://github.com/astral-sh/uv

补充技能

• scientific-python-packaging：现代Python打包模式
• scientific-python-testing：使用pytest的测试策略
• uv-package-manager：快速纯Python包管理

学习资源

• Pixi示例：https://github.com/prefix-dev/pixi/tree/main/examples
• 迁移指南：https://pixi.sh/latest/switching_from/conda/
• 最佳实践：https://pixi.sh/latest/features/

常见问题与解决方案

问题：在Conda-forge中找不到包

问题：运行pixi add my-package时出现"找不到包"错误

解决方案：

# 搜索conda-forge
pixi search my-package

# 如果不在conda-forge中，使用PyPI
pixi add --pypi my-package

# 检查包在conda中的名称是否不同
# 例如：scikit-learn（PyPI）与sklearn（conda）
pixi add scikit-learn  # 正确的conda名称

问题：依赖项冲突

问题：依赖项求解器因"冲突"错误失败

解决方案：

# 检查依赖树
pixi tree numpy

# 使用求解组隔离冲突
[tool.pixi.environments]
env1 = { features = ["feat1"], solve-group = "group1" }
env2 = { features = ["feat2"], solve-group = "group2" }  # 分开求解

# 放宽版本约束
# 而不是：numpy==1.26.0
# 使用：numpy>=1.24,<2.0

# 强制特定频道优先
pixi add numpy -c conda-forge --force-reinstall

问题：环境创建缓慢

问题：pixi install花费很长时间

解决方案：

# 使用求解组避免重新求解所有内容
[tool.pixi.environments]
default = { solve-group = "default" }
test = { features = ["test"], solve-group = "default" }  # 重用默认求解

# 如果缓存损坏则清理缓存
pixi clean cache

# 检查大型依赖树
pixi tree --depth 2

# 更新pixi到最新版本
pixi self-update

问题：平台特定故障

问题：在Linux上工作，但在macOS/Windows上失败

解决方案：

# 使用平台特定依赖项
[tool.pixi.target.osx-arm64.dependencies]
# macOS ARM特定包
tensorflow-macos = "*"

[tool.pixi.target.linux-64.dependencies]
# Linux特定
tensorflow = "*"

# 排除不支持的平台
[tool.pixi.platforms]
linux-64 = true
osx-arm64 = true
# 故意排除win-64如果不支持

问题：PyPI包安装失败

问题：pixi add --pypi package因构建错误失败

解决方案：

# 先从conda安装构建依赖项
pixi add python-build setuptools wheel

# 然后重试PyPI包
pixi add --pypi package

# 对于需要系统库的包
pixi add libgdal  # 系统库
pixi add --pypi gdal  # Python绑定

# 检查conda-forge版本是否存在
pixi search gdal  # 可能有编译版本

问题：环境激活中的脚本

问题：需要在pixi run之外运行脚本

解决方案：

# 使用pixi shell进行交互式会话
pixi shell
python script.py

# 对于自动化，始终使用pixi run
pixi run python script.py

# 在bash脚本中
#!/usr/bin/env bash
eval "$(pixi shell-hook)"
python script.py

# 在任务定义中
[tool.pixi.tasks]
run-script = "python script.py"  # 自动在环境中

问题：锁文件合并冲突

问题：Git合并时pixi.lock出现冲突

解决方案：

# 接受一个版本
git checkout --theirs pixi.lock  # 或--ours

# 重新生成锁文件
pixi install

# 提交重新生成的锁文件
git add pixi.lock
git commit -m "合并后重新生成锁文件"

# 预防：与团队协调更新
# 一个人一次更新依赖项

问题：缺少系统依赖项

问题：包在运行时因"找不到库"失败

解决方案：

# 检查环境中实际包含的内容
pixi list

# 明确添加系统库
pixi add libgdal proj geos  # 地理空间
pixi add hdf5 netcdf4  # 气候数据
pixi add mkl  # 优化的线性代数

# 尽可能使用conda
# 不要将系统包与conda包混合

问题：环境中找不到可执行文件

问题：pixi run mycommand因"命令未找到"失败

解决方案：

# 列出所有已安装的包
pixi list

# 检查包是否提供可执行文件
pixi add --help  # 文档

# 确保包在活动环境中
[tool.pixi.feature.dev.dependencies]
mypackage = "*"

[tool.pixi.environments]
default = { features = ["dev"] }  # 必须包括特性

# 或在特定环境中运行
pixi run --environment dev mycommand

问题：想要同时使用Pixi和Conda

问题：现有的conda环境，想要逐步迁移

解决方案：

# 导出现有conda环境
conda env export > environment.yml

# 导入到pixi项目
pixi init --format pyproject --import-environment environment.yml

# 或手动并行
conda activate myenv  # 激活conda环境
pixi shell  # 激活pixi环境（嵌套）

# 长期：完全迁移到pixi
# Pixi完全取代conda/mamba

问题：需要本地包的可编辑安装

问题：想要在pixi环境中开发本地包

解决方案：

[tool.pixi.pypi-dependencies]
mypackage = { path = ".", editable = true }

# 或对于相对路径
sibling-package = { path = "../sibling", editable = true }

# 开发模式安装
pixi install

# 源更改立即反映
pixi run python -c "import mypackage; print(mypackage.__file__)"

问题：需要不同的Python版本

问题：在Python 3.10、3.11、3.12上测试

解决方案：

[tool.pixi.feature.py310.dependencies]
python = "3.10.*"

[tool.pixi.feature.py311.dependencies]
python = "3.11.*"

[tool.pixi.feature.py312.dependencies]
python = "3.12.*"

[tool.pixi.environments]
py310 = { features = ["py310"], solve-group = "py310" }
py311 = { features = ["py311"], solve-group = "py311" }
py312 = { features = ["py312"], solve-group = "py312" }

# 测试所有版本
pixi run --environment py310 pytest
pixi run --environment py311 pytest
pixi run --environment py312 pytest

总结

Pixi通过统一conda和PyPI生态系统，具有极快的依赖关系解析、可复现的多平台锁文件和无缝的环境管理，彻底改变了科学Python开发。通过利用pyproject.toml集成，pixi提供了一种现代的、符合标准的管理复杂科学依赖项的方法，同时保持与更广泛的Python生态系统的兼容性。

科学计算的主要优势：

1. 优化的科学包：访问conda-forge的预构建二进制文件，用于NumPy、SciPy等编译包，具有MKL/OpenBLAS优化
2. 简化复杂依赖项：处理需要C/Fortran/C++系统库的挑战性包，如GDAL、netCDF4和HDF5
3. 真正的可复现性：多平台锁文件确保在Linux、macOS和Windows上获得相同的环境
4. 灵活的环境管理：基于特性的环境适用于开发/测试/生产、GPU/CPU或任何自定义配置
5. 快速可靠：比conda快10-100倍，具有基于Rust的并行依赖关系解析
6. 任务自动化：内置任务运行器，用于科学工作流、测试和文档
7. 两全其美：无缝混合conda-forge优化包与PyPI的广泛生态系统

无论您是进行可复现研究、开发科学软件还是管理复杂的数据分析管道，pixi都为现代科学Python开发提供了坚实的基础。通过用pixi替换conda/mamba，您将获得速度、可靠性和现代工作流，同时完全访问科学Python生态系统。

准备好开始了吗？ 安装pixi，使用pixi init --format pyproject初始化您的项目，并体验科学Python包管理的未来。