vaex的使用

最新推荐文章于 2024-02-16 14:42:13 发布

落日晚风愿能与你共赏

最新推荐文章于 2024-02-16 14:42:13 发布

阅读量3.9k

点赞数 9

文章标签： python

本文链接：https://blog.csdn.net/qq_45659384/article/details/110920467

版权

DataFrame

import vaex
import numpy as np
# 读取vaex自带数据
df = vaex.example()
#读取指定列
df.x
#获取指定列值
df.x.values
#虚拟列
df['r'] = np.sqrt(df.x**2 + df.y**2 + df.z**2) #构造虚拟列由来
#重构表格
df[['x', 'y', 'z', 'r']]

#将一个内存阵列添加为一列
df.add_column(name, f_or_array, dtype=None)

#将变量添加到DataFrme
add_variable(name, expression, overwrite=True, unique=True)

# 将虚拟列添加到DataFrame
add_virtual_column(name, expression, unique=False)
例：df.add_virtual_column("r", "sqrt(x**2 + y**2 + z**2)")

#apply在整个DataFrame中逐行应用一个函数。
apply（f，arguments = None，vectorize = False，multiprocessing = True）
f –要应用的功能
arguments –要传递给函数f的参数列表。
vectorize –使用数组而不是标量调用f（以获得更好的性能）。
multiprocessing（bool）–使用多个进程来避免GIL（全局解释器锁定）
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)

# 考虑到active_fraction，返回整个DataFrame需要（或选择）的字节大小。
byte_size(selection=False, virtual=False)

# 显示从第i1行到i2行的DataFrame
cat(i1, i2, format='html')

# col仅直接访问列 
df.col.x

# 返回列数（包括虚拟列）
column_count(hidden=False)

# 生成给定维的可能表达式的组合列表。
combinations(expressions_list=None, dimension=2, exclude=None, **kwargs)
expressions_list –表达式列表的列表，其中内部列表定义子空间
dimension–如果给定，则生成具有该维所有可能组合的子空间
exclude–清单

#计算非NaN值的数目（如果表达式为None或“ *”，则为全部）
count(expression=None, binby=[], limits=None, shape=128, selection=False, delay=False, edges=False, progress=None, array_type=None)
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 –一个带有一个表示进度的参数（0到1之间的浮点值）的可调用对象，当该可调用对象返回False时，将取消计算
edges–目前仅供内部使用（它包括在边界nan和0处超出限制的nan和值，小于1且大于-1
array_type –输出数组的类型，可能的值是None /“ numpy”（ndarray），xarray.DataArray的“ xarray”，或Python列表的“ list”

# 计算x和y或者更多表达式的协方差矩阵
cov(x,y)
#计算x和y之间的协方差
covar(x,y)
# 返回给定表达式的数据类型
data_type(expression,array_type=None,internal=False)
array_type（str）–'numpy'，'arrow'或None，指示是否应转换数据类型

#从DataFrame删除变量
delete_variable(name)
#从DataFrame删除虚拟列
delete_virtual_column(name)
#给出DataFrame的描述
describe(strings=True,virtual=True,selection=None)
strings（bool）–是否描述字符串列
virtual（bool）–是否描述虚拟列
selection –要使用的可选选项。
# 删除列
drop(column,inplace=False,check=True)
column–列列表或单个列名称
inplace–修改自身或返回新的DataFrame
check –为true时，它将检查该列是否用于虚拟列或过滤器中，并隐藏它。
#从DataFrame中删除所有过滤器
drop_filter(inplace = False)
#创建一个DataFrame的浅表副本，并使用isinf进行过滤。：param column_names：要考虑的列，默认值：所有（真实，非虚拟）列：rtype：DataFrame
dropinf（column_names = None）
# 创建DataFrame的浅表副本，并使用ismissing进行过滤
dropmissing（column_names = None）
#创建一个DataFrame的浅表副本，并使用isna进行过滤。
dropna（column_names = None）
#创建一个DataFrame的浅表副本，并使用isnan进行过滤。
dropnan（column_names = None）
# 返回一个DataFrame，其中缺失的值/ NaN用“值”填充。原始列将被重命名，默认情况下，它们将是隐藏列。没有数据丢失。
fillna(value, column_names=None, prefix='__original_', inplace=False)
value（float）–用于填充nan或masked值的值。
fill_na（bool）–如果为True，则用value填充np.nan值。
fill_masked（bool）–如果为True，则使用values填充被屏蔽的值。
column_names（list）-列名称列表，用于在其中填充缺失值。
prefix（str）–赋予原始列的前缀。

#返回列名列表
get_column_names(virtual=True, strings=True, hidden=False, regex=None)
virtual –如果为False，则跳过虚拟列
hidden –如果为False，则跳过隐藏的列
字符串–如果为False，则跳过字符串列
regex –仅返回与（可选）正则表达式匹配的列名
alias –返回别名（True）或内部名称（False）

#可以“选择”单个行，这是当前行的索引（整数），或者“无”不选择任何行。
get_current_row()
#返回列名和变量名列表
get_name(hidden=False)
#每个DataFrame都有一个目录，用于存储元数据等的文件。
get_private_dir(create=False)

#重命名列或变量
rename（name，new_name，unique = False）
# 排序 by=列名，ascending=True为升序，否则为降序
sort（by，ascending = True，kind = 'quicksort'）
# 在字典中返回DataFrame的内部状态
state_get（）
# 将内部状态写入json或yaml文件
state_write（file，fs_options = None）

#返回表达式中中NA值的数量，包括缺失值和NAN
countno()
#返回NAN的数量
countnan()
#填充
fillmissing(value)#返回一个数组，其中缺少的值将替换为值
fillna(value) fillnan(value)
isin(value,use_hashmap=True) #懒惰地测试表达式中的每个值是否存在值中

读取文件

函数	功能
vaex.exampe()	返回vaex附带的示例DataFrame，用于测试/学习。
vaex.from_arrays(**arrays)[source]	从numpy数组创建一个内存中的DataFrame。参量：带有数组的关键字参数x=[],y=[]
vaex.from_arrow_table(table）	从arrow表创建一个vaex DataFrame。
vaex.from_ascii(path, seperator=None,names=True, skip_lines=0, skip_after=0, **kwargs)	从ascii文件（默认情况下为空格）创建一个内存DataFrame。
vaex.from_csv(filename_or_buffer=None,copy_index=None,chunk_size=None,convert=False,fs_option={},**kwarge)	读取CSV文件作为DataFrame，并可选地转换为hdf5文件。
vaex.from_dict(data)
vaex.from_item(data)
vaex.from_pandas(df,name=‘pandas’,cop_index=False,index_name=‘index’)

--
#names –如果为True，则第一行用于列名，否则提供带有名称的字符串列表
#skip_lines –跳过文件开头的行
#skip_after –跳过文件末尾的行
ds = vx.from_ascii("table.asc")
ds = vx.from_ascii("table.csv", seperator=",", names=["x", "y", "z"])
--
#filename_or_buffer（str）– CSV文件路径或类似文件的路径
#copy_index（bool）–通过pandas读取源时的复制索引
#str convert（bool）–将文件转换为hdf5文件以进行优化，也可以是路径。CSV文件将分块读取：使用提供的chunk_size参数或默认大小读取。每个块将保存为一个单独的hdf5文件，然后将它们全部合并为一个hdf5文件。因此，对于大CSV文件，您至少需要磁盘上额外空间的两倍。用于转换的默认chunk_size为500万行，相当于纽约出租车数据集示例中大约1Gb的内存。
#kwargs –额外的关键字参数，当前传递给Pandas的read_csv函数，但其实现可能会在将来的版本中更改。
#chunk_size（int）–如果CSV文件太大而无法容纳在内存中，则此参数可用于大块读取CSV文件。例如：
import vaex
for i, df in enumerate(vaex.from_csv('taxi.csv', chunk_size=100_000)):
     df = df[df.passenger_count < 6]
     df.export_hdf5(f'taxi_{i:02}.hdf5')

导出数据

df.export_csv('va.csv')

选择和过滤

# 筛选df.x的数据 selection为选择条件
df.evaluate(df.x, selection=True)
df.evaluate(df.x, selection=df.x>0) #获取df.x列中df.x>0的数据（不包含其他列）
df_negative = df[df.x < 0] #获取df.x<0的数据（包含其他列）

统计

# 计数 求均值
df.count(selection=df.x<0)
df.mean(df.x)
# 统计df.x在范围limits（[-10,10]）区间分为shape（64）组，每一组的个数
counts_x = df.count(binby=df.x, limits=[-10, 10], shape=64)
#统计df.x，df.y在范围limits（[-10, 10], [-10, 20]）区间分为shape（64,128）组，每一组的个数
xycounts = df.count(binby=[df.x, df.y], limits=[[-10, 10], [-10, 20]], shape=(64, 128))

表达式	功能
`vaex.dataframe.DataFrame.count`（[表达式，…]）	计算非NaN值的数目（如果表达式为None或“ *”，则为全部）。
`vaex.dataframe.DataFrame.mean`（表达式[，…]）	计算表达的平均值，可能在binby定义的网格上。
`vaex.dataframe.DataFrame.std`（表达式[，…]）	计算给定表达式的标准偏差，可能在binby定义的网格上
`vaex.dataframe.DataFrame.var`（表达式[，…]）	计算给定表达式的样本方差，可能在binby定义的网格上
`vaex.dataframe.DataFrame.cov`（x [，y，binby，…]）	计算x和y或更多表达式的协方差矩阵，可能在binby定义的网格上。
`vaex.dataframe.DataFrame.correlation`（x [，y，…]）	计算x和y之间的相关系数cov [x，y] /（std [x] * std [y]），可能在binby定义的网格上。
`vaex.dataframe.DataFrame.median_approx`（…）	计算中位数，可能在binby定义的网格上。
`vaex.dataframe.DataFrame.mode`（表达式[，…]）	计算/估计模式。
`vaex.dataframe.DataFrame.min`（表达式[，…]）	计算给定表达式的最小值，可能在binby定义的网格上。
`vaex.dataframe.DataFrame.max`（表达式[，…]）	计算给定表达式的最大值，可能在binby定义的网格上。
`vaex.dataframe.DataFrame.minmax`（表达）	计算表达式的最小和最大值，可能在binby定义的网格上。
`vaex.dataframe.DataFrame.mutual_information`（X）	在形状为mi_shape和mi_limits的网格上（可能在binby定义的网格上）估计x和y之间的相互信息。
df.sum(df.y,selection=[df.x<0,df.x>0])

获取数据

import vaex
import numpy as np
x = np.arange(5)
y = x**2
df = vaex.from_arrays(x=x, y=y)
df

from_arrow_table：arrow表支持
from_csv：用逗号分隔的文件
from_ascii：用空格/制表符分隔的文件
from_pandas：转换一个熊猫DataFrame
from_astropy_table：转换一个天体表

将DataFrame导出或转换为其他数据结构也非常容易：

绘图

import vaex
import numpy as np
df = vaex.example()
# 一维绘图，仅提供一个参数时，他将显示一个直方图，显示数据的99.7%（可以抛弃偏差过大的异常值）
df.plot1d(df.x, limits='99.7%');#会画出df.x中每一个值拥有的个数，既分组计数
# 复杂程度更高的可视化效果不是绘制计数，而是绘制该仓的不同统计信息
df.plot1d(df.x, what='mean(E)', limits='99.7%');# 当x等于某个值的时候，对应的E的平均值（将x进行分组，将每一个组里面的E值求平均作为该x对应的y）
# 等效于
df.plot1d(df.x, what=vaex.stat.mean(df.E), limits='99.7%');

# 通过自己计算统计量并将其传递给plot1d的grid参数
# grid既为y的值
limits = [-30, 30]
shape  = 64
meanE  = df.mean(df.E, binby=df.x, limits=limits, shape=shape)
grid   = np.clip(np.log(-meanE), 11, 11.4)
df.plot1d(df.x, grid=grid, limits=limits, ylabel='clipped E');

#在每一组x对应的每一个y下的
# 例：当x=1,y=1时对应的df.E的平均值（sum(df.E)/count(df.E)）
df.plot(df.x, df.y, what=vaex.stat.mean(df.E), limits='99.7%');
# 添加选择条件
df.plot(df.x, df.y, what=np.log(vaex.stat.count()+1), limits='99.7%',
        selection=[None, df.x < df.y, df.x < -10]);

#根据df中的x和y列，x和z列画出
df.plot([["x", "y"], ["x", "z"]], limits='99.7%',
        title="Face on and edge on", figsize=(10,4));
#添加选择条件
df.plot([["x", "y"], ["x", "z"]],
        limits='99.7%',
        what=[np.log(vaex.stat.count()+1), vaex.stat.mean(df.E)],
        selection=[None, df.x < df.y],
        title="Face on and edge on", figsize=(10,10));

#画散点图，根据条件筛选数据，c为颜色，alpha为透明度，s为点的大小
df.scatter(df.x, df.y, selection=df.Lz < -2500, c="red", alpha=0.5, s=4)
df.scatter(df.x, df.y, selection=df.Lz > 1500, c="green", alpha=0.5, s=4);

表连接

a = np.array(['a', 'b', 'c'])
x = np.arange(1,4)
df1 = vaex.from_arrays(a=a, x=x)

b = np.array(['a', 'b', 'd'])
y = x**2
df2 = vaex.from_arrays(b=b, y=y)
#将df1拼接在df2左边，其中保留左侧DataFrame（df1）的所有行，并df2添加右侧DataFrame（）的匹配行。（将df1的a与df2的b相比较若df1的a列与df2的b列的值相同则拼接，若不同则df1保留，df2同空值填充）
df1.join(df2, left_on='a', right_on='b')
#将df1拼接在df2有边
df1.join(df2, left_on='a', right_on='b', how='right')
#内连接，仅仅保留df1中的a列和df2中b列相同的值所对应的行
df1.join(df2, left_on='a', right_on='b', how='inner')

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)

other –其他要加入的DataFrame（右侧）
on –左表的默认键（自己）
left_on –左表（自身）的键，覆盖on
right_on –右表（其他）的默认键，覆盖on
lprefix –在名称冲突的情况下添加到左列名称的前缀
rprefix –右边类似
lsuffix –在名称冲突的情况下添加到左列名称的后缀
rsuffix –右边类似
方式–如何联接，“左”将所有行保留在左侧，并添加列（可能带有缺失值），“右”与self和其他交换方式相似。“内部”将仅返回重叠的行。
allow_duplication（bool）–当联接的列包含非唯一值时，允许复制行。
cardinality_other（int）–另一个表的唯一元素数（或估计数）。
prime_growth（bool）–内部使用的哈希表的增长策略在某些情况下可以提高性能（例如，未使用低位的整数）。
inplace–修改自身或返回新的DataFrame

聚合函数

# 数据
import vaex
animal = ['dog', 'dog', 'cat', 'guinea pig', 'guinea pig', 'dog']
age = [2, 1, 5, 1, 3, 7]
cuteness = [9, 10, 5, 8, 4, 8]
df_pets = vaex.from_arrays(animal=animal, age=age, cuteness=cuteness)
df_pets

# 将df_pets中的animal列进行分组，添加列age为平均值，cuteness_mean、cuteness_std为cuteness的平均值和标准偏差
df_pets.groupby(by='animal').agg({'age': 'mean','cuteness': ['mean', 'std']})
得出结果为
#	animal	age	cuteness_mean	cuteness_std
0	dog	3.33333	9	0.816497
1	cat	5	5	0
2	guinea pig	2	6	2

Vaex支持多种聚合功能：

vaex.agg.count：组中元素的数量
vaex.agg.first：组中的第一个元素
vaex.agg.max：组中的最大值
vaex.agg.min：组中的最小值
vaex.agg.sum：一组的总和
vaex.agg.mean：一组的平均值
vaex.agg.std：一组的标准偏差
vaex.agg.var：组的方差
vaex.agg.nunique：组中唯一元素的数量

# 我们可以在groupby方法中指定聚合操作。我们也可以根据需要命名结果汇总列。
df_pets.groupby(by='animal',
                agg={'mean_age': vaex.agg.mean('age'),
                     'cuteness_unique_values': vaex.agg.nunique('cuteness'),
                     'cuteness_unique_min': vaex.agg.min('cuteness')})
# 添加选择条件
df_pets.groupby(by='animal',
                agg={'mean_cuteness_old': vaex.agg.mean('cuteness', selection='age>=5'),
                     'mean_cuteness_young': vaex.agg.mean('cuteness', selection='~(age>=5)')})

字符串处理

import vaex
text = ['Something', 'very pretty', 'is coming', 'our', 'way.']
df = vaex.from_arrays(text=text)
# 大写
df.text.str.upper()
# 替换
df.text.str.title().str.replace('et', 'ET')
#查看是否包含
df.text.str.contains('e')
# 查看出现的次数
df.text.str.count('e')

#将字符串样本的首字母大写
capitalize()
#将列拼接
cat(other)
#用其他字符填充字符串的左侧和右侧，以使样本总共具有宽度 字符。
center(width，fillchar = '')

#检查字符串模式的样本中是否包含字符串模式或正则表达式。
contains（pattern，regex = True）

pattern（str）–字符串或正则表达式
regex（bool）–如果为True

#计算字符串列样本中某个模式的出现次数。
count（pat，regex = False）

#检查每个字符串样本的末尾是否与指定的模式匹配
endswith(pat)

#测试字符串x和y是否相同
equals(y)

#返回列中每个字符串的最低索引，其中提供的子字符串完全包含在样本之间。如果未找到子字符串，则返回-1。
find（sub，start = 0，end = None）
sub为在样本中寻找的字符串

落日晚风愿能与你共赏

关注

9
点赞
踩
48

收藏

觉得还不错? 一键收藏
2
评论
vaex的使用

DataFrameimport vaeximport numpy as np# 读取vaex自带数据df = vaex.example()#读取指定列df.x#获取指定列值df.x.values#虚拟列df['r'] = np.sqrt(df.x**2 + df.y**2 + df.z**2) #构造虚拟列由来#重构表格df[['x', 'y', 'z', 'r']]#将一个内存阵列添加为一列df.add_column(name, f_or_array, dtype=None)
复制链接

扫一扫