Numpy_V0

一维数组

import numpy as np
returns=np.array([3.5,5,2,8,4])
print (returns[0], returns[len(returns)-1])
print (returns[1:3])

3.5 4.0
[ 5.  2.]

二维数组

two_d=np.array([[1,2],[3,4]])
print (two_d.shape)
print (two_d[:, 0])
print (two_d[0, :])
print (type(two_d[0,:]))
print (two_d[0])
print (two_d[1, 1])

(2, 2)
[1 3]
[1 2]
<class 'numpy.ndarray'>
[1 2]
4

三维数组

three_d=np.array([[[1,2],[3,4]],[[-1,-2],[-3,-4]]])
print(three_d.shape)

(2, 2, 2)

计算功能

print (np.log(returns))
print (np.mean(returns))
print (np.max(returns))
print (returns*2 + 5)
print ('Std Dev: ', np.std(returns))

[ 1.25276297  1.60943791  0.69314718  2.07944154  1.38629436]
4.5
8.0
[ 12.  15.   9.  21.  13.]
Std Dev:  2.0

矩阵计算基础

矩阵转置

A=np.array([[1,2],[3,4]])
print(A)
A_=A.T
print(A_)

[[1 2]
 [3 4]]
[[1 3]
 [2 4]]

矩阵加减乘除

print(A+A_)
print(A-A_)

[[2 5]
 [5 8]]
[[ 0 -1]
 [ 1  0]]

print(2*A)

[[2 4]
 [6 8]]

矩阵相乘

矩阵A和B必须是相符的矩阵，A的列要等于B的行。

A = np.array([
[1, 2],
[4, 5],
[7, 8]
])
B = np.array([
[4, 4, 2],
[2, 3, 1],
])
print(np.dot(A, B))

[[ 8 10  4]
 [26 31 13]
 [44 52 22]]

逆矩阵

矩阵与逆矩阵相乘为 [[1,0][0,1]]

A=np.array([[2,1],[1,-2]])
A_=np.linalg.inv(A)
print(A)
print(A_)
print(np.dot(A,A_))

[[ 2  1]
 [ 1 -2]]
[[ 0.4  0.2]
 [ 0.2 -0.4]]
[[ 1.  0.]
 [ 0.  1.]]

矩阵解线代：

b=np.array([[1],[1]])
z=np.dot(A_,b)
print(z)

[[ 0.6]
 [-0.2]]

模拟收益率计算

random/cumprod

N = 10
assets = np.zeros((N, 10))
returns = np.zeros((N, 10))
R_1 = np.random.normal(1.01, 0.03, 10) #生产mean是1.01,标准差是0.03,10个数字
returns[0] = R_1 #第一行填满
assets[0] = np.cumprod(R_1) #累乘
for i in range(1, N): #i循环1到9
    R_i = R_1 + np.random.normal(0.001, 0.02, 10) #依赖R_1再加随机分布值
    returns[i] = R_i #每一行新行都填满
    assets[i] = np.cumprod(R_i) #每一行的资产价格
mean_returns = [(np.mean(R)-1)*100 for R in returns]
return_volatilities = [np.std(R) for R in returns]

计算预期回报率

uniform/dot

weights = np.random.uniform(0, 1,N)
weights = weights/np.sum(weights)
p_returns = np.dot(weights, mean_returns) #相乘后求和
print ("Expected return of the portfolio: ", p_returns)

Expected return of the portfolio:  1.92147101096

组合方差计算

cov = np.cov(returns)
print (cov)
# INSERT VARIANCES AND COVARIANCES HERE
var_p = np.dot(np.dot(weights, cov), weights.T)
vol_p = np.sqrt(var_p)
print ("Portfolio volatility: ", vol_p)

[[ 0.00099351  0.00071169  0.00100641  0.00078264  0.0005784   0.00076031
   0.0011774   0.00080169  0.00129754  0.00137542]
 [ 0.00071169  0.00094042  0.00074393  0.0007035   0.00018939  0.00052523
   0.00084827  0.00054028  0.00096172  0.00090507]
 [ 0.00100641  0.00074393  0.00131859  0.00077832  0.00040642  0.00064044
   0.00116463  0.00074241  0.00122998  0.00127675]
 [ 0.00078264  0.0007035   0.00077832  0.00110114  0.00052953  0.00072944
   0.00076405  0.00064023  0.0011361   0.00136472]
 [ 0.0005784   0.00018939  0.00040642  0.00052953  0.00080537  0.00067569
   0.00063351  0.00034159  0.00055221  0.00092572]
 [ 0.00076031  0.00052523  0.00064044  0.00072944  0.00067569  0.00086815
   0.00090113  0.00050108  0.0007645   0.00119473]
 [ 0.0011774   0.00084827  0.00116463  0.00076405  0.00063351  0.00090113
   0.00157151  0.00089647  0.00147618  0.00146065]
 [ 0.00080169  0.00054028  0.00074241  0.00064023  0.00034159  0.00050108
   0.00089647  0.00089553  0.00130243  0.00124931]
 [ 0.00129754  0.00096172  0.00122998  0.0011361   0.00055221  0.0007645
   0.00147618  0.00130243  0.00243586  0.0019394 ]
 [ 0.00137542  0.00090507  0.00127675  0.00136472  0.00092572  0.00119473
   0.00146065  0.00124931  0.0019394   0.00228438]]
Portfolio volatility:  0.0320212349566