Python自学第4周反馈：大盘股指，从爬取到预测_python 大盘指数预测

目标：爬取大盘数据，并简单预测

本次忽略了股市的其他影响因素，仅对数据进行移动平滑预测，文末会附上自己写的几个常用函数和完整的整个过程代码

1.解析网页，找到目标数据

找到日K线图，点开开发者工具，数据量这么大的肯定就是这个日数据了
点开看下，一目了然
找到数据对应的位置

2.用python爬取数据

找到目标数据的位置和他的排列之后，看下爬取可能性，这个网址没有反爬，所以不用Cookie和代理，简单的请求就能得到数据，如果是要请求大量的网页时，可以先爬取网页的二级URL形成连接列表，然后遍历列表请求数据

# 1.get请求，隐去部分为学习知识点
shuju = requests.get(URL)                                                  #用requests模块请求网页
print(shuju)                                                               #得到请求状态码检查是否正确请求成功
#print(shuju.content.decode('utf-8'))                                      #返回字节流数据  自己解码，避免乱码
#print(shuju.url)                                                          #查看完整url地址，自动帮忙编码
#print(shuju.encoding)                                                     # 查看响应头部字符编码
#print(shuju.text)                                                         #返回unicode格式的数据 有中文，已经解码 返回字符串
#print(shuju.content)                                                      #返回字节流数据  无中文，编码字节
1
2
3
4
5
6
7
8

3.对数据进行处理

得到的数据并不能直接使用，要稍微处理下方便后面用，因为还没学正则，所以这里按特定符号切割得到的数据字符串，再放入标准字典。
我的标准字典，是按照第几行第几列来编码数据顺序，方便对接我自己写的其他函数

#整理得到的数据
liebiao_1= re.split(r'\[',shuju.content.decode('utf-8'))[-1]               #把字符串按方括号[切割取后面部分
liebiao_2 = re.split(r']',liebiao_1)[0]                                    #把字符串按方括号]切割取前面部分
liebiao_3 = re.split(r'","|"',liebiao_2)                                   #把字符串按引号和逗号切割
liebiao = []                                                               #建立一个空列表
for x in liebiao_3:                                                        #遍历原先切割字符串等得到的列表
    if x != '':                                                            #剔除空集
        liebiao.append(x)                                                  #放回空列表
#print(liebiao)
DaPan = {}                                                                 #建立个标准字典放数据
for i in range(0,len(liebiao)):                                            #遍历数据的行数
    DaPan['第'+str(i+1)+'行'] = {}                                         #生成行字典
    i_biao = re.split(r',',liebiao[i])                                     #对数据按逗号再切割
    for k in range(0,len(i_biao)):                                         #遍历切割好的数据到行列表下的列键
        DaPan['第' + str(i + 1) + '行']['第' + str(k + 1) + '列'] =  i_biao[k]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.对数据进行预测

我之前写了个按照周期移动预测的小脚本，把这个脚本函数化后用在这里可以较为方便得到预测数据

def Yuce(Y_,T,yece_X_T):                                                   #对周期为T的数组列表Y_预测未来X个周期的值
    Y = []                                                                 #建立一个空列表用来装格式化后的数据
    for a in Y_:                                                           #遍历数组中的数据，进行标准格式化
        a_ = float(a)                                                      #全部浮点化放给a_
        Y.append(a_)                                                       #把标准化后的数据放进预存列表

    # 1.计算一个周期变化后的连续移动求和:根据数据选取周期，日数据周期为365，周数据周期为52，月数据周期为12
    Last_T_yidong_Sum = []                                                 #建立一个列表用来存放一个周期之后的移动求和值
    for num_1 in list(range(1, len(Y) + 1 - T)):                           #移动求和值的总数量等于所有数值减去一个周期
        Sum_num = sum(Y[num_1:num_1 + T])                                  #设置好求和长度为一个周期T并求和
        Last_T_yidong_Sum.append(Sum_num)                                  #把求和结果放入预存列表

    # 2.生成移动求和的预测值
    X = list(range(1, len(Last_T_yidong_Sum) + 1))                         #因为只有一个数组，生成一个与之匹配的标准单位X
    X_pingjun = sum(X) / len(Last_T_yidong_Sum)                            #求单位X的均值
    Y_pingjun = sum(Last_T_yidong_Sum) / len(Last_T_yidong_Sum)            #求Y项的均值，即前面得出的移动求和值的均值
    Sum_1 = []                                                             # 放Xi*Yi
    Sum_2 = []                                                             # 放Xi*Xi
    for n in list(range(0, len(Last_T_yidong_Sum))):                       #遍历一个和移动求和值数组等位的序数表
        sum_1 = X[n] * Last_T_yidong_Sum[n]                                #Xi*Yi
        Sum_1.append(sum_1)                                                #对Xi*Yi求合计
        sum_2 = X[n] * X[n]                                                #Xi*Xi
        Sum_2.append(sum_2)                                                #对Xi*Xi求合计
    if (sum(Sum_2) - len(Last_T_yidong_Sum) * X_pingjun * X_pingjun) ==0:
        b = 0                                                              #剔除被除数为零的情况，被除数为零代表是一条水平线
    else:                                                                  #被除数不为零时，按照回归方程公式计算系数b
        b = (sum(Sum_1) - len(Last_T_yidong_Sum) * X_pingjun * Y_pingjun) / (sum(Sum_2) - len(Last_T_yidong_Sum) * X_pingjun * X_pingjun)
    a = Y_pingjun - b * X_pingjun                                          #计算系数a
    Yuce = list(range(len(Last_T_yidong_Sum) + 1, len(Last_T_yidong_Sum) + yece_X_T* T + 1))#生成用于预测的X数组
    X_Y_yece_sum = []                                                      #建立个列表用来放移动合计的预测值
    for yuce_X_num in Yuce:                                                #遍历需要预测Y值的X数组
        Y_yuce = b * yuce_X_num + a                                        #按照回归系数进行预测
        X_Y_yece_sum.append(Y_yuce)                                        #把得到的预测值放入预存列表

    # 3.拼接移动做差
    every_T = Y[T:]                                                        #先把原始数据中一个周期时间点后的数据放到每期中
    start_X_T = int(len(Y[T:]))                                            #计算原始数据砍去第一个周期后的剩余长度
    for sum_y in X_Y_yece_sum:                                             #遍历移动求和的预测值
        every_T.append(sum_y)                                              #把移动求和的预测值添加到每期数据后方便做差方便向前做减
    for Y_i in list(range(start_X_T, start_X_T + len(X_Y_yece_sum))):      #从历史长度之后开始到最后一个位置为止
        every_T[Y_i] = every_T[Y_i] - sum(every_T[Y_i - T + 1:Y_i])        #减去前面T-1位的合计值（减去前面T-1项的求和）

    # 5.实际得到的X个周期内的各期值
    X_Y_every_yuce = every_T[start_X_T:]                                   #把历史数据移除只要预测出来的数据
    return X_Y_every_yuce                                                  #返回这个预测值列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

那么我只需要调用几次这个函数，就可以得到想要的数据预测值
这里所有的数据都是字符串，因为日期是字符串，如果需要使用浮点数据或整数数据，可以遍历重新转化数据类型（在我的极值函数中能够用上）

# 标准工作日一年250天，一个周期T=250，一般4年含有一次闰年4T/8T为完整变化，
# 所以选用7*250天的数据，预测第8个250天
# 因为7年数据长度过长在Pycharm中不便于展示，设定为2年预测1年，
# 后期深入学习可视化后会进行优化
Year = 2
#day_1 = get_line_excel(DaPan,1)[-250*Year:]                                  # 日期
open_2 = get_line_excel(DaPan,2)[-250*Year:]                                  # 开盘
end_3 = get_line_excel(DaPan,3)[-250*Year:]                                   # 收盘
max_4 = get_line_excel(DaPan,4)[-250*Year:]                                   # 最高
min_5 = get_line_excel(DaPan,5)[-250*Year:]                                   # 最低
#deal_6 = get_line_excel(DaPan,6)[-250*Year:]                                 # 成交量
#deal_7 = get_line_excel(DaPan,7)[-250*Year:]                                 # 成交额
#FFF_8 = get_line_excel(DaPan,7)[-250*Year:]                                  # 振幅
#这里用遍历附加，如果还要使用原始预测数据不容易出错
Open = open_2                                                              #原始数据+预测数据
for i in Yuce(open_2,250,1):
    Open.append(i)
END  = end_3                                                               #原始数据+预测数据
for m in Yuce(end_3,250,1):
    END.append(m)
Max  = max_4                                                               #原始数据+预测数据
for n in Yuce(max_4, 250, 1):
    Max.append(n)
Min  = min_5                                                               #原始数据+预测数据
for k in Yuce(min_5, 250, 1):
    Min.append(k)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

5.数据可视化展示

# 可视化看下趋势
import matplotlib.pyplot as plt                                           #用于制定图表
from matplotlib.font_manager import FontProperties                        #用于设定中文
font = FontProperties(fname=r"C:\windows\fonts\msyh.ttc")                 #大概是用来指定系统中的中文

# 1.折线

plt.title("大盘股指预测",fontproperties=font,fontsize=15)                 #给定图标名称并设置字号
plt.xlabel("日序数",fontproperties=font,fontsize=15)                      #给定X轴名称并设置字号
plt.ylabel("价格",fontproperties=font,fontsize=15)                        #给定Y轴名称并设置字号
# 给定坐标刻度并设置字号，both意思是横竖坐标都包括，labelsize=刻度字号，direction=刻度线朝向，width=刻度线粗细，length=刻度线长度
plt.tick_params(axis='both',labelsize=10,width=1,length=10)               #direction='in',不写时自动在外面

X = list(range(1,len(Open)+1))                                            #因为系统对应第一个Y值是0坐标，所以自设X坐标修正
plt.plot(X,Open,0,alpha=1,color='b',lw=1)                                 #（x,y）|坐标下限|透明度|颜色|粗细
plt.plot(X,END,0,alpha=1,color='y',lw=1)                                  #（x,y）|坐标下限|透明度|颜色|粗细
plt.plot(X,Max,0,alpha=1,color='r',lw=1)                                  #（x,y）|坐标下限|透明度|颜色|粗细
plt.plot(X,Min,0,alpha=1,color='g',lw=1)                                  #（x,y）|坐标下限|透明度|颜色|粗细

plt.show()                                                                #显示内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

得到下面这么个玩意?，因为数据量过大，暂时没学会可视化，将就着看下，如果需要实际操作或者看更为细致，可以把数据导出到EXcel

最后，附上整个过程的代码

URL = "http://push2his.eastmoney.com/api/qt/stock/kline/get?cb=jQuery18307260937131972509_1568895663861&secid=1.000001&ut=fa5fd1943c7b386f172d6893dbfba10b&fields1=f1%2Cf2%2Cf3%2Cf4%2Cf5&fields2=f51%2Cf52%2Cf53%2Cf54%2Cf55%2Cf56%2Cf57%2Cf58&klt=101&fqt=0&beg=19900101&end=20220101&_=1568895665541"
import re
import requests
#在单独表字典中单独读取某列为列表
def get_line_excel(biao_zidian,lie_num):                                   #读取自定义标准字典的特定列为列表的函数
    key = []                                                               #建立一个列表用来装标准字典的键，即第几行
    lie_liebiao = []                                                       #建立一个列表用来装不同行相同列获得的值
    for a in biao_zidian.keys():                                           #遍历标准字典的键名
        key.append(a)                                                      #把键名放入键预存列表
    for key_i in key:                                                      #遍历键预存列表中的键名（遍历行）
        lie_liebiao.append(str(biao_zidian[key_i]['第'+str(lie_num)+'列']))#把指定列的值放入列值预存列表
    return lie_liebiao                                                     #返回这个值列表
#移动平滑预测函数
def Yuce(Y_,T,yece_X_T):                                                   #对周期为T的数组列表Y_预测未来X个周期的值
    Y = []                                                                 #建立一个空列表用来装格式化后的数据
    for a in Y_:                                                           #遍历数组中的数据，进行标准格式化
        a_ = float(a)                                                      #全部浮点化放给a_
        Y.append(a_)                                                       #把标准化后的数据放进预存列表

    # 1.计算一个周期变化后的连续移动求和:根据数据选取周期，日数据周期为365，周数据周期为52，月数据周期为12
    Last_T_yidong_Sum = []                                                 #建立一个列表用来存放一个周期之后的移动求和值
    for num_1 in list(range(1, len(Y) + 1 - T)):                           #移动求和值的总数量等于所有数值减去一个周期
        Sum_num = sum(Y[num_1:num_1 + T])                                  #设置好求和长度为一个周期T并求和
        Last_T_yidong_Sum.append(Sum_num)                                  #把求和结果放入预存列表

    # 2.生成移动求和的预测值
    X = list(range(1, len(Last_T_yidong_Sum) + 1))                         #因为只有一个数组，生成一个与之匹配的标准单位X
    X_pingjun = sum(X) / len(Last_T_yidong_Sum)                            #求单位X的均值
    Y_pingjun = sum(Last_T_yidong_Sum) / len(Last_T_yidong_Sum)            #求Y项的均值，即前面得出的移动求和值的均值
    Sum_1 = []                                                             # 放Xi*Yi
    Sum_2 = []                                                             # 放Xi*Xi
    for n in list(range(0, len(Last_T_yidong_Sum))):                       #遍历一个和移动求和值数组等位的序数表
        sum_1 = X[n] * Last_T_yidong_Sum[n]                                #Xi*Yi
        Sum_1.append(sum_1)                                                #对Xi*Yi求合计
        sum_2 = X[n] * X[n]                                                #Xi*Xi
        Sum_2.append(sum_2)                                                #对Xi*Xi求合计
    if (sum(Sum_2) - len(Last_T_yidong_Sum) * X_pingjun * X_pingjun) ==0:
        b = 0                                                              #剔除被除数为零的情况，被除数为零代表是一条水平线
    else:                                                                  #被除数不为零时，按照回归方程公式计算系数b
        b = (sum(Sum_1) - len(Last_T_yidong_Sum) * X_pingjun * Y_pingjun) / (sum(Sum_2) - len(Last_T_yidong_Sum) * X_pingjun * X_pingjun)
    a = Y_pingjun - b * X_pingjun                                          #计算系数a
    Yuce = list(range(len(Last_T_yidong_Sum) + 1, len(Last_T_yidong_Sum) + yece_X_T* T + 1))#生成用于预测的X数组
    X_Y_yece_sum = []                                                      #建立个列表用来放移动合计的预测值
    for yuce_X_num in Yuce:                                                #遍历需要预测Y值的X数组
        Y_yuce = b * yuce_X_num + a                                        #按照回归系数进行预测
        X_Y_yece_sum.append(Y_yuce)                                        #把得到的预测值放入预存列表

    # 3.拼接移动做差
    every_T = Y[T:]                                                        #先把原始数据中一个周期时间点后的数据放到每期中
    start_X_T = int(len(Y[T:]))                                            #计算原始数据砍去第一个周期后的剩余长度
    for sum_y in X_Y_yece_sum:                                             #遍历移动求和的预测值
        every_T.append(sum_y)                                              #把移动求和的预测值添加到每期数据后方便做差方便向前做减
    for Y_i in list(range(start_X_T, start_X_T + len(X_Y_yece_sum))):      #从历史长度之后开始到最后一个位置为止
        every_T[Y_i] = every_T[Y_i] - sum(every_T[Y_i - T + 1:Y_i])        #减去前面T-1位的合计值（减去前面T-1项的求和）

    # 5.实际得到的X个周期内的各期值
    X_Y_every_yuce = every_T[start_X_T:]                                   #把历史数据移除只要预测出来的数据
    return X_Y_every_yuce                                                  #返回这个预测值列表


#1.get请求
shuju = requests.get(URL)                                                  #用requests模块请求网页
print(shuju)                                                               #得到请求状态码检查是否正确请求成功
#print(shuju.content.decode('utf-8'))                                      #返回字节流数据  自己解码，避免乱码
#print(shuju.url)                                                          #查看完整url地址，自动帮忙编码
#print(shuju.encoding)                                                     # 查看响应头部字符编码
#print(shuju.text)                                                         #返回unicode格式的数据 有中文，已经解码 返回字符串
#print(shuju.content)                                                      #返回字节流数据  无中文，编码字节

#整理得到的数据
liebiao_1= re.split(r'\[',shuju.content.decode('utf-8'))[-1]               #把字符串按方括号[切割取后面部分
liebiao_2 = re.split(r']',liebiao_1)[0]                                    #把字符串按方括号]切割取前面部分
liebiao_3 = re.split(r'","|"',liebiao_2)                                   #把字符串按引号和逗号切割
liebiao = []                                                               #建立一个空列表
for x in liebiao_3:                                                        #遍历原先切割字符串等得到的列表
    if x != '':                                                            #剔除空集
        liebiao.append(x)                                                  #放回空列表
#print(liebiao)
DaPan = {}                                                                 #建立个标准字典放数据
for i in range(0,len(liebiao)):                                            #遍历数据的行数
    DaPan['第'+str(i+1)+'行'] = {}                                         #生成行字典
    i_biao = re.split(r',',liebiao[i])                                     #对数据按逗号再切割
    for k in range(0,len(i_biao)):                                         #遍历切割好的数据到行列表下的列键
        DaPan['第' + str(i + 1) + '行']['第' + str(k + 1) + '列'] = float(i_biao[k])

#标准工作日一年250天，一个周期T=250，一般4年含有一次闰年4T/8T为完整变化，所以选用7*250天的数据，预测第8个250天
Year = 2
#day_1 = get_line_excel(DaPan,1)[-250*Year:]                                  # 日期
open_2 = get_line_excel(DaPan,2)[-250*Year:]                                  # 开盘
end_3 = get_line_excel(DaPan,3)[-250*Year:]                                   # 收盘
max_4 = get_line_excel(DaPan,4)[-250*Year:]                                   # 最高
min_5 = get_line_excel(DaPan,5)[-250*Year:]                                   # 最低
#deal_6 = get_line_excel(DaPan,6)[-250*Year:]                                 # 成交量
#deal_7 = get_line_excel(DaPan,7)[-250*Year:]                                 # 成交额
#FFF_8 = get_line_excel(DaPan,7)[-250*Year:]                                  # 振幅

Open = open_2                                                              #原始数据+预测数据
for i in Yuce(open_2,250,1):
    Open.append(i)

END  = end_3                                                               #原始数据+预测数据
for m in Yuce(end_3,250,1):
    END.append(m)

Max  = max_4                                                               #原始数据+预测数据
for n in Yuce(max_4, 250, 1):
    Max.append(n)

Min  = min_5                                                               #原始数据+预测数据
for k in Yuce(min_5, 250, 1):
    Min.append(k)


#可视化看下趋势
import matplotlib.pyplot as plt                                           #用于制定图表
from matplotlib.font_manager import FontProperties                        #用于设定中文
font = FontProperties(fname=r"C:\windows\fonts\msyh.ttc")                 #大概是用来指定系统中的中文

#1.折线

plt.title("大盘股指预测",fontproperties=font,fontsize=15)                 #给定图标名称并设置字号
plt.xlabel("日序数",fontproperties=font,fontsize=15)                      #给定X轴名称并设置字号
plt.ylabel("价格",fontproperties=font,fontsize=15)                        #给定Y轴名称并设置字号
#给定坐标刻度并设置字号，both意思是横竖坐标都包括，labelsize=刻度字号，direction=刻度线朝向，width=刻度线粗细，length=刻度线长度
plt.tick_params(axis='both',labelsize=10,width=1,length=10)               #direction='in',不写时自动在外面

X = list(range(1,len(Open)+1))                                            #因为系统对应第一个Y值是0坐标，所以自设X坐标修正
plt.plot(X,Open,0,alpha=1,color='b',lw=1)                                 #（x,y）|坐标下限|透明度|颜色|粗细
plt.plot(X,END,0,alpha=1,color='y',lw=1)                                  #（x,y）|坐标下限|透明度|颜色|粗细
plt.plot(X,Max,0,alpha=1,color='r',lw=1)                                  #（x,y）|坐标下限|透明度|颜色|粗细
plt.plot(X,Min,0,alpha=1,color='g',lw=1)                                  #（x,y）|坐标下限|透明度|颜色|粗细

plt.show()                                                                #显示内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

如果需要极值线做通道线的，可以将数据浮点化后，再使用这两个函数

def plt_Max(liebiao):
    Maxbox_num = []
    for i in range(0, len(liebiao)):
        if i == 0:
            if liebiao[i] > liebiao[i + 1]:
                Maxbox_num.append(i + 1)
        else:
            if i == len(liebiao) - 1:
                if liebiao[i] > liebiao[i - 1]:
                    Maxbox_num.append(i + 1)
            else:
                if liebiao[i] > liebiao[i - 1]:
                    if liebiao[i] > liebiao[i + 1]:
                        Maxbox_num.append(i + 1)
    x_1 = Maxbox_num
    y_1 = []
    for i in x_1:
        y_1.append(x_1[i-1])
    import matplotlib.pyplot as plt  # 用于制定图表
    from matplotlib.font_manager import FontProperties  # 用于设定中文
    font = FontProperties(fname=r"C:\windows\fonts\msyh.ttc")  # 大概是用来指定系统中的中文
    plt.plot(x_1, y_1, 0, alpha=1, color='g', lw=2)  # （x,y）|坐标下限|透明度|颜色|粗细
def plt_Min(liebiao):
    Minbox_num = []
    for i in range(0, len(liebiao)):
        if i == 0:
            if liebiao[i] < liebiao[i + 1]:
                Minbox_num.append(i + 1)
        else:
            if i == len(liebiao) - 1:
                if liebiao[i] < liebiao[i - 1]:
                    Minbox_num.append(i + 1)
            else:
                if liebiao[i] < liebiao[i - 1]:
                    if liebiao[i] < liebiao[i + 1]:
                        Minbox_num.append(i + 1)
    x_1 = Minbox_num
    y_1 = []
    for i in x_1:
        y_1.append(x_1[i - 1])
    import matplotlib.pyplot as plt  # 用于制定图表
    from matplotlib.font_manager import FontProperties  # 用于设定中文
    font = FontProperties(fname=r"C:\windows\fonts\msyh.ttc")  # 大概是用来指定系统中的中文
    plt.plot(x_1, y_1, 0, alpha=1, color='g', lw=2)  # （x,y）|坐标下限|透明度|颜色|粗细
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44