Roger V.'s questions

以下代码运行：

fn main() {
    let mut df = df! [
        "names" => ["a", "b", "c", "d"],
        "values" => [1, 2, 3, 4],
        "floats" => [1.25, 2., 1., 0.5]
    ].unwrap();
    // println!("{:?}", df);

    let names_to_remove = Series::new("bad names".into(), ["c", "d"]);

    let df1 = df
        .clone()
        .lazy()
        .filter(col("names").is_in(lit(names_to_remove)).not())
        .collect()
        .unwrap();
    println!("{:?}", df1);
}

现在我尝试做同样的事情，但过滤列的名称发生了变化：

fn main() {
    let mut df = df! [
        "names" => ["a", "b", "c", "d"],
        "values" => [1, 2, 3, 4],
        "floats" => [1.25, 2., 1., 0.5]
    ].unwrap();
    // println!("{:?}", df);

    let old_name = &df.get_column_names_owned()[0]; // rename first column
    let _ = df.rename(old_name, "all_names".into());
    // println!("{:?}", df);
    // println!("{:?}", df.column("all_names").unwrap());

    let cols_to_remove = Series::new("bad names".into(), ["c", "d"]);

    let df1 = df
        .clone()
        .lazy()
        .filter(col("all_names").is_in(lit(cols_to_remove)).not())
        .collect()
        .unwrap();
    println!("{:?}", df1);
}

这会导致出现错误消息：

thread 'main' panicked at src/main.rs:42:10:
called `Result::unwrap()` on an `Err` value: ColumnNotFound(ErrString("unable to find column \"all_names\"; valid columns: [\"names\", \"values\", \"floats\"]\n\nResolved plan until failure:\n\n\t---> FAILED HERE RESOLVING 'filter' <---\nDF [\"names\", \"values\", \"floats\"]; PROJECT */3 COLUMNS"))
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

该消息似乎表明第一列名称没有改变，尽管打印数据框或甚至按其名字提取的第一列都表明名称确实已改变。

但是，使用旧的列名也不起作用（col("all_names")--> col("names")）：

thread 'main' panicked at src/main.rs:43:10:
called `Result::unwrap()` on an `Err` value: ColumnNotFound(ErrString("\"names\" not found"))
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

我正在尝试通过不同框架中包含的名称对 rust-polars 数据框进行子集化：

use polars::prelude::*;

fn main() {
    let mut df = df! [
        "names" => ["a", "b", "c", "d"],
        "values" => [1, 2, 3, 4],
        "floats" => [1.25, 2., 1., 0.5]
    ].unwrap();
//    println!("{:?}", df);

    let mut df1 = df! [
        "names" => ["b", "c"],
        "values" => [2, 3]
    ].unwrap();
//    println!("original df: {:?}", df1);

    let df2 = df
        .lazy()
        .filter(col("names").is_in(df1.column("names")))
        .collect()
        .unwrap();
//    println!("{:?}", df2);
}

这会导致出现错误消息：

error[E0599]: no method named `is_in` found for enum `Expr` in the current scope
   --> src/main.rs:22:30
    |
22  |         .filter(col("names").is_in(df1.column("names")))
    |                              ^^^^^
    |
help: there is a method `is_finite` with a similar name, but with different arguments
   --> /home/puller/.cargo/registry/src/index.crates.io-6f17d22bba15001f/polars-plan-0.46.0/src/dsl/mod.rs:781:5
    |
781 |     pub fn is_finite(self) -> Self {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0599`.
error: could not compile `drop_row` (bin "drop_row") due to 1 previous error

此页面建议is_in“仅在 crate 功能 polars-ops 上可用”。但是，将“polars-ops”添加到我的 Cargo.toml 并没有帮助：

[dependencies]
polars = {version = "0.46.0", features = ["lazy", "polars-ops"]}

此外，的签名似乎与本问题is_in中讨论的签名不同。因此，尚不清楚该功能是否已被贬值或可从另一个板条箱或其他东西中获得。

我也试过

    let df2 = df
        .lazy()
        .filter(is_in(col("names"), df1.column("names")))
        .collect()
        .unwrap();
    println!("{:?}", df2);

在这种情况下，错误信息是

error[E0425]: cannot find function `is_in` in this scope
  --> src/main.rs:30:17
   |
30 |         .filter(is_in(col("names"), df1.column("names")))
   |                 ^^^^^ not found in this scope

For more information about this error, try `rustc --explain E0425`.
error: could not compile `drop_row` (bin "drop_row") due to 1 previous error

更新
仔细查看之前链接的威胁，正确的签名是这个，来自 crate is_in。错误消息是 no

error[E0277]: the trait bound `Expr: From<&polars::prelude::Column>` is not satisfied
    --> src/main.rs:19:36
     |
19   |         .filter(col("names").is_in(df1.column("names").unwrap()))
     |                              ----- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<&polars::prelude::Column>` is not implemented for `Expr`
     |                              |
     |                              required by a bound introduced by this call
     |
     = help: the following other types implement trait `From<T>`:
               `Expr` implements `From<&str>`
               `Expr` implements `From<AggExpr>`
               `Expr` implements `From<bool>`
               `Expr` implements `From<f32>`
               `Expr` implements `From<f64>`
               `Expr` implements `From<i16>`
               `Expr` implements `From<i32>`
               `Expr` implements `From<i64>`
             and 3 others
     = note: required for `&polars::prelude::Column` to implement `Into<Expr>`
note: required by a bound in `polars_plan::dsl::<impl Expr>::is_in`
    --> /home/puller/.cargo/registry/src/index.crates.io-6f17d22bba15001f/polars-plan-0.46.0/src/dsl/mod.rs:1190:21
     |
1190 |     pub fn is_in<E: Into<Expr>>(self, other: E) -> Self {
     |                     ^^^^^^^^^^ required by this bound in `polars_plan::dsl::<impl Expr>::is_in`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `drop_row` (bin "drop_row") due to 1 previous error

以下重命名 Polars-Rust 数据框中的一列：

#![allow(unused_variables)]
use polars::prelude::*;

fn main() {
    println!("Hello, world!");
    let mut df = df! [
        "names" => ["a", "b", "c"],
        "values" => [1, 2, 3],
    ].unwrap();

    println!("{:?}", df);

    let new_name = <PlSmallStr>::from_str("letters");
    let _ = df.rename("names", new_name);
    println!("{:?}", df);
}

现在假设第一列的名称未知（例如，数据框是从 csv/excel 文件中读取的，其中没有名称），我想重命名它以便于将来使用：

fn main() {
    println!("Hello, world!");
    let mut df = df! [
        "names" => ["a", "b", "c"],
        "values" => [1, 2, 3],
    ].unwrap();

    println!("{:?}", df);

    let old_name = df.get_column_names_str()[0];
    // let old_name = df.get_column_names_str()[0].clone();
    // let old_name = &mut df.get_column_names_str()[0].clone();
    // let mut old_name = &mut df.get_column_names_str()[0].clone();
    let new_name = <PlSmallStr>::from_str("letters");
    let _ = df.rename(old_name, new_name);
    println!("{:?}", df);
}

这会导致错误

error[E0502]: cannot borrow `df` as mutable because it is also borrowed as immutable
  --> src/main.rs:32:13
   |
27 |     let old_name = df.get_column_names_str()[0];
   |                    -- immutable borrow occurs here
...
32 |     let _ = df.rename(old_name, new_name);
   |             ^^^------^^^^^^^^^^^^^^^^^^^^
   |             |  |
   |             |  immutable borrow later used by call
   |             mutable borrow occurs here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `rename_col` (bin "rename_col") due to 1 previous error

错误发生的原因或多或少是清楚的，但如何修复它并不清楚......
注释行显示了我解决这个问题的各种不成功的尝试。

相关：
在 Rust 中，如何重命名 Polars Dataframe 的所有列？
如何重命名 Polars 中第一行的列名？

我很难对 Polars-Rust 数据框中的一列求和。例如，以下代码片段：

use polars::prelude::*;

fn main() {

    // let numbers = [1, 2, 3, 4, 5];
    let n = 5;
    let numbers: Vec<u32> = (1..=n).collect();
    let sum: u32 = numbers.iter().sum();
    println!("the sum is: {}", sum);

    let names: Vec<String> = (1..=n).map(|v| format!("row{v}")).collect();

    // creating dataframe
    let c1 = Column::new("names".into(), &names);
    let c2 = Column::new("numbers".into(), &numbers);
    let df = DataFrame::new(vec![c1, c2]).unwrap();
    println!("{:?}", df);

    let column_sum: u32 = df.column("numbers").iter().sum();
    println!("the columns sum is: {}", column_sum);

}

会产生此错误：

error[E0277]: a value of type `u32` cannot be made by summing an iterator over elements of type `&&polars::prelude::Column`
  --> src/sum_column.rs:19:55
   |
19 |     let column_sum: u32 = df.column("numbers").iter().sum();
   |                                                       ^^^ value of type `u32` cannot be made by summing a `std::iter::Iterator<Item=&&polars::prelude::Column>`
   |
   = help: the trait `std::iter::Sum<&&polars::prelude::Column>` is not implemented for `u32`
   = help: the following other types implement trait `std::iter::Sum<A>`:
             `u32` implements `std::iter::Sum<&u32>`
             `u32` implements `std::iter::Sum`
note: required by a bound in `std::iter::Iterator::sum`
  --> /rustc/9fc6b43126469e3858e2fe86cafb4f0fd5068869/library/core/src/iter/traits/iterator.rs:3515:5

For more information about this error, try `rustc --explain E0277`.
error: could not compile `sum_column` (bin "sum_column") due to 1 previous error

从这条消息来看，这似乎是一个小问题……但我对 Rust 还不熟悉，不清楚这条消息到底是什么意思。非常感谢您的帮助。

在我的 Julia 代码中，我使用来自其他文件的函数，这些函数是通过 include 添加的。例如，我可能有类似

using DataFrames, CSV
import Random: shuffle, seed
using Base.Filesystem: mkpath

include("existing_code.jl")

seed!(2025)

但是，代码中existing_code.jl可能已经包含类似

using DataFrames, CSV, Random
using Base.Filesystem: mkpath

Random.seed!(1984)

但是，我的印象是，由于模块（例如DataFrames, CSV, Random已经在其他文件中导入，因此无需重新导入它们。我想知道，这里的好做法是什么？不遵循良好做法可能存在哪些危险？

我对 Julia 和 Julia DataFrames 还不熟悉。我的理解是，DataFrames 不支持 MultiIndexing，这通常不会造成太大问题，但将一些 Python 习惯转换为 Julia 却很困难。我想知道如何按列加载和子选择特征，如下例所示。

import numpy as np
import pandas as pd

#generating sample data
nsmpls = 10
smpls = [f'smpl{j}' for j in range(nsmpls)]

nfeats = 5
feats = [f'feat{j}' for j in range(nfeats)]

data = np.random.rand(nfeats, nsmpls)

countries = ['France'] * 2 + ['UK'] * 3 + ['US'] * 5

df = pd.DataFrame(data, index=feats, columns=pd.MultiIndex.from_tuples(zip(countries, smpls)))
df.to_csv('./data.tsv', sep='\t')

#---------------------------------------------------------------------
#loading dataset
df = pd.read_csv('./data.tsv', sep='\t', index_col=0, header=[0,1])

#extracting subset
dg = df.xs('France', level=0, axis=1)
print(dg.shape)

#iterating
for country, group in df.groupby(level=0, axis=1):
    print('#samples: {}'.format(group.shape[1]))