python数据分析与量化交易

芳香千里 發表於 2019-5-8 21:20:00

<h1>第一章-学习之前的认知</h1>
影响股价的因素
<div class="cnblogs_code">
<pre>1、公司自身因素
2、心理因素
3、行业因素
4、经济因素
5、市场因素
6、政治因素</pre>
</div>
金融量化投资
<div class="cnblogs_code">
<pre>量化投资的优势
1、避免主观情绪，人性弱点和认知偏差，选择更加客观
2、能同时包括多角度的观察和多层次的模型
3、及时跟踪市场变化，不断发现新的统计模型，寻找交易机会
4、在决定投资策略后，能通过回测验证其效果 量化策略 　　通过一套固定的逻辑来分析、判断和决策，自动地进行股票交易 策略的周期 　　实现想法、学习知识 　　实现策略：python 　　检验策略：回测、模拟交易 　　实盘交易 　　优化策略，放弃策略</pre>
</div>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420112514053-1498115908.png" alt="">
<h1>第二章-科学计算基础包---numpy</h1>
<h2>量化投资和python</h2>
为什么选择python呢?
<div class="cnblogs_code">
<pre>其他选择：excel、SAS/SPSS（统计软件，无编程）、R（功能太单一，制作数据分析）

量化投资实际上就是分析数据从而做出决策的过程
python数据处理相关模块
1、NumPy：数组批量计算
2、pandas：灵活的表计算
3、Matplotlib：数据可视化</pre>
</div>
怎么使用python进行量化投资
<div class="cnblogs_code">
<pre>自己编写
NumPy + pandas + Matplotlib....
在线平台
聚宽、优矿、米筐、Quantopian....
开源框架
RQAlpha、QUANTAXIS....</pre>
</div>
<h2>IPython的使用</h2>
<div class="cnblogs_code">
<pre>pip3 install ipthon 也可以直接安装anacoda ，集成了ipython、NumPy pandas Matplotlib 等许多python的常用模块和框架</pre>
</div>
与python解释器的使用方法一致
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420120816242-691587597.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420121212369-1745167126.png" alt="">
TAB键自动完成
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420121028738-1121365605.png" alt="">
？内省、查看具体信息
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420121414376-773614514.png" alt="">
？进行模糊匹配，命名空间搜索
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420121444117-2123049695.png" alt="">
！执行系统命令
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420121613677-2116605518.png" alt="">
某些命令不用加也能执行
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420121637100-1059781215.png" alt="">
？？两个问号
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420122213586-860325665.png" alt="">
快捷键
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420122339244-1477808928.png" alt="">
<h2>IPython的魔术命令</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420153100115-910295506.png" alt="">
%timeit 很费事，他要跑很多次
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420153233895-1965868288.png" alt="">
%paste 执行剪切板中的python代码
%pdb 在异常发生后自动进入调试模式，使用on
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420153901167-830558575.png" alt="">
然后就可以使用pdb相关的命令，进行调试状态
p命令最常用，打印的意思
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420153719130-1250342781.png" alt="">
%魔术命令
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420153317536-1565366845.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420154851540-1012543174.png" alt="">
命令的历史可以使用上下方向键，或者%hist查看命令历史
_ 表示上一次的输出
__ 表示上两个命令
_48 第多少的结果
_i48 第多少行的结果的字符串形式
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420154804202-1653458605.png" alt="">
 %bookmark 目录标签系统
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420160101764-1140894902.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420160255838-745274632.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420160405178-1798111661.png" alt="">
<h2>IPython Notebook-Jupyter的初识</h2>
安装jupyter
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420161550339-1817726183.png" alt="">
使用notebook
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420161752389-669464229.png" alt="">
进入了jupyter的web界面
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420161949469-2028773267.png" alt="">
创建新的notebook
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420164036129-628953701.png" alt="">
出现一个小问题：编写的代码不能运行且前面的提示符In[*]
查看命令行，出现错误提示
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420164210841-780571291.png" alt="">
将软件降级安装后，解决问题
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420164241956-1392173486.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420164309473-188441530.png" alt="">
可以用notebook写博客，支持makedown，而且他可以将页面直接输出成很多文本形式
<h2>正戏-Numpy模块</h2>
<h3>Numpy简介</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420170513434-117772064.png" alt="">
<h3>实例展示为什么要使用numpy</h3>
例子：已知若干家跨国公司的市值，将其换算成人民币
普通的函数方法
<div class="cnblogs_code">
<pre>1、将公司市值存储成列表或者其他格式
2、创建变量，存储汇率
2、遍历列表
3、做乘法运算，放入新的列表</pre>
</div>
用numpy
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420171654665-590860181.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420171721644-631880804.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420171735086-966882553.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420171752030-1994601162.png" alt="">
例子2：已知每件商品的价格和每件商品的数量，计算总金额
还是用a作为价格，再创建一个数组作为每件商品的数量
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420172143809-1027400687.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420172252475-991213893.png" alt="">
计算每件商品的价格
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420172309629-848059958.png" alt="">
计算总金额
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420172333789-1367308775.png" alt="">
<h3>ndarray-多维数组对象</h3>
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420172615547-1340667673.png" alt="">
<h3>ndarray-常用属性</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420172720142-493005091.png" alt="">
<div class="cnblogs_code">
<pre>In [26]: a.ndim
Out[26]: 1
In [27]: a.size
Out[27]: 50
In [28]: a.shape
Out[28]: (50,)
-----------------------------
In [30]: b = np.array([[1,2,3,],[4,5,6]])
In [31]: b.ndim
Out[31]: 2
In [32]: b.size
Out[32]: 6
In [33]: b.shape
Out[33]: (2, 3)
-----------------------------
三维-第三个维度相当于笔记本的每一页，翻个页就到另一面
In [35]: c = np.array([[[1,2,3,],[4,5,6]],[[1,2,3],[1,2,3]]])

In [36]: c
Out[36]:
array([[[1, 2, 3],
 [4, 5, 6]],

 [[1, 2, 3],
 [1, 2, 3]]])
In [37]: c.shape
Out[37]: (2, 2, 3)
------------------------------------
数组的转置
In [39]: c = c.T

In [40]: c
Out[40]:
array([[[1, 1],
 [4, 1]],

 [[2, 2],
 [5, 2]],

 [[3, 3],
 [6, 3]]])

In [41]: c = c.T

In [42]: c
Out[42]:
array([[[1, 2, 3],
 [4, 5, 6]],

 [[1, 2, 3],
 [1, 2, 3]]])</pre>
</div>
<h3>ndarray-数据类型</h3>
查看数据类型
<div class="cnblogs_code">
<pre>In [24]: a.dtype
Out[24]: dtype('float64')</pre>
</div>
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420172958751-1274327114.png" alt="">
我们使用的巨大部分都是数字类型，它本身就是用来做计算的
64位数的长度是多少（2**63-1）
<div class="cnblogs_code">
<pre>In [25]: 2**64-1
Out[25]: 18446744073709551615</pre>
</div>
<h2>numpy-array的创建</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420174513917-1979439202.png" alt="">
<div class="cnblogs_code">
<pre>In : # 可以这样创建一个10位全是0的数组
In : import numpy as np
In [3]: a = np.array(*10)
In [4]: a
Out[4]: array()

In [5]: # 也可以用zeros创建
In : b = np.zeros(10)
In [7]: b
Out[7]: array()

In [8]: # 可以看见都是0.，说明他是一个浮点数，来看一下类型
In : b.dtype
Out[9]: dtype('float64')

In [10]: # 创建的时候指定类型，不使用默认的，直接用int
In : c = np.zeros(10,dtype='int')
In [12]: c
Out[12]: array()
In [13]: c.dtype
Out[13]: dtype('int32')

In [14]: # 创建全是1的数组
In : d = np.ones(10)
In [16]: d
Out[16]: array()

In [17]: # 看一下empty的用法，创建空数组，里面放的都是随机数
In : e = np.empty(50)
In [19]: e
Out[19]:
array([1.23004319e-311, 1.23004150e-311, 2.95806213e-311, 1.26927730e-277,
 5.54041819e+228, 2.84855906e-311, 5.97288716e-299, 3.28487474e-311,
 9.43293441e-314, 2.26784710e-308, 1.23004306e-311, 1.23002517e-311,
 3.38460664e+125, 6.69053866e+151, 6.56693077e-085, 1.03564308e-308,
 1.33360293e+241, 1.71632673e+243, 5.96115807e+228, 1.71011791e+214,
 5.67517369e-311, 1.00562508e-248, 2.85308965e-313, 2.14793507e-308,
 1.38760675e+219, 2.92135768e+209, 2.21211602e+214, 2.28723653e-308,
 6.96983359e+228, 1.33360298e+241, 2.11280666e+161, 1.29883065e+219,
 1.11074825e-310, 1.46972270e-200, 4.97508544e-313, 4.65203811e+151,
 4.66820502e+180, 5.61168418e-313, 3.81674046e-308, 1.33360303e+241,
 1.54523733e-310, 5.03961303e-266, 3.99046880e-008, 2.08868046e-310,
 2.53185169e-212, 7.44726967e-251, 1.39069238e-309, 2.75926410e-306,
 4.90398331e-307, 5.23951796e+202])
In [20]: #这些随机值是，之前内存的残存值。这个empty有什么用呢?
In : #为了之后给里面赋值，因为它相对于zeros和ones创建的时候少了1个步骤，会更快一点

In [22]: # arange可以指定步长为小数，pyton中是不可以的
In : f = np.arange(1,10,0.3)
In [25]: f
Out[25]:
array([1. , 1.3, 1.6, 1.9, 2.2, 2.5, 2.8, 3.1, 3.4, 3.7, 4. , 4.3, 4.6,
 4.9, 5.2, 5.5, 5.8, 6.1, 6.4, 6.7, 7. , 7.3, 7.6, 7.9, 8.2, 8.5,
 8.8, 9.1, 9.4, 9.7])

In [26]: # linspace线性空间，和arange非常相，但是完全不一样，把指定的范围数字分成间隔相同的份数，最后一个参数是数组的长度，即份数
In : k = np.linspace(0,5,10)或者是np.linespace(0,5,num=10)
In [32]: k#并且linspace不像arange不包含最后一个数，它是包含最后一个数的，可以在最后看见5
Out[32]:
array([0. , 0.55555556, 1.11111111, 1.66666667, 2.22222222,
 2.77777778, 3.33333333, 3.88888889, 4.44444444, 5. ])
In [27]: g = np.linspace(1,100,100)
In [28]: g
Out[28]:
array([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.])

In [33]: #eye 生成单位矩阵，对角线上都是1，不做线性代数，基本不会遇到
In : w = np.eye(5)
In [38]: w
Out[38]:
array([[1., 0., 0., 0., 0.],
 ,
 ,
 ,
 ])</pre>
</div>
<h2>ndarray-批量运算</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420224414458-1050855440.png" alt="">
比较运算最后得到的是布尔值
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420225044579-822022373.png" alt="">
如何快速生成一个二维数组
<div class="cnblogs_code">
<pre>In : np.arange(15).reshape((3,5))
Out[39]:
array([[ 0,1,2,3,4],
 [ 5,6,7,8,9],
 [10, 11, 12, 13, 14]])</pre>
</div>
<h2>ndarray-索引</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420225354030-130364741.png" alt="">
<div class="cnblogs_code">
<pre>array([[ 0,1,2,3,4],
 [ 5,6,7,8,9],
 [10, 11, 12, 13, 14]])

In [40]: a = np.arange(15).reshape((3,5))

In [41]: a
Out[41]: 12</pre>
</div>
<h2>adarray-切片</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420230122856-310270608.png" alt="">
 
也是前包后不包
<div class="cnblogs_code">
<pre>In : f
Out[46]:
array([1. , 1.3, 1.6, 1.9, 2.2, 2.5, 2.8, 3.1, 3.4, 3.7, 4. , 4.3, 4.6,
 4.9, 5.2, 5.5, 5.8, 6.1, 6.4, 6.7, 7. , 7.3, 7.6, 7.9, 8.2, 8.5,
 8.8, 9.1, 9.4, 9.7])

In [48]: f
Out[48]: array()</pre>
</div>
 但是数组切片，为了省空间，在切片的时候只是浅拷贝
 如果要不影响原数组，切片的时候使用copy
<div class="cnblogs_code">
<pre>In : b = f

In [56]: b
Out[56]: array()

In [57]: b = 5

In [58]: b
Out[58]: array()

In [59]: f
Out[59]:
array([5. , 1.3, 1.6, 1.9, 2.2, 2.5, 2.8, 3.1, 3.4, 3.7, 4. , 4.3, 4.6,
 4.9, 5.2, 5.5, 5.8, 6.1, 6.4, 6.7, 7. , 7.3, 7.6, 7.9, 8.2, 8.5,
 8.8, 9.1, 9.4, 9.7]) 使用copy b = f.copy（）</pre>
</div>
多行切片
<div class="cnblogs_code">
<pre>In : a
Out[49]:
array([[ 0,1,2,3,4],
 [ 5,6,7,8,9],
 [10, 11, 12, 13, 14]])
In [50]: # 多行切片，可以看做是[切行，切列]
In : a
Out[54]:
array([,
 [5, 6]])</pre>
</div>
<h2>ndarray-布尔型索引</h2>
需求：选出列表中大于5的数
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420232313402-1421126718.png" alt="">
<div class="cnblogs_code">
<pre>In : import random
# 用列表的filter方法
In : a =
In [62]: a
Out[62]:
In [63]: list(filter(lambda x:x>5, a))
Out[63]:
# 用数组的布尔值索引
In : a = np.array(a)
In [65]: a
Out[65]: array([ 6,8,6,7,6,8,6, 10])

In [66]: # 布尔型索引的原理
In : # 第一步 a>5
In : a>5
Out[68]:
array([False, False, False,True, False,True,True,True, False,
 False,True,True, False,True, False, False, False,True,
 False, False])

In [69]: # 第二步，返回每一位置为ture的位置的值
In : b = np.array()
In [71]: c = np.array()
In [72]: b
Out[72]: array()</pre>
</div>
 需求2：选出数组中大于5的偶数
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420232647991-2134583192.png" alt="">
题外：and 和 & 有什么区别？
<h2>ndarray-花式索引</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420233317516-371122778.png" alt="">
注意：多维数组中，花式索引和花式索引不能出现在，逗号的两边
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420235645616-1900539405.png" alt="">
<h2>Numpy-通用函数</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190420235808125-934984373.png" alt="">
<h3>abs-批量求绝对值</h3>
<div class="cnblogs_code">
<pre>In : a = np.arange(-5,5)
In [3]: a
Out[3]: array([-5, -4, -3, -2, -1,0,1,2,3,4])
# 直接用abs也可以
In : abs(a)
Out[4]: array()
# 严谨的用法是np.abs
In : np.abs(a)
Out[5]: array()</pre>
</div>
<h3>aqrt-开方</h3>
<div class="cnblogs_code">
<pre># 直接使用会报错，没有这个sqrt，找不到
In : sqrt(a)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-7-55c08d4e5fa4> in <module>()
----> 1 sqrt(a)

NameError: name 'sqrt' is not defined
# math模块下有sqrt
In : import math
# 报错，sqrt一次只能处理一个值
In : math.sqrt(a)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-11-c85d302be686> in <module>()
----> 1 math.sqrt(a)

TypeError: only size-1 arrays can be converted to Python scalars
# 使用np.sqrt ，因为负数不能求开方
In : np.sqrt(a)
F:\Python36\Scripts\ipython3:1: RuntimeWarning: invalid value encountered in sqrt
Out[10]:
array([ nan, nan, nan, nan, nan,
 0. , 1. , 1.41421356, 1.73205081, 2. ])</pre>
</div>
<h3>把一个小数变成整数-取整和保留小数位</h3>
<div class="cnblogs_code">
<pre>In : a = 1.6
# 这种取整，叫做向0取整
In : int(a)
Out[13]: 1
# 这种叫做四舍五入
In : round(a)
Out[14]: 2
# 向上取整-ceil
In : math.ceil(a)
Out[15]: 2
# 向下取整-floor
In : math.floor(a)
Out[16]: 1
# 使用np
In : a
Out[18]: array([-5.5, -4.5, -3.5, -2.5, -1.5, -0.5,0.5,1.5,2.5,3.5,4.5])
# 向下取整
In : np.floor(a)
Out[19]: array([-6., -5., -4., -3., -2., -1.,0.,1.,2.,3.,4.])
# 向上取整
In : np.ceil(a)
Out[22]: array([-5., -4., -3., -2., -1., -0.,1.,2.,3.,4.,5.])
# 四舍五入
In : np.round(a)
Out[23]: array([-6., -4., -4., -2., -2., -0.,0.,2.,2.,4.,4.])
# rint和round是一样的
In : np.rint(a)
Out[20]: array([-6., -4., -4., -2., -2., -0.,0.,2.,2.,4.,4.])
# 向0取整
In : np.trunc(a)
Out[21]: array([-5., -4., -3., -2., -1., -0.,0.,1.,2.,3.,4.])</pre>
</div>
注：这里的round用的是"四舍六入五成双，奇进偶不进"的方法。对于大量的计算而言，比普通的四舍五入要更科学
<h3>modf-把小数和整数部分分开获取</h3>
<div class="cnblogs_code">
<pre>In : np.modf(a)
Out[26]:
(array([-0.5, -0.5, -0.5, -0.5, -0.5, -0.5,0.5,0.5,0.5,0.5,0.5]),
array([-5., -4., -3., -2., -1., -0.,0.,1.,2.,3.,4.]))

In [27]: x,y = _

In [28]: x
Out[28]: array([-0.5, -0.5, -0.5, -0.5, -0.5, -0.5,0.5,0.5,0.5,0.5,0.5])

In [29]: y
Out[29]: array([-5., -4., -3., -2., -1., -0.,0.,1.,2.,3.,4.])</pre>
</div>
<h3>isnan和isinf-浮点数特殊值的判定</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421114539048-1480530704.png" alt="">
<div class="cnblogs_code">
<pre>In : a = np.ones(5)

In [32]: a
Out[32]: array()

In [33]: a = 0

In [34]: a
Out[34]: array()

In [36]: b = a/a
F:\Python36\Scripts\ipython3:1: RuntimeWarning: invalid value encountered in true_divide

In [37]: a
Out[37]: array()

In [38]: b
Out[38]: array([ 1., nan,1.,1.,1.])

In [39]: 1 in b
Out[39]: True
# 这样判断对nan是无用的
In : np.nan in b
Out[40]: False
# isnan的作用
In : np.isnan(b)
Out[41]: array()</pre>
</div>
<h4> isnan用来取值</h4>
<div class="cnblogs_code">
<pre>In : b
Out[42]: array()

In [43]: b[~np.isnan(b)]
Out[43]: array()</pre>
</div>
<h4>inf-比任何数都大</h4>
<div class="cnblogs_code">
<pre>In : np.inf > 1000000000000000000000000000000
Out[44]: True

In [45]: float('inf') > 1000000000000000000000000000000000
Out[45]: True</pre>
</div>
<h4>inf和isinf的使用</h4>
<div class="cnblogs_code">
<pre>In : a = np.array()
In [47]: b = np.array()
In [48]: a/b
F:\Python36\Scripts\ipython3:1: RuntimeWarning: divide by zero encountered in true_divide
Out[48]: array([ 1., inf,1., inf,1.])
# 和np.nan不一样，是相等的
In : np.inf == np.inf
Out[49]: True

In [50]: c = a/b
F:\Python36\Scripts\ipython3:1: RuntimeWarning: divide by zero encountered in true_divide
In [51]: c
Out[51]: array([ 1., inf,1., inf,1.])
# 取出不是inf的值
In : c
Out[52]: array()
# 取出不是inf的值，用~
In : c[~np.isinf(c)]
Out[53]: array()</pre>
</div>
<h3>二元函数</h3>
<div class="cnblogs_code">
<pre>add 加
substract 减
multiply 乘
divide 除
power 乘方
mod 取模</pre>
</div>
<h4>maximum-对两个数组的每一个都取一个最大值</h4>
<div class="cnblogs_code">
<pre>In : a
Out[58]: array()

In [59]: b
Out[59]: array()

In [60]: np.maximum(a,b)
Out[60]: array()</pre>
</div>
mininum-和maxinum一样的用法，只是对比取最小的值
<h3>更改数组形状-reshape和resize和ravel</h3>
<div class="cnblogs_code">
<pre>a = np.random.random((3,2))
a

# reshape 并不改变原始数组
a.reshape(2, 3)
array([[0.91122299, 0.93234796, 0.86025081],
 [0.33770259, 0.13627525, 0.78460434]])

#查看 a
array([,
 [0.86025081, 0.33770259],
 [0.13627525, 0.78460434]])

# resize 会改变原始数组
a.resize(2, 3)
# 查看 a
array([,
 [0.33770259, 0.13627525, 0.78460434]]) # 展平数组-数组变成一行 a.ravel()</pre>
<pre>array([0.91122299, 0.93234796, 0.86025081, 0.33770259, 0.13627525,
 0.78460434])</pre>
</div>
<h3>拼合数组-vstack和hstack</h3>
<div class="cnblogs_code">
<pre>a = np.random.randint(10,size=(3,3))
b = np.random.randint(10,size=(3,3))
a,b
out:
(array([[1, 4, 7],
 [5, 6, 6],
 [6, 4, 5]]),
array([[8, 3, 1],
 [1, 5, 8],
 [5, 0, 6]]))
# 垂直拼合
np.vstack((a,b))
out：
array([[1, 4, 7],
 [5, 6, 6],
 [6, 4, 5],
 [8, 3, 1],
 [1, 5, 8],
 [5, 0, 6]])
# 水平拼合
np.hstack((a,b))
array([[1, 4, 7, 8, 3, 1],
 [5, 6, 6, 1, 5, 8],
 [6, 4, 5, 5, 0, 6]])</pre>
</div>
<h3>分割数组-vsplit和hsplit</h3>
<div class="cnblogs_code">
<pre># 沿横轴分割数组
np.hsplit(a,3)
,
 [5],
 [6]]),
array([[4],
 [6],
 [4]]),
array([[7],
 [6],
 [5]])]

# 沿纵轴分割数组
np.vsplit(a,3)
]), array([]), array([])]</pre>
</div>
<h3>数组排序</h3>
<div class="cnblogs_code">
<pre># 生成示例数组
a = np.array((, , ))
a
array([[1, 4, 3],
 [6, 2, 9],
 [4, 7, 2]])

#返回每列最大值
np.max(a, axis=0)
array([6, 7, 9])

# 返回每行最小值
np.min(a,axis=1)
array([1, 2, 2])

# 返回每列最大值索引
np.argmax(a,axis=0)
array([1, 2, 1])

# 返回每行最小值索引
np.argmin(a,axis=1)
array()</pre>
</div>
 
<h2>numpy-统计方法和随机数生成</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421121525524-902070626.png" alt="">
<div class="cnblogs_code">
<pre># 统计中位数
np.median(a, axis=0)

# 统计各行的算术平均值
np.mean(a, axis=1)

# 统计各列的加权平均值
np.average(a, axis=0)

# 统计各行的方差
np.var(a, axis=1)

# 统计数组各列的标准偏差
np.std(a, axis=0)</pre>
</div>
 
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421121558305-1556545535.png" alt="">
<h3>数学时间</h3>
<div class="cnblogs_code">
<pre>1 2 3 4 5
平均数： 3
方差：每个数-3的值的平方，加在一起，再除以数字的个数</pre>
</div>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421122024548-1558395989.png" alt="">
<div class="cnblogs_code">
<pre>标准差:对方差开平方根</pre>
</div>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421122255356-1114018891.png" alt="">
方差用来计算数组内数值的范围
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421122527761-1515266837.png" alt="">
平均数加减两倍方差的结果活落在90%的范围上
矩阵乘法
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422145348786-1596795075.png" alt="">
<h4>矩阵乘法运算（注意与a*b的区别）</h4>
<div class="cnblogs_code">
<pre>A = np.array([,]) B = np.array([,]) np.dot(A,B)
array([[19, 22],
 [43, 50]])</pre>
</div>
<h4>数学函数</h4>
<div class="cnblogs_code">
<pre># 求三角函数
a = np.array()

np.sin(a)
array([-0.54402111,0.91294525, -0.98803162,0.74511316, -0.26237485])

# 以自然对数为底数的指数函数
np.exp(a)
array([2.20264658e+04, 4.85165195e+08, 1.06864746e+13, 2.35385267e+17,
 5.18470553e+21])

# 方根的运算-开平方
np.sqrt(a)
array([3.16227766, 4.47213595, 5.47722558, 6.32455532, 7.07106781])

# 方根的运算-求立方
np.power(a,3)
array([1000, 8000,27000,64000, 125000])</pre>
</div>
<h3>随机数</h3>
<pre></pre>
<div class="cnblogs_code">
<pre># 创建二维随机数组
np.random.rand(2, 3)
array([[0.46181641, 0.06400509, 0.93763711],
 [0.67133387, 0.0801051 , 0.81633397]])

# 创建二维随机整数数组
np.random.randint(5, size=(2, 3))
array([[4, 2, 2],
 [4, 0, 0]])</pre>
</div>
<div class="cnblogs_code">
<pre>In : np.random.randint(0,10,10)
Out[61]: array()
# 生成多维随机数组
In : np.random.randint(0,10,(3,5)) 或者如上一个例子所示使用size参数
Out[62]:
array([[4, 5, 7, 7, 8],
 [4, 1, 5, 1, 4],
 [2, 3, 9, 6, 8]])

# 0-1之间的随机数
In : np.random.rand(10)
Out[63]:
array([0.97926997, 0.17454168, 0.52831388, 0.28070782, 0.2715298 ,
 0.2749287 , 0.44007621, 0.56472258, 0.53291951, 0.30727733])

# 指定数组中的随机数
In : np.random.choice(,10)
Out[64]: array()

In [65]: np.random.choice(,(2,3))
Out[65]:
array([[5, 2, 3],
 [3, 4, 4]])

# uniform 平均分布，出现每一个小数的概率都一样
In : np.random.uniform(2.0,4.0,10)
Out[67]:
array([3.30135597, 2.5034658 , 3.80415042, 3.58323964, 2.82819204,
 3.45701693, 2.51628589, 3.94588971, 2.46530701, 3.269412])

In [68]: np.random.uniform(2,4,10)
Out[68]:
array([3.99532675, 2.27704994, 2.44378248, 2.33492658, 3.79537452,
 2.6754694 , 3.04022564, 2.12863367, 3.27047096, 3.70261513])

In [69]: # random中所有的方法都被numpy重写过</pre>
</div>
<h3>fromfunction-依据自定义函数创建数组</h3>
<div class="cnblogs_code">
<pre>>>> def f(x,y):
... return 10*x+y
...
>>> b = fromfunction(f,(5,4),dtype=int)
>>> b
array([[ 0,1,2,3],
 [10, 11, 12, 13],
 [20, 21, 22, 23],
 [30, 31, 32, 33],
 [40, 41, 42, 43]])

#
np.fromfunction(lambda i,j:i+j,(3,3))
array([,
 [1., 2., 3.],
 [2., 3., 4.]])
# 生成的规则就是数组中每一个元素所在位置的索引值作为x和y的值</pre>
</div>
 
还有很多高级功能没有说，numpy相对于pandas来说是比较基础的包
接下来请领教pandas
<h1>第三章-数据分析核心包---pandas</h1>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421124530048-1151066614.png" alt="">
<h2>series-一维数据对象</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421124714542-634469400.png" alt="">
<div class="cnblogs_code">
<pre>In : import pandas as pd

In [73]: pd.Series()
Out[73]:
0 2
1 3
2 4
3 5
dtype: int64

In [74]: pd.Series(,index=['a','b','c','d'])
Out[74]:
a 2
b 3
c 4
d 5
dtype: int64

In [75]: # 所以说serries更像是列表和字典的结合体

In [76]: pd.Series(np.arange(5))
Out[76]:
0 0
1 1
2 2
3 3
4 4
dtype: int32

In [77]: # 在制定了索引之后，用原来的下标还是能访问
In :sr = pd.Series(,index=['a','b','c','d'])

In [83]: sr
Out[83]:
a 2
b 3
c 4
d 5
dtype: int64

In [84]: sr
Out[84]: 4
# 所以他有两种索引方式，一种是下标，一种是标签，像字典的key</pre>
</div>
<h2>Series-使用特性</h2>
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421144515623-1170452106.png" alt="">
<div class="cnblogs_code">
<pre># 字典创建Series
In : sr = pd.Series({'a':1,'b':2})
In [86]: sr
Out[86]:
a 1
b 2
# 键索引
dtype: int64
In [88]: sr['a']
Out[88]: 1
# in的用法
In : 'a' in sr
Out[89]: True
# 通过字典创建，也能使用下标索引
In : sr
Out[87]: 2
# 和字典有一点不一样，写for循环的时候，for字典循环的是key，而Series遍历的是值
In : for i in sr:
...: print(i)
...:
1
2

# 获取索引
In : sr.index
Out[91]: Index(['a', 'b'], dtype='object')
In [93]: sr.index
Out[93]: 'a'
# 获取值
In : sr.values
Out[94]: array(, dtype=int64)

In [95]: sr.values
Out[95]: 1
# 花式索引
In : sr = pd.Series(a,index=['a','b','c','d','e'])

In [102]: sr
Out[102]:
a 3
b 4
c 5
d 6
e 7
dtype: int32

In [103]: sr[['a','e','c']]
Out[103]:
a 3
e 7
c 5
dtype: int32
# 标签索引来切片，它是前包后也包的
In : sr['b':'d']
Out[106]:
b 4
c 5
d 6
dtype: int32</pre>
</div>
<h3>Series-整数索引问题</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421150402669-749309298.png" alt="">
<div class="cnblogs_code">
<pre>In : sr = pd.Series(np.arange(10))

In [108]: sr
Out[108]:
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
dtype: int32

In [111]: sr2 = sr.copy()
In [112]: sr2
Out[112]:
5 5
6 6
7 7
8 8
9 9
dtype: int32
# 问题开始了，sr2的下标索引并不是从0开始的
In : sr2
Out[113]: 5
# 因为这个时候是有歧义的，所以，如果索引是整数类型，则根据整数进行下标取值的时候，总是面相标签的</pre>
</div>
<h3>解决办法：loc和iloc</h3>
<div class="cnblogs_code">
<pre>In : sr2.loc
Out[114]: 5

In [115]: sr2.iloc[-1]
Out[115]: 9
# 因为长度只有5，所以使用sr.iloc会报错</pre>
</div>
<h2>Series-数据对齐</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421152454836-808421223.png" alt="">
 按照标签索引进行计算
<div class="cnblogs_code">
<pre>In : sr1 = pd.Series(,index=['c','a','d'])
In [118]: sr2 = pd.Series(,index=['d','c','a'])

In [119]: sr1+sr2
Out[119]:
a 33
c 32
d 45
dtype: int64</pre>
</div>
pandas中长度不一样也可以计算，并引入NaN数据作为数据缺失值
<div class="cnblogs_code">
<pre>In : sr1 = pd.Series(,index=['c','a','d'])

In [121]: sr2 = pd.Series(,index=['d','c','a','b'])

In [122]: sr1+sr2
Out[122]:
a 33.0
b NaN
c 32.0
d 45.0
dtype: float64</pre>
</div>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421153515029-600560682.png" alt="">
<div class="cnblogs_code">
<pre>In : sr1 = pd.Series(,index=['c','a','d'])

In [124]: sr2 = pd.Series(,index=['c','a','b'])

In [125]: sr1+sr2
Out[125]:
a 43.0
b NaN
c 23.0
d NaN
dtype: float64</pre>
</div>
但是有的时候，我不需要他出现NaN
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421153635382-308812488.png" alt="">
<div class="cnblogs_code">
<pre>In : sr1.add(sr2,fill_value=0)
Out[126]:
a 43.0
b 10.0
c 23.0
d 34.0
dtype: float64</pre>
</div>
Series-缺失数据和处理确实数据
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421153931786-618040992.png" alt="">
处理缺失数据有两种思路-删除和填充
判断有没有缺失数据-isnull和notnull
<div class="cnblogs_code">
<pre>In : sr.isnull()
Out[127]:
0 False
1 False
2 False
dtype: bool</pre>
</div>
删掉缺失数据的方法
<div class="cnblogs_code">
<pre># 恶意直接利用索引取值的方法
In : sr
Out[132]:
a 43.0
c 23.0
dtype: float64
# 使用dropna 删除
In : sr.dropna()
Out[134]:
a 43.0
c 23.0
dtype: float64</pre>
</div>
填充的方法
<div class="cnblogs_code">
<pre># 使用fillna填充
In : sr.fillna(0)
Out[133]:
a 43.0
b 0.0
c 23.0
d 0.0
dtype: float64</pre>
</div>
有的时候，不喜欢看见0 ，我们可以填充一个平均值
<div class="cnblogs_code">
<pre>In : sr.fillna(sr.mean())
Out[135]:
a 43.0
b 33.0
c 23.0
d 33.0
dtype: float64</pre>
</div>
pandas在计算平均值的时候，会跳过nan。如果不想跳过去，可以加一些参数
<h3>Series小结</h3>
<div class="cnblogs_code">
<pre>Series的特性-数组+字典的结合体-
整数索引的问题-loc和iloc
数据对齐-面向标签和缺失值
缺失值的处理-删除和填充
pandas的mean求平均值的特点的使用</pre>
</div>
<h2>DataFrame-二维数据对象</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421155512261-1423098807.png" alt="">
<div class="cnblogs_code">
<pre># 第一种创建范式
In : df=pd.DataFrame({'one':,'two':})

In [138]: df
Out[138]:
onetwo
0 1 4
1 2 5
2 3 6
# 第二种创建方式
In : pd.DataFrame({'one':pd.Series(,index=['a','b','c']),'two':pd.Series(,index=['a','b','c','d'])})
Out[140]:
onetwo
a1.0 4
b2.0 5
c3.0 6
dNaN 7
# 还有很多种创建的方式...</pre>
</div>
<h3>文件读写操作</h3>
vim test.csv
<div class="cnblogs_code">
<pre>a,b,c
1,2,3
4,5,6
7,8,9</pre>
</div>
读取csv文件
<div class="cnblogs_code">
<pre>In : pd.read_csv('test.csv')
Out[145]:
abc
0123
1456
2789</pre>
</div>
保存文件为csv
<div class="cnblogs_code">
<pre>In : df
Out[147]:
abc
0123
1456
2789

In [148]: df.to_csv('test2.csv')</pre>
</div>
<h2>DataFrame-常用属性</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421175036219-174650436.png" alt="">
index用来获取行索引，values获取的值是二维数组, 这是和Series一样的地方
<div class="cnblogs_code">
<pre>In : df = _140

In [157]: df
Out[157]:
onetwo
a1.0 4
b2.0 5
c3.0 6
dNaN 7

In [158]: df.index
Out[158]: Index(['a', 'b', 'c', 'd'], dtype='object')

In [159]: df.values
Out[159]:
array([[ 1.,4.],
 [ 2.,5.],
 [ 3.,6.],
 ])</pre>
</div>
转置T-把行变成列，列变成行，且一列都成了一个属性（所有的转置默认都会）
可以指定属性dtype
<div class="cnblogs_code">
<pre>In : df.T
Out[160]:
 a b c d
one1.02.03.0NaN
two4.05.06.07.0</pre>
</div>
获取列索引columns
<div class="cnblogs_code">
<pre>In : df.columns
Out[163]: Index(['one', 'two'], dtype='object')</pre>
</div>
快速统计
<div class="cnblogs_code">
<pre>In : df.describe()
Out[165]:
 one two
count3.04.000000　　个数
mean 2.05.500000　　平均数　　 
std 1.01.290994　　标准差
min 1.04.000000　　最小值
25% 1.54.750000　　25%位置的数
50% 2.05.500000　　中位数
75% 2.56.250000　　75%位置的数
max 3.07.000000　　最大数</pre>
</div>
<h2>DataFrame-索引和切片</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421180736776-1235038841.png" alt="">
<div class="cnblogs_code">
<pre># 先选列。再选行
In : df
Out[168]:
onetwo
a1.0 4
b2.0 5
c3.0 6
dNaN 7

In [169]: df['one']['a']
Out[169]: 1.0

In [170]: df['one']
Out[170]: 2.0

In [171]: df['one']
Out[171]: 1.0</pre>
</div>
建议使用loc或者iloc指定，并不建议使用双中括号
<div class="cnblogs_code">
<pre>In : df.loc['a','one']
Out[172]: 1.0

In [173]: df.loc['a',:]
Out[173]:
one 1.0
two 4.0
Name: a, dtype: float64</pre>
</div>
灵活搭配使用
<div class="cnblogs_code">
<pre>In : df.loc[['a','c'],:]
Out[174]:
onetwo
a1.0 4
c3.0 6</pre>
</div>
<h2>DataFrame-数据对齐与缺失数据</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421183117475-689914436.png" alt="">
DataFrame在使用dropna时，如果一行有一个缺失值，会将整行都删除
指定how=‘all’，删除全部是nan的行
<div class="cnblogs_code">
<pre>In : df.loc[['c','d'],'two'] = np.nan

In [178]: df
Out[178]:
onetwo
a1.04.0
b2.05.0
c3.0NaN
dNaNNaN

In [179]: df.dropna(how='all')
Out[179]:
onetwo
a1.04.0
b2.05.0
c3.0NaN
# how 默认的值是any，也就是只要有nan就都会删除</pre>
</div>
如何把有一列中有缺失值的那一列都删除？
axis参数意思是-轴，默认是0，是0的时候，指定的是行，1指定的是列
<div class="cnblogs_code">
<pre>In : df
Out[184]:
onetwo
a1.04.0
b2.05.0
c3.0NaN
d5.0NaN

In [185]: df.dropna(axis=1)
Out[185]:
one
a1.0
b2.0
c3.0
d5.0</pre>
</div>
pandas-其他常用方法
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421184528138-2135477873.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421184631253-1370829870.png" alt="">
排序中的ascending=False是倒序，by是指定排序的行（列）
当排序的列（行）有nan的时候，都默认放在了最后，不参与排序
numpy的所有通用函数都适于用pandas
<h2>pandas-时间对象处理</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421192831817-429366622.png" alt="">
 datetime中将时间字符串转化成时间对象
<div class="cnblogs_code">
<pre>In : import datetime

In [187]: datetime.datetime.strptime('2010-01-01','%Y-%m-%d')
Out[187]: datetime.datetime(2010, 1, 1, 0, 0) 记忆strptime p--parse 解析 记忆strftime f--format 格式化</pre>
</div>
但是不是所有人写时间的格式都像这样的，有一个库可以帮我们做这件事
<div class="cnblogs_code">
<pre>importdateutil

In [191]: dateutil.parser.parse('02/03/2010')
Out[191]: datetime.datetime(2010, 2, 3, 0, 0)

In [192]: dateutil.parser.parse('02-03-2010')
Out[192]: datetime.datetime(2010, 2, 3, 0, 0)

In [193]: dateutil.parser.parse('2010-JAN-10')
Out[193]: datetime.datetime(2010, 1, 10, 0, 0)</pre>
</div>
pandas中的to_datetime就是引用了这个模块，进行批量转换
<div class="cnblogs_code">
<pre>In : pd.to_datetime(['02-03-2010','2010-JAN-10'])
Out[194]: DatetimeIndex(['2010-02-03', '2010-01-10'], dtype='datetime64', freq=None)</pre>
</div>
注意：得到对象第DatetimeIndex
<h3>时间对象生成-date_range</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421194957570-1899547785.png" alt="">
<div class="cnblogs_code">
<pre>In : pd.date_range('2010-01-01','2010-05-01')
Out[195]:
DatetimeIndex(['2010-01-01', '2010-01-02', '2010-01-03', '2010-01-04',
 '2010-01-05', '2010-01-06', '2010-01-07', '2010-01-08',
 '2010-01-09', '2010-01-10',
 ...
 '2010-04-22', '2010-04-23', '2010-04-24', '2010-04-25',
 '2010-04-26', '2010-04-27', '2010-04-28', '2010-04-29',
 '2010-04-30', '2010-05-01'],
 dtype='datetime64', length=121, freq='D')</pre>
</div>
使用periods指定长度
pd.date_range? 查看帮助中的参数帮助信息
<div class="cnblogs_code">
<pre>start : str or datetime-like, optional
Left bound for generating dates.
end : str or datetime-like, optional
Right bound for generating dates.
periods : integer, optional 长度
Number of periods to generate.
freq : str or DateOffset, default 'D'频率 H-小时 W-周 W-MON W-WEN
Frequency strings can have multiples, e.g. '5H'. See//B-工作日
:ref:`here <timeseries.offset_aliases>` for a list of //1H20min
frequency aliases. date_range的参数freq可以各种花式定义时间间隔
tz : str or tzinfo, optional
Time zone name for returning localized DatetimeIndex, for example
'Asia/Hong_Kong'. By default, the resulting DatetimeIndex is
timezone-naive.
normalize : bool, default False
Normalize start/end dates to midnight before generating date range.
name : str, default None
Name of the resulting DatetimeIndex.
closed : {None, 'left', 'right'}, optional
Make the interval closed with respect to the given frequency to
the 'left', 'right', or both sides (None, the default).</pre>
</div>
得到的是Timestamp对象，可以将其用to_pydatetime转换成时间对象
还可以转成字符串
date_range的参数freq可以各种花式定义时间间隔
<h3>时间序列</h3>
生成的时间对象可以用来构建时间序列的
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421195614007-552567418.png" alt="">
<div class="cnblogs_code">
<pre>In : sr = pd.Series(np.arange(5),index=pd.date_range('2010-01-01',periods=5))

In [199]: sr
Out[199]:
2010-01-01 0
2010-01-02 1
2010-01-03 2
2010-01-04 3
2010-01-05 4
Freq: D, dtype: int32</pre>
</div>
那么有什么作用呢？直观的好处就是以时间为索引获取指定范围的数据
<div class="cnblogs_code">
<pre>In : sr = pd.Series(np.arange(100),index=pd.date_range('2010-01-01',periods=100))

In [201]: sr['2010-03']
Out[201]:
2010-03-01 59
2010-03-02 60
2010-03-03 61
2010-03-04 62
2010-03-05 63
2010-03-06 64
2010-03-07 65
2010-03-08 66
2010-03-09 67
2010-03-10 68
2010-03-11 69
2010-03-12 70
2010-03-13 71
2010-03-14 72
2010-03-15 73
2010-03-16 74
2010-03-17 75
2010-03-18 76
2010-03-19 77
2010-03-20 78
2010-03-21 79
2010-03-22 80
2010-03-23 81
2010-03-24 82
2010-03-25 83
2010-03-26 84
2010-03-27 85
2010-03-28 86
2010-03-29 87
2010-03-30 88
2010-03-31 89
Freq: D, dtype: int32</pre>
</div>
还比如  sr['2017':'2018']
特别方便
<h3>resample函数--重新取样</h3>
<div class="cnblogs_code">
<pre># 以周为单位取和
In : sr.resample('W').sum()
Out[203]:
2010-01-03 3
2010-01-10 42
2010-01-17 91
2010-01-24 140
2010-01-31 189
2010-02-07 238
2010-02-14 287
2010-02-21 336
2010-02-28 385
2010-03-07 434
2010-03-14 483
2010-03-21 532
2010-03-28 581
2010-04-04 630
2010-04-11 579
Freq: W-SUN, dtype: int32</pre>
</div>
truncate是类似切片的函数，意义不大，因为都可以通过切片操作来取值
<h2>pandas-文件处理</h2>
<h3>读取文件</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421200851634-151588328.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421201028983-472523151.png" alt="">
 
  例子：
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421201744267-739045217.png" alt="">
header= none
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421202110625-890641497.png" alt="">
names的使用
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421202222610-1409065642.png" alt="">
在一个数据表中，如果某一列中有None，这整个列的类型都会变成object，变成了字符串
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421202637537-1055874272.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421202805213-1098033717.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421202739366-706216884.png" alt="">本来应该是float的
 但是因为有none，变成了字符串
nan可以解释成浮点数，但是none无法解释，
解决：用na_values
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421203002872-1542720633.png" alt="">
<h3>写入文件</h3>
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421201200124-693091061.png" alt="">
写入文件示例：
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421222855022-1459267590.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421222601034-1644014706.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421222529044-491810987.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421222657871-1985694468.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421222721611-1703751199.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421201217029-1046806066.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421223230289-906513937.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421223514605-1784029215.png" alt="">
Python中读取excel的时候需要安装模块xlrd
......还有很多内容
要多多练习，才能掌握，变成自己的
<h1>第四章-数据可视化工具包---matplotlib</h1>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421224129609-1510183544.png" alt="">
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422063559810-1849959288.png" alt="">
如果在命令行或者pycharm中运行，会弹出对话框，可以进行拖动、放大等操作...
<h2>plot函数</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190421225207449-1771577956.png" alt="">
 plot用来绘制点图或者线图，两个参数（即x和y）
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422063944174-370680325.png" alt="">
还有第三个参数，一个字符串，来决定线的样式（示例：v是小三角，用短线和点连接，显示红色）
也可以使用参数传递（color=‘red’，marker=‘^’,linestyle='-.'）
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422064320338-105025403.png" alt="">
 我想画多条线？该如何操作
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422070130878-464740061.png" alt="">
show函数，调用之后，之前的plot都出现在一张图上了
<h2>Matplotlib-图像标注</h2>
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422070342515-820956011.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422071007837-222256149.png" alt="">
plt.legend的用法之一
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422071328437-884095875.png" alt="">
<h2>pandas和Matplotlib</h2>
 <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422210849899-1427575984.png" alt="">
直接使用
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422210919037-1052570688.png" alt="">
<h3>作业：绘制数学函数图像</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422211300668-303249649.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422212843238-1767900692.png" alt="">
<h2>画布与子图</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422213056878-1281202750.png" alt="">
 fig.add_subplot(2,2,1) 其中 2，2的意思就是把画布分成2x24份，最后的1是第一个位置
<h2>Matplotlib支持的图类型</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422214214044-1590349127.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422214310855-349536172.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422214405793-880401363.png" alt="">
<h3>条形图</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422214817852-1713120129.png" alt=""><img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422215822258-106828358.png" alt="">
<h3>饼图</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422220815765-463226650.png" alt="">
<h2>折线图-matplot.finance</h2>
matplotlib.finance.子包中有许多绘制金融相关图的函数接口
绘制K线图：matplotlib.finance.candlestick_ochl函数
参数的帮助信息
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422222816715-229643547.png" alt="">
导入模块并给数据添加了一个time字段
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422223300427-1265708043.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422224403182-137753089.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190422224524621-998759668.png" alt="">
<h1>第五章-金融数据分析基础实战</h1>
<h2>tushare包介绍</h2>
Tushare是一个免费、开源的财经数据接口包。
<h2>练习1-股票数据分析</h2>
<div class="cnblogs_code">
<pre>1、使用tushare包获取某股票的历史行情数据
2、输出该股票所有收盘比开盘上涨3%以上的日期
3、输出该股票所有开盘比前日收盘跌幅超过2%的日期（用shift错位）
4、加入我从2010年1月1日开始，每月第一个交易日买入一手股票，每年最后一个交易日卖出所有股票， 到今天为止，我的收益如何？</pre>
</div>
tushare接口的使用和shift函数，resample的使用
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190424230310635-1665647588.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190424230329237-1018335777.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190424230349218-939850052.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190424230434058-522801295.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190424230449720-1479260033.png" alt="">
<h2> 练习2-查找历史金叉死叉的日期</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190425212637115-201534254.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190425213123665-676442956.png" alt="">
编写代码
 
<h2>第一个量化策略</h2>
基于聚宽编码和回测
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190426220950187-900648160.png" alt="">
 initialize函数
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427092708394-1144224374.png" alt="">
handle_data函数，每个单位时间执行一次回测
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427101803744-500269552.png" alt="">
策略实现
<div class="cnblogs_code">
<pre># 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
# 1、设置股票池为沪深300的所有成分股
g.security = get_index_stocks('000300.XSHG') 　　 # 基准收益     set_benchmark('000300.XSHG') # 持有后不动
set_option('use_real_price',True)
set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003, close_commission=0.0003, close_today_commission=0, min_commission=5), type='stock')
## 回测函数
def handle_data(context, data):
# 每只股票买多少的问题,账户金额/股票个数的长度=每个股票分多少钱

# 一般情况下先卖后买 
tobuy = []
for stock in g.security:
 # 获取股票当前的开盘价
 p = get_current_data().day_open
 # 查看是否持有这只股票
 amount = context.portfolio.positions.total_amount
 # 股票的持仓成本
 cost = context.portfolio.positions.avg_cost
 # 3、如果当前股价比买入时上涨了25%，则清仓止盈
 if amount > 0 and p >= cost * 1.25:
 order_target(stock,0)# 止盈
 # 4、如果当前股价比买入时下跌了10%，则卖出止损
 if amount > 0 and p <= cost *0.9:
 order_target(stock,0)# 止损
 # 2、如果当前股价小于10元且当前不持仓，则买入
 if p <= 10.0 and amount == 0:
 tobuy.append(stock)
 order(stock,1000)
 if tobuy:
 cost_per_stock = context.portfolio.available_cash / len(tobuy)
 for per in tobuy:
 order_value(per,cost_per_stock)</pre>
</div>
<h2>双均线策略-最简单只股票</h2>
<div class="cnblogs_code">
<pre># 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
set_benchmark('000300.XSHG') # 持有后不动
set_option('use_real_price',True)
set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003, close_commission=0.0003, close_today_commission=0, min_commission=5), type='stock')

# 选股
g.security = ['601318.XSHG']
g.p1 = 5
g.p2 = 10

def handle_data(context, data):
for stock in g.security:
 # 金叉：如果5日均线大于10日均线，且没有持仓
 # 死叉：如果5日均线小于10日均线，并且持仓
 # 获取历史数据
 df = attribute_history(stock,g.p2)
 m10 = df['close'].mean()
 m5 = df['close'][-5:].mean()

 if m10 > m5 and stock in context.portfolio.positions:
 # 死叉卖出
 order_target(stock, 0)
 if m10 < m5 and stock not in context.portfolio.positions:
 order(stock,context.portfolio.available_cash * 0.8)
</pre>
</div>
 在回测图上添加其他的图
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427115619035-511446360.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427115708209-1398406559.png" alt="">
<h2>因子选股策略</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427115926196-974577243.png" alt="">
查询财务数据
get_fundanmentals
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427152559226-1841408059.png" alt="">
策略编写
<div class="cnblogs_code">
<pre># 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
set_benchmark('000300.XSHG') # 持有后不动
set_option('use_real_price',True)
set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003,
close_commission=0.0003, close_today_commission=0, min_commission=5), type='stock')

# 选股范围
g.security = get_index_stocks('000300.XSHG')

# 获取数据,在官网数据选项卡中找到valuation表
g.q = query(valuation).filter(valuation.code.in_(g.security))

# 要定期跟新调仓
 # 1、定义天数变量，在handle_data中计数，每天+1，当days%30==0的时候，执行调仓
 # 这是没30个交易日调一次
 # 2、使用run_monthly(handle,1),定义handle用来跟新的函数，1表示第一个交易日
 # 这是每月调一次
run_monthly(handle,1)

# 定义自己的仓位最多有20只股票
g.N = 20
def handle(context):
# 注意，有的函数方法会报错，因为平台支持的第三方平台的版本所导致
df = get_fundamentals(g.q)[['code','market_cap']]
df = df.sort_values('market_cap').iloc[:g.N,:]
# 新选出的股票池
to_hold = df['code'].values

# 手上可能有一些股票，有的留着，没有的卖掉，添加新的
for stock in context.portfolio.positions:
 # 手上的股票没在to_hold中，买掉
 if stock not in to_hold:
 order_target(stock,0)

to_buy =

if to_buy:
 cash_per_stock = context.portfolio.available_cash / len(to_buy)
 for per in to_buy:
 order_value(per,cash_per_stock)</pre>
</div>
注意停牌的股票的过滤
取前30个，把停牌的（paused）过滤掉，在取前20个
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427162539536-733168994.png" alt="">
<h2>多因子选股策略</h2>
市值小
净资产收益率要高
<h3>如何同时综合多个因子</h3>
...
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427164433155-956339690.png" alt="">
<h3>补充知识-标准化</h3>
 标准化，归一化，数据预处理的方法<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427170624754-1113946404.png" alt="">
编码实现
<div class="cnblogs_code">
<pre># 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
set_benchmark('000300.XSHG') # 持有后不动
set_option('use_real_price',True)
set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003,
close_commission=0.0003, close_today_commission=0, min_commission=5), type='stock')

# 选股范围
g.security = get_index_stocks('000002.XSHG')

# 获取数据,在官网数据选项卡中找到valuation表，市值数据在这个表中
# 找到roe在，indicator表中
g.q = query(valuation,indicator).filter(valuation.code.in_(g.security))

# 要定期跟新调仓
 # 1、定义天数变量，在handle_data中计数，每天+1，当days%30==0的时候，执行调仓
 # 这是没30个交易日调一次
 # 2、使用run_monthly(handle,1),定义handle用来跟新的函数，1表示第一个交易日
 # 这是每月调一次
 # 定义自己的仓位最多有20只股票
g.N = 20

run_monthly(handle,1)

def handle(context):
# 注意，有的函数方法会报错，因为平台支持的第三方平台的版本所导致
df = get_fundamentals(g.q)[['code','market_cap','roe']]
# 进行归一化
df['market_cap'] = (df['market_cap']) - df['market_cap'].min()) / (df['market_cap'].max() - df['market_cap'].min())
df['roe'] = (df['roe']) - df['roe'].min()) / (df['roe'].max() - df['roe'].min())
# 增加一列作为评分，收益率越大越好，市值越小越好。最后的结果越大越好
df['score'] = df['roe'] - df['market_cap']
# 选最后20只
df = df.sort_values('score').iloc[-g.N:,:]

# 新选出的股票池
to_hold = df['code'].values

# 手上可能有一些股票，有的留着，没有的卖掉，添加新的
for stock in context.portfolio.positions:
 # 手上的股票没在to_hold中，买掉
 if stock not in to_hold:
 order_target(stock,0)

to_buy =

if to_buy:
 cash_per_stock = context.portfolio.available_cash / len(to_buy)
 for per in to_buy:
 order_value(per,cash_per_stock)
</pre>
</div>
 还可以增加权重、增加更多的因子
<h2> 均值回归理论</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427173525623-371103927.png" alt="">
均值回归策略是一个选股策略
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427174114219-813567171.png" alt="">
编码实现
<div class="cnblogs_code">
<pre># 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
set_benchmark('000300.XSHG') # 持有后不动
set_option('use_real_price',True)
set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003,
close_commission=0.0003, close_today_commission=0, min_commission=5), type='stock')

# 选股范围
g.security = get_index_stocks('000002.XSHG')

# 均线
g.ma_days = 30

# 股票数量
g.stock_num = 10

run_monthly(handle,1)

def handle(context):
sr = pandas.Series(index=g.security)
for stock in sr.index:
 ma = attribute_history(stock, g.ma_days)['close'].mean()
 p = get_current_data().day_open
 # 计算偏离程度
 ratio = (ma-p) / ma
 sr = ratio

# 不用sort，有一个更快的函数nlargest
# 新选出的股票池
to_hold = sr.nlargest(g.stock_num).index.values

# 手上可能有一些股票，有的留着，没有的卖掉，添加新的
for stock in context.portfolio.positions:
 # 手上的股票没在to_hold中，买掉
 if stock not in to_hold:
 order_target(stock,0)

to_buy =

if to_buy:
 cash_per_stock = context.portfolio.available_cash / len(to_buy)
 for per in to_buy:
 order_value(per,cash_per_stock)</pre>
</div>
<h2>布林带策略</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427181600180-622272660.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427182306739-761275512.png" alt="">
上下N取小了不好，去大了等于没取，因为很难触碰，上下可以取不同的N
编码实现
<div class="cnblogs_code">
<pre># 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
set_benchmark('000300.XSHG') # 持有后不动
set_option('use_real_price',True)
set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003,
close_commission=0.0003, close_today_commission=0, min_commission=5), type='stock')

# 选股范围
g.security = ('600036.XSHG')

g.M = 20# 试验过20比较好
g.k = 2# 听说1.7比较好
# 初始化策略
def handle_data(context, data):
sr = attribute_history(g.security,g.M)['close']
ma = sr.mean()
up = ma + g.k * sr.std()
down = ma - g.k * sr.std()
p = get_current_data().day_open
cash = context.portfolio.available_cash
if p < down and g.security not in context.portfolio.positions:
 order_value(g.security, cash)
elif p >up and g.security in context.portfolio.positions:
 order_target(g.security, 0)</pre>
</div>
 
可以继续尝试其他股票或者多只股票
多只股票牵涉资金分配的问题
多尝试几个参数，看效果如何
布林带比较窄的时候，说明波动小，将不适合短线交易，也可将其作为一个因子
加入止损操作
<h2>PEG策略</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427184332476-1458241501.png" alt="">
<h3>市盈率是什么</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427184511079-1302027280.png" alt="">
<h3>PEG策略说明</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427185248325-1738574197.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427185550916-920790160.png" alt="">
<h3>PEG选股</h3>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427185653831-598483507.png" alt="">
编码实现
市盈率有静态的和动态的两种，我们使用静态的pe_ratio,在valuation表中
收益增长率inc_net_profit_year_on_year,在indicator里面
<div class="cnblogs_code">
<pre># 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
set_benchmark('000300.XSHG') # 持有后不动
set_option('use_real_price',True)
set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003,
close_commission=0.0003, close_today_commission=0, min_commission=5), type='stock')

# 选股范围
g.security = get_index_stocks('000300.XSHG')
g.q = query(valuation.code,valuation.pe_ratio,indicator.inc_net_profit_year_on_year).filter(valuation.code.in_(g.security))
g.N = 20
run_monthly(handle,1)

def handle(context):
df = get_fundamentals(g.q)
# 过滤负值的PEG
df = df[(df['pe_ratio'] > 0) & (df['inc_net_profit_year_on_year'] > 0) ]
# 计算peg
df['peg'] = df['pe_ratio'] /df['inc_net_profit_year_on_year']/100
df = df.sort_values('peg')
to_hold = df['code'][:g.N].values
print(to_hold)
# 手上可能有一些股票，有的留着，没有的卖掉，添加新的
for stock in context.portfolio.positions:
 # 手上的股票没在to_hold中，买掉
 if stock not in to_hold:
 order_target(stock,0)

to_buy =

if to_buy:
 cash_per_stock = context.portfolio.available_cash / len(to_buy)
 for per in to_buy:
 order_value(per,cash_per_stock)</pre>
</div>
<h2>动量策略和反转策略</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427230223998-1396108737.png" alt="">
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190427230255359-1320214746.png" alt="">
 
编码实现
<div class="cnblogs_code">
<pre>import jqdata
import math
import numpy as np
import pandas as pd
import datetime

def initialize(context):
set_option('use_real_price', True)
set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003,
close_commission=0.0003, close_today_commission=0, min_commission=5), type='stock')

g.benchmark = '000300.XSHG'
g.N = 10
set_benchmark(g.benchmark)
run_monthly(handle, 1)

def handle(context):
stocks = get_index_stocks('000300.XSHG')
# 这段时间的收盘价（attribu是选取一只股票多个时间的，history是选择多只股票）
# 转置，相当于将股票代码放在了表头上
df_close = history(30, field='close', security_list=list(stocks)).T
# 增加ret列，表示收益率（最后一天的价格-第一天的价格）/ 第一天的价格
df_close['ret'] = (df_close.iloc[:,-1]-df_close.iloc[:,0])/df_close.iloc[:,0]
# ascending = False 表示降序，即为动量策略，总选最好的
# ascending = True反转策略
sorted_stocks = df_close.sort_values('ret', ascending = False).index

to_hold = sorted_stocks[:g.N]

# 手上可能有一些股票，有的留着，没有的卖掉，添加新的
for stock in context.portfolio.positions:
 # 手上的股票没在to_hold中，买掉
 if stock not in to_hold:
 order_target(stock,0)

to_buy =

if to_buy:
 cash_per_stock = context.portfolio.available_cash / len(to_buy)
 for per in to_buy:
 order_value(per,cash_per_stock)
</pre>
</div>
 
最后得出结论，A股市场的反转策略优于动量策略
<h2>羊驼交易法则</h2>
<img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190428214532050-1009530002.png" alt=""> <img src="https://img2018.cnblogs.com/blog/1355675/201904/1355675-20190428214736656-1678388865.png" alt="">
编码实现
<div class="cnblogs_code">
<pre># 导入函数库
from jqdata import *

# 初始化函数，设定基准等等
def initialize(context):
set_benchmark('000300.XSHG') # 持有后不动
set_option('use_real_price',True)
set_order_cost(OrderCost(open_tax=0, close_tax=0.001, open_commission=0.0003,
close_commission=0.0003, close_today_commission=0, min_commission=5), type='stock')

# 选股范围
g.security = get_index_stocks('000300.XSHG')
# 看多长时间的收益率
g.period = 30
g.N = 10
# 每次调整几只股票
g.change = 1
# 标志位，第一次购买的时候购买的是10只
g.init = True
run_monthly(handle,1)

def get_sorted_stocks(context,stocks):
df_close = history(g.period, field='close', security_list=stocks).T
# 增加ret列，表示收益率（最后一天的价格-第一天的价格）/ 第一天的价格
df_close['ret'] = (df_close.iloc[:,-1]-df_close.iloc[:,0])/df_close.iloc[:,0]
# ascending = False 表示降序，即为动量策略，总选最好的
# ascending = True反转策略
sorted_stocks = df_close.sort_values('ret', ascending = False)
return sorted_stocks.index.values

def handle(context):
if g.init:
 stocks = get_sorted_stocks(context, g.security)[:g.N]
 cash = context.portfolio.available_cash * 0.9 / len(stocks)
 for stock in stocks:
 order_value(stock, cash)
 g.init = False
 return
stocks = get_sorted_stocks(context, context.portfolio.positions.keys())

for stock in stocks:
 if len(context.portfolio.positions) >= g.N:
 break
 if stock not in context.portfolio.positions:
 order_value(stock, context.portfolio.available_cash * 0.9)</pre>
</div>
<h2>简易回测框架开发</h2>
框架内容
<ol>
<li>上下文信息保存：context</li>
<li>获取数据：</li>
<li>下单函数：</li>
<li>用户接口：</li>
<li>...</li>
</ol>
  
来源：https://www.cnblogs.com/yxiaodao/p/10732824.html

頁: [1]

琼殿技术论坛's Archiver

python数据分析与量化交易