使用Python和Pandas实现一个经典鞅

Question

我想在投注系统中使用Python和Pandas实现一个经典鞅。在

假设这个数据帧是这样定义的

df = pd.DataFrame(np.random.randint(0,2,100)*2-1, columns=['TossResults'])

所以它包含掷骰结果（-1=输1=赢）

我想改变赌注（我每次下注的金额）使用经典鞅。在

初始股份为1。在

如果我失去的股份将是先前股份的2倍（乘数=2）。在

如果我赢了赌注将是赌注首字母

我做了个功能

^{pr2}$

但我不知道如何有效地利用熊猫来实现它。 我试过了：

initial_stake = 1
df['Stake'] = None
df['Stake'][0] = initial_stake
df['TossResultsPrevious'] = self.df['TossResults'].shift(1) # shifting-lagging
df['StakePrevious'] = self.df['Stake'].shift(1) # shifting-lagging

但现在，我需要沿着0轴应用这个（多参数）函数。在

我不知道该怎么办！在

我曾经见过pandas.DataFrame.applymap函数，但它似乎只是一个参数函数。在

也许我错了，使用shift函数不是一个好主意

Answer 1

一个小小的解释变化是，您需要将一次失败标记为1，而将一次胜利标记为0。在

第一步是找到丢失的运行的边缘，（steps+edges）。然后需要计算步骤大小的差异，并将这些值推回到原始数据中。当你得到cumsum的toss2时，它给出了你当前的连败时间。你的赌注是2 ** cumsum(toss2)。在

numpy版本比pandas版本快，但该系数取决于N（对于N=100为~8，对于{}为~2）。在

---

熊猫

使用pandas.Series：

import pandas as pd
toss = np.random.randint(0,2,100)

toss = pd.Series(toss)

steps = (toss.cumsum() * toss).diff() # mask out the cumsum where we won [0 1 2 3 0 0 4 5 6 ... ]
edges = steps < 0 # find where the cumsum steps down -> where we won
dsteps = steps[edges].diff() # find the length of each losing streak
dsteps[steps[edges].index[0]] = steps[edges][:1] # fix length of the first run which in now NaN
toss2 = toss.copy() # get a copy of the toss series
toss2[edges] = dsteps # insert the length of the losing streaks into the copy of the toss results
bets = 2 ** (toss2).cumsum() # compute the wagers

res = pd.DataFrame({'toss': toss,
                    'toss2': toss2,
                    'runs': toss2.cumsum(),
                    'next_bet': bets})

---

numpy公司

这是纯粹的numpy版本（我的母语是它）。为了让数组排成一行，pandas为您做了一些精细的工作

^{pr2}$

---

熊猫产量

In [65]: res
Out[65]: 
    next_bet  runs  toss  toss2
0          1     0     0      0
1          2     1     1      1
2          4     2     1      1
3          8     3     1      1
4         16     4     1      1
5          1     0     0     -4
6          1     0     0      0
7          2     1     1      1
8          4     2     1      1
9          1     0     0     -2
10         1     0     0      0
11         2     1     1      1
12         4     2     1      1
13         1     0     0     -2
14         1     0     0      0
15         2     1     1      1
16         1     0     0     -1
17         1     0     0      0
18         2     1     1      1
19         1     0     0     -1
20         1     0     0      0
21         1     0     0      0
22         2     1     1      1
23         1     0     0     -1
24         2     1     1      1
25         1     0     0     -1
26         1     0     0      0
27         1     0     0      0
28         2     1     1      1
29         4     2     1      1
30         1     0     0     -2
31         2     1     1      1
32         4     2     1      1
33         1     0     0     -2
34         1     0     0      0
35         1     0     0      0
36         1     0     0      0
37         2     1     1      1
38         4     2     1      1
39         1     0     0     -2
40         2     1     1      1
41         4     2     1      1
42         8     3     1      1
43         1     0     0     -3
44         1     0     0      0
45         1     0     0      0
46         1     0     0      0
47         2     1     1      1
48         1     0     0     -1
49         2     1     1      1
50         1     0     0     -1
51         1     0     0      0
52         1     0     0      0
53         1     0     0      0
54         1     0     0      0
55         2     1     1      1
56         1     0     0     -1
57         1     0     0      0
58         1     0     0      0
59         1     0     0      0
60         1     0     0      0
61         2     1     1      1
62         1     0     0     -1
63         2     1     1      1
64         4     2     1      1
65         8     3     1      1
66        16     4     1      1
67        32     5     1      1
68         1     0     0     -5
69         2     1     1      1
70         1     0     0     -1
71         2     1     1      1
72         4     2     1      1
73         1     0     0     -2
74         2     1     1      1
75         1     0     0     -1
76         1     0     0      0
77         2     1     1      1
78         4     2     1      1
79         1     0     0     -2
80         1     0     0      0
81         2     1     1      1
82         1     0     0     -1
83         1     0     0      0
84         1     0     0      0
85         1     0     0      0
86         2     1     1      1
87         4     2     1      1
88         8     3     1      1
89        16     4     1      1
90        32     5     1      1
91        64     6     1      1
92         1     0     0     -6
93         1     0     0      0
94         1     0     0      0
95         1     0     0      0
96         2     1     1      1
97         1     0     0     -1
98         1     0     0      0
99         1     0     0      0

---

numpy输出

（不同于panadas结果的种子）

(result -> next bet):
w->  1
l->  2
w->  1
w->  1
l->  2
w->  1
l->  2
w->  1
l->  2
l->  4
w->  1
l->  2
w->  1
l->  2
l->  4
w->  1
w->  1
w->  1
l->  2
l->  4
l->  8
w->  1
l->  2
l->  4
w->  1
l->  2
l->  4
w->  1
w->  1
l->  2
w->  1
w->  1
w->  1
w->  1
l->  2
l->  4
w->  1
w->  1
l->  2
l->  4
l->  8
w->  1
w->  1
l->  2
l->  4
w->  1
w->  1
w->  1
w->  1
w->  1
w->  1
l->  2
w->  1
l->  2
w->  1
l->  2
w->  1
w->  1
w->  1
w->  1
w->  1
w->  1
l->  2
l->  4
l->  8
l->  16
w->  1
l->  2
l->  4
w->  1
w->  1
w->  1
w->  1
l->  2
w->  1
w->  1
l->  2
w->  1
w->  1
w->  1
l->  2
w->  1
w->  1
w->  1
w->  1
w->  1
w->  1
l->  2
l->  4
l->  8
w->  1
w->  1
l->  2
l->  4
l->  8
w->  1
l->  2
l->  4
w->  1
l->  2

Answer 2

当你可以使用向量化操作时，Pandas将获得最大的效率胜利，但我认为这个问题需要迭代。使用熊猫的解决方案：

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randint(0,2,100)*2-1, columns=['TossResults'])
initial_stake = 1
df['Stake'] = initial_stake

for i in xrange(1,df.shape[0]):
    if df.TossResults[i-1] == -1:
        df.Stake[i] = 2 * df.Stake[i-1]