如何用Python投机倒把几天“暴富”

本文涉及到的技术点有（多图预警！）：

• 1.Packet Capture和Charles抓包；
• 2.安卓AccessibilityService无障碍服务实现自动下注；
• 3.Python爬虫模拟下注；
• 4.Python Flask编写简单接口；
• 5.Python使用Selenium应对JS动态加载数据的网页;

---

行吧，别做梦了，暴富了，我还这里码字？标题党的感觉就是舒服，还是踏踏实实搬砖吧！关于赚大钱的捷径都写在刑法里，想具体了解的可以到逼乎自行查阅：都说最赚钱的方法都在刑法里面,那么宪法里面到底禁止了哪些暴利的赚钱方法？这些方法到底有多赚钱呢？我只能帮你们到这里了。投机倒把暴富的念想是挺美好的，但我投机倒把的真实的结果是：国庆短短几天，因为投机倒把我亏了7755块（截止目前亏了9073块）...

编写本文的出于下面几个初衷：

• 1.记录自己在投机倒把过程中运用到的一些开发技术；
• 2.记录这次投机倒把的经历，以此警示自己以后要踏踏实实做事；
• 3.奉劝各位有这种念想的伙计引以为戒，远离投机倒把，保持身心健康。

在真正开始本文之前，要严肃的强调几点：

• 投机倒把，十有九输，或者十输，输！投机倒把中赚钱的永远是极少数的幸运儿。如果只为娱乐，不为赢钱可以，参考过年家里常有的小赌怡情，玩个几百块，赢了和输了都收手。
• 本文不是让你去投机倒把，所以不会提供任何APP下载外链或文件！

本文的讲解流程：

先讲解一波投机倒把相关的概念，然后通过和两个好基友的沙雕聊天记录，引出一些开发相关的东西，分析一波投机倒把过程里的一些猫腻，希望各位看官会喜欢这个有（悲）趣（伤）的真实故事~

---

第零章：名词碎碎念

先来了解一波和投机倒把有关的名词吧~

0.1 赌徒心理（贪欲和侥幸心理）

赢了还想赢更多的钱，输了又想回本，反复告诉自己赢一把就收手，回本就收手，事实上，只有当自己的前输得精光的时候才会收手。

举个例子：

• 1.下注，输了10块，想着把10块赚回来，又压了10块，然后又输，又压20，再输压30...本没有回，钱却越输越多。
• 2.输了10块，下把下注奖为5块，赢了，患得患失，如果刚刚那把压多一点就赢好多了，输了，暗自庆幸，幸好把下注少了，不然就亏大了。

赢钱的时候也不会见好就收，毕竟对于赌徒来说，收手是最难的。

0.2 大数法则

大数不是大叔，又称“平均法则”，即：在随机事件的大量重复中往往出现几乎必然的规律。在实验条件不变的情况下，重复实验多次，随机事件的频率近似于它的概率。举个例子，我们都知道的常识：抛硬币，正反面的概率各占50%。但是，现在让你去抛两次硬币，却很难出现刚好一正一反的情况。只在你重复了上千上万次后，正和反出现的次数接近持平。

看到这里，读者可能有这样的疑问：

既然最后是五五开，那我一直玩，为什么最后还是亏了，难道是有中间商赚差价了？

讲真，真的有中间商，尽管从概率上来说，是五五开的，但是有两点根本不平等。

首先，概率是建立在大量重复实验的基础上的，庄家有“用不完的钱”，可以进行无限次投机倒把，且没有赌徒心理，而反观赌徒的资金一般是有限的。然后呢，又有一个名词，概率波动论。

0.3 概率波动论

具备两面性的规律从概率来讲是对半的，但在一段时间内有可能多数呈一面性表现。 举个简单的三个骰子买大小的例子（1-9小，10-18大），10次的结果是这样的（连续3次大）：

概率波动是概率发生的必然，因此投机倒把过程中可能出现连续输好几把的情况。

0.4 倍投法

接着是中间商赚差价的第二点，比如有一些买大小单双的赌局，胜率并不是1:2，比如1:1.96，或者1:1.82等，比如你一把玩1块，第一把输了，第二把也投1块，你中了，只赢1.96块，但是，其实你已经花了2块钱，亏4分钱。如果是1.86的，亏1毛4，看上去数额很少是吧，但是基本都不会只玩几把吧，一天下来可能玩了上千把，一个赌客就贡献了好几百，赌客肯定不止你一个，而且下注也肯定不会1块1块的来，所以说说为什么那么多投机倒把类的APP。而扭转这种亏损的一种简单而且赚钱的做法，就是倍投法。举个简单的例子，假如赔率是1:2的话，下注的金额是这样一个列表：[10,20,40,80,160,320,640,1280,2560...]，第一把投10块，输了，第2把投20，赢了40，减去本金30，赚10，没中，第3把投40，赢了80，减去本金70，赚10块，就是保证每一轮赢10块。我们写个简单的Python代码来生成一个倍投收益的表格。代码如下（prettytable库用于生成表格）：

from prettytable import PrettyTable

purchase_base = 10  # 购买基数
ratio = 2  # 中奖倍率
price_list = []  # 投入金额


def init_purchase_list():
    x = PrettyTable(['投入', '投入总额', '获利', '净利润'])
    cost = 0
    price_list.append(purchase_base)
    # 其他进行动态计算
    print("初始化投入金额表格...")
    for i in range(0, 10):
        cost += purchase_base * (2 ** i)    # 花费
        bonus = purchase_base * (2 ** i) * ratio    # 奖金
        x.add_row([purchase_base * (2 ** i), cost, bonus, bonus - cost])
    print(x)


if __name__ == '__main__':
    init_purchase_list()
复制代码

运行下程序，可以得出一个倍投的结果列表：

初始化投入金额表格...
+------+----------+-------+--------+
| 投入 | 投入总额 |  获利 | 净利润 |
+------+----------+-------+--------+
|  10  |    10    |   20  |   10   |
|  20  |    30    |   40  |   10   |
|  40  |    70    |   80  |   10   |
|  80  |   150    |  160  |   10   |
| 160  |   310    |  320  |   10   |
| 320  |   630    |  640  |   10   |
| 640  |   1270   |  1280 |   10   |
| 1280 |   2550   |  2560 |   10   |
| 2560 |   5110   |  5120 |   10   |
| 5120 |  10230   | 10240 |   10   |
+------+----------+-------+--------+
复制代码

每一轮才挣10块，有点少是吧，你可以试试赚更多的3倍投，把上面的代码改一下：

    for i in range(0, 10):
        cost += purchase_base * (3 ** i)    # 花费
        bonus = purchase_base * (3 ** i) * ratio    # 奖金
        x.add_row([purchase_base * (3 ** i), cost, bonus, bonus - cost])
复制代码

输出结果如下：

初始化投入金额表格...
+--------+----------+--------+--------+
|  投入  | 投入总额 |  获利  | 净利润 |
+--------+----------+--------+--------+
|   10   |    10    |   20   |   10   |
|   30   |    40    |   60   |   20   |
|   90   |   130    |  180   |   50   |
|  270   |   400    |  540   |  140   |
|  810   |   1210   |  1620  |  410   |
|  2430  |   3640   |  4860  |  1220  |
|  7290  |  10930   | 14580  |  3650  |
| 21870  |  32800   | 43740  | 10940  |
| 65610  |  98410   | 131220 | 32810  |
| 196830 |  295240  | 393660 | 98420  |
+--------+----------+--------+--------+
复制代码

卧槽，刺激是吧，如果有30W的本金，三倍投，不中的次数越多，你赚的钱越多。如果连续不中到10次，中了，一轮1将近10W，这种是敢死队倍投法，很难很难挂一次，但是一旦出现一次直接跌入18层地狱永不超生！（笔者试过好几次...等下细讲）。这种是平台比例1:2的情况，有些中间商赚差价的平台的赔率是1.96这样，上面的代码生成的结果就变成了（2倍投，ratio改为1.96）：

初始化投入金额表格...
+------+----------+---------+---------------------+
| 投入 | 投入总额 |   获利  |        净利润       |
+------+----------+---------+---------------------+
|  10  |    10    |   19.6  |  9.600000000000001  |
|  20  |    30    |   39.2  |  9.200000000000003  |
|  40  |    70    |   78.4  |  8.400000000000006  |
|  80  |   150    |  156.8  |  6.800000000000011  |
| 160  |   310    |  313.6  |  3.6000000000000227 |
| 320  |   630    |  627.2  | -2.7999999999999545 |
| 640  |   1270   |  1254.4 | -15.599999999999909 |
| 1280 |   2550   |  2508.8 |  -41.19999999999982 |
| 2560 |   5110   |  5017.6 |  -92.39999999999964 |
| 5120 |  10230   | 10035.2 | -194.79999999999927 |
+------+----------+---------+---------------------+
复制代码

是的，普通的二倍投法越到后面反而越亏，而三倍投依旧是赚钱的，在本金不够充裕无法三倍投的情况下，要在二倍投的基础上加点，而且少于三倍投，保证我们每把赚的钱>购买基数，而且投入的金额最少，我们改下下我们的代码：

from prettytable import PrettyTable

purchase_base = 10  # 购买基数
ratio = 1.96  # 中奖倍率
price_list = []  # 投入金额


def init_purchase_list():
    x = PrettyTable(['投入', '投入总额', '获利', '净利润'])
    x.add_row([purchase_base, purchase_base, round(purchase_base * ratio, 2),
               round(purchase_base * ratio - purchase_base, 2)])
    cost = purchase_base
    price_list.append(purchase_base)
    # 其他进行动态计算
    print("初始化投入金额表格...")
    for i in range(10):
        purchase = 0
        # 购买价格其实区间（2倍）
        start_price = purchase_base * (2 ** i)
        # 购买价格极限区间（3倍）
        end_price = purchase_base * (3 ** i)
        # 保证没把不亏就行
        for j in range(start_price, end_price + 1):
            if j * ratio - cost - j > purchase_base:
                x.add_row([j, cost + j, round(j * ratio, 2), round(j * ratio - cost - j, 2)])
                cost += j
                price_list.append(j)
                break
    print(x)


if __name__ == '__main__':
    init_purchase_list()
复制代码

输出下注金额列表如下：

初始化投入金额表格...
+------+----------+----------+--------+
| 投入 | 投入总额 |   获利   | 净利润 |
+------+----------+----------+--------+
|  10  |    10    |   19.6   |  9.6   |
|  21  |    31    |  41.16   | 10.16  |
|  43  |    74    |  84.28   | 10.28  |
|  88  |   162    |  172.48  | 10.48  |
| 180  |   342    |  352.8   |  10.8  |
| 367  |   709    |  719.32  | 10.32  |
| 749  |   1458   | 1468.04  | 10.04  |
| 1530 |   2988   |  2998.8  |  10.8  |
| 3123 |   6111   | 6121.08  | 10.08  |
| 6377 |  12488   | 12498.92 | 10.92  |
+------+----------+----------+--------+
复制代码

以上就是通过Python计算倍投下注金额，关于更多的倍投方法可自行查阅：倍投的方案全面讲解如何倍投，关于投机倒把的名词就科普那么多，正式开始这个令人悲伤的故事吧~

---

第一章：引子

和往常一样，下午等电梯去吃饭，好基友小A又掏出他的小锤子在那里把玩，抱着好奇心的 我用眼角的余光瞄了一下他在看什么，em...竟然不是那种不堪入目的东西？

在我的威逼利诱（Y威）下全盘托出：别人介绍玩的一款赚钱APP（买彩票）。但是，我记得错网络售彩不是从15年就开始命令禁止了吗。行吧，看了下，私庄（私人庄家）。然后大概看了看APP：

页面非常简单，四个部分：

• 1.顶部最新一期下注倒计时+用户余额
• 2.每期开奖结果
• 3.房间里赌客的投注记录
• 4.下注面板

规则就是下注结果和出的结果一样就中，根据买的种类有不同的倍率，三分钟开一把，下注最小金额10元宝（10块），数据来源加拿大28彩票的出奖结果。这种算是公彩吧，不是私彩。区分的最简单依据就是有这个项目的多个平台是不是开奖的结果都是一样的，相比起私彩，公彩稍微稍微公平一点。私彩的话，后台是可以调的！！！好吧，一向对于投机倒把不怎么感冒的我就没有过多的关注了。不过，他貌似从别人那里搞了个下注的投法，慢慢从20奋斗到102，成功引起了我的注意。

这个所谓靠谱的投法就是：

• 1.历史记录里，单跟双，多就买谁。
• 2.历史记录里面，大跟小，少就买谁。
• 3.每一次亏了下一把就把下注金额在上一把基础上翻倍，每一次赚了下一把下注金额就还原到最低值。 4.循环上面三步骤。如果遇到异常流：当前步骤应该买大小或者单双时，出现历史记录里他们数量相同，则停止一局。

后面果然给他撸到200了：

啧啧，竟然真的从20撸到200，不心动是假的...

但是作为一个从不相信天上掉馅饼的开发仔有着自己的矜持，不模拟一下，打死我也不信，于是我盘算着，自己写个脚本按照这个投法去模拟，模拟一段时间后，看看最后是不是真的赚了。先来抓一波APP的包看看吧，这里用到的是手机抓包工具：Packet Capture

行吧，token和sign，后面另外抓了下注的接口，一大串，加密，所以基本可以放弃了。然后想逆向找下APP的代码，直接apktool反编译后看到qihoo的包名，擦，360加固，这就触及到我的知识盲区了，我还不会脱壳...

幸运的是，这是公彩，有很多网站会直接公布每一期的结果，比如： www.kandandan.com/yuce/jnd.ht…，接着打开Chrome抓下包，先看下页面节点：

可以，看下Network也可以找到这些节点，不是JS加载的，nice，所有要做的就是写一个定时器，每隔3分40秒左右（延时问题）访问一下这个站点，提取一波数据。行吧，直接用Python请求库Requests模拟一波请求就行了，定时任务用apscheduler库，最后加上投注相关的算法就可以了，直接给代码，就不解释那么多了。

import requests as r
from bs4 import BeautifulSoup
from apscheduler.schedulers.blocking import BlockingScheduler

current_buy = '单双'  # 当前买的类型
current_buy_type = '单'  # 当前下注类型
current_buy_money = 10  # 当前投注金额
is_buy_flag = False  # 此轮是否购买
first_buy = True  # 是否第一次下注
balance = 300  # 剩余金额
sched = BlockingScheduler()


def fetch_result():
    global first_buy
    resp = r.get('https://m.99yuce.com/yuce/jnd.html').text
    bs = BeautifulSoup(resp, 'lxml')
    tr_s = bs.find("table", attrs={
   'id': 'tbe'}).find_all('tr')
    # 获取数字列表
    num_list = []
    for tr in tr_s[2:12]:
        num_list.append(int(tr.find('td', attrs={
   'class': 'tbe_3'}).text))
    print(num_list)
    # 构建数字文字列表
    num_str_list = []
    for num in num_list:
        if num % 2 == 0:
            num_str_list.append('双')
        else:
            num_str_list.append('单')
        if num > 13:
            num_str_list.append('大')
        else:
            num_str_list.append('小')
    if first_buy:
        first_buy = False
        print("当前余额：", balance, " 当前投注金额：", current_buy_money, "当前买的类型：", current_buy)
    else:
        calculate(num_list[0])
    predict(num_str_list)


# 预判
def predict(num_str_list):
    global balance
    global current_buy_money
    global current_buy
    global c