polars中的选择器及聚合操作

数据筛选是做数据分析时必不可少的常用操作

polars通过一个Selectors类来实现常用的数据筛选，我们称之为选择器

通过polars.selectors包中个多种函数可以创建不同功能的Selectors选择器

首先需要引入该包

官方建议是将包重命名为cs，你也可以重命名为任意名称或直接使用

import polars.selectors as cs

后续使用cs.func_name()的方式来调用该包中的各种函数创建不同功能的Selectors选择器

选择器的逻辑运算

&  ：逻辑与，例  A & B
|  ：逻辑或，例  A | B
~  ：逻辑非，例  ~A
-  ：差集，  例  A - B，满足A但不满足B
^  ：异或，  例  A ^ B，两者有且仅有一个满足时返回True

根据数据类型筛选

binary()    二进制

boolean()   布尔值

string(*, include_categorical=False)  ：String，参数表示是否包含Categorical类型
categorical()   Categorical

float()     float32或float64
decimal()   decimal

signed_integer()    有符号的int
unsigned_integer()  无符号的int
integer()           int，包含所有int类型

numeric()           数字，包含所有int和float类型

date()   date
time()   time
datetime(time_unit=None, time_zone=None)   datetime
    time_unit，str|list[str]，表示进一步筛选数据精度为指定级别，可选值ms,us或ns
    time_zone：str|list[str]，表示根据时区筛选
        为None表示选择没有时区的列
        为*表示具有任何时区的列
duration(time_unit=None)   选择数据类型为duration的列
temporal()   选择所有时间或日期类型的列

by_dtype(*dtypes) ：选择数据类型为指定类型的列，多个类型使用逗号隔开且关系为逻辑或

根据列名筛选

by_name(*names, require_all=True)   根据列名称选择指定的列
    require_all表示是否要求所有列都匹配，在指定的某些列可能不存在时
    返回数据列的排序根与传入的列名称顺序一致

alpha(ascii_only=False, *, ignore_spaces=False)   选择列名仅由字母组成的列
    ascii_only：是否只考虑ASCII字母，还是考虑整个Unicode范围
        当为False时，带音调的字母，汉字都被视为合法字母
    ignore_spaces：是否忽略空格

alphanumeric(ascii_only=False, *, ignore_spaces=False)  选择列名仅由字母和数字组成的列

digit(ascii_only=False)  选择列名仅由数字组成的列

contains(*substring)     选择名称包含特定字符串的列，多个使用逗号隔开且关系为逻辑或

starts_with(*prefix)     选择名称以指定字符串开始的列，多个使用逗号隔开且关系为逻辑或
ends_with(*suffix)       选择名称以指定字符串结束的列，多个使用逗号隔开且关系为逻辑或

matches(pattern)         选择名称匹配指定的正则字符串的列

根据列名选择还有一个更常用的方法，使用polars包中的col方法，polars.col(colname)

根据位置筛选

all()    选择所有列
first()  选择第一列
last()   选择最后一列

by_index(*indexs)   根据列索引选择指定的列，可以为负数，也可以为一个range
    返回数据列的排序根与传入的列索引顺序一致

其他筛选

exclude(*columns)    选择与指定列的逻辑非匹配的列，等价于逻辑非运算符"~"
    可以传入若干列名str或Selectors或他们组成的list

expand_selector(dataFrame, selector, *, strict=True)
    返回将dataFrame进行selector指定的筛选后的列名组成的list
    strict为False表示允许使用更广泛的选择器表达式，如exclude()

聚合操作

选择器可以让我们选择满足一定条件的数据，当选择了这些数据以后我们还可以进行一些聚合操作，通过与选择器链式调用来进行一些聚合操作

其实聚合操作就是对选定了每一列数据进行操作，每一列的数据为一个Series，所以理论上Series可用的所有方法均可作为聚合函数进行链式调用

对列中的数据进行简单计算

pl.col("C")/2
    对C列每个数字进行除2操作，列名仍然是C

pl.col("C") + pl.col("D")
    将C列与D列数据进行相加
    列名以第一个选择器为准，该例种列名为C

设置列名

alias(name)
rename(name)

数据信息

cast(dtype,*,strict=True)  转换数据类型，转换错误不抛出异常会转换为null

estimated_size(unit = 'b')   返回数据的堆分配大小的估计值
                  参数为返回数值的单位，可选'b', 'kb', 'mb', 'gb', 'tb'
n_chunks()        int，此数据在内存中的连续内存块数量
lower_bound()     该数据dtype的下限，返回仅包含该下限一个值的Series
upper_bound()     该数据dtype的上限

数据排序

shuffle(seed = None)  随机排序数据，seed表示一个int类型的种子，None表示每次调用都生成一个随机种子
search_sorted(value,side='any')  获取在一个已排序的数据中插入value时应该插入的索引值
                  side表示如果已经存在该值时插入的位置，any、left、right
reverse()         反转数据

arg_sort(*,descending=False,nulls_last=False)  获取数据排序的索引
                escending表示是否降序
                并不会对数据实际进行排序，仅返回排序的索引
                pl.Series("a", [5, 3, 4, 1, 2]).arg_sort()
                // Series [3,4,1,2,0]
is_sorted(*, descending = False, nulls_last = False)  数据是否已经排序
                  descending表示是否降序
sort(*,descending=False,nulls_last=False,multithreaded=True,in_place=False)
                  对数据进行排序
                  descending表示是否降序
                  multithreaded表示是否多线程
set_sorted(*, descending = False)  将数据标注为已排序状态用以加快后续的相关操作
                  如果数据未排序，在后续的操作中可能会导致无法预知的结果

数据优化

rechunk(*, in_place = False)  将数据整合到一个连续的内存块中
shrink_dtype()    降低数据占用内存，自动分析所有数据并将dtype转化为可以放置完整数据的占用空间最小的数据类型
                  s = pl.Series("a", [3, 4, 5, 6])  // 默认为 i64 数据类型
                  s.shrink_dtype()  // 自动转化为 i8 数据类型

shrink_to_fit(*, in_place = False)  通过缩小底层数组容量(不修改数据类型)的方式优化数据的内存占用

数学计算

cum_count(*, reverse = False)  非null值的累计数量
cum_max(*, reverse = False)    累计最大值
cum_min(*, reverse = False)    累计最小值
cum_prod(*, reverse = False)   累计乘积
cum_sum(*, reverse = False)    累计和

ceil()            每个值向上获取最小的整数
floor()           每个值向下获取最大的整数

bitwise_and()     按位与
bitwise_or()      按位或
bitwise_xor()     按位异或

log(base = 2.718281828459045)  每个值的指定底数的对数
log10()           每个值的10为底数的对数
pow(n)            每个值的指定幂的值，可以传入int、float或Series
cbrt()            立方根
sqrt()            平方根
std(ddof = 1)     标准差
abs()             绝对值
max()/min()       最大/小值
mean()            平均值
sum()             求和
median()          中位数
round(decimal=0)  按指定小数位数四舍五入值

逻辑运算

all()           所有数据是否都为True
any()           数据中是否存在True
has_nulls()     是否包含null值
is_empty()      是否为空数据

is_nan()        每个值是否为NaN
is_not_nan()    每个值是否不为NaN
is_null()       每个值是否为null
is_not_null()   每个值是否不为null
is_duplicated() 每个值在数据中是否存在重复
is_unique()     每个值在数据中是否唯一
is_first_distinct()  每个值是否首次出现
is_last_distinct()   每个值是否是最后一次出现

is_in(other)    每个值在另一个Series中是否存在
not_()          每个值运行逻辑非
is_between(lower_bound,upper_bound,closed='both')
                返回数据中的元素是否在指定区间
                lower_bound表示下限，upper_bound表示上限
                closed定义区间的哪些边是闭合的(含该值)
                  both, left, right, none

统计信息

approx_n_unique()  唯一值的近似计数，结果是一个近似值，但计算速度非常快
n_unique()         唯一值的数量
value_counts(*,sort = False,name = None,normalize = False)
                  计算唯一值出现的次数
                  sort表示结果是否排序(从大到小)
                  normalize表示是否计算为相对频率，默认计算为次数
                  返回一个DataFrame，第一列名为Series的名字
                  第二列名称由name参数指定，为None时
                    normalize为False为count
                    normalize为True为proportion
null_count()      null值的数量
count()           非null数据的数量
len()             数据数量，含null
mode()            出现次数最多的值，返回的Series可能有多个值
sign()            每个元素的数字符号表示，1表示正数，-1表示负数，NaN和null会原封输出，其余用0表示
                  如果数据类型为float，会将结果转换为对应数据类型

arg_max()         最大值的索引值
arg_max()         最小值的索引值
arg_true()        获取表达式计算为True的元素的索引
                  (pl.Series("a", [1, 2, 3]) > 1).arg_true()
                  // Series [1,2]
arg_unique()      唯一值的索引

增

append(Series)  在数据后面追加另一个Series
extend(Series)  在数据后面追加另一个Series
                append不会重新申请内存，原数据占用一块内存，新增数据可能在另外一块不连续的内存
                extend如果现有内存不足以放置拓展后的数据，会重新申请内存以保证所有数据在一个连续的内存块中
                操作层面append由于不涉及内存申请会更加快速
                查询层面extend由于存放于连续内存中会更加快速
extend_constant(value, n)  使用value值在数据后面填充n次
                value可以为一个确切的值，也可以为一个计算表达式
shift(n = 1, *, fill_value = None)  将数据整体上移n位，空出的数据用fill_value填充
                n可以为负数，表示向下移动

删

clear(n = 0)      返回一个清空数据后用n行空数据(null)填充的数据副本
drop_nans()       删除所有浮点 NaN 值
drop_nulls()      删除所有 null 值

改

scatter(index,value)  设置指定索引位置的值
set(filter,value) 将满足filter条件的元素值替换为value

fill_nan(value)   使用指定值替代浮点 NaN 值
fill_null(value,strategy,limit)  使用指定值替代 null 值
                  strategy表示填充策略，可选值
                  ‘forward’, ‘backward’, ‘min’, ‘max’, ‘mean’, ‘zero’, ‘one’
                  limit表示使用 'forward' 或 'backward' 策略时要填充的连续null值的数量
interpolate(method = 'linear')  使用差值法填充null值，linear为线性，nearest为最近
Series.interpolate_by(other)    基于另一个Series来填充null值
                  s1 = pl.Series([1, None, None, 3])
                  s2 = pl.Series([1, 2, 7, 8])
                  s1.interpolate_by(s2)
                    // Series [1.0,1.285714,2.714286,3.0]
                    // 会基于已有数据进行分析推断
map_elements(func,redtype=None,*,skip_nulls=True)
                  返回每个值经过func函数处理后的返回值组成的Series
                  redtype在函数返回不同的数据类型时必须提供
                  skip_nulls表示是否跳过null值
                  func处理未经过优化，性能可能会很低
replace(old,new)  将值为old的元素替换为new
                  如果new的数据类型与原数据类型不同，会转换为原数据类型
                  old可以传入一个list，对应的new也需要传入相同长度的list

replace_strict(old,new,*,default,return_dtype=None)
                  将值为old的元素替换为new
                  没有替换的元素统一替换为default值
                  数据的数据类型转换为new的数据类型
                  return_dtype不指定会自动推断

查

first()/last()    第/最后一个值
bottom_k(k = 5)   获取k个最小的元素，非null始终优先于null
top_k(k = 5)      获取k个最大的元素，非null始终优先于null
head(n = 10)      前 n 个元素，n如果为负，则返回倒数第n个元素至末尾的数据
limit(n=10)       head()的别名函数
tail(n=5)         最后n行个元素
item(index = 0)   获取指定索引的值
filter(expr)      返回每个元素经过表达式expr处理为True的数据
                  data.filter(data>2)  // 返回data中所有大于2的数据
gather(ints)      跟据索引返回对应数据，可以传入一个int或list
gather_every(n,offset=0)  从偏移量offset开始每隔n个元素取一个值
unique(*, maintain_order = False)  返回唯一值组成的Series
                  maintain_order表示是否保持原顺序

其他操作

slice(offset, length = None)  截取数据，offset支持负数

explode()        分解元素中的list值，每个list元素会新增一行
implode()         将所有的值聚合到一个list中，返回的Series仅有一个list元素
clone()           返回当前数据的副本
get_chunks()      按数据在内存中的存放块返回每个内存块中的Series
to_init_repr(n = 1000)  返回前n行数据的和直接打印的格式相同的字符串
to_frame(name=None)  转换为单列的DataFrame数据，name表示列名
to_list()         转换为python的list，此操作会复制数据
new_from_index(index,len)  创建一个将索引index处的值重复len次的新Series