这是我的数据框：
import pandas as pd
df = pd.DataFrame({
'a': [10, 20, 30, 50, 50, 50, 4, 100],
'b': [30, 3, 200, 25, 24, 31, 29, 2],
'd': list('aaabbbcc')
})
预期输出：
a b d
0 10 30 a
1 20 3 a
2 30 200 a
按列分组d。我想返回至少有两个此掩码实例的组
m = (df.b.gt(df.a))
这是我试过的。它有效，但我想知道是否有更好/更有效的方法来做到这一点。
out = df.groupby('d').filter(lambda x: len(x.loc[x.b.gt(x.a)]) >= 2)
这是我的数据框：
import pandas as pd
df = pd.DataFrame({
'a': [10, 20, 30, 1, 20, 3, 4, 0],
'b': [30, 3, 11, 25, 24, 31, 29, 2],
'c': [True, True, True, False, False, True, True, True]
})
预期输出正在创建列d：
a b c d
0 10 30 True NaN
1 20 3 True 10
2 30 11 True 20
3 1 25 False NaN
4 20 24 False NaN
5 3 31 True NaN
6 4 29 True 30
7 0 2 True 4
首先选择其中的值b。c我True逐行解释这个过程，1因为这样更容易理解。
中的值为b3，则应检查其以上所有值。并且a应选择其中大于 3 的最近值。因此选择 10。
对于行号2，其值为 11。与该值最接近且大于该值的a值为 20。
对于第 3 行和第 4 行，由于c是False，因此NaN应该选择。
对于行5，由于 中没有大于 31 的先前值a，NaN因此被选中。
对于行，其中大于 29 的6最接近的值是 30。a
这是我迄今为止尝试过的方法。它没有给我输出。我认为我采取的方法可能是正确的。
t = df['a'].to_numpy()
h = df['b'].to_numpy()
m2 = t < h[:, None]
df['d'] = np.nanmax(np.where(m2, t, np.nan), axis=1)
这是我的数据框：
import pandas as pd
df = pd.DataFrame(
{
'group': list('xxxxyyy'),
'open': [100, 150, 200, 160, 300, 150, 170],
'close': [105, 150, 200, 160, 350, 150, 170],
'stop': [104, 104, 104, 104, 400, 400, 400]
}
)
预期输出是x根据group列返回的组：
group open close stop
0 x 100 105 104
1 x 150 150 104
2 x 200 200 104
3 x 160 160 104
逻辑：
我想检查df.stop.iloc[0]每个组是否在df.open.iloc[0]和之间df.close.iloc[0]。如果在这两者之间，我想返回整个组。
这是我的尝试。它有效，但我认为有更好的方法。请注意，在if子句中，需要检查两个条件。
def func(df):
s = df.stop.iloc[0]
o = df.open.iloc[0]
c = df.close.iloc[0]
if (o <= s <= c) or (c <= s <= o):
return df
out = df.groupby('group').apply(func).reset_index(drop=True)
这是我的数据框：
import pandas as pd
df = pd.DataFrame(
{
'a': ['long', 'long', 'short', 'long', 'short', 'short', 'short'],
'b': [1, -1, 1, 1, -1, -1, 1],
}
)
预期输出正在创建列a_1：
a b a_1
0 long 1 long
1 long -1 long
2 short 1 short
3 long 1 long
4 short -1 long
5 short -1 long
6 short 1 short
逻辑：
a_1应像这样创建：
df.loc[df.b.eq(-1), 'a_1'] = 'long'
df['a_1'] = df.a_1.fillna(df.a)
这个问题真的很奇怪。我试了一下，fillna它不起作用。我尝试使用 pandas 版本 1.2.4，它起作用了，但使用版本 2.1.4 却不起作用。此版本目前是 Colab 的默认版本，我在 Colab 上运行了此代码。
我的数据框是：
import pandas as pd
df = pd.DataFrame(
{
'a': [20, 30, 2, 5, 10]
}
)
预期产出pct_change()为a：
a pct_change
0 20 -50.000000
1 30 50.000000
2 2 -93.333333
3 5 150.000000
4 10 100.000000
我想df.a.iloc[0]将 的第一个值与 40进行比较pct_change。如果我使用df['pct_change'] = df.a.pct_change().mul(100)，则第一个值是NaN。
我的尝试：
def percent(a, b):
result = ((a - b) / b) * 100
return result.round(2)
df.loc[df.index[0], 'pct_change'] = percent(df.a.iloc[0], 40)
有没有更好/更有效的方法？
这是对这个已接受答案的扩展。
我的数据框：
import pandas as pd
df = pd.DataFrame(
{
'a': [-3, -1, -2, -5, 10, -3, -13, -3, -2, 1, 2, -100],
'b': [1, 2, 3, 4, 5, 10, 80, 90, 100, 99, 1, 12]
}
)
预期输出：
a b
5 -3 10
6 -13 80
7 -3 90
8 -2 100
逻辑：
a) 选择中最长的一串负片a。
b) 例如，如果有两个条纹具有相同的大小，我想要一个总和更大的条纹b。df有两个条纹的大小为 4，但我想要第二个，因为总和b更大。
我的尝试：
import numpy as np
s = np.sign(df['a'])
df['g'] = s.ne(s.shift()).cumsum()
df['size'] = df.groupby('g')['g'].transform('size')
df['b_sum'] = df.groupby('g')['b'].transform('sum')
我的数据框是：
import pandas as pd
df = pd.DataFrame(
{
'a': [-3, -1, -2, -5, 10, -3, -13, -3, -2, 1, 2, -100],
}
)
预期输出：
a
0 -3
1 -1
2 -2
3 -5
逻辑：
我想返回最大的负数序列。如果有多个最大的序列，我想返回第一个序列。有df两个大小为 4 的负数序列，因此返回第一个。
这是我的尝试，但每当我idxmax()在代码中使用时，我都想仔细检查，因为在某些情况下有时会变得棘手。
import numpy as np
df['sign'] = np.sign(df.a)
df['sign_streak'] = df.sign.ne(df.sign.shift(1)).cumsum()
m = df.sign.eq(-1)
group_sizes = df.groupby('sign_streak').size()
largest_group = group_sizes.idxmax()
largest_group_df = df[df['sign_streak'] == largest_group]
这是我的数据框：
import pandas as pd
df = pd.DataFrame(
{
'a': [3, 1, 2, 5, 10, 3, 13, 3, 2],
}
)
预期输出是创建一个a_max和a_min：
a a_max a_min
0 3 NaN NaN
1 1 3 1
2 2 3 1
3 5 3 1
4 10 3 1
5 3 10 3
6 13 10 3
7 3 13 3
8 2 13 2
逻辑：
我逐行解释逻辑。有一个动态窗口，对于df窗口的第一个实例，只考虑第一行。对于窗口的第二个实例，考虑前两行。如下所示：
这是前四个窗口。它会相应扩展。
对于每个窗口，我需要找到最大值，然后找到低于该最大值的最小值。
我从黄色窗口开始解释。这个窗口的最大值是 3，其下方的最小值是 1。这就是为什么这个窗口的a_max和a_min是 3 和 1。
现在对于橙色窗口，最大值为 5，但由于此窗口中没有低于此值且小于 5 的值，因此重复前一个a_max和。a_min
该逻辑对于其余行也同样适用。
这是我的尝试：
df['a_max'] = df.a.cummax()
df['a_min'] = df.a.cummin()
我的数据框是：
import pandas as pd
df = pd.DataFrame(
{
'x': ['a', 'a', 'a','b', 'b','c', 'c', 'c',],
'y': list(range(8))
}
)
这是预期的输出。我想创建列z：
x y z
0 a 0 NaN
1 a 1 NaN
2 a 2 NaN
3 b 3 3
4 b 4 NaN
5 c 5 NaN
6 c 6 NaN
7 c 7 NaN
逻辑是：
我想找到第一组重复行之后的第一行。例如在列中x，值a是第一个重复的值。我想在值结束后找到一行a。然后将该y行的作为z列。
这是我的尝试，但没有给出输出：
m = (df.x.duplicated())
out = df[m]
这是我的数据框：
import pandas as pd
import numpy as np
df = pd.DataFrame(
{
'a': [np.nan, np.nan, np.nan, 20, 12, 42, 33, 32, 31],
'b': [np.nan, np.nan, np.nan, np.nan, 2333, np.nan, np.nan, 12323, np.nan]
}
)
掩码是：
mask = (
(df.a.notna()) &
(df.b.notna())
)
预期输出：切片df到 的第一个实例mask。请注意，第一行mask已包含：
a b
0 NaN NaN
1 NaN NaN
2 NaN NaN
3 20.0 NaN
4 12.0 2333.0
第一个实例mask是 row 4。因此，将其分割到该索引就是目标。
这些是我的尝试。第一个有效，但我不确定该方法是否正确：
# attempt 1
idx = df.loc[mask.cumsum().eq(1) & mask].index[0]
df = df.loc[:idx]
print(df)
# attempt 2
out = df[~mask.cummax()]
这是我的数据框：
import pandas as pd
df = pd.DataFrame(
{
'a': [4, 3, 2, 2, 6]
}
)
这是预期的输出：我想创建列id：
a id
0 4 x_0
1 3 x_1
2 2 x_2
3 2 x_3
4 6 x_4
我可以id这样创建，但我认为有一个行话：
df['id'] = np.arange(len(df))
df['id'] = 'x_' + df.id.astype(str)
我更喜欢不使用index.
这是这篇文章的延伸。
我的数据框是：
import pandas as pd
df = pd.DataFrame(
{
'main': ['x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'y', 'y', 'y', 'y', 'y', 'y', 'y'],
'sub': ['c', 'c', 'c', 'd', 'd', 'e', 'e', 'e', 'e', 'f', 'f', 'f', 'f', 'g', 'g', 'g'],
'num_1': [97, 90, 105, 2100, 1000, 101, 110, 222, 90, 100, 99, 90, 2, 92, 95, 93],
'num_2': [100, 100, 100, 102, 102, 209, 209, 209, 209, 100, 100, 100, 100, 90, 90, 90],
'num_3': [99, 110, 110, 110, 110, 222, 222, 222, 222, 150, 101, 200, 5, 95, 95, 100],
'label': ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']
}
)
这是预期的输出。我想创建专栏result：
main sub num_1 num_2 num_3 label result
0 x c 97 100 99 a b
1 x c 90 100 110 b b
2 x c 105 100 110 c b
3 x d 2100 102 110 d f
4 x d 1000 102 110 e f
5 x e 101 209 222 f f
6 x e 110 209 222 g f
7 x e 222 209 222 h f
8 x e 90 209 222 i f
9 y f 100 100 150 j k
10 y f 99 100 101 k k
11 y f 90 100 200 l k
12 y f 2 100 5 m k
13 y g 92 90 95 n NaN
14 y g 95 90 95 o NaN
15 y g 93 90 100 p NaN
面具是：
mask = (
(df.num_1 < df.num_2) &
(df.num_2 < df.num_3)
)
该过程是这样开始的：
a) groupby 列是sub
b)找到满足每组掩码条件的第一行。
c)将 的值放入label结果中
如果没有满足掩码条件的行，则将 groupby 列更改为 来main查找掩码的第一行。这个阶段有一个条件：
用作列sub时不应考虑前面的s 。maingroupby
d上述子列中的组步骤的示例：
a) sub是 groupby 列。
b)d组中没有df.num_2位于df.num_1和之间的行df.num_3（ 的条件mask）
现在对于 group d，搜索其主要组。然而组c也在这个主组中。由于它位于 group 之前d，因此 groupc不应计入此步骤。因此，在x组中，第一行有mask标签f(101 < 102 < 222)。
需要注意的一件事是，对于每个sub组来说num_2，整个组都不会发生变化。例如整个组c num_2为 100。
这是我基于这个答案的尝试，但它不起作用：
def find(g):
# get sub as 0,1,2…
sub = pd.factorize(g['sub'])[0]
# convert inputs to numpy
a = g['num_1'].to_numpy()
b = g.loc[~g['sub'].duplicated(), 'num_2'].to_numpy()
c = g['num_3'].to_numpy()
# form mask
# (a[:, None] > b) -> num_1 > num_2
# (sub[:, None] >= np.arange(len(b))) -> exclude previous groups
m = (a[:, None] < b) & (a[:, None] > c) & (sub[:, None] >= np.arange(len(b)))
# find first True per column
return pd.Series(np.where(m.any(0), a[m.argmax(0)], np.nan)[sub],
index=g.index)
df['result'] = df.groupby('main', group_keys=False).apply(find)
这是我的数据框：
import pandas as pd
df = pd.DataFrame(
{
'main': ['x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'y', 'y', 'y', 'y', 'y', 'y', 'y'],
'sub': ['c', 'c', 'c', 'd', 'd', 'e', 'e', 'e', 'e', 'f', 'f', 'f', 'f', 'g', 'g', 'g'],
'num_1': [10, 9, 80, 80, 99, 101, 110, 222, 90, 1, 7, 10, 2, 10, 95, 10],
'num_2': [99, 99, 99, 102, 102, 209, 209, 209, 209, 100, 100, 100, 100, 90, 90, 90]
}
)
这是我的预期输出。我想添加列result：
main sub num_1 num_2 result
0 x c 10 99 101
1 x c 9 99 101
2 x c 80 99 101
3 x d 80 102 110
4 x d 99 102 110
5 x e 101 209 222
6 x e 110 209 222
7 x e 222 209 222
8 x e 90 209 222
9 y f 1 100 NaN
10 y f 7 100 NaN
11 y f 10 100 NaN
12 y f 2 100 NaN
13 y g 10 90 95
14 y g 95 90 95
15 y g 10 90 95
面具是：
mask = (df.num_1 > df.num_2)
该过程是这样开始的：
a)该groupby列是sub
b)找到满足每组掩码条件的第一行。
c)将 的值num_1放入result
如果没有满足掩码条件的行，则将该groupby列更改为main来查找 的第一行mask。这个阶段有一个条件：
用作列subs时不应考虑前一个。maingroupby
d上述列中组的步骤示例sub：
a)sub是groupby列。
db)组中没有行df.num_1 > df.num_2
所以现在对于 group d，它的main组被搜索。然而组c也在这个main组中。由于它位于 group 之前d，因此 groupc不应计入此步骤。
在这张图片中，我展示了这些值的来源：
这就是我的尝试。它部分解决了某些群体的问题，但不是全部：
def step_a(g):
mask = (g.num_1 > g.num_2)
g.loc[mask.cumsum().eq(1) & mask, 'result'] = g.num_1
g['result'] = g.result.ffill().bfill()
return g
a = df.groupby('sub').apply(step_a)
这是我的数据框。
import pandas as pd
df = pd.DataFrame(
{
'a': [100, 1123, 9999, 100, 1, 954, 1],
'b': [1000, 11123, 1123, 0, 55, 0, 1],
},
)
预期输出正在创建列c：
a b c
0 100 1000 NaN
1 1123 11123 NaN
2 9999 1123 9999.0
3 100 0 NaN
4 1 55 NaN
5 954 0 NaN
6 1 1 NaN
面具是：
mask = ((df.a > df.b))
我想获得满足此掩码条件的第一行（如果它位于前 3 行）并放入df.acreate c。对于此示例，此代码有效：
df.loc[mask.cumsum().eq(1) & mask, 'c'] = df.a
但对于此 DataFrame，它应该返回NaNfor c，因为 的第一个实例mask不在前 3 行中。但这不起作用。
df = pd.DataFrame(
{
'a': [0, 0, 0, 0, 0, 954, 1],
'b': [1000, 11123, 1123, 0, 55, 0, 1],
},
)
这是我的数据框：
import pandas as pd
df = pd.DataFrame(
{
'a': [100, 1123, 123, 100, 1, 0, 1],
'b': [1000, 11123, 1123, 0, 55, 0, 1],
},
index=range(100, 107)
)
这是预期的输出。我想创建专栏c：
a b c
100 100 1000 NaN
101 1123 11123 NaN
102 123 1123 NaN
103 100 0 3.0
104 1 55 NaN
105 0 0 NaN
106 1 1 NaN
使用的掩模是：
mask = ((df.a > df.b))
我想获取出现的第一行的索引mask。我想保留原始索引但获取值reset_index()。在此示例中，掩码的第一个实例位于索引处3。
我可以通过以下方式获取掩码的第一个实例：
df.loc[mask.cumsum().eq(1) & mask, 'c'] = 'the first row'
但我不知道如何获取索引。
这是我的数据框。
import pandas as pd
import numpy as np
df = pd.DataFrame(
{
'a': [2, 2, 2, -4, np.nan, np.nan, 4, -3, 2, -2, -6],
'b': [2, 2, 2, 4, 4, 4, 4, 3, 2, 2, 6]
}
)
a我想在导出到 Excel 时仅为列添加正数加号。例如1变成+1。请注意，我NaN也有价值观。我希望它们是 Excel 中的空单元格，类似于 Pandas 在处理NaN中的值时的默认行为to_excel.
我尝试了很多解决方案。这是其中之一。但在 Excel 中却不起作用。
df.style.format({'a': '{:+g}'}).to_excel(r'df.xlsx', sheet_name='xx', index=False)
我的数据框是：
df = pd.DataFrame(
{
'a': [20, 9, 31, 40],
'b': [1, 10, 17, 30],
}
)
预期输出：创建列c和name
a b c name
0 20 1 20 NaN
1 9 10 20 NaN
2 31 17 17 NaN
3 40 30 40 a
脚步：
a)c由以下人员创建df['c'] = np.fmax(df['a'].shift().bfill(), df['b'])
b) 对于最后一行：df['c'] = df[['a', 'b']].max(). 因为最后一行a > b选择了 40。
c) 获取最后一行之间a或最后一行的最大值的名称。b
我的尝试：
df['c'] = np.fmax(df['a'].shift().bfill(), df['b'])
df.loc[df.index[-1], 'c'] = df.loc[df.index[-1], ['a', 'b']].max()
df.loc[df.index[-1], 'name'] = df.loc[df.index[-1], ['a', 'b']].idxmax()
这是最干净的方法/最好的方法吗？
我的数据框是：
import pandas as pd
df = pd.DataFrame(
{
'a': [20, 9, 31, 40],
'b': [1, 10, 17, 30],
}
)
预期输出：创建列c
a b c
0 20 1 20
1 9 10 20
2 31 17 17
3 40 30 31
脚步：
cdf.b是和之间的最大值df.a.shift(1).bfill()。
我的尝试：
df['temp'] = df.a.shift(1).bfill()
df['c'] = df[['temp', 'b']].max(axis=1)
这是最干净的方法/最好的方法吗？
这是我的数据框：
import pandas as pd
df = pd.DataFrame(
{
'a': [101, 90, 11, 120, 1]
}
)
这就是我想要的输出。我想创建专栏y：
a y
0 101 101.0
1 90 101.0
2 11 90.0
3 120 120.0
4 1 120.0
基本上，将 中的值a与其先前的值进行比较，并选择较大的值。
例如，对于 row 1，将 90 与 101 进行比较。101 更大，因此选择它。
我是这样做的：
df['x'] = df.a.shift(1)
df['y'] = df[['a', 'x']].max(axis=1)
是否有清洁剂或某种内置方法可以做到这一点？
这是我的数据框：
df = pd.DataFrame(
{
'a': [0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0],
'b': [1, -1, -1, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1]
}
)
这就是我想要的输出。我想创建专栏c：
a b c
0 0 1 0
1 0 -1 0
2 1 -1 0
3 1 -1 0
4 1 1 1
5 1 -1 1
6 0 1 0
7 0 1 0
8 0 -1 0
9 1 1 1
10 1 1 1
11 1 -1 1
12 0 1 0
13 0 1 0
14 1 -1 0
15 1 -1 1
16 0 1 0
这基本上是这篇文章的扩展。下面突出显示的行总结了需要完成此操作的方式。
首先，在column中a，组是由连续1秒和连续结束后的一行创建的。列中突出显示的行a是这些组。这一步的解决方案在这里。
现在我需要的是检查b中每个组的列a。找到每个组中第一个为 1 的值b。然后在此之前的任何值都变为 0。这就是c创建列的方式。
例如，对于 中的第一组a，列为 1 的第一个值b是行号4。该组中先前的值变为 0。结果是 列 中第一个突出显示的组c。
注意，如果对于一个组， 中的所有值b都不为 1，则对应的组 中c将变为全 0。
这是我尝试过的方法，但找不到完整的解决方案：
g = df.loc[::-1, 'a'].eq(0).cumsum()
x = df.groupby(g).filter(lambda x: x.b.iloc[0] == 1)