金融与量化投资

一、介绍

10年积累的做网站、成都网站设计经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有洪江管理区免费网站建设让你可以放心的选择与我们合作。

1、量化投资第三方相关模块

NumPy：数组批量计算

Pandas：表计算与数据分析

Matplotlib：图表绘制

2、如何使用Python进行量化投资

自己编写：NumPy+pandas+Matplotlib+……

在线平台：聚宽、优矿、米筐、Quantopian、……

开源框架：RQAlpha、QUANTAXIS、……

金融：就是对现有资源进行重新整合之后，实现价值和利润的等效流通。

量化投资：利用计算机技术并且采用一定的数学模型去实践投资理念，实现投资策略的过程。

量化投资的优势：

        避免主观情绪、人性弱点和认知偏差，选择更加客观

        能同时包括多角度的观察和多层次的模型

        及时跟踪市场变化，不断发现新的统计模型，寻找交易机会

        在决定投资策略后，能通过回测验证其效果

量化策略：通过一套固定的逻辑来分析、判断和决策，自动化地进行股票交易

二、IPython和jupyter

IPython是交互式的Python命令行

pip install ipython

使用：ipython

pip install jupyter

执行命令：jupyter-notebook

三、IPython快捷键及常用命令

1、IPython快捷键

2、IPython的魔法命令

3、IPython调试器命令

四、NumPy：数组计算

NumPy是高性能科学计算和数据分析的基础包。它是pandas等其他各种工具的基础。

NumPy的主要功能：

        ndarray，一个多维数组结构，高效且节省空间

        无需循环对整组数据进行快速运算的数学函数

        *读写磁盘数据的工具以及用于操作内存映射文件的工具

        *线性代数、随机数生成和傅里叶变换功能

        *用于集成C、C++等代码的工具

安装方法：pip install numpy

引用方式：import numpy as np

例1：已知若干家跨国公司的市值（美元），将其换算为人民币
import numpy as np
import random
a = [random.uniform(100.0,200.0) for _ in range(1000)]            #随机生成有1000个小数的列表
# list(map(lambda x:x*6.6,a))                                  #每个元素都乘6.6，组成新的列表
arr = np.array(a)                                                  #列表转化为数组
arr * 6.6                                                         #对数组每个值乘以6.6得到所需的值

例2：已知购物车中每件商品的价格与商品件数，求总金额
price = [random.uniform(10,20) for _ in range(100)]
num = [random.randint(1,10) for _ in range(100)]
# sum_p=0
# for p,n in zip(price,num):                                   #拉链函数把对应的值相乘
#         sum_p+=p*n
# print(sum_p)
price_arr = np.array(price)                                #价格列表变成数组
num_arr = np.array(num)                                   #数量列表变成数组
np.sum(price_arr*num_arr)

五、NumPy常用属性和常用方法

常用属性：

T     数组的转置（对高维数组而言）

dtype数组元素的数据类型

size数组元素的个数

ndim数组的维数

shape数组的维度大小（以元组形式）

常用方法：
array.shape                         array的规格
array.ndim
array.dtype                         array的数据规格
numpy.zeros(dim1,dim2)              创建dim1*dim2的零矩阵
numpy.arange
numpy.eye(n) /numpy.identity(n)     创建n*n单位矩阵
numpy.array([…data…], dtype=float64 )
array.astype(numpy.float64)         更换矩阵的数据形式
array.astype(float)                 更换矩阵的数据形式
array * array                       矩阵点乘
array[a:b]                          切片
array.copy()                        得到ndarray的副本，而不是视图
array [a] [b]=array [ a, b ]        两者等价
name=np.array(['bob','joe','will']) res=name==’bob’ res= array([ True, False, False], dtype=bool)
data[True,False,…..]                索引，只索取为True的部分，去掉False部分
通过布尔型索引选取数组中的数据，将总是创建数据的副本。
data[ [4,3,0,6] ]                   索引，将第4,3,0,6行摘取出来，组成新数组
data[-1]=data[data.__len__()-1]
numpy.reshape(a,b)                  将a*b的一维数组排列为a*b的形式
array([a,b,c,d],[d,e,f,g])          返回一维数组，分别为[a,d],[b,e],[c,f],[d,g]
array[ [a,b,c,d] ][:,[e,f,g,h] ]=array[ numpy.ix_( [a,b,c,d],[e,f,g,h] ) ]
array.T                             array的转置
numpy.random.randn(a,b)             生成a*b的随机数组
numpy.dot(matrix_1,matrix_2)        矩阵乘法
array.transpose( (1,0,2,etc.) )     对于高维数组，转置需要一个由轴编号组成的元组

创建ndarray：
    array()         将列表转换为数组，可选择显式指定dtype
    arange()        range的numpy版，支持浮点数，np.arange(2,10,0.2) 步长可以为小数
    linspace()      类似arange()，第三个参数为数组长度，分为多少份
    zeros()         根据指定形状和dtype创建全0数组
    ones()          根据指定形状和dtype创建全1数组
    empty()         根据指定形状和dtype创建空数组（随机值）
    eye()           根据指定边长和dtype创建单位矩阵

六、NumPy：索引和切片

1、数组和标量之间的运算

    a+1    a*3    1//a    a**0.5

2、同样大小数组之间的运算

    a+b    a/b    a**b

3、数组的索引：

    一维数组：a[5]

    多维数组：

        列表式写法：a[2][3]

        新式写法：a[2,3] (推荐)

   数组的切片：

        一维数组：a[5:8]    a[4:]        a[2:10] = 1

        多维数组：a[1:2, 3:4]    a[:,3:5]        a[:,1]

4、强调：与列表不同，数组切片时并不会自动复制，在切片数组上的修改会影响原数组。    【解决方法：copy()】

arr=np.arange(10).reshape(2,5)             #生成的数组元素0到9通过reshape拆成两行，五列，要拆的行列相乘必须等于数组的总元素
arr=np.arange(10).reshape(2,-1)            #后面-1是占位的，会通过计算得到列数
ag=[random.randint(1,10) for _ in range(20)]
list(filter(lambda x:x>5,ag))            #过滤大于5的元素列表
ag= np.array(ag)
a[a>5]                                   #给一个数组，选出数组中所有大于5的数
a[(a>5) & (a%2==0)]                      #给一个数组，选出数组中所有大于5的偶数
a[(a>5) | (a%2==0)]                       #给一个数组，选出数组中所有大于5的数和偶数。


import numpy as np
a = np.array([1,2,3,4,5,4,7,8,9,10])
a[a>5&(a%2==0)]                               #注意加括号
输出：array([ 1,  2,  3,  4,  5,  4,  7,  8,  9, 10])
a[(a>5)&(a%2==0)]
输出：array([ 8, 10])


对一个二维数组，选出其第一列和第三列，组成新的二维数组
a[:,[1,3]]

七、NumPy：通用函数’

通用函数：能同时对数组中所有元素进行运算的函数

常见通用函数：

一元函数：abs, sqrt, exp, log, ceil, floor, rint, trunc, modf, isnan, isinf, cos, sin, tan

numpy.sqrt(array)                   平方根函数
numpy.exp(array)                    e^array[i]的数组
numpy.abs/fabs(array)               计算绝对值
numpy.square(array)                 计算各元素的平方 等于array**2
numpy.log/log10/log2(array)         计算各元素的各种对数
numpy.sign(array)                   计算各元素正负号
numpy.isnan(array)                  计算各元素是否为NaN
numpy.isinf(array)                  计算各元素是否为inf
numpy.cos/cosh/sin/sinh/tan/tanh(array) 三角函数
numpy.modf(array)                   将array中值得整数和小数分离，作两个数组返回
numpy.ceil(array)                   向上取整,也就是取比这个数大的整数
numpy.floor(array)                  向下取整,也就是取比这个数小的整数
numpy.rint(array)                   四舍五入
numpy.trunc(array)                  向0取整
numpy.cos(array)                       正弦值
numpy.sin(array)                    余弦值
numpy.tan(array)                    正切值

二元函数：add, substract, multiply, divide, power, mod,  maximum, mininum,

numpy.add(array1,array2)            元素级加法
numpy.subtract(array1,array2)       元素级减法
numpy.multiply(array1,array2)       元素级乘法
numpy.divide(array1,array2)         元素级除法 array1./array2
numpy.power(array1,array2)          元素级指数 array1.^array2
numpy.maximum/minimum(array1,aray2) 元素级最大值/最小值
numpy.fmax/fmin(array1,array2)      元素级最大值，忽略NaN
numpy.mod(array1,array2)            元素级求模
numpy.copysign(array1,array2)       将第二个数组中值得符号复制给第一个数组中值
numpy.greater/greater_equal/less/less_equal/equal/not_equal (array1,array2)
元素级比较运算，产生布尔数组
numpy.logical_end/logical_or/logic_xor(array1,array2)元素级的真值逻辑运算

浮点数有两个特殊值：

nan(Not a Number)：不等于任何浮点数（nan != nan）

inf(infinity)：比任何浮点数都大

NumPy中创建特殊值：np.nannp.inf

在数据分析中，nan常被用作表示数据缺失值
a=np.nan
b=np.inf
np.isnan(a)                       #判断a是否是nan
np.isinf(b)                      #判断b是否是inf
a[~np.isnan(a)]                   #删除数组中的nan

八、NumPy：数学和统计方法

1、常用函数：

sum求和
cumsum 求前缀和
mean求平均数
std求标准差
var求方差
min求最小值
max求最大值
argmin求最小值索引
argmax求最大值索引

arr=np.arange(15).reshape(3,5)
arr.sum(axis=0)              #行作为轴，对数组逐列求和
arr.sum(axis=1)              #列作为轴，对数组逐行求和

2、NumPy：随机数生成

随机数生成函数在np.random子包内

常用函数
rand给定形状产生随机数组（0到1之间的数）
randint给定形状产生随机整数
choice给定形状产生随机选择
shuffle与random.shuffle相同
uniform给定形状产生随机小数数组

九、pandas简单介绍

pandas是一个基于NumPy构建的强大的Python数据分析的工具包。

1、pandas的主要功能

具备对其功能的数据结构DataFrame、Series

集成时间序列功能

提供丰富的数学运算和操作

灵活处理缺失数据

2、安装方法：pip install pandas

3、引用方法：import pandas as pd

十、Series

Series是一种类似于一位数组的对象，由一组数据和一组与之相关的数据标签（索引）组成。

1、创建方式：

    pd.Series([4,7,-5,3])                                      #默认元素下标数字
    pd.Series([4,7,-5,3],index=['a','b','c','d'])            #两套索引系统，下标和标签
    pd.Series({'a':1, 'b':2})
    pd.Series(0, index=['a','b','c','d'])

2、Series支持数组的特性：

从ndarray创建Series：Series(arr)

与标量运算：sr*2

两个Series运算：sr1+sr2

索引：sr[0], sr[[1,2,4]]

切片：sr[0:2]（切片依然是视图形式）

通用函数：np.abs(sr)

布尔值过滤：sr[sr>0]

统计函数：

mean() #求平均数

sum() #求和

cumsum() #累加

s = pd.Series(0,index=['a','b','c','d'])
s.a                    #结果0
v = pd.Series({'a':1,'b':2})
v.a                    #结果1
v.b                      #结果2
v[0]                    #结果1
s*2
#结果
a    0
b    0
c    0
d    0
dtype: int64
v*2
#结果
a    2
b    4
dtype: int64

3、整数索引

sr = np.Series(np.arange(4.))

sr[-1]

如果索引是整数类型，则根据整数进行数据操作时总是面向标签的。

loc属性以标签解释

iloc属性以下标解释

十一、pandas：Series数据对齐

pandas在运算时，会按索引进行对齐然后计算。如果存在不同的索引，则结果的索引是两个操作数索引的并集。

    sr1 = pd.Series([12,23,34], index=['c','a','d'])
    sr2 = pd.Series([11,20,10], index=['d','c','a',])
    sr=sr1+sr2
    sr3 = pd.Series([11,20,10,14], index=['d','c','a','b'])
    sr1+sr3
    
    如何在两个Series对象相加时将缺失值设为0？
    sr1.add(sr2, fill_value=0)
    灵活的算术方法：add, sub, div, mul

十二、pandas：Series缺失数据

1、缺失数据：使用NaN（Not a Number）来表示缺失数据。其值等于np.nan。内置的None值也会被当做NaN处理。

2、处理缺失数据的相关方法：

dropna()过滤掉值为NaN的行
fillna()填充缺失数据
isnull()返回布尔数组，缺失值对应为True
notnull()返回布尔数组，缺失值对应为False

3、过滤缺失数据：sr.dropna() 或 sr[data.notnull()]

4、填充缺失数据：fillna(0)

sr=sr.dropna()                       #丢掉缺失值
sr=sr.fillna(0)                       #缺失值填充为0
sr=sr.fillna(sr.mean())                 #缺失值填充为平均数

十三、pandas：DataFrame与DataFrame查看数据

1、DataFrame

DataFrame是一个表格型的数据结构，含有一组有序的列。

DataFrame可以被看做是由Series组成的字典，并且共用一个索引。

创建方式：
pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']), 'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
……
csv文件读取与写入：
df.read_csv('E:\算法\day110 Numpy、Pandas模块\601318.csv')
df.to_csv()

2、DataFrame查看数据

查看数据常用属性及方法：

        index                    获取索引

        T                        转置

        columns                    获取列索引

        values                    获取值数组

        describe()                获取快速统计

    DataFrame各列name属性：列名

    rename(columns={})

十四、pandas：DataFrame索引和切片

1、DataFrame有行索引和列索引。

2、DataFrame同样可以通过标签和位置两种方法进行索引和切片。

3、DataFrame使用索引切片：

方法1：两个中括号，先取列再取行。    df['A'][0]

方法2（推荐）：使用loc / iloc属性，一个中括号，逗号隔开，先取行再取列。

loc属性：解释为标签

iloc属性：解释为下标

向DataFrame对象中写入值时只使用方法2

行 / 列索引部分可以是常规索引、切片、布尔值索引、花式索引任意搭配。（注意：两部分都是花式索引时结果可能与预料的不同）

通过标签获取：
df['A']
df[['A', 'B']]
df['A'][0]
df[0:10][['A', 'C']]
df.loc[:, ['A', 'B']]  # 行是所有的行，列取是A和B的
df.loc[:, 'A':'C']
df.loc[0, 'A']
df.loc[0:10, ['A', 'C']]

通过位置获取：
df.iloc[3]
df.iloc[3, 3]
df.iloc[0:3, 4:6]
df.iloc[1:5, :]
df.iloc[[1, 2, 4], [0, 3]]、

通过布尔值过滤：
　　df[df['A'] > 0]
　　df[df['A'].isin([1, 3, 5])]
　　df[df < 0] = 0

十五、pandas：DataFrame数据对齐与缺失数据

DataFrame对象在运算时，同样会进行数据对齐，行索引与列索引分别对齐。

结果的行索引与列索引分别为两个操作数的行索引与列索引的并集。

1、DataFrame处理缺失数据的相关方法：

dropna(axis=0,how=‘any’,…) 过滤掉包含值为NaN的行
fillna()填充缺失数据
isnull()返回布尔数组，缺失值对应为True
notnull()返回布尔数组，缺失值对应为False

df2.dropna(axis=0,how="all")            #一行全是nan的就丢掉

2、pandas：其他常用方法

- mean        #求平均值

- sum         #求和

- sort_index  #按行或列索引排序

- sort_values  #按值排序

- apply(func,axis=0)  #axis=0指的是逐行，axis=1指的是逐列。

        df.apply(lamada x:x.mean())  #按列求平均

        df.apply(lamada x:x['high']+x["low"])/2,axis=1)  #按列求平均（最高价和最低价的平均）

        df.apply(lamada x:x['high']+x["low"])/2,axis=1)  #按列求平均（最高价和最低价的平均）

- applymap(func) #将函数应用在DataFrame各个元素上

- map(func) #将函数应用在Series各个元素上

df2=df.loc[:,"open":"low"]         #对所有行取open列到low列的元素
df2.sort_values("open")             #基于open列的数据进行升序排序
df2.sort_values("open",ascending=False)       #基于open列的数据倒序排序

3、pandas：时间对象处理

时间序列类型：

    时间戳：特定时刻

    固定时期：如2017年7月

    时间间隔：起始时间-结束时间

Python标准库：datetime

    datetime.datetime.timedelta  # 表示 时间间隔

    dt.strftime()                           #f：format吧时间对象格式化成字符串

    strptime()                              #吧字符串解析成时间对象p：parse

    灵活处理时间对象：dateutil包

        dateutil.parser.parse('2018/1/29')

    成组处理时间对象：pandas

        pd.to_datetime(['2001-01-01', '2002-02-02'])

产生时间对象数组：date_range

start 开始时间

end 结束时间

periods 时间长度

freq 时间频率，默认为'D'，可选H(our),W(eek),B(usiness),S(emi-)M(onth),(min)T(es), S(econd), A(year),…

pd.date_range(['2001-01-01', '2002-02-02'])

pd.date_range(['2001-01-01',periods=10])

4、pandas：时间序列

（1）时间序列就是以时间对象为索引的Series或DataFrame。

（2）datetime对象作为索引时是存储在DatetimeIndex对象中的。

（3）时间序列特殊功能：

传入“年”或“年月”作为切片方式

传入日期范围作为切片方式

丰富的函数支持：resample(), strftime(), ……

批量转换为datetime对象：to_pydatetime()

df.index = pd.DatetimeIndex(pd.to_datetime(df["date"]))        #date变成时间索引

del df["date"]                                        #删掉原来的date列

十六、pandas：从文件读取

1、时间序列就是以时间对象作为索引

读取文件：从文件名、URL、文件对象中加载数据
read_csv               默认分隔符为逗号
read_table            默认分隔符为\t
read_excel             读取excel文件

2、读取文件函数主要参数：

sep                  指定分隔符，可用正则表达式如'\s+'
header = None             指定文件无列名
name                 指定列名
index_col             指定某列作为索引
skip_row              指定跳过某些行
na_values             指定某些字符串表示缺失值，na_values=["None","null"],对应的显示为nan
parse_dates           指定某些列是否被解析为日期，布尔值或列表，为True表示转换为时间对象
df = pd.read_csv("601318.csv")                # 默认以,为分隔符
     - pd.read_csv("601318.csv", sep='\s+')  # 匹配空格，支持正则表达式
     - pd.read_table("601318.csv", sep=',')  # 和df = pd.read_csv("601318.csv")   一样
     - pd.read_excle("601318.xlsx")          # 读Excel文件
     
sep：指定分隔符
header = None, 就会吧默认的表名去除,如果后面names=list("abcdef")表示使用abcdef作为header
df.rename(column={0: 'a', 1: "b"})  # 修改列名
pd.read_csv(index_col=0)              # 第0列
如果想让时间成为索引，pd.read_csv(index_col='date')  # 时间列
pd.read_csv(index_col='date', parse_datas=True)     # 时间列，parse_datas转换为时间对象，设为true是吧所有能转的都转
pd.read_csv(index_col='date', parse_datas=['date'])  # 把date的那一列转换成时间对象
na_values = ['None']  # 吧表里面为None的转换成NaN，是吧字符串转换成缺失值
na_rep()               # 是吧缺失值nan转换成字符串

cols                   # 指定输出的列，传入列表

十七、pandas：写入到文件

1、写入到文件：

to_csv

2、写入文件函数的主要参数：

sep

na_rep                  指定缺失值转换的字符串，默认为空字符串

header = False          不输出列名一行

index = False           不输出行索引一列

cols                    指定输出的列，传入列表

3、其他文件类型：json, XML, HTML, 数据库

4、pandas转换为二进制文件格式（pickle）:

save

load

十八、pandas:数据分组与聚合

分组
df = pd.DateFrame({
'data1':np.random.uniform(10, 20, 5),
'data2':np.random.uniform(-10, 10, 5),
'key1':list("sbbsb")
'key2':
})
df.groupby('key1').mean()  # 做平均
df.groupby('key1').sum()  # 做平均
df.groupby(['key1', 'key2']).mean()  # 做平均  支持分层索引，按多列分组
df.groupby(len).mean()  # 传一个函数的时候，x是每一个行的索引
df.groupby(lambda x: len(x)).mean()  # 传一个函数的时候，x是每一个行的索引
df.groupby.groups()  # 取得多有的组
df.groupby.get_group()  # 取得一个组


聚合
df.groupby('key1').max()[['data1', 'data2']]  # 去掉key2的data1，data2，花式索引
df.groupby('key1').max()[['data1', 'data2']] - df.groupby('key1').min()[['data1', 'data2']]  # 去掉key2
df.groupby('key1').agg(lamada
x:x.max() - x.min())
既想看最大也可看最小
df.groupby('key1').agg([np.max, np.min])
不同的列不一样的聚合
df.groupby('key1').agg({'data1': 'min', 'data2': 'max'})  # 键是列名，值是
a = _219  # 219行的代码
a.resample('3D'), mean()  # 3D 3天，3M就是三周

数据合并
- 数据拼接
df = df.copy()
pd.concat([df, df2, df3], ignore_index=True)  # 不用之前的索引，
pd.concat([df, df2, df3], axis=1)  # 列
pd.concat([df, df2, df3], keys=['a', 'b', 'c'])  # 不用之前的索引，
df2.appeng(df3)
- 数据连接
如果不指定on，默认是行索引进行join
pd.merge(df, df3, on='key1')
pd.merge(df, df3, on='['key1','key2'])

十九、简单介绍Matplotlib

1、Matplotlib是一个强大的Python绘图和数据可视化的工具包

2、安装方法：pip install matplotlib

3、引用方法：import matplotlib.pyplot as plt

4、绘图函数：plt.plot()

5、显示图像：plt.show()

6、plot函数

（1）plot函数：绘制折线图

线型linestyle（-,-.,--,..）

点型marker（v,^,s,*,H,+,x,D,o,…）

颜色color（b,g,r,y,k,w,…）

（2）plot函数绘制多条曲线

（3）pandas包对plot的支持

7、图像标注

设置图像标题：plt.title()

设置x轴名称：plt.xlabel()

设置y轴名称：plt.ylabel()

设置x轴范围：plt.xlim()

设置y轴范围：plt.ylim()

设置x轴刻度：plt.xticks()

设置y轴刻度：plt.yticks()

设置曲线图例：plt.legend()

二十、示例

使用Matplotlib模块在一个窗口中绘制数学函数y=x, y=x2, y=sin(x)的图像，使用不同颜色的线加以区别

x=np.linspace(-100,100,10000))
y1=x
y2=x**2
y3=np.sin(x)
plt.plot(x,y1,label="$y=x$")
plt.plot(x,y2,label="$y=x^2$")
plt.plot(x,y3,label="$y=\sin x$")
plt.ylim(-100,100)            #显示Y轴范围自定义
plt.legend()
plt.show()

二十一、图形定义

网页题目：金融与量化投资
浏览地址：http://cdiso.cn/article/isgihg.html