问题：
有效地查找数据帧列中的连续条纹？
邓夕
我有一个类似下面的DataFrame：，我想添加一个Streak列到它（见下面的例子）：
Date Home_Team Away_Team Winner Streak
2005-08-06 A G A 0
2005-08-06 B H H 0
2005-08-06 C I C 0
2005-08-06 D J J 0
2005-08-06 E K K 0
2005-08-06 F L F 0
2005-08-13 A B A 1
2005-08-13 C D D 1
2005-08-13 E F F 0
2005-08-13 G H H 0
2005-08-13 I J J 0
2005-08-13 K L K 1
2005-08-20 B C B 0
2005-08-20 A D A 2
2005-08-20 G K K 0
2005-08-20 I E E 0
2005-08-20 F H F 2
2005-08-20 J L J 2
2005-08-27 A H A 3
2005-08-27 B F B 1
2005-08-27 J C C 3
2005-08-27 D E D 0
2005-08-27 I K K 0
2005-08-27 L G G 0
2005-09-05 B A A 2
2005-09-05 D C D 1
2005-09-05 F E F 0
2005-09-05 H G H 0
2005-09-05 J I I 0
2005-09-05 K L K 4
DataFrame大约200k行，从2005年到2020年。
现在，我要做的是在数据框的日期列中找到主队在该日期之前连续赢得的比赛数。我有一个解决方案，但速度太慢，请参见以下内容：
df["Streak"] = 0
def home_streak(x): # x is a row of the DataFrame
"""Keep track of a team's winstreak"""
home_team = x["Home_Team"]
date = x["Date"]
# all previous matches for the home team
home_df = df[(df["Home_Team"] == home_team) | (df["Away_Team"] == home_team)]
home_df = home_df[home_df["Date"] < date].sort_values(by="Date", ascending=False).reset_index()
if len(home_df.index) == 0: # no previous matches for that team, so start streak at 0
return 0
elif home_df.iloc[0]["Winner"] != home_team: # lost the last match
return 0
else: # they won the last game
winners = home_df["Winner"]
streak = 0
for i in winners.index:
if home_df.iloc[i]["Winner"] == home_team:
streak += 1
else: # they lost, return the streak
return streak
df["Streak"] = df.apply(lambda x: home_streak(x), axis = 1)
我怎样才能加快速度？
共有3个答案
呼延辰龙
无法想到熊猫解决方案，但您可以使用ngroup分配组号，然后使用defaultdices创建组，以便您可以查找累积结果：
from collections import defaultdict
d = defaultdict(lambda: defaultdict(int))
df["group"] = df.groupby("Date").ngroup()
for a, b in zip(df["Winner"], df["group"]):
d[b][a] = 1+d.get(b-1,{}).get(a, 0)
df["Streak"] = [d.get(y-1, {}).get(x, 0) for x, y in zip(df["Home_Team"], df["group"])]
print (df.drop("group", 1))
Date Home_Team Away_Team Winner Streak
0 2005-08-06 A G A 0
1 2005-08-06 B H H 0
2 2005-08-06 C I C 0
3 2005-08-06 D J J 0
4 2005-08-06 E K K 0
5 2005-08-06 F L F 0
6 2005-08-13 A B A 1
7 2005-08-13 C D D 1
8 2005-08-13 E F F 0
9 2005-08-13 G H H 0
10 2005-08-13 I J J 0
11 2005-08-13 K L K 1
12 2005-08-20 B C B 0
13 2005-08-20 A D A 2
14 2005-08-20 G K K 0
15 2005-08-20 I E E 0
16 2005-08-20 F H F 2
17 2005-08-20 J L J 2
18 2005-08-27 A H A 3
19 2005-08-27 B F B 1
20 2005-08-27 J C C 3
21 2005-08-27 D E D 0
22 2005-08-27 I K K 0
23 2005-08-27 L G G 0
24 2005-09-05 B A A 2
25 2005-09-05 D C D 1
26 2005-09-05 F E F 0
27 2005-09-05 H G H 0
28 2005-09-05 J I I 0
29 2005-09-05 K L K 4
万浩淼
优雅的方式：
new_df = (df.reset_index()
.melt(['index', 'Date', 'Winner'])
.assign(win=lambda x: x['value'].eq(x.Winner))
.sort_values('Date')
.assign(cum_wins=lambda x: x.groupby('value')['win'].cumsum())
.assign(cum_wins_prev=lambda x: x.groupby('value')['cum_wins'].shift(fill_value=0))
.pivot_table(index='index', values='cum_wins_prev', columns='variable')
.add_prefix('Streak_')
)
print(new_df)
variable Streak_Away_Team Streak_Home_Team
index
0 0.0 0.0
1 0.0 0.0
2 0.0 0.0
3 0.0 0.0
4 0.0 0.0
5 0.0 0.0
6 0.0 1.0
7 0.0 1.0
8 1.0 0.0
9 1.0 0.0
10 1.0 0.0
11 0.0 1.0
12 1.0 0.0
13 1.0 2.0
14 2.0 0.0
15 0.0 0.0
16 2.0 2.0
17 0.0 2.0
#new_df = df.assign(**new_df) #you could use join or assign
new_df = df.join(new_df)
print(new_df)
Date Home_Team Away_Team Winner Streak_Away_Team Streak_Home_Team
0 2005-08-06 A G A 0.0 0.0
1 2005-08-06 B H H 0.0 0.0
2 2005-08-06 C I C 0.0 0.0
3 2005-08-06 D J J 0.0 0.0
4 2005-08-06 E K K 0.0 0.0
5 2005-08-06 F L F 0.0 0.0
6 2005-08-13 A B A 0.0 1.0
7 2005-08-13 C D D 0.0 1.0
8 2005-08-13 E F F 1.0 0.0
9 2005-08-13 G H H 1.0 0.0
10 2005-08-13 I J J 1.0 0.0
11 2005-08-13 K L K 0.0 1.0
12 2005-08-20 B C B 1.0 0.0
13 2005-08-20 A D A 1.0 2.0
14 2005-08-20 G K K 2.0 0.0
15 2005-08-20 I E E 0.0 0.0
16 2005-08-20 F H F 2.0 2.0
17 2005-08-20 J L J 0.0 2.0
据了解，一支球队每天比赛不超过一次
时代
%%timeit
df["Streak"] = 0
def home_streak(x): # x is a row of the DataFrame
"""Keep track of a team's winstreak"""
home_team = x["Home_Team"]
date = x["Date"]
# all previous matches for the home team
home_df = df[(df["Home_Team"] == home_team) | (df["Away_Team"] == home_team)]
home_df = home_df[home_df["Date"] < date].sort_values(by="Date", ascending=False).reset_index()
if len(home_df.index) == 0: # no previous matches for that team, so start streak at 0
return 0
elif home_df.iloc[0]["Winner"] != home_team: # lost the last match
return 0
else: # they won the last game
winners = home_df["Winner"]
streak = 0
for i in winners.index:
if home_df.iloc[i]["Winner"] == home_team:
streak += 1
else: # they lost, return the streak
return streak
df["Streak"] = df.apply(lambda x: home_streak(x), axis = 1)
66.2 ms ± 9.54 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%%timeit
new_df = (df.reset_index()
.melt(['index', 'Date', 'Winner'])
.assign(win=lambda x: x['value'].eq(x.Winner))
.sort_values('Date')
.assign(cum_wins=lambda x: x.groupby('value')['win'].cumsum())
.assign(cum_wins_prev=lambda x: x.groupby('value')['cum_wins'].shift(fill_value=0))
.pivot_table(index='index', values='cum_wins_prev', columns='variable')
.add_prefix('Streak_')
)
new_df=df.assign(**new_df)
29.5 ms ± 2.97 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
戚澄邈
我将在这里提出一个基于Numpy的解决方案。首先是因为我对熊猫不太熟悉，也不想做这项研究，其次是因为无论如何，一个麻木的解决方案都应该工作得很好。
让我们来看看一个给定的团队首先会发生什么。你的目标是根据一支球队参加的比赛的顺序，找出该队连续获胜的次数。我将删除日期列，并将您的数据转换为numpy数组供初学者使用：
x = np.array([
['A', 'G', 'A'],
['B', 'H', 'H'],
['C', 'I', 'C'],
['D', 'J', 'J'],
['E', 'K', 'K'],
['F', 'L', 'F'],
['A', 'B', 'A'],
['C', 'D', 'D'],
['E', 'F', 'F'],
['G', 'H', 'H'],
['I', 'J', 'J'],
['K', 'L', 'K'],
['B', 'C', 'B'],
['A', 'D', 'A'],
['G', 'K', 'K'],
['I', 'E', 'E'],
['F', 'H', 'F'],
['J', 'L', 'J']])
你不需要日期，因为你只关心谁玩，即使他们在一天内玩了多次。所以让我们看看团队A：
A_played = np.flatnonzero((x[:, :2] == 'A').any(axis=1))
A_won = x[A_played, -1] == 'A'
A_是一个索引数组，其元素数与x中的行数相同A_-won是一个包含与np一样多元素的掩码。计数非零（播放的A）；i、 例如，A参与的游戏数量。
找到条纹的大小是一个相当复杂的问题：
streaks = np.diff(np.flatnonzero(np.diff(np.r_[False, A_won, False])))[::2]
计算掩码值切换的每对索引之间的差异。使用False的额外填充确保您知道掩码的切换方式。您所寻找的是基于此计算的，但需要更多的细节，因为您需要累积和，但在每次运行后重置。可以在运行后立即将数据值设置为否定的运行长度：
wins = np.r_[0, A_won, 0] # Notice the int dtype here
switch_indices = np.flatnonzero(np.diff(wins)) + 1
streaks = np.diff(switch_indices)[::2]
wins[switch_indices[1::2]] = -streaks
现在，您有了一个可修剪数组，其累积总和可以直接分配给输出列：
streak_counts = np.cumsum(wins[:-2])
output = np.zeros((x.shape[0], 2), dtype=int)
# Home streak
home_mask = x[A_played, 0] == 'A'
output[A_played[home_mask], 0] = streak_counts[home_mask]
# Away streak
away_mask = ~home_mask
output[A_played[away_mask], 1] = streak_counts[away_mask]
现在，您可以遍历所有团队（与游戏总数相比，这应该是一个相当小的数字）：
def process_team(data, team, output):
played = np.flatnonzero((data[:, :2] == team).any(axis=1))
won = data[played, -1] == team
wins = np.r_[0, won, 0]
switch_indices = np.flatnonzero(np.diff(wins)) + 1
streaks = np.diff(switch_indices)[::2]
wins[switch_indices[1::2]] = -streaks
streak_counts = np.cumsum(wins[:-2])
home_mask = data[played, 0] == team
away_mask = ~home_mask
output[played[home_mask], 0] = streak_counts[home_mask]
output[played[away_mask], 1] = streak_counts[away_mask]
output = np.empty((x.shape[0], 2), dtype=int)
# Assume every team has been home team at least once.
# If not, x[:, :2].ravel() copies the data and np.unique(x[:, :2]) does too
for team in set(x[:, 0]):
process_team(x, team, output)
类似资料：
-
问题内容： 我有一个大的数据框（几百万行）。 我希望能够对它进行分组操作，而只是按行的任意连续（最好大小相等）的子集进行分组，而不是使用各个行的任何特定属性来确定它们要进入的组。 用例：我想通过IPython中的并行映射将函数应用于每一行。哪行进入哪个后端引擎都没有关系，因为该函数一次基于一行来计算结果。（至少在概念上；实际上是矢量化的。） 我想出了这样的东西： 但这似乎很漫长，并且不能保证大小相
-
预期产出 每列计数为nan/null的数据帧 注意：我在堆栈溢出中发现的前面的问题只检查null 我知道我可以在Spark中使用函数来查找Spark列中的空值数，但如何在Spark数据帧中查找Nan值？
-
假设我有一个如下所示的数据框，我需要识别每行，其中一个或多个缺失值 （NA） 后跟至少一个有效值（任何数字）。你可以帮我吗？
-
问题内容： 我正在尝试使用蒙特卡洛算法查找下周的乐透数字包含连续数字的概率。我认为对数字进行排序可能会使实际查找连续项更加容易，但是在网上搜索了很多之后，似乎并没有什么真正可以帮助我寻找所需内容的信息 到目前为止，这就是我所知道的，我知道我将使用计数器来查找百万结果中的连续数，但实际上我只是为如何真正找到连续数而烦恼 问题答案： 首先我读错了问题，对不起，答案很抱歉！ 好吧，让我们分手吧。那么首先
-
问题内容： 我有一个表，每个月的每月（一年中的每个月）包含1条记录。我需要确定给定月份的站点是否至少有15个连续记录，并且我需要知道该连续天数的开始和结束日期。我可以在存储过程中执行此操作，但我希望可以在单个查询中完成此操作。我正在处理一个相当大的数据集，每月至少有3000万条记录。 结果示例： 感谢您的帮助！ 问题答案： 这是有关如何执行此查询的示例： 然后查询： 结果： 问候，罗布。
-
问题内容： 如果我有串，我要检查，如果它作为一个连续存在 串 中，我可以使用： 在非连续子 序列 的情况下，我可以使用什么？例： 问题答案： 我不知道是否有内置功能，但是手动操作相当简单