7

我想在投注系统中使用 Python 和 Pandas 实现经典的马丁格尔。

假设这个 DataFrame 是这样定义的

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

所以它包含折腾结果（-1=输 1=赢）

我想用经典的马丁格尔改变赌注（我每次下注的金额）。

初始赌注为 1。

如果我失去赌注将是之前赌注的 2 倍（乘数 = 2）。

如果我赢了赌注将是stake_initial

我做了一个功能

def stake_martingale_classical(stake_previous, result_previous, multiplier, stake_initial):
    if (result_previous==-1): # lose
        stake = stake_previous*multiplier
    elif (result_previous==1):
        stake = stake_initial
    else:
        raise(Exception('Error result_previous must be equal to 1 (win) or -1 (lose)'))
    return(stake)

但我不知道如何使用 Pandas 有效地实现它。我试过这个：

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函数，但它似乎只是 1 个参数函数。

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

4

2 回答 2

6

一个细微的解释变化是您需要将损失标记为 a1并将胜利标记为0。

第一步是找到失败运行的边缘（steps+ edges）。然后，您需要获取步骤大小的差异，并将这些值推回原始数据中。当您选择其中一个cumsum时toss2，您会看到当前的连败长度。你的赌注是2 ** cumsum(toss2)。

版本比numpy版本快pandas，但因素取决于N（~8 forN=100和 ~2 for N > 10000）。

熊猫

使用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版本（我的母语是它）。需要进行一些微调才能使阵列对齐，pandas这对您有用

toss = np.random.randint(0,2,100)

steps = np.diff(np.cumsum(toss) * toss)
edges = steps < 0
edges_shift = np.append(False, edges[:-1])
init_step = steps[edges][0]
toss2 = np.array(toss)
toss2[edges_shift] = np.append(init_step, np.diff(steps[edges]))
bets = 2 ** np.cumsum(toss2)

fmt_dict = {1:'l', 0:'w'}
for t, b in zip(toss, bets):
    print fmt_dict[t] + '-> {0:d}'.format(b)

熊猫输出

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
于 2013-02-09T06:14:46.163 回答
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]
于 2013-02-07T17:50:55.210 回答