问题[pandas](coding)

我有一个与此非常相似的问题，但 1）我希望它也适用于系列，2）我没有代表我的分组值的列；值在索引中。

假设我有一个如下所示的系列：

2023-08-01    1515000.08
2023-09-01    2629410.80
2023-10-01    2548748.40
2023-11-01    2494398.04
2023-12-01    3397805.34
2024-01-01    3285501.49
2024-02-01    3173978.74
2024-03-01    3139235.65
2024-04-01    2927895.84
2024-05-01    2750708.29
dtype: float64

我想创建一个新系列，其中的值代表上一季度最后一个月的值，如下所示：

2023-08-01    NaN
2023-09-01    NaN
2023-10-01    2629410.80 <--- the old value from 2023-09-01, which was the end of Q3
2023-11-01    2629410.80
2023-12-01    2629410.80
2024-01-01    3397805.34 <--- the old value from 2023-12-01
2024-02-01    3397805.34
2024-03-01    3397805.34
2024-04-01    3139235.65 <--- the old value from 2024-03-01
2024-05-01    3139235.65
dtype: float64

我发现在这里找到一个优雅的解决方案非常麻烦。我的代码如下所示：

period_to_val = (
    series.groupby(
        lambda x: get_quarter(date=x)
    )
    .last()
    .shift()
)

data = series.index.map(
    lambda x: period_to_val[get_end_of_period(date=x, term_length=term_length, fiscal_year_start=fiscal_year_start)]
)

result = pd.Series(data=data, index=series.index)

但这感觉太冗长和丑陋了。我想要一个对 a和 aSeriesGroupBy混合的操作，但这种东西似乎不存在。.shift().transform("last")

有什么改进建议吗？谢谢！

我想在数据框上运行 groupby 和聚合，其中聚合将具有相同的字符串连接起来id。 df 如下所示：

In [1]: df = pd.DataFrame.from_dict({'id':[1,1,2,2,2,3], 'name':['a','b','c','d','e','f']})
In [2]: df
Out[2]:
   id name
0   1    a
1   1    b
2   2    c
3   2    d
4   2    e
5   3    f

我在 Pandas 中实现了这个功能：

def list_aggregator(x):
    return '|'.join(x)

df2 = pd.DataFrame.from_dict('id':[], 'name':[])
df2['id'] = df['id'].drop_duplicates()
df2['name'] = df['name'].groupby(df['id']).agg(list_aggregator).values

生成：

In [26]: df2
Out[26]:
   id   name
0   1    a|b
2   2  c|d|e
5   3      f

对于 Dask，我的理解（来自文档）是你必须告诉 Dask 如何在块内进行聚合，然后如何处理这些聚合块。在这两种情况下，我都想做等同于的事情'|'.join()。所以：

ddf = dd.from_pandas(df, 2)
ddf2 = dd.from_pandas(pd.DataFrame.from_dict({'id':[],'name':[]}))
ddf2['id'] = ddf['id'].drop_duplicates()

dd_list_aggregation = dd.Aggregation(
    'list_aggregation',
    list_aggregator,  # chunks are aggregated into strings with 1 string per chunk
    list_aggregator,  # per-chunk strings are aggregated into a single string per id
)

ddf2['name'] = ddf['name'].groupby(ddf['id']).agg(dd_list_aggregation).values

预期结果如上（或者，实际上没有任何结果，因为我ddf2.compute()还没有调用），但我收到此错误：

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_core.py:446, in Expr.__getattr__(self, key)
    445 try:
--> 446     return object.__getattribute__(self, key)
    447 except AttributeError as err:

File ~/miniconda3/envs/test/lib/python3.10/functools.py:981, in cached_property.__get__(self, instance, owner)
    980 if val is _NOT_FOUND:
--> 981     val = self.func(instance)
    982     try:

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_groupby.py:206, in GroupByApplyConcatApply._meta_chunk(self)
    205 meta = meta_nonempty(self.frame._meta)
--> 206 return self.chunk(meta, *self._by_meta, **self.chunk_kwargs)

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask/dataframe/groupby.py:1200, in _groupby_apply_funcs(df, *by, **kwargs)
   1199 for result_column, func, func_kwargs in funcs:
-> 1200     r = func(grouped, **func_kwargs)
   1202     if isinstance(r, tuple):

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask/dataframe/groupby.py:1276, in _apply_func_to_column(df_like, column, func)
   1275 if column is None:
-> 1276     return func(df_like)
   1278 return func(df_like[column])

Cell In[88], line 2
      1 def dd_list_aggregator(x):
----> 2     return '|'.join(x[1])

File ~/miniconda3/envs/test/lib/python3.10/site-packages/pandas/core/base.py:245, in SelectionMixin.__getitem__(self, key)
    244     raise KeyError(f"Column not found: {key}")
--> 245 ndim = self.obj[key].ndim
    246 return self._gotitem(key, ndim=ndim)

AttributeError: 'str' object has no attribute 'ndim'

During handling of the above exception, another exception occurred:

RuntimeError                              Traceback (most recent call last)
Cell In[96], line 1
----> 1 ddf2['name'] = ddf['name'].groupby(ddf['id']).agg(dd_list_aggregation).values

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_groupby.py:1907, in GroupBy.agg(self, *args, **kwargs)
   1906 def agg(self, *args, **kwargs):
-> 1907     return self.aggregate(*args, **kwargs)

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_groupby.py:1891, in GroupBy.aggregate(self, arg, split_every, split_out, shuffle_method, **kwargs)
   1888 if arg == "size":
   1889     return self.size()
-> 1891 return new_collection(
   1892     GroupbyAggregation(
   1893         self.obj.expr,
   1894         arg,
   1895         self.observed,
   1896         self.dropna,
   1897         split_every,
   1898         split_out,
   1899         self.sort,
   1900         shuffle_method,
   1901         self._slice,
   1902         *self.by,
   1903     )
   1904 )

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_collection.py:4440, in new_collection(expr)
   4438 def new_collection(expr):
   4439     """Create new collection from an expr"""
-> 4440     meta = expr._meta
   4441     expr._name  # Ensure backend is imported
   4442     return get_collection_type(meta)(expr)

File ~/miniconda3/envs/test/lib/python3.10/functools.py:981, in cached_property.__get__(self, instance, owner)
    979 val = cache.get(self.attrname, _NOT_FOUND)
    980 if val is _NOT_FOUND:
--> 981     val = self.func(instance)
    982     try:
    983         cache[self.attrname] = val

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_groupby.py:432, in GroupbyAggregation._meta(self)
    430 @functools.cached_property
    431 def _meta(self):
--> 432     return self._lower()._meta

File ~/miniconda3/envs/test/lib/python3.10/functools.py:981, in cached_property.__get__(self, instance, owner)
    979 val = cache.get(self.attrname, _NOT_FOUND)
    980 if val is _NOT_FOUND:
--> 981     val = self.func(instance)
    982     try:
    983         cache[self.attrname] = val

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_reductions.py:425, in ApplyConcatApply._meta(self)
    423 @functools.cached_property
    424 def _meta(self):
--> 425     meta = self._meta_chunk
    426     aggregate = self.aggregate or (lambda x: x)
    427     if self.combine:

File ~/miniconda3/envs/test/lib/python3.10/site-packages/dask_expr/_core.py:451, in Expr.__getattr__(self, key)
    447 except AttributeError as err:
    448     if key.startswith("_meta"):
    449         # Avoid a recursive loop if/when `self._meta*`
    450         # produces an `AttributeError`
--> 451         raise RuntimeError(
    452             f"Failed to generate metadata for {self}. "
    453             "This operation may not be supported by the current backend."
    454         )
    456     # Allow operands to be accessed as attributes
    457     # as long as the keys are not already reserved
    458     # by existing methods/properties
    459     _parameters = type(self)._parameters

RuntimeError: Failed to generate metadata for DecomposableGroupbyAggregation(frame=df['name'], arg=<dask.dataframe.groupby.Aggregation object at 0x7f052960b850>, observed=False, split_out=1). This operation may not be supported by the current backend.

我的想法是期望数值对象，但后端是 pandas，所以应该可以进行字符串操作，对吗？

pandas DataFrame 的一个问题是它需要一些数据来创建其结构。因此，表示无行的情况可能会有问题。

例如，假设我有一个函数返回以字典形式表示的记录列表：get_data() -> list[dict[str, Any]]并且我想要一个函数返回相同数据的 DataFrame：

def get_dataframe() -> pd.DataFrame:
    l = get_data()
    df = pd.DataFrame(l)
    return df

这种方法效果很好，但 pandas 需要至少一条记录来推断列数和列类型的情况除外len(l)=0。在这种情况下返回 None 并不好，因为您可能需要在下游编写大量 if/else 语句来处理零记录情况。理想情况下，最好返回一个具有正确列数和列类型的空 DataFrame，这样我们就不必在下游代码中对无记录情况进行特殊处理。但这样做非常繁琐，因为：

1. 在 中get_dataframe()，我需要指定列数和列类型来创建一个空的 DataFrame，但这些信息已经在其他地方指定了。两次指定相同的内容很繁琐。
2. 因为我两次指定了相同的信息，它们可能不一致。所以我需要添加代码来检查一致性。
3. 信不信由你，DataFrame 构造函数不接受 dtype 列表。有解决方法可以为每个列指定一个类型，但这不方便。

消除冗余的一个想法是，我不再将原始数据表示为字典列表，而是将其表示为数据类列表，这样我就可以注释每个字段的类型。然后我可以使用注释信息来创建列类型。这也不理想，因为类型注释是可选的，而且 Python 类型的映射dtype也不是一对一的。

请问没有数据的情况一般是怎么处理的？

我有一个熊猫数据框，看起来像

data = {
'Date': ['2024-07-14','2024-07-14','2024-07-14','2024-07-14','2024-07-14','2024-03-14','2024-03-14','2024-03-14','2024-02-14','2024-02-10','2024-02-10','2024-02-10','2024-04-13','2024-04-13','2023-02-11','2023-02-11','2023-02-11','2011-10-11','2011-05-02','2011-05-02'],
'Test_Number': [5,4,3,2,1,3,2,1,4,3,2,1,2,1,3,2,1,1,2,1],
'Student_ID': [2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1],
'Place': [3,5,7,3,1,9,6,3,7,8,2,1,3,4,2,1,5,6,2,7]
}
df = pd.DataFrame(data)

我想使用以下方法创建三个新列“student_rec_1”、“student_rec_2”、“student_rec_3”：

对于每个 Student_ID，student_rec_1 等于该学生在最近的最后一次考试中的成绩，如果不存在则等于 np.nan。

类似地，student_rec_2 等于该学生在最近一次日期的倒数第二次考试中的成绩，如果不存在则等于 np.nan，

student_rec_3 等于该学生在最近日期的倒数第三次考试中的排名，如果不存在则等于 np.nan。因此，期望的结果如下

data_new = {
'Date': ['2024-07-14','2024-07-14','2024-07-14','2024-07-14','2024-07-14','2024-03-14','2024-03-14','2024-03-14','2024-02-14','2024-02-10','2024-02-10','2024-02-10','2024-04-13','2024-04-13','2023-02-11','2023-02-11','2023-02-11','2011-10-11','2011-05-02','2011-05-02'],
'Test_Number': [5,4,3,2,1,3,2,1,4,3,2,1,2,1,3,2,1,1,2,1],
'Student_ID': [2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1],
'Place': [3,5,7,3,1,9,6,3,7,8,2,1,3,4,2,1,5,6,2,7],
'student_rec_1': [9,9,9,9,9,7,7,7,8,np.nan,np.nan,np.nan,2,2,6,6,6,2,np.nan,np.nan],
'student_rec_2': [6,6,6,6,6,8,8,8,2,np.nan,np.nan,np.nan,1,1,2,2,2,7,np.nan,np.nan],
'student_rec_3': [3,3,3,3,3,2,2,2,1,np.nan,np.nan,np.nan,5,5,7,7,7,np.nan,np.nan,np.nan]
}
df_new = pd.DataFrame(data_new)

这就是我尝试过的：

df['日期'] = pd.to_datetime(df['日期'])

df = df.sort_values(['日期', '测试编号'], 升序=[False, False])

def get_last_n_records(group，n):返回group['Place'].shift(-n)

df['student_rec_1'] = df.groupby('学生ID').apply(get_last_n_records, 1).reset_index(level=0, drop=True) df['student_rec_2'] = df.groupby('学生ID').apply(get_last_n_records, 2).reset_index(level=0, drop=True) df['student_rec_3'] = df.groupby('学生ID').apply(get_last_n_records, 3).reset_index(level=0, drop=True)

但它只是改变了每个学生的位置，并没有考虑到“最后一天”的因素，而且无论如何都会改变位置。

我想在现有的 pandas 数据框 ( df) 中创建三个新列，方法是对同一列使用相同的lambda函数，但输入不同。我已通过以下代码行成功完成此操作。不过，我想知道是否有更快的方法可以用更少的代码行产生相同的输出：

df["1d"] = (
        df
        .groupby(cols)["ln"]
        .apply(lambda x: x - x.shift(1))
        .values
)
df["5d"] = (
        df
        .groupby(cols)["ln"]
        .apply(lambda x: x - x.shift(5))
        .values
)
df["30d"] = (
        df
        .groupby(cols)["ln"]
        .apply(lambda x: x - x.shift(30))
        .values
)

我有一个包含以下列的 数据框：region_id，，，，，，和。nameparentparent_namet2md2mtp

我想以特定方式对列值进行分组和聚合。为了实现这一点，我定义了以下列表：

w_params = ['t2m', 't2m', 't2m', 'd2m', 'tp']
operation = ['max', 'min', 'mean', 'mean', 'sum']
common_cols = ['region_id', 'name', 'parent', 'parent_name']

我已经编写了函数来按和聚合agg_daily对列值进行分组。dateregion_id

def agg_daily(df, common_cols, w_params, operation):
    """
    Aggregate the data for each day.

    Parameters
    ----------
    df : pandas dataframe
        Dataframe containing daily data.

    Returns
    -------
    agg_daily_df : pandas dataframe
        Dataframe containing aggregated data for each day.

    """
    agg_daily_df = df.groupby(['date', 'region_id']).agg(
        name=('name', 'first'),
        parent=('parent', 'first'),
        parent_name=('parent_name', 'first'),
        t2m_max=('t2m', 'max'),
        t2m_min=('t2m', 'min'),
        t2m_mean=('t2m', 'mean'),
        d2m=('d2m', 'mean'),
        tp=('tp', 'sum')
    ).reset_index()
    agg_daily_df = agg_daily_df.sort_values(['region_id', 'date'], ascending=[True, True]).reset_index(drop=True)
    return agg_daily_df

但是，请注意agg_daily， 中的参数（agg例如t2m_max）是硬编码的。相反，我想将、、作为参数传递给，避免硬编码，同时让函数执行所需的操作。t2m_mint2m_meancommon_colsw_paramsoperationagg_dailyagg_daily

请注意，对于属于的列common_cols，我不希望在最终输出中创建新的列名。但是，对于属于的列w_params，我希望创建一个与operation正在执行的相对应的列。

有人能帮助我获得一个可定制的功能吗？

我有一个如下数据框：

ID   f_1   f_2   f_3
1    1     0     1
2    0     1     1
3    1     1     0
4    1     0     1
5    0     1     1   

我完全不知道如何开始。而且我的原始数据框相当大（约 1M 行），因此非常希望有一种快速的方法。

我想生成一个新列Result，记录f其中包含 1 的一对，即

ID   f_1   f_2   f_3   Result
1    1     0     1     1_3
2    0     1     1     2_3
3    1     1     0     1_2
4    1     0     1     1_3
5    0     1     1     2_3

我有一个像这样的条件数据框，其中大约有 300 行

pd.DataFrame({"PERSONALNR":["000009461","000009461"],"PERIODE":["202401","202402"],"MANDANT":["LB","LB"],"DA":["01","01"]})

其中“PERSONALNR”和“PERIODE”是我需要满足的条件，并且需要在第二个数据框中替换值“MANDANT”和“DA”

我想要替换的数据框与此类似，其中约有 110k 行

pd.DataFrame({"PERSONALNR":["000009461","000009461"],"PERIODE":["202401","202402"],"MANDANT":["LB","LB"],"DA":["01","01"], "KSTBEZ":["Springer pool","bla bla"]})

我想到的解决方案如下：

for row in POOL.itertuples():
    LA.loc[(LA.PERSONALNR==row.PERSONALNR)&(LA.PERIODE==row.PERIODE)&(LA.DA=="01")&(LA.KSTBEZ.str.contains("pool")),["MANDANT","DA"]]=[row.MANDANT,row.DA]

我的解决方案对于上面的数据框来说效果很好——大约需要 10 秒钟左右才能完成，但我需要在具有 100 万行的数据框中执行相同的操作——大约需要 10 分钟......

谁能想出更好的解决办法？

有一个像这样的数据框：

import numpy as np
import pandas as pd

df = pd.DataFrame({'x':np.arange(1,29),'y':[5.69, 6.03, 6.03, 6.03, 6.03, 6.03, 6.03, 5.38, 5.21, 5.4 , 5.24,
       5.4 , 5.36, 5.47, 5.58, 5.5 , 5.61, 5.53, 5.4 , 5.51, 5.47, 5.44,5.39, 5.27, 5.38, 5.35, 5.32, 5.09],
          'valley':[1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
          'peak':[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0]})

>>> df
     x     y  valley  peak
0    1  5.69       1     0
1    2  6.03       0     0
2    3  6.03       0     1
3    4  6.03       0     0
4    5  6.03       0     0
5    6  6.03       0     0
6    7  6.03       0     0
7    8  5.38       0     0
8    9  5.21       1     0
9   10  5.40       0     0
10  11  5.24       0     0
11  12  5.40       0     0
12  13  5.36       0     0
13  14  5.47       0     0
14  15  5.58       0     0
15  16  5.50       0     0
16  17  5.61       0     1
17  18  5.53       0     0
18  19  5.40       0     0
19  20  5.51       0     0
20  21  5.47       0     0
21  22  5.44       0     0
22  23  5.39       0     0
23  24  5.27       0     0
24  25  5.38       0     0
25  26  5.35       0     0
26  27  5.32       0     0
27  28  5.09       1     0

我希望向该数据框添加一个新列“grp”，要求对于谷值列以“1”开头、峰值列以“1”结尾的每一行，添加的列中的值为“A”，反之，对于峰值列以“1”开头、谷值列以“1”结尾的每一行，添加的列中的值为“B”。

期望的结果是：

>>> out
     x     y  valley  peak  grp
0    1  5.69       1     0  A
1    2  6.03       0     0  A
2    3  6.03       0     1  B
3    4  6.03       0     0  B
4    5  6.03       0     0  B
5    6  6.03       0     0  B
6    7  6.03       0     0  B
7    8  5.38       0     0  B
8    9  5.21       1     0  A
9   10  5.40       0     0  A
10  11  5.24       0     0  A
11  12  5.40       0     0  A
12  13  5.36       0     0  A
13  14  5.47       0     0  A
14  15  5.58       0     0  A
15  16  5.50       0     0  A
16  17  5.61       0     1  B
17  18  5.53       0     0  B
18  19  5.40       0     0  B
19  20  5.51       0     0  B
20  21  5.47       0     0  B
21  22  5.44       0     0  B
22  23  5.39       0     0  B
23  24  5.27       0     0  B
24  25  5.38       0     0  B
25  26  5.35       0     0  B
26  27  5.32       0     0  B
27  28  5.09       1     0  A

如果我们不使用带有函数和 for 循环的 apply，是否有一种使用 pandas 的原生方法来实现？

最终结果

假设我们有上述数据框，其中每个键都是用于创建组合以获得所需最终结果的选项。假设您还可以指定可用于实现以下最终结果的最大组合数，那么如何遍历数据框，当一组组合等于最终结果时，它会打印组成组合的所有键以及它所采用的组合数？

例如，假设最大组合数为 3 键组合。那么以下组合将满足最终结果，并且保持低于或等于允许实现该结果的按键组合数

钥匙 2（本身），连击 1

键 4 + 键 5，组合 2

键 3 + 键 8，组合 2