vaex库的API文档#
快速列表#
打开/读取您的数据。#
|
从给定路径的文件中打开一个DataFrame。 |
|
打开一个文件名列表,并返回一个包含所有DataFrame连接后的DataFrame。 |
|
从numpy数组创建一个内存中的DataFrame。 |
|
从Apache Arrow数据集创建一个DataFrame。 |
|
从箭头表创建一个vaex DataFrame。 |
|
从ASCII文件(默认以空格分隔)创建内存中的DataFrame。 |
|
从Astropy表创建一个vaex DataFrame。 |
|
将CSV文件加载为DataFrame,并可选择转换为HDF5文件。 |
|
使用Apache Arrow的快速CSV读取器。 |
|
从Vaex数据集创建一个Vaex DataFrame |
|
从字典创建一个内存中的数据集,字典的键为列名,值为列表或numpy数组 |
|
从numpy数组创建一个内存中的DataFrame,与from_arrays相比,这个方法保持了列的顺序(适用于Python < 3.6)。 |
|
一种使用pandas读取JSON文件并直接转换为DataFrame的方法。 |
|
从pandas DataFrame创建一个内存中的DataFrame。 |
|
从字典列表创建数据框。 |
可视化.#
|
在二维直方图/热图中可视化数据。 |
|
绘制直方图。 |
使用散点图可视化(少量)二维数据 |
统计.#
|
计算x和y之间的相关系数cov[x,y]/(std[x]*std[y]),可能在由binby定义的网格上。 |
|
计算非NaN值的数量(如果表达式为None或"*",则计算所有值的数量)。 |
|
计算x和y或多个表达式的协方差矩阵,可能在由binby定义的网格上。 |
|
计算给定表达式的最大值,可能在由binby定义的网格上。 |
|
计算表达式的平均值,可能在由binby定义的网格上。 |
计算中位数,可能在由 binby 定义的网格上。 |
|
|
计算给定表达式的最小值,可能在由 binby 定义的网格上。 |
|
计算表达式的最小值和最大值,可能在由binby定义的网格上。 |
|
计算/估计众数。 |
在形状为 mi_shape 和 mi_limits 的网格上估计 x 和 y 之间的互信息,可能在由 binby 定义的网格上。 |
|
|
计算给定表达式的标准差,可能在由binby定义的网格上 |
|
返回所有唯一值。 |
|
计算给定表达式的样本方差,可能在由binby定义的网格上 |
vaex-core#
Vaex 是一个用于处理大于内存的 DataFrame(核心外)的库。
在vaex中最重要的类(数据结构)是DataFrame
。DataFrame可以通过打开示例数据集来获得:
>>> import vaex
>>> df = vaex.example()
或者使用 open()
来打开一个文件。
>>> df1 = vaex.open("somedata.hdf5")
>>> df2 = vaex.open("somedata.fits")
>>> df2 = vaex.open("somedata.arrow")
>>> df4 = vaex.open("somedata.csv")
或者连接到远程服务器:
>>> df_remote = vaex.open("http://try.vaex.io/nyc_taxi_2015")
vaex 的几个强大特性包括:
性能:能够处理巨大的表格数据,每秒处理超过十亿(> 109)行。
表达式系统 / 虚拟列:动态计算,不浪费内存。
内存高效:在进行过滤/选择/子集操作时无需内存复制。
可视化:直接支持,通常一行代码就足够了。
用户友好的API:您只需要处理一个DataFrame对象,标签补全和文档字符串将帮助您:ds.mean
,感觉与Pandas非常相似。 在N维网格上进行非常快速的统计,例如直方图、运行均值、热图。
按照教程 https://docs.vaex.io/en/latest/tutorial.html 学习如何使用 vaex。
- vaex.concat(dfs, resolver='flexible') DataFrame [source]#
连接一个DataFrame列表。
- Parameters:
resolver – 如何解决模式冲突,请参见
DataFrame.concat()
。
- vaex.delayed(f)[source]#
装饰器用于透明地接受延迟计算。
示例:
>>> delayed_sum = ds.sum(ds.E, binby=ds.x, limits=limits, >>> shape=4, delay=True) >>> @vaex.delayed >>> def total_sum(sums): >>> return sums.sum() >>> sum_of_sums = total_sum(delayed_sum) >>> ds.execute() >>> sum_of_sums.get() See the tutorial for a more complete example https://docs.vaex.io/en/latest/tutorial.html#Parallel-computations
- vaex.example()[source]#
33个卫星星系在银河系暗物质晕中吸积的N体模拟结果。
数据由Helmi & de Zeeuw于2000年创建。 数据包含粒子的位置(x, y, z)、速度(vx, vy, vz)、能量(E)、 角动量(L, Lz)和铁含量(FeH)。
- Return type:
- vaex.from_arrays(**arrays) DataFrameLocal [来源]#
从numpy数组创建一个内存中的DataFrame。
Example
>>> import vaex, numpy as np >>> x = np.arange(5) >>> y = x ** 2 >>> vaex.from_arrays(x=x, y=y) # x y 0 0 0 1 1 1 2 2 4 3 3 9 4 4 16 >>> some_dict = {'x': x, 'y': y} >>> vaex.from_arrays(**some_dict) # in case you have your columns in a dict # x y 0 0 0 1 1 1 2 2 4 3 3 9 4 4 16
- Parameters:
arrays – 带有数组的关键字参数
- Return type:
- vaex.from_arrow_table(table) DataFrame [source]#
从箭头表创建一个vaex DataFrame。
- Parameters:
as_numpy – 将懒加载地将列转换为NumPy ndarray。
- Return type:
- vaex.from_ascii(path, seperator=None, names=True, skip_lines=0, skip_after=0, **kwargs)[source]#
从ASCII文件(默认情况下以空格分隔)创建一个内存中的DataFrame。
>>> ds = vx.from_ascii("table.asc") >>> ds = vx.from_ascii("table.csv", seperator=",", names=["x", "y", "z"])
- Parameters:
path – 文件路径
seperator – 值分隔符,默认为空格,使用“,”表示逗号分隔的值。
names – 如果为True,第一行将用作列名,否则提供一个字符串列表作为名称
skip_lines – 跳过文件开头的行
skip_after – 跳过文件末尾的行
kwargs
- Return type:
- vaex.from_csv(filename_or_buffer, copy_index=False, chunk_size=None, convert=False, fs_options={}, progress=None, fs=None, **kwargs)[source]#
将CSV文件加载为DataFrame,并可选择转换为HDF5文件。
- Parameters:
filename_or_buffer (str 或 file) – CSV 文件路径或类文件对象
copy_index (bool) – 当通过Pandas读取源时复制索引
chunk_size (int) –
如果CSV文件太大无法一次性加载到内存中,可以使用此参数分块读取CSV文件。例如:
>>> import vaex >>> for i, df in enumerate(vaex.read_csv('taxi.csv', chunk_size=100_000)): >>> df = df[df.passenger_count < 6] >>> df.export_hdf5(f'taxi_{i:02}.hdf5')
convert (bool 或 str) – 将文件转换为hdf5文件以进行优化,也可以是一个路径。CSV文件将分块读取:使用提供的chunk_size参数或默认大小。每个块将保存为一个单独的hdf5文件,然后将它们全部合并为一个hdf5文件。因此,对于一个大CSV文件,您将需要至少双倍的额外磁盘空间。转换的默认chunk_size为500万行,对应于NYC Taxi数据集示例中的大约1Gb内存。
progress – (仅当 convert 不为 False 时适用) True 表示显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于 0 和 1 之间的浮点值)表示进度,当此可调用对象返回 False 时,计算将被取消
kwargs – 额外的关键字参数,目前传递给Pandas的read_csv函数,但实现可能在未来的版本中发生变化。
- Returns:
DataFrame
- vaex.from_dict(data)[source]#
从字典创建一个内存数据集,其中列名作为键,列表/NumPy数组作为值
Example
>>> data = {'A':[1,2,3],'B':['a','b','c']} >>> vaex.from_dict(data) # A B 0 1 'a' 1 2 'b' 2 3 'c'
- Parameters:
data – 一个字典,格式为 {列名:[值, 值,…]}
- Return type:
- vaex.from_items(*items)[source]#
从numpy数组创建一个内存中的DataFrame,与from_arrays相比,这个方法保持了列的原始顺序(适用于Python < 3.6)。
Example
>>> import vaex, numpy as np >>> x = np.arange(5) >>> y = x ** 2 >>> vaex.from_items(('x', x), ('y', y)) # x y 0 0 0 1 1 1 2 2 4 3 3 9 4 4 16
- Parameters:
items – [(名称, numpy 数组), …] 的列表
- Return type:
- vaex.from_json(path_or_buffer, orient=None, precise_float=False, lines=False, copy_index=False, **kwargs)[source]#
一种使用pandas读取JSON文件并直接转换为DataFrame的方法。
- Parameters:
path_or_buffer (str) – 一个有效的JSON字符串或类文件对象,默认值:None 该字符串可以是一个URL。有效的URL方案包括http、ftp、s3、 gcs和file。对于文件URL,需要指定主机。例如,本地 文件可以是
file://localhost/path/to/table.json
orient (str) – 预期JSON字符串格式的指示。允许的值为
split
,records
,index
,columns
, 和values
。precise_float (bool) – 设置为启用更高精度(strtod)函数,当将字符串解码为双精度值时。默认值(False)是使用快速但精度较低的内置功能。
lines (bool) – 将文件作为每行一个json对象读取。
- Return type:
- vaex.from_pandas(df, name='pandas', copy_index=False, index_name='index')[来源]#
从pandas DataFrame创建一个内存中的DataFrame。
- Param:
pandas.DataFrame df: Pandas 数据框
- Param:
名称: 对于DataFrame是唯一的
>>> import vaex, pandas as pd >>> df_pandas = pd.from_csv('test.csv') >>> df = vaex.from_pandas(df_pandas)
- Return type:
- vaex.from_records(records: List[Dict], array_type='arrow', defaults={}) DataFrame [source]#
从字典列表创建数据框。
警告
这仅是为了方便起见,为了提高性能,请将数组传递给
from_arrays()
。
- vaex.open(path, convert=False, progress=None, shuffle=False, fs_options={}, fs=None, *args, **kwargs)[source]#
从路径指定的文件中打开一个DataFrame。
示例:
>>> df = vaex.open('sometable.hdf5') >>> df = vaex.open('somedata*.csv', convert='bigdata.hdf5')
- Parameters:
convert – 当convert是一个路径时,使用dataframe.export。如果为True,
convert=path+'.hdf5'
如果输入文件或转换参数没有改变,则跳过转换。progress – (仅当 convert 不为 False 时适用) True 表示显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于 0 和 1 之间的浮点值)表示进度,当此可调用对象返回 False 时,计算将被取消
shuffle (bool) – 是否对转换后的DataFrame进行洗牌
fs_options (dict) – 如果需要,传递给可选文件系统的额外参数。请参见下文
group – (可选)指定要从HDF5文件中读取的组。默认情况下,此值设置为“/table”。
fs – Apache Arrow 文件系统对象,或 FSSpec 文件系统对象,如果指定了,fs_options 应为空。
args – 文件读取器所需的额外参数
kwargs – 额外的关键字参数
- Returns:
成功时返回一个DataFrame,否则返回None
- Return type:
注意:从版本4.14.0开始,vaex.open()将惰性读取CSV文件。 如果您希望将整个CSV文件读入内存,请使用vaex.from_csv()或vaex.from_csv_arrow()代替。
云存储支持:
Vaex 支持从 Amazon AWS S3 和 Google Cloud Storage 流式传输 HDF5 文件。 文件默认缓存在 $HOME/.vaex/file-cache/(s3|gs) 中,以便后续访问速度与本地磁盘访问一样快。
亚马逊AWS S3选项:
以下常见的 fs_options 用于 S3 访问:
anon: 是否使用匿名访问(默认为false)。(允许的值为:true,True,1,false,False,0)
anonymous - anon的别名
cache: 是否使用磁盘缓存,仅在数据应仅访问一次时设置为false。(允许的值为:true,True,1,false,False,0)
access_key - AWS 访问密钥,如果未提供,将使用标准环境变量或 ~/.aws/credentials 文件
secret_key - AWS 密钥,类似于 access_key
profile - 如果~/.aws/credentials中存在多个配置文件,选择此配置文件而不是‘default’,请参阅https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html
region - AWS 区域,例如 'us-east-1',如果未提供将自动确定。
endpoint_override - 连接的URL/ip,而不是AWS,例如minio的‘localhost:9000’
所有 fs_options 也可以作为查询字符串编码在文件路径中。
示例:
>>> df = vaex.open('s3://vaex/taxi/nyc_taxi_2015_mini.hdf5?anon=true', fs_options={'anonymous': True}) >>> df = vaex.open('s3://vaex/taxi/nyc_taxi_2015_mini.hdf5?anon=true?anon=true') >>> df = vaex.open('s3://mybucket/path/to/file.hdf5', fs_options={'access_key': my_key, 'secret_key': my_secret_key}) >>> df = vaex.open(f's3://mybucket/path/to/file.hdf5?access_key={my_key}&secret_key={my_secret_key}') >>> df = vaex.open('s3://mybucket/path/to/file.hdf5?profile=myproject')
Google 云存储选项:
以下 fs_options 用于 GCP 访问:
token: GCP的认证方法。使用‘anon’进行匿名访问。更多详情请参见https://gcsfs.readthedocs.io/en/latest/index.html#credentials。
cache: 是否使用磁盘缓存,仅在数据应仅访问一次时设置为false。(允许的值为:true,True,1,false,False,0)。
project 和其他参数传递给
gcsfs.core.GCSFileSystem
示例:
>>> df = vaex.open('gs://vaex-data/airlines/us_airline_data_1988_2019.hdf5', fs_options={'token': None}) >>> df = vaex.open('gs://vaex-data/airlines/us_airline_data_1988_2019.hdf5?token=anon') >>> df = vaex.open('gs://vaex-data/testing/xys.hdf5?token=anon&cache=False')
- vaex.open_many(filenames)[源代码]#
打开一个文件名列表,并返回一个包含所有DataFrame连接后的DataFrame。
文件名可以是
vaex.open()
支持的任何格式,即hdf5、arrow、parquet、csv等。
- vaex.register_function(scope=None, as_property=False, name=None, on_expression=True, df_accessor=None, multiprocessing=False)[source]#
用于向vaex注册新函数的装饰器。
如果 on_expression 为 True,该函数将作为 Expression 上的一个方法可用,其中第一个参数将是表达式本身。
如果给出了df_accessor,它将被添加为该数据框访问器的方法(参见例如vaex/geo.py)
示例:
>>> import vaex >>> df = vaex.example() >>> @vaex.register_function() >>> def invert(x): >>> return 1/x >>> df.x.invert()
>>> import numpy as np >>> df = vaex.from_arrays(departure=np.arange('2015-01-01', '2015-12-05', dtype='datetime64')) >>> @vaex.register_function(as_property=True, scope='dt') >>> def dt_relative_day(x): >>> return vaex.functions.dt_dayofyear(x)/365. >>> df.departure.dt.relative_day
- vaex.vconstant(value, length, dtype=None, chunk_size=1024)[source]#
创建一个具有常量值的虚拟列,该列使用0内存。
- Parameters:
value – 用于填充列的值
length – 列的长度,即它应包含的行数。
dtype – 列的首选数据类型。
chunk_size – 可用于优化此列的性能(评估)。
聚合与统计#
- class vaex.agg.AggregatorDescriptorKurtosis(name, expression, short_name='kurtosis', selection=None, edges=False)[source]#
- class vaex.agg.AggregatorDescriptorMean(name, expressions, short_name='mean', selection=None, edges=False)[source]#
- class vaex.agg.AggregatorDescriptorMulti(name, expressions, short_name, selection=None, edges=False)[source]#
基础类:
AggregatorDescriptor
使用多个操作/聚合来计算最终的聚合
- class vaex.agg.AggregatorDescriptorSkew(name, expression, short_name='skew', selection=None, edges=False)[source]#
- class vaex.agg.AggregatorDescriptorStd(name, expression, short_name='var', ddof=0, selection=None, edges=False)[source]#
- class vaex.agg.AggregatorDescriptorVar(name, expression, short_name='var', ddof=0, selection=None, edges=False)[来源]#
- vaex.agg.all(expression=None, selection=None)[source]#
聚合器,当组中的所有值都为True时,或者当组中的所有数据都有效时(即没有缺失值或np.nan),返回True。如果使用选择参数时组中没有数据,则聚合器返回False。
- Parameters:
expression – 以字符串形式表示的表达式,例如 'x' 或 'x+y',或 vaex 表达式对象,例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时)
- vaex.agg.any(expression=None, selection=None)[source]#
聚合器,当组中的任何值为True时,或者当组中有任何有效数据时(即没有缺失值或np.nan),返回True。 如果使用选择参数时组中没有数据,则聚合器返回False。
- Parameters:
expression – 以字符串形式表示的表达式,例如 'x' 或 'x+y' 或 vaex 表达式对象,例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称(或为‘default’选择时为True),或所有数据(当选择为None或False时)
- vaex.agg.first(expression, order_expression=None, selection=None, edges=False)[source]#
创建第一个聚合。
- Parameters:
expression – {expression_one}.
order_expression – 使用此表达式对箱子中的值进行排序。
selection – {selection1}
edges – {edges}
- vaex.agg.last(expression, order_expression=None, selection=None, edges=False)[source]#
创建第一个聚合。
- Parameters:
expression – 以字符串形式表示的表达式,例如 'x' 或 'x+y' 或 vaex 表达式对象,例如 df.x 或 df.x+df.y。
order_expression – 使用此表达式对箱子中的值进行排序。
selection – 要使用的选择的名称(或为‘default’选择时为True),或所有数据(当选择为None或False时)
edges – 目前仅供内部使用(它包括边界处的nan值和超出限制的值,nan和0,小于1的值,以及大于-1的值)
- class vaex.agg.list(expression, selection=None, dropna=False, dropnan=False, dropmissing=False, edges=False)[source]#
基础类:
AggregatorDescriptorBasic
返回属于指定表达式的值列表的聚合器。
- Parameters:
expression – 以字符串形式表示的表达式,例如 'x' 或 'x+y' 或 vaex 表达式对象,例如 df.x 或 df.x+df.y
selection – 要使用的选择的名称(或为‘default’选择时为True),或所有数据(当选择为None或False时)
dropmissing – 删除包含缺失值的行
dropnan – 删除包含NaN值的行
dropna – 删除包含不可用(NA)值(NaN 或缺失值)的行。
edges – 目前仅供内部使用(它包括边界处的nan值和超出限制的值,nan和0,小于1,大于-1)
- vaex.agg.nunique(expression, dropna=False, dropnan=False, dropmissing=False, selection=None, edges=False)[source]#
计算每个区间内唯一项目数量的聚合器。
- Parameters:
expression – 以字符串形式表示的表达式,例如 'x' 或 'x+y' 或 vaex 表达式对象,例如 df.x 或 df.x+df.y
dropmissing – 删除包含缺失值的行
dropnan – 删除包含NaN值的行
dropna – 删除包含不可用(NA)值(NaN 或缺失值)的行。
selection – 要使用的选择的名称(或为‘default’选择时为True),或所有数据(当选择为None或False时)
缓存#
(目前处于实验阶段,使用需自担风险) Vaex 可以缓存任务结果,例如聚合或用于分组操作的内部哈希映射,以加快重复计算的速度,但需要计算缓存键并存储/检索缓存值。
在内部,Vaex 计算指纹(例如数据的哈希值,或文件路径和修改时间)以创建跨进程相似的缓存键,这样进程的重启很可能会导致相似的哈希键。
缓存可以全局开启,或者作为上下文管理器使用:
>>> import vaex
>>> df = vaex.example()
>>> vaex.cache.memory_infinite() # cache on globally
<cache restore context manager>
>>> vaex.cache.is_on()
True
>>> vaex.cache.off() # cache off globally
<cache restore context manager>
>>> vaex.cache.is_on()
False
>>> with vaex.cache.memory_infinite():
... df.x.sum() # calculated without cache
array(-20884.64307324)
>>> vaex.cache.is_on()
False
函数 vaex.cache.set()
和 vaex.cache.get()
只是在一个全局字典 (vaex.cache.cache
) 中查找值,但可以设置为更复杂的行为。
一个用于内存缓存的好库是cachetools (https://pypi.org/project/cachetools/)
>>> import vaex
>>> import cachetools
>>> df = vaex.example()
>>> vaex.cache.cache = cachetools.LRUCache(1_000_000_000) # 1gb cache
使用环境变量进行配置#
查看 Configuration 以获取更多配置选项。
特别是在使用vaex server时,使用环境变量外部开启缓存可能会很有用。
$ VAEX_CACHE=disk VAEX_CACHE_DISK_SIZE_LIMIT=”10GB” python -m vaex.server
将启用缓存使用 vaex.cache.disk()
并将其配置为最多使用 10 GB 的磁盘空间。
当将Vaex与Flask或Plotly Dash结合使用,并使用gunicorn进行扩展时,使用多级缓存可能很有用,其中第一级缓存较小但延迟低(并且对每个进程是私有的),而第二级是延迟较高的磁盘缓存,在所有进程之间共享。
$ VAEX_CACHE=”memory,disk” VAEX_CACHE_DISK_SIZE_LIMIT=”10GB” VAEX_CACHE_MEMORY_SIZE_LIMIT=”1GB” gunicorn -w 16 app:server
- vaex.cache.disk(clear=False, size_limit='10GB', eviction_policy='least-recently-stored')[source]#
使用diskcache库存储缓存值。
- Parameters:
size_limit (int 或 str) – 缓存的最大大小,以字节为单位(或使用类似 '128MB' 的字符串) 有关更多详细信息,请参阅 http://www.grantjenks.com/docs/diskcache/tutorial.html?highlight=eviction#tutorial-settings。
eviction_policy (str) – 驱逐策略, 参见 http://www.grantjenks.com/docs/diskcache/tutorial.html?highlight=eviction#tutorial-eviction-policies
clear (bool) – 在开启缓存之前,清除所有用于缓存的磁盘空间。
- vaex.cache.get(key, default=None, type=None)[source]#
查找键的缓存值,或返回默认值
如果缓存关闭,将返回 None。
- Parameters:
key (str) – 缓存键。
default – 当缓存开启但键不在缓存中时返回
type – 当前未使用。
- vaex.cache.memory(maxsize='1GB', classname='LRUCache', clear=False)[source]#
使用cachetools设置内存缓存 (https://cachetools.readthedocs.io/).
多次调用时使用clear=False将保留当前缓存(在笔记本使用中很有用)。
- vaex.cache.memory_infinite(clear=False)[source]#
设置一个字典作为缓存,创建一个无限缓存。
多次调用时使用clear=False将保留当前缓存(在笔记本使用中很有用)
- vaex.cache.off()[source]#
关闭缓存,或在用作上下文管理器时临时关闭
>>> import vaex >>> df = vaex.example() >>> vaex.cache.memory_infinite() # cache on <cache restore context manager> >>> with vaex.cache.off(): ... df.x.sum() # calculated without cache array(-20884.64307324) >>> df.x.sum() # calculated with cache array(-20884.64307324) >>> vaex.cache.off() # cache off <cache restore context manager> >>> df.x.sum() # calculated without cache array(-20884.64307324)
- vaex.cache.redis(client=None)[source]#
使用Redis进行缓存。
- Parameters:
client – Redis 客户端,如果为 None,将调用 redis.Redis()
- vaex.cache.set(key, value, type=None, duration_wallclock=None)[source]#
设置缓存值
对于更高级的策略非常有用,我们希望根据类型和成本有不同的行为。实现可以设置此函数以覆盖默认行为:
>>> import vaex >>> vaex.cache.memory_infinite() >>> def my_smart_cache_setter(key, value, type=None, duration_wallclock=None): ... if duration_wallclock >= 0.1: # skip fast calculations ... vaex.cache.cache[key] = value ... >>> vaex.cache.set = my_smart_cache_setter
DataFrame 类#
- class vaex.dataframe.DataFrame(name=None, executor=None)[源代码]#
基础类:
object
所有本地或远程数据集都封装在这个类中,它提供了一个类似pandas的API来操作你的数据集。
每个DataFrame (df) 都有若干列和若干行,即DataFrame的长度。
所有DataFrame都有多个“选择”,所有计算都在整个DataFrame(默认)或选择上进行。以下示例展示了如何使用选择。
>>> df.select("x < 0") >>> df.sum(df.y, selection=True) >>> df.sum(df.y, selection=[df.x < 0, df.x > 0])
- __getitem__(item)[source]#
获取表达式、几列的(浅)副本或应用过滤的便捷方法。
示例:
>>> df['Lz'] # the expression 'Lz >>> df['Lz/2'] # the expression 'Lz/2' >>> df[["Lz", "E"]] # a shallow copy with just two columns >>> df[df.Lz < 0] # a shallow copy with the filter Lz < 0 applied
- __setitem__(name, value)[source]#
向此DataFrame添加虚拟列/表达式的便捷方法。
示例:
>>> import vaex, numpy as np >>> df = vaex.example() >>> df['r'] = np.sqrt(df.x**2 + df.y**2 + df.z**2) >>> df.r <vaex.expression.Expression(expressions='r')> instance at 0x121687e80 values=[2.9655450396553587, 5.77829281049018, 6.99079603950256, 9.431842752707537, 0.8825613121347967 ... (total 330000 values) ... 7.453831761514681, 15.398412491068198, 8.864250273925633, 17.601047186042507, 14.540181524970293]
- __weakref__#
对象的弱引用列表
- add_variable(name, expression, overwrite=True, unique=True)[source]#
向DataFrame添加一个变量。
变量可能引用其他变量,虚拟列和表达式可能引用变量。
Example
>>> df.add_variable('center', 0) >>> df.add_virtual_column('x_prime', 'x-center') >>> df.select('x_prime < 0')
- Param:
str name: 虚拟变量的名称
- Param:
表达式:变量的表达式
- add_virtual_column(name, expression, unique=False)[source]#
向DataFrame添加一个虚拟列。
示例:
>>> df.add_virtual_column("r", "sqrt(x**2 + y**2 + z**2)") >>> df.select("r < 10")
- Param:
str name: 虚拟列的名称
- Param:
表达式: 列的表达式
- Parameters:
unique (str) – 如果名称已被使用,通过添加后缀使其唯一,例如 _1 或 _2
- apply(f, arguments=None, vectorize=False, multiprocessing=True)[源代码]#
在整个DataFrame上逐行应用一个函数。
示例:
>>> import vaex >>> df = vaex.example() >>> def func(x, y): ... return (x+y)/(x-y) ... >>> df.apply(func, arguments=[df.x, df.y]) Expression = lambda_function(x, y) Length: 330,000 dtype: float64 (expression) ------------------------------------------- 0 -0.460789 1 3.90038 2 -0.642851 3 0.685768 4 -0.543357
- Parameters:
f – 要应用的函数
arguments – 传递给函数 f 的参数列表。
vectorize – 使用数组而不是标量调用 f(以获得更好的性能)。
multiprocessing (bool) – 使用多进程以避免GIL(全局解释器锁)。
- Returns:
一个延迟求值的函数。
- cat(i1, i2, format='html')[source]#
显示从第 i1 行到第 i2 行的 DataFrame
有关格式,请参见 https://pypi.org/project/tabulate/
- property col#
直接访问列(适用于制表符完成)。
在与小型DataFrames结合使用ipython时非常方便,因为这提供了标签补全功能。
可以通过列名访问列,列名是属性。这些属性目前是表达式,因此你可以用它们进行计算。
Example
>>> ds = vaex.example() >>> df.plot(df.col.x, df.col.y)
- column_count(hidden=False)[source]#
返回列的数量(包括虚拟列)。
- Parameters:
hidden (bool) – 如果为True,则在统计中包含隐藏列
- Returns:
DataFrame中的列数
- combinations(expressions_list=None, dimension=2, exclude=None, **kwargs)[source]#
为给定维度生成可能表达式的组合列表。
- Parameters:
expressions_list – 表达式列表的列表,其中内部列表定义了子空间
dimensions – 如果给定,生成一个包含该维度所有可能组合的子空间
exclude – 排除列表
- correlation(x, y=None, binby=[], limits=None, shape=128, sort=False, sort_key=<ufunc 'absolute'>, selection=False, delay=False, progress=None, array_type=None)[来源]#
计算x和y之间的相关系数cov[x,y]/(std[x]*std[y]),可能在由binby定义的网格上进行。
x 和 y 参数可以是单个表达式或表达式列表。 - 如果 x 和 y 是单个表达式,则计算 x 和 y 之间的相关性; - 如果 x 是表达式列表且 y 是单个表达式,则计算 x 中每个表达式与 y 中表达式之间的相关性; - 如果 x 是表达式列表且 y 为 None,则计算 x 中所有表达式之间的相关矩阵; - 如果 x 是长度为 2 的元组列表,则计算指定维度对的相关性; - 如果 x 和 y 是表达式列表,则计算由两个表达式列表定义的相关矩阵。
示例:
>>> import vaex >>> df = vaex.example() >>> df.correlation("x**2+y**2+z**2", "-log(-E+1)") array(0.6366637382215669) >>> df.correlation("x**2+y**2+z**2", "-log(-E+1)", binby="Lz", shape=4) array([ 0.40594394, 0.69868851, 0.61394099, 0.65266318]) >>> df.correlation(x=['x', 'y', 'z']) array([[ 1. , -0.06668907, -0.02709719], [-0.06668907, 1. , 0.03450365], [-0.02709719, 0.03450365, 1. ]]) >>> df.correlation(x=['x', 'y', 'z'], y=['E', 'Lz']) array([[-0.01116315, -0.00369268], [-0.0059848 , 0.02472491], [ 0.01428211, -0.05900035]])
- Parameters:
x – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
y – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- count(expression=None, binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None, array_type=None)[source]#
计算非NaN值的数量(如果表达式为None或“*”,则计算所有值)。
示例:
>>> df.count() 330000 >>> df.count("*") 330000.0 >>> df.count("*", binby=["x"], shape=4) array([ 10925., 155427., 152007., 10748.])
- Parameters:
expression – 用于计算非缺失值的表达式或列,或者为 None 或 '*' 以计算行数
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
edges – 目前仅供内部使用(它包括边界处的nan值和超出限制的值,nan和0,小于1,大于-1)
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- cov(x, y=None, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
计算x和y或更多表达式的协方差矩阵,可能在由binby定义的网格上。
x 和 y 是表达式,例如:
>>> df.cov("x", "y")
或者只给出x参数和一个表达式列表,例如:
>>> df.cov(["x, "y, "z"])
示例:
>>> df.cov("x", "y") array([[ 53.54521742, -3.8123135 ], [ -3.8123135 , 60.62257881]]) >>> df.cov(["x", "y", "z"]) array([[ 53.54521742, -3.8123135 , -0.98260511], [ -3.8123135 , 60.62257881, 1.21381057], [ -0.98260511, 1.21381057, 25.55517638]])
>>> df.cov("x", "y", binby="E", shape=2) array([[[ 9.74852878e+00, -3.02004780e-02], [ -3.02004780e-02, 9.99288215e+00]], [[ 8.43996546e+01, -6.51984181e+00], [ -6.51984181e+00, 9.68938284e+01]]])
- Parameters:
x – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
y – 如果前一个参数不是列表,则应提供此参数
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为标量,包含统计信息,最后两个维度形状为(2,2)
- covar(x, y, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
计算x和y之间的协方差cov[x,y],可能在由binby定义的网格上。
示例:
>>> df.covar("x**2+y**2+z**2", "-log(-E+1)") array(52.69461456005138) >>> df.covar("x**2+y**2+z**2", "-log(-E+1)")/(df.std("x**2+y**2+z**2") * df.std("-log(-E+1)")) 0.63666373822156686 >>> df.covar("x**2+y**2+z**2", "-log(-E+1)", binby="Lz", shape=4) array([ 10.17387143, 51.94954078, 51.24902796, 20.2163929 ])
- Parameters:
x – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
y – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- data_type(expression, array_type=None, internal=False, axis=0)[source]#
返回给定表达式的数据类型,如果不是列,则将评估第一行以获取数据类型。
示例:
>>> df = vaex.from_scalars(x=1, s='Hi')
- describe(strings=True, virtual=True, selection=None)[source]#
给出DataFrame的描述。
>>> import vaex >>> df = vaex.example()[['x', 'y', 'z']] >>> df.describe() x y z dtype float64 float64 float64 count 330000 330000 330000 missing 0 0 0 mean -0.0671315 -0.0535899 0.0169582 std 7.31746 7.78605 5.05521 min -128.294 -71.5524 -44.3342 max 271.366 146.466 50.7185 >>> df.describe(selection=df.x > 0) x y z dtype float64 float64 float64 count 164060 164060 164060 missing 165940 165940 165940 mean 5.13572 -0.486786 -0.0868073 std 5.18701 7.61621 5.02831 min 1.51635e-05 -71.5524 -44.3342 max 271.366 78.0724 40.2191
- diff(periods=1, column=None, fill_value=None, trim=False, inplace=False, reverse=False)[source]#
计算当前行与偏移periods行的差异
- drop(columns, inplace=False, check=True)[source]#
删除列(或单个列)。
- Parameters:
columns – 列名列表或单个列名
inplace – 如果为True,则对自身进行修改,否则返回一个新的DataFrame
check – 当为true时,它将检查该列是否用于虚拟列或过滤器中,并隐藏它。
- property dtypes#
提供一个包含所有列(除隐藏列外)的numpy数据类型的Pandas系列对象。
- evaluate(expression, i1=None, i2=None, out=None, selection=None, filtered=True, array_type=None, parallel=True, chunk_size=None, progress=None)[源代码]#
评估一个表达式,并返回一个包含整个列或其中一部分结果的numpy数组。
请注意,这不是vaex应该使用的方式,因为这意味着数据的副本需要适合内存。
要获取部分结果,请使用 i1 和 i2
- evaluate_iterator(expression, s1=None, s2=None, out=None, selection=None, filtered=True, array_type=None, parallel=True, chunk_size=None, prefetch=True, progress=None)[source]#
生成器以块(行数)高效评估表达式。
请参阅
DataFrame.evaluate()
以获取其他参数。示例:
>>> import vaex >>> df = vaex.example() >>> for i1, i2, chunk in df.evaluate_iterator(df.x, chunk_size=100_000): ... print(f"Total of {i1} to {i2} = {chunk.sum()}") ... Total of 0 to 100000 = -7460.610158279056 Total of 100000 to 200000 = -4964.85827154921 Total of 200000 to 300000 = -7303.271340043915 Total of 300000 to 330000 = -2424.65234724951
- Parameters:
progress – {progress}
prefetch – 在当前值被生成/返回的同时,预取/计算下一个块。
- extract()[源代码]#
返回一个仅包含过滤行的DataFrame。
注意
请注意,不会复制基础数据,只会创建视图/引用。
当原始DataFrame被大量过滤(仅包含少量行)时,生成的DataFrame可能更高效。
如果没有应用过滤,它将返回一个修剪后的视图。 对于返回的df,len(df) == df.length_original() == df.length_unfiltered()
- Return type:
- fillna(value, column_names=None, prefix='__original_', inplace=False)[source]#
返回一个DataFrame,其中缺失值/NaN用‘value’填充。
原始列将被重命名,默认情况下它们将成为隐藏列。不会丢失任何数据。
注意
请注意,不会复制底层数据,只会创建视图/引用。
注意
请注意,过滤将被忽略(因为它们可能会改变),您可能需要考虑先运行
extract()
。示例:
>>> import vaex >>> import numpy as np >>> x = np.array([3, 1, np.nan, 10, np.nan]) >>> df = vaex.from_arrays(x=x) >>> df_filled = df.fillna(value=-1, column_names=['x']) >>> df_filled # x 0 3 1 1 2 -1 3 10 4 -1
- filter(expression, mode='and')[source]#
df[
] 的通用版本,用于修改应用于 DataFrame 的过滤器。 请参阅
DataFrame.select()
了解选择的使用方法。请注意,使用 df = df[
] 只能缩小过滤范围(即只能选择更少的行)。使用过滤方法和不同的布尔模式(例如“或”),实际上可以选择更多的行。这与 numpy 和 pandas 等库有很大不同,它们只能缩小过滤范围。示例:
>>> import vaex >>> import numpy as np >>> x = np.arange(10) >>> df = vaex.from_arrays(x=x, y=x**2) >>> df # x y 0 0 0 1 1 1 2 2 4 3 3 9 4 4 16 5 5 25 6 6 36 7 7 49 8 8 64 9 9 81 >>> dff = df[df.x<=2] >>> dff # x y 0 0 0 1 1 1 2 2 4 >>> dff = dff.filter(dff.x >=7, mode="or") >>> dff # x y 0 0 0 1 1 1 2 2 4 3 7 49 4 8 64 5 9 81
- first(expression, order_expression=None, binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None, array_type=None)[source]#
返回分箱后的expression的第一个元素,其中每个箱的值按order_expression排序。
示例:
>>> import vaex >>> df = vaex.example() >>> df.first(df.x, df.y, shape=8) >>> df.first(df.x, df.y, shape=8, binby=[df.y]) >>> df.first(df.x, df.y, shape=8, binby=[df.y]) array([-4.81883764, 11.65378 , 9.70084476, -7.3025589 , 4.84954977, 8.47446537, -5.73602629, 10.18783 ])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
order_expression – 使用此表达式对箱子中的值进行排序。
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
edges – 目前仅供内部使用(它包括边界处的nan值和超出限制的值,nan和0,小于1,大于-1)
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
包含第一个元素的Ndarray。
- Return type:
numpy.array
- get_column_names(virtual=True, strings=True, hidden=False, regex=None, dtype=None)[来源]#
返回列名的列表
示例:
>>> import vaex >>> df = vaex.from_scalars(x=1, x2=2, y=3, s='string') >>> df['r'] = (df.x**2 + df.y**2)**2 >>> df.get_column_names() ['x', 'x2', 'y', 's', 'r'] >>> df.get_column_names(virtual=False) ['x', 'x2', 'y', 's'] >>> df.get_column_names(regex='x.*') ['x', 'x2'] >>> df.get_column_names(dtype='string') ['s']
- get_private_dir(create=False)[source]#
每个DataFrame都有一个目录,用于存储元数据等文件。
Example
>>> import vaex >>> ds = vaex.example() >>> vaex.get_private_dir() '/Users/users/breddels/.vaex/dfs/_Users_users_breddels_vaex-testing_data_helmi-dezeeuw-2000-10p.hdf5'
- Parameters:
创建 (bool) – 如果为True,当目录不存在时将会创建该目录
- get_variable(name)[source]#
返回由名称给定的变量,它不会对其进行评估。
用于评估,请参见
DataFrame.evaluate_variable()
,另请参见DataFrame.set_variable()
- healpix_count(expression=None, healpix_expression=None, healpix_max_level=12, healpix_level=8, binby=None, limits=None, shape=128, delay=False, progress=None, selection=None)[source]#
计算表示healpix数据的数组上表达式的非缺失值数量。
- Parameters:
expression – 用于计算非缺失值的表达式或列,或者为 None 或 '*' 以计算行数
healpix_expression – {healpix_max_level}
healpix_max_level – {healpix_max_level}
healpix_level – {healpix_level}
binby – {binby},这些维度遵循第一个healpix维度。
limits – {limits}
shape – {shape}
selection – {selection}
delay – {delay}
progress – {progress}
- Returns:
- kurtosis(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算给定表达式的峰度,可能在由binby定义的网格上进行。
示例:
>>> df.kurtosis('vz') 0.33414303 >>> df.kurtosis("vz", binby=["E"], shape=4) array([0.35286113, 0.14455428, 0.52955107, 5.06716345])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- last(expression, order_expression=None, binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None, array_type=None)[source]#
返回分箱后的expression的最后一个元素,其中每个箱中的值按order_expression排序。
- Parameters:
expression – 要放入分箱中的值。
order_expression – 使用此表达式对箱子中的值进行排序。
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
edges – 目前仅供内部使用(它包括边界处的nan值和超出限制的值,nan和0,小于1,大于-1)
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
包含第一个元素的Ndarray。
- Return type:
numpy.array
- limits(expression, value=None, square=False, selection=None, delay=False, progress=None, shape=None)[source]#
计算表达式的最小值和最大值范围,默认值为‘minmax’。
如果值是形式为 [minvalue, maxvalue] 的列表,则直接返回,这是为了方便使用混合形式。
示例:
>>> import vaex >>> df = vaex.example() >>> df.limits("x") array([-128.293991, 271.365997]) >>> df.limits("x", "99.7%") array([-28.86381927, 28.9261226 ]) >>> df.limits(["x", "y"]) (array([-128.293991, 271.365997]), array([ -71.5523682, 146.465836 ])) >>> df.limits(["x", "y"], "99.7%") (array([-28.86381927, 28.9261226 ]), array([-28.60476934, 28.96535249])) >>> df.limits(["x", "y"], ["minmax", "90%"]) (array([-128.293991, 271.365997]), array([-13.37438402, 13.4224423 ])) >>> df.limits(["x", "y"], ["minmax", [0, 10]]) (array([-128.293991, 271.365997]), [0, 10])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
value – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
- Returns:
列表形式为[[xmin, xmax], [ymin, ymax], …. ,[zmin, zmax]],或者当表达式不是列表时为[xmin, xmax]
- limits_percentage(expression, percentage=99.73, square=False, selection=False, progress=None, delay=False)[source]#
计算表达式的最小值和最大值范围,该范围包含大约由百分比定义的数据百分比。
范围在中位数周围对称,即对于90%的百分比,这与以下结果相同:
示例:
>>> df.limits_percentage("x", 90) array([-12.35081376, 12.14858052] >>> df.percentile_approx("x", 5), df.percentile_approx("x", 95) (array([-12.36813152]), array([ 12.13275818]))
注意:此值是通过在网格上计算累积分布来近似的。 注意2:上述值并不完全相同,因为percentile和limits_percentage不共享相同的代码
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
percentage (float) – 值介于0到100之间
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
- Returns:
列表形式为[[xmin, xmax], [ymin, ymax], …. ,[zmin, zmax]],当表达式不是列表时为[xmin, xmax]
- materialize(column=None, inplace=False, virtual_column=None)[source]#
将列转换为原生CPU格式,以内存为代价实现最佳性能。
警告
这可能会使用大量内存,请注意。
虚拟列将立即被评估,所有真实列在首次使用时将被缓存到内存中。
虚拟列示例:
>>> x = np.arange(1,4) >>> y = np.arange(2,5) >>> df = vaex.from_arrays(x=x, y=y) >>> df['r'] = (df.x**2 + df.y**2)**0.5 # 'r' is a virtual column (computed on the fly) >>> df = df.materialize('r') # now 'r' is a 'real' column (i.e. a numpy array)
使用parquet文件的示例 >>> df = vaex.open(‘somewhatslow.parquet’) >>> df.x.sum() # 慢 >>> df = df.materialize() >>> df.x.sum() # 慢,但会填充缓存 >>> df.x.sum() # 尽可能快,将使用内存
- Parameters:
column – 字符串或字符串列表,用于具体化的列名,当为None时表示所有列
inplace – 如果为True,则对自身进行修改,否则返回一个新的DataFrame
virtual_column – 用于向后兼容
- max(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[来源]#
计算给定表达式的最大值,可能在由binby定义的网格上。
示例:
>>> df.max("x") array(271.365997) >>> df.max(["x", "y"]) array([ 271.365997, 146.465836]) >>> df.max("x", binby="x", shape=5, limits=[-10, 10]) array([-6.00010443, -2.00002384, 1.99998057, 5.99983597, 9.99984646])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量,最后一个维度的形状为(2)
- mean(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算表达式的平均值,可能在由binby定义的网格上。
示例:
>>> df.mean("x") -0.067131491264005971 >>> df.mean("(x**2+y**2)**0.5", binby="E", shape=4) array([ 2.43483742, 4.41840721, 8.26742458, 15.53846476])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- median_approx(expression, percentage=50.0, binby=[], limits=None, shape=128, percentile_shape=256, percentile_limits='minmax', selection=False, delay=False, progress=None)[来源]#
计算中位数,可能在由 binby 定义的网格上。
注意:该值是通过在由percentile_shape和percentile_limits定义的网格上计算累积分布来近似的
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
percentile_limits – 用于累积直方图的最小值和最大值的描述,目前应仅为‘minmax’
percentile_shape – 计算累积直方图的数组的形状,整数类型
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- min(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算给定表达式的最小值,可能在由binby定义的网格上。
示例:
>>> df.min("x") array(-128.293991) >>> df.min(["x", "y"]) array([-128.293991 , -71.5523682]) >>> df.min("x", binby="x", shape=5, limits=[-10, 10]) array([-9.99919128, -5.99972439, -1.99991322, 2.0000093 , 6.0004878 ])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量,最后一个维度的形状为(2)
- minmax(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[来源]#
计算表达式的最小值和最大值,可能是在由binby定义的网格上。
示例:
>>> df.minmax("x") array([-128.293991, 271.365997]) >>> df.minmax(["x", "y"]) array([[-128.293991 , 271.365997 ], [ -71.5523682, 146.465836 ]]) >>> df.minmax("x", binby="x", shape=5, limits=[-10, 10]) array([[-9.99919128, -6.00010443], [-5.99972439, -2.00002384], [-1.99991322, 1.99998057], [ 2.0000093 , 5.99983597], [ 6.0004878 , 9.99984646]])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量,最后一个维度的形状为(2)
- mode(expression, binby=[], limits=None, shape=256, mode_shape=64, mode_limits=None, progressbar=False, selection=None)[源代码]#
计算/估计模式。
- mutual_information(x, y=None, dimension=2, mi_limits=None, mi_shape=256, binby=[], limits=None, shape=128, sort=False, selection=False, delay=False)[source]#
估计在形状为mi_shape和mi_limits的网格上,x和y之间的互信息,可能是在由binby定义的网格上。
x 和 y 参数可以是单个表达式或表达式列表: - 如果 x 和 y 是单个表达式,则计算 x 和 y 之间的互信息; - 如果 x 是表达式列表且 y 是单个表达式,则计算 x 中每个表达式与 y 中表达式之间的互信息; - 如果 x 是表达式列表且 y 为 None,则计算 x 中所有表达式之间的互信息矩阵; - 如果 x 是长度为 2 的元组列表,则计算指定维度对的互信息; - 如果 x 和 y 是表达式列表,则计算由两个表达式列表定义的互信息矩阵。
如果 sort 为 True,则互信息按排序(降序)顺序返回,表达式列表也按相同顺序返回。
示例:
>>> import vaex >>> df = vaex.example() >>> df.mutual_information("x", "y") array(0.1511814526380327) >>> df.mutual_information([["x", "y"], ["x", "z"], ["E", "Lz"]]) array([ 0.15118145, 0.18439181, 1.07067379]) >>> df.mutual_information([["x", "y"], ["x", "z"], ["E", "Lz"]], sort=True) (array([ 1.07067379, 0.18439181, 0.15118145]), [['E', 'Lz'], ['x', 'z'], ['x', 'y']]) >>> df.mutual_information(x=['x', 'y', 'z']) array([[3.53535106, 0.06893436, 0.11656418], [0.06893436, 3.49414866, 0.14089177], [0.11656418, 0.14089177, 3.96144906]]) >>> df.mutual_information(x=['x', 'y', 'z'], y=['E', 'Lz']) array([[0.32316291, 0.16110026], [0.36573065, 0.17802792], [0.35239151, 0.21677695]])
- Parameters:
x – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
y – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
sort – 返回按排序(降序)顺序的互信息,并在 sorted 为 True 时返回相应的表达式列表
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
- Returns:
具有给定形状的Numpy数组,或在未给出binby参数时为标量,包含统计量,
- property nbytes#
df.byte_size() 的别名,请参阅
DataFrame.byte_size()
。
- nop(expression=None, progress=False, delay=False)[source]#
评估表达式或表达式列表,并丢弃结果。由于vaex通常是惰性的,这对于基准测试非常有用。
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
- Returns:
无
- percentile_approx(expression, percentage=50.0, binby=[], limits=None, shape=128, percentile_shape=1024, percentile_limits='minmax', selection=False, delay=False, progress=None)[source]#
计算由百分比给出的百分位数,可能在由binby定义的网格上。
注意:该值是通过在由percentile_shape和percentile_limits定义的网格上计算累积分布来近似的。
示例:
>>> df.percentile_approx("x", 10), df.percentile_approx("x", 90) (array([-8.3220355]), array([ 7.92080358])) >>> df.percentile_approx("x", 50, binby="x", shape=5, limits=[-10, 10]) array([[-7.56462982], [-3.61036641], [-0.01296306], [ 3.56697863], [ 7.45838367]])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
percentile_limits – 用于累积直方图的最小值和最大值的描述,目前应仅为‘minmax’
percentile_shape – 计算累积直方图的数组的形状,整数类型
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- plot2d_contour(x=None, y=None, what='count(*)', limits=None, shape=256, selection=None, f='identity', figsize=None, xlabel=None, ylabel=None, aspect='auto', levels=None, fill=False, colorbar=False, colorbar_label=None, colormap=None, colors=None, linewidths=None, linestyles=None, vmin=None, vmax=None, grid=None, show=None, **kwargs)#
在二维网格上绘制等高线。
- Parameters:
x – {表达式}
y – {表达式}
what – 要绘制的内容,count(*) 将显示一个 N 维直方图,mean('x') 表示 x 列的平均值,sum('x') 表示总和,std('x') 表示标准差,correlation('vx', 'vy') 表示相关系数。也可以是一个值列表,如 ['count(x)', std('vx')](默认映射到列)
limits – {limits}
shape – {shape}
selection – {selection}
f – 通过以下方式转换值:'identity' 不做任何操作,'log' 或 'log10' 将显示值的对数
figsize – 传递给 plt.figure 的 (x, y) 元组,用于设置图形大小
xlabel – x轴的标签(默认为参数x)
ylabel – y轴的标签(默认为参数 y)
aspect – 图形的宽高比
levels – 要传递给 plt.contour 或 plt.contourf 的等高线级别
colorbar – 是否绘制颜色条
colorbar_label – 颜色条的标签(默认为参数 what)
colormap – 传递给 plt.contour 或 plt.contourf 的 matplotlib 颜色映射
colors – 等高线的颜色
linewidths – 轮廓的宽度
linestyles – 等高线的样式
vmin – 不使用自动归一化,将数据缩放到 vmin 和 vmax 之间
vmax – 参见 vmin
grid – {grid}
显示
- plot3d(x, y, z, vx=None, vy=None, vz=None, vwhat=None, limits=None, grid=None, what='count(*)', shape=128, selection=[None, True], f=None, vcount_limits=None, smooth_pre=None, smooth_post=None, grid_limits=None, normalize='normalize', colormap='afmhot', figure_key=None, fig=None, lighting=True, level=[0.1, 0.5, 0.9], opacity=[0.01, 0.05, 0.1], level_width=0.1, show=True, **kwargs)[源代码]#
使用风险自负,需要ipyvolume
- plot_bq(x, y, grid=None, shape=256, limits=None, what='count(*)', figsize=None, f='identity', figure_key=None, fig=None, axes=None, xlabel=None, ylabel=None, title=None, show=True, selection=[None, True], colormap='afmhot', grid_limits=None, normalize='normalize', grid_before=None, what_kwargs={}, type='default', scales=None, tool_select=False, bq_cleanup=True, **kwargs)[来源]#
已弃用:请使用 plot_widget
- propagate_uncertainties(columns, depending_variables=None, cov_matrix='auto', covariance_format='{}_{}_covariance', uncertainty_format='{}_uncertainty')[source]#
为一组虚拟列传播不确定性(完整的协方差矩阵)。
通过查找以“e”或“e_”为前缀或以“_error”、“_uncertainty”、“e”和“_e”为后缀的列来猜测因变量的协方差矩阵。 通过后缀“_correlation”或“_corr”表示相关性,或“_covariance”或“_cov”表示协方差来确定非对角线(协方差或相关性)。 (注意x_y_cov = x_e * y_e * x_y_correlation。)
Example
>>> df = vaex.from_scalars(x=1, y=2, e_x=0.1, e_y=0.2) >>> df["u"] = df.x + df.y >>> df["v"] = np.log10(df.x) >>> df.propagate_uncertainties([df.u, df.v]) >>> df.u_uncertainty, df.v_uncertainty
- Parameters:
columns – 用于计算协方差矩阵的列列表。
depending_variables – 如果未给出,则会自动找出,否则是一个包含不确定性的列列表。
cov_matrix – 由表达式组成的列表的列表,给出协方差矩阵,顺序与 depending_variables 相同。如果为 'full' 或 'auto',将猜测 depending_variables 的协方差矩阵,其中 'full' 在未找到条目时会报错。
- rolling(window, trim=False, column=None, fill_value=None, edge='right')[source]#
创建一个
vaex.rolling.Rolling
滚动窗口对象
- sample(n=None, frac=None, replace=False, weights=None, random_state=None)[source]#
返回一个包含随机行集的DataFrame
注意
请注意,不会复制底层数据,只会创建视图/引用。
提供 n 或 frac。
示例:
>>> import vaex, numpy as np >>> df = vaex.from_arrays(s=np.array(['a', 'b', 'c', 'd']), x=np.arange(1,5)) >>> df # s x 0 a 1 1 b 2 2 c 3 3 d 4 >>> df.sample(n=2, random_state=42) # 2 random rows, fixed seed # s x 0 b 2 1 d 4 >>> df.sample(frac=1, random_state=42) # 'shuffling' # s x 0 c 3 1 a 1 2 d 4 3 b 2 >>> df.sample(frac=1, replace=True, random_state=42) # useful for bootstrap (may contain repeated samples) # s x 0 d 4 1 a 1 2 a 1 3 d 4
- schema_arrow(reduce_large=False)[source]#
类似于
schema()
,但返回一个箭头模式- Parameters:
reduce_large (bool) – 将大字符串转换为普通字符串
- select(boolean_expression, mode='replace', name='default', executor=None)[来源]#
执行一个选择,由布尔表达式定义,并使用给定的模式与之前的选择结合。
选择记录在每个名称的历史树中,可以分别对它们进行撤销/重做。
- select_box(spaces, limits, mode='replace', name='default')[源代码]#
选择一个由界限界定的n维矩形框。
以下示例是等效的:
>>> df.select_box(['x', 'y'], [(0, 10), (0, 1)]) >>> df.select_rectangle('x', 'y', [(0, 10), (0, 1)])
- Parameters:
spaces – 表达式列表
limits – 形状为 [(x1, x2), (y1, y2)] 的序列
模式
名称
- Returns:
- select_circle(x, y, xc, yc, r, mode='replace', name='default', inclusive=True)[source]#
选择一个以xc, yc为中心,半径为r的圆形区域。
示例:
>>> df.select_circle('x','y',2,3,1)
- Parameters:
x – x 空间的表达式
y – y 空间的表达式
xc – 圆心在x轴上的位置
yc – 圆心在 y 轴上的位置
r – 圆的半径
name – 选择的名称
模式
- Returns:
- select_ellipse(x, y, xc, yc, width, height, angle=0, mode='replace', name='default', radians=False, inclusive=True)[source]#
选择一个以xc, yc为中心的椭圆形区域,具有一定的宽度、高度和角度。
示例:
>>> df.select_ellipse('x','y', 2, -1, 5,1, 30, name='my_ellipse')
- Parameters:
x – x 空间的表达式
y – y 空间的表达式
xc – 椭圆中心在x轴上的位置
yc – 椭圆中心在 y 轴上的位置
width – 椭圆的宽度(直径)
height – 椭圆的宽度(直径)
angle – (度)椭圆的定向,从y轴逆时针测量
name – 选择的名称
模式
- Returns:
- select_inverse(name='default', executor=None)[source]#
反转选择,即被选中的将不被选中,反之亦然
- Parameters:
name (str)
执行器
- Returns:
- select_lasso(expression_x, expression_y, xsequence, ysequence, mode='replace', name='default', executor=None)[source]#
出于性能原因,套索选择的处理方式有所不同。
- select_non_missing(drop_nan=True, drop_masked=True, column_names=None, mode='replace', name='default')[source]#
创建一个选择,选择在column_names中的所有列都具有非缺失值的行。
名称反映了Pandas,实际上没有删除任何行,而是保留了一个掩码来跟踪选择
- select_rectangle(x, y, limits, mode='replace', name='default')[source]#
在由x和y给出的空间中,选择一个由限制条件界定的二维矩形框。
示例:
>>> df.select_box('x', 'y', [(0, 10), (0, 1)])
- Parameters:
x – x 空间的表达式
y – y 空间的表达式
limits – 形状为 [(x1, x2), (y1, y2)] 的序列
模式
- set_active_fraction(value)[source]#
设置active_fraction,将选中的行设置为None,并移除选择。
待办事项:如果我们保留表达式以及选定的行,我们可能能够保留选择
- set_selection(selection, name='default', executor=None)[来源]#
设置选择对象
- Parameters:
selection – 选择对象
name – 选择 'slot'
执行器
- Returns:
- set_variable(name, expression_or_value, write=True)[源代码]#
将变量设置为由expression_or_value定义的表达式或值。
Example
>>> df.set_variable("a", 2.) >>> df.set_variable("b", "a**2") >>> df.get_variable("b") 'a**2' >>> df.evaluate_variable("b") 4.0
- Parameters:
name – 变量的名称
write – 将变量写入元文件
expression – 值或表达式
- shift(periods, column=None, fill_value=None, trim=False, inplace=False)[source]#
将一列或多列按periods数量的行进行移动。
- shuffle(random_state=None)[来源]#
打乱行的顺序(等同于 df.sample(frac=1))
注意
请注意,不会复制底层数据,只会创建视图/引用。
示例:
>>> import vaex, numpy as np >>> df = vaex.from_arrays(s=np.array(['a', 'b', 'c']), x=np.arange(1,4)) >>> df # s x 0 a 1 1 b 2 2 c 3 >>> df.shuffle(random_state=42) # s x 0 a 1 1 b 2 2 c 3
- Parameters:
RandomState (int 或) – 设置一个种子或RandomState以确保可重复性。当None时,将选择一个随机种子。
- Returns:
返回一个新的DataFrame,其中包含基础数据的浅拷贝/视图
- Return type:
- skew(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算给定表达式的偏斜度,可能在由binby定义的网格上进行。
示例:
>>> df.skew("vz") 0.02116528 >>> df.skew("vz", binby=["E"], shape=4) array([-0.069976 , -0.01003445, 0.05624177, -2.2444322 ])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- sort(by, ascending=True)[source]#
返回一个按表达式‘by’排序的DataFrame。
'by' 和 'ascending' 参数都可以是列表。 请注意,无论排序顺序如何,缺失/NaN/NA 值总是会被推到末尾。
注意
请注意,不会复制底层数据,只会创建视图/引用。
注意
请注意,过滤将被忽略(因为它们可能会改变),您可能需要考虑先运行
extract()
。示例:
>>> import vaex, numpy as np >>> df = vaex.from_arrays(s=np.array(['a', 'b', 'c', 'd']), x=np.arange(1,5)) >>> df['y'] = (df.x-1.8)**2 >>> df # s x y 0 a 1 0.64 1 b 2 0.04 2 c 3 1.44 3 d 4 4.84 >>> df.sort('y', ascending=False) # Note: passing '(x-1.8)**2' gives the same result # s x y 0 d 4 4.84 1 c 3 1.44 2 a 1 0.64 3 b 2 0.04
- split(into=None)[来源]#
返回一个包含DataFrame有序子集的列表。
注意
请注意,不会复制底层数据,只会创建视图/引用。
示例:
>>> import vaex >>> df = vaex.from_arrays(x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> for dfs in df.split(into=0.3): ... print(dfs.x.values) ... [0 1 3] [3 4 5 6 7 8 9] >>> for split in df.split(into=[0.2, 0.3, 0.5]): ... print(dfs.x.values) [0 1] [2 3 4] [5 6 7 8 9]
- Parameters:
into (int/float/list) – 如果是浮点数,将把DataFrame分成两部分,其中第一部分的相对长度由该参数指定。 如果是列表,将分成与列表中元素数量相同的部分,其中每个元素定义该部分的相对长度。请注意,这样的分数列表将始终重新归一化为1。 如果是整数,将DataFrame分成n个长度相等的DataFrame(最后一个可能会有所不同),如果len(df) < n,它将返回len(df)个DataFrame。
- split_random(into, random_state=None)[source]#
返回一个包含DataFrame随机部分的数据列表。
注意
请注意,不会复制底层数据,只会创建视图/引用。
示例:
>>> import vaex, import numpy as np >>> np.random.seed(111) >>> df = vaex.from_arrays(x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> for dfs in df.split_random(into=0.3, random_state=42): ... print(dfs.x.values) ... [8 1 5] [0 7 2 9 4 3 6] >>> for split in df.split_random(into=[0.2, 0.3, 0.5], random_state=42): ... print(dfs.x.values) [8 1] [5 0 7] [2 9 4 3 6]
- Parameters:
into (int/float/list) – 如果是浮点数,将把DataFrame分成两部分,其中第一部分的相对长度由该参数指定。 如果是列表,将分成与列表中元素数量相同的部分,其中每个元素定义该部分的相对长度。请注意,这样的分数列表将始终重新归一化为1。 如果是整数,将DataFrame分成n个长度相等的DataFrame(最后一个可能会有所不同),如果len(df) < n,它将返回len(df)个DataFrame。
RandomState (int 或) – 设置一个种子或 RandomState 以确保可重复性。当为 None 时,将选择一个随机种子。
- Returns:
DataFrame 的列表。
- Return type:
- state_load(file, use_active_range=False, keep_columns=None, set_filter=True, trusted=True, fs_options=None, fs=None)[source]#
加载之前由
DataFrame.state_write()
存储的状态,另请参见DataFrame.state_set()
。
- state_write(file, fs_options=None, fs=None)[来源]#
将内部状态写入json或yaml文件(参见
DataFrame.state_get()
)Example
>>> import vaex >>> df = vaex.from_scalars(x=1, y=2) >>> df['r'] = (df.x**2 + df.y**2)**0.5 >>> df.state_write('state.json') >>> print(open('state.json').read()) { "virtual_columns": { "r": "(((x ** 2) + (y ** 2)) ** 0.5)" }, "column_names": [ "x", "y", "r" ], "renamed_columns": [], "variables": { "pi": 3.141592653589793, "e": 2.718281828459045, "km_in_au": 149597870.7, "seconds_per_year": 31557600 }, "functions": {}, "selections": { "__filter__": null }, "ucds": {}, "units": {}, "descriptions": {}, "description": null, "active_range": [ 0, 1 ] } >>> df.state_write('state.yaml') >>> print(open('state.yaml').read()) active_range: - 0 - 1 column_names: - x - y - r description: null descriptions: {} functions: {} renamed_columns: [] selections: __filter__: null ucds: {} units: {} variables: pi: 3.141592653589793 e: 2.718281828459045 km_in_au: 149597870.7 seconds_per_year: 31557600 virtual_columns: r: (((x ** 2) + (y ** 2)) ** 0.5)
- Parameters:
file (str) – 文件名(以 .json 或 .yaml 结尾)
fs_options (dict) – 传递给文件系统处理程序(s3fs 或 gcsfs)的参数
fs – ‘直接传递一个文件系统对象,参见
vaex.open()
’
- std(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, array_type=None)[来源]#
计算给定表达式的标准差,可能在由binby定义的网格上进行
>>> df.std("vz") 110.31773397535071 >>> df.std("vz", binby=["(x**2+y**2)**0.5"], shape=4) array([ 123.57954851, 85.35190177, 61.14345748, 38.0740619 ])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- sum(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, edges=False, array_type=None)[source]#
计算给定表达式的总和,可能在由binby定义的网格上进行
示例:
>>> df.sum("L") 304054882.49378014 >>> df.sum("L", binby="E", shape=4) array([ 8.83517994e+06, 5.92217598e+07, 9.55218726e+07, 1.40008776e+08])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
- take(indices, filtered=True, dropfilter=True)[source]#
返回一个仅包含由索引索引的行的DataFrame
注意
请注意,不会复制底层数据,只会创建视图/引用。
示例:
>>> import vaex, numpy as np >>> df = vaex.from_arrays(s=np.array(['a', 'b', 'c', 'd']), x=np.arange(1,5)) >>> df.take([0,2]) # s x 0 a 1 1 c 3
- Parameters:
indices – 包含行号的序列(列表或numpy数组)
filtered – (供内部使用) 索引指的是过滤后的数据。
dropfilter – (供内部使用)删除过滤器,当索引引用未过滤的数据时设置为False,但可能仍包含需要过滤掉的行。
- Returns:
DataFrame 是原始数据的浅拷贝。
- Return type:
- to_arrays(column_names=None, selection=None, strings=True, virtual=True, parallel=True, chunk_size=None, array_type=None)[source]#
返回一个ndarrays列表
- Parameters:
column_names – 列名列表,用于导出,当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
strings – 当 column_names 为 None 时,传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估(虚拟)列
chunk_size – 返回一个迭代器,其中包含按此长度切割的对象
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
数组列表
- to_arrow_table(column_names=None, selection=None, strings=True, virtual=True, parallel=True, chunk_size=None, reduce_large=False)[source]#
返回一个包含与评估数据对应的数组的箭头表对象
- Parameters:
column_names – 列名列表,用于导出,当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估(虚拟)列
chunk_size – 返回一个迭代器,该迭代器将对象切割成此大小的片段
reduce_large (bool) – 如果可能,将large_string转换为普通字符串
- Returns:
pyarrow.Table 对象或迭代器
- to_astropy_table(column_names=None, selection=None, strings=True, virtual=True, index=None, parallel=True)[source]#
返回一个包含与评估数据对应的ndarrays的astropy表对象
- Parameters:
column_names – 列名列表,用于导出,当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
index – 如果提供了此列,它将用作DataFrame的索引
- Returns:
astropy.table.Table 对象
- to_dask_array(chunks='auto')[source]#
懒散地将DataFrame暴露为dask.array
Example
>>> df = vaex.example() >>> A = df[['x', 'y', 'z']].to_dask_array() >>> A dask.array<vaex-df-1f048b40-10ec-11ea-9553, shape=(330000, 3), dtype=float64, chunksize=(330000, 3), chunktype=numpy.ndarray> >>> A+1 dask.array<add, shape=(330000, 3), dtype=float64, chunksize=(330000, 3), chunktype=numpy.ndarray>
- Parameters:
chunks – 如何分割数组,类似于
dask.array.from_array()
。- Returns:
dask.array.Array
对象。
- to_dict(column_names=None, selection=None, strings=True, virtual=True, parallel=True, chunk_size=None, array_type=None)[来源]#
返回一个包含与评估数据对应的ndarray的字典
- Parameters:
column_names – 列名列表,用于导出,当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估(虚拟)列
chunk_size – 返回一个迭代器,该迭代器将对象切割成此大小的片段
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
字典
- to_items(column_names=None, selection=None, strings=True, virtual=True, parallel=True, chunk_size=None, array_type=None)[来源]#
返回一个[(列名, ndarray), …)]对的列表,其中ndarray对应于评估的数据
- Parameters:
column_names – 列名列表,用于导出,当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估(虚拟)列
chunk_size – 返回一个迭代器,该迭代器将对象切割成此大小的片段
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
(名称, ndarray) 对的列表或迭代器
- to_pandas_df(column_names=None, selection=None, strings=True, virtual=True, index_name=None, parallel=True, chunk_size=None, array_type=None)[source]#
返回一个包含与评估数据对应的ndarray的pandas DataFrame
如果提供了索引,则该列将用作数据框的索引。
Example
>>> df_pandas = df.to_pandas_df(["x", "y", "z"]) >>> df_copy = vaex.from_pandas(df_pandas)
- Parameters:
column_names – 列名列表,用于导出,当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
index_column – 如果提供了此列,它将用作DataFrame的索引
parallel – 并行评估(虚拟)列
chunk_size – 返回一个迭代器,该迭代器将对象切割成此大小的片段
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
pandas.DataFrame 对象或迭代器
- to_records(index=None, selection=None, column_names=None, strings=True, virtual=True, parallel=True, chunk_size=None, array_type='python')[source]#
返回一个列表 [{column_name: value}, …)] “记录”,其中每个字典是一个评估过的行。
- Parameters:
index – 当提供时,用于获取特定行的记录的索引
column_names – 列名列表,用于导出,当为 None 时使用 DataFrame.get_column_names(strings=strings, virtual=virtual)
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
strings – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
virtual – 当 column_names 为 None 时传递给 DataFrame.get_column_names 的参数
parallel – 并行评估(虚拟)列
chunk_size – 返回一个迭代器,该迭代器将对象切割成此大小的片段
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
记录列表 [{column_name:value}, …]
- trim(inplace=False)[source]#
返回一个DataFrame,其中所有列都被活动范围“修剪”。
对于返回的DataFrame,df.get_active_range()返回(0, df.length_original())。
注意
请注意,不会复制底层数据,只会创建视图/引用。
- Parameters:
inplace – 如果为True,则对自身进行修改,否则返回一个新的DataFrame
- Return type:
- ucd_find(ucds, exclude=[])[source]#
找到一组具有ucd或部分ucd的列(名称)。
以 ^ 开头,它将仅匹配 ucd 的第一部分。
Example
>>> df.ucd_find('pos.eq.ra', 'pos.eq.dec') ['RA', 'DEC'] >>> df.ucd_find('pos.eq.ra', 'doesnotexist') >>> df.ucds[df.ucd_find('pos.eq.ra')] 'pos.eq.ra;meta.main' >>> df.ucd_find('meta.main')] 'dec' >>> df.ucd_find('^meta.main')]
- unique(expression, return_inverse=False, dropna=False, dropnan=False, dropmissing=False, progress=False, selection=None, axis=None, delay=False, limit=None, limit_raise=True, array_type='python')[source]#
返回所有唯一值。
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
return_inverse – 返回从唯一值到原始值的逆映射。
dropna – 删除包含不可用(NA)值(NaN 或缺失值)的行。
dropnan – 删除包含NaN值的行
dropmissing – 删除包含缺失值的行
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
axis (int) – 确定唯一元素的轴(None 将会展平数组或列表)
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
limit (int) – 限制结果的数量
limit_raise (bool) – 当超过限制时,抛出
vaex.RowLimitException
,或者最多返回 'limit' 数量的结果。array_type (str) – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray” 用于 xarray.DataArray,或 “list”/“python” 用于 Python 列表
- unit(expression, default=None)[source]#
返回表达式的单位(一个 astropy.unit.Units 对象)。
Example
>>> import vaex >>> ds = vaex.example() >>> df.unit("x") Unit("kpc") >>> df.unit("x*L") Unit("km kpc2 / s")
- Parameters:
expression – 表达式,可以是一个列名
default – 如果没有已知的单位,将返回此值
- Returns:
表达式的结果单位
- Return type:
astropy.units.Unit
- var(expression, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None, array_type=None)[source]#
计算给定表达式的样本方差,可能在由binby定义的网格上
示例:
>>> df.var("vz") 12170.002429456246 >>> df.var("vz", binby=["(x**2+y**2)**0.5"], shape=4) array([ 15271.90481083, 7284.94713504, 3738.52239232, 1449.63418988]) >>> df.var("vz", binby=["(x**2+y**2)**0.5"], shape=4)**0.5 array([ 123.57954851, 85.35190177, 61.14345748, 38.0740619 ])
- Parameters:
expression – 表达式或表达式列表,例如 df.x, 'x', 或 ['x', 'y']
binby – 用于构建分箱网格的表达式列表
limits – 表达式的最小值和最大值的描述,例如 'minmax'(默认)、'99.7%'、[0, 10],或一个列表,例如 [[0, 10], [0, 20], 'minmax']
shape – 用于计算统计量的数组的形状,如果只给出一个整数,则用于所有维度,例如 shape=128, shape=[128, 256]
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
delay – 不返回结果,而是返回异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
array_type – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray”表示 xarray.DataArray,或“list”/“python”表示 Python 列表
- Returns:
具有给定形状的Numpy数组,或者在没有给出binby参数时为一个标量,包含统计量
DataFrameLocal 类#
- class vaex.dataframe.DataFrameLocal(dataset=None, name=None)[source]#
基础类:
DataFrame
用于处理本地文件/数据的DataFrames的基类
- __array__(dtype=None, parallel=True)[source]#
将DataFrame的完整内存副本转换为形状为(n_rows, n_columns)的2d numpy数组。 请注意,内存顺序是fortran顺序,因此出于性能原因,1列的所有值在内存中是连续的。
注意,这将返回与以下相同的结果:
>>> np.array(ds)
如果任何列包含掩码数组,掩码将被忽略(即掩码元素也会被返回)。
- binby(by=None, agg=None, sort=False, copy=True, delay=False, progress=None)[来源]#
当agg不为None时,返回一个
BinBy
或DataArray
对象binby 操作不会返回一个“扁平”的 DataFrame,而是返回一个以 xarray 形式表示的 N 维网格。
- Parameters:
- Returns:
DataArray
或BinBy
对象。
- categorize(column, min_value=0, max_value=None, labels=None, inplace=False)[source]#
将列标记为分类。
这可能有助于加快使用[min_value, max_value]范围内的整数列的计算速度。
如果没有给出max_value,则[min_value和max_value]将从数据中计算得出。
示例:
>>> import vaex >>> df = vaex.from_arrays(year=[2012, 2015, 2019], weekday=[0, 4, 6]) >>> df = df.categorize('year', min_value=2020, max_value=2019) >>> df = df.categorize('weekday', labels=['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']) >>> df # year weekday 0 2012 0 1 2015 4 2 2019 6 >>> df.is_category('year') True
- Parameters:
column – 假设为分类的列。
labels – 与 min_value 和 max_value 之间的值相关联的标签
min_value – 最小整数值(如果未给出max_value,则计算此值)
max_value – 最大整数值(如果未给出 max_value,则计算此值)
labels – 与每个值关联的标签,默认为 list(range(min_value, max_value+1))
inplace – 如果为True,则对自身进行修改,否则返回一个新的DataFrame
- compare(other, report_missing=True, report_difference=False, show=10, orderby=None, column_names=None)[source]#
比较两个DataFrame并报告它们的差异,对于大型DataFrame请谨慎使用
- concat(*others, resolver='flexible') DataFrame [来源]#
将多个DataFrame连接起来,将其他DataFrame的行添加到当前DataFrame中,并返回一个新的DataFrame。
在resolver='flexible'的情况下,当并非所有列具有相同的名称时,缺失的数据将用缺失值填充。
在resolver='strict'的情况下,所有数据集都需要有匹配的列名。
- Parameters:
others – 与此DataFrame连接的其他DataFrames
resolver (str) – 如何解决模式冲突,'flexible' 或 'strict'。
- Returns:
新DataFrame,行已连接
- copy(column_names=None, treeshake=False)[来源]#
制作一个DataFrame的浅拷贝。也可以指定列的子集。
这是一个相当廉价的操作,因为不会对底层数据进行内存复制。
{note_copy}
- property data#
直接访问数据作为numpy数组。
在与小数据框结合使用IPython时非常方便,因为这提供了标签补全功能。 只能访问真实列(即非虚拟列),要从虚拟列获取数据,请使用 DataFrame.evaluate(…)。
可以通过列名访问列,列名是属性。这些属性的类型是numpy.ndarray。
示例:
>>> df = vaex.example() >>> r = np.sqrt(df.data.x**2 + df.data.y**2)
- export(path, progress=None, chunk_size=1048576, parallel=True, fs_options=None, fs=None, **kwargs)[来源]#
根据文件扩展名将DataFrame导出到文件。
例如,如果文件名以 .hdf5 结尾,则调用 df.export_hdf5。
- Parameters:
path (str) – 文件的路径
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
chunk_size (int) – 如果支持,每次迭代写入磁盘的行数。
parallel (bool) – 并行评估(虚拟)列
fs_options (dict) – 参见
vaex.open()
例如对于 S3 {“profile”: “myproject”}
- Returns:
- export_arrow(to, progress=None, chunk_size=1048576, parallel=True, reduce_large=True, fs_options=None, fs=None, as_stream=True)[来源]#
将DataFrame导出到用arrow写入的文件或流中
- Parameters:
to – 文件名、文件对象,或
pyarrow.RecordBatchStreamWriter
, py:data:pyarrow.RecordBatchFileWriter 或pyarrow.parquet.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文件。
- export_feather(to, parallel=True, reduce_large=True, compression='lz4', fs_options=None, fs=None)[source]#
使用feather文件格式版本2将DataFrame导出为arrow文件
- Feather is exactly represented as the Arrow IPC file format on disk, but also support compression.
- Parameters:
to – 文件名或文件对象
parallel (bool) – 并行评估(虚拟)列
reduce_large (bool) – 如果为True,将arrow large_string类型转换为string类型
compression – 可以是 'zstd'、'lz4' 或 'uncompressed' 之一
fs_options – 参见
vaex.open()
例如对于 S3 {“profile”: “myproject”}fs – 直接传递一个文件系统对象,参见
vaex.open()
- Returns:
- export_fits(path, progress=None)[source]#
将DataFrame导出为与TOPCAT colfits格式兼容的fits文件
- Parameters:
path (str) – 文件的路径
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
- Returns:
- export_hdf5(path, byteorder='=', progress=None, chunk_size=1048576, parallel=True, column_count=1, writer_threads=0, group='/table', mode='w')[source]#
将DataFrame导出为vaex hdf5文件
- Parameters:
path (str) – 文件的路径
byteorder (str) – = 表示本机字节序,< 表示小端序,> 表示大端序
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
parallel (bool) – 并行评估(虚拟)列
column_count (int) – 并行评估和导出的列数(大于1需要快速的随机访问,如SSD驱动器)。
writer_threads (int) – 是否使用线程进行写入,仅在 column_count > 1 时有用。
group (str) – 将数据写入hdf5文件中的自定义组。
mode (str) – 如果设置为“w”(写入),现有文件将被覆盖。如果设置为“a”,可以将附加数据追加到hdf5文件中,但需要放在不同的组中。
- Returns:
- export_json(to, progress=None, chunk_size=1048576, parallel=True, fs_options=None, fs=None)[source]#
将DataFrame导出到CSV文件。
- Parameters:
to – 文件名或文件对象
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel – 并行评估(虚拟)列
fs_options – 参见
vaex.open()
例如对于 S3 {“profile”: “myproject”}fs – 直接传递一个文件系统对象,参见
vaex.open()
- Returns:
- export_many(path, progress=None, chunk_size=1048576, parallel=True, max_workers=None, fs_options=None, fs=None, **export_kwargs)[source]#
将DataFrame并行导出为多个相同类型的文件。
路径将使用i参数(即块索引)进行格式化。
示例:
>>> import vaex >>> df = vaex.open('my_big_dataset.hdf5') >>> print(f'number of rows: {len(df):,}') number of rows: 193,938,982 >>> df.export_many(path='my/destination/folder/chunk-{i:03}.arrow') >>> df_single_chunk = vaex.open('my/destination/folder/chunk-00001.arrow') >>> print(f'number of rows: {len(df_single_chunk):,}') number of rows: 1,048,576 >>> df_all_chunks = vaex.open('my/destination/folder/chunk-*.arrow') >>> print(f'number of rows: {len(df_all_chunks):,}') number of rows: 193,938,982
- Parameters:
path (str) – 文件路径,按块索引 i 格式化(例如 'chunk-{i:05}.parquet')
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel (bool) – 并行评估(虚拟)列
max_workers (int) – 用于并行写入的工作线程/线程数
fs_options (dict) – 参见
vaex.open()
例如对于 S3 {“profile”: “myproject”}
- export_parquet(path, progress=None, chunk_size=1048576, parallel=True, fs_options=None, fs=None, **kwargs)[来源]#
将DataFrame导出为parquet文件。
注意:这可能要求所有数据都适合内存(内存映射数据是一个例外)。
- Parameters:
path (str) – 文件的路径
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel (bool) – 并行评估(虚拟)列
fs_options (dict) – 参见
vaex.open()
例如对于 S3 {“profile”: “myproject”}fs – 直接传递一个文件系统对象,参见
vaex.open()
kwargs – 传递给
py:data:pyarrow.parquet.ParquetWriter
的额外关键字参数。
- Returns:
- export_partitioned(path, by, directory_format='{key}={value}', progress=None, chunk_size=1048576, parallel=True, fs_options={}, fs=None)[来源]#
实验性:使用 hive 分区导出文件。
如果在路径中没有找到扩展名,我们假设是parquet文件。否则,你可以像格式字符串一样指定格式。其中{i}是从零开始的索引,{uuid}是唯一ID,{subdir}是Hive的key=value目录。
- Example paths:
‘/some/dir/{subdir}/{i}.parquet’
‘/some/dir/{subdir}/fixed_name.parquet’
‘/some/dir/{subdir}/{uuid}.parquet’
‘/some/dir/{subdir}/{uuid}.parquet’
- Parameters:
path – 写入文件的目录。
str (str 或 列表) – 按哪一列进行分区。
directory_format (str) – 目录的格式字符串,Hive布局的默认值为‘{key}={value}’。
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
chunk_size (int) – 每次迭代写入磁盘的行数
parallel (bool) – 并行评估(虚拟)列
fs_options (dict) – 参见
vaex.open()
例如对于 S3 {“profile”: “myproject”}
- groupby(by=None, agg=None, sort=False, ascending=True, assume_sparse='auto', row_limit=None, copy=True, progress=None, delay=False)[source]#
当agg不为None时,返回一个
GroupBy
或DataFrame
对象示例:
>>> import vaex >>> import numpy as np >>> np.random.seed(42) >>> x = np.random.randint(1, 5, 10) >>> y = x**2 >>> df = vaex.from_arrays(x=x, y=y) >>> df.groupby(df.x, agg='count') # x y_count 0 3 4 1 4 2 2 1 3 3 2 1 >>> df.groupby(df.x, agg=[vaex.agg.count('y'), vaex.agg.mean('y')]) # x y_count y_mean 0 3 4 9 1 4 2 16 2 1 3 1 3 2 1 4 >>> df.groupby(df.x, agg={'z': [vaex.agg.count('y'), vaex.agg.mean('y')]}) # x z_count z_mean 0 3 4 9 1 4 2 16 2 1 3 1 3 2 1 4
使用 datetime 的示例:
>>> import vaex >>> import numpy as np >>> t = np.arange('2015-01-01', '2015-02-01', dtype=np.datetime64) >>> y = np.arange(len(t)) >>> df = vaex.from_arrays(t=t, y=y) >>> df.groupby(vaex.BinnerTime.per_week(df.t)).agg({'y' : 'sum'}) # t y 0 2015-01-01 00:00:00 21 1 2015-01-08 00:00:00 70 2 2015-01-15 00:00:00 119 3 2015-01-22 00:00:00 168 4 2015-01-29 00:00:00 87
- Parameters:
agg (dict, list or agg) – 聚合操作,可以是字符串形式、vaex.agg对象、字典(其中键表示目标列名,值表示操作),或者是聚合操作的列表。如果未提供,将返回groupby对象。
sort (bool) – 对我们分组的列进行排序。
assume_sparse (bool 或 str) – 假设在按多个键分组时,现有的键值对相对于笛卡尔积是稀疏的。 如果为‘auto’,则由vaex决定(例如,一个包含10_000行但只有4*3=12种组合的分组,压缩为8种现有组合并不重要,并且将节省另一次数据遍历)
row_limit (int) – 限制结果数据框的行数(默认不检查,仅在 assume_sparse 为 True 时有效)。 当条件不满足时,抛出
vaex.RowLimitException
。copy (bool) – 复制数据框(浅复制,不占用内存),以便原始数据框的指纹不被修改。
delay (bool) – 不返回结果,而是返回一个用于异步计算的代理(目前仅限内部使用)
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
- Returns:
DataFrame
或GroupBy
对象。
- is_local()[来源]#
DataFrame.evaluate()
的本地实现总是返回 True。
- join(other, on=None, left_on=None, right_on=None, lprefix='', rprefix='', lsuffix='', rsuffix='', how='left', allow_duplication=False, prime_growth=False, cardinality_other=None, inplace=False)[来源]#
返回一个与其他DataFrames连接的DataFrame,通过列/表达式在/left_on/right_on上进行匹配
如果没有给出on/left_on/right_on,连接是通过简单地添加列来完成的(即在隐式行索引上)。
注意:在连接时,过滤器将被忽略,将连接完整的DataFrame(因为过滤器可能会改变)。如果任一DataFrame被大量过滤(仅包含少量行),请考虑首先运行
DataFrame.extract()
。示例:
>>> a = np.array(['a', 'b', 'c']) >>> x = np.arange(1,4) >>> ds1 = vaex.from_arrays(a=a, x=x) >>> b = np.array(['a', 'b', 'd']) >>> y = x**2 >>> ds2 = vaex.from_arrays(b=b, y=y) >>> ds1.join(ds2, left_on='a', right_on='b')
- Parameters:
other – 要连接的另一个DataFrame(右侧)
on – 左表(自身)的默认键
left_on – 左表(self)的键,覆盖 on
right_on – 右表(other)的默认键,覆盖 on
lprefix – 在名称冲突的情况下,添加到左侧列名称的前缀
rprefix – 右侧类似
lsuffix – 在名称冲突的情况下,添加到左侧列名的后缀
rsuffix – 右侧的类似内容
how – 如何连接,'left' 保留左侧的所有行,并添加列(可能包含缺失值) 'right' 类似,但交换了自身和其他。'inner' 仅返回重叠的行。
allow_duplication (bool) – 当连接的列包含非唯一值时,允许行的重复。
cardinality_other (int) – 另一个表的唯一元素数量(或估计值)。
prime_growth (bool) – 用于内部哈希表的增长策略,在某些情况下可以提高性能(例如,未使用低位整数的整数)。
inplace – 如果为True,则对自身进行修改,否则返回一个新的DataFrame
- Returns:
- label_encode(column, values=None, inplace=False, lazy=False)#
已弃用:请使用 ordinal_encode
将列编码为序数值并将其标记为分类。
现有列被重命名为隐藏列,并被替换为数值列,其值在[0, len(values)-1]之间。
- param lazy:
当为False时,它将具体化序数代码。
- length(selection=False)[来源]#
获取DataFrames的长度,用于选择整个DataFrame。
如果选择为False,则返回len(df)。
待办事项:在DataFrameRemote中实现此功能,并将方法上移到
DataFrame.length()
- Parameters:
selection – 当为True时,将返回所选行的数量
- Returns:
- ordinal_encode(column, values=None, inplace=False, lazy=False)[source]#
已弃用:请使用 ordinal_encode
将列编码为序数值并将其标记为分类。
现有列将被重命名为隐藏列,并被替换为数值列,其值在[0, len(values)-1]之间。
- param lazy:
当为False时,它将具体化序数代码。
- shallow_copy(virtual=True, variables=True)[source]#
创建DataFrame的(浅)副本。
它将链接到相同的数据,但会有自己的状态,例如虚拟列、变量、选择等。
- property values#
将DataFrame的完整内存副本转换为形状为(n_rows, n_columns)的2d numpy数组。 请注意,内存顺序是fortran顺序,因此出于性能原因,1列的所有值在内存中是连续的。
注意,这将返回与以下相同的结果:
>>> np.array(ds)
如果任何列包含掩码数组,掩码将被忽略(即掩码元素也会被返回)。
日期/时间操作#
- class vaex.expression.DateTime(expression)[来源]#
基础类:
object
日期时间操作
通常使用例如 df.birthday.dt.dayofweek 访问
- __weakref__#
对象的弱引用列表
- property date#
返回日期时间值的日期部分
- Returns:
包含日期时间值的日期部分的表达式
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.date Expression = dt_date(date) Length: 3 dtype: datetime64[D] (expression) ------------------------------------------- 0 2009-10-12 1 2016-02-11 2 2015-11-12
- property day#
从日期时间样本中提取天数。
- Returns:
一个表达式,包含从日期时间列中提取的天数。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.day Expression = dt_day(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 12 1 11 2 12
- property day_name#
返回日期时间样本的英文星期名称。
- Returns:
一个表达式,包含从日期时间列中提取的星期名称。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.day_name Expression = dt_day_name(date) Length: 3 dtype: str (expression) --------------------------------- 0 Monday 1 Thursday 2 Thursday
- property dayofweek#
获取星期几,其中星期一=0,星期日=6
- Returns:
一个包含星期几的表达式。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.dayofweek Expression = dt_dayofweek(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 0 1 3 2 3
- property dayofyear#
一年中的序数日。
- Returns:
一个包含一年中序数日的表达式。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.dayofyear Expression = dt_dayofyear(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 285 1 42 2 316
- floor(freq, *args)#
对给定频率的表达式执行向下取整操作。
- Parameters:
freq – 将索引向下取整的频率级别。必须是一个固定的频率,如‘S’(秒)或‘H’(小时),但不能是‘ME’(月末)。
- Returns:
一个包含向下取整的日期时间列的表达式。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.floor("H") Expression = dt_floor(date, 'H') Length: 3 dtype: datetime64[ns] (expression) -------------------------------------------- 0 2009-10-12 03:00:00.000000000 1 2016-02-11 10:00:00.000000000 2 2015-11-12 11:00:00.000000000
- property halfyear#
返回日期的半年。值可以是1和2,分别表示上半年和下半年。
- Returns:
一个表达式,包含从日期时间列中提取的半年度。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22 >>> df.date.dt.halfyear Expression = dt_halfyear(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 2 1 1 2 2
- property hour#
从日期时间样本中提取小时。
- Returns:
一个表达式,包含从日期时间列中提取的小时。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.hour Expression = dt_hour(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 3 1 10 2 11
- property is_leap_year#
检查某一年是否为闰年。
- Returns:
一个表达式,如果某年是闰年则评估为True,否则为False。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.is_leap_year Expression = dt_is_leap_year(date) Length: 3 dtype: bool (expression) ---------------------------------- 0 False 1 True 2 False
- property minute#
从日期时间样本中提取分钟。
- Returns:
一个表达式,包含从日期时间列中提取的分钟。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.minute Expression = dt_minute(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 31 1 17 2 34
- property month#
从日期时间样本中提取月份。
- Returns:
一个表达式,包含从日期时间列中提取的月份。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.month Expression = dt_month(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 10 1 2 2 11
- property month_name#
返回一个日期时间样本的英文月份名称。
- Returns:
一个表达式,包含从日期时间列中提取的月份名称。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.month_name Expression = dt_month_name(date) Length: 3 dtype: str (expression) --------------------------------- 0 October 1 February 2 November
- property quarter#
返回日期的季度。值的范围是1-4。
- Returns:
一个表达式,包含从日期时间列中提取的季度。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22 >>> df.date.dt.quarter Expression = dt_quarter(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 4 1 1 2 4
- property second#
从日期时间样本中提取秒数。
- Returns:
一个表达式,包含从日期时间列中提取的秒数。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.second Expression = dt_second(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 0 1 34 2 22
- strftime(date_format)#
从日期时间样本返回格式化的字符串。
- Returns:
一个包含从日期时间列中提取的格式化字符串的表达式。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.strftime("%Y-%m") Expression = dt_strftime(date, '%Y-%m') Length: 3 dtype: object (expression) ------------------------------------ 0 2009-10 1 2016-02 2 2015-11
- property weekofyear#
返回一年中的周序号。
- Returns:
一个表达式,包含从日期时间列中提取的年份的周序号。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.weekofyear Expression = dt_weekofyear(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 42 1 6 2 46
- property year#
从日期时间样本中提取年份。
- Returns:
一个表达式,包含从日期时间列中提取的年份。
示例:
>>> import vaex >>> import numpy as np >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64) >>> df = vaex.from_arrays(date=date) >>> df # date 0 2009-10-12 03:31:00 1 2016-02-11 10:17:34 2 2015-11-12 11:34:22
>>> df.date.dt.year Expression = dt_year(date) Length: 3 dtype: int64 (expression) ----------------------------------- 0 2009 1 2016 2 2015
表达式类#
- class vaex.expression.Expression(ds, expression, ast=None, _selection=False)[source]#
基础类:
object
Expression 类
- __bool__()[源代码]#
将表达式转换为布尔值。仅支持 (
== 和 != ) 主要用途是支持分配给traitlets。例如:
>>> bool(expr1 == expr2)
当expr1和expr2完全相同(在字符串表示中)时,这将返回True。同样适用于:
>>> bool(expr != expr2)
所有其他情况将返回True。
- __eq__(b)#
返回 self==value。
- __ge__(b)#
返回 self>=value。
- __getitem__(slicer)[source]#
通过方括号表示法提供行和可选字段访问(结构数组)。
示例:
>>> import vaex >>> import pyarrow as pa >>> array = pa.StructArray.from_arrays(arrays=[[1, 2, 3], ["a", "b", "c"]], names=["col1", "col2"]) >>> df = vaex.from_arrays(array=array, integer=[5, 6, 7]) >>> df # array integer 0 {'col1': 1, 'col2': 'a'} 5 1 {'col1': 2, 'col2': 'b'} 6 2 {'col1': 3, 'col2': 'c'} 7
>>> df.integer[1:] Expression = integer Length: 2 dtype: int64 (column) ------------------------------- 0 6 1 7
>>> df.array[1:] Expression = array Length: 2 dtype: struct<col1: int64, col2: string> (column) ----------------------------------------------------------- 0 {'col1': 2, 'col2': 'b'} 1 {'col1': 3, 'col2': 'c'}
>>> df.array[:, "col1"] Expression = struct_get(array, 'col1') Length: 3 dtype: int64 (expression) ----------------------------------- 0 1 1 2 2 3
>>> df.array[1:, ["col1"]] Expression = struct_project(array, ['col1']) Length: 2 dtype: struct<col1: int64> (expression) ------------------------------------------------- 0 {'col1': 2} 1 {'col1': 3}
>>> df.array[1:, ["col2", "col1"]] Expression = struct_project(array, ['col2', 'col1']) Length: 2 dtype: struct<col2: string, col1: int64> (expression) --------------------------------------------------------------- 0 {'col2': 'b', 'col1': 2} 1 {'col2': 'c', 'col1': 3}
- __gt__(b)#
返回 self>value。
- __hash__ = None#
- __le__(b)#
返回 self<=value。
- __lt__(b)#
返回 self
- __ne__(b)#
返回 self 不等于 value。
- __or__(b)#
返回 self|value。
- __ror__(b)#
返回值|自身。
- __weakref__#
对象的弱引用列表
- abs(**kwargs)#
围绕
numpy.abs
的惰性包装器
- apply(f, vectorize=False, multiprocessing=True)[source]#
沿着表达式的所有值应用一个函数。
df.apply(f, arguments=[expression])
的简写,参见DataFrame.apply()
示例:
>>> df = vaex.example() >>> df.x Expression = x Length: 330,000 dtype: float64 (column) --------------------------------------- 0 -0.777471 1 3.77427 2 1.37576 3 -7.06738 4 0.243441
>>> def func(x): ... return x**2
>>> df.x.apply(func) Expression = lambda_function(x) Length: 330,000 dtype: float64 (expression) ------------------------------------------- 0 0.604461 1 14.2451 2 1.89272 3 49.9478 4 0.0592637
- Parameters:
f – 一个应用于表达式值的函数
vectorize – 使用数组而不是标量调用 f(以获得更好的性能)。
multiprocessing (bool) – 使用多进程以避免GIL(全局解释器锁)。
- Returns:
一个在调用时延迟求值的函数。
- arccos(**kwargs)#
围绕
numpy.arccos
的惰性包装器
- arccosh(**kwargs)#
围绕
numpy.arccosh
的惰性包装器
- arcsin(**kwargs)#
围绕
numpy.arcsin
的懒加载包装器
- arcsinh(**kwargs)#
围绕
numpy.arcsinh
的惰性包装器
- arctan(**kwargs)#
围绕
numpy.arctan
的惰性包装器
- arctan2(**kwargs)#
围绕
numpy.arctan2
的惰性包装器
- arctanh(**kwargs)#
围绕
numpy.arctanh
的惰性包装器
- as_arrow()#
懒加载转换为Apache Arrow数组类型
- as_numpy(strict=False)#
懒加载转换为NumPy ndarray类型
- property ast#
返回表达式的抽象语法树(AST)
- clip(**kwargs)#
围绕
numpy.clip
的惰性包装器
- copy(df=None)[来源]#
高效地复制一个表达式。
表达式对象既有字符串表示也有AST表示。创建AST表示涉及解析表达式,这是昂贵的。
使用 copy 将在表达式已被解析时深拷贝 AST。
- Parameters:
df – 用于评估表达式的DataFrame(如果为None,则为self.df)
- cosh(**kwargs)#
围绕
numpy.cosh
的惰性包装器
- count(binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None)[source]#
ds.count(expression, …) 的快捷方式,参见 Dataset.count
- deg2rad(**kwargs)#
围绕
numpy.deg2rad
的懒加载包装器
- digitize(**kwargs)#
围绕
numpy.digitize
的惰性包装器
- dot_product(b)#
计算a和b之间的点积。
- Parameters:
a – 一个表达式列表或一个值列表(例如一个向量)
b – 一个表达式列表或一个值列表(例如一个向量)
- Returns:
Vaex 表达式
- expand(stop=[])[source]#
展开表达式,使其不包含虚拟列,仅包含普通列。
示例:
>>> df = vaex.example() >>> r = np.sqrt(df.data.x**2 + df.data.y**2) >>> r.expand().expression 'sqrt(((x ** 2) + (y ** 2)))'
- expm1(**kwargs)#
围绕
numpy.expm1
的懒加载包装器
- fillna(value)#
返回一个数组,其中NA值被替换为指定值。 有关缺失值的定义,请参见:isna。
- fillnan(value)#
返回一个数组,其中nan值被替换为指定值。 有关缺失值的定义,请参见:isnan。
- format(format)#
使用 http://www.cplusplus.com/reference/string/to_string/ 进行格式化
- hashmap_apply(hashmap, check_missing=False)#
将值应用到哈希映射中,如果check_missing为True,哈希映射中的缺失值将被转换为null/缺失值
- isfinite(**kwargs)#
围绕
numpy.isfinite
的惰性包装器
- isin(values, use_hashmap=True)[source]#
懒散地测试表达式中的每个值是否存在于值中。
- Parameters:
values – 要检查的值列表/数组
use_hashmap – 是否使用哈希表(当值包含许多元素时尤其更快)
- Returns:
Expression
带有惰性表达式。
- isinf(**kwargs)#
围绕
numpy.isinf
的惰性包装器
- ismissing()#
在有缺失值(掩码数组)、缺失字符串或None的地方返回True
- isna()#
返回一个布尔表达式,指示值是否不可用(缺失或NaN)。
- isnan()#
返回一个包含NaN值的数组
- kurtosis(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
df.kurtosis(expression, …) 的快捷方式,参见 DataFrame.kurtosis
- log10(**kwargs)#
围绕
numpy.log10
的惰性包装器
- log1p(**kwargs)#
围绕
numpy.log1p
的惰性包装
- map(mapper, nan_value=None, missing_value=None, default_value=None, allow_missing=False, axis=None)[source]#
根据输入的字典或自定义的可调用函数,映射表达式或内存列的值。
示例:
>>> import vaex >>> df = vaex.from_arrays(color=['red', 'red', 'blue', 'red', 'green']) >>> mapper = {'red': 1, 'blue': 2, 'green': 3} >>> df['color_mapped'] = df.color.map(mapper) >>> df # color color_mapped 0 red 1 1 red 1 2 blue 2 3 red 1 4 green 3 >>> import numpy as np >>> df = vaex.from_arrays(type=[0, 1, 2, 2, 2, np.nan]) >>> df['role'] = df['type'].map({0: 'admin', 1: 'maintainer', 2: 'user', np.nan: 'unknown'}) >>> df # type role 0 0 admin 1 1 maintainer 2 2 user 3 2 user 4 2 user 5 nan unknown >>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(type=[0, 1, 2, 2, 2, 4]) >>> df['role'] = df['type'].map({0: 'admin', 1: 'maintainer', 2: 'user'}, default_value='unknown') >>> df # type role 0 0 admin 1 1 maintainer 2 2 user 3 2 user 4 2 user 5 4 unknown :param mapper: dict like object used to map the values from keys to values :param nan_value: value to be used when a nan is present (and not in the mapper) :param missing_value: value to use used when there is a missing value :param default_value: value to be used when a value is not in the mapper (like dict.get(key, default)) :param allow_missing: used to signal that values in the mapper should map to a masked array with missing values, assumed True when default_value is not None. :param bool axis: Axis over which to determine the unique elements (None will flatten arrays or lists) :return: A vaex expression :rtype: vaex.expression.Expression
- property masked#
别名到 df.is_masked(expression)
- max(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.max(expression, …) 的快捷方式,参见 Dataset.max
- maximum(**kwargs)#
围绕
numpy.maximum
的惰性包装
- mean(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.mean(expression, …) 的快捷方式,参见 Dataset.mean
- min(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.min(expression, …) 的快捷方式,参见 Dataset.min
- minimum(**kwargs)#
围绕
numpy.minimum
的懒加载包装器
- minmax(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[来源]#
ds.minmax(expression, …) 的快捷方式,参见 Dataset.minmax
- notna()#
与isna相反
- nunique(dropna=False, dropnan=False, dropmissing=False, selection=None, axis=None, limit=None, limit_raise=True, progress=None, delay=False)[source]#
计算唯一值的数量,即 len(df.x.unique()) == df.x.nunique()。
- Parameters:
dropna – 删除包含不可用(NA)值(NaN 或缺失值)的行。
dropnan – 删除包含NaN值的行
dropmissing – 删除包含缺失值的行
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
axis (bool) – 确定唯一元素的轴(None 将展平数组或列表)
limit (int) – 限制结果的数量
limit_raise (bool) – 当超过限制时,抛出
vaex.RowLimitException
,或者最多返回 'limit' 数量的结果。progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
delay (bool) – 不返回结果,而是返回一个用于异步计算的代理(目前仅限内部使用)
- rad2deg(**kwargs)#
围绕
numpy.rad2deg
的懒加载包装器
- round(**kwargs)#
围绕
numpy.round
的惰性包装器
- searchsorted(**kwargs)#
围绕
numpy.searchsorted
的惰性包装器
- sinc(**kwargs)#
围绕
numpy.sinc
的惰性包装器
- sinh(**kwargs)#
围绕
numpy.sinh
的懒加载包装器
- skew(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
df.skew(expression, …) 的快捷方式,参见 DataFrame.skew
- sqrt(**kwargs)#
围绕
numpy.sqrt
的懒加载包装器
- std(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.std(expression, …) 的快捷方式,参见 Dataset.std
- property str#
通过
StringOperations
提供对字符串操作的访问
- property str_pandas#
通过
StringOperationsPandas
(使用Pandas Series)提供对字符串操作的访问
- property struct#
通过
StructOperations
提供对结构体操作的访问
- sum(axis=None, binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[源代码]#
在给定轴上求和元素。
如果没有给出轴,它将对所有轴求和。
对于非列表元素,这是 ds.sum(expression, …) 的快捷方式,请参阅 Dataset.sum。
>>> list_data = [1, 2, None], None, [], [1, 3, 4, 5] >>> df = vaex.from_arrays(some_list=pa.array(list_data)) >>> df.some_list.sum().item() # will sum over all axis 16 >>> df.some_list.sum(axis=1).tolist() # sums the list elements [3, None, 0, 13]
- Parameters:
axis (int) – 确定唯一元素的轴(None 将展平数组或列表)
- tanh(**kwargs)#
围绕
numpy.tanh
的惰性包装器
- to_string()#
转换为字符串,与 expression.astype(‘str’) 相同
- property transient#
如果此表达式不是瞬态的(例如在磁盘上),可以进行优化
- unique(dropna=False, dropnan=False, dropmissing=False, selection=None, axis=None, limit=None, limit_raise=True, array_type='list', progress=None, delay=False)[source]#
返回所有唯一值。
- Parameters:
dropna – 删除包含不可用(NA)值(NaN 或缺失值)的行。
dropnan – 删除包含NaN值的行
dropmissing – 删除包含缺失值的行
selection – 要使用的选择的名称(或为“默认”选择时为True),或所有数据(当选择为None或False时),或选择列表
axis (bool) – 确定唯一元素的轴(None 将展平数组或列表)
limit (int) – 限制结果的数量
limit_raise (bool) – 当超过限制时,抛出
vaex.RowLimitException
,或者最多返回 'limit' 数量的结果。array_type (bool) – 输出数组的类型,可能的值为 None(保持原样)、“numpy”(ndarray)、“xarray” 用于 xarray.DataArray,或 “list”/“python” 用于 Python 列表
progress – 如果为True,则显示进度条,或者是一个可调用对象,该对象接受一个参数(一个介于0和1之间的浮点值)表示进度,当此可调用对象返回False时,计算将被取消
delay (bool) – 不返回结果,而是返回一个用于异步计算的代理(目前仅限内部使用)
- value_counts(dropna=False, dropnan=False, dropmissing=False, ascending=False, progress=False, axis=None, delay=False)[源代码]#
计算唯一值的计数。
- WARNING:
如果表达式/列不是分类的,它将被即时转换
dropna 默认为 False,在 pandas 中默认为 True
- Parameters:
- Returns:
包含计数的Pandas系列
- var(binby=[], limits=None, shape=128, selection=False, delay=False, progress=None)[source]#
ds.std(expression, …) 的快捷方式,参见 Dataset.var
- variables(ourself=False, expand_virtual=True, include_virtual=True)[source]#
返回此表达式依赖的一组变量。
示例:
>>> df = vaex.example() >>> r = np.sqrt(df.data.x**2 + df.data.y**2) >>> r.variables() {'x', 'y'}
- where(x, y, dtype=None)#
根据condition从x或y中按行返回值。
当您想根据某些条件创建时,这是一个有用的函数。 如果条件为真,则取x的值,否则取y的值。 考虑语法的一个简单方法是df.func.where(“if”, “then”, “else”)。 请参见下面的示例。
注意:如果该函数用作表达式的方法,则假定该表达式为条件。
- Parameters:
condition – 一个布尔表达式
x – 单个值或表达式,如果条件满足,则传递该值。
y – 单个值或表达式,如果条件不满足时传递的值。
dtype – 可选地指定结果表达式的数据类型
- Return type:
示例:
>>> import vaex >>> df = vaex.from_arrays(x=[0, 1, 2, 3]) >>> df['y'] = df.func.where(df.x >=2, df.x, -1) >>> df # x y 0 0 -1 1 1 -1 2 2 2 3 3 3
地理操作#
- class vaex.geo.DataFrameAccessorGeo(df)[source]#
基础类:
object
几何/地理辅助方法
示例:
>>> df_xyz = df.geo.spherical2cartesian(df.longitude, df.latitude, df.distance) >>> df_xyz.x.mean()
- __weakref__#
对象的弱引用列表
- cartesian2spherical(x='x', y='y', z='z', alpha='l', delta='b', distance='distance', radians=False, center=None, center_name='solar_position', inplace=False)[来源]#
将笛卡尔坐标转换为球面坐标。
- Parameters:
x
y
z
alpha
delta – 极角名称,范围从-90到90(当弧度设置为True时,范围为-pi到pi)。
距离
弧度
中心
center_name
- Returns:
- cartesian_to_polar(x='x', y='y', radius_out='r_polar', azimuth_out='phi_polar', propagate_uncertainties=False, radians=False, inplace=False)[来源]#
将笛卡尔坐标转换为极坐标
- Parameters:
x – x的表达式
y – y的表达式
radius_out – 半径的虚拟列名称
azimuth_out – 方位角虚拟列的名称
propagate_uncertainties – {propagate_uncertainties}
radians – 如果为True,方位角以弧度表示,默认为度
- Returns:
- inside_polygon(y, px, py)#
测试由x和y定义的点是否在多边形px, py内
示例:
>>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(x=[1, 2, 3], y=[2, 3, 4]) >>> px = np.array([1.5, 2.5, 2.5, 1.5]) >>> py = np.array([2.5, 2.5, 3.5, 3.5]) >>> df['inside'] = df.geo.inside_polygon(df.x, df.y, px, py) >>> df # x y inside 0 1 2 False 1 2 3 True 2 3 4 False
- Parameters:
x – {expression_one}
y – {expression_one}
px – 多边形x坐标的列表
px – 多边形的y坐标列表
- Returns:
表达式,如果点在内部则为真,否则为假。
- inside_polygons(y, pxs, pys, any=True)#
测试由x和y定义的点是否在所有或任何多边形px、py内
示例:
>>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(x=[1, 2, 3], y=[2, 3, 4]) >>> px = np.array([1.5, 2.5, 2.5, 1.5]) >>> py = np.array([2.5, 2.5, 3.5, 3.5]) >>> df['inside'] = df.geo.inside_polygons(df.x, df.y, [px, px + 1], [py, py + 1], any=True) >>> df # x y inside 0 1 2 False 1 2 3 True 2 3 4 True
- Parameters:
x – {expression_one}
y – {expression_one}
pxs – N个ndarrays的列表,包含多边形的x坐标,N是多边形的数量
pxs – N个ndarrays的列表,包含多边形的y坐标
any – 如果在任何多边形或所有多边形中,则返回 true
- Returns:
表达式,如果点在内部则为真,否则为假。
- inside_which_polygon(y, pxs, pys)#
查找一个点位于哪个多边形(基于0的索引)
示例:
>>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(x=[1, 2, 3], y=[2, 3, 4]) >>> px = np.array([1.5, 2.5, 2.5, 1.5]) >>> py = np.array([2.5, 2.5, 3.5, 3.5]) >>> df['polygon_index'] = df.geo.inside_which_polygon(df.x, df.y, [px, px + 1], [py, py + 1]) >>> df # x y polygon_index 0 1 2 -- 1 2 3 0 2 3 4 1
- Parameters:
x – {expression_one}
y – {expression_one}
px – 包含多边形x坐标的N个ndarrays列表,N是多边形的数量
px – 包含多边形y坐标的N个ndarrays的列表
- Returns:
表达式,基于0的索引,表示点所属的多边形(或缺失/掩码值)
- inside_which_polygons(x, y, pxss, pyss=None, any=True)[source]#
查找点位于哪一组多边形中(基于0的索引)。
如果 any=True,它将是第一个匹配的多边形集合索引,如果 any=False,它将是匹配集合中所有多边形的第一个索引。
>>> import vaex >>> import numpy as np >>> df = vaex.from_arrays(x=[1, 2, 3], y=[2, 3, 4]) >>> px = np.array([1.5, 2.5, 2.5, 1.5]) >>> py = np.array([2.5, 2.5, 3.5, 3.5]) >>> polygonA = [px, py] >>> polygonB = [px + 1, py + 1] >>> pxs = [[polygonA, polygonB], [polygonA]] >>> df['polygon_index'] = df.geo.inside_which_polygons(df.x, df.y, pxs, any=True) >>> df # x y polygon_index 0 1 2 -- 1 2 3 0 2 3 4 0 >>> df['polygon_index'] = df.geo.inside_which_polygons(df.x, df.y, pxs, any=False) >>> df # x y polygon_index 0 1 2 -- 1 2 3 1 2 3 4 --
- Parameters:
x – 以字符串形式表示的表达式,例如 'x' 或 'x+y',或 vaex 表达式对象,例如 df.x 或 df.x+df.y
y – 以字符串形式表示的表达式,例如 'x' 或 'x+y',或 vaex 表达式对象,例如 df.x 或 df.x+df.y
px – 包含多边形x坐标的N个ndarrays列表,N是多边形的数量
px – N个ndarrays的列表,包含多边形的y坐标,如果为None,则x数组的最后一个维度的ndarrays的形状应为2(即包含x和y坐标)
any – 测试点是否在任何多边形中(逻辑或),或在所有多边形中(逻辑与)
- Returns:
表达式,基于0的索引,表示点所属的多边形(或缺失/掩码值)
- project_aitoff(alpha, delta, x, y, radians=True, inplace=False)[来源]#
添加aitoff (https://en.wikipedia.org/wiki/Aitoff_projection) 投影
- Parameters:
alpha – 方位角
delta – 极角
x – x坐标的输出名称
y – y坐标的输出名称
radians – 输入和输出以弧度(True)或度(False)为单位
- Returns:
- project_gnomic(alpha, delta, alpha0=0, delta0=0, x='x', y='y', radians=False, postfix='', inplace=False)[来源]#
向DataFrame添加一个格诺米克投影
- rotation_2d(x, y, xnew, ynew, angle_degrees, propagate_uncertainties=False, inplace=False)[source]#
二维旋转。
- spherical2cartesian(alpha, delta, distance, xname='x', yname='y', zname='z', propagate_uncertainties=False, center=[0, 0, 0], radians=False, inplace=False)[source]#
将球面坐标转换为笛卡尔坐标。
- Parameters:
alpha
delta – 极角,范围从-90(南极)到90(北极)
distance – 径向距离,决定x、y和z的单位
xname
yname
zname
propagate_uncertainties – 如果为真,将为新的虚拟列传播误差,详情请参见
propagate_uncertainties()
中心
弧度
- Returns:
新的数据框(如果inplace为False)包含新的x、y、z列
- velocity_cartesian2polar(x='x', y='y', vx='vx', radius_polar=None, vy='vy', vr_out='vr_polar', vazimuth_out='vphi_polar', propagate_uncertainties=False, inplace=False)[source]#
将笛卡尔速度转换为极坐标速度。
- Parameters:
x
y
vx
radius_polar – 半径的可选表达式,如果提供可能会带来更好的性能。
vy
vr_out
vazimuth_out
propagate_uncertainties – 如果为真,将为新的虚拟列传播误差,详情请参见
propagate_uncertainties()
- Returns:
- velocity_cartesian2spherical(x='x', y='y', z='z', vx='vx', vy='vy', vz='vz', vr='vr', vlong='vlong', vlat='vlat', distance=None, inplace=False)[source]#
将速度从笛卡尔坐标系转换为球面坐标系
待办:不确定性传播
- Parameters:
x – x列的名称(输入)
y – y
z – z
vx – vx
vy – vy
vz – vz
vr – r 方向径向速度的列名(输出)
vlong – 经度方向速度分量的列名(输出)
vlat – 纬度方向速度分量的列名,正值指向北极(输出)
distance – 距离的表达式,如果未给出,则默认为 sqrt(x**2+y**2+z**2),但如果此列已存在,传递此表达式可能会带来更好的性能
- Returns:
- velocity_polar2cartesian(x='x', y='y', azimuth=None, vr='vr_polar', vazimuth='vphi_polar', vx_out='vx', vy_out='vy', propagate_uncertainties=False, inplace=False)[source]#
将圆柱极坐标速度转换为笛卡尔坐标。
- Parameters:
x
y
azimuth – 可选的方位角表达式,以度为单位,如果提供可能会带来更好的性能。
vr
vazimuth
vx_out
vy_out
propagate_uncertainties – 如果为真,将为新的虚拟列传播误差,详情请参见
propagate_uncertainties()
日志记录#
为vaex设置日志记录。
请参阅日志配置如何配置日志记录。