vaex库的API文档#
快速列表#
打开/读取您的数据。#
|
从给定路径的文件中打开一个DataFrame。 |
|
打开一个文件名列表，并返回一个包含所有DataFrame连接后的DataFrame。 |
|
从numpy数组创建一个内存中的DataFrame。 |
|
从Apache Arrow数据集创建一个DataFrame。 |
|
从箭头表创建一个vaex DataFrame。 |
|
从ASCII文件（默认以空格分隔）创建内存中的DataFrame。 |
|
从Astropy表创建一个vaex DataFrame。 |
|
将CSV文件加载为DataFrame，并可选择转换为HDF5文件。 |
|
使用Apache Arrow的快速CSV读取器。 |
|
从Vaex数据集创建一个Vaex DataFrame |
|
从字典创建一个内存中的数据集，字典的键为列名，值为列表或numpy数组 |
|
从numpy数组创建一个内存中的DataFrame，与from_arrays相比，这个方法保持了列的顺序（适用于Python < 3.6）。 |
|
一种使用pandas读取JSON文件并直接转换为DataFrame的方法。 |
|
从pandas DataFrame创建一个内存中的DataFrame。 |
|
从字典列表创建数据框。 |
可视化.#
|
在二维直方图/热图中可视化数据。 |
|
绘制直方图。 |
使用散点图可视化（少量）二维数据 |
统计.#
|
计算x和y之间的相关系数cov[x,y]/(std[x]*std[y])，可能在由binby定义的网格上。 |
|
计算非NaN值的数量（如果表达式为None或"*"，则计算所有值的数量）。 |
|
计算x和y或多个表达式的协方差矩阵，可能在由binby定义的网格上。 |
|
计算给定表达式的最大值，可能在由binby定义的网格上。 |
|
计算表达式的平均值，可能在由binby定义的网格上。 |
计算中位数，可能在由 binby 定义的网格上。 |
|
|
计算给定表达式的最小值，可能在由 binby 定义的网格上。 |
|
计算表达式的最小值和最大值，可能在由binby定义的网格上。 |
|
计算/估计众数。 |
在形状为 mi_shape 和 mi_limits 的网格上估计 x 和 y 之间的互信息，可能在由 binby 定义的网格上。 |
|
|
计算给定表达式的标准差，可能在由binby定义的网格上 |
|
返回所有唯一值。 |
|
计算给定表达式的样本方差，可能在由binby定义的网格上 |
vaex-core#
Vaex 是一个用于处理大于内存的 DataFrame（核心外）的库。
在vaex中最重要的类（数据结构）是DataFrame。DataFrame可以通过打开示例数据集来获得：
>>> import vaex
>>> df = vaex.example()
或者使用 open() 来打开一个文件。
>>> df1 = vaex.open("somedata.hdf5")
>>> df2 = vaex.open("somedata.fits")
>>> df2 = vaex.open("somedata.arrow")
>>> df4 = vaex.open("somedata.csv")
或者连接到远程服务器：
>>> df_remote = vaex.open("http://try.vaex.io/nyc_taxi_2015")
vaex 的几个强大特性包括：
性能：能够处理巨大的表格数据，每秒处理超过十亿（> 109）行。
表达式系统 / 虚拟列：动态计算，不浪费内存。
内存高效：在进行过滤/选择/子集操作时无需内存复制。
可视化：直接支持，通常一行代码就足够了。
用户友好的API：您只需要处理一个DataFrame对象，标签补全和文档字符串将帮助您：ds.mean
，感觉与Pandas非常相似。 在N维网格上进行非常快速的统计，例如直方图、运行均值、热图。
按照教程 https://docs.vaex.io/en/latest/tutorial.html 学习如何使用 vaex。
- vaex.concat(dfs, resolver='flexible') DataFrame[source]#
连接一个DataFrame列表。
- Parameters:
resolver – 如何解决模式冲突，请参见
DataFrame.concat()。
- vaex.delayed(f)[source]#
装饰器用于透明地接受延迟计算。
示例：
>>> delayed_sum = ds.sum(ds.E, binby=ds.x, limits=limits, >>> shape=4, delay=True) >>> @vaex.delayed >>> def total_sum(sums): >>> return sums.sum() >>> sum_of_sums = total_sum(delayed_sum) >>> ds.execute() >>> sum_of_sums.get() See the tutorial for a more complete example https://docs.vaex.io/en/latest/tutorial.html#Parallel-computations
- vaex.example()[source]#
33个卫星星系在银河系暗物质晕中吸积的N体模拟结果。
数据由Helmi & de Zeeuw于2000年创建。 数据包含粒子的位置（x, y, z）、速度（vx, vy, vz）、能量（E）、 角动量（L, Lz）和铁含量（FeH）。
- Return type:
- vaex.from_arrays(**arrays) DataFrameLocal[来源]#
从numpy数组创建一个内存中的DataFrame。
Example
>>> import vaex, numpy as np >>> x = np.arange(5) >>> y = x ** 2 >>> vaex.from_arrays(x=x, y=y) # x y 0 0 0 1 1 1 2 2 4 3 3 9 4 4 16 >>> some_dict = {'x': x, 'y': y} >>> vaex.from_arrays(**some_dict) # in case you have your columns in a dict # x y 0 0 0 1 1 1 2 2 4 3 3 9 4 4 16
- Parameters:
arrays – 带有数组的关键字参数
- Return type:
- vaex.from_arrow_table(table) DataFrame[source]#
从箭头表创建一个vaex DataFrame。
- Parameters:
as_numpy – 将懒加载地将列转换为NumPy ndarray。
- Return type:
- vaex.from_ascii(path, seperator=None, names=True, skip_lines=0, skip_after=0, **kwargs)[source]#
从ASCII文件（默认情况下以空格分隔）创建一个内存中的DataFrame。
>>> ds = vx.from_ascii("table.asc") >>> ds = vx.from_ascii("table.csv", seperator=",", names=["x", "y", "z"])
- Parameters:
path – 文件路径
seperator – 值分隔符，默认为空格，使用“,”表示逗号分隔的值。
names – 如果为True，第一行将用作列名，否则提供一个字符串列表作为名称
skip_lines – 跳过文件开头的行
skip_after – 跳过文件末尾的行
kwargs
- Return type:
- vaex.from_csv(filename_or_buffer, copy_index=False, chunk_size=None, convert=False, fs_options={}, progress=None, fs=None, **kwargs)[source]#
将CSV文件加载为DataFrame，并可选择转换为HDF5文件。
- Parameters:
filename_or_buffer (str 或 file) – CSV 文件路径或类文件对象
copy_index (bool) – 当通过Pandas读取源时复制索引
chunk_size (int) –
如果CSV文件太大无法一次性加载到内存中，可以使用此参数分块读取CSV文件。例如：
>>> import vaex >>> for i, df in enumerate(vaex.read_csv('taxi.csv', chunk_size=100_000)): >>> df = df[df.passenger_count < 6] >>> df.export_hdf5(f'taxi_{i:02}.hdf5')
convert (bool 或 str) – 将文件转换为hdf5文件以进行优化，也可以是一个路径。CSV文件将分块读取：使用提供的chunk_size参数或默认大小。每个块将保存为一个单独的hdf5文件，然后将它们全部合并为一个hdf5文件。因此，对于一个大CSV文件，您将需要至少双倍的额外磁盘空间。转换的默认chunk_size为500万行，对应于NYC Taxi数据集示例中的大约1Gb内存。
progress – (仅当 convert 不为 False 时适用) True 表示显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于 0 和 1 之间的浮点值）表示进度，当此可调用对象返回 False 时，计算将被取消
kwargs – 额外的关键字参数，目前传递给Pandas的read_csv函数，但实现可能在未来的版本中发生变化。
- Returns:
DataFrame
- vaex.from_dict(data)[source]#
从字典创建一个内存数据集，其中列名作为键，列表/NumPy数组作为值
Example
>>> data = {'A':[1,2,3],'B':['a','b','c']} >>> vaex.from_dict(data) # A B 0 1 'a' 1 2 'b' 2 3 'c'
- Parameters:
data – 一个字典，格式为 {列名:[值, 值,…]}
- Return type:
- vaex.from_items(*items)[source]#
从numpy数组创建一个内存中的DataFrame，与from_arrays相比，这个方法保持了列的原始顺序（适用于Python < 3.6）。
Example
>>> import vaex, numpy as np >>> x = np.arange(5) >>> y = x ** 2 >>> vaex.from_items(('x', x), ('y', y)) # x y 0 0 0 1 1 1 2 2 4 3 3 9 4 4 16
- Parameters:
items – [(名称, numpy 数组), …] 的列表
- Return type:
- vaex.from_json(path_or_buffer, orient=None, precise_float=False, lines=False, copy_index=False, **kwargs)[source]#
一种使用pandas读取JSON文件并直接转换为DataFrame的方法。
- Parameters:
path_or_buffer (str) – 一个有效的JSON字符串或类文件对象，默认值：None 该字符串可以是一个URL。有效的URL方案包括http、ftp、s3、 gcs和file。对于文件URL，需要指定主机。例如，本地 文件可以是
file://localhost/path/to/table.jsonorient (str) – 预期JSON字符串格式的指示。允许的值为
split,records,index,columns, 和values。precise_float (bool) – 设置为启用更高精度（strtod）函数，当将字符串解码为双精度值时。默认值（False）是使用快速但精度较低的内置功能。
lines (bool) – 将文件作为每行一个json对象读取。
- Return type:
- vaex.from_pandas(df, name='pandas', copy_index=False, index_name='index')[来源]#
从pandas DataFrame创建一个内存中的DataFrame。
- Param:
pandas.DataFrame df: Pandas 数据框
- Param:
名称: 对于DataFrame是唯一的
>>> import vaex, pandas as pd >>> df_pandas = pd.from_csv('test.csv') >>> df = vaex.from_pandas(df_pandas)
- Return type:
- vaex.from_records(records: List[Dict], array_type='arrow', defaults={}) DataFrame[source]#
从字典列表创建数据框。
警告
这仅是为了方便起见，为了提高性能，请将数组传递给
from_arrays()。
- vaex.open(path, convert=False, progress=None, shuffle=False, fs_options={}, fs=None, *args, **kwargs)[source]#
从路径指定的文件中打开一个DataFrame。
示例：
>>> df = vaex.open('sometable.hdf5') >>> df = vaex.open('somedata*.csv', convert='bigdata.hdf5')
- Parameters:
convert – 当convert是一个路径时，使用dataframe.export。如果为True，
convert=path+'.hdf5'如果输入文件或转换参数没有改变，则跳过转换。progress – (仅当 convert 不为 False 时适用) True 表示显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于 0 和 1 之间的浮点值）表示进度，当此可调用对象返回 False 时，计算将被取消
shuffle (bool) – 是否对转换后的DataFrame进行洗牌
fs_options (dict) – 如果需要，传递给可选文件系统的额外参数。请参见下文
group – （可选）指定要从HDF5文件中读取的组。默认情况下，此值设置为“/table”。
fs – Apache Arrow 文件系统对象，或 FSSpec 文件系统对象，如果指定了，fs_options 应为空。
args – 文件读取器所需的额外参数
kwargs – 额外的关键字参数
- Returns:
成功时返回一个DataFrame，否则返回None
- Return type:
注意：从版本4.14.0开始，vaex.open()将惰性读取CSV文件。 如果您希望将整个CSV文件读入内存，请使用vaex.from_csv()或vaex.from_csv_arrow()代替。
云存储支持：
Vaex 支持从 Amazon AWS S3 和 Google Cloud Storage 流式传输 HDF5 文件。 文件默认缓存在 $HOME/.vaex/file-cache/(s3|gs) 中，以便后续访问速度与本地磁盘访问一样快。
亚马逊AWS S3选项：
以下常见的 fs_options 用于 S3 访问：
anon: 是否使用匿名访问（默认为false）。（允许的值为：true,True,1,false,False,0）
anonymous - anon的别名
cache: 是否使用磁盘缓存，仅在数据应仅访问一次时设置为false。（允许的值为：true,True,1,false,False,0）
access_key - AWS 访问密钥，如果未提供，将使用标准环境变量或 ~/.aws/credentials 文件
secret_key - AWS 密钥，类似于 access_key
profile - 如果~/.aws/credentials中存在多个配置文件，选择此配置文件而不是‘default’，请参阅https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html
region - AWS 区域，例如 'us-east-1'，如果未提供将自动确定。
endpoint_override - 连接的URL/ip，而不是AWS，例如minio的‘localhost:9000’
所有 fs_options 也可以作为查询字符串编码在文件路径中。
示例：
>>> df = vaex.open('s3://vaex/taxi/nyc_taxi_2015_mini.hdf5?anon=true', fs_options={'anonymous': True}) >>> df = vaex.open('s3://vaex/taxi/nyc_taxi_2015_mini.hdf5?anon=true?anon=true') >>> df = vaex.open('s3://mybucket/path/to/file.hdf5', fs_options={'access_key': my_key, 'secret_key': my_secret_key}) >>> df = vaex.open(f's3://mybucket/path/to/file.hdf5?access_key={my_key}&secret_key={my_secret_key}') >>> df = vaex.open('s3://mybucket/path/to/file.hdf5?profile=myproject')
Google 云存储选项：
以下 fs_options 用于 GCP 访问：
token: GCP的认证方法。使用‘anon’进行匿名访问。更多详情请参见https://gcsfs.readthedocs.io/en/latest/index.html#credentials。
cache: 是否使用磁盘缓存，仅在数据应仅访问一次时设置为false。（允许的值为：true,True,1,false,False,0）。
project 和其他参数传递给
gcsfs.core.GCSFileSystem
示例：
>>> df = vaex.open('gs://vaex-data/airlines/us_airline_data_1988_2019.hdf5', fs_options={'token': None}) >>> df = vaex.open('gs://vaex-data/airlines/us_airline_data_1988_2019.hdf5?token=anon') >>> df = vaex.open('gs://vaex-data/testing/xys.hdf5?token=anon&cache=False')
- vaex.open_many(filenames)[源代码]#
打开一个文件名列表，并返回一个包含所有DataFrame连接后的DataFrame。
文件名可以是
vaex.open()支持的任何格式，即hdf5、arrow、parquet、csv等。
- vaex.register_function(scope=None, as_property=False, name=None, on_expression=True, df_accessor=None, multiprocessing=False)[source]#
用于向vaex注册新函数的装饰器。
如果 on_expression 为 True，该函数将作为 Expression 上的一个方法可用，其中第一个参数将是表达式本身。
如果给出了df_accessor，它将被添加为该数据框访问器的方法（参见例如vaex/geo.py）
示例：
>>> import vaex >>> df = vaex.example() >>> @vaex.register_function() >>> def invert(x): >>> return 1/x >>> df.x.invert()
>>> import numpy as np >>> df = vaex.from_arrays(departure=np.arange('2015-01-01', '2015-12-05', dtype='datetime64')) >>> @vaex.register_function(as_property=True, scope='dt') >>> def dt_relative_day(x): >>> return vaex.functions.dt_dayofyear(x)/365. >>> df.departure.dt.relative_day
- vaex.vconstant(value, length, dtype=None, chunk_size=1024)[source]#
创建一个具有常量值的虚拟列，该列使用0内存。
- Parameters:
value – 用于填充列的值
length – 列的长度，即它应包含的行数。
dtype – 列的首选数据类型。
chunk_size – 可用于优化此列的性能（评估）。
聚合与统计#
- class vaex.agg.AggregatorDescriptorKurtosis(name, expression, short_name='kurtosis', selection=None, edges=False)[source]#
- class vaex.agg.AggregatorDescriptorMean(name, expressions, short_name='mean', selection=None, edges=False)[source]#
- class vaex.agg.AggregatorDescriptorMulti(name, expressions, short_name, selection=None, edges=False)[source]#
基础类:
AggregatorDescriptor使用多个操作/聚合来计算最终的聚合
- class vaex.agg.AggregatorDescriptorSkew(name, expression, short_name='skew', selection=None, edges=False)[source]#
- class vaex.agg.AggregatorDescriptorStd(name, expression, short_name='var', ddof=0, selection=None, edges=False)[source]#
- class vaex.agg.AggregatorDescriptorVar(name, expression, short_name='var', ddof=0, selection=None, edges=False)[来源]#
- vaex.agg.all(expression=None, selection=None)[source]#
聚合器，当组中的所有值都为True时，或者当组中的所有数据都有效时（即没有缺失值或np.nan），返回True。如果使用选择参数时组中没有数据，则聚合器返回False。
- Parameters:
expression – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时）
- vaex.agg.any(expression=None, selection=None)[source]#
聚合器，当组中的任何值为True时，或者当组中有任何有效数据时（即没有缺失值或np.nan），返回True。 如果使用选择参数时组中没有数据，则聚合器返回False。
- Parameters:
expression – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称（或为‘default’选择时为True），或所有数据（当选择为None或False时）
- vaex.agg.first(expression, order_expression=None, selection=None, edges=False)[source]#
创建第一个聚合。
- Parameters:
expression – {expression_one}.
order_expression – 使用此表达式对箱子中的值进行排序。
selection – {selection1}
edges – {edges}
- vaex.agg.last(expression, order_expression=None, selection=None, edges=False)[source]#
创建第一个聚合。
- Parameters:
expression – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y。
order_expression – 使用此表达式对箱子中的值进行排序。
selection – 要使用的选择的名称（或为‘default’选择时为True），或所有数据（当选择为None或False时）
edges – 目前仅供内部使用（它包括边界处的nan值和超出限制的值，nan和0，小于1的值，以及大于-1的值）
- class vaex.agg.list(expression, selection=None, dropna=False, dropnan=False, dropmissing=False, edges=False)[source]#
基础类:
AggregatorDescriptorBasic返回属于指定表达式的值列表的聚合器。
- Parameters:
expression – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称（或为‘default’选择时为True），或所有数据（当选择为None或False时）
dropmissing – 删除包含缺失值的行
dropnan – 删除包含NaN值的行
dropna – 删除包含不可用（NA）值（NaN 或缺失值）的行。
edges – 目前仅供内部使用（它包括边界处的nan值和超出限制的值，nan和0，小于1，大于-1）
- vaex.agg.nunique(expression, dropna=False, dropnan=False, dropmissing=False, selection=None, edges=False)[source]#
计算每个区间内唯一项目数量的聚合器。
- Parameters:
expression – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
dropmissing – 删除包含缺失值的行
dropnan – 删除包含NaN值的行
dropna – 删除包含不可用（NA）值（NaN 或缺失值）的行。
selection – 要使用的选择的名称（或为‘default’选择时为True），或所有数据（当选择为None或False时）
缓存#
（目前处于实验阶段，使用需自担风险） Vaex 可以缓存任务结果，例如聚合或用于分组操作的内部哈希映射，以加快重复计算的速度，但需要计算缓存键并存储/检索缓存值。
在内部，Vaex 计算指纹（例如数据的哈希值，或文件路径和修改时间）以创建跨进程相似的缓存键，这样进程的重启很可能会导致相似的哈希键。
缓存可以全局开启，或者作为上下文管理器使用：
>>> import vaex
>>> df = vaex.example()
>>> vaex.cache.memory_infinite() # cache on globally
<cache restore context manager>
>>> vaex.cache.is_on()
True
>>> vaex.cache.off() # cache off globally
<cache restore context manager>
>>> vaex.cache.is_on()
False
>>> with vaex.cache.memory_infinite():
... df.x.sum() # calculated without cache
array(-20884.64307324)
>>> vaex.cache.is_on()
False
函数 vaex.cache.set() 和 vaex.cache.get() 只是在一个全局字典 (vaex.cache.cache) 中查找值，但可以设置为更复杂的行为。
一个用于内存缓存的好库是cachetools (https://pypi.org/project/cachetools/)
>>> import vaex
>>> import cachetools
>>> df = vaex.example()
>>> vaex.cache.cache = cachetools.LRUCache(1_000_000_000) # 1gb cache
使用环境变量进行配置#
查看 Configuration 以获取更多配置选项。
特别是在使用vaex server时，使用环境变量外部开启缓存可能会很有用。
$ VAEX_CACHE=disk VAEX_CACHE_DISK_SIZE_LIMIT=”10GB” python -m vaex.server
将启用缓存使用 vaex.cache.disk() 并将其配置为最多使用 10 GB 的磁盘空间。
当将Vaex与Flask或Plotly Dash结合使用，并使用gunicorn进行扩展时，使用多级缓存可能很有用，其中第一级缓存较小但延迟低（并且对每个进程是私有的），而第二级是延迟较高的磁盘缓存，在所有进程之间共享。
$ VAEX_CACHE=”memory,disk” VAEX_CACHE_DISK_SIZE_LIMIT=”10GB” VAEX_CACHE_MEMORY_SIZE_LIMIT=”1GB” gunicorn -w 16 app:server
- vaex.cache.disk(clear=False, size_limit='10GB', eviction_policy='least-recently-stored')[source]#
使用diskcache库存储缓存值。
- Parameters:
size_limit (int 或 str) – 缓存的最大大小，以字节为单位（或使用类似 '128MB' 的字符串） 有关更多详细信息，请参阅 http://www.grantjenks.com/docs/diskcache/tutorial.html?highlight=eviction#tutorial-settings。
eviction_policy (str) – 驱逐策略, 参见 http://www.grantjenks.com/docs/diskcache/tutorial.html?highlight=eviction#tutorial-eviction-policies
clear (bool) – 在开启缓存之前，清除所有用于缓存的磁盘空间。
- vaex.cache.get(key, default=None, type=None)[source]#
查找键的缓存值，或返回默认值
如果缓存关闭，将返回 None。
- Parameters:
key (str) – 缓存键。
default – 当缓存开启但键不在缓存中时返回
type – 当前未使用。
- vaex.cache.memory(maxsize='1GB', classname='LRUCache', clear=False)[source]#
使用cachetools设置内存缓存 (https://cachetools.readthedocs.io/).
多次调用时使用clear=False将保留当前缓存（在笔记本使用中很有用）。
- vaex.cache.memory_infinite(clear=False)[source]#
设置一个字典作为缓存，创建一个无限缓存。
多次调用时使用clear=False将保留当前缓存（在笔记本使用中很有用）
- vaex.cache.off()[source]#
关闭缓存，或在用作上下文管理器时临时关闭
>>> import vaex >>> df = vaex.example() >>> vaex.cache.memory_infinite() # cache on <cache restore context manager> >>> with vaex.cache.off(): ... df.x.sum() # calculated without cache array(-20884.64307324) >>> df.x.sum() # calculated with cache array(-20884.64307324) >>> vaex.cache.off() # cache off <cache restore context manager> >>> df.x.sum() # calculated without cache array(-20884.64307324)
- vaex.cache.redis(client=None)[source]#
使用Redis进行缓存。
- Parameters:
client – Redis 客户端，如果为 None，将调用 redis.Redis()
- vaex.cache.set(key, value, type=None, duration_wallclock=None)[source]#
设置缓存值
对于更高级的策略非常有用，我们希望根据类型和成本有不同的行为。实现可以设置此函数以覆盖默认行为：
>>> import vaex >>> vaex.cache.memory_infinite() >>> def my_smart_cache_setter(key, value, type=None, duration_wallclock=None): ... if duration_wallclock >= 0.1: # skip fast calculations ... vaex.cache.cache[key] = value ... >>> vaex.cache.set = my_smart_cache_setter
DataFrame 类#
- class vaex.dataframe.DataFrame(name=None, executor=None)[源代码]#
基础类：
object所有本地或远程数据集都封装在这个类中，它提供了一个类似pandas的API来操作你的数据集。
每个DataFrame (df) 都有若干列和若干行，即DataFrame的长度。
所有DataFrame都有多个“选择”，所有计算都在整个DataFrame（默认）或选择上进行。以下示例展示了如何使用选择。
>>> df.select("x < 0") >>> df.sum(df.y, selection=True) >>> df.sum(df.y, selection=[df.x < 0, df.x > 0])
- __getitem__(item)[source]#
获取表达式、几列的（浅）副本或应用过滤的便捷方法。
示例：
>>> df['Lz'] # the expression 'Lz >>> df['Lz/2'] # the expression 'Lz/2' >>> df[["Lz", "E"]] # a shallow copy with just two columns >>> df[df.Lz < 0] # a shallow copy with the filter Lz < 0 applied
- __setitem__(name, value)[source]#
向此DataFrame添加虚拟列/表达式的便捷方法。
示例：
>>> import vaex, numpy as np >>> df = vaex.example() >>> df['r'] = np.sqrt(df.x**2 + df.y**2 + df.z**2) >>> df.r <vaex.expression.Expression(expressions='r')> instance at 0x121687e80 values=[2.9655450396553587, 5.77829281049018, 6.99079603950256, 9.431842752707537, 0.8825613121347967 ... (total 330000 values) ... 7.453831761514681, 15.398412491068198, 8.864250273925633, 17.601047186042507, 14.540181524970293]
- __weakref__#
对象的弱引用列表
- add_variable(name, expression, overwrite=True, unique=True)[source]#
向DataFrame添加一个变量。
变量可能引用其他变量，虚拟列和表达式可能引用变量。
Example
>>> df.add_variable('center', 0) >>> df.add_virtual_column('x_prime', 'x-center') >>> df.select('x_prime < 0')
- Param:
str name: 虚拟变量的名称
- Param:
表达式：变量的表达式
- add_virtual_column(name, expression, unique=False)[source]#
向DataFrame添加一个虚拟列。
示例：
>>> df.add_virtual_column("r", "sqrt(x**2 + y**2 + z**2)") >>> df.select("r < 10")
- Param:
str name: 虚拟列的名称
- Param:
表达式: 列的表达式
- Parameters:
unique (str) – 如果名称已被使用，通过添加后缀使其唯一，例如 _1 或 _2
- apply(f, arguments=None, vectorize=False, multiprocessing=True)[源代码]#
在整个DataFrame上逐行应用一个函数。
示例：
>>> import vaex >>> df = vaex.example() >>> def func(x, y): ... return (x+y)/(x-y) ... >>> df.apply(func, arguments=[df.x, df.y]) Expression = lambda_function(x, y) Length: 330,000 dtype: float64 (expression) ------------------------------------------- 0 -0.460789 1 3.90038 2 -0.642851 3 0.685768 4 -0.543357
- Parameters:
f – 要应用的函数
arguments – 传递给函数 f 的参数列表。
vectorize – 使用数组而不是标量调用 f（以获得更好的性能）。
multiprocessing (bool) – 使用多进程以避免GIL（全局解释器锁）。
- Returns:
一个延迟求值的函数。
- cat(i1, i2, format='html')[source]#
显示从第 i1 行到第 i2 行的 DataFrame
有关格式，请参见 https://pypi.org/project/tabulate/
- property col#
直接访问列（适用于制表符完成）。
在与小型DataFrames结合使用ipython时非常方便，因为这提供了标签补全功能。
可以通过列名访问列，列名是属性。这些属性目前是表达式，因此你可以用它们进行计算。
Example
>>> ds = vaex.example() >>> df.plot(df.col.x, df.col.y)
- column_count(hidden=False)[source]#
返回列的数量（包括虚拟列）。
- Parameters:
hidden (bool) – 如果为True，则在统计中包含隐藏列
- Returns:
DataFrame中的列数
- combinations(expressions_list=None, dimension=2, exclude=None, **kwargs)[source]#
为给定维度生成可能表达式的组合列表。
- Parameters:
expressions_list – 表达式列表的列表，其中内部列表定义了子空间
dimensions – 如果给定，生成一个包含该维度所有可能组合的子空间
exclude – 排除列表
- correlation(x, y=None, binby=[], limits=None, shape=128, sort=False, sort_key=<ufunc 'absolute'>, selection=False, delay=False, progress=None, array_type=None)[来源]#
计算x和y之间的相关系数cov[x,y]/(std[x]*std[y])，可能在由binby定义的网格上进行。
x 和 y 参数可以是单个表达式或表达式列表。 - 如果 x 和 y 是单个表达式，则计算 x 和 y 之间的相关性； - 如果 x 是表达式列表且 y 是单个表达式，则计算 x 中每个表达式与 y 中表达式之间的相关性； - 如果 x 是表达式列表且 y 为 None，则计算 x 中所有表达式之间的相关矩阵； - 如果 x 是长度为 2 的元组列表，则计算指定维度对的相关性； - 如果 x 和 y 是表达式列表，则计算由两个表达式列表定义的相关矩阵。
示例：
>>> import vaex >>> df = vaex.example() >>> df.correlation("x**2+y**2+z**2", "-log(-E+1)") array(0.6366637382215669) >>> df.correlation("x**2+y**2+z**2", "-log(-E+1)", binby="Lz", shape=4) array([ 0.40594394, 0.69868851, 0.61394099, 0.65266318]) >>> df.correlation(x=['x', 'y', 'z']) array([[ 1. , -0.06668907, -0.02709719], [-0.06668907, 1. , 0.03450365], [-0.02709719, 0.03450365, 1. ]]) >>> df.correlation(x=['x', 'y', 'z'], y=['E', 'Lz']) array([[-0.01116315, -0.00369268], [-0.0059848 , 0.02472491], [ 0.01428211, -0.05900035]])
- Parameters:
x – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
y – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- count(expression=None, binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None, array_type=None)[source]#
计算非NaN值的数量（如果表达式为None或“*”，则计算所有值）。
示例：
>>> df.count() 330000 >>> df.count("*") 330000.0 >>> df.count("*", binby=["x"], shape=4) array([ 10925., 155427., 152007., 10748.])
- Parameters:
expression – 用于计算非缺失值的表达式或列，或者为 None 或 '*' 以计算行数
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
edges – 目前仅供内部使用（它包括边界处的nan值和超出限制的值，nan和0，小于1，大于-1）
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- cov(x, y=None, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
计算x和y或更多表达式的协方差矩阵，可能在由binby定义的网格上。
x 和 y 是表达式，例如：
>>> df.cov("x", "y")
或者只给出x参数和一个表达式列表，例如：
>>> df.cov(["x, "y, "z"])
示例：
>>> df.cov("x", "y") array([[ 53.54521742, -3.8123135 ], [ -3.8123135 , 60.62257881]]) >>> df.cov(["x", "y", "z"]) array([[ 53.54521742, -3.8123135 , -0.98260511], [ -3.8123135 , 60.62257881, 1.21381057], [ -0.98260511, 1.21381057, 25.55517638]])
>>> df.cov("x", "y", binby="E", shape=2) array([[[ 9.74852878e+00, -3.02004780e-02], [ -3.02004780e-02, 9.99288215e+00]], [[ 8.43996546e+01, -6.51984181e+00], [ -6.51984181e+00, 9.68938284e+01]]])
- Parameters:
x – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
y – 如果前一个参数不是列表，则应提供此参数
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为标量，包含统计信息，最后两个维度形状为(2,2)
- covar(x, y, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
计算x和y之间的协方差cov[x,y]，可能在由binby定义的网格上。
示例：
>>> df.covar("x**2+y**2+z**2", "-log(-E+1)") array(52.69461456005138) >>> df.covar("x**2+y**2+z**2", "-log(-E+1)")/(df.std("x**2+y**2+z**2") * df.std("-log(-E+1)")) 0.63666373822156686 >>> df.covar("x**2+y**2+z**2", "-log(-E+1)", binby="Lz", shape=4) array([ 10.17387143, 51.94954078, 51.24902796, 20.2163929 ])
- Parameters:
x – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
y – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- data_type(expression, array_type=None, internal=False, axis=0)[source]#
返回给定表达式的数据类型，如果不是列，则将评估第一行以获取数据类型。
示例：
>>> df = vaex.from_scalars(x=1, s='Hi')
- describe(strings=True, virtual=True, selection=None)[source]#
给出DataFrame的描述。
>>> import vaex >>> df = vaex.example()[['x', 'y', 'z']] >>> df.describe() x y z dtype float64 float64 float64 count 330000 330000 330000 missing 0 0 0 mean -0.0671315 -0.0535899 0.0169582 std 7.31746 7.78605 5.05521 min -128.294 -71.5524 -44.3342 max 271.366 146.466 50.7185 >>> df.describe(selection=df.x > 0) x y z dtype float64 float64 float64 count 164060 164060 164060 missing 165940 165940 165940 mean 5.13572 -0.486786 -0.0868073 std 5.18701 7.61621 5.02831 min 1.51635e-05 -71.5524 -44.3342 max 271.366 78.0724 40.2191
- diff(periods=1, column=None, fill_value=None, trim=False, inplace=False, reverse=False)[source]#
计算当前行与偏移periods行的差异
- drop(columns, inplace=False, check=True)[source]#
删除列（或单个列）。
- Parameters:
columns – 列名列表或单个列名
inplace – 如果为True，则对自身进行修改，否则返回一个新的DataFrame
check – 当为true时，它将检查该列是否用于虚拟列或过滤器中，并隐藏它。
- property dtypes#
提供一个包含所有列（除隐藏列外）的numpy数据类型的Pandas系列对象。
- evaluate(expression, i1=None, i2=None, out=None, selection=None, filtered=True, array_type=None, parallel=True, chunk_size=None, progress=None)[源代码]#
评估一个表达式，并返回一个包含整个列或其中一部分结果的numpy数组。
请注意，这不是vaex应该使用的方式，因为这意味着数据的副本需要适合内存。
要获取部分结果，请使用 i1 和 i2
- evaluate_iterator(expression, s1=None, s2=None, out=None, selection=None, filtered=True, array_type=None, parallel=True, chunk_size=None, prefetch=True, progress=None)[source]#
生成器以块（行数）高效评估表达式。
请参阅
DataFrame.evaluate()以获取其他参数。示例：
>>> import vaex >>> df = vaex.example() >>> for i1, i2, chunk in df.evaluate_iterator(df.x, chunk_size=100_000): ... print(f"Total of {i1} to {i2} = {chunk.sum()}") ... Total of 0 to 100000 = -7460.610158279056 Total of 100000 to 200000 = -4964.85827154921 Total of 200000 to 300000 = -7303.271340043915 Total of 300000 to 330000 = -2424.65234724951
- Parameters:
progress – {progress}
prefetch – 在当前值被生成/返回的同时，预取/计算下一个块。
- extract()[源代码]#
返回一个仅包含过滤行的DataFrame。
注意
请注意，不会复制基础数据，只会创建视图/引用。
当原始DataFrame被大量过滤（仅包含少量行）时，生成的DataFrame可能更高效。
如果没有应用过滤，它将返回一个修剪后的视图。 对于返回的df，len(df) == df.length_original() == df.length_unfiltered()
- Return type:
- fillna(value, column_names=None, prefix='__original_', inplace=False)[source]#
返回一个DataFrame，其中缺失值/NaN用‘value’填充。
原始列将被重命名，默认情况下它们将成为隐藏列。不会丢失任何数据。
注意
请注意，不会复制底层数据，只会创建视图/引用。
注意
请注意，过滤将被忽略（因为它们可能会改变），您可能需要考虑先运行
extract()。示例：
>>> import vaex >>> import numpy as np >>> x = np.array([3, 1, np.nan, 10, np.nan]) >>> df = vaex.from_arrays(x=x) >>> df_filled = df.fillna(value=-1, column_names=['x']) >>> df_filled # x 0 3 1 1 2 -1 3 10 4 -1
- filter(expression, mode='and')[source]#
df[
] 的通用版本，用于修改应用于 DataFrame 的过滤器。 请参阅
DataFrame.select()了解选择的使用方法。请注意，使用 df = df[
] 只能缩小过滤范围（即只能选择更少的行）。使用过滤方法和不同的布尔模式（例如“或”），实际上可以选择更多的行。这与 numpy 和 pandas 等库有很大不同，它们只能缩小过滤范围。示例：
>>> import vaex >>> import numpy as np >>> x = np.arange(10) >>> df = vaex.from_arrays(x=x, y=x**2) >>> df # x y 0 0 0 1 1 1 2 2 4 3 3 9 4 4 16 5 5 25 6 6 36 7 7 49 8 8 64 9 9 81 >>> dff = df[df.x<=2] >>> dff # x y 0 0 0 1 1 1 2 2 4 >>> dff = dff.filter(dff.x >=7, mode="or") >>> dff # x y 0 0 0 1 1 1 2 2 4 3 7 49 4 8 64 5 9 81
- first(expression, order_expression=None, binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None, array_type=None)[source]#
返回分箱后的expression的第一个元素，其中每个箱的值按order_expression排序。
示例：
>>> import vaex >>> df = vaex.example() >>> df.first(df.x, df.y, shape=8) >>> df.first(df.x, df.y, shape=8, binby=[df.y]) >>> df.first(df.x, df.y, shape=8, binby=[df.y]) array([-4.81883764, 11.65378 , 9.70084476, -7.3025589 , 4.84954977, 8.47446537, -5.73602629, 10.18783 ])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
order_expression – 使用此表达式对箱子中的值进行排序。
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
edges – 目前仅供内部使用（它包括边界处的nan值和超出限制的值，nan和0，小于1，大于-1）
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
包含第一个元素的Ndarray。
- Return type:
numpy.array
- get_column_names(virtual=True, strings=True, hidden=False, regex=None, dtype=None)[来源]#
返回列名的列表
示例：
>>> import vaex >>> df = vaex.from_scalars(x=1, x2=2, y=3, s='string') >>> df['r'] = (df.x**2 + df.y**2)**2 >>> df.get_column_names() ['x', 'x2', 'y', 's', 'r'] >>> df.get_column_names(virtual=False) ['x', 'x2', 'y', 's'] >>> df.get_column_names(regex='x.*') ['x', 'x2'] >>> df.get_column_names(dtype='string') ['s']
- get_private_dir(create=False)[source]#
每个DataFrame都有一个目录，用于存储元数据等文件。
Example
>>> import vaex >>> ds = vaex.example() >>> vaex.get_private_dir() '/Users/users/breddels/.vaex/dfs/_Users_users_breddels_vaex-testing_data_helmi-dezeeuw-2000-10p.hdf5'
- Parameters:
创建 (bool) – 如果为True，当目录不存在时将会创建该目录
- get_variable(name)[source]#
返回由名称给定的变量，它不会对其进行评估。
用于评估，请参见
DataFrame.evaluate_variable()，另请参见DataFrame.set_variable()
- healpix_count(expression=None, healpix_expression=None, healpix_max_level=12, healpix_level=8, binby=None, limits=None, shape=128, delay=False, progress=None, selection=None)[source]#
计算表示healpix数据的数组上表达式的非缺失值数量。
- Parameters:
expression – 用于计算非缺失值的表达式或列，或者为 None 或 '*' 以计算行数
healpix_expression – {healpix_max_level}
healpix_max_level – {healpix_max_level}
healpix_level – {healpix_level}
binby – {binby}，这些维度遵循第一个healpix维度。
limits – {limits}
shape – {shape}
selection – {selection}
delay – {delay}
progress – {progress}
- Returns:
- kurtosis(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算给定表达式的峰度，可能在由binby定义的网格上进行。
示例：
>>> df.kurtosis('vz') 0.33414303 >>> df.kurtosis("vz", binby=["E"], shape=4) array([0.35286113, 0.14455428, 0.52955107, 5.06716345])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- last(expression, order_expression=None, binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None, array_type=None)[source]#
返回分箱后的expression的最后一个元素，其中每个箱中的值按order_expression排序。
- Parameters:
expression – 要放入分箱中的值。
order_expression – 使用此表达式对箱子中的值进行排序。
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
edges – 目前仅供内部使用（它包括边界处的nan值和超出限制的值，nan和0，小于1，大于-1）
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
包含第一个元素的Ndarray。
- Return type:
numpy.array
- limits(expression, value=None, square=False, selection=None, delay=False, progress=None, shape=None)[source]#
计算表达式的最小值和最大值范围，默认值为‘minmax’。
如果值是形式为 [minvalue, maxvalue] 的列表，则直接返回，这是为了方便使用混合形式。
示例：
>>> import vaex >>> df = vaex.example() >>> df.limits("x") array([-128.293991, 271.365997]) >>> df.limits("x", "99.7%") array([-28.86381927, 28.9261226 ]) >>> df.limits(["x", "y"]) (array([-128.293991, 271.365997]), array([ -71.5523682, 146.465836 ])) >>> df.limits(["x", "y"], "99.7%") (array([-28.86381927, 28.9261226 ]), array([-28.60476934, 28.96535249])) >>> df.limits(["x", "y"], ["minmax", "90%"]) (array([-128.293991, 271.365997]), array([-13.37438402, 13.4224423 ])) >>> df.limits(["x", "y"], ["minmax", [0, 10]]) (array([-128.293991, 271.365997]), [0, 10])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
value – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
- Returns:
列表形式为[[xmin, xmax], [ymin, ymax], …. ,[zmin, zmax]]，或者当表达式不是列表时为[xmin, xmax]
- limits_percentage(expression, percentage=99.73, square=False, selection=False, progress=None, delay=False)[source]#
计算表达式的最小值和最大值范围，该范围包含大约由百分比定义的数据百分比。
范围在中位数周围对称，即对于90%的百分比，这与以下结果相同：
示例：
>>> df.limits_percentage("x", 90) array([-12.35081376, 12.14858052] >>> df.percentile_approx("x", 5), df.percentile_approx("x", 95) (array([-12.36813152]), array([ 12.13275818]))
注意：此值是通过在网格上计算累积分布来近似的。 注意2：上述值并不完全相同，因为percentile和limits_percentage不共享相同的代码
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
percentage (float) – 值介于0到100之间
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
- Returns:
列表形式为[[xmin, xmax], [ymin, ymax], …. ,[zmin, zmax]]，当表达式不是列表时为[xmin, xmax]
- materialize(column=None, inplace=False, virtual_column=None)[source]#
将列转换为原生CPU格式，以内存为代价实现最佳性能。
警告
这可能会使用大量内存，请注意。
虚拟列将立即被评估，所有真实列在首次使用时将被缓存到内存中。
虚拟列示例：
>>> x = np.arange(1,4) >>> y = np.arange(2,5) >>> df = vaex.from_arrays(x=x, y=y) >>> df['r'] = (df.x**2 + df.y**2)**0.5 # 'r' is a virtual column (computed on the fly) >>> df = df.materialize('r') # now 'r' is a 'real' column (i.e. a numpy array)
使用parquet文件的示例 >>> df = vaex.open(‘somewhatslow.parquet’) >>> df.x.sum() # 慢 >>> df = df.materialize() >>> df.x.sum() # 慢，但会填充缓存 >>> df.x.sum() # 尽可能快，将使用内存
- Parameters:
column – 字符串或字符串列表，用于具体化的列名，当为None时表示所有列
inplace – 如果为True，则对自身进行修改，否则返回一个新的DataFrame
virtual_column – 用于向后兼容
- max(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[来源]#
计算给定表达式的最大值，可能在由binby定义的网格上。
示例：
>>> df.max("x") array(271.365997) >>> df.max(["x", "y"]) array([ 271.365997, 146.465836]) >>> df.max("x", binby="x", shape=5, limits=[-10, 10]) array([-6.00010443, -2.00002384, 1.99998057, 5.99983597, 9.99984646])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量，最后一个维度的形状为(2)
- mean(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算表达式的平均值，可能在由binby定义的网格上。
示例：
>>> df.mean("x") -0.067131491264005971 >>> df.mean("(x**2+y**2)**0.5", binby="E", shape=4) array([ 2.43483742, 4.41840721, 8.26742458, 15.53846476])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- median_approx(expression, percentage=50.0, binby=[], limits=None, shape=128, percentile_shape=256, percentile_limits='minmax', selection=False, delay=False, progress=None)[来源]#
计算中位数，可能在由 binby 定义的网格上。
注意：该值是通过在由percentile_shape和percentile_limits定义的网格上计算累积分布来近似的
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
percentile_limits – 用于累积直方图的最小值和最大值的描述，目前应仅为‘minmax’
percentile_shape – 计算累积直方图的数组的形状，整数类型
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- min(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算给定表达式的最小值，可能在由binby定义的网格上。
示例：
>>> df.min("x") array(-128.293991) >>> df.min(["x", "y"]) array([-128.293991 , -71.5523682]) >>> df.min("x", binby="x", shape=5, limits=[-10, 10]) array([-9.99919128, -5.99972439, -1.99991322, 2.0000093 , 6.0004878 ])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量，最后一个维度的形状为(2)
- minmax(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[来源]#
计算表达式的最小值和最大值，可能是在由binby定义的网格上。
示例：
>>> df.minmax("x") array([-128.293991, 271.365997]) >>> df.minmax(["x", "y"]) array([[-128.293991 , 271.365997 ], [ -71.5523682, 146.465836 ]]) >>> df.minmax("x", binby="x", shape=5, limits=[-10, 10]) array([[-9.99919128, -6.00010443], [-5.99972439, -2.00002384], [-1.99991322, 1.99998057], [ 2.0000093 , 5.99983597], [ 6.0004878 , 9.99984646]])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量，最后一个维度的形状为(2)
- mode(expression, binby=[], limits=None, shape=256, mode_shape=64, mode_limits=None, progressbar=False, selection=None)[源代码]#
计算/估计模式。
- mutual_information(x, y=None, dimension=2, mi_limits=None, mi_shape=256, binby=[], limits=None, shape=128, sort=False, selection=False, delay=False)[source]#
估计在形状为mi_shape和mi_limits的网格上，x和y之间的互信息，可能是在由binby定义的网格上。
x 和 y 参数可以是单个表达式或表达式列表： - 如果 x 和 y 是单个表达式，则计算 x 和 y 之间的互信息； - 如果 x 是表达式列表且 y 是单个表达式，则计算 x 中每个表达式与 y 中表达式之间的互信息； - 如果 x 是表达式列表且 y 为 None，则计算 x 中所有表达式之间的互信息矩阵； - 如果 x 是长度为 2 的元组列表，则计算指定维度对的互信息； - 如果 x 和 y 是表达式列表，则计算由两个表达式列表定义的互信息矩阵。
如果 sort 为 True，则互信息按排序（降序）顺序返回，表达式列表也按相同顺序返回。
示例：
>>> import vaex >>> df = vaex.example() >>> df.mutual_information("x", "y") array(0.1511814526380327) >>> df.mutual_information([["x", "y"], ["x", "z"], ["E", "Lz"]]) array([ 0.15118145, 0.18439181, 1.07067379]) >>> df.mutual_information([["x", "y"], ["x", "z"], ["E", "Lz"]], sort=True) (array([ 1.07067379, 0.18439181, 0.15118145]), [['E', 'Lz'], ['x', 'z'], ['x', 'y']]) >>> df.mutual_information(x=['x', 'y', 'z']) array([[3.53535106, 0.06893436, 0.11656418], [0.06893436, 3.49414866, 0.14089177], [0.11656418, 0.14089177, 3.96144906]]) >>> df.mutual_information(x=['x', 'y', 'z'], y=['E', 'Lz']) array([[0.32316291, 0.16110026], [0.36573065, 0.17802792], [0.35239151, 0.21677695]])
- Parameters:
x – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
y – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
sort – 返回按排序（降序）顺序的互信息，并在 sorted 为 True 时返回相应的表达式列表
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
- Returns:
具有给定形状的Numpy数组，或在未给出binby参数时为标量，包含统计量，
- property nbytes#
df.byte_size() 的别名，请参阅
DataFrame.byte_size()。
- nop(expression=None, progress=False, delay=False)[source]#
评估表达式或表达式列表，并丢弃结果。由于vaex通常是惰性的，这对于基准测试非常有用。
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
- Returns:
无
- percentile_approx(expression, percentage=50.0, binby=[], limits=None, shape=128, percentile_shape=1024, percentile_limits='minmax', selection=False, delay=False, progress=None)[source]#
计算由百分比给出的百分位数，可能在由binby定义的网格上。
注意：该值是通过在由percentile_shape和percentile_limits定义的网格上计算累积分布来近似的。
示例：
>>> df.percentile_approx("x", 10), df.percentile_approx("x", 90) (array([-8.3220355]), array([ 7.92080358])) >>> df.percentile_approx("x", 50, binby="x", shape=5, limits=[-10, 10]) array([[-7.56462982], [-3.61036641], [-0.01296306], [ 3.56697863], [ 7.45838367]])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
percentile_limits – 用于累积直方图的最小值和最大值的描述，目前应仅为‘minmax’
percentile_shape – 计算累积直方图的数组的形状，整数类型
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- plot2d_contour(x=None, y=None, what='count(*)', limits=None, shape=256, selection=None, f='identity', figsize=None, xlabel=None, ylabel=None, aspect='auto', levels=None, fill=False, colorbar=False, colorbar_label=None, colormap=None, colors=None, linewidths=None, linestyles=None, vmin=None, vmax=None, grid=None, show=None, **kwargs)#
在二维网格上绘制等高线。
- Parameters:
x – {表达式}
y – {表达式}
what – 要绘制的内容，count(*) 将显示一个 N 维直方图，mean('x') 表示 x 列的平均值，sum('x') 表示总和，std('x') 表示标准差，correlation('vx', 'vy') 表示相关系数。也可以是一个值列表，如 ['count(x)', std('vx')]（默认映射到列）
limits – {limits}
shape – {shape}
selection – {selection}
f – 通过以下方式转换值：'identity' 不做任何操作，'log' 或 'log10' 将显示值的对数
figsize – 传递给 plt.figure 的 (x, y) 元组，用于设置图形大小
xlabel – x轴的标签（默认为参数x）
ylabel – y轴的标签（默认为参数 y）
aspect – 图形的宽高比
levels – 要传递给 plt.contour 或 plt.contourf 的等高线级别
colorbar – 是否绘制颜色条
colorbar_label – 颜色条的标签（默认为参数 what）
colormap – 传递给 plt.contour 或 plt.contourf 的 matplotlib 颜色映射
colors – 等高线的颜色
linewidths – 轮廓的宽度
linestyles – 等高线的样式
vmin – 不使用自动归一化，将数据缩放到 vmin 和 vmax 之间
vmax – 参见 vmin
grid – {grid}
显示
- plot3d(x, y, z, vx=None, vy=None, vz=None, vwhat=None, limits=None, grid=None, what='count(*)', shape=128, selection=[None, True], f=None, vcount_limits=None, smooth_pre=None, smooth_post=None, grid_limits=None, normalize='normalize', colormap='afmhot', figure_key=None, fig=None, lighting=True, level=[0.1, 0.5, 0.9], opacity=[0.01, 0.05, 0.1], level_width=0.1, show=True, **kwargs)[源代码]#
使用风险自负，需要ipyvolume
- plot_bq(x, y, grid=None, shape=256, limits=None, what='count(*)', figsize=None, f='identity', figure_key=None, fig=None, axes=None, xlabel=None, ylabel=None, title=None, show=True, selection=[None, True], colormap='afmhot', grid_limits=None, normalize='normalize', grid_before=None, what_kwargs={}, type='default', scales=None, tool_select=False, bq_cleanup=True, **kwargs)[来源]#
已弃用：请使用 plot_widget
- propagate_uncertainties(columns, depending_variables=None, cov_matrix='auto', covariance_format='{}_{}_covariance', uncertainty_format='{}_uncertainty')[source]#
为一组虚拟列传播不确定性（完整的协方差矩阵）。
通过查找以“e”或“e_”为前缀或以“_error”、“_uncertainty”、“e”和“_e”为后缀的列来猜测因变量的协方差矩阵。 通过后缀“_correlation”或“_corr”表示相关性，或“_covariance”或“_cov”表示协方差来确定非对角线（协方差或相关性）。 （注意x_y_cov = x_e * y_e * x_y_correlation。）
Example
>>> df = vaex.from_scalars(x=1, y=2, e_x=0.1, e_y=0.2) >>> df["u"] = df.x + df.y >>> df["v"] = np.log10(df.x) >>> df.propagate_uncertainties([df.u, df.v]) >>> df.u_uncertainty, df.v_uncertainty
- Parameters:
columns – 用于计算协方差矩阵的列列表。
depending_variables – 如果未给出，则会自动找出，否则是一个包含不确定性的列列表。
cov_matrix – 由表达式组成的列表的列表，给出协方差矩阵，顺序与 depending_variables 相同。如果为 'full' 或 'auto'，将猜测 depending_variables 的协方差矩阵，其中 'full' 在未找到条目时会报错。
- rolling(window, trim=False, column=None, fill_value=None, edge='right')[source]#
创建一个
vaex.rolling.Rolling滚动窗口对象
- sample(n=None, frac=None, replace=False, weights=None, random_state=None)[source]#
返回一个包含随机行集的DataFrame
注意
请注意，不会复制底层数据，只会创建视图/引用。
提供 n 或 frac。
示例：
>>> import vaex, numpy as np >>> df = vaex.from_arrays(s=np.array(['a', 'b', 'c', 'd']), x=np.arange(1,5)) >>> df # s x 0 a 1 1 b 2 2 c 3 3 d 4 >>> df.sample(n=2, random_state=42) # 2 random rows, fixed seed # s x 0 b 2 1 d 4 >>> df.sample(frac=1, random_state=42) # 'shuffling' # s x 0 c 3 1 a 1 2 d 4 3 b 2 >>> df.sample(frac=1, replace=True, random_state=42) # useful for bootstrap (may contain repeated samples) # s x 0 d 4 1 a 1 2 a 1 3 d 4
- schema_arrow(reduce_large=False)[source]#
类似于
schema()，但返回一个箭头模式- Parameters:
reduce_large (bool) – 将大字符串转换为普通字符串
- select(boolean_expression, mode='replace', name='default', executor=None)[来源]#
执行一个选择，由布尔表达式定义，并使用给定的模式与之前的选择结合。
选择记录在每个名称的历史树中，可以分别对它们进行撤销/重做。
- select_box(spaces, limits, mode='replace', name='default')[源代码]#
选择一个由界限界定的n维矩形框。
以下示例是等效的：
>>> df.select_box(['x', 'y'], [(0, 10), (0, 1)]) >>> df.select_rectangle('x', 'y', [(0, 10), (0, 1)])
- Parameters:
spaces – 表达式列表
limits – 形状为 [(x1, x2), (y1, y2)] 的序列
模式
名称
- Returns:
- select_circle(x, y, xc, yc, r, mode='replace', name='default', inclusive=True)[source]#
选择一个以xc, yc为中心，半径为r的圆形区域。
示例：
>>> df.select_circle('x','y',2,3,1)
- Parameters:
x – x 空间的表达式
y – y 空间的表达式
xc – 圆心在x轴上的位置
yc – 圆心在 y 轴上的位置
r – 圆的半径
name – 选择的名称
模式
- Returns:
- select_ellipse(x, y, xc, yc, width, height, angle=0, mode='replace', name='default', radians=False, inclusive=True)[source]#
选择一个以xc, yc为中心的椭圆形区域，具有一定的宽度、高度和角度。
示例：
>>> df.select_ellipse('x','y', 2, -1, 5,1, 30, name='my_ellipse')
- Parameters:
x – x 空间的表达式
y – y 空间的表达式
xc – 椭圆中心在x轴上的位置
yc – 椭圆中心在 y 轴上的位置
width – 椭圆的宽度（直径）
height – 椭圆的宽度（直径）
angle – （度）椭圆的定向，从y轴逆时针测量
name – 选择的名称
模式
- Returns:
- select_inverse(name='default', executor=None)[source]#
反转选择，即被选中的将不被选中，反之亦然
- Parameters:
name (str)
执行器
- Returns:
- select_lasso(expression_x, expression_y, xsequence, ysequence, mode='replace', name='default', executor=None)[source]#
出于性能原因，套索选择的处理方式有所不同。
- select_non_missing(drop_nan=True, drop_masked=True, column_names=None, mode='replace', name='default')[source]#
创建一个选择，选择在column_names中的所有列都具有非缺失值的行。
名称反映了Pandas，实际上没有删除任何行，而是保留了一个掩码来跟踪选择
- select_rectangle(x, y, limits, mode='replace', name='default')[source]#
在由x和y给出的空间中，选择一个由限制条件界定的二维矩形框。
示例：
>>> df.select_box('x', 'y', [(0, 10), (0, 1)])
- Parameters:
x – x 空间的表达式
y – y 空间的表达式
limits – 形状为 [(x1, x2), (y1, y2)] 的序列
模式
- set_active_fraction(value)[source]#
设置active_fraction，将选中的行设置为None，并移除选择。
待办事项：如果我们保留表达式以及选定的行，我们可能能够保留选择
- set_selection(selection, name='default', executor=None)[来源]#
设置选择对象
- Parameters:
selection – 选择对象
name – 选择 'slot'
执行器
- Returns:
- set_variable(name, expression_or_value, write=True)[源代码]#
将变量设置为由expression_or_value定义的表达式或值。
Example
>>> df.set_variable("a", 2.) >>> df.set_variable("b", "a**2") >>> df.get_variable("b") 'a**2' >>> df.evaluate_variable("b") 4.0
- Parameters:
name – 变量的名称
write – 将变量写入元文件
expression – 值或表达式
- shift(periods, column=None, fill_value=None, trim=False, inplace=False)[source]#
将一列或多列按periods数量的行进行移动。
- shuffle(random_state=None)[来源]#
打乱行的顺序（等同于 df.sample(frac=1)）
注意
请注意，不会复制底层数据，只会创建视图/引用。
示例：
>>> import vaex, numpy as np >>> df = vaex.from_arrays(s=np.array(['a', 'b', 'c']), x=np.arange(1,4)) >>> df # s x 0 a 1 1 b 2 2 c 3 >>> df.shuffle(random_state=42) # s x 0 a 1 1 b 2 2 c 3
- Parameters:
RandomState (int 或) – 设置一个种子或RandomState以确保可重复性。当None时，将选择一个随机种子。
- Returns:
返回一个新的DataFrame，其中包含基础数据的浅拷贝/视图
- Return type:
- skew(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算给定表达式的偏斜度，可能在由binby定义的网格上进行。
示例：
>>> df.skew("vz") 0.02116528 >>> df.skew("vz", binby=["E"], shape=4) array([-0.069976 , -0.01003445, 0.05624177, -2.2444322 ])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- sort(by, ascending=True)[source]#
返回一个按表达式‘by’排序的DataFrame。
'by' 和 'ascending' 参数都可以是列表。 请注意，无论排序顺序如何，缺失/NaN/NA 值总是会被推到末尾。
注意
请注意，不会复制底层数据，只会创建视图/引用。
注意
请注意，过滤将被忽略（因为它们可能会改变），您可能需要考虑先运行
extract()。示例：
>>> import vaex, numpy as np >>> df = vaex.from_arrays(s=np.array(['a', 'b', 'c', 'd']), x=np.arange(1,5)) >>> df['y'] = (df.x-1.8)**2 >>> df # s x y 0 a 1 0.64 1 b 2 0.04 2 c 3 1.44 3 d 4 4.84 >>> df.sort('y', ascending=False) # Note: passing '(x-1.8)**2' gives the same result # s x y 0 d 4 4.84 1 c 3 1.44 2 a 1 0.64 3 b 2 0.04
- split(into=None)[来源]#
返回一个包含DataFrame有序子集的列表。
注意
请注意，不会复制底层数据，只会创建视图/引用。
示例：
>>> import vaex >>> df = vaex.from_arrays(x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> for dfs in df.split(into=0.3): ... print(dfs.x.values) ... [0 1 3] [3 4 5 6 7 8 9] >>> for split in df.split(into=[0.2, 0.3, 0.5]): ... print(dfs.x.values) [0 1] [2 3 4] [5 6 7 8 9]
- Parameters:
into (int/float/list) – 如果是浮点数，将把DataFrame分成两部分，其中第一部分的相对长度由该参数指定。 如果是列表，将分成与列表中元素数量相同的部分，其中每个元素定义该部分的相对长度。请注意，这样的分数列表将始终重新归一化为1。 如果是整数，将DataFrame分成n个长度相等的DataFrame（最后一个可能会有所不同），如果len(df) < n，它将返回len(df)个DataFrame。
- split_random(into, random_state=None)[source]#
返回一个包含DataFrame随机部分的数据列表。
注意
请注意，不会复制底层数据，只会创建视图/引用。
示例：
>>> import vaex, import numpy as np >>> np.random.seed(111) >>> df = vaex.from_arrays(x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> for dfs in df.split_random(into=0.3, random_state=42): ... print(dfs.x.values) ... [8 1 5] [0 7 2 9 4 3 6] >>> for split in df.split_random(into=[0.2, 0.3, 0.5], random_state=42): ... print(dfs.x.values) [8 1] [5 0 7] [2 9 4 3 6]
- Parameters:
into (int/float/list) – 如果是浮点数，将把DataFrame分成两部分，其中第一部分的相对长度由该参数指定。 如果是列表，将分成与列表中元素数量相同的部分，其中每个元素定义该部分的相对长度。请注意，这样的分数列表将始终重新归一化为1。 如果是整数，将DataFrame分成n个长度相等的DataFrame（最后一个可能会有所不同），如果len(df) < n，它将返回len(df)个DataFrame。
RandomState (int 或) – 设置一个种子或 RandomState 以确保可重复性。当为 None 时，将选择一个随机种子。
- Returns:
DataFrame 的列表。
- Return type:
- state_load(file, use_active_range=False, keep_columns=None, set_filter=True, trusted=True, fs_options=None, fs=None)[source]#
加载之前由
DataFrame.state_write()存储的状态，另请参见DataFrame.state_set()。
- state_write(file, fs_options=None, fs=None)[来源]#
将内部状态写入json或yaml文件（参见
DataFrame.state_get()）Example
>>> import vaex >>> df = vaex.from_scalars(x=1, y=2) >>> df['r'] = (df.x**2 + df.y**2)**0.5 >>> df.state_write('state.json') >>> print(open('state.json').read()) { "virtual_columns": { "r": "(((x ** 2) + (y ** 2)) ** 0.5)" }, "column_names": [ "x", "y", "r" ], "renamed_columns": [], "variables": { "pi": 3.141592653589793, "e": 2.718281828459045, "km_in_au": 149597870.7, "seconds_per_year": 31557600 }, "functions": {}, "selections": { "__filter__": null }, "ucds": {}, "units": {}, "descriptions": {}, "description": null, "active_range": [ 0, 1 ] } >>> df.state_write('state.yaml') >>> print(open('state.yaml').read()) active_range: - 0 - 1 column_names: - x - y - r description: null descriptions: {} functions: {} renamed_columns: [] selections: __filter__: null ucds: {} units: {} variables: pi: 3.141592653589793 e: 2.718281828459045 km_in_au: 149597870.7 seconds_per_year: 31557600 virtual_columns: r: (((x ** 2) + (y ** 2)) ** 0.5)
- Parameters:
file (str) – 文件名（以 .json 或 .yaml 结尾）
fs_options (dict) – 传递给文件系统处理程序（s3fs 或 gcsfs）的参数
fs – ‘直接传递一个文件系统对象，参见
vaex.open()’
- std(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, array_type=None)[来源]#
计算给定表达式的标准差，可能在由binby定义的网格上进行
>>> df.std("vz") 110.31773397535071 >>> df.std("vz", binby=["(x**2+y**2)**0.5"], shape=4) array([ 123.57954851, 85.35190177, 61.14345748, 38.0740619 ])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- sum(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算给定表达式的总和，可能在由binby定义的网格上进行
示例：
>>> df.sum("L") 304054882.49378014 >>> df.sum("L", binby="E", shape=4) array([ 8.83517994e+06, 5.92217598e+07, 9.55218726e+07, 1.40008776e+08])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
- take(indices, filtered=True, dropfilter=True)[source]#
返回一个仅包含由索引索引的行的DataFrame
注意
请注意，不会复制底层数据，只会创建视图/引用。
示例：
>>> import vaex, numpy as np >>> df = vaex.from_arrays(s=np.array(['a', 'b', 'c', 'd']), x=np.arange(1,5)) >>> df.take([0,2]) # s x 0 a 1 1 c 3
- Parameters:
indices – 包含行号的序列（列表或numpy数组）
filtered – (供内部使用) 索引指的是过滤后的数据。
dropfilter – （供内部使用）删除过滤器，当索引引用未过滤的数据时设置为False，但可能仍包含需要过滤掉的行。
- Returns:
DataFrame 是原始数据的浅拷贝。
- Return type:
- to_arrays(column_names=None, selection=None, strings=True, virtual=True, parallel=True, chunk_size=None, array_type=None)[source]#
返回一个ndarrays列表
- Parameters:
column_names – 列名列表，用于导出，当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
strings – 当 column_names 为 None 时，传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估（虚拟）列
chunk_size – 返回一个迭代器，其中包含按此长度切割的对象
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
数组列表
- to_arrow_table(column_names=None, selection=None, strings=True, virtual=True, parallel=True, chunk_size=None, reduce_large=False)[source]#
返回一个包含与评估数据对应的数组的箭头表对象
- Parameters:
column_names – 列名列表，用于导出，当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估（虚拟）列
chunk_size – 返回一个迭代器，该迭代器将对象切割成此大小的片段
reduce_large (bool) – 如果可能，将large_string转换为普通字符串
- Returns:
pyarrow.Table 对象或迭代器
- to_astropy_table(column_names=None, selection=None, strings=True, virtual=True, index=None, parallel=True)[source]#
返回一个包含与评估数据对应的ndarrays的astropy表对象
- Parameters:
column_names – 列名列表，用于导出，当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
index – 如果提供了此列，它将用作DataFrame的索引
- Returns:
astropy.table.Table 对象
- to_dask_array(chunks='auto')[source]#
懒散地将DataFrame暴露为dask.array
Example
>>> df = vaex.example() >>> A = df[['x', 'y', 'z']].to_dask_array() >>> A dask.array<vaex-df-1f048b40-10ec-11ea-9553, shape=(330000, 3), dtype=float64, chunksize=(330000, 3), chunktype=numpy.ndarray> >>> A+1 dask.array<add, shape=(330000, 3), dtype=float64, chunksize=(330000, 3), chunktype=numpy.ndarray>
- Parameters:
chunks – 如何分割数组，类似于
dask.array.from_array()。- Returns:
dask.array.Array对象。
- to_dict(column_names=None, selection=None, strings=True, virtual=True, parallel=True, chunk_size=None, array_type=None)[来源]#
返回一个包含与评估数据对应的ndarray的字典
- Parameters:
column_names – 列名列表，用于导出，当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估（虚拟）列
chunk_size – 返回一个迭代器，该迭代器将对象切割成此大小的片段
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
字典
- to_items(column_names=None, selection=None, strings=True, virtual=True, parallel=True, chunk_size=None, array_type=None)[来源]#
返回一个[(列名, ndarray), …)]对的列表，其中ndarray对应于评估的数据
- Parameters:
column_names – 列名列表，用于导出，当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估（虚拟）列
chunk_size – 返回一个迭代器，该迭代器将对象切割成此大小的片段
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
(名称, ndarray) 对的列表或迭代器
- to_pandas_df(column_names=None, selection=None, strings=True, virtual=True, index_name=None, parallel=True, chunk_size=None, array_type=None)[source]#
返回一个包含与评估数据对应的ndarray的pandas DataFrame
如果提供了索引，则该列将用作数据框的索引。
Example
>>> df_pandas = df.to_pandas_df(["x", "y", "z"]) >>> df_copy = vaex.from_pandas(df_pandas)
- Parameters:
column_names – 列名列表，用于导出，当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
index_column – 如果提供了此列，它将用作DataFrame的索引
parallel – 并行评估（虚拟）列
chunk_size – 返回一个迭代器，该迭代器将对象切割成此大小的片段
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
pandas.DataFrame 对象或迭代器
- to_records(index=None, selection=None, column_names=None, strings=True, virtual=True, parallel=True, chunk_size=None, array_type='python')[source]#
返回一个列表 [{column_name: value}, …)] “记录”，其中每个字典是一个评估过的行。
- Parameters:
index – 当提供时，用于获取特定行的记录的索引
column_names – 列名列表，用于导出，当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估（虚拟）列
chunk_size – 返回一个迭代器，该迭代器将对象切割成此大小的片段
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
记录列表 [{column_name:value}, …]
- trim(inplace=False)[source]#
返回一个DataFrame，其中所有列都被活动范围“修剪”。
对于返回的DataFrame，df.get_active_range()返回(0, df.length_original())。
注意
请注意，不会复制底层数据，只会创建视图/引用。
- Parameters:
inplace – 如果为True，则对自身进行修改，否则返回一个新的DataFrame
- Return type:
- ucd_find(ucds, exclude=[])[source]#
找到一组具有ucd或部分ucd的列（名称）。
以 ^ 开头，它将仅匹配 ucd 的第一部分。
Example
>>> df.ucd_find('pos.eq.ra', 'pos.eq.dec') ['RA', 'DEC'] >>> df.ucd_find('pos.eq.ra', 'doesnotexist') >>> df.ucds[df.ucd_find('pos.eq.ra')] 'pos.eq.ra;meta.main' >>> df.ucd_find('meta.main')] 'dec' >>> df.ucd_find('^meta.main')]
- unique(expression, return_inverse=False, dropna=False, dropnan=False, dropmissing=False, progress=False, selection=None, axis=None, delay=False, limit=None, limit_raise=True, array_type='python')[source]#
返回所有唯一值。
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
return_inverse – 返回从唯一值到原始值的逆映射。
dropna – 删除包含不可用（NA）值（NaN 或缺失值）的行。
dropnan – 删除包含NaN值的行
dropmissing – 删除包含缺失值的行
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
axis (int) – 确定唯一元素的轴（None 将会展平数组或列表）
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
limit (int) – 限制结果的数量
limit_raise (bool) – 当超过限制时，抛出
vaex.RowLimitException，或者最多返回 'limit' 数量的结果。array_type (str) – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray” 用于 xarray.DataArray，或 “list”/“python” 用于 Python 列表
- unit(expression, default=None)[source]#
返回表达式的单位（一个 astropy.unit.Units 对象）。
Example
>>> import vaex >>> ds = vaex.example() >>> df.unit("x") Unit("kpc") >>> df.unit("x*L") Unit("km kpc2 / s")
- Parameters:
expression – 表达式，可以是一个列名
default – 如果没有已知的单位，将返回此值
- Returns:
表达式的结果单位
- Return type:
astropy.units.Unit
- var(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, array_type=None)[source]#
计算给定表达式的样本方差，可能在由binby定义的网格上
示例：
>>> df.var("vz") 12170.002429456246 >>> df.var("vz", binby=["(x**2+y**2)**0.5"], shape=4) array([ 15271.90481083, 7284.94713504, 3738.52239232, 1449.63418988]) >>> df.var("vz", binby=["(x**2+y**2)**0.5"], shape=4)**0.5 array([ 123.57954851, 85.35190177, 61.14345748, 38.0740619 ])
- Parameters:
expression – 表达式或表达式列表，例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
delay – 不返回结果，而是返回异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组，或者在没有给出binby参数时为一个标量，包含统计量
DataFrameLocal 类#
- class vaex.dataframe.DataFrameLocal(dataset=None, name=None)[source]#
基础类:
DataFrame用于处理本地文件/数据的DataFrames的基类
- __array__(dtype=None, parallel=True)[source]#
将DataFrame的完整内存副本转换为形状为(n_rows, n_columns)的2d numpy数组。 请注意，内存顺序是fortran顺序，因此出于性能原因，1列的所有值在内存中是连续的。
注意，这将返回与以下相同的结果：
>>> np.array(ds)
如果任何列包含掩码数组，掩码将被忽略（即掩码元素也会被返回）。
- binby(by=None, agg=None, sort=False, copy=True, delay=False, progress=None)[来源]#
当agg不为None时，返回一个
BinBy或DataArray对象binby 操作不会返回一个“扁平”的 DataFrame，而是返回一个以 xarray 形式表示的 N 维网格。
- Parameters:
- Returns:
DataArray或BinBy对象。
- categorize(column, min_value=0, max_value=None, labels=None, inplace=False)[source]#
将列标记为分类。
这可能有助于加快使用[min_value, max_value]范围内的整数列的计算速度。
如果没有给出max_value，则[min_value和max_value]将从数据中计算得出。
示例：
>>> import vaex >>> df = vaex.from_arrays(year=[2012, 2015, 2019], weekday=[0, 4, 6]) >>> df = df.categorize('year', min_value=2020, max_value=2019) >>> df = df.categorize('weekday', labels=['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']) >>> df # year weekday 0 2012 0 1 2015 4 2 2019 6 >>> df.is_category('year') True
- Parameters:
column – 假设为分类的列。
labels – 与 min_value 和 max_value 之间的值相关联的标签
min_value – 最小整数值（如果未给出max_value，则计算此值）
max_value – 最大整数值（如果未给出 max_value，则计算此值）
labels – 与每个值关联的标签，默认为 list(range(min_value, max_value+1))
inplace – 如果为True，则对自身进行修改，否则返回一个新的DataFrame
- compare(other, report_missing=True, report_difference=False, show=10, orderby=None, column_names=None)[source]#
比较两个DataFrame并报告它们的差异，对于大型DataFrame请谨慎使用
- concat(*others, resolver='flexible') DataFrame[来源]#
将多个DataFrame连接起来，将其他DataFrame的行添加到当前DataFrame中，并返回一个新的DataFrame。
在resolver='flexible'的情况下，当并非所有列具有相同的名称时，缺失的数据将用缺失值填充。
在resolver='strict'的情况下，所有数据集都需要有匹配的列名。
- Parameters:
others – 与此DataFrame连接的其他DataFrames
resolver (str) – 如何解决模式冲突，'flexible' 或 'strict'。
- Returns:
新DataFrame，行已连接
- copy(column_names=None, treeshake=False)[来源]#
制作一个DataFrame的浅拷贝。也可以指定列的子集。
这是一个相当廉价的操作，因为不会对底层数据进行内存复制。
{note_copy}
- property data#
直接访问数据作为numpy数组。
在与小数据框结合使用IPython时非常方便，因为这提供了标签补全功能。 只能访问真实列（即非虚拟列），要从虚拟列获取数据，请使用 DataFrame.evaluate(…)。
可以通过列名访问列，列名是属性。这些属性的类型是numpy.ndarray。
示例：
>>> df = vaex.example() >>> r = np.sqrt(df.data.x**2 + df.data.y**2)
- export(path, progress=None, chunk_size=1048576, parallel=True, fs_options=None, fs=None, **kwargs)[来源]#
根据文件扩展名将DataFrame导出到文件。
例如，如果文件名以 .hdf5 结尾，则调用 df.export_hdf5。
- Parameters:
path (str) – 文件的路径
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
chunk_size (int) – 如果支持，每次迭代写入磁盘的行数。
parallel (bool) – 并行评估（虚拟）列
fs_options (dict) – 参见
vaex.open()例如对于 S3 {“profile”: “myproject”}
- Returns:
- export_arrow(to, progress=None, chunk_size=1048576, parallel=True, reduce_large=True, fs_options=None, fs=None, as_stream=True)[来源]#
将DataFrame导出到用arrow写入的文件或流中
- Parameters:
to – 文件名、文件对象，或
pyarrow.RecordBatchStreamWriter, py:data:pyarrow.RecordBatchFileWriter 或pyarrow.parquet.ParquetWriterprogress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel (bool) – 并行评估（虚拟）列
reduce_large (bool) – 如果为True，将arrow large_string类型转换为string类型
as_stream (bool) – 如果为真，则写入为Arrow流，否则写入为文件。 另见 https://arrow.apache.org/docs/format/Columnar.html?highlight=arrow1#ipc-file-format
fs_options (dict) – 参见
vaex.open()例如对于 S3 {“profile”: “myproject”}
- Returns:
- export_csv(path, progress=None, chunk_size=1048576, parallel=True, backend='pandas', **kwargs)[source]#
将DataFrame导出到CSV文件。
- Parameters:
path (str) – 文件的路径
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel (bool) – 并行评估（虚拟）列
backend (str) – 使用哪个后端，可以是‘pandas’或‘arrow’。Arrow速度更快，但pandas更灵活。
kwargs – 额外的关键字参数传递给后端。详情请参见
DataFrameLocal.export_csv_pandas()和DataFrameLocal.export_csv_arrow()。
- export_csv_arrow(to, progress=None, chunk_size=1048576, parallel=True, fs_options=None, fs=None)[source]#
通过PyArrow将DataFrame导出为CSV文件。
- Parameters:
to (str) – 文件的路径
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel (bool) – 并行评估（虚拟）列
fs_options (dict) – 参见
vaex.open()例如对于 S3 {“profile”: “myproject”}fs – 直接传递一个文件系统对象，参见
vaex.open()
- export_csv_pandas(path, progress=None, chunk_size=1048576, parallel=True, **kwargs)[来源]#
通过Pandas将DataFrame导出到CSV文件。
- export_feather(to, parallel=True, reduce_large=True, compression='lz4', fs_options=None, fs=None)[source]#
使用feather文件格式版本2将DataFrame导出为arrow文件
- Feather is exactly represented as the Arrow IPC file format on disk, but also support compression.
- Parameters:
to – 文件名或文件对象
parallel (bool) – 并行评估（虚拟）列
reduce_large (bool) – 如果为True，将arrow large_string类型转换为string类型
compression – 可以是 'zstd'、'lz4' 或 'uncompressed' 之一
fs_options – 参见
vaex.open()例如对于 S3 {“profile”: “myproject”}fs – 直接传递一个文件系统对象，参见
vaex.open()
- Returns:
- export_fits(path, progress=None)[source]#
将DataFrame导出为与TOPCAT colfits格式兼容的fits文件
- Parameters:
path (str) – 文件的路径
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
- Returns:
- export_hdf5(path, byteorder='=', progress=None, chunk_size=1048576, parallel=True, column_count=1, writer_threads=0, group='/table', mode='w')[source]#
将DataFrame导出为vaex hdf5文件
- Parameters:
path (str) – 文件的路径
byteorder (str) – = 表示本机字节序，< 表示小端序，> 表示大端序
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
parallel (bool) – 并行评估（虚拟）列
column_count (int) – 并行评估和导出的列数（大于1需要快速的随机访问，如SSD驱动器）。
writer_threads (int) – 是否使用线程进行写入，仅在 column_count > 1 时有用。
group (str) – 将数据写入hdf5文件中的自定义组。
mode (str) – 如果设置为“w”（写入），现有文件将被覆盖。如果设置为“a”，可以将附加数据追加到hdf5文件中，但需要放在不同的组中。
- Returns:
- export_json(to, progress=None, chunk_size=1048576, parallel=True, fs_options=None, fs=None)[source]#
将DataFrame导出到CSV文件。
- Parameters:
to – 文件名或文件对象
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel – 并行评估（虚拟）列
fs_options – 参见
vaex.open()例如对于 S3 {“profile”: “myproject”}fs – 直接传递一个文件系统对象，参见
vaex.open()
- Returns:
- export_many(path, progress=None, chunk_size=1048576, parallel=True, max_workers=None, fs_options=None, fs=None, **export_kwargs)[source]#
将DataFrame并行导出为多个相同类型的文件。
路径将使用i参数（即块索引）进行格式化。
示例：
>>> import vaex >>> df = vaex.open('my_big_dataset.hdf5') >>> print(f'number of rows: {len(df):,}') number of rows: 193,938,982 >>> df.export_many(path='my/destination/folder/chunk-{i:03}.arrow') >>> df_single_chunk = vaex.open('my/destination/folder/chunk-00001.arrow') >>> print(f'number of rows: {len(df_single_chunk):,}') number of rows: 1,048,576 >>> df_all_chunks = vaex.open('my/destination/folder/chunk-*.arrow') >>> print(f'number of rows: {len(df_all_chunks):,}') number of rows: 193,938,982
- Parameters:
path (str) – 文件路径，按块索引 i 格式化（例如 'chunk-{i:05}.parquet'）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel (bool) – 并行评估（虚拟）列
max_workers (int) – 用于并行写入的工作线程/线程数
fs_options (dict) – 参见
vaex.open()例如对于 S3 {“profile”: “myproject”}
- export_parquet(path, progress=None, chunk_size=1048576, parallel=True, fs_options=None, fs=None, **kwargs)[来源]#
将DataFrame导出为parquet文件。
注意：这可能要求所有数据都适合内存（内存映射数据是一个例外）。
- Parameters:
path (str) – 文件的路径
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel (bool) – 并行评估（虚拟）列
fs_options (dict) – 参见
vaex.open()例如对于 S3 {“profile”: “myproject”}fs – 直接传递一个文件系统对象，参见
vaex.open()kwargs – 传递给
py:data:pyarrow.parquet.ParquetWriter的额外关键字参数。
- Returns:
- export_partitioned(path, by, directory_format='{key}={value}', progress=None, chunk_size=1048576, parallel=True, fs_options={}, fs=None)[来源]#
实验性：使用 hive 分区导出文件。
如果在路径中没有找到扩展名，我们假设是parquet文件。否则，你可以像格式字符串一样指定格式。其中{i}是从零开始的索引，{uuid}是唯一ID，{subdir}是Hive的key=value目录。
- Example paths:
‘/some/dir/{subdir}/{i}.parquet’
‘/some/dir/{subdir}/fixed_name.parquet’
‘/some/dir/{subdir}/{uuid}.parquet’
‘/some/dir/{subdir}/{uuid}.parquet’
- Parameters:
path – 写入文件的目录。
str (str 或 列表) – 按哪一列进行分区。
directory_format (str) – 目录的格式字符串，Hive布局的默认值为‘{key}={value}’。
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel (bool) – 并行评估（虚拟）列
fs_options (dict) – 参见
vaex.open()例如对于 S3 {“profile”: “myproject”}
- groupby(by=None, agg=None, sort=False, ascending=True, assume_sparse='auto', row_limit=None, copy=True, progress=None, delay=False)[source]#
当agg不为None时，返回一个
GroupBy或DataFrame对象示例：
>>> import vaex >>> import numpy as np >>> np.random.seed(42) >>> x = np.random.randint(1, 5, 10) >>> y = x**2 >>> df = vaex.from_arrays(x=x, y=y) >>> df.groupby(df.x, agg='count') # x y_count 0 3 4 1 4 2 2 1 3 3 2 1 >>> df.groupby(df.x, agg=[vaex.agg.count('y'), vaex.agg.mean('y')]) # x y_count y_mean 0 3 4 9 1 4 2 16 2 1 3 1 3 2 1 4 >>> df.groupby(df.x, agg={'z': [vaex.agg.count('y'), vaex.agg.mean('y')]}) # x z_count z_mean 0 3 4 9 1 4 2 16 2 1 3 1 3 2 1 4
使用 datetime 的示例：
>>> import vaex >>> import numpy as np >>> t = np.arange('2015-01-01', '2015-02-01', dtype=np.datetime64) >>> y = np.arange(len(t)) >>> df = vaex.from_arrays(t=t, y=y) >>> df.groupby(vaex.BinnerTime.per_week(df.t)).agg({'y' : 'sum'}) # t y 0 2015-01-01 00:00:00 21 1 2015-01-08 00:00:00 70 2 2015-01-15 00:00:00 119 3 2015-01-22 00:00:00 168 4 2015-01-29 00:00:00 87
- Parameters:
agg (dict, list or agg) – 聚合操作，可以是字符串形式、vaex.agg对象、字典（其中键表示目标列名，值表示操作），或者是聚合操作的列表。如果未提供，将返回groupby对象。
sort (bool) – 对我们分组的列进行排序。
assume_sparse (bool 或 str) – 假设在按多个键分组时，现有的键值对相对于笛卡尔积是稀疏的。 如果为‘auto’，则由vaex决定（例如，一个包含10_000行但只有4*3=12种组合的分组，压缩为8种现有组合并不重要，并且将节省另一次数据遍历）
row_limit (int) – 限制结果数据框的行数（默认不检查，仅在 assume_sparse 为 True 时有效）。 当条件不满足时，抛出
vaex.RowLimitException。copy (bool) – 复制数据框（浅复制，不占用内存），以便原始数据框的指纹不被修改。
delay (bool) – 不返回结果，而是返回一个用于异步计算的代理（目前仅限内部使用）
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
- Returns:
DataFrame或GroupBy对象。
- is_local()[来源]#
DataFrame.evaluate()的本地实现总是返回 True。
- join(other, on=None, left_on=None, right_on=None, lprefix='', rprefix='', lsuffix='', rsuffix='', how='left', allow_duplication=False, prime_growth=False, cardinality_other=None, inplace=False)[来源]#
返回一个与其他DataFrames连接的DataFrame，通过列/表达式在/left_on/right_on上进行匹配
如果没有给出on/left_on/right_on，连接是通过简单地添加列来完成的（即在隐式行索引上）。
注意：在连接时，过滤器将被忽略，将连接完整的DataFrame（因为过滤器可能会改变）。如果任一DataFrame被大量过滤（仅包含少量行），请考虑首先运行
DataFrame.extract()。示例：
>>> a = np.array(['a', 'b', 'c']) >>> x = np.arange(1,4) >>> ds1 = vaex.from_arrays(a=a, x=x) >>> b = np.array(['a', 'b', 'd']) >>> y = x**2 >>> ds2 = vaex.from_arrays(b=b, y=y) >>> ds1.join(ds2, left_on='a', right_on='b')
- Parameters:
other – 要连接的另一个DataFrame（右侧）
on – 左表（自身）的默认键
left_on – 左表（self）的键，覆盖 on
right_on – 右表（other）的默认键，覆盖 on
lprefix – 在名称冲突的情况下，添加到左侧列名称的前缀
rprefix – 右侧类似
lsuffix – 在名称冲突的情况下，添加到左侧列名的后缀
rsuffix – 右侧的类似内容
how – 如何连接，'left' 保留左侧的所有行，并添加列（可能包含缺失值） 'right' 类似，但交换了自身和其他。'inner' 仅返回重叠的行。
allow_duplication (bool) – 当连接的列包含非唯一值时，允许行的重复。
cardinality_other (int) – 另一个表的唯一元素数量（或估计值）。
prime_growth (bool) – 用于内部哈希表的增长策略，在某些情况下可以提高性能（例如，未使用低位整数的整数）。
inplace – 如果为True，则对自身进行修改，否则返回一个新的DataFrame
- Returns:
- label_encode(column, values=None, inplace=False, lazy=False)#
已弃用：请使用 ordinal_encode
将列编码为序数值并将其标记为分类。
现有列被重命名为隐藏列，并被替换为数值列，其值在[0, len(values)-1]之间。
- param lazy:
当为False时，它将具体化序数代码。
- length(selection=False)[来源]#
获取DataFrames的长度，用于选择整个DataFrame。
如果选择为False，则返回len(df)。
待办事项：在DataFrameRemote中实现此功能，并将方法上移到
DataFrame.length()- Parameters:
selection – 当为True时，将返回所选行的数量
- Returns:
- ordinal_encode(column, values=None, inplace=False, lazy=False)[source]#
已弃用：请使用 ordinal_encode
将列编码为序数值并将其标记为分类。
现有列将被重命名为隐藏列，并被替换为数值列，其值在[0, len(values)-1]之间。
- param lazy:
当为False时，它将具体化序数代码。
- shallow_copy(virtual=True, variables=True)[source]#
创建DataFrame的（浅）副本。
它将链接到相同的数据，但会有自己的状态，例如虚拟列、变量、选择等。
- property values#
将DataFrame的完整内存副本转换为形状为(n_rows, n_columns)的2d numpy数组。 请注意，内存顺序是fortran顺序，因此出于性能原因，1列的所有值在内存中是连续的。
注意，这将返回与以下相同的结果：
>>> np.array(ds)
如果任何列包含掩码数组，掩码将被忽略（即掩码元素也会被返回）。
日期/时间操作#
- class vaex.expression.DateTime(expression)[来源]#
基础类：
object日期时间操作
通常使用例如 df.birthday.dt.dayofweek 访问
- __weakref__#
对象的弱引用列表
- property date#
返回日期时间值的日期部分
- Returns:
包含日期时间值的日期部分的表达式
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.date Expression = dt_date(date) Length: 3 dtype: datetime64[D] (expression) ------------------------------------------- 0 2009-10-12 1 2016-02-11 2 2015-11-12
- property day#
从日期时间样本中提取天数。
- Returns:
一个表达式，包含从日期时间列中提取的天数。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.day Expression = dt_day(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 12 1 11 2 12
- property day_name#
返回日期时间样本的英文星期名称。
- Returns:
一个表达式，包含从日期时间列中提取的星期名称。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.day_name Expression = dt_day_name(date) Length: 3 dtype: str (expression) --------------------------------- 0 Monday 1 Thursday 2 Thursday
- property dayofweek#
获取星期几，其中星期一=0，星期日=6
- Returns:
一个包含星期几的表达式。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.dayofweek Expression = dt_dayofweek(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 0 1 3 2 3
- property dayofyear#
一年中的序数日。
- Returns:
一个包含一年中序数日的表达式。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.dayofyear Expression = dt_dayofyear(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 285 1 42 2 316
- floor(freq, *args)#
对给定频率的表达式执行向下取整操作。
- Parameters:
freq – 将索引向下取整的频率级别。必须是一个固定的频率，如‘S’（秒）或‘H’（小时），但不能是‘ME’（月末）。
- Returns:
一个包含向下取整的日期时间列的表达式。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.floor("H") Expression = dt_floor(date, 'H') Length: 3 dtype: datetime64[ns] (expression) -------------------------------------------- 0 2009-10-12 03:00:00.000000000 1 2016-02-11 10:00:00.000000000 2 2015-11-12 11:00:00.000000000
- property halfyear#
返回日期的半年。值可以是1和2，分别表示上半年和下半年。
- Returns:
一个表达式，包含从日期时间列中提取的半年度。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22 >>> df.date.dt.halfyear Expression = dt_halfyear(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 2 1 1 2 2
- property hour#
从日期时间样本中提取小时。
- Returns:
一个表达式，包含从日期时间列中提取的小时。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.hour Expression = dt_hour(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 3 1 10 2 11
- property is_leap_year#
检查某一年是否为闰年。
- Returns:
一个表达式，如果某年是闰年则评估为True，否则为False。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.is_leap_year Expression = dt_is_leap_year(date) Length: 3 dtype: bool (expression) ---------------------------------- 0 False 1 True 2 False
- property minute#
从日期时间样本中提取分钟。
- Returns:
一个表达式，包含从日期时间列中提取的分钟。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.minute Expression = dt_minute(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 31 1 17 2 34
- property month#
从日期时间样本中提取月份。
- Returns:
一个表达式，包含从日期时间列中提取的月份。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.month Expression = dt_month(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 10 1 2 2 11
- property month_name#
返回一个日期时间样本的英文月份名称。
- Returns:
一个表达式，包含从日期时间列中提取的月份名称。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.month_name Expression = dt_month_name(date) Length: 3 dtype: str (expression) --------------------------------- 0 October 1 February 2 November
- property quarter#
返回日期的季度。值的范围是1-4。
- Returns:
一个表达式，包含从日期时间列中提取的季度。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22 >>> df.date.dt.quarter Expression = dt_quarter(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 4 1 1 2 4
- property second#
从日期时间样本中提取秒数。
- Returns:
一个表达式，包含从日期时间列中提取的秒数。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.second Expression = dt_second(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 0 1 34 2 22
- strftime(date_format)#
从日期时间样本返回格式化的字符串。
- Returns:
一个包含从日期时间列中提取的格式化字符串的表达式。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.strftime("%Y-%m") Expression = dt_strftime(date, '%Y-%m') Length: 3 dtype: object (expression) ------------------------------------ 0 2009-10 1 2016-02 2 2015-11
- property weekofyear#
返回一年中的周序号。
- Returns:
一个表达式，包含从日期时间列中提取的年份的周序号。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.weekofyear Expression = dt_weekofyear(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 42 1 6 2 46
- property year#
从日期时间样本中提取年份。
- Returns:
一个表达式，包含从日期时间列中提取的年份。
示例：
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.year Expression = dt_year(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 2009 1 2016 2 2015
表达式类#
- class vaex.expression.Expression(ds, expression, ast=None, _selection=False)[source]#
基础类：
objectExpression 类
- __bool__()[源代码]#
将表达式转换为布尔值。仅支持 (
== 和 != ) 主要用途是支持分配给traitlets。例如：
>>> bool(expr1 == expr2)
当expr1和expr2完全相同（在字符串表示中）时，这将返回True。同样适用于：
>>> bool(expr != expr2)
所有其他情况将返回True。
- __eq__(b)#
返回 self==value。
- __ge__(b)#
返回 self>=value。
- __getitem__(slicer)[source]#
通过方括号表示法提供行和可选字段访问（结构数组）。
示例：
>>> import vaex >>> import pyarrow as pa >>> array = pa.StructArray.from_arrays(arrays=[[1, 2, 3], ["a", "b", "c"]], names=["col1", "col2"]) >>> df = vaex.from_arrays(array=array, integer=[5, 6, 7]) >>> df # array integer 0 {'col1': 1, 'col2': 'a'} 5 1 {'col1': 2, 'col2': 'b'} 6 2 {'col1': 3, 'col2': 'c'} 7
>>> df.integer[1:] Expression = integer Length: 2 dtype: int64 (column) ------------------------------- 0 6 1 7
>>> df.array[1:] Expression = array Length: 2 dtype: struct<col1: int64, col2: string> (column) ----------------------------------------------------------- 0 {'col1': 2, 'col2': 'b'} 1 {'col1': 3, 'col2': 'c'}
>>> df.array[:, "col1"] Expression = struct_get(array, 'col1') Length: 3 dtype: int64 (expression) ----------------------------------- 0 1 1 2 2 3
>>> df.array[1:, ["col1"]] Expression = struct_project(array, ['col1']) Length: 2 dtype: struct<col1: int64> (expression) ------------------------------------------------- 0 {'col1': 2} 1 {'col1': 3}
>>> df.array[1:, ["col2", "col1"]] Expression = struct_project(array, ['col2', 'col1']) Length: 2 dtype: struct<col2: string, col1: int64> (expression) --------------------------------------------------------------- 0 {'col2': 'b', 'col1': 2} 1 {'col2': 'c', 'col1': 3}
- __gt__(b)#
返回 self>value。
- __hash__ = None#
- __le__(b)#
返回 self<=value。
- __lt__(b)#
返回 self
- __ne__(b)#
返回 self 不等于 value。
- __or__(b)#
返回 self|value。
- __ror__(b)#
返回值|自身。
- __weakref__#
对象的弱引用列表
- abs(**kwargs)#
围绕
numpy.abs的惰性包装器
- apply(f, vectorize=False, multiprocessing=True)[source]#
沿着表达式的所有值应用一个函数。
df.apply(f, arguments=[expression])的简写，参见DataFrame.apply()示例：
>>> df = vaex.example() >>> df.x Expression = x Length: 330,000 dtype: float64 (column) --------------------------------------- 0 -0.777471 1 3.77427 2 1.37576 3 -7.06738 4 0.243441
>>> def func(x): ... return x**2
>>> df.x.apply(func) Expression = lambda_function(x) Length: 330,000 dtype: float64 (expression) ------------------------------------------- 0 0.604461 1 14.2451 2 1.89272 3 49.9478 4 0.0592637
- Parameters:
f – 一个应用于表达式值的函数
vectorize – 使用数组而不是标量调用 f（以获得更好的性能）。
multiprocessing (bool) – 使用多进程以避免GIL（全局解释器锁）。
- Returns:
一个在调用时延迟求值的函数。
- arccos(**kwargs)#
围绕
numpy.arccos的惰性包装器
- arccosh(**kwargs)#
围绕
numpy.arccosh的惰性包装器
- arcsin(**kwargs)#
围绕
numpy.arcsin的懒加载包装器
- arcsinh(**kwargs)#
围绕
numpy.arcsinh的惰性包装器
- arctan(**kwargs)#
围绕
numpy.arctan的惰性包装器
- arctan2(**kwargs)#
围绕
numpy.arctan2的惰性包装器
- arctanh(**kwargs)#
围绕
numpy.arctanh的惰性包装器
- as_arrow()#
懒加载转换为Apache Arrow数组类型
- as_numpy(strict=False)#
懒加载转换为NumPy ndarray类型
- property ast#
返回表达式的抽象语法树（AST）
- clip(**kwargs)#
围绕
numpy.clip的惰性包装器
- copy(df=None)[来源]#
高效地复制一个表达式。
表达式对象既有字符串表示也有AST表示。创建AST表示涉及解析表达式，这是昂贵的。
使用 copy 将在表达式已被解析时深拷贝 AST。
- Parameters:
df – 用于评估表达式的DataFrame（如果为None，则为self.df）
- cosh(**kwargs)#
围绕
numpy.cosh的惰性包装器
- count(binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None)[source]#
ds.count(expression, …) 的快捷方式，参见 Dataset.count
- deg2rad(**kwargs)#
围绕
numpy.deg2rad的懒加载包装器
- digitize(**kwargs)#
围绕
numpy.digitize的惰性包装器
- dot_product(b)#
计算a和b之间的点积。
- Parameters:
a – 一个表达式列表或一个值列表（例如一个向量）
b – 一个表达式列表或一个值列表（例如一个向量）
- Returns:
Vaex 表达式
- expand(stop=[])[source]#
展开表达式，使其不包含虚拟列，仅包含普通列。
示例：
>>> df = vaex.example() >>> r = np.sqrt(df.data.x**2 + df.data.y**2) >>> r.expand().expression 'sqrt(((x ** 2) + (y ** 2)))'
- expm1(**kwargs)#
围绕
numpy.expm1的懒加载包装器
- fillna(value)#
返回一个数组，其中NA值被替换为指定值。 有关缺失值的定义，请参见：isna。
- fillnan(value)#
返回一个数组，其中nan值被替换为指定值。 有关缺失值的定义，请参见：isnan。
- format(format)#
使用 http://www.cplusplus.com/reference/string/to_string/ 进行格式化
- hashmap_apply(hashmap, check_missing=False)#
将值应用到哈希映射中，如果check_missing为True，哈希映射中的缺失值将被转换为null/缺失值
- isfinite(**kwargs)#
围绕
numpy.isfinite的惰性包装器
- isin(values, use_hashmap=True)[source]#
懒散地测试表达式中的每个值是否存在于值中。
- Parameters:
values – 要检查的值列表/数组
use_hashmap – 是否使用哈希表（当值包含许多元素时尤其更快）
- Returns:
Expression带有惰性表达式。
- isinf(**kwargs)#
围绕
numpy.isinf的惰性包装器
- ismissing()#
在有缺失值（掩码数组）、缺失字符串或None的地方返回True
- isna()#
返回一个布尔表达式，指示值是否不可用（缺失或NaN）。
- isnan()#
返回一个包含NaN值的数组
- kurtosis(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
df.kurtosis(expression, …) 的快捷方式，参见 DataFrame.kurtosis
- log10(**kwargs)#
围绕
numpy.log10的惰性包装器
- log1p(**kwargs)#
围绕
numpy.log1p的惰性包装
- map(mapper, nan_value=None, missing_value=None, default_value=None, allow_missing=False, axis=None)[source]#
根据输入的字典或自定义的可调用函数，映射表达式或内存列的值。
示例：
>>> import vaex >>> df = vaex.from_arrays(color=['red', 'red', 'blue', 'red', 'green']) >>> mapper = {'red': 1, 'blue': 2, 'green': 3} >>> df['color_mapped'] = df.color.map(mapper) >>> df # color color_mapped 0 red 1 1 red 1 2 blue 2 3 red 1 4 green 3 >>> import numpy as np >>> df = vaex.from_arrays(type=[0, 1, 2, 2, 2, np.nan]) >>> df['role'] = df['type'].map({0: 'admin', 1: 'maintainer', 2: 'user', np.nan: 'unknown'}) >>> df # type role 0 0 admin 1 1 maintainer 2 2 user 3 2 user 4 2 user 5 nan unknown >>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(type=[0, 1, 2, 2, 2, 4]) >>> df['role'] = df['type'].map({0: 'admin', 1: 'maintainer', 2: 'user'}, default_value='unknown') >>> df # type role 0 0 admin 1 1 maintainer 2 2 user 3 2 user 4 2 user 5 4 unknown :param mapper: dict like object used to map the values from keys to values :param nan_value: value to be used when a nan is present (and not in the mapper) :param missing_value: value to use used when there is a missing value :param default_value: value to be used when a value is not in the mapper (like dict.get(key, default)) :param allow_missing: used to signal that values in the mapper should map to a masked array with missing values, assumed True when default_value is not None. :param bool axis: Axis over which to determine the unique elements (None will flatten arrays or lists) :return: A vaex expression :rtype: vaex.expression.Expression
- property masked#
别名到 df.is_masked(expression)
- max(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.max(expression, …) 的快捷方式，参见 Dataset.max
- maximum(**kwargs)#
围绕
numpy.maximum的惰性包装
- mean(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.mean(expression, …) 的快捷方式，参见 Dataset.mean
- min(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.min(expression, …) 的快捷方式，参见 Dataset.min
- minimum(**kwargs)#
围绕
numpy.minimum的懒加载包装器
- minmax(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[来源]#
ds.minmax(expression, …) 的快捷方式，参见 Dataset.minmax
- notna()#
与isna相反
- nunique(dropna=False, dropnan=False, dropmissing=False, selection=None, axis=None, limit=None, limit_raise=True, progress=None, delay=False)[source]#
计算唯一值的数量，即 len(df.x.unique()) == df.x.nunique()。
- Parameters:
dropna – 删除包含不可用（NA）值（NaN 或缺失值）的行。
dropnan – 删除包含NaN值的行
dropmissing – 删除包含缺失值的行
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
axis (bool) – 确定唯一元素的轴（None 将展平数组或列表）
limit (int) – 限制结果的数量
limit_raise (bool) – 当超过限制时，抛出
vaex.RowLimitException，或者最多返回 'limit' 数量的结果。progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
delay (bool) – 不返回结果，而是返回一个用于异步计算的代理（目前仅限内部使用）
- rad2deg(**kwargs)#
围绕
numpy.rad2deg的懒加载包装器
- round(**kwargs)#
围绕
numpy.round的惰性包装器
- searchsorted(**kwargs)#
围绕
numpy.searchsorted的惰性包装器
- sinc(**kwargs)#
围绕
numpy.sinc的惰性包装器
- sinh(**kwargs)#
围绕
numpy.sinh的懒加载包装器
- skew(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
df.skew(expression, …) 的快捷方式，参见 DataFrame.skew
- sqrt(**kwargs)#
围绕
numpy.sqrt的懒加载包装器
- std(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.std(expression, …) 的快捷方式，参见 Dataset.std
- property str#
通过
StringOperations提供对字符串操作的访问
- property str_pandas#
通过
StringOperationsPandas（使用Pandas Series）提供对字符串操作的访问
- property struct#
通过
StructOperations提供对结构体操作的访问
- sum(axis=None, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[源代码]#
在给定轴上求和元素。
如果没有给出轴，它将对所有轴求和。
对于非列表元素，这是 ds.sum(expression, …) 的快捷方式，请参阅 Dataset.sum。
>>> list_data = [1, 2, None], None, [], [1, 3, 4, 5] >>> df = vaex.from_arrays(some_list=pa.array(list_data)) >>> df.some_list.sum().item() # will sum over all axis 16 >>> df.some_list.sum(axis=1).tolist() # sums the list elements [3, None, 0, 13]
- Parameters:
axis (int) – 确定唯一元素的轴（None 将展平数组或列表）
- tanh(**kwargs)#
围绕
numpy.tanh的惰性包装器
- to_string()#
转换为字符串，与 expression.astype(‘str’) 相同
- property transient#
如果此表达式不是瞬态的（例如在磁盘上），可以进行优化
- unique(dropna=False, dropnan=False, dropmissing=False, selection=None, axis=None, limit=None, limit_raise=True, array_type='list', progress=None, delay=False)[source]#
返回所有唯一值。
- Parameters:
dropna – 删除包含不可用（NA）值（NaN 或缺失值）的行。
dropnan – 删除包含NaN值的行
dropmissing – 删除包含缺失值的行
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
axis (bool) – 确定唯一元素的轴（None 将展平数组或列表）
limit (int) – 限制结果的数量
limit_raise (bool) – 当超过限制时，抛出
vaex.RowLimitException，或者最多返回 'limit' 数量的结果。array_type (bool) – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray” 用于 xarray.DataArray，或 “list”/“python” 用于 Python 列表
progress – 如果为True，则显示进度条，或者是一个可调用对象，该对象接受一个参数（一个介于0和1之间的浮点值）表示进度，当此可调用对象返回False时，计算将被取消
delay (bool) – 不返回结果，而是返回一个用于异步计算的代理（目前仅限内部使用）
- value_counts(dropna=False, dropnan=False, dropmissing=False, ascending=False, progress=False, axis=None, delay=False)[源代码]#
计算唯一值的计数。
- WARNING:
如果表达式/列不是分类的，它将被即时转换
dropna 默认为 False，在 pandas 中默认为 True
- Parameters:
- Returns:
包含计数的Pandas系列
- var(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.std(expression, …) 的快捷方式，参见 Dataset.var
- variables(ourself=False, expand_virtual=True, include_virtual=True)[source]#
返回此表达式依赖的一组变量。
示例：
>>> df = vaex.example() >>> r = np.sqrt(df.data.x**2 + df.data.y**2) >>> r.variables() {'x', 'y'}
- where(x, y, dtype=None)#
根据condition从x或y中按行返回值。
当您想根据某些条件创建时，这是一个有用的函数。 如果条件为真，则取x的值，否则取y的值。 考虑语法的一个简单方法是df.func.where(“if”, “then”, “else”)。 请参见下面的示例。
注意：如果该函数用作表达式的方法，则假定该表达式为条件。
- Parameters:
condition – 一个布尔表达式
x – 单个值或表达式，如果条件满足，则传递该值。
y – 单个值或表达式，如果条件不满足时传递的值。
dtype – 可选地指定结果表达式的数据类型
- Return type:
示例：
>>> import vaex >>> df = vaex.from_arrays(x=[0, 1, 2, 3]) >>> df['y'] = df.func.where(df.x >=2, df.x, -1) >>> df # x y 0 0 -1 1 1 -1 2 2 2 3 3 3
地理操作#
- class vaex.geo.DataFrameAccessorGeo(df)[source]#
基础类：
object几何/地理辅助方法
示例：
>>> df_xyz = df.geo.spherical2cartesian(df.longitude, df.latitude, df.distance) >>> df_xyz.x.mean()
- __weakref__#
对象的弱引用列表
- cartesian2spherical(x='x', y='y', z='z', alpha='l', delta='b', distance='distance', radians=False, center=None, center_name='solar_position', inplace=False)[来源]#
将笛卡尔坐标转换为球面坐标。
- Parameters:
x
y
z
alpha
delta – 极角名称，范围从-90到90（当弧度设置为True时，范围为-pi到pi）。
距离
弧度
中心
center_name
- Returns:
- cartesian_to_polar(x='x', y='y', radius_out='r_polar', azimuth_out='phi_polar', propagate_uncertainties=False, radians=False, inplace=False)[来源]#
将笛卡尔坐标转换为极坐标
- Parameters:
x – x的表达式
y – y的表达式
radius_out – 半径的虚拟列名称
azimuth_out – 方位角虚拟列的名称
propagate_uncertainties – {propagate_uncertainties}
radians – 如果为True，方位角以弧度表示，默认为度
- Returns:
- inside_polygon(y, px, py)#
测试由x和y定义的点是否在多边形px, py内
示例：
>>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(x=[1, 2, 3], y=[2, 3, 4]) >>> px = np.array([1.5, 2.5, 2.5, 1.5]) >>> py = np.array([2.5, 2.5, 3.5, 3.5]) >>> df['inside'] = df.geo.inside_polygon(df.x, df.y, px, py) >>> df # x y inside 0 1 2 False 1 2 3 True 2 3 4 False
- Parameters:
x – {expression_one}
y – {expression_one}
px – 多边形x坐标的列表
px – 多边形的y坐标列表
- Returns:
表达式，如果点在内部则为真，否则为假。
- inside_polygons(y, pxs, pys, any=True)#
测试由x和y定义的点是否在所有或任何多边形px、py内
示例：
>>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(x=[1, 2, 3], y=[2, 3, 4]) >>> px = np.array([1.5, 2.5, 2.5, 1.5]) >>> py = np.array([2.5, 2.5, 3.5, 3.5]) >>> df['inside'] = df.geo.inside_polygons(df.x, df.y, [px, px + 1], [py, py + 1], any=True) >>> df # x y inside 0 1 2 False 1 2 3 True 2 3 4 True
- Parameters:
x – {expression_one}
y – {expression_one}
pxs – N个ndarrays的列表，包含多边形的x坐标，N是多边形的数量
pxs – N个ndarrays的列表，包含多边形的y坐标
any – 如果在任何多边形或所有多边形中，则返回 true
- Returns:
表达式，如果点在内部则为真，否则为假。
- inside_which_polygon(y, pxs, pys)#
查找一个点位于哪个多边形（基于0的索引）
示例：
>>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(x=[1, 2, 3], y=[2, 3, 4]) >>> px = np.array([1.5, 2.5, 2.5, 1.5]) >>> py = np.array([2.5, 2.5, 3.5, 3.5]) >>> df['polygon_index'] = df.geo.inside_which_polygon(df.x, df.y, [px, px + 1], [py, py + 1]) >>> df # x y polygon_index 0 1 2 -- 1 2 3 0 2 3 4 1
- Parameters:
x – {expression_one}
y – {expression_one}
px – 包含多边形x坐标的N个ndarrays列表，N是多边形的数量
px – 包含多边形y坐标的N个ndarrays的列表
- Returns:
表达式，基于0的索引，表示点所属的多边形（或缺失/掩码值）
- inside_which_polygons(x, y, pxss, pyss=None, any=True)[source]#
查找点位于哪一组多边形中（基于0的索引）。
如果 any=True，它将是第一个匹配的多边形集合索引，如果 any=False，它将是匹配集合中所有多边形的第一个索引。
>>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(x=[1, 2, 3], y=[2, 3, 4]) >>> px = np.array([1.5, 2.5, 2.5, 1.5]) >>> py = np.array([2.5, 2.5, 3.5, 3.5]) >>> polygonA = [px, py] >>> polygonB = [px + 1, py + 1] >>> pxs = [[polygonA, polygonB], [polygonA]] >>> df['polygon_index'] = df.geo.inside_which_polygons(df.x, df.y, pxs, any=True) >>> df # x y polygon_index 0 1 2 -- 1 2 3 0 2 3 4 0 >>> df['polygon_index'] = df.geo.inside_which_polygons(df.x, df.y, pxs, any=False) >>> df # x y polygon_index 0 1 2 -- 1 2 3 1 2 3 4 --
- Parameters:
x – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
y – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
px – 包含多边形x坐标的N个ndarrays列表，N是多边形的数量
px – N个ndarrays的列表，包含多边形的y坐标，如果为None，则x数组的最后一个维度的ndarrays的形状应为2（即包含x和y坐标）
any – 测试点是否在任何多边形中（逻辑或），或在所有多边形中（逻辑与）
- Returns:
表达式，基于0的索引，表示点所属的多边形（或缺失/掩码值）
- project_aitoff(alpha, delta, x, y, radians=True, inplace=False)[来源]#
添加aitoff (https://en.wikipedia.org/wiki/Aitoff_projection) 投影
- Parameters:
alpha – 方位角
delta – 极角
x – x坐标的输出名称
y – y坐标的输出名称
radians – 输入和输出以弧度（True）或度（False）为单位
- Returns:
- project_gnomic(alpha, delta, alpha0=0, delta0=0, x='x', y='y', radians=False, postfix='', inplace=False)[来源]#
向DataFrame添加一个格诺米克投影
- rotation_2d(x, y, xnew, ynew, angle_degrees, propagate_uncertainties=False, inplace=False)[source]#
二维旋转。
- spherical2cartesian(alpha, delta, distance, xname='x', yname='y', zname='z', propagate_uncertainties=False, center=[0, 0, 0], radians=False, inplace=False)[source]#
将球面坐标转换为笛卡尔坐标。
- Parameters:
alpha
delta – 极角，范围从-90（南极）到90（北极）
distance – 径向距离，决定x、y和z的单位
xname
yname
zname
propagate_uncertainties – 如果为真，将为新的虚拟列传播误差，详情请参见
propagate_uncertainties()中心
弧度
- Returns:
新的数据框（如果inplace为False）包含新的x、y、z列
- velocity_cartesian2polar(x='x', y='y', vx='vx', radius_polar=None, vy='vy', vr_out='vr_polar', vazimuth_out='vphi_polar', propagate_uncertainties=False, inplace=False)[source]#
将笛卡尔速度转换为极坐标速度。
- Parameters:
x
y
vx
radius_polar – 半径的可选表达式，如果提供可能会带来更好的性能。
vy
vr_out
vazimuth_out
propagate_uncertainties – 如果为真，将为新的虚拟列传播误差，详情请参见
propagate_uncertainties()
- Returns:
- velocity_cartesian2spherical(x='x', y='y', z='z', vx='vx', vy='vy', vz='vz', vr='vr', vlong='vlong', vlat='vlat', distance=None, inplace=False)[source]#
将速度从笛卡尔坐标系转换为球面坐标系
待办：不确定性传播
- Parameters:
x – x列的名称（输入）
y – y
z – z
vx – vx
vy – vy
vz – vz
vr – r 方向径向速度的列名（输出）
vlong – 经度方向速度分量的列名（输出）
vlat – 纬度方向速度分量的列名，正值指向北极（输出）
distance – 距离的表达式，如果未给出，则默认为 sqrt(x**2+y**2+z**2)，但如果此列已存在，传递此表达式可能会带来更好的性能
- Returns:
- velocity_polar2cartesian(x='x', y='y', azimuth=None, vr='vr_polar', vazimuth='vphi_polar', vx_out='vx', vy_out='vy', propagate_uncertainties=False, inplace=False)[source]#
将圆柱极坐标速度转换为笛卡尔坐标。
- Parameters:
x
y
azimuth – 可选的方位角表达式，以度为单位，如果提供可能会带来更好的性能。
vr
vazimuth
vx_out
vy_out
propagate_uncertainties – 如果为真，将为新的虚拟列传播误差，详情请参见
propagate_uncertainties()
日志记录#
为vaex设置日志记录。
请参阅日志配置如何配置日志记录。
字符串操作#
- class vaex.expression.StringOperations(expression)[source]#
基础类：
object字符串操作。
通常使用例如 df.name.str.lower() 访问
- __weakref__#
对象的弱引用列表
- byte_length()#
返回字符串样本中的字节数。
- Returns:
一个表达式包含字符串列中每个样本的字节数。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.byte_length() Expression = str_byte_length(text) Length: 5 dtype: int64 (expression) ----------------------------------- 0 9 1 11 2 9 3 3 4 4
- capitalize()#
将字符串示例的首字母大写。
- Returns:
一个包含大写字符串的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.capitalize() Expression = str_capitalize(text) Length: 5 dtype: str (expression) --------------------------------- 0 Something 1 Very pretty 2 Is coming 3 Our 4 Way.
- cat(other)#
逐行连接两个字符串列。
- Parameters:
其他 (表达式) – 要连接的其他列的表达式。
- Returns:
一个包含连接列的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.cat(df.text) Expression = str_cat(text, text) Length: 5 dtype: str (expression) --------------------------------- 0 SomethingSomething 1 very prettyvery pretty 2 is comingis coming 3 ourour 4 way.way.
- center(width, fillchar=' ')#
用额外的字符填充字符串的左右两侧，使得样本总共有width个字符。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.center(width=11, fillchar='!') Expression = str_center(text, width=11, fillchar='!') Length: 5 dtype: str (expression) --------------------------------- 0 !Something! 1 very pretty 2 !is coming! 3 !!!!our!!!! 4 !!!!way.!!!
- contains(pattern, regex=True)#
检查字符串列样本中是否包含字符串模式或正则表达式。
- Parameters:
- Returns:
如果在一个给定的样本中找到了模式，则表达式评估为True，否则为False。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.contains('very') Expression = str_contains(text, 'very') Length: 5 dtype: bool (expression) ---------------------------------- 0 False 1 True 2 False 3 False 4 False
- count(pat, regex=False)#
计算字符串列样本中某个模式的出现次数。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.count(pat="et", regex=False) Expression = str_count(text, pat='et', regex=False) Length: 5 dtype: int64 (expression) ----------------------------------- 0 1 1 1 2 0 3 0 4 0
- endswith(pat)#
检查每个字符串样本的结尾是否与指定的模式匹配。
- Parameters:
pat (str) – 一个字符串模式或正则表达式
- Returns:
如果模式在给定样本的末尾找到，则表达式评估为True，否则为False。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.endswith(pat="ing") Expression = str_endswith(text, pat='ing') Length: 5 dtype: bool (expression) ---------------------------------- 0 True 1 False 2 True 3 False 4 False
- equals(y)#
测试字符串x和y是否相同
- Returns:
一个布尔表达式
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.equals(df.text) Expression = str_equals(text, text) Length: 5 dtype: bool (expression) ---------------------------------- 0 True 1 True 2 True 3 True 4 True
>>> df.text.str.equals('our') Expression = str_equals(text, 'our') Length: 5 dtype: bool (expression) ---------------------------------- 0 False 1 False 2 False 3 True 4 False
- extract_regex(pattern)#
使用Apache Arrow（Google RE2库）提取由正则表达式定义的子字符串。
- Parameters:
pattern (str) – 一个需要包含命名捕获组的正则表达式，例如对于正则表达式 ‘(?P
[ab])(?P d)’ 中的 ‘letter’ 和 ‘digit’。 - Returns:
一个包含结构体的表达式，其字段名称对应于捕获组标识符。
示例：
>>> import vaex >>> email = ["foo@bar.org", "bar@foo.org", "open@source.org", "invalid@address.com"] >>> df = vaex.from_arrays(email=email) >>> df # email 0 foo@bar.org 1 bar@foo.org 2 open@source.org 3 invalid@address.com
>>> pattern = "(?P<name>.*)@(?P<address>.*)\.org" >>> df.email.str.extract_regex(pattern=pattern) Expression = str_extract_regex(email, pattern='(?P<name>.*)@(?P<addres... Length: 4 dtype: struct<name: string, address: string> (expression) ------------------------------------------------------------------- 0 {'name': 'foo', 'address': 'bar'} 1 {'name': 'bar', 'address': 'foo'} 2 {'name': 'open', 'address': 'source'} 3 --
- find(sub, start=0, end=None)#
返回列中每个字符串中提供子字符串完全包含在样本中的最低索引。如果未找到子字符串，则返回-1。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.find(sub="et") Expression = str_find(text, sub='et') Length: 5 dtype: int64 (expression) ----------------------------------- 0 3 1 7 2 -1 3 -1 4 -1
- get(i)#
从字符串列的每个样本中提取指定位置的字符。 请注意，如果指定的位置超出字符串样本的边界，此方法返回‘’，而pandas返回nan。
- Parameters:
i (int) – 索引位置，用于提取字符。
- Returns:
包含提取字符的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.get(5) Expression = str_get(text, 5) Length: 5 dtype: str (expression) --------------------------------- 0 h 1 p 2 m 3 4
- index(sub, start=0, end=None)#
返回列中每个字符串中提供子字符串完全包含在样本中的最低索引。如果未找到子字符串，则返回-1。这与str.find相同。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.index(sub="et") Expression = str_find(text, sub='et') Length: 5 dtype: int64 (expression) ----------------------------------- 0 3 1 7 2 -1 3 -1 4 -1
- isalnum(ascii=False)#
检查字符串样本中的所有字符是否都是字母数字。
- Parameters:
ascii (bool) – 仅转换ascii字符（通常更快）。
- Returns:
如果样本仅包含字母数字字符，则表达式评估为True，否则为False。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.isalnum() Expression = str_isalnum(text) Length: 5 dtype: bool (expression) ---------------------------------- 0 True 1 False 2 False 3 True 4 False
- isalpha()#
检查字符串样本中的所有字符是否都是字母。
- Returns:
如果样本仅包含字母字符，则表达式评估为True，否则为False。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.isalpha() Expression = str_isalpha(text) Length: 5 dtype: bool (expression) ---------------------------------- 0 True 1 False 2 False 3 True 4 False
- isdigit()#
检查字符串样本中的所有字符是否都是数字。
- Returns:
如果样本仅包含数字，则表达式评估为True，否则为False。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', '6'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 6
>>> df.text.str.isdigit() Expression = str_isdigit(text) Length: 5 dtype: bool (expression) ---------------------------------- 0 False 1 False 2 False 3 False 4 True
- islower()#
检查字符串样本中的所有字符是否都是小写字符。
- Returns:
如果样本仅包含小写字符，则表达式评估为True，否则为False。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.islower() Expression = str_islower(text) Length: 5 dtype: bool (expression) ---------------------------------- 0 False 1 True 2 True 3 True 4 True
- isspace()#
检查字符串样本中的所有字符是否都是空格。
- Returns:
如果样本仅包含空白字符，则表达式评估为True，否则为False。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', ' ', ' '] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 4
>>> df.text.str.isspace() Expression = str_isspace(text) Length: 5 dtype: bool (expression) ---------------------------------- 0 False 1 False 2 False 3 True 4 True
- istitle(ascii=False)#
待办事项
- isupper()#
检查字符串样本中的所有字符是否都是小写字符。
- Returns:
如果样本仅包含小写字符，则表达式评估为True，否则为False。
示例：
>>> import vaex >>> text = ['SOMETHING', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 SOMETHING 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.isupper() Expression = str_isupper(text) Length: 5 dtype: bool (expression) ---------------------------------- 0 True 1 False 2 False 3 False 4 False
- join(sep)#
与find相同（与pandas的区别在于它不会引发ValueError）
- len()#
返回字符串样本的长度。
- Returns:
一个表达式包含字符串列中每个样本的长度。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.len() Expression = str_len(text) Length: 5 dtype: int64 (expression) ----------------------------------- 0 9 1 11 2 9 3 3 4 4
- ljust(width, fillchar=' ')#
用指定的字符填充字符串样本的右侧，使字符串右对齐。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.ljust(width=10, fillchar='!') Expression = str_ljust(text, width=10, fillchar='!') Length: 5 dtype: str (expression) --------------------------------- 0 Something! 1 very pretty 2 is coming! 3 our!!!!!!! 4 way.!!!!!!
- lower()#
将字符串样本转换为小写。
- Returns:
包含转换后字符串的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.lower() Expression = str_lower(text) Length: 5 dtype: str (expression) --------------------------------- 0 something 1 very pretty 2 is coming 3 our 4 way.
- lstrip(to_strip=None)#
从字符串样本中移除前导字符。
- Parameters:
to_strip (str) – 要删除的字符串
- Returns:
一个包含修改后的字符串列的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.lstrip(to_strip='very ') Expression = str_lstrip(text, to_strip='very ') Length: 5 dtype: str (expression) --------------------------------- 0 Something 1 pretty 2 is coming 3 our 4 way.
- match(pattern)#
检查字符串样本是否与给定的正则表达式匹配。
- Parameters:
pattern (str) – 一个字符串或正则表达式，用于匹配字符串样本。
- Returns:
如果找到匹配项，则表达式评估为True，否则为False。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.match(pattern='our') Expression = str_match(text, pattern='our') Length: 5 dtype: bool (expression) ---------------------------------- 0 False 1 False 2 False 3 True 4 False
- notequals(y)#
测试字符串x和y是否不相同
- Returns:
一个布尔表达式
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.notequals(df.text) Expression = str_notequals(text, text) Length: 5 dtype: bool (expression) ---------------------------------- 0 False 1 False 2 False 3 False 4 False
>>> df.text.str.notequals('our') Expression = str_notequals(text, 'our') Length: 5 dtype: bool (expression) ---------------------------------- 0 True 1 True 2 True 3 False 4 True
- pad(width, side='left', fillchar=' ')#
在给定列中填充字符串。
- Parameters:
- Returns:
包含填充字符串的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.pad(width=10, side='left', fillchar='!') Expression = str_pad(text, width=10, side='left', fillchar='!') Length: 5 dtype: str (expression) --------------------------------- 0 !Something 1 very pretty 2 !is coming 3 !!!!!!!our 4 !!!!!!way.
- repeat(repeats)#
复制列中的每个字符串。
- Parameters:
repeats (int) – 每个字符串样本要重复的次数。
- Returns:
包含重复字符串的表达式
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.repeat(3) Expression = str_repeat(text, 3) Length: 5 dtype: str (expression) --------------------------------- 0 SomethingSomethingSomething 1 very prettyvery prettyvery pretty 2 is comingis comingis coming 3 ourourour 4 way.way.way.
- replace(pat, repl, n=-1, flags=0, regex=False)#
用其他字符串替换列中的模式/正则表达式的出现。
- Parameters:
- Returns:
包含字符串替换的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.replace(pat='et', repl='__') Expression = str_replace(text, pat='et', repl='__') Length: 5 dtype: str (expression) --------------------------------- 0 Som__hing 1 very pr__ty 2 is coming 3 our 4 way.
- rfind(sub, start=0, end=None)#
返回列中每个字符串中提供子字符串完全包含在样本内的最高索引。如果未找到子字符串，则返回-1。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.rfind(sub="et") Expression = str_rfind(text, sub='et') Length: 5 dtype: int64 (expression) ----------------------------------- 0 3 1 7 2 -1 3 -1 4 -1
- rindex(sub, start=0, end=None)#
返回列中每个字符串中最高索引，其中提供的子字符串完全包含在样本中。如果未找到子字符串，则返回-1。与str.rfind相同。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.rindex(sub="et") Expression = str_rindex(text, sub='et') Length: 5 dtype: int64 (expression) ----------------------------------- 0 3 1 7 2 -1 3 -1 4 -1
- rjust(width, fillchar=' ')#
用指定的字符填充字符串样本的左侧，使字符串左对齐。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.rjust(width=10, fillchar='!') Expression = str_rjust(text, width=10, fillchar='!') Length: 5 dtype: str (expression) --------------------------------- 0 !Something 1 very pretty 2 !is coming 3 !!!!!!!our 4 !!!!!!way.
- rstrip(to_strip=None)#
从字符串示例中移除尾随字符。
- Parameters:
to_strip (str) – 要删除的字符串
- Returns:
一个包含修改后的字符串列的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.rstrip(to_strip='ing') Expression = str_rstrip(text, to_strip='ing') Length: 5 dtype: str (expression) --------------------------------- 0 Someth 1 very pretty 2 is com 3 our 4 way.
- slice(start=0, stop=None)#
从列中的每个字符串元素中切片子字符串。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.slice(start=2, stop=5) Expression = str_pandas_slice(text, start=2, stop=5) Length: 5 dtype: str (expression) --------------------------------- 0 met 1 ry 2 co 3 r 4 y.
- startswith(pat)#
检查字符串的开头是否匹配一个模式。
- Parameters:
pat (str) – 一个字符串模式。不支持正则表达式。
- Returns:
如果模式在字符串样本的开头找到，则评估为True的表达式，否则为False。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.startswith(pat='is') Expression = str_startswith(text, pat='is') Length: 5 dtype: bool (expression) ---------------------------------- 0 False 1 False 2 True 3 False 4 False
- strip(to_strip=None)#
移除前导和尾随字符。
去除列中每个字符串样本的空白（包括换行符），或从左右两侧去除一组指定的字符。
- Parameters:
to_strip (str) – 要移除的字符。所有字符的组合都将被移除。 如果为 None，则移除空白字符。
returns – 包含修改后的字符串样本的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.strip(to_strip='very') Expression = str_strip(text, to_strip='very') Length: 5 dtype: str (expression) --------------------------------- 0 Something 1 prett 2 is coming 3 ou 4 way.
- title()#
将所有字符串样本转换为标题格式。
- Returns:
包含转换后字符串的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.title() Expression = str_title(text) Length: 5 dtype: str (expression) --------------------------------- 0 Something 1 Very Pretty 2 Is Coming 3 Our 4 Way.
- upper(ascii=False)#
将列中的所有字符串转换为大写。
- Parameters:
ascii (bool) – 仅转换ascii字符（通常更快）。
- Returns:
包含转换后字符串的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.upper() Expression = str_upper(text) Length: 5 dtype: str (expression) --------------------------------- 0 SOMETHING 1 VERY PRETTY 2 IS COMING 3 OUR 4 WAY.
- zfill(width)#
通过在列中的字符串前添加“0”字符来填充字符串。
- Parameters:
width (int) – 结果字符串的最小长度。长度小于width的字符串将在前面补零。
- Returns:
包含修改后字符串的表达式。
示例：
>>> import vaex >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.'] >>> df = vaex.from_arrays(text=text) >>> df # text 0 Something 1 very pretty 2 is coming 3 our 4 way.
>>> df.text.str.zfill(width=12) Expression = str_zfill(text, width=12) Length: 5 dtype: str (expression) --------------------------------- 0 000Something 1 0very pretty 2 000is coming 3 000000000our 4 00000000way.
字符串 (pandas) 操作#
- class vaex.expression.StringOperationsPandas(expression)[source]#
基础类：
object使用Pandas Series进行字符串操作（速度较慢）
- __weakref__#
对象的弱引用列表
- byte_length(**kwargs)#
围绕pandas.Series.byte_length的封装
- capitalize(**kwargs)#
围绕pandas.Series.capitalize的封装
- cat(**kwargs)#
围绕pandas.Series.cat的封装
- center(**kwargs)#
围绕pandas.Series.center的包装器
- contains(**kwargs)#
围绕pandas.Series.contains的封装
- count(**kwargs)#
围绕pandas.Series.count的封装
- endswith(**kwargs)#
围绕pandas.Series.endswith的封装
- equals(**kwargs)#
围绕pandas.Series.equals的包装器
- extract_regex(**kwargs)#
围绕pandas.Series.extract_regex的封装
- find(**kwargs)#
围绕pandas.Series.find的封装
- get(**kwargs)#
围绕pandas.Series.get的包装器
- index(**kwargs)#
围绕pandas.Series.index的包装器
- isalnum(**kwargs)#
围绕pandas.Series.isalnum的封装
- isalpha(**kwargs)#
围绕pandas.Series.isalpha的封装
- isdigit(**kwargs)#
围绕pandas.Series.isdigit的封装
- islower(**kwargs)#
围绕pandas.Series.islower的封装
- isspace(**kwargs)#
围绕pandas.Series.isspace的封装
- istitle(**kwargs)#
围绕pandas.Series.istitle的包装器
- isupper(**kwargs)#
围绕pandas.Series.isupper的封装
- join(**kwargs)#
围绕pandas.Series.join的封装
- len(**kwargs)#
围绕pandas.Series.len的包装器
- ljust(**kwargs)#
围绕pandas.Series.ljust的封装
- lower(**kwargs)#
围绕pandas.Series.lower的封装
- lstrip(**kwargs)#
围绕pandas.Series.lstrip的封装
- match(**kwargs)#
围绕pandas.Series.match的封装
- notequals(**kwargs)#
围绕pandas.Series.notequals的包装器
- pad(**kwargs)#
围绕pandas.Series.pad的封装
- repeat(**kwargs)#
围绕pandas.Series.repeat的封装
- replace(**kwargs)#
围绕pandas.Series.replace的封装
- rfind(**kwargs)#
围绕pandas.Series.rfind的封装
- rindex(**kwargs)#
围绕pandas.Series.rindex的封装
- rjust(**kwargs)#
围绕pandas.Series.rjust的封装
- rsplit(**kwargs)#
围绕pandas.Series.rsplit的封装
- rstrip(**kwargs)#
围绕pandas.Series.rstrip的封装
- slice(**kwargs)#
围绕pandas.Series.slice的封装
- split(**kwargs)#
围绕pandas.Series.split的封装
- startswith(**kwargs)#
围绕pandas.Series.startswith的封装
- strip(**kwargs)#
围绕pandas.Series.strip的封装
- title(**kwargs)#
围绕pandas.Series.title的包装器
- upper(**kwargs)#
围绕pandas.Series.upper的封装
- zfill(**kwargs)#
围绕pandas.Series.zfill的封装
结构体（箭头）操作#
- class vaex.expression.StructOperations(expression)[source]#
基础类：
Mapping结构数组操作。
通常使用例如 df.name.struct.get(‘field1’) 访问
- __weakref__#
对象的弱引用列表
- property dtypes#
返回所有字段名称及其对应的类型。
- Returns:
一个pandas系列，其中键作为索引，类型作为值。
示例：
>>> import vaex >>> import pyarrow as pa >>> array = pa.StructArray.from_arrays(arrays=[[1,2], ["a", "b"]], names=["col1", "col2"]) >>> df = vaex.from_arrays(array=array) >>> df # array 0 {'col1': 1, 'col2': 'a'} 1 {'col1': 2, 'col2': 'b'}
>>> df.array.struct.dtypes col1 int64 col2 string dtype: object
- get(field)#
从结构数组中返回单个字段。你也可以使用简写符号 df.name[:, ‘field’]。
请注意，如果字段标签重复，则无法唯一标识字段。请使用基于索引位置的访问方式。要获取相应的字段索引，请使用{{idx: key for idx, key in enumerate(df.array.struct)}}。
- Parameters:
field ({str, int}) – 一个字符串（标签）或整数（索引位置），用于标识结构字段。
- Returns:
一个包含结构体字段的表达式。
示例：
>>> import vaex >>> import pyarrow as pa >>> array = pa.StructArray.from_arrays(arrays=[[1,2], ["a", "b"]], names=["col1", "col2"]) >>> df = vaex.from_arrays(array=array) >>> df # array 0 {'col1': 1, 'col2': 'a'} 1 {'col1': 2, 'col2': 'b'}
>>> df.array.struct.get("col1") Expression = struct_get(array, 'col1') Length: 2 dtype: int64 (expression) ----------------------------------- 0 1 1 2
>>> df.array.struct.get(0) Expression = struct_get(array, 0) Length: 2 dtype: int64 (expression) ----------------------------------- 0 1 1 2
>>> df.array[:, 'col1'] Expression = struct_get(array, 'col1') Length: 2 dtype: int64 (expression) ----------------------------------- 0 1 1 2
- items()[source]#
返回所有字段名称及其对应的vaex表达式。
- Returns:
包含字段名称和字段的元组列表，字段作为vaex表达式。
示例：
>>> import vaex >>> import pyarrow as pa >>> array = pa.StructArray.from_arrays(arrays=[[1,2], ["a", "b"]], names=["col1", "col2"]) >>> df = vaex.from_arrays(array=array) >>> df # array 0 {'col1': 1, 'col2': 'a'} 1 {'col1': 2, 'col2': 'b'}
>>> df.array.struct.items() [('col1', Expression = struct_get(array, 0) Length: 2 dtype: int64 (expression) ----------------------------------- 0 1 1 2), ('col2', Expression = struct_get(array, 1) Length: 2 dtype: string (expression) ------------------------------------ 0 a 1 b)]
- keys()[source]#
返回结构数组中包含的所有字段名称。
- Returns:
字段名称列表。
示例：
>>> import vaex >>> import pyarrow as pa >>> array = pa.StructArray.from_arrays(arrays=[[1,2], ["a", "b"]], names=["col1", "col2"]) >>> df = vaex.from_arrays(array=array) >>> df # array 0 {'col1': 1, 'col2': 'a'} 1 {'col1': 2, 'col2': 'b'}
>>> df.array.struct.keys() ["col1", "col2"]
- project(fields)#
将一个结构数组的一个或多个字段投影到一个新的结构数组。你也可以使用简写符号 df.name[:, [‘field1’, ‘field2’]]。
- Parameters:
field (list) – 一个字符串（标签）或整数（索引位置）的列表，用于标识一个或多个字段。
- Returns:
一个包含结构体数组的表达式。
示例：
>>> import vaex >>> import pyarrow as pa >>> array = pa.StructArray.from_arrays(arrays=[[1,2], ["a", "b"], [3, 4]], names=["col1", "col2", "col3"]) >>> df = vaex.from_arrays(array=array) >>> df # array 0 {'col1': 1, 'col2': 'a', 'col3': 3} 1 {'col1': 2, 'col2': 'b', 'col3': 4}
>>> df.array.struct.project(["col3", "col1"]) Expression = struct_project(array, ['col3', 'col1']) Length: 2 dtype: struct<col3: int64, col1: int64> (expression) -------------------------------------------------------------- 0 {'col3': 3, 'col1': 1} 1 {'col3': 4, 'col1': 2}
>>> df.array.struct.project([2, 0]) Expression = struct_project(array, [2, 0]) Length: 2 dtype: struct<col3: int64, col1: int64> (expression) -------------------------------------------------------------- 0 {'col3': 3, 'col1': 1} 1 {'col3': 4, 'col1': 2}
>>> df.array[:, ["col3", "col1"]] Expression = struct_project(array, ['col3', 'col1']) Length: 2 dtype: struct<col3: int64, col1: int64> (expression) -------------------------------------------------------------- 0 {'col3': 3, 'col1': 1} 1 {'col3': 4, 'col1': 2}
- values()[source]#
返回所有字段作为vaex表达式。
- Returns:
对应于结构体中每个字段的vaex表达式列表。
示例：
>>> import vaex >>> import pyarrow as pa >>> array = pa.StructArray.from_arrays(arrays=[[1,2], ["a", "b"]], names=["col1", "col2"]) >>> df = vaex.from_arrays(array=array) >>> df # array 0 {'col1': 1, 'col2': 'a'} 1 {'col1': 2, 'col2': 'b'}
>>> df.array.struct.values() [Expression = struct_get(array, 0) Length: 2 dtype: int64 (expression) ----------------------------------- 0 1 1 2, Expression = struct_get(array, 1) Length: 2 dtype: string (expression) ------------------------------------ 0 a 1 b]
时间差操作#
- class vaex.expression.TimeDelta(expression)[源代码]#
基础类：
object时间差操作
通常使用例如 df.delay.td.days 访问
- __weakref__#
对象的弱引用列表
- property days#
每个时间差样本中的天数。
- Returns:
一个包含时间差样本中天数的表达式。
示例：
>>> import vaex >>> import numpy as np >>> delta = np.array([17658720110, 11047049384039, 40712636304958, -18161254954], dtype='timedelta64[s]') >>> df = vaex.from_arrays(delta=delta) >>> df # delta 0 204 days +9:12:00 1 1 days +6:41:10 2 471 days +5:03:56 3 -22 days +23:31:15
>>> df.delta.td.days Expression = td_days(delta) Length: 4 dtype: int64 (expression) ----------------------------------- 0 204 1 1 2 471 3 -22
- property microseconds#
每个timedelta样本中的微秒数（大于等于0且小于1秒）。
- Returns:
一个表达式，包含timedelta样本中的微秒数。
示例：
>>> import vaex >>> import numpy as np >>> delta = np.array([17658720110, 11047049384039, 40712636304958, -18161254954], dtype='timedelta64[s]') >>> df = vaex.from_arrays(delta=delta) >>> df # delta 0 204 days +9:12:00 1 1 days +6:41:10 2 471 days +5:03:56 3 -22 days +23:31:15
>>> df.delta.td.microseconds Expression = td_microseconds(delta) Length: 4 dtype: int64 (expression) ----------------------------------- 0 290448 1 978582 2 19583 3 709551
- property nanoseconds#
每个timedelta样本中的纳秒数（大于等于0且小于1微秒）。
- Returns:
一个表达式，包含timedelta样本中的纳秒数。
示例：
>>> import vaex >>> import numpy as np >>> delta = np.array([17658720110, 11047049384039, 40712636304958, -18161254954], dtype='timedelta64[s]') >>> df = vaex.from_arrays(delta=delta) >>> df # delta 0 204 days +9:12:00 1 1 days +6:41:10 2 471 days +5:03:56 3 -22 days +23:31:15
>>> df.delta.td.nanoseconds Expression = td_nanoseconds(delta) Length: 4 dtype: int64 (expression) ----------------------------------- 0 384 1 16 2 488 3 616
- property seconds#
每个时间差样本中的秒数（大于等于0且小于1天）。
- Returns:
一个包含timedelta样本中秒数的表达式。
示例：
>>> import vaex >>> import numpy as np >>> delta = np.array([17658720110, 11047049384039, 40712636304958, -18161254954], dtype='timedelta64[s]') >>> df = vaex.from_arrays(delta=delta) >>> df # delta 0 204 days +9:12:00 1 1 days +6:41:10 2 471 days +5:03:56 3 -22 days +23:31:15
>>> df.delta.td.seconds Expression = td_seconds(delta) Length: 4 dtype: int64 (expression) ----------------------------------- 0 30436 1 39086 2 28681 3 23519
- total_seconds()#
每个timedelta样本的总持续时间以秒表示。
- Returns:
一个表达式，包含timedelta样本中的总秒数。
示例：
>>> import vaex >>> import numpy as np >>> delta = np.array([17658720110, 11047049384039, 40712636304958, -18161254954], dtype='timedelta64[s]') >>> df = vaex.from_arrays(delta=delta) >>> df # delta 0 204 days +9:12:00 1 1 days +6:41:10 2 471 days +5:03:56 3 -22 days +23:31:15
>>> df.delta.td.total_seconds() Expression = td_total_seconds(delta) Length: 4 dtype: float64 (expression) ------------------------------------- 0 -7.88024e+08 1 -2.55032e+09 2 6.72134e+08 3 2.85489e+08
vaex-graphql#
vaex-jupyter#
- class vaex.jupyter.DataFrameAccessorWidget(df)[source]#
基础类：
object- __weakref__#
对象的弱引用列表
- data_array(axes=[], selection=None, shared=False, display_function=<function display>, **kwargs)[来源]#
创建一个
vaex.jupyter.model.DataArray()模型和一个vaex.jupyter.view.DataArray()小部件，并将它们链接起来。这是一个方便的方法来创建模型和视图，并将它们连接起来。
- expression(value=None, label='Custom expression')[source]#
创建一个用于编辑vaex表达式的小部件。
如果值是一个
vaex.jupyter.model.Axis对象，它的表达式将与小部件（双向）链接。- Parameters:
value – 有效的表达式（字符串或表达式对象），或轴
- vaex.jupyter.debounced(delay_seconds=0.5, skip_gather=False, on_error=None, reentrant=True)[source]#
一个装饰器，用于将多个方法/函数调用合并为一次调用。
注意：这仅在异步环境中有效，例如Jupyter笔记本环境。在此环境之外，调用
flush()将执行挂起的调用。
- vaex.jupyter.flush(recursive_counts=-1, ignore_exceptions=False, all=False)[源代码]#
运行所有未执行的防抖函数。
如果防抖调用的执行导致新调用的调度，它们将被递归执行，最多递归调用 recursive_counts 次。recursive_counts=-1 表示无限递归。
vaex.jupyter.model#
- class vaex.jupyter.model.Axis(*, bin_centers=None, df, exception=None, expression=None, max=None, min=None, shape=None, shape_default=64, slice=None, status=Status.NO_LIMITS, **kwargs)[source]#
基础类：
_HasState- class Status(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]#
基础类：
Enum状态转换 NO_LIMITS -> STAGED_CALCULATING_LIMITS -> CALCULATING_LIMITS -> CALCULATED_LIMITS -> READY
- when expression changes:
- STAGED_CALCULATING_LIMITS:
calculation.cancel() ->NO_LIMITS
- CALCULATING_LIMITS:
calculation.cancel() ->NO_LIMITS
- when min/max changes:
- STAGED_CALCULATING_LIMITS:
calculation.cancel() ->NO_LIMITS
- CALCULATING_LIMITS:
calculation.cancel() ->NO_LIMITS
- ABORTED = 7#
- CALCULATED_LIMITS = 4#
- CALCULATING_LIMITS = 3#
- EXCEPTION = 6#
- NO_LIMITS = 1#
- READY = 5#
- STAGED_CALCULATING_LIMITS = 2#
- bin_centers#
一个允许任何值的特性。
- df#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
- exception#
一个允许任何值的特性。
- expression#
- property has_missing_limit#
- max#
浮点数特性的转换版本。
- min#
浮点数特性的转换版本。
- on_change_limits#
- shape#
int trait 的转换版本。
- shape_default#
int trait 的转换版本。
- slice#
int trait 的转换版本。
- status#
使用枚举类作为数据类型描述的模型。 请注意，如果没有提供默认值，则使用第一个枚举值作为默认值。
# -- SINCE: Python 3.4 (or install backport: pip install enum34) import enum from traitlets import HasTraits, UseEnum class Color(enum.Enum): red = 1 # -- IMPLICIT: default_value blue = 2 green = 3 class MyEntity(HasTraits): color = UseEnum(Color, default_value=Color.blue) entity = MyEntity(color=Color.red) entity.color = Color.green # USE: Enum-value (preferred) entity.color = "green" # USE: name (as string) entity.color = "Color.green" # USE: scoped-name (as string) entity.color = 3 # USE: number (as int) assert entity.color is Color.green
- class vaex.jupyter.model.DataArray(*, axes, df, exception=None, grid, grid_sliced, selection=None, shape=64, status=Status.MISSING_LIMITS, status_text='Initializing', **kwargs)[source]#
基础类：
_HasState- class Status(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]#
基础类：
Enum- CALCULATED_GRID = 9#
- CALCULATED_LIMITS = 5#
- CALCULATING_GRID = 8#
- CALCULATING_LIMITS = 4#
- EXCEPTION = 11#
- MISSING_LIMITS = 1#
- NEEDS_CALCULATING_GRID = 6#
- READY = 10#
- STAGED_CALCULATING_GRID = 7#
- STAGED_CALCULATING_LIMITS = 3#
- axes#
一个Python列表的实例。
- df#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
- exception#
一个允许任何值的特性。
- grid#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
- grid_sliced#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
- property has_missing_limits#
- selection#
一个允许任何值的特性。
- shape#
int trait 的转换版本。
- status#
使用枚举类作为数据类型描述的模型。 请注意，如果没有提供默认值，则使用第一个枚举值作为默认值。
# -- SINCE: Python 3.4 (or install backport: pip install enum34) import enum from traitlets import HasTraits, UseEnum class Color(enum.Enum): red = 1 # -- IMPLICIT: default_value blue = 2 green = 3 class MyEntity(HasTraits): color = UseEnum(Color, default_value=Color.blue) entity = MyEntity(color=Color.red) entity.color = Color.green # USE: Enum-value (preferred) entity.color = "green" # USE: name (as string) entity.color = "Color.green" # USE: scoped-name (as string) entity.color = 3 # USE: number (as int) assert entity.color is Color.green
- status_text#
用于Unicode字符串的特性。
- class vaex.jupyter.model.GridCalculator(**kwargs: Any)[source]#
基础类：
_HasState网格负责调度网格计算和可能的切片
- class Status(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]#
基础类：
Enum- CALCULATING = 4#
- READY = 9#
- STAGED_CALCULATION = 3#
- VOID = 1#
- df#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
- models#
一个Python列表的实例。
- status#
使用枚举类作为数据类型描述的模型。 请注意，如果没有提供默认值，则使用第一个枚举值作为默认值。
# -- SINCE: Python 3.4 (or install backport: pip install enum34) import enum from traitlets import HasTraits, UseEnum class Color(enum.Enum): red = 1 # -- IMPLICIT: default_value blue = 2 green = 3 class MyEntity(HasTraits): color = UseEnum(Color, default_value=Color.blue) entity = MyEntity(color=Color.red) entity.color = Color.green # USE: Enum-value (preferred) entity.color = "green" # USE: name (as string) entity.color = "Color.green" # USE: scoped-name (as string) entity.color = 3 # USE: number (as int) assert entity.color is Color.green
- class vaex.jupyter.model.Heatmap(*, axes, df, exception=None, grid, grid_sliced, selection=None, shape=64, status=Status.MISSING_LIMITS, status_text='Initializing', **kwargs)[source]#
基础类:
DataArray- x#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
- y#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
vaex.jupyter.view#
- class vaex.jupyter.view.DataArray(**kwargs: Any)[source]#
基础类:
ViewBase将以交互方式显示一个DataArray，并带有可选的自定义display_function。
默认情况下，它将简单地显示(…) DataArray，使用xarray的默认显示机制。
公共构造函数
- clear_output#
每次数据变化时清除输出
- display_function#
一个允许任何值的特性。
- matplotlib_autoshow#
如果存在打开的图形句柄，将在输出上下文中调用 plt.show()
- model#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
- numpy_errstate#
默认的numpy错误状态在显示时避免显示错误消息，请参阅
numpy.errstate
- class vaex.jupyter.view.Heatmap(**kwargs: Any)[source]#
基础类:
ViewBase公共构造函数
- TOOLS_SUPPORTED = ['pan-zoom', 'select-rect', 'select-x']#
- blend#
用于Unicode字符串的特性。
- colormap#
用于Unicode字符串的特性。
- dimension_alternative#
用于Unicode字符串的特性。
- dimension_facets#
用于Unicode字符串的特性。
- dimension_fade#
用于Unicode字符串的特性。
- model#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
- normalize#
一个布尔值（True, False）特性。
- supports_normalize = False#
- supports_transforms = True#
- tool#
用于Unicode字符串的特性。
- transform#
用于Unicode字符串的特性。
- class vaex.jupyter.view.Histogram(**kwargs: Any)[source]#
基础类:
ViewBase公共构造函数
- TOOLS_SUPPORTED = ['pan-zoom', 'select-x']#
- dimension_facets#
用于Unicode字符串的特性。
- dimension_groups#
用于Unicode字符串的特性。
- dimension_overplot#
用于Unicode字符串的特性。
- model#
一个特质，其值必须是特定类的实例。
该值也可以是指定类子类的实例。
子类可以通过覆盖klass属性来声明默认类
- normalize#
一个布尔值（True, False）特性。
- supports_normalize = True#
- supports_transforms = False#
- transform#
用于Unicode字符串的特性。
- class vaex.jupyter.view.PieChart(**kwargs: Any)[source]#
基础类：
Histogram公共构造函数
- radius_split_fraction = 0.8#
vaex.jupyter.widgets#
- class vaex.jupyter.widgets.ColumnExpressionAdder(**kwargs: Any)[source]#
基础类:
ColumnPicker公共构造函数
- component#
一个允许任何值的特性。
- target#
用于Unicode字符串的特性。
- class vaex.jupyter.widgets.ColumnList(**kwargs: Any)[源代码]#
基础类：
VuetifyTemplate,ColumnsMixin公共构造函数
- column_filter#
用于Unicode字符串的特性。
- dialog_open#
一个布尔值（True, False）特性。
- editor#
一个允许任何值的特性。
- editor_open#
一个布尔值（True, False）特性。
- template#
用于Unicode字符串的特性。
- tooltip#
用于Unicode字符串的特性。
- valid_expression#
一个布尔值（True, False）特性。
- class vaex.jupyter.widgets.ColumnPicker(**kwargs: Any)[source]#
基础类：
VuetifyTemplate,ColumnsMixin公共构造函数
- label#
用于Unicode字符串的特性。
- template#
用于Unicode字符串的特性。
- value#
- class vaex.jupyter.widgets.ColumnSelectionAdder(**kwargs: Any)[source]#
基础类：
ColumnPicker公共构造函数
- component#
一个允许任何值的特性。
- target#
用于Unicode字符串的特性。
- class vaex.jupyter.widgets.ContainerCard(**kwargs: Any)[source]#
基础类：
VuetifyTemplate公共构造函数
- card_props#
Python字典的一个实例。
可以将一个或多个特性传递给构造函数 以验证字典的键和/或值。 如果您需要更详细的验证， 您可以使用自定义验证器方法。
在版本5.0中更改：添加了用于验证字典键的key_trait。
在版本5.0中更改：弃用了不明确的
trait，traits参数，改为使用value_trait，per_key_traits。
- controls#
一个Python列表的实例。
- main#
一个允许任何值的特性。
- main_props#
一个Python字典的实例。
可以将一个或多个特性传递给构造函数以验证字典的键和/或值。如果需要更详细的验证，可以使用自定义验证方法。
在版本5.0中更改：添加了用于验证字典键的key_trait。
在版本5.0中更改：弃用了不明确的
trait和traits参数，改用value_trait和per_key_traits。
- show_controls#
一个布尔值（True, False）特性。
- subtitle#
用于Unicode字符串的特性。
- text#
用于Unicode字符串的特性。
- title#
用于Unicode字符串的特性。
- class vaex.jupyter.widgets.Counter(**kwargs: Any)[source]#
基础类：
VuetifyTemplate公共构造函数
- characters#
一个Python列表的实例。
- format#
用于Unicode字符串的特性。
- postfix#
用于Unicode字符串的特性。
- prefix#
用于Unicode字符串的特性。
- template#
用于Unicode字符串的特性。
- value#
一个整数特性。
- class vaex.jupyter.widgets.Expression(**kwargs: Any)[source]#
基础类：
TextField公共构造函数
- df#
一个允许任何值的特性。
- valid#
一个布尔值（True, False）特性。
- value#
- class vaex.jupyter.widgets.ExpressionSelectionTextArea(**kwargs: Any)[源代码]#
基础类：
Expression公共构造函数
- selection_name#
一个允许任何值的特性。
- update_custom_selection#
- vaex.jupyter.widgets.ExpressionTextArea#
Expression的别名
- class vaex.jupyter.widgets.PlotTemplate(**kwargs: Any)[source]#
基础类：
VuetifyTemplate公共构造函数
- button_text#
用于Unicode字符串的特性。
- clipped#
一个布尔值（True, False）特性。
- components#
一个Python字典的实例。
可以将一个或多个特性传递给构造函数以验证字典的键和/或值。如果需要更详细的验证，可以使用自定义验证方法。
在版本5.0中更改：添加了用于验证字典键的key_trait。
在版本5.0中更改：弃用了不明确的
trait和traits参数，改用value_trait和per_key_traits。
- dark#
一个布尔值（True, False）特性。
- drawer#
一个布尔值（True, False）特性。
- drawers#
一个允许任何值的特性。
- floating#
一个布尔值（True, False）特性。
- items#
一个Python列表的实例。
- mini#
一个布尔值（True, False）特性。
- model#
一个允许任何值的特性。
- new_output#
一个布尔值（True, False）特性。
- show_output#
一个布尔值（True, False）特性。
- template#
用于Unicode字符串的特性。
- title#
用于Unicode字符串的特性。
- type#
用于Unicode字符串的特性。
- class vaex.jupyter.widgets.ProgressCircularNoAnimation(**kwargs: Any)[source]#
基础类：
VuetifyTemplate避免动画的v-progress-circular
公共构造函数
- color#
用于Unicode字符串的特性。
一个布尔值（True, False）特性。
- parts#
一个Python列表的实例。
- size#
一个整数特性。
- template#
用于Unicode字符串的特性。
- text#
用于Unicode字符串的特性。
- value#
一个浮点数特性。
- width#
一个整数特性。
- class vaex.jupyter.widgets.Selection(**kwargs: Any)[source]#
基础类：
VuetifyTemplate公共构造函数
- df#
一个允许任何值的特性。
- name#
用于Unicode字符串的特性。
- value#
用于Unicode字符串的特性。
- class vaex.jupyter.widgets.SelectionEditor(**kwargs: Any)[源代码]#
基础类：
VuetifyTemplate公共构造函数
- adder#
一个允许任何值的特性。
- components#
一个Python字典的实例。
可以将一个或多个特性传递给构造函数以验证字典的键和/或值。如果需要更详细的验证，可以使用自定义验证方法。
在版本5.0中更改：添加了用于验证字典键的key_trait。
在版本5.0中更改：弃用了不明确的
trait和traits参数，改用value_trait和per_key_traits。
- df#
一个允许任何值的特性。
- input#
一个允许任何值的特性。
- on_close#
一个允许任何值的特性。
- template#
用于Unicode字符串的特性。
- class vaex.jupyter.widgets.SelectionToggleList(**kwargs: Any)[source]#
基础类：
VuetifyTemplate公共构造函数
- df#
一个允许任何值的特性。
- selection_names#
一个Python列表的实例。
- title#
用于Unicode字符串的特性。
- value#
一个Python列表的实例。
- class vaex.jupyter.widgets.SettingsEditor(**kwargs: Any)[源代码]#
基础类：
VuetifyTemplate公共构造函数
- schema#
一个Python字典的实例。
可以将一个或多个特性传递给构造函数以验证字典的键和/或值。如果需要更详细的验证，可以使用自定义验证方法。
在版本5.0中更改：添加了用于验证字典键的key_trait。
在版本5.0中更改：弃用了不明确的
trait和traits参数，改用value_trait和per_key_traits。
- template_file = '/home/docs/checkouts/readthedocs.org/user_builds/vaex/envs/latest/lib/python3.12/site-packages/vaex/jupyter/vue/vjsf.vue'#
- valid#
一个布尔值（True, False）特性。
- values#
一个Python字典的实例。
可以将一个或多个特性传递给构造函数以验证字典的键和/或值。如果需要更详细的验证，可以使用自定义验证方法。
在版本5.0中更改：添加了用于验证字典键的key_trait。
在版本5.0中更改：弃用了不明确的
trait和traits参数，改用value_trait和per_key_traits。
- vjsf_loaded#
一个布尔值（True, False）特性。
- class vaex.jupyter.widgets.Status(**kwargs: Any)[source]#
基础类：
VuetifyTemplate公共构造函数
- template#
用于Unicode字符串的特性。
- value#
用于Unicode字符串的特性。
- class vaex.jupyter.widgets.ToolsSpeedDial(**kwargs: Any)[source]#
基础类：
VuetifyTemplate公共构造函数
- children#
一个Python列表的实例。
- expand#
一个布尔值（True, False）特性。
- items#
一个允许任何值的特性。
- template#
用于Unicode字符串的特性。
- value#
用于Unicode字符串的特性。
- class vaex.jupyter.widgets.ToolsToolbar(**kwargs: Any)[source]#
基础类：
VuetifyTemplate公共构造函数
- interact_items#
一个允许任何值的特性。
- interact_value#
用于Unicode字符串的特性。
- normalize#
一个布尔值（True, False）特性。
- selection_mode#
用于Unicode字符串的特性。
- selection_mode_items#
一个允许任何值的特性。
- supports_normalize#
一个布尔值（True, False）特性。
- supports_transforms#
一个布尔值（True, False）特性。
- transform_items#
一个Python列表的实例。
- transform_value#
用于Unicode字符串的特性。
- z_normalize#
一个布尔值（True, False）特性。
- class vaex.jupyter.widgets.VirtualColumnEditor(**kwargs: Any)[source]#
基础类：
VuetifyTemplate公共构造函数
- adder#
一个允许任何值的特性。
- column_name#
用于Unicode字符串的特性。
- components#
一个Python字典的实例。
可以将一个或多个特性传递给构造函数以验证字典的键和/或值。如果需要更详细的验证，可以使用自定义验证方法。
在版本5.0中更改：添加了用于验证字典键的key_trait。
在版本5.0中更改：弃用了不明确的
trait和traits参数，改用value_trait和per_key_traits。
- df#
一个允许任何值的特性。
- editor#
一个允许任何值的特性。
- on_close#
一个允许任何值的特性。
- template#
用于Unicode字符串的特性。
vaex-ml#
变换器与编码器#
|
通过各自样本的频率对分类列进行编码。 |
|
使用0到num_classes-1之间的整数值对分类列进行编码。 |
|
通过其最大绝对值缩放特征。 |
|
将一组特征缩放到给定范围。 |
|
根据One-Hot方案对分类列进行编码。 |
|
根据二进制多热方案对分类列进行编码。 |
|
使用主成分分析转换一组特征。 |
|
RobustScaler 移除中位数并根据给定的百分位范围缩放数据。 |
|
通过移除均值并将特征缩放到单位方差来标准化特征。 |
|
一种用于转换周期性特征（例如角度、时间）的策略。 |
|
使用贝叶斯目标编码器对分类变量进行编码。 |
|
使用证据权重编码器对分类变量进行编码。 |
|
将连续特征分箱为离散的区间。 |
|
GroupByTransformer 通过 groupby 操作创建聚合，这些聚合会与 DataFrame 进行连接。 |
- class vaex.ml.transformations.FrequencyEncoder(**kwargs: Any)[source]#
基础类：
Transformer根据各自样本的频率对分类列进行编码。
示例：
>>> import vaex >>> df = vaex.from_arrays(color=['red', 'green', 'green', 'blue', 'red', 'green']) >>> df # color 0 red 1 green 2 green 3 blue 4 red >>> encoder = vaex.ml.FrequencyEncoder(features=['color']) >>> encoder.fit_transform(df) # color frequency_encoded_color 0 red 0.333333 1 green 0.5 2 green 0.5 3 blue 0.166667 4 red 0.333333 5 green 0.5
- Parameters:
features – 要转换的特征列表。
prefix – 转换后特征名称的前缀。
unseen – 处理未见值的策略。
- prefix#
转换后特征名称的前缀。
- transform(df)[source]#
使用已拟合的FrequencyEncoder转换DataFrame。
- Parameters:
df – 一个 vaex 数据框。
- Returns:
包含编码的DataFrame的浅拷贝。
- Return type:
- unseen#
处理未见值的策略。
- class vaex.ml.transformations.LabelEncoder(**kwargs: Any)[source]#
基础类：
Transformer将分类列编码为0到num_classes-1之间的整数值。
示例：
>>> import vaex >>> df = vaex.from_arrays(color=['red', 'green', 'green', 'blue', 'red']) >>> df # color 0 red 1 green 2 green 3 blue 4 red >>> encoder = vaex.ml.LabelEncoder(features=['color']) >>> encoder.fit_transform(df) # color label_encoded_color 0 red 2 1 green 1 2 green 1 3 blue 0 4 red 2
- Parameters:
allow_unseen – 如果为True，未看到的值将被编码为-1，否则会引发错误
features – 要转换的特征列表。
prefix – 转换后特征名称的前缀。
- allow_unseen#
如果为True，未看到的值将被编码为-1，否则将引发错误
- labels_#
每个特征的编码标签。
- prefix#
转换后特征名称的前缀。
- class vaex.ml.transformations.MaxAbsScaler(**kwargs: Any)[source]#
基础类：
Transformer通过它们的最大绝对值来缩放特征。
示例：
>>> import vaex >>> df = vaex.from_arrays(x=[2,5,7,2,15], y=[-2,3,0,0,10]) >>> df # x y 0 2 -2 1 5 3 2 7 0 3 2 0 4 15 10 >>> scaler = vaex.ml.MaxAbsScaler(features=['x', 'y']) >>> scaler.fit_transform(df) # x y absmax_scaled_x absmax_scaled_y 0 2 -2 0.133333 -0.2 1 5 3 0.333333 0.3 2 7 0 0.466667 0 3 2 0 0.133333 0 4 15 10 1 1
- Parameters:
features – 要转换的特征列表。
prefix – 转换后特征名称的前缀。
- absmax_#
特征的最大绝对值。
- prefix#
转换后特征名称的前缀。
- class vaex.ml.transformations.MinMaxScaler(**kwargs: Any)[source]#
基础类：
Transformer将一组特征缩放到给定范围。
示例：
>>> import vaex >>> df = vaex.from_arrays(x=[2,5,7,2,15], y=[-2,3,0,0,10]) >>> df # x y 0 2 -2 1 5 3 2 7 0 3 2 0 4 15 10 >>> scaler = vaex.ml.MinMaxScaler(features=['x', 'y']) >>> scaler.fit_transform(df) # x y minmax_scaled_x minmax_scaled_y 0 2 -2 0 0 1 5 3 0.230769 0.416667 2 7 0 0.384615 0.166667 3 2 0 0 0.166667 4 15 10 1 1
- Parameters:
feature_range – 特征被缩放到的范围。
features – 要转换的特征列表。
prefix – 转换后特征名称的前缀。
- feature_range#
特征被缩放到的范围。
- fmax_#
特征的最小值。
- fmin_#
特征的最大值。
- prefix#
转换后特征名称的前缀。
- class vaex.ml.transformations.OneHotEncoder(**kwargs: Any)[source]#
基础类：
Transformer根据One-Hot方案对分类列进行编码。
示例：
>>> import vaex >>> df = vaex.from_arrays(color=['red', 'green', 'green', 'blue', 'red']) >>> df # color® 0 red 1 green 2 green 3 blue 4 red >>> encoder = vaex.ml.OneHotEncoder(features=['color']) >>> encoder.fit_transform(df) # color color_blue color_green color_red 0 red 0 0 1 1 green 0 1 0 2 green 0 1 0 3 blue 1 0 0 4 red 0 0 1
- Parameters:
features – 要转换的特征列表。
one – 当类别存在时要编码的值。
prefix – 转换后特征名称的前缀。
zero – 当类别不存在时的编码值。
- one#
当存在类别时要编码的值。
- prefix#
转换后特征名称的前缀。
- transform(df)[source]#
使用已拟合的OneHotEncoder转换DataFrame。
- Parameters:
df – 一个 vaex 数据框。
- Returns:
包含编码的DataFrame的浅拷贝。
- Return type:
- uniques_#
每个特征中找到的唯一元素。
- zero#
当类别不存在时要编码的值。
- class vaex.ml.transformations.MultiHotEncoder(**kwargs: Any)[source]#
基础类：
Transformer根据二进制多热方案对分类列进行编码。
使用多热编码器（有时称为二进制编码器），分类变量首先进行序数编码，然后将这些编码转换为二进制数。该二进制数的每一位都是一个单独的列，包含“0”或“1”。这可以被视为对独热编码器的改进，因为它防止在分类列的基数较高时生成过多的新列，同时有效地消除了序数编码器会引入的序数性。
示例：
>>> import vaex >>> import vaex.ml >>> df = vaex.from_arrays(color=['red', 'green', 'green', 'blue', 'red']) >>> df # color 0 red 1 green 2 green 3 blue 4 red >>> encoder = vaex.ml.MultiHotEncoder(features=['color']) >>> encoder.fit_transform(df) # color color_0 color_1 color_2 0 red 0 1 1 1 green 0 1 0 2 green 0 1 0 3 blue 0 0 1 4 red 0 1 1
- Parameters:
features – 要转换的特征列表。
prefix – 转换后特征名称的前缀。
- labels_#
每个特征的序数编码标签。
- prefix#
转换后特征名称的前缀。
- class vaex.ml.transformations.PCA(**kwargs: Any)[source]#
基础类：
Transformer使用主成分分析转换一组特征。
示例：
>>> import vaex >>> import vaex.ml >>> df = vaex.from_arrays(x=[2,5,7,2,15], y=[-2,3,0,0,10]) >>> df # x y 0 2 -2 1 5 3 2 7 0 3 2 0 4 15 10 >>> pca = vaex.ml.PCA(n_components=2, features=['x', 'y']) >>> pca.fit_transform(df) # x y PCA_0 PCA_1 0 2 -2 5.92532 0.413011 1 5 3 0.380494 -1.39112 2 7 0 0.840049 2.18502 3 2 0 4.61287 -1.09612 4 15 10 -11.7587 -0.110794
- Parameters:
features – 要转换的特征列表。
n_components – 要保留的组件数量。如果为None，则保留所有组件。
prefix – 转换后特征名称的前缀。
whiten – 如果为True，执行白化处理，即去除转换后组件的相对方差比例。
- eigen_values_#
对应于每个特征的特征值。
- eigen_vectors_#
每个特征对应的特征向量
- explained_variance_#
每个组件解释的方差。与特征值相同。
- explained_variance_ratio_#
由每个选定组件解释的方差百分比。
- fit(df, progress=None)[source]#
将PCA模型拟合到DataFrame。
- Parameters:
df – 一个 vaex 数据框。
progress – 如果为True或'widget'，则显示拟合过程的进度条。
- means_#
每个特征的平均值
- n_components#
要保留的组件数量。如果为None，则保留所有组件。
- prefix#
转换后特征名称的前缀。
- transform(df, n_components=None)[源代码]#
将PCA转换应用于DataFrame。
- Parameters:
df – 一个 vaex 数据框。
n_components – 保留的PCA组件数量。
- Return copy:
包含PCA组件的DataFrame的浅拷贝。
- Return type:
- whiten#
如果为True，则执行白化，即去除转换组件的相对方差比例。
- class vaex.ml.transformations.RobustScaler(**kwargs: Any)[source]#
基础类：
TransformerRobustScaler 移除中位数并根据给定的百分位范围缩放数据。默认情况下，缩放是在第25百分位和第75百分位之间进行的。每个特征（列）的居中和缩放是独立进行的。
示例：
>>> import vaex >>> df = vaex.from_arrays(x=[2,5,7,2,15], y=[-2,3,0,0,10]) >>> df # x y 0 2 -2 1 5 3 2 7 0 3 2 0 4 15 10 >>> scaler = vaex.ml.MaxAbsScaler(features=['x', 'y']) >>> scaler.fit_transform(df) # x y robust_scaled_x robust_scaled_y 0 2 -2 -0.333686 -0.266302 1 5 3 -0.000596934 0.399453 2 7 0 0.221462 0 3 2 0 -0.333686 0 4 15 10 1.1097 1.33151
- Parameters:
features – 要转换的特征列表。
percentile_range – 每个特征要缩放的百分位范围。
prefix – 转换后特征名称的前缀。
with_centering – 如果为True，移除中位数。
with_scaling – 如果为True，则在指定的百分位数范围内缩放每个特征。
- center_#
每个特征的中位数。
- percentile_range#
将每个特征缩放到百分位范围。
- prefix#
转换后特征名称的前缀。
- scale_#
每个特征的百分位范围。
- transform(df)[source]#
使用拟合的RobustScaler转换DataFrame。
- Parameters:
df – 一个 vaex 数据框。
- Returns copy:
包含缩放特征的DataFrame的浅拷贝。
- Return type:
- with_centering#
如果为True，移除中位数。
- with_scaling#
如果为True，则在指定的百分位数范围内缩放每个特征。
- class vaex.ml.transformations.StandardScaler(**kwargs: Any)[source]#
基础类：
Transformer通过去除特征的均值并将其缩放到单位方差来标准化特征。
示例：
>>> import vaex >>> df = vaex.from_arrays(x=[2,5,7,2,15], y=[-2,3,0,0,10]) >>> df # x y 0 2 -2 1 5 3 2 7 0 3 2 0 4 15 10 >>> scaler = vaex.ml.StandardScaler(features=['x', 'y']) >>> scaler.fit_transform(df) # x y standard_scaled_x standard_scaled_y 0 2 -2 -0.876523 -0.996616 1 5 3 -0.250435 0.189832 2 7 0 0.166957 -0.522037 3 2 0 -0.876523 -0.522037 4 15 10 1.83652 1.85086
- Parameters:
features – 要转换的特征列表。
prefix – 转换后特征名称的前缀。
with_mean – 如果为True，从每个特征中移除均值。
with_std – 如果为True，将每个特征缩放到单位方差。
- mean_#
每个特征的平均值
- prefix#
转换后特征名称的前缀。
- std_#
每个特征的标准差。
- transform(df)[source]#
使用拟合的StandardScaler转换DataFrame。
- Parameters:
df – 一个 vaex 数据框。
- Returns copy:
包含缩放特征的DataFrame的浅拷贝。
- Return type:
- with_mean#
如果为True，从每个特征中移除均值。
- with_std#
如果为True，将每个特征缩放到单位方差。
- class vaex.ml.transformations.CycleTransformer(**kwargs: Any)[源代码]#
基础类：
Transformer一种用于转换周期性特征（例如角度、时间）的策略。
将每个特征视为极坐标中单位圆的一个角度，然后获取x和y坐标投影，或者分别获取cos和sin分量。
适用于各种机器学习任务。 它保留了特征的循环连续性。 灵感来源：http://blog.davidkaleko.com/feature-engineering-cyclical-features.html
>>> df = vaex.from_arrays(days=[0, 1, 2, 3, 4, 5, 6]) >>> cyctrans = vaex.ml.CycleTransformer(n=7, features=['days']) >>> cyctrans.fit_transform(df) # days days_x days_y 0 0 1 0 1 1 0.62349 0.781831 2 2 -0.222521 0.974928 3 3 -0.900969 0.433884 4 4 -0.900969 -0.433884 5 5 -0.222521 -0.974928 6 6 0.62349 -0.781831
- Parameters:
features – 要转换的特征列表。
n – 一个周期中的元素数量。
prefix_x – 转换特征的x分量的前缀。
prefix_y – 转换特征的 y 分量的前缀。
suffix_x – 转换特征的x分量的后缀。
suffix_y – 转换特征的 y 组件的后缀。
- n#
一个周期中的元素数量。
- prefix_x#
变换特征的x分量的前缀。
- prefix_y#
变换特征的y分量的前缀。
- suffix_x#
转换特征的x分量的后缀。
- suffix_y#
转换特征的y分量的后缀。
- class vaex.ml.transformations.BayesianTargetEncoder(**kwargs: Any)[source]#
基础类：
Transformer使用贝叶斯目标编码器对分类变量进行编码。
类别通过其目标值的平均值进行编码， 该平均值使用贝叶斯方案根据目标变量的全局平均值进行调整。 对于较大的weight值，目标编码会向全局平均值平滑， 而对于weight为0的情况，编码只是每个类别的平均目标值。
参考：https://www.wikiwand.com/en/Bayes_estimator#/Practical_example_of_Bayes_estimators
示例：
>>> import vaex >>> import vaex.ml >>> df = vaex.from_arrays(x=['a', 'a', 'a', 'a', 'b', 'b', 'b', 'b'], ... y=[1, 1, 1, 0, 0, 0, 0, 1]) >>> target_encoder = vaex.ml.BayesianTargetEncoder(features=['x'], weight=4) >>> target_encoder.fit_transform(df, 'y') # x y mean_encoded_x 0 a 1 0.625 1 a 1 0.625 2 a 1 0.625 3 a 0 0.625 4 b 0 0.375 5 b 0 0.375 6 b 0 0.375 7 b 1 0.375
- Parameters:
features – 要转换的特征列表。
prefix – 转换后特征名称的前缀。
target – 包含目标变量的列的名称。
unseen – 处理未见值的策略。
weight – 应用于均值编码的权重（平滑参数）。
- prefix#
转换后特征名称的前缀。
- target#
包含目标变量的列的名称。
- transform(df)[source]#
使用拟合的BayesianTargetEncoder转换DataFrame。
- Parameters:
df – 一个 vaex 数据框。
- Returns:
包含编码的DataFrame的浅拷贝。
- Return type:
- unseen#
处理未见值的策略。
- weight#
应用于均值编码的权重（平滑参数）。
- class vaex.ml.transformations.WeightOfEvidenceEncoder(**kwargs: Any)[源代码]#
基础类：
Transformer使用权重证据编码器对分类变量进行编码。
证据权重衡量特定特征对给定假设（即目标变量）的支持程度。使用此编码器，分类特征中的每个类别都通过其“强度”即证据权重值进行编码。目标特征可以是布尔值或数值列，其中True/1被视为“好”，False/0被视为“坏”。
参考: https://www.listendata.com/2015/03/weight-of-evidence-woe-and-information.html
示例：
>>> import vaex >>> import vaex.ml >>> df = vaex.from_arrays(x=['a', 'a', 'b', 'b', 'b', 'c', 'c'], ... y=[1, 1, 0, 0, 1, 1, 0]) >>> woe_encoder = vaex.ml.WeightOfEvidenceEncoder(target='y', features=['x']) >>> woe_encoder.fit_transform(df) # x y mean_encoded_x 0 a 1 13.8155 1 a 1 13.8155 2 b 0 -0.693147 3 b 0 -0.693147 4 b 1 -0.693147 5 c 1 0 6 c 0 0
- Parameters:
epsilon – 作为负数的最小值的小值，以避免除以零
features – 要转换的特征列表。
prefix – 转换后特征名称的前缀。
target – 包含目标变量的列的名称。
unseen – 处理未见值的策略。
- epsilon#
取一个小的值作为负数的最小值，以避免除以零
- prefix#
转换后特征名称的前缀。
- target#
包含目标变量的列的名称。
- transform(df)[source]#
使用已拟合的WeightOfEvidenceEncoder转换DataFrame。
- Parameters:
df – 一个 vaex 数据框。
- Returns:
包含编码的DataFrame的浅拷贝。
- Return type:
- unseen#
处理未见值的策略。
- class vaex.ml.transformations.KBinsDiscretizer(**kwargs: Any)[源代码]#
基础类：
Transformer将连续特征分箱为离散的区间。
一种将连续特征编码为离散区间的策略。转换后的列包含每个样本所属的区间标签。在某种程度上，这个转换器对连续特征进行了标签/序数编码。
示例：
>>> import vaex >>> import vaex.ml >>> df = vaex.from_arrays(x=[0, 2.5, 5, 7.5, 10, 12.5, 15]) >>> bin_trans = vaex.ml.KBinsDiscretizer(features=['x'], n_bins=3, strategy='uniform') >>> bin_trans.fit_transform(df) # x binned_x 0 0 0 1 2.5 0 2 5 1 3 7.5 1 4 10 2 5 12.5 2 6 15 2
- Parameters:
epsilon – 添加到分箱边缘的微小值，确保接近分箱边缘的样本被正确分箱。
features – 要转换的特征列表。
n_bins – 分箱数量。必须大于1。
prefix – 转换后特征名称的前缀。
strategy – 用于定义箱子宽度的策略。可以是“uniform”、“quantile”或“kmeans”。
- bin_edges_#
每个分箱特征的分箱边界
- epsilon#
添加到箱边缘的微小值，确保靠近箱边缘的样本被正确分箱。
- n_bins#
箱子的数量。必须大于1。
- n_bins_#
每个特征的箱数。
- prefix#
转换后特征名称的前缀。
- strategy#
用于定义箱子宽度的策略。可以是“uniform”、“quantile”或“kmeans”。
- class vaex.ml.transformations.GroupByTransformer(**kwargs: Any)[source]#
基础类：
TransformerGroupByTransformer 通过 groupby 操作创建聚合，这些聚合会与 DataFrame 进行连接。这对于创建聚合特征非常有用。
示例：
>>> import vaex >>> import vaex.ml >>> df_train = vaex.from_arrays(x=['dog', 'dog', 'dog', 'cat', 'cat'], y=[2, 3, 4, 10, 20]) >>> df_test = vaex.from_arrays(x=['dog', 'cat', 'dog', 'mouse'], y=[5, 5, 5, 5]) >>> group_trans = vaex.ml.GroupByTransformer(by='x', agg={'mean_y': vaex.agg.mean('y')}, rsuffix='_agg') >>> group_trans.fit_transform(df_train) # x y x_agg mean_y 0 dog 2 dog 3 1 dog 3 dog 3 2 dog 4 dog 3 3 cat 10 cat 15 4 cat 20 cat 15 >>> group_trans.transform(df_test) # x y x_agg mean_y 0 dog 5 dog 3.0 1 cat 5 cat 15.0 2 dog 5 dog 3.0 3 mouse 5 -- --
- Parameters:
agg – 字典，其中键是特征名称，值是vaex.agg对象。
by – 用于分组的特征。
features – 要转换的特征列表。
rprefix – 在发生冲突时，聚合特征名称的前缀。
rsuffix – 在发生冲突时，聚合特征名称的后缀。
- agg#
字典，其中键是特征名称，值是vaex.agg对象。
- by#
用于分组的特征。
- rprefix#
在发生冲突时，聚合特征名称的前缀。
- rsuffix#
在发生冲突时，聚合特征名称的后缀。
聚类#
|
KMeans 聚类算法。 |
- class vaex.ml.cluster.KMeans(**kwargs: Any)[source]#
基础类：
TransformerKMeans聚类算法。
示例：
>>> import vaex.ml >>> import vaex.ml.cluster >>> df = vaex.datasets.iris() >>> features = ['sepal_width', 'petal_length', 'sepal_length', 'petal_width'] >>> cls = vaex.ml.cluster.KMeans(n_clusters=3, features=features, init='random', max_iter=10) >>> cls.fit(df) >>> df = cls.transform(df) >>> df.head(5) # sepal_width petal_length sepal_length petal_width class_ prediction_kmeans 0 3 4.2 5.9 1.5 1 2 1 3 4.6 6.1 1.4 1 2 2 2.9 4.6 6.6 1.3 1 2 3 3.3 5.7 6.7 2.1 2 0 4 4.2 1.4 5.5 0.2 0 1
- Parameters:
cluster_centers – 聚类中心的坐标。
features – 要聚类的特征列表。
inertia – 样本到其最近聚类中心的平方距离之和。
init – 用于初始化质心的方法。
max_iter – KMeans算法单次运行的最大迭代次数。
n_clusters – 要形成的簇的数量。
n_init – 质心初始化的次数。KMeans算法将为每次初始化运行，最终结果将是n_init次连续运行中惯性最小的输出。
prediction_label – 存储每个点的聚类标签的虚拟列的名称。
random_state – 用于质心初始化的随机数生成。如果指定了一个整数，随机性将变为确定性。
verbose – 如果为True，启用详细模式。
- cluster_centers#
聚类中心的坐标。
- features#
要聚类的特征列表。
- inertia#
样本到其最近聚类中心的距离平方和。
- init#
初始化质心的方法。
- max_iter#
KMeans算法单次运行的最大迭代次数。
- n_clusters#
要形成的集群数量。
- n_init#
质心初始化的次数。KMeans算法将为每次初始化运行，最终结果将是n_init次连续运行中惯性最佳的输出。
- prediction_label#
存储每个点的聚类标签的虚拟列的名称。
- random_state#
用于质心初始化的随机数生成。如果指定了一个整数，随机性将变为确定性。
- transform(dataframe)[source]#
使用拟合的KMeans模型标记DataFrame。
- Parameters:
dataframe – 一个 vaex 数据框。
- Returns copy:
包含聚类标签的DataFrame的浅拷贝。
- Return type:
- verbose#
如果为True，则启用详细模式。
指标#
- class vaex.ml.metrics.DataFrameAccessorMetrics(ml)[source]#
基础类：
object评估机器学习任务的常见指标。
此DataFrame访问器包含许多常见的机器学习评估指标。 其理念是可以在不进行核心计算的情况下评估这些指标，并且无需具体化目标和预测列。
请参阅https://vaex.io/docs/api.html#metrics以获取支持的评估指标列表。
- accuracy_score(y_true, y_pred, selection=None, array_type='python')[source]#
计算分类准确率得分。
- Parameters:
y_true – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
y_pred – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
准确率得分。
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.from_arrays(y_true=[1, 1, 0, 1, 0], y_pred=[1, 0, 0, 1, 1]) >>> df.ml.metrics.accuracy_score(df.y_true, df.y_pred) 0.6
- classification_report(y_true, y_pred, average='binary', decimals=3)[source]#
返回一个显示主要分类指标的文本报告
显示了准确率、精确率、召回率和F1分数。
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.from_arrays(y_true=[1, 1, 0, 1, 0, 1], y_pred=[1, 0, 0, 1, 1, 1]) >>> report = df.ml.metrics.classification_report(df.y_true, df.y_pred) >>> print(report) >>> print(report) Classification report:
准确率: 0.667 精确率: 0.75 召回率: 0.75 F1: 0.75
- confusion_matrix(y_true, y_pred, selection=None, array_type=None)[来源]#
文档字符串 :param y_true: 字符串形式的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y :param y_pred: 字符串形式的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y :param selection: 要使用的选择的名称（或 True 表示 'default'），或所有数据（当选择为 None 或 False 时），或选择的列表 :param array_type: 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray” 表示 xarray.DataArray，或 “list”/“python” 表示 Python 列表 :returns: 混淆矩阵
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.from_arrays(y_true=[1, 1, 0, 1, 0, 1], y_pred=[1, 0, 0, 1, 1, 1]) >>> df.ml.metrics.confusion_matrix(df.y_true, df.y_pred) array([[1, 1], [1, 3]]
- f1_score(y_true, y_pred, average='binary', selection=None, array_type=None)[source]#
计算F1分数。
这是精确率和召回率之间的调和平均值。
对于二分类问题，average 应设置为“binary”。 在这种情况下，假设输入数据以0和1的整数编码，其中重要的类别标记为1。
对于多类分类问题，average 应设置为“macro”。 “macro”平均是每个标签的度量的未加权平均值。 对于多类问题，数据可以进行序数编码，但也支持类名。
- Parameters:
y_true – {expression_one}
y_pred – {expression_one}
average – 应该是 'binary' 或 'macro'。
selection – {selection}
array_type – {array_type}
- Returns:
召回分数
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.from_arrays(y_true=[1, 1, 0, 1, 0, 1], y_pred=[1, 0, 0, 1, 1, 1]) >>> df.ml.metrics.recall_score(df.y_true, df.y_pred) 0.75
- matthews_correlation_coefficient(y_true, y_pred, selection=None, array_type=None)[source]#
计算马修斯相关系数。
该指标可用于二分类和多分类问题。
- Parameters:
y_true – {expression_one}
y_pred – {expression_one}
selection – {selection}
- Returns:
马修斯相关系数。
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.from_arrays(y_true=[1, 1, 0, 1, 0, 1], y_pred=[1, 0, 0, 1, 1, 1]) >>> df.ml.metrics.matthews_correlation_coefficient(df.y_true, df.y_pred) 0.25
- mean_absolute_error(y_true, y_pred, selection=None, array_type='python')[来源]#
计算平均绝对误差。
- Parameters:
y_true – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
y_pred – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
array_type (str) – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray” 用于 xarray.DataArray，或 “list”/“python” 用于 Python 列表
- Returns:
平均绝对误差
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.datasets.iris() >>> df.ml.metrics.mean_absolute_error(df.sepal_length, df.petal_length) 2.0846666666666667
- mean_squared_error(y_true, y_pred, selection=None, array_type='python')[来源]#
计算均方误差。
- Parameters:
y_true – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
y_pred – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
array_type (str) – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray” 用于 xarray.DataArray，或 “list”/“python” 用于 Python 列表
- Returns:
均方误差
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.datasets.iris() >>> df.ml.metrics.mean_squared_error(df.sepal_length, df.petal_length) 5.589000000000001
- precision_recall_fscore(y_true, y_pred, average='binary', selection=None, array_type=None)[来源]#
计算分类问题的精确率、召回率和f1分数。
这些指标定义如下： - 精确率 = tp / (tp + fp) - 召回率 = tp / (tp + fn) - f1 = tp / (tp + 0.5 * (fp + fn)) 其中“tp”表示真正例，“fp”表示假正例，“fn”表示假反例。
对于二分类问题，average 应设置为“binary”。 在这种情况下，假设输入数据以0和1的整数编码，其中重要的类别标记为1。
对于多类分类问题，average 应设置为“macro”。 “macro”平均是每个标签的度量的未加权平均值。 对于多类问题，数据可以进行序数编码，但也支持类名。
- Y_true:
以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
- Y_pred:
以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
- Average:
应该是‘binary’或‘macro’。
- Selection:
要使用的选择的名称（或为“默认”选择True），或所有数据（当选择为None或False时），或选择的列表
- Array_type:
输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray” 用于 xarray.DataArray，或 “list”/“python” 用于 Python 列表
- Returns:
精确率、召回率和f1分数
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.from_arrays(y_true=[1, 1, 0, 1, 0, 1], y_pred=[1, 0, 0, 1, 1, 1]) >>> df.ml.metrics.precision_score(df.y_true, df.y_pred) (0.75, 0.75, 0.75)
- precision_score(y_true, y_pred, average='binary', selection=None, array_type=None)[来源]#
计算分类的精确度分数。
对于二分类问题，average 应设置为“binary”。 在这种情况下，假设输入数据以0和1的整数编码，其中重要的类别标记为1。
对于多类分类问题，average 应设置为“macro”。 “macro”平均是每个标签的度量的未加权平均值。 对于多类问题，数据可以进行序数编码，但也支持类名。
- Parameters:
y_true – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
y_pred – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
average – 应该是 'binary' 或 'macro'。
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
精确度分数
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.from_arrays(y_true=[1, 1, 0, 1, 0, 1], y_pred=[1, 0, 0, 1, 1, 1]) >>> df.ml.metrics.precision_score(df.y_true, df.y_pred) 0.75
- r2_score(y_true, y_pred)[来源]#
计算R**2（决定系数）回归评分函数。
- Parameters:
y_true – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
y_pred – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
array_type (str) – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray” 用于 xarray.DataArray，或 “list”/“python” 用于 Python 列表
- Returns:
R**2 分数
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.datasets.iris() >>> df.ml.metrics.r2_score(df.sepal_length, df.petal_length) -7.205575765485069
- recall_score(y_true, y_pred, average='binary', selection=None, array_type=None)[来源]#
计算召回分类分数。
对于二分类问题，average 应设置为“binary”。 在这种情况下，假设输入数据以0和1的整数编码，其中重要的类别标记为1。
对于多类分类问题，average 应设置为“macro”。 “macro”平均是每个标签的度量的未加权平均值。 对于多类问题，数据可以进行序数编码，但也支持类名。
- Parameters:
y_true – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
y_pred – 以字符串形式表示的表达式，例如 'x' 或 'x+y' 或 vaex 表达式对象，例如 df.x 或 df.x+df.y
average – 应该是 'binary' 或 'macro'。
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
array_type – 输出数组的类型，可能的值为 None（保持原样）、“numpy”（ndarray）、“xarray”表示 xarray.DataArray，或“list”/“python”表示 Python 列表
- Returns:
召回分数
示例：
>>> import vaex >>> import vaex.ml.metrics >>> df = vaex.from_arrays(y_true=[1, 1, 0, 1, 0, 1], y_pred=[1, 0, 0, 1, 1, 1]) >>> df.ml.metrics.recall_score(df.y_true, df.y_pred) 0.75
Scikit-learn#
|
此类包装任何具有.partial_fit方法的scikit-learn估计器（也称为预测器），并将其转换为vaex管道对象。 |
|
此类包装任何scikit-learn估计器（也称为预测器），使其成为vaex管道对象。 |
- class vaex.ml.sklearn.IncrementalPredictor(**kwargs: Any)[source]#
基础类：
HasState这个类包装了任何具有.partial_fit方法的scikit-learn估计器（也称为预测器），并将其转换为vaex管道对象。
通过将“在线”scikit-learn估计器包装在此类中，它们成为vaex管道对象。因此，它们可以充分利用vaex的序列化和管道系统。虽然底层估计器需要调用.partial_fit方法，但此类包含标准的.fit方法，其余操作在幕后进行。还可以多次迭代数据（epochs），并在将每个批次发送到估计器之前选择性地打乱顺序。predict方法返回一个numpy数组，而transform方法将预测作为虚拟列添加到vaex DataFrame中。
注意：.fit 方法将使用尽可能多的内存来复制一批数据，而 .predict 方法将需要尽可能多的内存来输出预测结果作为 numpy 数组。transform 方法是惰性评估的，不会进行内存复制。
注意：我们在这里使用的是未经修改的普通sklearn。
示例：
>>> import vaex >>> import vaex.ml >>> from vaex.ml.sklearn import IncrementalPredictor >>> from sklearn.linear_model import SGDRegressor >>> >>> df = vaex.example() >>> >>> features = df.column_names[:6] >>> target = 'FeH' >>> >>> standard_scaler = vaex.ml.StandardScaler(features=features) >>> df = standard_scaler.fit_transform(df) >>> >>> features = df.get_column_names(regex='^standard') >>> model = SGDRegressor(learning_rate='constant', eta0=0.01, random_state=42) >>> >>> incremental = IncrementalPredictor(model=model, ... features=features, ... target=target, ... batch_size=10_000, ... num_epochs=3, ... shuffle=True, ... prediction_name='pred_FeH') >>> incremental.fit(df=df) >>> df = incremental.transform(df) >>> df.head(5)[['FeH', 'pred_FeH']] # FeH pred_FeH 0 -2.30923 -1.66226 1 -1.78874 -1.68218 2 -0.761811 -1.59562 3 -1.52088 -1.62225 4 -2.65534 -1.61991
- Parameters:
batch_size – 每批次发送到模型的样本数量。
features – 要使用的特征列表。
model – 一个具有 .fit_predict 方法的 scikit-learn 估计器。
num_epochs – 每个批次发送到模型的次数。
partial_fit_kwargs – 一个关键字参数字典，将传递给model的fit_predict方法。
prediction_name – 存储预测结果的虚拟列的名称。
prediction_type – 使用哪种方法来获取预测。可以是“predict”、“predict_proba”或“predict_log_proba”。
shuffle – 如果为True，则在将样本发送到模型之前对其进行洗牌。
target – 目标列的名称。
- batch_size#
每批发送到模型的样本数量。
- features#
要使用的特征列表。
- fit(df, progress=None)[source]#
将IncrementalPredictor适配到DataFrame。
- Parameters:
df – 一个包含特征和目标变量的 vaex DataFrame，用于训练模型。
progress – 如果为True，显示一个进度条来跟踪训练进度。
- model#
一个带有.fit_predict方法的scikit-learn估计器。
- num_epochs#
每个批次发送到模型的次数。
- partial_fit_kwargs#
传递给model的fit_predict方法的关键字参数字典。
- predict(df)[source]#
获取一个包含Predictor预测结果的numpy数组
- Parameters:
df – 一个 vaex DataFrame，包含输入特征。
- Returns:
一个包含预测器预测结果的numpy内存数组。
- Return type:
numpy.array
- prediction_name#
存储预测结果的虚拟列的名称。
- prediction_type#
使用哪种方法来获取预测。可以是“predict”、“predict_proba”或“predict_log_proba”。
- shuffle#
如果为True，在将样本发送到模型之前进行洗牌。
- snake_name = 'sklearn_incremental_predictor'#
- target#
目标列的名称。
- class vaex.ml.sklearn.Predictor(**kwargs: Any)[source]#
基础类：
HasState此类包装任何scikit-learn估计器（也称为预测器），使其成为vaex管道对象。
通过将任何scikit-learn估计器包装在此类中，它将成为vaex管道对象。因此，它可以充分利用vaex的序列化和管道系统。可以使用predict方法获取拟合估计器的numpy数组输出，或使用transform方法将此类预测作为虚拟列添加到vaex DataFrame中。
请注意，当调用fit和predict时，会创建数据使用的完整内存副本。transform方法是延迟评估的。
scikit-learn 的估计器本身完全没有被修改，它们是从您本地安装的 scikit-learn 中获取的。
示例：
>>> import vaex.ml >>> from vaex.ml.sklearn import Predictor >>> from sklearn.linear_model import LinearRegression >>> df = vaex.datasets.iris() >>> features = ['sepal_width', 'petal_length', 'sepal_length'] >>> df_train, df_test = df.ml.train_test_split() >>> model = Predictor(model=LinearRegression(), features=features, target='petal_width', prediction_name='pred') >>> model.fit(df_train) >>> df_train = model.transform(df_train) >>> df_train.head(3) # sepal_length sepal_width petal_length petal_width class_ pred 0 5.4 3 4.5 1.5 1 1.64701 1 4.8 3.4 1.6 0.2 0 0.352236 2 6.9 3.1 4.9 1.5 1 1.59336 >>> df_test = model.transform(df_test) >>> df_test.head(3) # sepal_length sepal_width petal_length petal_width class_ pred 0 5.9 3 4.2 1.5 1 1.39437 1 6.1 3 4.6 1.4 1 1.56469 2 6.6 2.9 4.6 1.3 1 1.44276
- Parameters:
features – 要使用的特征列表。
model – 一个 scikit-learn 估计器。
prediction_name – 存储预测结果的虚拟列的名称。
prediction_type – 使用哪种方法来获取预测。可以是“predict”、“predict_proba”或“predict_log_proba”。
target – 目标列的名称。
- features#
要使用的特征列表。
- model#
一个scikit-learn估计器。
- predict(df)[源代码]#
获取一个包含Predictor预测结果的numpy数组。
- Parameters:
df – 一个 vaex DataFrame，包含输入特征。
- Returns:
一个包含预测器预测结果的numpy内存数组。
- Return type:
numpy.array
- prediction_name#
存储预测结果的虚拟列的名称。
- prediction_type#
使用哪种方法来获取预测。可以是“predict”、“predict_proba”或“predict_log_proba”。
- snake_name = 'sklearn_predictor'#
- target#
目标列的名称。
提升树#
|
LightGBM 算法。 |
|
XGBoost 算法。 |
|
CatBoost 算法。 |
- class vaex.ml.lightgbm.LightGBMModel(**kwargs: Any)[source]#
基础类：
HasStateLightGBM算法。
该类提供了对LightGBM算法的接口，并针对训练大型数据集时进行了内存效率的优化。算法本身并未做任何修改。
LightGBM 是一种基于决策树的快速梯度提升算法，主要用于分类、回归和排序任务。它隶属于微软的分布式机器学习工具包（DMTK）项目。更多信息，请访问 Microsoft/LightGBM。
示例：
>>> import vaex.ml >>> import vaex.ml.lightgbm >>> df = vaex.datasets.iris() >>> features = ['sepal_width', 'petal_length', 'sepal_length', 'petal_width'] >>> df_train, df_test = df.ml.train_test_split() >>> params = { 'boosting': 'gbdt', 'max_depth': 5, 'learning_rate': 0.1, 'application': 'multiclass', 'num_class': 3, 'subsample': 0.80, 'colsample_bytree': 0.80} >>> booster = vaex.ml.lightgbm.LightGBMModel(features=features, target='class_', num_boost_round=100, params=params) >>> booster.fit(df_train) >>> df_train = booster.transform(df_train) >>> df_train.head(3) # sepal_width petal_length sepal_length petal_width class_ lightgbm_prediction 0 3 4.5 5.4 1.5 1 [0.00165619 0.98097899 0.01736482] 1 3.4 1.6 4.8 0.2 0 [9.99803930e-01 1.17346471e-04 7.87235133e-05] 2 3.1 4.9 6.9 1.5 1 [0.00107541 0.9848717 0.01405289] >>> df_test = booster.transform(df_test) >>> df_test.head(3) # sepal_width petal_length sepal_length petal_width class_ lightgbm_prediction 0 3 4.2 5.9 1.5 1 [0.00208904 0.9821348 0.01577616] 1 3 4.6 6.1 1.4 1 [0.00182039 0.98491357 0.01326604] 2 2.9 4.6 6.6 1.3 1 [2.50915444e-04 9.98431777e-01 1.31730785e-03]
- Parameters:
features – 用于拟合 LightGBMModel 的特征列表。
num_boost_round – 提升迭代的次数。
params – 传递给LightGBM模型的参数。
prediction_name – 存储预测结果的虚拟列的名称。
target – 目标列的名称。
- features#
在拟合LightGBMModel时使用的特征列表。
- fit(df, valid_sets=None, valid_names=None, early_stopping_rounds=None, evals_result=None, verbose_eval=False, **kwargs)[来源]#
将 LightGBMModel 拟合到 DataFrame。
模型将训练直到验证分数停止提高。 验证分数需要至少每early_stopping_rounds轮提高一次 以继续训练。需要至少一个验证DataFrame，指定 指标。如果有多个，将检查所有指标，但 训练数据无论如何都会被忽略。如果发生早停，模型 将向booster对象添加
best_iteration字段。- Parameters:
- num_boost_round#
提升迭代的次数。
- params#
要传递给LightGBM模型的参数。
- predict(df, **kwargs)[source]#
获取一个内存中的numpy数组，其中包含LightGBMModel在vaex DataFrame上的预测结果。 此方法接受来自LightGBM的predict方法的关键字参数。
- Parameters:
df – 一个 vaex 数据框。
- Returns:
包含LightGBMModel预测的内存中的numpy数组。
- Return type:
numpy.array
- prediction_name#
存储预测结果的虚拟列的名称。
- target#
目标列的名称。
- class vaex.ml.xgboost.XGBoostModel(**kwargs: Any)[源代码]#
基础类：
HasStateXGBoost算法。
XGBoost 是一个优化的分布式梯度提升库，旨在高效、灵活和可移植。它在梯度提升框架下实现了机器学习算法。XGBoost 提供了并行树提升（也称为 GBDT、GBM），以快速准确的方式解决许多数据科学问题。 (dmlc/xgboost)
示例：
>>> import vaex >>> import vaex.ml.xgboost >>> df = vaex.datasets.iris() >>> features = ['sepal_width', 'petal_length', 'sepal_length', 'petal_width'] >>> df_train, df_test = df.ml.train_test_split() >>> params = { 'max_depth': 5, 'learning_rate': 0.1, 'objective': 'multi:softmax', 'num_class': 3, 'subsample': 0.80, 'colsample_bytree': 0.80, 'silent': 1} >>> booster = vaex.ml.xgboost.XGBoostModel(features=features, target='class_', num_boost_round=100, params=params) >>> booster.fit(df_train) >>> df_train = booster.transform(df_train) >>> df_train.head(3) # sepal_length sepal_width petal_length petal_width class_ xgboost_prediction 0 5.4 3 4.5 1.5 1 1 1 4.8 3.4 1.6 0.2 0 0 2 6.9 3.1 4.9 1.5 1 1 >>> df_test = booster.transform(df_test) >>> df_test.head(3) # sepal_length sepal_width petal_length petal_width class_ xgboost_prediction 0 5.9 3 4.2 1.5 1 1 1 6.1 3 4.6 1.4 1 1 2 6.6 2.9 4.6 1.3 1 1
- Parameters:
features – 用于拟合XGBoostModel的特征列表。
num_boost_round – 提升迭代的次数。
params – 传递给XGBoost模型的参数字典。
prediction_name – 存储预测结果的虚拟列的名称。
target – 目标列的名称。
- features#
拟合XGBoostModel时使用的特征列表。
- fit(df, evals=(), early_stopping_rounds=None, evals_result=None, verbose_eval=False, **kwargs)[来源]#
给定一个DataFrame，拟合XGBoost模型。
此方法接受所有用于xgboost.train方法的关键字参数。
- Parameters:
df – 一个包含特征和目标变量的 vaex DataFrame，用于训练模型。
evals – 一个由 (DataFrame, string) 对组成的列表。 训练期间要评估的项目列表，这允许用户观察验证集上的表现。
early_stopping_rounds (int) – 激活早停功能。 验证误差需要至少每early_stopping_rounds轮减少一次才能继续训练。 需要在evals中至少有一个项目。如果有多个，将使用最后一个。返回最后一次迭代的模型（不是最好的一个）。
evals_result (dict) – 一个字典，存储evals中所有项目的评估结果。
verbose_eval (bool) – 需要在 evals 中至少有一个项目。 如果 verbose_eval 为 True，则在每个提升阶段打印验证集上的评估指标。
- num_boost_round#
提升迭代的次数。
- params#
传递给XGBoost模型的参数字典。
- predict(df, **kwargs)[来源]#
提供一个vaex DataFrame，获取一个包含XGBoost模型预测结果的内存中的numpy数组。 此方法接受XGBoost中predict方法的关键字参数。
- Returns:
包含XGBoostModel预测的内存中的numpy数组。
- Return type:
numpy.array
- prediction_name#
存储预测结果的虚拟列的名称。
- target#
目标列的名称。
- class vaex.ml.catboost.CatBoostModel(**kwargs: Any)[source]#
基础类：
HasStateCatBoost算法。
该类提供了对CatBoost算法的接口。 CatBoost是一个快速、可扩展、高性能的基于决策树的梯度提升库，用于排序、分类、回归和其他机器学习任务。更多信息请访问 catboost/catboost
示例：
>>> import vaex >>> import vaex.ml.catboost >>> df = vaex.datasets.iris() >>> features = ['sepal_width', 'petal_length', 'sepal_length', 'petal_width'] >>> df_train, df_test = df.ml.train_test_split() >>> params = { 'leaf_estimation_method': 'Gradient', 'learning_rate': 0.1, 'max_depth': 3, 'bootstrap_type': 'Bernoulli', 'objective': 'MultiClass', 'eval_metric': 'MultiClass', 'subsample': 0.8, 'random_state': 42, 'verbose': 0} >>> booster = vaex.ml.catboost.CatBoostModel(features=features, target='class_', num_boost_round=100, params=params) >>> booster.fit(df_train) >>> df_train = booster.transform(df_train) >>> df_train.head(3) # sepal_length sepal_width petal_length petal_width class_ catboost_prediction 0 5.4 3 4.5 1.5 1 [0.00615039 0.98024259 0.01360702] 1 4.8 3.4 1.6 0.2 0 [0.99034267 0.00526382 0.0043935 ] 2 6.9 3.1 4.9 1.5 1 [0.00688241 0.95190908 0.04120851] >>> df_test = booster.transform(df_test) >>> df_test.head(3) # sepal_length sepal_width petal_length petal_width class_ catboost_prediction 0 5.9 3 4.2 1.5 1 [0.00464228 0.98883351 0.00652421] 1 6.1 3 4.6 1.4 1 [0.00350424 0.9882139 0.00828186] 2 6.6 2.9 4.6 1.3 1 [0.00325705 0.98891631 0.00782664]
- Parameters:
batch_size – 如果提供，将以此大小的批次进行训练。
batch_weights – 在训练结束时批量求和模型的权重。
ctr_merge_policy – 模型求和的策略。仅在批量训练时使用。有关更多信息，请参阅CatBoost文档。
evals_result – 评估结果
features – 用于拟合 CatBoostModel 的特征列表。
num_boost_round – 提升迭代的次数。
params – 传递给 CatBoostModel 模型的参数字典。
pool_params – 传递给Pool数据对象构造的参数字典
prediction_name – 存储预测结果的虚拟列的名称。
prediction_type – 预测的形式。可以是“RawFormulaVal”、“Probability”或“Class”。
target – 目标列的名称。
- batch_size#
如果提供，将以此大小的批次进行训练。
- batch_weights#
在训练结束时批量汇总模型的权重。
- ctr_merge_policy#
模型求和的策略。仅在批量训练时使用。有关更多信息，请参阅CatBoost文档。
- evals_result_#
评估结果
- features#
用于拟合CatBoostModel的特征列表。
- fit(df, evals=None, early_stopping_rounds=None, verbose_eval=None, plot=False, progress=None, **kwargs)[source]#
给定一个DataFrame，拟合CatBoostModel模型。 此方法接受catboost.train方法的所有关键字参数。
- Parameters:
df – 一个包含特征和目标变量的 vaex DataFrame，用于训练模型。
evals – 一个在训练期间要评估的DataFrames列表。 这允许用户观察验证集上的性能。
early_stopping_rounds (int) – 激活早停功能。
verbose_eval (bool) – 需要在 evals 中至少有一个项目。 如果 verbose_eval 为 True，则在每个提升阶段打印验证集上的评估指标。
plot (bool) – 如果为True，则在Jupyter笔记本中显示一个交互式小部件，展示训练集和验证集在每次提升迭代中的得分情况。
progress – 如果为True，在批量训练完成时显示进度条。
- num_boost_round#
提升迭代的次数。
- params#
传递给CatBoostModel模型的参数字典。
- pool_params#
传递给Pool数据对象构造的参数字典
- predict(df, **kwargs)[source]#
提供一个vaex DataFrame，获取一个包含CatBoostModel模型预测结果的numpy数组。 此方法接受catboost中predict方法的关键字参数。
- Parameters:
df – 一个 vaex 数据框
- Returns:
包含CatBoostModel预测的内存中的numpy数组。
- Return type:
numpy.array
- prediction_name#
存储预测结果的虚拟列的名称。
- prediction_type#
预测的形式。可以是“RawFormulaVal”、“Probability”或“Class”。
- target#
目标列的名称。
Tensorflow#
|
一个简单的类，使Keras模型在Vaex状态中可序列化，并支持预测的惰性转换。 |
- class vaex.ml.tensorflow.KerasModel(**kwargs: Any)[source]#
基础类：
HasState一个简单的类，使Keras模型在Vaex状态下可序列化，并支持预测的惰性转换。
有关如何使用Keras库的更多信息，请访问https://keras.io/。
示例：
>>> import vaex >>> import vaex.ml.tensorflow >>> import tensorflow.keras as K
>>> df = vaex.example() >>> df_train, df_test = df.ml.train_test_split(0.2)
>>> features = ['vx', 'vy', 'vz'] >>> target = 'FeH'
>>> gen_train = df_train.ml.tensorflow.to_keras_generator(features=features, target=target, batch_size=512) Recommended "steps_per_epoch" arg: 516.0
>>> nn_model = K.Sequential() >>> nn_model.add(K.layers.Dense(3, activation='tanh')) >>> nn_model.add(K.layers.Dense(1, activation='linear')) >>> nn_model.compile(optimizer='sgd', loss='mse') >>> nn_model.fit(x=gen_train, epochs=11, steps_per_epoch=516, verbose=0)
>>> keras_model = vaex.ml.tensorflow.KerasModel(features=features, prediction_name='pred', model=nn_model) >>> df_test = keras_model.transform(df_test) >>> print(df_test.head(3)['vx', 'vy', 'vz', 'FeH', 'pred']) # vx vy vz FeH pred 0 301.155 174.059 27.4275 -1.00539 array([-1.5861175], dtype=float32) 1 -195 170.472 142.53 -1.70867 array([-1.6035867], dtype=float32) 2 -48.6342 171.647 -2.07944 -1.83361 array([-1.5978462], dtype=float32)
- Parameters:
custom_objects – 可选的字典，将名称（字符串）映射到自定义类或函数，用于反序列化过程中。有关更多详细信息，请参阅“tf.keras.models.load_model”。
features – 应用KerasModel时使用的特征列表。
model – 一个已训练的 Keras 模型
prediction_name – 存储预测结果的虚拟列的名称。
- custom_objects#
可选的字典，将名称（字符串）映射到在反序列化期间使用的自定义类或函数。有关更多详细信息，请参阅“tf.keras.models.load_model”。
- features#
应用KerasModel时要使用的特征列表。
- model#
一个拟合的Keras模型
- prediction_name#
存储预测结果的虚拟列的名称。
- class vaex.ml.tensorflow.DataFrameAccessorTensorflow(ml)[源代码]#
基础类：
object- to_keras_generator(features, target=None, batch_size=1024, parallel=True, shuffle=True, infinite=True, verbose=True)[source]#
返回一个适合作为Keras数据源的批量生成器。请注意，默认情况下生成器是无限的，即它会不断地循环数据。因此，在拟合Keras模型时需要指定“steps_per_epoch”参数，在用于验证时需要指定“validation_steps”参数，在调用Keras模型的“predict”方法时需要指定“steps”参数。
- Parameters:
features – 特征列表。
target – 依赖或目标列或列列表（如果有的话）。
batch_size – 每个数据块中的样本数量。这可以被视为批量大小。
parallel – 如果为True，vaex将并行评估数据块。
shuffle – 如果为True，每次传递前打乱数据。
infinite – 如果为True，生成器是无限的，即它会不断循环数据。如果为False，生成器只会对数据进行一次遍历。
- Parallel verbose:
如果为True，根据样本总数和“batch_size”显示推荐的“steps_per_epoch”信息。
示例：
>>> import vaex >>> import vaex.ml >>> import tensorflow.keras as K
>>> df = vaex.example() >>> features = ['x', 'y', 'z', 'vx', 'vz', 'vz'] >>> target = 'FeH'
>>> # Scaling the features >>> df = df.ml.minmax_scaler(features=features) >>> features = df.get_column_names(regex='^minmax_')
>>> # Create a training generator >>> train_generator = df.ml.tensorflow.to_keras_generator(features=features, target=target, batch_size=512) Recommended "steps_per_epoch" arg: 645.0
>>> # Build a neural network model >>> nn_model = K.Sequential() >>> nn_model.add(K.layers.Dense(4, activation='tanh')) >>> nn_model.add(K.layers.Dense(4, activation='tanh')) >>> nn_model.add(K.layers.Dense(1, activation='linear')) >>> nn_model.compile(optimizer='sgd', loss='mse')
>>> nn_model.fit(x=train_generator, epochs=3, steps_per_epoch=645) Epoch 1/3 645/645 [==============================] - 3s 5ms/step - loss: 0.2068 Epoch 2/3 645/645 [==============================] - 3s 5ms/step - loss: 0.1706 Epoch 3/3 645/645 [==============================] - 3s 5ms/step - loss: 0.1705
孵化器/实验性#
这些模型处于孵化阶段，未来可能会消失
- class vaex.ml.incubator.annoy.ANNOYModel(**kwargs: Any)[source]#
基础类：
HasState- Parameters:
features – 要使用的特征列表。
metric – 用于距离计算的度量标准
n_neighbours – 现在有多少邻居
n_trees – 要构建的树的数量。
predcition_name – 转换DataFrame时用于邻居的输出列名
prediction_name – 转换DataFrame时用于邻居的输出列名
search_k – 约万？
- features#
要使用的特征列表。
- metric#
用于距离计算的指标
- n_neighbours#
现在有很多邻居
- n_trees#
要构建的树的数量。
- predcition_name#
转换DataFrame时邻居的输出列名
- prediction_name#
转换DataFrame时邻居的输出列名
- search_k#
约万？
- class vaex.ml.incubator.river.RiverModel(**kwargs: Any)[source]#
基础类：
HasState该类封装了River（github.com/online-ml/river）的估计器，使它们成为vaex管道对象。
这个类方便地包装了River模型，使它们成为vaex管道对象。 因此，它们充分利用了vaex的序列化和管道系统。 只有实现了learn_many的River模型是兼容的。 也可以包装整个River管道，只要每个管道步骤 实现了learn_many方法。使用包装器，可以多次迭代 数据（epochs），并可选地在每个批次发送到 估计器之前进行洗牌。predict方法将需要尽可能多的内存来 将预测输出为numpy数组，而transform 方法是惰性评估的，不会进行内存复制。
示例：
>>> import vaex >>> import vaex.ml >>> from vaex.ml.incubator.river import RiverModel >>> from river.linear_model import LinearRegression >>> from river import optim >>> >>> df = vaex.example() >>> >>> features = df.column_names[:6] >>> target = 'FeH' >>> >>> df = df.ml.standard_scaler(features=features, prefix='scaled_') >>> >>> features = df.get_column_names(regex='^scaled_') >>> model = LinearRegression(optimizer=optim.SGD(lr=0.1), intercept_lr=0.1) >>> >>> river_model = RiverModel(model=model, features=features, target=target, batch_size=10_000, num_epochs=3, shuffle=True, prediction_name='pred_FeH') >>> >>> river_model.fit(df=df) >>> df = river_model.transform(df) >>> df.head(5)[['FeH', 'pred_FeH']] # FeH pred_FeH 0 -1.00539 -1.6332 1 -1.70867 -1.56632 2 -1.83361 -1.55338 3 -1.47869 -1.60646 4 -1.85705 -1.5996
- Parameters:
batch_size – 每批次发送到模型的样本数量。
features – 要使用的特征列表。
model – 一个实现了 learn_many 方法的 River 模型。
num_epochs – 每个批次发送到模型的次数。
prediction_name – 存储预测结果的虚拟列的名称。
prediction_type – 使用哪种方法来获取预测。可以是“predict”或“predict_proba”，分别对应于River模型中的“predict_many”和“predict_proba_many”。
shuffle – 如果为True，则在将样本发送到模型之前对其进行洗牌。
target – 目标列的名称。
- batch_size#
每批发送到模型的样本数量。
- features#
要使用的特征列表。
- fit(df, progress=None)[来源]#
将RiverModel适配到DataFrame。
- Parameters:
df – 一个包含特征和目标变量的 vaex DataFrame，用于训练模型
progress – 如果为True，显示一个进度条来跟踪训练进度。
- model#
一个实现了learn_many方法的River模型。
- num_epochs#
每个批次发送到模型的次数。
- predict(df)[source]#
获取一个内存中的numpy数组，包含模型的预测结果
- Parameters:
df – 一个包含输入特征的 vaex DataFrame
- Returns:
包含模型预测的内存中的numpy数组
- Return type:
numpy.array
- prediction_name#
存储预测结果的虚拟列的名称。
- prediction_type#
使用哪种方法来获取预测。可以是“predict”或“predict_proba”，分别对应于River模型中的“predict_many”和“predict_proba_many”。
- shuffle#
如果为True，在将样本发送到模型之前进行洗牌。
- target#
目标列的名称。
vaex-viz#
- class vaex.viz.DataFrameAccessorViz(df)[source]#
基础类：
object- __weakref__#
对象的弱引用列表
- healpix_heatmap(healpix_expression='source_id/34359738368', healpix_max_level=12, healpix_level=8, what='count(*)', selection=None, grid=None, healpix_input='equatorial', healpix_output='galactic', f=None, colormap='afmhot', grid_limits=None, image_size=800, nest=True, figsize=None, interactive=False, title='', smooth=None, show=False, colorbar=True, rotation=(0, 0, 0), **kwargs)#
使用healpix列在2D中可视化数据。
- Parameters:
healpix_expression – {healpix_max_level}
healpix_max_level – {healpix_max_level}
healpix_level – {healpix_level}
什么 – {what}
selection – {selection}
grid – {grid}
healpix_input – 指定healpix索引是“赤道”、“银河”还是“黄道”。
healpix_output – 以“赤道”、“银河”或“黄道”绘制。
f – 应用于数据的函数
colormap – matplotlib 颜色映射
grid_limits – 可选的序列 [minvalue, maxvalue]，用于确定映射到颜色图的最小值和最大值（低于和高于这些值的将被裁剪到最小/最大值）。(默认值为 [min(f(grid)), max(f(grid)))
image_size – healpy用于渲染的图像大小
nest – 如果healpix数据是嵌套的（True）或环状的（False）
figsize – 如果提供，修改matplotlib图形的大小。示例 (14,9)
interactive – （实验性，如果 healpy.mollzoom 为 True）
title – 图的标题
smooth – 应用高斯平滑，单位为度
show – 调用 matplotlib 的 show（True）或不调用（False，默认）
rotation – 旋转图表，格式为 (lon, lat, psi)，其中 (lon, lat) 是中心点，并在屏幕上旋转角度 psi。所有角度均为度数。
- Returns:
- heatmap(x=None, y=None, z=None, what='count(*)', vwhat=None, reduce=['colormap'], f=None, normalize='normalize', normalize_axis='what', vmin=None, vmax=None, shape=256, vshape=32, limits=None, grid=None, colormap='afmhot', figsize=None, xlabel=None, ylabel=None, aspect='auto', tight_layout=True, interpolation='nearest', show=False, colorbar=True, colorbar_label=None, selection=None, selection_labels=None, title=None, background_color='white', pre_blend=False, background_alpha=1.0, visual={'column': 'what', 'fade': 'selection', 'layer': 'z', 'row': 'subspace', 'x': 'x', 'y': 'y'}, smooth_pre=None, smooth_post=None, wrap=True, wrap_columns=4, return_extra=False, hardcopy=None)#
在二维直方图/热图中可视化数据。
使用matplotlib进行统计图的声明式绘图，支持子图、选择和图层。
不要传递x和y，而是将列表作为x参数传递以创建多个面板。提供一个选项列表以拥有多个面板。当两者都存在时，将按列/行顺序组织。
此方法创建一个6维的“网格”，其中每个维度可以映射到一个视觉维度。 网格维度为：
x: 形状由shape决定，内容由x参数或每个空间的第一个维度决定
y: ,,
z: 与z参数相关
选择：形状等于选择参数的长度
what: shape 等于 what 参数的长度
space: 如果提供了多个值，则形状等于x参数的长度
默认情况下，其形状为 (1, 1, 1, 1, shape, shape)（其中 x 是最后一个维度）
视觉维度是
x: 图表/图像上的x坐标（默认映射到网格的x）
y: y ,, (默认映射到网格的 y)
层：此维度中的每个图像将混合成一个图像（默认映射到z）
淡入淡出：每张图片在下一张图片显示后会逐渐淡出（默认映射到选择）
row: 子图的行数（默认映射到空间）
columns: 子图的列数（默认映射到what）
所有这些映射都可以通过视觉参数进行更改，一些示例：
>>> df.viz.heatmap('x', 'y', what=['mean(x)', 'correlation(vx, vy)'])
将每个“what”绘制为一列。
>>> df.viz.heatmap('x', 'y', selection=['FeH < -3', '(FeH >= -3) & (FeH < -2)'], visual=dict(column='selection'))
将每个选择绘制为一列，而不是相互叠加的淡色。
- Parameters:
x – 在x方向上分箱的表达式（默认映射到x），或成对列表，如[[‘x’, ‘y’], [‘x’, ‘z’]]，如果给出多对，此维度默认映射到行
y – y (默认映射到 y)
z – 在z方向上分箱的表达式，后跟一个:start,end,shape签名，例如‘FeH:-3,1:5’将在-10到10之间生成5层（默认映射到层）
what – 要绘制的内容，count(*) 将显示一个 N 维直方图，mean('x') 表示 x 列的平均值，sum('x') 表示总和，std('x') 表示标准差，correlation('vx', 'vy') 表示相关系数。也可以是一个值列表，如 ['count(x)', std('vx')]（默认映射到列）
reduce
f – 通过以下方式转换值：'identity' 不做任何操作，'log' 或 'log10' 将显示值的对数
normalize – 归一化函数，目前仅支持 'normalize'
normalize_axis – 在哪些轴上进行归一化，None 表示通过全局最大值进行归一化。
vmin – 不使用自动归一化（使用 normalize 和 normalization_axis），将数据在 vmin 和 vmax 之间缩放到 [0, 1]
vmax – 参见 vmin
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
grid – 如果提供了 grid，则不再计算由 what 给出的统计量，而是使用这个 Nd-numpy 数组，这在计算自定义计算/统计量但仍然希望使用绘图机制时非常有用。
colormap – 使用的matplotlib颜色映射
figsize – 传递给 plt.figure 的 (x, y) 元组，用于设置图形大小
x轴标签
ylabel
aspect
tight_layout – 是否调用 plt.tight_layout
colorbar – 是否绘制颜色条
selection – 要使用的选择的名称（或为‘default’选择时为True），或所有数据（当选择为None或False时）
interpolation – imshow的插值方法，可能的选项有：'nearest', 'bilinear', 'bicubic'，更多信息请参见matplotlib
return_extra
- Returns:
- histogram(x=None, what='count(*)', grid=None, shape=64, facet=None, limits=None, figsize=None, f='identity', n=None, normalize_axis=None, xlabel=None, ylabel=None, label=None, selection=None, show=False, tight_layout=True, hardcopy=None, progress=None, **kwargs)#
绘制一个直方图。
示例：
>>> df.histogram(df.x) >>> df.histogram(df.x, limits=[0, 100], shape=100) >>> df.histogram(df.x, what='mean(y)', limits=[0, 100], shape=100)
如果你想自己进行计算，传递网格参数，但你需要负责传递相同的限制参数：
>>> counts = df.mean(df.y, binby=df.x, limits=[0, 100], shape=100)/100. >>> df.histogram(df.x, limits=[0, 100], shape=100, grid=means, label='mean(y)/100')
- Parameters:
x – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
what – 要绘制的内容，count(*) 将显示一个 N 维直方图，mean('x') 表示 x 列的平均值，sum('x') 表示 x 列的总和
grid – 如果提供了 grid，则不再计算由 what 给出的统计量，而是使用这个 Nd-numpy 数组，这在计算自定义计算/统计量但仍然希望使用绘图机制时非常有用。
shape – 用于计算统计量的数组的形状，如果只给出一个整数，则用于所有维度，例如 shape=128, shape=[128, 256]
facet – 用于生成分面图的表达式（facet='x:0,1,12' 将生成12个图，x的范围在0到1之间）
limits – 表达式的最小值和最大值的描述，例如 'minmax'（默认）、'99.7%'、[0, 10]，或一个列表，例如 [[0, 10], [0, 20], 'minmax']
figsize – 传递给 plt.figure 的 (x, y) 元组，用于设置图形大小
f – 通过以下方式转换值：'identity' 不做任何操作，'log' 或 'log10' 将显示值的对数
n – 归一化函数，目前仅支持‘normalize’，或None表示不进行归一化
normalize_axis – 在哪些轴上进行归一化，None 表示通过全局最大值进行归一化。
selection – 要使用的选择的名称（或为“默认”选择时为True），或所有数据（当选择为None或False时），或选择列表
xlabel – x轴上的标签字符串（可能包含latex）
ylabel – y轴同理
kwargs – 传递给 plt.plot 的额外参数
- Param:
tight_layout: 是否调用 plt.tight_layout
- Returns:
- scatter(x, y, xerr=None, yerr=None, cov=None, corr=None, s_expr=None, c_expr=None, labels=None, selection=None, length_limit=50000, length_check=True, label=None, xlabel=None, ylabel=None, errorbar_kwargs={}, ellipse_kwargs={}, **kwargs)#
使用散点图在二维中可视化少量数据
当处理小型DataFrames或选择时，plt.scatter的便捷包装器
- Parameters:
x – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
y – 以字符串形式表示的表达式，例如 'x' 或 'x+y'，或 vaex 表达式对象，例如 df.x 或 df.x+df.y
s_expr – 当提供时，将其用作 plt.scatter 的 s（大小）参数
c_expr – 当提供时，用于 plt.scatter 的 c（颜色）参数
labels – 使用这些文本值标注点
selection – 要使用的选择的名称（或为‘default’选择时为True），或所有数据（当选择为None或False时）
length_limit – 它将绘制的最大行数
length_check – 我们是否应该进行最大行检查？
label – 图例的标签
xlabel – x轴的标签，如果为None，则使用.label(x)
ylabel – y轴的标签，如果为None，则使用.label(y)
errorbar_kwargs – 传递给 plt.errorbar 的额外参数字典
kwargs – 传递给 plt.scatter 的额外参数
- Returns:
- class vaex.viz.ExpressionAccessorViz(expression)[source]#
基础类：
object- __weakref__#
对象的弱引用列表
- histogram(what='count(*)', grid=None, shape=64, facet=None, limits=None, figsize=None, f='identity', n=None, normalize_axis=None, xlabel=None, ylabel=None, label=None, selection=None, show=False, tight_layout=True, hardcopy=None, progress=None, **kwargs)[来源]#
绘制表达式的直方图。这是df.histogram(…)的一个便捷方法。
示例：
>>> df.x.histogram() >>> df.x.histogram(limits=[0, 100], shape=100) >>> df.x.histogram(what='mean(y)', limits=[0, 100], shape=100)
如果你想自己进行计算，传递网格参数，但你需要负责传递相同的限制参数：
>>> counts = df.mean(df.y, binby=df.x, limits=[0, 100], shape=100)/100. >>> df.plot1d(df.x, limits=[0, 100], shape=100, grid=means, label='mean(y)/100')
- Parameters:
x – 在x方向上分箱的表达式
what – 要绘制的内容，count(*) 将显示一个 N 维直方图，mean('x') 表示 x 列的平均值，sum('x') 表示 x 列的总和
grid – 如果已经由您自己完成了分箱操作，您可以传递它
facet – 用于生成分面图的表达式（facet='x:0,1,12' 将生成12个图，x的范围在0到1之间）
limits – [xmin, xmax] 的列表，或描述如 'minmax', '99%'
figsize – 传递给 plt.figure 的 (x, y) 元组，用于设置图形大小
f – 通过以下方式转换值：'identity' 不做任何操作，'log' 或 'log10' 将显示值的对数
n – 归一化函数，目前仅支持‘normalize’，或None表示不进行归一化
normalize_axis – 在哪些轴上进行归一化，None 表示通过全局最大值进行归一化。
normalize_axis
xlabel – x轴上的标签字符串（可能包含latex）
ylabel – y轴同理
kwargs – 传递给 plt.plot 的额外参数
- Param:
tight_layout: 是否调用 plt.tight_layout
- Returns: