主页 / coding / 问题

问题[dataframe](coding)

Martin Hope
Roger V.
Asked: 2025-02-24 21:28:16 +0800 CST
  • 7

以下重命名 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 中第一行的列名？

dataframe
Martin Hope
Roger V.
Asked: 2025-02-14 16:12:05 +0800 CST
  • 6

我很难对 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 还不熟悉，不清楚这条消息到底是什么意思。非常感谢您的帮助。

dataframe
Martin Hope
David Regan
Asked: 2024-11-21 16:25:28 +0800 CST
  • 7

我经常使用mapspark 数据集行上的函数在 Scala 中对类型化对象进行转换。我通常的模式是转换数据框转换（withColumn、groupBy等）创建的中间结果，并创建中间结果的类型化数据集，以便我可以使用map。

这种方法效果很好，但会导致中间结果或难以处理的元组类型产生很多“临时”的案例类。

另一种方法是map在数据框上运行并从行中检索类型字段，但如果是案例类，getAs[T]这似乎不起作用。spark.implicitsT

例如这给出了错误ClassCastException: org.apache.spark.sql.catalyst.expressions.GenericRowWithSchema cannot be cast to Person

import org.apache.spark._
import org.apache.spark.sql._
import org.apache.spark.sql.functions.{round => colRound, min => colMin, max => colMax, _}
import org.apache.spark.sql.expressions.Window

import spark.implicits._

final case class Person(name: String, age: Integer)
val people = Seq(Person("Alice", 20), Person("Bob", 30), Person("Charlie", 40)).toDS

val df = people.alias("p")
               .select($"p.name", struct($"p.*").alias("person"))
val ds = df.map(row => {
  val name = row.getAs[String]("name")
  val person = row.getAs[Person]("person")
  (name, person)
})

display(ds)

而这个工作正常：

import org.apache.spark._
import org.apache.spark.sql._
import org.apache.spark.sql.functions.{round => colRound, min => colMin, max => colMax, _}
import org.apache.spark.sql.expressions.Window

import spark.implicits._

final case class Person(name: String, age: Integer)
val people = Seq(Person("Alice", 20), Person("Bob", 30), Person("Charlie", 40)).toDS

val df = people.alias("p")
               .select($"p.name", struct($"p.*").alias("person"))
               .as[Tuple2[String, Person]]
val ds = df.map(row => {
  val name = row._1
  val person = row._2
  (name, person)
})

display(ds)

因此，在第二个示例中，spark 很乐意将数据框 person 结构转换为Personcase 类，但在第一个示例中却不会这样做。有人知道解决这个问题的简单方法吗？

谢谢，

大卫

dataframe
Martin Hope
dark.vador
Asked: 2024-11-01 18:29:34 +0800 CST
  • 5

尽管：

  1. polar_lazy 0.44.2的阅读

  2. 成功安装cargo add polars-lazy

以下代码会导致错误：

  • 错误[E0433]：无法解析：legacy找不到arrow

  • 错误[E0433]：无法解析：使用未声明的包或模块polars_core

  • PolarsResult错误[E0412]：在此范围内找不到类型

  • DataFrame错误[E0412]：在此范围内找不到类型

    use polars_core::prelude::*;
use polars_core::df;
use polars_lazy::prelude::*;
use arrow::legacy::prelude::QuantileMethod;

fn main() {
  let test = example()
  println!("show dataframe: {:?}", test);

}

fn example() -> PolarsResult<DataFrame> {
 let df = df!(
     "date" => ["2020-08-21", "2020-08-21", "2020-08-22", "2020-08-23", "2020-08-22"],
     "temp" => [20, 10, 7, 9, 1],
     "rain" => [0.2, 0.1, 0.3, 0.1, 0.01]
 )?;

 df.lazy()
 .group_by([col("date")])
 .agg([
     col("rain").min().alias("min_rain"),
     col("rain").sum().alias("sum_rain"),
     col("rain").quantile(lit(0.5), QuantileMethod::Nearest).alias("median_rain"),
 ])
 .sort(["date"], Default::default())
 .collect()
}

注意：Cargo.toml

[dependencies]
arrow = "53.2.0"
polars-lazy = "0.44.2"
dataframe
Martin Hope
Cristian Scutaru
Asked: 2024-10-31 01:16:23 +0800 CST
  • 7

我怀疑这肯定是为了某种向后兼容性。我只是试图找出背后的原因。Snowpark DataFrame API 的灵感来自 Apache Spark DataFrame API。

但是为什么这么多类似的DataFrame类方法，具有相同的签名和功能，却有两个不同的名称？

仅举几个例子（但还有很多）：

  • create_or_replace_temp_view和createOrReplaceTempView
  • to_df和toDF
  • group_by和GroupBy

另外，现在有首选符号吗？与这些调用相关的最佳实践有哪些？

dataframe
Martin Hope
John
Asked: 2024-10-14 12:01:55 +0800 CST
  • 5

我在 PySpark 代码中创建了以下数据框：

+---------------+-------------+---------------+------+
|TransactionDate|AccountNumber|TransactionType|Amount|
+---------------+-------------+---------------+------+
|     2023-01-01|          100|         Credit|  1000|
|     2023-01-02|          100|         Credit|  1500|
|     2023-01-03|          100|          Debit|  1000|
|     2023-01-02|          200|         Credit|  3500|
|     2023-01-03|          200|          Debit|  2000|
|     2023-01-04|          200|         Credit|  3500|
|     2023-01-13|          300|         Credit|  4000|
|     2023-01-14|          300|          Debit|  4500|
|     2023-01-15|          300|         Credit|  5000|
+---------------+-------------+---------------+------+

我需要将另一列打印为CurrentBalance。

预期输出：

+---------------+-------------+---------------+------+--------------+
|TransactionDate|AccountNumber|TransactionType|Amount|CurrentBalance|
+---------------+-------------+---------------+------+--------------+
|     2023-01-01|          100|         Credit|  1000|          1000|
|     2023-01-02|          100|         Credit|  1500|          2500|
|     2023-01-03|          100|          Debit|  1000|          1500|
|     2023-01-02|          200|         Credit|  3500|          3500|
|     2023-01-03|          200|          Debit|  2000|          1500|
|     2023-01-04|          200|         Credit|  3500|          5000|
|     2023-01-13|          300|         Credit|  4000|          4000|
|     2023-01-14|          300|          Debit|  4500|          -500|
|     2023-01-15|          300|         Credit|  5000|          1000|
+---------------+-------------+---------------+------+--------------+

我已尝试使用最小日期并在条件中传递日期来计算贷方和借方，但似乎不起作用。

# Find minimum date in TransactionDate column, grouped by AccountNumber column
df_new.groupBy('AccountNumber').agg(f.min('TransactionDate').alias('min_date'))
dataframe
Martin Hope
DJDuque
Asked: 2024-09-12 12:09:59 +0800 CST
  • 6

我有以下两个数据集：

  1. 这个可以非常可靠地告诉我某个事件是否发生，但它的时间戳仅在几秒钟内有效（假设是 2 秒）： 
    coarse = {
    "name": ["a", "a", "b", "c", "a"],
    "timestamp": [100, 103, 195, 220, 221],
}
coarse_df = pl.DataFrame(coarse)
"""
┌──────┬───────────┐
│ name ┆ timestamp │
│ ---  ┆ ---       │
│ str  ┆ i64       │
╞══════╪═══════════╡
│ a    ┆ 100       │
│ a    ┆ 103       │
│ b    ┆ 195       │
│ c    ┆ 220       │
│ a    ┆ 221       │
└──────┴───────────┘
"""
  1. 这个具有非常准确的时间，但它有一些噪音/误报（请注意，t=0两个数据集是不同的，有一个任意偏移）： 
    fine = {
    "name": ["a", "a", "a", "a", "b", "c", "b", "a"],
    "time": [0.05, 10.05, 12.51, 51.12, 106.0, 128.01, 130.0, 132.9],
}
fine_df = pl.DataFrame(fine)
"""
┌──────┬────────┐
│ name ┆ time   │
│ ---  ┆ ---    │
│ str  ┆ f64    │
╞══════╪════════╡
│ a    ┆ 0.05   │
│ a    ┆ 10.05  │
│ a    ┆ 12.51  │
│ a    ┆ 51.12  │
│ b    ┆ 106.0  │
│ c    ┆ 128.01 │
│ b    ┆ 130.0  │
│ a    ┆ 132.9  │
└──────┴────────┘
"""

我正在尝试以某种方式合并这些数据集以获得类似以下内容。本质上是从第二个数据集获取时间戳，并使用第一个数据集中的时间差来过滤掉误报。

"""
┌──────┬────────┐
│ name ┆ time   │
│ ---  ┆ ---    │
│ str  ┆ f64    │
╞══════╪════════╡
│ a    ┆ 10.05  │
│ a    ┆ 12.51  │
│ b    ┆ 106.0  │
│ c    ┆ 128.01 │
│ a    ┆ 132.9  │
└──────┴────────┘
"""

编辑

我目前正在做什么来识别假阳性（用文字表示，因为这是一个丑陋的嵌套 for 循环）：

鉴于两个数据集之间的偏移是任意的，假设第一个“a”事件是真实的：

现在coarse看起来像是将时间转移了 100：

┌──────┬───────────┐
│ name ┆ timestamp │
│ ---  ┆ ---       │
│ str  ┆ i64       │
╞══════╪═══════════╡
│ a    ┆ 0         │  -> Good, there is a timestamp in `fine` within 2s
│ a    ┆ 3         │  -> Bad, no timestamp in `fine` matches
│ b    ┆ 95        │  -> Bad, ditto
│ c    ┆ 120       │  -> Bad, ditto
│ a    ┆ 121       │  -> Bad, ditto
└──────┴───────────┘

好的，我没有找到所有匹配项，那么第二个“a”一定是真正的“a”（而是偏移了 90 秒）：

┌──────┬───────────┐
│ name ┆ timestamp │
│ ---  ┆ ---       │
│ str  ┆ i64       │
╞══════╪═══════════╡
│ a    ┆ 10        │  -> Good, it matches 10.05
│ a    ┆ 13        │  -> Good, it matches 12.51
│ b    ┆ 105       │  -> Good, it matches 106.0
│ c    ┆ 130       │  -> Good, it matches 128.01
│ a    ┆ 131       │  -> Good it matches 132.9
└──────┴───────────┘

基本上，我会随着时间滑动第二个数据集，直到找到一个“时间模式”，将第一个数据框中的所有事件匹配到第二个数据框的子集中。

dataframe
Martin Hope
Dante
Asked: 2024-08-24 01:42:57 +0800 CST
  • 6

假设我有一份包含用户及其薪资记录的 excel 表/csv。我在数据库中为每个用户创建了一个帐户，并希望使用数据库中的 ID 为每个用户创建薪资记录。

import polars as pl

# Create the DataFrame with repeated entries for John and Jane
df = pl.DataFrame({
    "first_name": ["John", "Jane", "Alice", "Bob", "John", "Jane", "John", "Jane"],
    "middle_name": ["A.", "B.", "C.", "D.", "A.", "B.", "A.", "B."],
    "last_name": ["Doe", "Smith", "Johnson", "Brown", "Doe", "Smith", "Doe", "Smith"],
    "salary": [50000, 60000, 55000, 62000, 50000, 60000, 50000, 60000],
    "date": ["2023-01-15", "2023-02-20", "2023-03-05", "2023-04-10", "2023-05-15", "2023-06-20", "2023-07-15", "2023-08-20"]
})
print(df)
shape: (8, 5)
┌────────────┬────────────┬────────────┬────────┬────────────┐
│ first_name │ middle_name│ last_name  │ salary │ date       │
│ ---        │ ---        │ ---        │ ---    │ ---        │
│ str        │ str        │ str        │ i64    │ date       │
├────────────┼────────────┼────────────┼────────┼────────────┤
│ John       │ A.         │ Doe        │ 50000  │ 2023-01-15 │
│ Jane       │ B.         │ Smith      │ 60000  │ 2023-02-20 │
│ Alice      │ C.         │ Johnson    │ 55000  │ 2023-03-05 │
│ Bob        │ D.         │ Brown      │ 62000  │ 2023-04-10 │
│ John       │ A.         │ Doe        │ 50000  │ 2023-05-15 │
│ Jane       │ B.         │ Smith      │ 60000  │ 2023-06-20 │
│ John       │ A.         │ Doe        │ 50000  │ 2023-07-15 │
│ Jane       │ B.         │ Smith      │ 60000  │ 2023-08-20 │
└────────────┴────────────┴────────────┴────────┴────────────┘

#Get unique values
 subset_df = df.select(["first_name", "middle_name", "last_name"])
 unique_subset_df = subset_df.unique()
 for row in subset_df.select(pl.struct(pl.all()).value_counts()):
    # create acoount

用户列表及其对应的id如下

users = [
    {'id': 1, 'first_name': 'John', 'middle_name': 'A.', 'last_name': 'Doe'},
    {'id': 2, 'first_name': 'Jane', 'middle_name': 'B.', 'last_name': 'Smith'},
    {'id': 3, 'first_name': 'Alice', 'middle_name': 'C.', 'last_name': 'Johnson'},
    {'id': 4, 'first_name': 'Bob', 'middle_name': 'D.', 'last_name': 'Brown'}
]
# Note:The data above can also be transformed into a list of tuples

我怎样才能用该字典列表中相应的 ID 替换数据框的、和列first_name中middle_name的值？last_name

dataframe
Martin Hope
Phil-ZXX
Asked: 2024-08-20 23:33:20 +0800 CST
  • 7

我有这个代码：

import polars as pl

df1 = pl.DataFrame({
    'type':   ['A', 'O', 'B', 'O'],
    'origin': ['EU', 'US', 'US', 'EU'],
    'qty1':   [343,11,22,-5]
})

df2 = pl.DataFrame({
    'type':   ['A', 'O', 'B', 'S'],
    'origin': ['EU', 'US', 'US', 'AS'],
    'qty2':   [-200,-12,-25,8]
})

df1.join(df2, on=['type', 'origin'], how='full')

给出

┌──────┬────────┬──────┬────────────┬──────────────┬──────┐
│ type ┆ origin ┆ qty1 ┆ type_right ┆ origin_right ┆ qty2 │
│ ---  ┆ ---    ┆ ---  ┆ ---        ┆ ---          ┆ ---  │
│ str  ┆ str    ┆ i64  ┆ str        ┆ str          ┆ i64  │
╞══════╪════════╪══════╪════════════╪══════════════╪══════╡
│ A    ┆ EU     ┆ 343  ┆ A          ┆ EU           ┆ -200 │
│ O    ┆ US     ┆ 11   ┆ O          ┆ US           ┆ -12  │
│ B    ┆ US     ┆ 22   ┆ B          ┆ US           ┆ -25  │
│ null ┆ null   ┆ null ┆ S          ┆ AS           ┆ 8    │
│ O    ┆ EU     ┆ -5   ┆ null       ┆ null         ┆ null │
└──────┴────────┴──────┴────────────┴──────────────┴──────┘

但我想要的输出是这样的：

┌──────┬────────┬──────┬──────┐
│ type ┆ origin ┆ qty1 ┆ qty2 │
│ ---  ┆ ---    ┆ ---  ┆ ---  │
│ str  ┆ str    ┆ i64  ┆ i64  │
╞══════╪════════╪══════╪══════╡
│ A    ┆ EU     ┆ 343  ┆ -200 │
│ O    ┆ US     ┆ 11   ┆ -12  │
│ B    ┆ US     ┆ 22   ┆ -25  │
│ S    ┆ AS     ┆ null ┆ 8    │
│ O    ┆ EU     ┆ -5   ┆ null │
└──────┴────────┴──────┴──────┘

我尝试suffix=''通过df1.join(df2, on=['type', 'origin'], how='full', suffix='')，但这引发了一个错误：

DuplicateError: unable to hstack, column with name "type" already exists

我怎样才能实现这个目标？

dataframe
Martin Hope
Phil-ZXX
Asked: 2024-07-31 20:18:14 +0800 CST
  • 7

我有以下代码

import polars as pl

mapping = {
    'CASH':  {'qty':  1, 'origin': 'E'},
    'ITEM':  {'qty': -9, 'origin': 'A'},
    'CHECK': {'qty': 46, 'origin': 'A'},
}

df = pl.DataFrame([{'type': k} | v for k, v in mapping.items()])\
         .with_columns(pl.struct(['qty', 'origin']).alias('mapping'))\
         .select(pl.col(['type', 'mapping']))

因此，字典的键type应成为一个名为的新列，而字典的值mapping应位于其自己的列中。我的上述实现有效，df如下所示：

shape: (3, 2)
┌───────┬───────────┐
│ type  ┆ mapping   │
│ ---   ┆ ---       │
│ str   ┆ struct[2] │
╞═══════╪═══════════╡
│ CASH  ┆ {1,"E"}   │
│ ITEM  ┆ {-9,"A"}  │
│ CHECK ┆ {46,"A"}  │
└───────┴───────────┘

但是我的实现很长，而且看起来效率不高。有没有更惯用的极坐标方法来创建这个数据框？

dataframe