vaex-dataframes

Vaex DataFrames

概述

Vaex 是一个高性能 Python 库，用于对大到无法装入 RAM 的数据集执行惰性、外存 DataFrame 操作。它通过内存映射文件和惰性求值，每秒处理超过 10 亿行数据，无需将数据加载到内存即可进行交互式探索和分析。

适用场景

• 处理大于可用 RAM 的表格数据集（10 GB 至数 TB）
• 对海量数据集执行快速统计聚合（十亿行规模下的均值、标准差、分位数）
• 无需抽样即可为大型数据集创建可视化图表（热力图、直方图）
• 在大数据集上构建 ML 预处理工作流（缩放、编码、PCA）
• 在不同数据格式之间转换（将 CSV 转换为 HDF5/Arrow，以便快速重复访问）
• 使用不额外占用内存的虚拟列进行特征工程
• 处理天文目录、金融时间序列或大型科学数据集
• 对于适合装入 RAM 的数据，如果需要内存中运行速度，请改用 polars
• 对于分布式多节点计算，请改用 dask

前提条件

pip install vaex
# Optional extras:
pip install vaex-hdf5          # HDF5 support (recommended)
pip install vaex-arrow          # Apache Arrow support
pip install vaex-ml             # Machine learning transformers
pip install vaex-viz            # Visualization support
pip install vaex-jupyter        # Jupyter widget support
pip install s3fs gcsfs adlfs    # Cloud storage (S3, GCS, Azure)

需要 Python 3.7+。HDF5 和 Arrow 格式可实现即时内存映射加载；要获得最佳性能，CSV 需要先转换。

快速入门

import vaex
import numpy as np

df = vaex.from_arrays(
    x=np.random.normal(0, 1, 1_000_000),
    y=np.random.normal(0, 1, 1_000_000),
    category=np.random.choice(['A', 'B', 'C'], 1_000_000),
)

df['radius'] = (df.x**2 + df.y**2).sqrt()  # Virtual column, zero memory
df_inner = df[df.radius < 1.0]              # Filtered view
print(df_inner.radius.mean())               # ~0.48

result = df.groupby('category').agg({'radius': 'mean'})
print(result)  # shape: (3, 2)

df.export_hdf5('/tmp/sample.hdf5')          # Export to efficient format
df2 = vaex.open('/tmp/sample.hdf5')         # Future loads are instant
print(f"Loaded {len(df2):,} rows instantly")

核心 API

1. DataFrame 创建与 I/O

从文件、数组、pandas 或 Arrow 表创建 DataFrame。HDF5 和 Arrow 文件采用内存映射，可即时加载。

import vaex
import numpy as np

# From files (HDF5/Arrow are instant via memory mapping)
df = vaex.open('data.hdf5')       # Recommended: instant, memory-mapped
df = vaex.open('data.arrow')      # Also instant, memory-mapped
df = vaex.open('data.parquet')    # Fast, columnar, compressed
df = vaex.open('data_*.hdf5')     # Wildcards: multiple files as one DataFrame

# From CSV (slow for large files — convert to HDF5)
df = vaex.from_csv('data.csv', convert='data.hdf5')  # Auto-converts

# From Python objects
df = vaex.from_arrays(x=np.arange(100), y=np.random.rand(100))
df = vaex.from_dict({'name': ['Alice', 'Bob'], 'age': [30, 25]})
df = vaex.from_pandas(pd.DataFrame({'a': [1, 2, 3]}), copy_index=False)

# From Arrow table
import pyarrow as pa
df = vaex.from_arrow_table(pa.table({'x': [1, 2, 3]}))

# Inspect
print(df.shape)          # (rows, cols)
print(df.column_names)   # Column names
df.describe()            # Statistical summary

# Export
df.export_hdf5('out.hdf5')                             # Recommended
df.export_arrow('out.arrow')                            # Interoperability
df.export_parquet('out.parquet', compression='snappy')   # Compressed
df.export_parquet('s3://bucket/data.parquet')            # Cloud storage

2. 筛选与选择

使用布尔表达式筛选行。命名选择允许对多个子集计算统计数据，而无需创建新的 DataFrame。

import vaex
import numpy as np

df = vaex.from_arrays(
    age=np.array([22, 35, 45, 19, 60]),
    salary=np.array([30000, 70000, 90000, 25000, 120000]),
    dept=np.array(['Eng', 'Sales', 'Eng', 'Sales', 'Eng']),
)

# Boolean filtering (creates a view, no copy)
df_eng_high = df[(df.dept == 'Eng') & (df.salary > 50000)]
print(len(df_eng_high))  # 2

# isin, between, string/null checks
df_mid = df[df.age.between(25, 50)]
# df[df.name.str.contains('Ali')], df[df.salary.notna()]

# Named selections (more efficient for multiple aggregations)
df.select(df.age >= 30, name='senior')
df.select(df.dept == 'Eng', name='engineers')
mean_senior = df.salary.mean(selection='senior')
mean_eng = df.salary.mean(selection='engineers')
print(f"Senior avg: {mean_senior}, Eng avg: {mean_eng}")
# Senior avg: 93333.33, Eng avg: 80000.0

3. 虚拟列与表达式

虚拟列按需计算，不产生任何内存开销。它们是 Vaex 高效运行的核心。

import vaex
import numpy as np

df = vaex.from_arrays(
    price=np.array([10.0, 20.0, 30.0, 40.0]),
    quantity=np.array([5, 3, 8, 2]),
    discount=np.array([0.0, 0.1, 0.0, 0.2]),
)

# Arithmetic (virtual columns — no memory used)
df['revenue'] = df.price * df.quantity * (1 - df.discount)
df['log_price'] = df.price.log()

# Conditional logic
df['tier'] = (df.price >= 30).where('premium', 'standard')

# Math: .abs(), .sqrt(), .log(), .log10(), .exp(), .sin(), .cos(),
#        .round(n), .floor(), .ceil(), .astype('float64')

# Check virtual vs materialized
print(df.get_column_names(virtual=False))  # Materialized only

# Materialize when needed (complex expr used repeatedly)
df['revenue_mat'] = df.revenue.values  # Now stored in memory

4. 聚合与 GroupBy

高效聚合数十亿行数据。使用 delay=True 可将多个操作批处理为一次数据遍历。

import vaex
import numpy as np

np.random.seed(42)
n = 100_000
df = vaex.from_arrays(
    sales=np.random.uniform(10, 500, n),
    quantity=np.random.randint(1, 20, n),
    region=np.random.choice(['East', 'West', 'North'], n),
)

# Single-column aggregations
print(f"Mean: {df.sales.mean():.2f}, Std: {df.sales.std():.2f}")
# Also: .min(), .max(), .minmax(), .sum(), .count(), .nunique(),
#   .quantile(0.5), .median_approx(), .kurtosis(), .skew()
#   .correlation(df.x, df.y), .covar(df.x, df.y)

# Batch aggregations with delay=True (single pass through data)
mean_s = df.sales.mean(delay=True)
std_s = df.sales.std(delay=True)
sum_q = df.quantity.sum(delay=True)
results = vaex.execute([mean_s, std_s, sum_q])
print(f"Mean: {results[0]:.2f}, Std: {results[1]:.2f}, Total qty: {results[2]}")

# GroupBy
grouped = df.groupby('region').agg({'sales': ['sum', 'mean'], 'quantity': 'sum'})
print(grouped)  # shape: (3, 4)

# Multi-dimensional binned aggregation (for heatmap data)
counts = df.count(binby=[df.sales, df.quantity],
                  limits=[[0, 500], [1, 20]], shape=(50, 19))
print(f"2D histogram shape: {counts.shape}")  # (50, 19)

5. 字符串与日期时间操作

通过 .str 访问器使用字符串方法；通过 .dt 访问器使用日期时间方法。

import vaex
import numpy as np

# String operations via .str accessor
df = vaex.from_dict({
    'name': ['Alice Smith', 'Bob Jones', 'Charlie Brown'],
    'email': ['[email protected]', '[email protected]', '[email protected]'],
})
df['email_clean'] = df.email.str.lower().str.strip()
df['first_name'] = df.name.str.split(' ')[0]
df['has_test'] = df.email_clean.str.contains('test')
# Also: .upper(), .title(), .startswith(), .endswith(), .len(),
#   .replace(), .pad(), .slice(start, end)

# DateTime operations via .dt accessor
dates = np.array(['2024-01-15', '2024-06-20', '2024-12-01'], dtype='datetime64')
df2 = vaex.from_arrays(timestamp=dates, value=np.array([100, 200, 300]))
df2['year'] = df2.timestamp.dt.year
df2['month'] = df2.timestamp.dt.month
df2['weekday'] = df2.timestamp.dt.dayofweek  # 0=Monday
# Also: .day, .hour, .minute, .second
print(df2[['timestamp', 'year', 'month']].head(3))

6. 可视化

Vaex 通过高效分箱对十亿行数据集进行可视化，使用全部数据而无需抽样。

import vaex
import numpy as np
import matplotlib.pyplot as plt

np.random.seed(0)
df = vaex.from_arrays(
    x=np.random.normal(0, 1, 500_000),
    y=np.random.normal(0, 1, 500_000),
    z=np.random.uniform(0, 10, 500_000),
)

# 1D histogram
df.plot1d(df.x, limits=[-4, 4], shape=80, figsize=(8, 4))
plt.title('X Distribution')
plt.savefig('hist1d.png', dpi=150, bbox_inches='tight')
plt.close()

# 2D density heatmap (core vaex visualization)
df.plot(df.x, df.y, limits='99.7%', shape=(256, 256),
        f='log', colormap='viridis', figsize=(8, 8))
plt.savefig('heatmap2d.png', dpi=150, bbox_inches='tight')
plt.close()

# Aggregation on grid (mean of z over x-y plane)
df.plot(df.x, df.y, what=df.z.mean(),
        limits=[[-3, 3], [-3, 3]], shape=(100, 100))
plt.savefig('mean_grid.png', dpi=150, bbox_inches='tight')
plt.close()
print("Saved: hist1d.png, heatmap2d.png, mean_grid.png")

7. ML 集成

vaex.ml 提供用于预处理、降维、聚类以及包装 scikit-learn 模型的转换器。所有转换器都会创建虚拟列（零内存开销）。

import vaex, vaex.ml
import numpy as np

np.random.seed(42)
n = 10_000
df = vaex.from_arrays(
    age=np.random.randint(18, 70, n).astype(float),
    income=np.random.uniform(20000, 150000, n),
    category=np.random.choice(['A', 'B', 'C'], n),
    target=np.random.randint(0, 2, n),
)

# Feature scaling (creates virtual columns: standard_scaled_age, ...)
scaler = vaex.ml.StandardScaler(features=['age', 'income'])
df = scaler.fit_transform(df)
# Also: MinMaxScaler, MaxAbsScaler, RobustScaler

# Categorical encoding
encoder = vaex.ml.LabelEncoder(features=['category'])
df = encoder.fit_transform(df)
# Also: OneHotEncoder, FrequencyEncoder, TargetEncoder, WeightOfEvidenceEncoder

# PCA
pca = vaex.ml.PCA(features=['standard_scaled_age', 'standard_scaled_income'],
                   n_components=2)
df = pca.fit_transform(df)
print(f"Explained variance: {pca.explained_variance_ratio_}")

# Scikit-learn bridge: wrap any sklearn model
from sklearn.ensemble import RandomForestClassifier
features = ['standard_scaled_age', 'standard_scaled_income',
            'label_encoded_category']
model = vaex.ml.sklearn.Predictor(
    features=features, target='target',
    model=RandomForestClassifier(n_estimators=50, random_state=42),
    prediction_name='rf_prediction',
)
train_df, test_df = df[:8000], df[8000:]
model.fit(train_df)
test_df = model.transform(test_df)  # Predictions as virtual columns
accuracy = (test_df.rf_prediction == test_df.target).mean()
print(f"Accuracy: {accuracy:.3f}")  # ~0.50 (random data)

# Save pipeline state (encoding + scaling + model)
train_df.state_write('pipeline_state.json')
# Deploy: prod_df.state_load('pipeline_state.json')

核心概念

惰性求值模型

Vaex 操作会构建表达式图，而不执行计算。只有在访问结果时（打印值、调用 .values、导出）才会触发求值。

import vaex, numpy as np
df = vaex.from_arrays(x=np.random.rand(1_000_000))

# NOT computed: virtual column, expression, filtered view
df['x_sq'] = df.x ** 2;  expr = df.x_sq.mean();  df_f = df[df.x > 0.5]

# COMPUTED: accessing value, .values, .to_pandas_df(), .export_hdf5()
print(f"Mean: {df.x.mean():.4f}")

虚拟列与物化列

方面	虚拟列	物化列
内存	零开销	存储完整数组
速度	每次使用时重新计算	即时访问
创建方式	df['col'] = expr	df['col'] = expr.values
适用场景	简单表达式、不常使用	反复使用的复杂表达式
检查方式	df.is_local('col') 返回 False	返回 True

经验法则： 除非同一个复杂表达式用于 3 次或更多次聚合，否则请保留列为虚拟列。

内存映射文件架构

HDF5 和 Apache Arrow 文件采用内存映射：操作系统会按需将文件页映射到虚拟内存，因此打开 100 GB 文件是即时的，且只占用极少 RAM。只有在访问数据页时，才会从磁盘读取。

# Opens instantly regardless of file size
df = vaex.open('100gb_dataset.hdf5')  # ~0.001s, minimal RAM
mean = df.column.mean()  # Streams through data, ~RSS stays low

格式对比

特性	HDF5	Arrow/Feather	Parquet	CSV
加载速度	即时	即时	快	慢
内存映射	是	是	否	否
压缩	可选（gzip、lzf、blosc）	否	默认（snappy、gzip、brotli）	否
列式存储	是	是	是	否
可移植性	良好	极佳	极佳	极佳
最适用于	本地 Vaex 工作流	跨语言互操作	分布式系统	数据交换

建议： 将 CSV 转换为 HDF5 一次（vaex.from_csv('data.csv', convert='data.hdf5')），之后所有加载操作都使用 HDF5。

常见工作流

工作流 1：大型 CSV 探索与转换

import vaex
import matplotlib.pyplot as plt

# Convert CSV to HDF5 (one-time); future loads instant
df = vaex.from_csv('large_data.csv', convert='large_data.hdf5')
print(f"Shape: {df.shape}, Columns: {df.column_names}")

# Feature engineering with virtual columns
df['log_value'] = df.value.log()
df['category_clean'] = df.category.str.lower().str.strip()
df['is_high'] = df.value > df.value.mean()

# Batch statistics (single pass)
delayed = [df.value.mean(delay=True), df.value.std(delay=True),
           df.value.quantile(0.5, delay=True), df.value.quantile(0.99, delay=True)]
results = vaex.execute(delayed)
print(f"Mean: {results[0]:.2f}, Std: {results[1]:.2f}, P99: {results[3]:.2f}")

# Visualize
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
df.plot1d(df.value, ax=axes[0], show=False)
axes[0].set_title('Value Distribution')
df.plot1d(df.log_value, ax=axes[1], show=False)
axes[1].set_title('Log Value Distribution')
plt.tight_layout()
plt.savefig('exploration.png', dpi=150, bbox_inches='tight')
plt.close()

工作流 2：带状态部署的机器学习流水线

import vaex, vaex.ml
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier

np.random.seed(42)
n = 50_000
df = vaex.from_arrays(
    age=np.random.randint(18, 70, n).astype(float),
    income=np.random.uniform(20000, 150000, n),
    region=np.random.choice(['East', 'West', 'Central'], n),
    target=np.random.randint(0, 2, n),
)
train, test = df[:40_000], df[40_000:]

# Preprocessing pipeline
train = vaex.ml.LabelEncoder(features=['region']).fit_transform(train)
train = vaex.ml.StandardScaler(features=['age', 'income']).fit_transform(train)

# Train model
features = ['standard_scaled_age', 'standard_scaled_income', 'label_encoded_region']
model = vaex.ml.sklearn.Predictor(
    features=features, target='target',
    model=GradientBoostingClassifier(n_estimators=50, random_state=42),
    prediction_name='prediction',
)
model.fit(train)

# Save pipeline state (encoding + scaling + model in one file)
train.state_write('ml_pipeline.json')

# Deploy: apply saved state to new data
test.state_load('ml_pipeline.json')
accuracy = (test.prediction == test.target).mean()
print(f"Test accuracy: {accuracy:.3f}")  # ~0.50 (random data)
# Production: prod_df = vaex.open('new_batch.hdf5'); prod_df.state_load('ml_pipeline.json')

关键参数

参数	模块	默认值	范围/选项	作用
shape	plot、plot1d	64（1D）、（256,256）（2D）	32-2048	直方图分箱数 / 热力图分辨率
limits	plot、plot1d	'minmax'	'99%'、'99.7%'、[min,max]	轴范围；基于百分位数处理异常值
f	plot	'identity'	'log'、'log10'、'sqrt'	密度图的颜色刻度变换
delay	聚合操作	False	True/False	将多个聚合操作批处理为一次遍历
convert	from_csv	None	文件路径字符串	加载时自动将 CSV 转换为 HDF5
chunk_size	from_csv	5,000,000	100K-50M	CSV 处理时每个分块的行数
n_components	PCA	2	1-n_features	主成分数量
n_clusters	KMeans	8	2-100+	簇的数量
features	所有机器学习转换器	必填	列名列表	要转换的列
compression	export_hdf5	None	'gzip'、'lzf'、'blosc'	在文件大小与 I/O 速度之间权衡

最佳实践

1. 重复访问时，务必将 CSV 转换为 HDF5 或 Arrow。 一次性转换在首次重新加载时就能收回成本：vaex.from_csv('data.csv', convert='data.hdf5')。

2. 除非必须物化，否则保持列为虚拟列。 虚拟列不占用内存。只有在复杂表达式会在 3 次或更多聚合操作中重复使用时，才进行物化。

3. 使用 delay=True 批处理聚合操作。 每次单独的聚合调用都会扫描整个数据集。通过 vaex.execute([df.x.mean(delay=True), df.x.std(delay=True)]) 进行批处理，可将 N 次遍历减少到 1 次。

4. 在多个子集上计算统计数据时，使用选择而不是创建经过筛选的 DataFrame。 df.select(df.age > 30, name='senior')，然后执行 df.salary.mean(selection='senior')，比创建 df_senior = df[df.age > 30] 更高效。

5. 处理大型数据时，避免使用 .values 和 .to_pandas_df()。 这些操作会将数据加载到 RAM 中，违背 Vaex 的设计目的。仅用于小型子集或样本。

6. 保存流水线状态以确保可复现性。 df.state_write('state.json') 会保存虚拟列、选择和机器学习转换器，便于部署。

7. 反模式——逐行迭代。 切勿在 Vaex 中逐行迭代。请改用向量化表达式和聚合操作。

常见配方

配方：多源数据整合

import vaex

# Load from multiple sources and formats
df_csv = vaex.from_csv('data_2022.csv')
df_hdf = vaex.open('data_2023.hdf5')
df_pq = vaex.open('data_2024.parquet')

# Concatenate vertically
df_all = vaex.concat([df_csv, df_hdf, df_pq])
print(f"Combined: {len(df_all):,} rows")

# Export as unified HDF5
df_all.export_hdf5('unified_data.hdf5')
# Future: vaex.open('unified_data.hdf5')

配方：处理缺失数据

import vaex
import numpy as np

df = vaex.from_arrays(
    x=np.array([1.0, np.nan, 3.0, np.nan, 5.0]),
    y=np.array([10, 20, 30, 40, 50]),
)

# Detect missing
missing_pct = df.x.isna().mean() * 100
print(f"Missing: {missing_pct:.0f}%")
# Missing: 40%

# Fill with value or column mean
df['x_filled'] = df.x.fillna(df.x.mean())

# Filter out missing
df_clean = df[df.x.notna()]
print(f"Clean rows: {len(df_clean)}")
# Clean rows: 3

配方：使用选择进行对比可视化

import vaex
import numpy as np
import matplotlib.pyplot as plt

df = vaex.from_arrays(
    value=np.concatenate([
        np.random.normal(50, 10, 200_000),
        np.random.normal(70, 15, 200_000),
    ]),
    group=np.array(['Control'] * 200_000 + ['Treatment'] * 200_000),
)

# Named selections for efficient comparison
df.select(df.group == 'Control', name='ctrl')
df.select(df.group == 'Treatment', name='treat')

plt.figure(figsize=(10, 5))
df.plot1d(df.value, selection='ctrl', label='Control', show=False)
df.plot1d(df.value, selection='treat', label='Treatment', show=False)
plt.legend()
plt.title('Distribution Comparison')
plt.savefig('comparison.png', dpi=150, bbox_inches='tight')
plt.close()
print("Saved comparison.png")

故障排除

问题	原因	解决方案
CSV 加载速度极慢	CSV 不支持内存映射；数据按行解析	转换一次：vaex.from_csv('data.csv', convert='data.hdf5')。之后加载时使用 HDF5
简单操作触发 MemoryError	对完整数据集调用 .values 或 .to_pandas_df()	保持操作惰性。检查时使用 .sample(n=1000).to_pandas_df()
2D 图为空白或全白	坐标轴范围与数据范围不匹配	使用 limits='99.7%' 或 limits='minmax'，而不是手动设置范围
热力图只显示一个亮点	线性色标受高密度区域影响	使用 f='log' 进行对数色阶缩放
在循环中虚拟列重新计算速度慢	每次访问都会重新计算复杂表达式	实体化：df['col'] = df.complex_expr.values
使用云路径时出现 FileNotFoundError	缺少文件系统库	安装 s3fs（S3）、gcsfs（GCS）或 adlfs（Azure）
含多个虚拟列时导出速度慢	导出期间会重新计算每个虚拟列	先实体化：df.materialize().export_hdf5('out.hdf5')
预期为数值的列被识别为字符串	CSV 自动检测选择了错误的类型	转换类型：df['col_num'] = df.col.astype('float64')
新数据导致 state_load 失败	状态中的列名与新 DataFrame 不匹配	确保新数据的列名与训练数据完全一致

打包资源

此条目在 references/ 中包含两个参考文件：

• references/io_performance.md -- 由原始的 io_operations.md（704 行）和 performance.md（572 行）合并而成。 涵盖：特定格式的 I/O 详情（HDF5 压缩选项、Parquet 压缩、Arrow 集成、FITS）、分块 I/O 处理、云存储（使用凭据的 S3/GCS/Azure）、Vaex 服务（远程数据）、数据库集成（通过 pandas 桥接读写 SQL）、状态文件（保存/加载流水线状态）、内存管理、并行计算（多线程、Dask 集成）、使用 Numba 进行 JIT 编译、异步操作，以及详细的性能分析和基准测试模式。 已整合至正文：格式比较表、CSV 到 HDF5 的转换模式、delay=True 批处理、内存映射架构说明、基本导出方法。 已省略：与主文件中已有内容重复的“最佳实践”列表；“相关资源”交叉链接（已由“打包资源”部分取代）。

• references/ml_visualization.md -- 由原始的 machine_learning.md（729 行）和 visualization.md（614 行）合并而成。 涵盖：完整的 ML 转换器目录（MinMaxScaler、MaxAbsScaler、RobustScaler、FrequencyEncoder、TargetEncoder、WeightOfEvidenceEncoder、CycleTransformer、Discretizer、RandomProjection）、KMeans 聚类、外部库集成（XGBoost、LightGBM、CatBoost、Keras）、交叉验证、特征选择、不平衡数据处理、高级可视化（等高线图、矢量场叠加、交互式 Jupyter 小组件、分面图、批量绘图、Plotly/seaborn 集成）。 已整合至正文：StandardScaler、LabelEncoder、OneHotEncoder、PCA、scikit-learn Predictor 封装器、基本的 plot1d/plot/what 模式、基于选择的可视化。 已省略：模型评估指标部分（标准 sklearn 指标，并非 Vaex 特有——请直接使用 scikit-learn）；“相关资源”交叉链接。

原始参考文件的处理情况：

• core_dataframes.md（368 行）——已全部整合至核心 API 模块 1（DataFrame 创建与 I/O）和关键概念。合并后的内容：正文中约 65 行，涵盖所有创建方法（open、from_csv、from_arrays、from_dict、from_pandas、from_arrow_table）、检查、导出和表达式基础。已省略：详细的行/列操作模式（由模块 2-4 涵盖）、复制/拼接模式（由实用方案涵盖）。
• data_processing.md（556 行）——已全部整合至核心 API 模块 2-5。筛选、虚拟列、表达式、聚合、groupby、字符串操作、日期时间操作、缺失数据、连接、列管理均已在正文中体现。已省略：高级分箱（searchsorted 模式、统计分箱细节）——属于小众用法，请查阅官方文档。

相关技能

• polars-dataframes -- 内存中的 DataFrame 库；数据可放入 RAM 时使用，可实现 10-100 倍的更快处理
• dask-parallel-computing -- 用于多节点集群以及并行 pandas/NumPy 的分布式计算
• pandas（计划中） -- 标准 Python DataFrame 库；Vaex 可通过 from_pandas/to_pandas_df 进行互操作

参考资料

• Vaex 文档：https://vaex.io/docs/latest/
• Vaex GitHub 仓库：https://github.com/vaexio/vaex
• Vaex PyPI：https://pypi.org/project/vaex/
• Breddels & Veljanoski（2018），“Vaex: Big Data exploration in the era of Gaia”，Astronomy & Astrophysics，https://doi.org/10.1051/0004-6361/201732493