DJDuque's questions

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

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。我不知道如何让它发挥作用。