vaex库的API文档

目录

vaex库的API文档#

快速列表#

打开/读取您的数据。#

vaex.open(path[, convert, progress, ...])

从给定路径的文件中打开一个DataFrame。

vaex.open_many(filenames)

打开一个文件名列表,并返回一个包含所有DataFrame连接后的DataFrame。

vaex.from_arrays(**arrays)

从numpy数组创建一个内存中的DataFrame。

vaex.from_arrow_dataset(arrow_dataset)

从Apache Arrow数据集创建一个DataFrame。

vaex.from_arrow_table(table)

从箭头表创建一个vaex DataFrame。

vaex.from_ascii(path[, seperator, names, ...])

从ASCII文件(默认以空格分隔)创建内存中的DataFrame。

vaex.from_astropy_table(table)

从Astropy表创建一个vaex DataFrame。

vaex.from_csv(filename_or_buffer[, ...])

将CSV文件加载为DataFrame,并可选择转换为HDF5文件。

vaex.from_csv_arrow(file[, read_options, ...])

使用Apache Arrow的快速CSV读取器。

vaex.from_dataset(dataset)

从Vaex数据集创建一个Vaex DataFrame

vaex.from_dict(data)

从字典创建一个内存中的数据集,字典的键为列名,值为列表或numpy数组

vaex.from_items(*items)

从numpy数组创建一个内存中的DataFrame,与from_arrays相比,这个方法保持了列的顺序(适用于Python < 3.6)。

vaex.from_json(path_or_buffer[, orient, ...])

一种使用pandas读取JSON文件并直接转换为DataFrame的方法。

vaex.from_pandas(df[, name, copy_index, ...])

从pandas DataFrame创建一个内存中的DataFrame。

vaex.from_records(records[, array_type, ...])

从字典列表创建数据框。

可视化.#

vaex.viz.DataFrameAccessorViz.heatmap([x, ...])

在二维直方图/热图中可视化数据。

vaex.viz.DataFrameAccessorViz.histogram([x, ...])

绘制直方图。

vaex.viz.DataFrameAccessorViz.scatter(x, y)

使用散点图可视化(少量)二维数据

统计.#

vaex.dataframe.DataFrame.correlation(x[, y, ...])

计算x和y之间的相关系数cov[x,y]/(std[x]*std[y]),可能在由binby定义的网格上。

vaex.dataframe.DataFrame.count([expression, ...])

计算非NaN值的数量(如果表达式为None或"*",则计算所有值的数量)。

vaex.dataframe.DataFrame.cov(x[, y, binby, ...])

计算x和y或多个表达式的协方差矩阵,可能在由binby定义的网格上。

vaex.dataframe.DataFrame.max(expression[, ...])

计算给定表达式的最大值,可能在由binby定义的网格上。

vaex.dataframe.DataFrame.mean(expression[, ...])

计算表达式的平均值,可能在由binby定义的网格上。

vaex.dataframe.DataFrame.median_approx(...)

计算中位数,可能在由 binby 定义的网格上。

vaex.dataframe.DataFrame.min(expression[, ...])

计算给定表达式的最小值,可能在由 binby 定义的网格上。

vaex.dataframe.DataFrame.minmax(expression)

计算表达式的最小值和最大值,可能在由binby定义的网格上。

vaex.dataframe.DataFrame.mode(expression[, ...])

计算/估计众数。

vaex.dataframe.DataFrame.mutual_information(x)

在形状为 mi_shape 和 mi_limits 的网格上估计 x 和 y 之间的互信息,可能在由 binby 定义的网格上。

vaex.dataframe.DataFrame.std(expression[, ...])

计算给定表达式的标准差,可能在由binby定义的网格上

vaex.dataframe.DataFrame.unique(expression)

返回所有唯一值。

vaex.dataframe.DataFrame.var(expression[, ...])

计算给定表达式的样本方差,可能在由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:

DataFrame

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:

DataFrame

vaex.from_arrow_dataset(arrow_dataset) DataFrame[source]#

从Apache Arrow数据集创建一个DataFrame。

vaex.from_arrow_table(table) DataFrame[source]#

从箭头表创建一个vaex DataFrame。

Parameters:

as_numpy – 将懒加载地将列转换为NumPy ndarray。

Return type:

DataFrame

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:

DataFrame

vaex.from_astropy_table(table)[source]#

从Astropy表创建一个vaex DataFrame。

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 (strfile) – 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 (boolstr) – 将文件转换为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_dataset(dataset: Dataset) DataFrame[source]#

从Vaex数据集创建一个Vaex 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:

DataFrame

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:

DataFrame

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.json

  • orient (str) – 预期JSON字符串格式的指示。允许的值为 split, records, index, columns, 和 values

  • precise_float (bool) – 设置为启用更高精度(strtod)函数,当将字符串解码为双精度值时。默认值(False)是使用快速但精度较低的内置功能。

  • lines (bool) – 将文件作为每行一个json对象读取。

Return type:

DataFrame

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:

DataFrame

vaex.from_records(records: List[Dict], array_type='arrow', defaults={}) DataFrame[source]#

从字典列表创建数据框。

警告

这仅是为了方便起见,为了提高性能,请将数组传递给from_arrays()

Parameters:
  • array_type (str) – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray” 用于 xarray.DataArray,或 “list”/“python” 用于 Python 列表

  • defaults (dict) – 如果记录缺少条目时的默认值

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:
  • path (strlist) – 文件的本地或绝对路径,或通配符字符串,或路径列表

  • 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:

DataFrame

注意:从版本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 访问:

示例:

>>> 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等。

Parameters:

filenames (list[str]) – 文件名/路径列表

Return type:

DataFrame

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 – 可用于优化此列的性能(评估)。

vaex.vrange(start, stop, step=1, dtype='f8')[source]#

创建一个虚拟列,相当于numpy.arange,但使用0内存

Parameters:
  • start (int) – 区间的开始。该区间包括此值。

  • stop (int) – 区间的结束。该区间不包括此值,

  • step (int) – 值之间的间距。

Dtype:

列的首选数据类型。

聚合与统计#

class vaex.stat.Expression[source]#

基础类:object

描述统计量的表达式

calculate(ds, binby=[], shape=256, limits=None, selection=None)[源代码]#

计算Dataset的统计量

vaex.stat.correlation(x, y)[source]#

创建一个标准差统计

vaex.stat.count(expression='*')[source]#

创建一个计数统计

vaex.stat.covar(x, y)[source]#

创建一个标准差统计量

vaex.stat.mean(expression)[source]#

创建一个均值统计量

vaex.stat.std(expression)[source]#

创建一个标准差统计

vaex.stat.sum(expression)[source]#

创建一个求和统计

class vaex.agg.AggregatorDescriptorKurtosis(name, expression, short_name='kurtosis', selection=None, edges=False)[source]#

基础类:AggregatorDescriptorMulti

class vaex.agg.AggregatorDescriptorMean(name, expressions, short_name='mean', selection=None, edges=False)[source]#

基础类:AggregatorDescriptorMulti

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]#

基础类:AggregatorDescriptorMulti

class vaex.agg.AggregatorDescriptorStd(name, expression, short_name='var', ddof=0, selection=None, edges=False)[source]#

基础类: AggregatorDescriptorVar

class vaex.agg.AggregatorDescriptorVar(name, expression, short_name='var', ddof=0, selection=None, edges=False)[来源]#

基础类:AggregatorDescriptorMulti

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.count(expression='*', selection=None, edges=False)[source]#

创建一个计数聚合

vaex.agg.first(expression, order_expression=None, selection=None, edges=False)[source]#

创建第一个聚合。

Parameters:
  • expression – {expression_one}.

  • order_expression – 使用此表达式对箱子中的值进行排序。

  • selection – {selection1}

  • edges – {edges}

vaex.agg.kurtosis(expression, selection=None, edges=False)[source]#

创建一个峰度聚合。

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.max(expression, selection=None, edges=False)[source]#

创建一个最大聚合

vaex.agg.mean(expression, selection=None, edges=False)[source]#

创建一个均值聚合

vaex.agg.min(expression, selection=None, edges=False)[source]#

创建一个最小聚合

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.agg.skew(expression, selection=None, edges=False)[源代码]#

创建一个偏斜聚合。

vaex.agg.std(expression, ddof=0, selection=None, edges=False)[source]#

创建一个标准差聚合

vaex.agg.sum(expression, selection=None, edges=False)[source]#

创建一个求和聚合

vaex.agg.var(expression, ddof=0, selection=None, edges=False)[source]#

创建一个方差聚合

缓存#

(目前处于实验阶段,使用需自担风险) 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:
vaex.cache.get(key, default=None, type=None)[source]#

查找键的缓存值,或返回默认值

如果缓存关闭,将返回 None。

Parameters:
  • key (str) – 缓存键。

  • default – 当缓存开启但键不在缓存中时返回

  • type – 当前未使用。

vaex.cache.is_on()[source]#

当缓存启用时返回True

vaex.cache.memory(maxsize='1GB', classname='LRUCache', clear=False)[source]#

使用cachetools设置内存缓存 (https://cachetools.readthedocs.io/).

多次调用时使用clear=False将保留当前缓存(在笔记本使用中很有用)。

Parameters:
  • maxsize (intstr) – 缓存的最大大小,以字节为单位(或使用类似 '128MB' 的字符串)

  • classname (str) – 用于缓存的cachetools库中的类名(例如LRUCache, MRUCache)。

  • clear (bool) – 如果为False,将始终设置一个新的缓存;如果为True,当缓存类型相同时,将保留缓存。

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
Parameters:
  • key (str) – 用于缓存的键

  • type – 当前未使用。

  • duration_wallclock (float) – 计算结果的耗时(以挂钟时间计)。

  • value – 任何值,通常需要是可序列化的(除非存储在内存中)

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])
__dataframe__(nan_as_null: bool = False, allow_copy: bool = True)[来源]#
__delitem__(item)[source]#

df.drop(item, inplace=True) 的别名

__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
__init__(name=None, executor=None)[source]#
__iter__()[来源]#

遍历列名。

__len__()[来源]#

返回DataFrame中的行数(应用了过滤)。

__repr__()[source]#

返回 repr(self)。

__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]
__str__()[source]#

返回 str(self)。

__weakref__#

对象的弱引用列表

add_column(name, f_or_array, dtype=None)[来源]#

将内存中的数组添加为一列。

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:

一个延迟求值的函数。

byte_size(selection=False, virtual=False)[来源]#

返回整个DataFrame(或所选部分)所需的字节大小,考虑active_fraction。

cat(i1, i2, format='html')[source]#

显示从第 i1 行到第 i2 行的 DataFrame

有关格式,请参见 https://pypi.org/project/tabulate/

Parameters:
  • i1 (int) – 起始行

  • i2 (int) – 结束行。

  • format (str) – 使用的格式,例如 'html', 'plain', 'latex'

close()[来源]#

关闭任何可能打开的文件句柄或其他资源,之后DataFrame将无法使用。

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定义的网格上进行。

xy 参数可以是单个表达式或表达式列表。 - 如果 xy 是单个表达式,则计算 xy 之间的相关性; - 如果 x 是表达式列表且 y 是单个表达式,则计算 x 中每个表达式与 y 中表达式之间的相关性; - 如果 x 是表达式列表且 y 为 None,则计算 x 中所有表达式之间的相关矩阵; - 如果 x 是长度为 2 的元组列表,则计算指定维度对的相关性; - 如果 xy 是表达式列表,则计算由两个表达式列表定义的相关矩阵。

示例:

>>> 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')
Parameters:
  • array_type (str) – ‘numpy’, ‘arrow’ 或 None,用于指示是否应转换数据类型

  • axis (int) – 如果是一个嵌套类型(如列表),它将返回嵌套类型的 value_type,深度为 axis 层。

delete_variable(name)[source]#

从DataFrame中删除一个变量。

delete_virtual_column(name)[source]#

从DataFrame中删除一个虚拟列。

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
Parameters:
  • strings (bool) – 是否描述字符串列

  • virtual (bool) – 描述是否为虚拟列

  • selection – 可选的选择使用。

Returns:

Pandas 数据框

diff(periods=1, column=None, fill_value=None, trim=False, inplace=False, reverse=False)[source]#

计算当前行与偏移periods行的差异

Parameters:
  • periods (int) – 与哪一行进行差异计算

  • column (strlist[str]) – 要使用的列或列列表(默认为全部)。

  • fill_value – 用于替代缺失值的值。

  • trim (bool) – 不包括那些原本会有缺失值的行

  • reverse (bool) – 当为真时,计算 row[periods] - row[current]

  • inplace – 如果为True,则对自身进行修改,否则返回一个新的DataFrame

drop(columns, inplace=False, check=True)[source]#

删除列(或单个列)。

Parameters:
  • columns – 列名列表或单个列名

  • inplace – 如果为True,则对自身进行修改,否则返回一个新的DataFrame

  • check – 当为true时,它将检查该列是否用于虚拟列或过滤器中,并隐藏它。

drop_filter(inplace=False)[source]#

从DataFrame中移除所有过滤器

dropinf(column_names=None, how='any')[source]#

创建一个DataFrame的浅拷贝,使用isinf设置过滤。

Parameters:
  • column_names – 要考虑的列,默认值:所有(实际,非虚拟)列

  • how (str) – 其中之一为 ("any", "all")。 如果为 "any",则删除任何列中包含 inf 的行。 如果为 "all",则删除所有列中都包含 inf 的行。

Return type:

DataFrame

dropmissing(column_names=None, how='any')[来源]#

创建一个DataFrame的浅拷贝,使用ismissing设置过滤。

Parameters:
  • column_names – 要考虑的列,默认值:所有(真实,非虚拟)列

  • how (str) – 其中之一为 ("any", "all")。 如果为 "any",则删除任何列缺失的行。 如果为 "all",则删除所有列缺失的行。

Return type:

DataFrame

dropna(column_names=None, how='any')[source]#

创建一个DataFrame的浅拷贝,使用isna设置过滤。

Parameters:
  • column_names – 要考虑的列,默认值:所有(实际,非虚拟)列

  • how (str) – 其中之一为 ("any", "all")。 如果为 "any",则删除任何列中包含 na 的行。 如果为 "all",则删除所有列中都包含 na 的行。

Return type:

DataFrame

dropnan(column_names=None, how='any')[source]#

创建一个DataFrame的浅拷贝,使用isnan设置过滤。

Parameters:
  • column_names – 要考虑的列,默认值:所有(真实,非虚拟)列

  • how (str) – 其中之一为 ("any", "all")。 如果为 "any",则删除任何列中包含 nan 的行。 如果为 "all",则删除所有列中都包含 nan 的行。

Return type:

DataFrame

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

Parameters:
  • expression (str) – 要评估的名称/表达式

  • i1 (int) – 起始行索引,默认为开始(0)

  • i2 (int) – 结束行索引,默认是DataFrame的长度

  • out (ndarray) – 输出数组,结果可以写入此数组(可用于重用数组或写入内存映射数组)

  • progress – {progress}

  • selection – 要应用的选择

Returns:

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 – 在当前值被生成/返回的同时,预取/计算下一个块。

evaluate_variable(name)[source]#

评估由名称给出的变量。

execute()[源代码]#

执行所有延迟的任务。

async execute_async()[source]#

异步版本的执行

extract()[源代码]#

返回一个仅包含过滤行的DataFrame。

注意

请注意,不会复制基础数据,只会创建视图/引用。

当原始DataFrame被大量过滤(仅包含少量行)时,生成的DataFrame可能更高效。

如果没有应用过滤,它将返回一个修剪后的视图。 对于返回的df,len(df) == df.length_original() == df.length_unfiltered()

Return type:

DataFrame

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
Parameters:
  • value (float) – 用于填充 nan 或掩码值的值。

  • fill_na (bool) – 如果为True,则用value填充np.nan值。

  • fill_masked (bool) – 如果为True,则用values填充被屏蔽的值。

  • column_names (list) – 要填充缺失值的列名列表。

  • prefix (str) – 给原始列的前缀。

  • inplace – 如果为True,则对自身进行修改,否则返回一个新的DataFrame

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
fingerprint(dependencies=None, treeshake=False)[来源]#

唯一标识数据帧的ID(跨运行时)。

Parameters:
  • dependencies (set[str]) – 要使用的列、虚拟列、函数或选择名称的集合。

  • treeshake (bool) – 在计算指纹之前去除未使用的变量。

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_active_fraction()[source]#

值在范围 (0, 1] 内,仅用于处理行的子集。

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']
Parameters:
  • virtual – 如果为False,跳过虚拟列

  • hidden – 如果为False,跳过隐藏列

  • strings – 如果为False,跳过字符串列

  • regex – 仅返回匹配(可选)正则表达式的列名

  • dtype – 仅返回具有给定数据类型的列名。可以是单个数据类型或数据类型列表。

Return type:

liststr

get_current_row()[来源]#

可以“选择”单个行,这是当前行的索引(整数),如果没有选择任何内容,则为None。

get_names(hidden=False)[来源]#

返回列名和变量名的列表。

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_selection(name='default')[来源]#

获取当前选择对象(目前主要用于内部使用)。

get_variable(name)[source]#

返回由名称给定的变量,它不会对其进行评估。

用于评估,请参见 DataFrame.evaluate_variable(),另请参见 DataFrame.set_variable()

has_current_row()[来源]#

如果当前有选中的行,则返回 True/False。

has_selection(name='default')[source]#

如果存在具有给定名称的选择,则返回 True。

head(n=10)[source]#

返回一个包含前n行的DataFrame的浅拷贝。

head_and_tail_print(n=5)[source]#

显示DataFrame的前n个和后n个元素。

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:

is_category(column)[source]#

如果列是类别,则返回 true。

is_local()[来源]#

如果DataFrame是本地的,则返回True;如果DataFrame是远程的,则返回False。

is_masked(column)[source]#

返回列是否为掩码(numpy.ma)列。

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

length_original()[source]#

DataFrame 的完整长度,与 active_fraction 或过滤无关。这是底层 ndarrays 的实际长度。

length_unfiltered()[source]#

应考虑的数组长度(尊重活动范围),但不进行过滤。

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定义的网格上。

xy 参数可以是单个表达式或表达式列表: - 如果 xy 是单个表达式,则计算 xy 之间的互信息; - 如果 x 是表达式列表且 y 是单个表达式,则计算 x 中每个表达式与 y 中表达式之间的互信息; - 如果 x 是表达式列表且 y 为 None,则计算 x 中所有表达式之间的互信息矩阵; - 如果 x 是长度为 2 的元组列表,则计算指定维度对的互信息; - 如果 xy 是表达式列表,则计算由两个表达式列表定义的互信息矩阵。

如果 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

plot_widget(x, y, limits=None, f='identity', **kwargs)[source]#

已弃用:请使用 df.widget.heatmap

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' 在未找到条目时会报错。

remove_virtual_meta()[source]#

移除带有虚拟列等的文件,它不会改变当前的虚拟列等。

rename(name, new_name, unique=False)[来源]#

重命名列或变量,并重写表达式,使其引用新名称

rolling(window, trim=False, column=None, fill_value=None, edge='right')[source]#

创建一个 vaex.rolling.Rolling 滚动窗口对象

Parameters:
  • window (int) – 滚动窗口的大小。

  • trim (bool) – 修剪数据框的开始或结束以避免缺失值

  • column (strlist[str]) – 受影响的列名或列名列表(None 表示所有列)

  • fill_value (any) – 用于现有行之外数据的标量值。

  • edge (str) – 当前行的滚动窗口边缘位置。

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
Parameters:
  • n (int) – 要抽取的样本数量(如果frac为None,则默认为1)

  • frac (float) – 要获取的取数的分数部分

  • replace (bool) – 如果为真,一行可能会被多次绘制

  • weights (strexpression) – (未归一化的)行被抽取的概率

  • RandomState (int 或) – 设置一个种子或 RandomState 以确保可重复性。当为 None 时,将选择一个随机种子。

Returns:

返回一个新的DataFrame,其中包含基础数据的浅拷贝/视图

Return type:

DataFrame

schema()[source]#

类似于 df.dtypes,但返回一个字典

schema_arrow(reduce_large=False)[source]#

类似于 schema(),但返回一个箭头模式

Parameters:

reduce_large (bool) – 将大字符串转换为普通字符串

select(boolean_expression, mode='replace', name='default', executor=None)[来源]#

执行一个选择,由布尔表达式定义,并使用给定的模式与之前的选择结合。

选择记录在每个名称的历史树中,可以分别对它们进行撤销/重做。

Parameters:
  • boolean_expression (str) – 任何有效的列表达式,带有比较运算符

  • mode (str) – 可能的布尔运算符:replace/and/or/xor/subtract

  • name (str) – 要使用的历史树或选择“槽”

  • 执行器

Returns:

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]#

出于性能原因,套索选择的处理方式有所不同。

Parameters:
  • expression_x (str) – x坐标的名称/表达式

  • expression_y (str) – y坐标的名称/表达式

  • xsequence – 定义lasso的x数字列表,与y一起

  • ysequence

  • mode (str) – 可能的布尔运算符:replace/and/or/xor/subtract

  • name (str)

  • 执行器

Returns:

select_non_missing(drop_nan=True, drop_masked=True, column_names=None, mode='replace', name='default')[source]#

创建一个选择,选择在column_names中的所有列都具有非缺失值的行。

名称反映了Pandas,实际上没有删除任何行,而是保留了一个掩码来跟踪选择

Parameters:
  • drop_nan – 在任何列中存在NaN时删除行(仅影响浮点数值)

  • drop_masked – 在任何列中存在掩码值时删除行

  • column_names – 要考虑的列,默认值:所有(真实,非虚拟)列

  • mode (str) – 可能的布尔运算符:replace/and/or/xor/subtract

  • name (str) – 要使用的历史树或选择“槽”

Returns:

select_nothing(name='default')[source]#

不选择任何内容。

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)] 的序列

  • 模式

selected_length()[来源]#

返回所选行的数量。

selection_can_redo(name='default')[source]#

选择名称可以重新做吗?

selection_can_undo(name='default')[source]#

选择名称可以撤销吗?

selection_redo(name='default', executor=None)[source]#

重新选择名称。

selection_undo(name='default', executor=None)[source]#

撤销选择,针对名称。

set_active_fraction(value)[source]#

设置active_fraction,将选中的行设置为None,并移除选择。

待办事项:如果我们保留表达式以及选定的行,我们可能能够保留选择

set_active_range(i1, i2)[来源]#

设置active_fraction,将选中的行设置为None,并移除选择。

待办事项:如果我们保留表达式以及选中的行,我们可能能够保留选择

set_current_row(value)[来源]#

设置当前行,并发出信号 signal_pick。

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数量的行进行移动。

Parameters:
  • periods (int) – 将列向前移动(当为正数时)或向后移动(当为负数时)

  • column (strlist[str]) – 要移动的列或列列表(默认为所有列)。

  • fill_value – 用于替代缺失值的值。

  • trim (bool) – 不包括那些原本会有缺失值的行

  • inplace – 如果为True,则对自身进行修改,否则返回一个新的DataFrame

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:

DataFrame

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
Parameters:
  • by (strexpressionliststr/expressions) – 用于排序的表达式。

  • ascending (boollistbools) – 升序(默认,True)或降序(False)。

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:

list

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()

Parameters:
  • file (str) – 文件名(以 .json 或 .yaml 结尾)

  • use_active_range (bool) – 是否使用活动范围。

  • keep_columns (list) – 如果要设置的状态包含较少的列,则应保留的列列表。

  • set_filter (bool) – 从状态设置过滤器(默认),或保持过滤器不变。

  • fs_options (dict) – 传递给文件系统处理程序(s3fs 或 gcsfs)的参数

  • fs – ‘直接传递一个文件系统对象,参见 vaex.open()

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参数时为一个标量,包含统计量

tail(n=10)[source]#

返回一个包含最后n行的DataFrame的浅拷贝。

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:

DataFrame

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:

DataFrame

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

validate_expression(expression)[source]#

验证一个表达式(可能会抛出异常)

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)

如果任何列包含掩码数组,掩码将被忽略(即掩码元素也会被返回)。

__call__(*expressions, **kwargs)[source]#

DataFrame.__call__() 的本地实现

__getstate__()[source]#

用于pickle的助手。

__init__(dataset=None, name=None)[来源]#
as_arrow()[来源]#

将所有列延迟转换为arrow类型,除了对象类型。

as_numpy(strict=False)[source]#

将所有数值列惰性转换为numpy。

如果 strict 为 True,它还将强制转换非数值类型。

binby(by=None, agg=None, sort=False, copy=True, delay=False, progress=None)[来源]#

当agg不为None时,返回一个BinByDataArray对象

binby 操作不会返回一个“扁平”的 DataFrame,而是返回一个以 xarray 形式表示的 N 维网格。

Parameters:
  • agg (dict, list or agg) – 聚合操作,可以是字符串形式、vaex.agg对象、字典(其中键表示目标列名,值表示操作)或聚合列表。如果未提供,将返回binby对象。

  • copy (bool) – 复制数据框(浅复制,不占用内存),以便原始数据框的指纹不被修改。

  • delay (bool) – 不返回结果,而是返回一个用于异步计算的代理(目前仅限内部使用)

  • progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消

Returns:

DataArrayBinBy 对象。

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}

Parameters:
  • column_names (list) – 用于DataFrame副本的列的子集。如果为None,则复制所有列。

  • treeshake (bool) – 去除未使用的变量。

Return type:

DataFrame

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.RecordBatchFileWriterpyarrow.parquet.ParquetWriter

  • progress – 如果为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文件。

Parameters:
  • path (str) – 文件路径

  • progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消

  • chunk_size (int) – 每次迭代写入磁盘的行数

  • parallel – 并行评估(虚拟)列

  • kwargs – 传递给 pandas.DataFrame.to_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.

另请参阅 https://arrow.apache.org/docs/python/feather.html

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时,返回一个GroupByDataFrame对象

示例:

>>> 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) – 对我们分组的列进行排序。

  • ascending (boollistbools) – 升序(默认,True)或降序(False)。

  • assume_sparse (boolstr) – 假设在按多个键分组时,现有的键值对相对于笛卡尔积是稀疏的。 如果为‘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:

DataFrameGroupBy 对象。

hashed(inplace=False) DataFrame[source]#

返回一个包含哈希数据集的DataFrame

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时,它将具体化序数代码。

selected_length(selection='default')[source]#

DataFrame.selected_length() 的本地实现

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 访问

__init__(expression)[source]#
__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]#

基础类:object

Expression 类

__abs__()[源代码]#

返回表达式的绝对值

__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#
__init__(ds, expression, ast=None, _selection=False)[源代码]#
__le__(b)#

返回 self<=value。

__lt__(b)#

返回 self

__ne__(b)#

返回 self 不等于 value。

__or__(b)#

返回 self|value。

__repr__()[源代码]#

返回 repr(self)。

__ror__(b)#

返回值|自身。

__str__()[source]#

返回 str(self)。

__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)

cos(**kwargs)#

围绕numpy.cos的惰性包装器

cosh(**kwargs)#

围绕numpy.cosh的惰性包装器

count(binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None)[source]#

ds.count(expression, …) 的快捷方式,参见 Dataset.count

countmissing()[source]#

返回表达式中缺失值的数量。

countna()[source]#

返回表达式中不可用(N/A)值的数量。 这包括缺失值和np.nan值。

countnan()[source]#

返回表达式中NaN值的数量。

deg2rad(**kwargs)#

围绕numpy.deg2rad的懒加载包装器

dependencies()[source]#

获取此表达式的所有依赖项,包括我们自己

digitize(**kwargs)#

围绕 numpy.digitize 的惰性包装器

dot_product(b)#

计算ab之间的点积。

Parameters:
  • a – 一个表达式列表或一个值列表(例如一个向量)

  • b – 一个表达式列表或一个值列表(例如一个向量)

Returns:

Vaex 表达式

property dt#

通过DateTime提供对日期时间操作的访问

exp(**kwargs)#

围绕numpy.exp的懒加载包装器

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的懒加载包装器

fillmissing(value)[源代码]#

返回一个数组,其中缺失值被替换为指定值。

参见:ismissing 了解缺失值的定义。

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

log(**kwargs)#

围绕 numpy.log 的惰性包装器

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

nop()[source]#

评估表达式,并丢弃结果,对于基准测试非常有用,因为vaex通常是惰性的

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 的惰性包装器

sin(**kwargs)#

围绕numpy.sin的惰性包装器

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 将展平数组或列表)

tan(**kwargs)#

围绕numpy.tan的惰性包装器

tanh(**kwargs)#

围绕numpy.tanh的惰性包装器

property td#

通过TimeDelta提供对时间差操作的访问

to_arrow(convert_to_native=False)[source]#

转换为Apache Arrow数组(如果convert_to_native=True,将进行字节交换/复制)。

to_numpy(strict=True)[source]#

返回数据的numpy表示

to_pandas_series()[来源]#

返回表达式的pandas.Series表示。

注意:Pandas 可能会对数据进行内存复制。

to_string()#

转换为字符串,与 expression.astype(‘str’) 相同

tolist(i1=None, i2=None)[source]#

expr.evaluate().tolist() 的缩写

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:
  • dropna – 删除包含不可用(NA)值(NaN 或缺失值)的行。

  • dropnan – 删除包含NaN值的行

  • dropmissing – 删除包含缺失值的行

  • ascending – 当为 False(默认)时,它将首先报告出现频率最高的项目

  • progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消

  • axis (bool) – 确定唯一元素的轴(None 将展平数组或列表)

  • delay (bool) – 不返回结果,而是返回一个用于异步计算的代理(目前仅限内部使用)

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)#

根据conditionxy中按行返回值。

当您想根据某些条件创建时,这是一个有用的函数。 如果条件为真,则取x的值,否则取y的值。 考虑语法的一个简单方法是df.func.where(“if”, “then”, “else”)。 请参见下面的示例。

注意:如果该函数用作表达式的方法,则假定该表达式为条件。

Parameters:
  • condition – 一个布尔表达式

  • x – 单个值或表达式,如果条件满足,则传递该值。

  • y – 单个值或表达式,如果条件不满足时传递的值。

  • dtype – 可选地指定结果表达式的数据类型

Return type:

Expression

示例:

>>> 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()
__init__(df)[来源]#
__weakref__#

对象的弱引用列表

bearing(lon1, lat1, lon2, lat2, bearing='bearing', inplace=False)[来源]#

基于http://www.movable-type.co.uk/scripts/latlong.html计算方位角

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]#

二维旋转。

Parameters:
  • x (str) – x列的名称/表达式

  • y (str) – y 的 idem

  • xnew (str) – 转换后的x列的名称

  • ynew (str)

  • angle_degrees (float) – 旋转角度,逆时针方向

Returns:

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设置日志记录。

请参阅日志配置如何配置日志记录。

vaex.logging.remove_handler()[源代码]#

禁用日志记录,移除默认处理器并添加空处理器

vaex.logging.reset()[source]#

重置日志配置(即移除默认处理程序)

vaex.logging.set_log_level(loggers=['vaex'], level=10)[source]#

将日志级别设置为调试

vaex.logging.set_log_level_debug(loggers=['vaex'])[source]#

将日志级别设置为调试

vaex.logging.set_log_level_error(loggers=['vaex'])[source]#

将日志级别设置为异常/错误

vaex.logging.set_log_level_info(loggers=['vaex'])