DJDuque's questions

我有如下数据：

lf = pl.LazyFrame(
    {
        "points": [
            [
                [1.0, 2.0],
            ],
            [
                [3.0, 4.0],
                [5.0, 6.0],
            ],
            [
                [7.0, 8.0],
                [9.0, 10.0],
                [11.0, 12.0],
            ],
        ],
        "other": ["foo", "bar", "baz"],
    },
    schema={
        "points": pl.List(pl.Array(pl.Float32, 2)),
        "other": pl.String,
    },
)

我想让所有列表都具有相同数量的元素。如果当前列表包含的元素多于我需要的元素，则应将其截断。如果列表包含的元素少于我需要的元素，则应按顺序重复执行，直到包含足够的元素。

我设法让它工作了，但我觉得我有点太过繁琐了。有没有更简洁的方法来实现这一点？也许可以用gather？

target_length = 3

result = (
    lf.with_columns(
        needed=pl.lit(target_length).truediv(pl.col("points").list.len()).ceil()
    )
    .with_columns(
        pl.col("points")
        .repeat_by("needed")
        .list.eval(pl.element().explode())
        .list.head(target_length)
    )
    .drop("needed")
)

编辑

上述方法适用于玩具示例，但当我尝试在真实数据集中使用它时，它会失败：

pyo3_runtime.PanicException: Polars' maximum length reached. Consider installing 'polars-u64-idx'.

我还没能为此制作一个 MRE，但我的数据有 400 万行，每行的“点”列表有 1 到 8000 个元素（我试图填充/截断到 800 个元素）。这些元素看起来都很小，我不明白如何u32达到最大长度。

我很感激我可以尝试的任何替代方法。

我最接近的（不惊慌）是：

但这不会按顺序填充重复列表。它只会填充重复的最后一个元素。

target_length = 3

result = (
    lf.with_columns(
        pl.col("points")
        .list.gather(
            pl.int_range(target_length),
            null_on_oob=True,
        )
        .list.eval(pl.element().forward_fill())
    )
    .drop("needed")
)

我有一个具有如下模式的数据集：

df = pl.DataFrame(
    {
        "target": [
            [1.0, 1.0, 0.0],
            [1.0, 1.0, 0.1],
            [1.0, 1.0, 0.2],
            [1.0, 1.0, 0.8],
            [1.0, 1.0, 0.9],
            [1.0, 1.0, 1.0],
        ],
        "feature": ["a", "b", "c", "d", "e", "f"],
    },
    schema={
        "target": pl.Array(pl.Float32, 3),
        "feature": pl.String,
    },
)

如果我制作目标 z 值的直方图，它看起来像：

我想重新采样数据以使其沿 z 方向平坦。

我设法用一种多步骤的黑客方法完成了这件事（而且速度很慢）。我想知道是否有人可以建议一种更干净（和更高效）的方法？

我正在做的是：

1. 找到所述直方图的箱边界：

bins = 2 # Use e.g. 100 or larger in reality
z = df.select(z=pl.col("target").arr.get(2))
z_min = z.min()
z_max = z.max()
breaks = np.linspace(z_min, z_max, num=bins+1)

2. 找出计数最少的箱子中有多少个计数：

counts = (
    df.with_columns(bin=pl.col("target").arr.get(2).cut(breaks))
    .with_columns(counter=pl.int_range(pl.len()).over("bin"))
    .group_by("bin")
    .agg(pl.col("counter").max())
    .filter(pl.col("counter") > 0)  # <- Nasty way of filtering the (-inf, min] bin
    .select(pl.col("counter").min())
).item()

3. 在每个箱子上仅选择“计数”元素：

df = (
    df.with_columns(bin=pl.col("target").arr.get(2).cut(breaks))
    .with_columns(counter=pl.int_range(pl.len()).over("bin"))
    .filter(pl.col("counter") <= counts)
    .select("target", "feature")
)

这给了我：

大家有什么建议吗？

我有一个像这样的数据框：

data = {
    "a": [[1], [2], [3, 4], [5, 6, 7]],
    "b": [[], [8], [9, 10], [11, 12]],
}
df = pl.DataFrame(data)
"""
┌───────────┬───────────┐
│ a         ┆ b         │
│ ---       ┆ ---       │
│ list[i64] ┆ list[i64] │
╞═══════════╪═══════════╡
│ [1]       ┆ []        │
│ [2]       ┆ [8]       │
│ [3, 4]    ┆ [9, 10]   │
│ [5, 6, 7] ┆ [11, 12]  │
└───────────┴───────────┘
"""

每对列表的长度可能不一样，我想将爆炸“截断”为两个列表中最短的一个：

"""
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 2   ┆ 8   │
│ 3   ┆ 9   │
│ 4   ┆ 10  │
│ 5   ┆ 11  │
│ 6   ┆ 12  │
└─────┴─────┘
"""

我在想，也许我必须用 填充两个列表中最短的列表以None匹配两个长度，然后drop_nulls。但我想知道是否有更直接的方法可以解决这个问题？

我试图做的基本上是相反的drop_nulls()。我想保留至少有一个的所有行null。

我想做类似的事情（但我不想列出所有其他列）：

for (name,) in (
    df.filter(
        pl.col("a").is_null()
        | pl.col("b").is_null()
        | pl.col("c").is_null()
    )
    .select("name")
    .unique()
    .rows()
):
    print(
        f"Ignoring `{name}` because it has at least one null",
        file=sys.stderr,
    )
df = df.drop_nulls()

我有两组数据集：

第一个描述了我的期望：

expected = {
    "name": ["start", "stop", "start", "stop", "start", "stop", "start", "stop"],
    "description": ["a", "b", "c", "d", "e", "f", "g", "h"],
}

第二段描述了我的观察：

observed = {
    "name": ["start", "stop", "start", "stop", "stop", "stop", "start"],
    "time": [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7],
}

我想根据我期望的顺序将我的所有观察结果与描述进行匹配。但是一旦发现不一致，就什么都不能匹配了。

我设法找到了第一个不一致之处，例如：

observed_df = pl.DataFrame(observed).with_row_index()
expected_df = pl.DataFrame(expected).with_row_index()

result = observed_df.join(expected_df, on=["index", "name"], how="left").select(
    "description", "time"
)
"""
┌─────────────┬──────┐
│ description ┆ time │
│ ---         ┆ ---  │
│ str         ┆ f64  │
╞═════════════╪══════╡
│ a           ┆ 0.1  │
│ b           ┆ 0.2  │
│ c           ┆ 0.3  │
│ d           ┆ 0.4  │
│ null        ┆ 0.5  │   -> First inconsistency gets a "null" description
│ f           ┆ 0.6  │
│ g           ┆ 0.7  │
└─────────────┴──────┘
"""

我怎样才能传播这个null通过第一个不一致的情况？

此外，我的真实数据还有一个附加id列，其中每个列id都是如上所述的情况，并且独立于其他id列。是否可以以某种方式“按 ID 分组”并一次性应用此逻辑，而不是id分别处理每个逻辑：

observed = {
    "id": [1, 2, 1, 2, 2],
    "name": ["start", "start", "stop", "stop", "stop"],
    "time": [0.1, 0.2, 0.3, 0.4, 0.5],
}

expected = {
    "id": [1, 1, 2, 2],
    "name": ["start", "stop", "start", "stop"],
    "description": ["a", "b", "c", "d"],
}

result = {
    "id": [1, 2, 1, 2, 2],
    "description": ["a", "c", "b", "d", None],
    "time": [0.1, 0.2, 0.3, 0.4, 0.5],
}

我有以下两个数据集：

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       │
   └──────┴───────────┘
   """
   

2. 这个具有非常准确的时间，但它有一些噪音/误报（请注意，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
└──────┴───────────┘

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

假设我有一个如下数据集：

data = {
    "a": [1, 4, 2, 4, 7, 4],
    "b": [4, 2, 3, 3, 0, 2],
    "c": ["a", "b", "c", "d", "e", "f"],
}

并且我只想保留由和a + b的单个组合唯一描述的行。我设法破解了这一点：ab

df = (
    pl.DataFrame(data)
    .with_columns(sum_ab=pl.col("a") + pl.col("b"))
    .group_by("sum_ab")
    .agg(pl.col("a"), pl.col("b"), pl.col("c"))
    .filter(
        (pl.col("a").list.unique().list.len() == 1)
        & (pl.col("b").list.unique().list.len() == 1)
    )
    .explode(["a", "b", "c"])
    .select("a", "b", "c")
)

"""
shape: (2, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 4   ┆ 2   ┆ b   │
│ 4   ┆ 2   ┆ f   │
└─────┴─────┴─────┘
"""

有人能建议一种更好的方法来实现同样的效果吗？我花了一些功夫才弄清楚这个逻辑，所以我想有一种更直接/更优雅的方法可以获得相同的结果。

我正在学习引导程序，我想x在每个选项卡名称旁边有一个按钮来关闭它：

<link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">

<ul class="nav nav-tabs" id="myTab" role="tablist">
  <li class="nav-item" id="tab-li-1">
    <button
      class="nav-link active"
      data-bs-toggle="tab"
      data-bs-target="#tab-1"
      type="button"
    >
      First
      <button
        class="btn-close"
        onclick="
          document.getElementById(`tab-li-1`).remove();
          document.getElementById(`tab-1`).remove();
        "
       ></button>
    </button>
  </li>
  <li class="nav-item" id="tab-li-2">
    <button
      class="nav-link"
      data-bs-toggle="tab"
      data-bs-target="#tab-2"
      type="button"
     >
     Second
       <button
        class="btn-close"
        onclick="
          document.getElementById(`tab-li-2`).remove();
          document.getElementById(`tab-2`).remove();
        "
       ></button>
     </button>
  </li>
</ul>
<div class="tab-content" id="myTabContent">
  <div class="tab-pane fade show active" id="tab-1" tabindex="0">Some text here for `First`</div>
  <div class="tab-pane fade" id="tab-2" tabindex="0">More text here for `Second`</div>
</div>

    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js" integrity="sha384-kenU1KFdBIe4zVF0s0G1M5b4hcpxyD9F7jL+jjXkk+Q2h455rYXK/7HAuoJl+0I4" crossorigin="anonymous"></script>

我可以对在第一个按钮内嵌套另一个按钮进行一些修改，然后：

document.getElementById(tabId).remove();
document.getElementById(tabContentId).remove();

但是我在网上发现将一个按钮嵌套在另一个按钮中是无效的

大家能建议一下有没有更好的替代方案吗？

抱歉，如果我的问题没有多大意义。我在 python 方面没有太多经验。

我有一些代码看起来像：

import polars as pl
from typing import NamedTuple


class Event(NamedTuple):
    name: str
    description: str


def event_table(num) -> list[Event]:
    events = []
    for i in range(5):
        events.append(Event("name", "description"))
    return events


def pretty_string(events: list[Event]) -> str:
    pretty = ""
    for event in events:
        pretty += f"{event.name}: {event.description}\n"
    return pretty

# This does work
print(pretty_string(event_table(5)))

# But then it doesn't work if I have my `list[Event]` in a dataframe
data = {"events": [0, 1, 2, 3, 4]}
df = pl.DataFrame(data).select(events=pl.col("events").map_elements(event_table))

# This doesn't work
pretty_df = df.select(events=pl.col("events").map_elements(pretty_string))
print(pretty_df)

# Neither does this
print(pretty_string(df["events"][0]))

它失败并出现错误：

Traceback (most recent call last):
  File "path/to/script.py", line 32, in <module>
    pretty_df = df.select(events=pl.col("events").map_elements(pretty_string))
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "path/to/.venv/lib/python3.11/site-packages/polars/dataframe/frame.py", line 8116, in select
    return self.lazy().select(*exprs, **named_exprs).collect(_eager=True)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "path/to/.venv/lib/python3.11/site-packages/polars/lazyframe/frame.py", line 1934, in collect
    return wrap_df(ldf.collect())
                   ^^^^^^^^^^^^^
polars.exceptions.ComputeError: AttributeError: 'dict' object has no attribute 'name'

看来我的list[Event]已经不再是里面的了df。我不知道如何让它发挥作用。