数据分析三剑客--Numpy

 

NumPy模块的介绍

NumPy是Python语言的一个扩展包。支持多维数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。NumPy提供了与Matlab相似的功能与操作方式，因为两者皆为直译语言。

NumPy通常与SciPy(Scientific Python)和Matplotlib(绘图库)一起使用，这种组合广泛用于替代Matlab，是一个流行的技术平台。

NumPy中定义的最重要的对象是称为ndarray的N维数组类型。它描述相同类型的元素集合，可以使用基于零的索引访问集合中元素。基本的ndarray是使用NumPy中的数组函数创建的: numpy.array。

NumPy支持比Python更多种类的数值类型。NumPy数值是dtype(数据类型)对象的实例，每个对象具有唯一的特征。

NumPy模块的基础知识

#numpy 的 本质 与 特性
# ndarray -- 多维数组 高阶运算
# 同质性 -- 对于一个给定的数组而言，数组内的每个元素具有相同的数据类型

#ndarray  -- 4 个 维度   shape   siez   dtype  ndim

import  numpy 

rant_arr = numpy.random.randint(20,40,(6,8),dtype=int) # 产生一个数组
print(rant_arr)

print(rant_arr.shape)
print(rant_arr.size)
print(rant_arr.dtype)
print(rant_arr.ndim)

#如何生成数组
"""empty_like : Return an empty array with shape and type of input.
ones_like : Return an array of ones with shape and type of input.
zeros_like : Return an array of zeros with shape and type of input.
full_like : Return a new array with shape of input filled with value.
empty : Return a new uninitialized array.
ones : Return a new array setting values to one.
zeros : Return a new array setting values to zero.
full : Return a new array of given shape filled with value. """
# array
list_p = [1,2,3,4,5,6,7,8,9,10]
array = numpy.array(list_p)
print(array)
print(type(list_p))
print(type(array))

# 列表解析式
L = [i for i in range(1,10)]
print(L)

# arange
b = numpy.arange(10)
c = numpy.arange(0,10,2)
d = numpy.arange(1,10,3)
print(b,c,d)

# 正态分布 random.normal(u, r, (x, y))
normal = numpy.random.normal(1.5,3,(3,4)) # 均值为5 标准差为3
print(normal)

#数据的重塑与级联

"""ma.concatenate : Concatenate function that preserves input masks.
array_split : Split an array into multiple sub-arrays of equal or
near-equal size.
split : Split array into a list of multiple sub-arrays of equal size.
hsplit : Split array into multiple sub-arrays horizontally (column wise).
vsplit : Split array into multiple sub-arrays vertically (row wise).
dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
stack : Stack a sequence of arrays along a new axis.
block : Assemble arrays from blocks.
hstack : Stack arrays in sequence horizontally (column wise).
vstack : Stack arrays in sequence vertically (row wise).
dstack : Stack arrays in sequence depth wise (along third dimension).
column_stack : Stack 1-D arrays as columns into a 2-D array."""

# 数据重塑 reshape
list_p = [1,2,3,4,5,6,7,8,9,10,11,12]
array = numpy.array(list_p)
new_arr = numpy.reshape(array,(3,4))
print(new_arr)

# 级联 concatenate
conw_arr = numpy.concatenate((new_arr,new_arr),axis=0) # 行向级联
print(conw_arr)

conh_arr = numpy.concatenate((new_arr,new_arr),axis=1) # 纵向级联
print(conh_arr)

numpy.concatenate()

#numpy 下的随机问题 numpy.random.xxx 类似 -- random.xxx
rant_arr = numpy.random.randint(10,40,(3,5))
print(rant_arr)

print("随机种子 seed ")
# 设定一个随机种子

numpy.random.seed(10)
rant_arr = numpy.random.randint(10,40,(3,5)) # 产生第一个
print(rant_arr)

numpy.random.seed(10)
rant_arr = numpy.random.randint(10,40,(3,5)) # 产生第二个
print(rant_arr)

random = numpy.random.random((3,5)) # 在[0, 1.0)之间 生成 3行5列的数组
print(random)

# 关于 数组 值的获取 以及 切片问题
arr = numpy.random.randint(10,40,(6,6),dtype=int)
print(arr)

# 取值
#print(arr[0][5])
print(arr[0,5])

# 切片
print(arr[1:5]) # 行的切片 [start,end,step] [start,end)
print(arr[:,2:5]) # 列的切片 [start,end,step] [start,end)

# 反向的问题
print(arr[::-1]) # 行反转
print(arr[:,::-1]) # 行反转

#  图片举例

import cv2
import numpy as np

img_arr = cv2.imread("cat.jpg")
#print(img_arr )
w_img = img_arr[::-1]
h_img = img_arr[:,::-1]

cv2.imshow("img_arr",img_arr)
cv2.imshow("w_img",w_img)
cv2.imshow("h_img",h_img)

cv2.waitKey(0)
cv2.destroyAllWindows()

# 数组运算问题

# 算数运算 -- + - * / // ** % -->
"""
1 保证双目运算符左右两侧 数组结构shape一致
2 在进行实质运算过程中，完成的是 对应元素之间的加减问题
"""
int_arr1 = numpy.random.randint(10,40,(5,5),dtype=int)
print(int_arr1)

int_arr2 = numpy.random.randint(40,60,(5,5),dtype=int)
print(int_arr2)

# +
arr3 = int_arr1 + int_arr2
print(arr3)

# 矩阵的聚合运算

import numpy as np

a = np.array([1,2,3,4],[5,6,7,8],[2,5,8,3],[4[6[7[3]]]])
# 求和
print(np.sum(a)) # axis 可以指定 行列模式
print(np.sum(a,axis=1)) # 列式相加
# 最大值
print(np.max(a))
print(np.max(a,axis=1)) # 列式最大值
# 最小值
print(np.min(a))
print(np.min(a,axis=1)) # 列式最小值
# 均值
print(np.mean(a))
print(np.mean(a,axis=1)) # 列式均值
# 标准差
print(np.std(a))
print(np.std(a,axis=1)) # 列式均值
# 开根号
print(np.sqrt(a))
# 求方
print(np.exp(a))
# 向下取整
print(np.floor(10*np.random.random((2,2)))) # 向下取整
# 变换结构
print(a.resize(1,))

# 数组点乘 -- 矩阵点乘

int_arr4 = numpy.random.randint(6,11,(3,3),dtype=int)
print(int_arr4)

int_arr5 = numpy.random.randint(1,6,(3,3),dtype=int)
print(int_arr5)

int_arr6 = int_arr4 * int_arr5
int_arr7 = (int_arr4).dot(int_arr5)
int_arr8 = numpy.dot(int_arr4,int_arr5)

print("算数乘法 {}".format(int_arr6))
print("A.dot(B) 点乘 {}".format(int_arr7))
print("np.(A,B) 点乘 {}".format(int_arr8))

# 数组矩阵化 -- 矩阵及其运算
int_arr4 = numpy.random.randint(6,11,(3,3),dtype=int)
print(int_arr4)

mat4_int = numpy.asmatrix(int_arr4)
print(mat4_int)

print(type(int_arr4))
print(type(mat4_int))

import numpy.linalg as nlg

# 矩阵求逆
mat__int = nlg.inv(mat4_int) # 求逆
print(mat__int)

# 特征值 与 特征向量
eig_value,eig_vector = nlg.eig(mat4_int)
print(eig_value)
print(eig_vector)

案例-- 股票分析

# 股票分析案例
"""实例分析：
假设股票收益率服从正态分布，使用numpy产生正态分布随机数，模拟股票收益率，
并采用正态分布策略进行交易。
假设有2000只股票，一年股市共250个交易日。一年365天-全民法定节假日=365-每周双休日*52-节日放假日
（国庆3天+春节3天+劳动节、元旦、清明、端午、中秋共11天）=365-104-11=250日,产生2000x500的数组。"""

# 生成基准数据
import numpy as np

stocks = 2000 # 2000支骨片
days = 500 # 两年大约 500 个交易日

# 生成服从正态分布：期望为0 ，方差为1 的序列
stock_day = np.random.standard_normal((stocks,days))
print(stock_day.shape) # 打印数据结构
# 打印出前5只股票，头五个交易日的涨幅情况
print(stock_day[0:5,:5])

# 正态分布 买入策略

# 保留后 250 天的随机数据，作为策略验证数据
keep_days = 250

# 统计前 250 ， 切片切出 0-250 day ， days = 500
stock_day_train = stock_day[:,0:days - keep_days]

# 打印出前 250 天涨幅最大的三支，总幅度通过 np.sum计算 ，通过 np.sort 排序
print(np.sort(np.sum(stock_day_train,axis=1))[:3])

# 使用 np.argsort 针对股票涨幅进行排序，返回序号，既符合买入条件的股票序号
stock_lower = np.argsort(np.sum(stock_day_train,axis=1))[:3]

# 输出符合 买入条件的 股票序号
print(stock_lower)

# 封装函数plot_buy_lower()
#可视化选中的前3只跌幅最大的股票前250走势以及从第250日买入后的走势

import matplotlib.pyplot as plt
"""%matpltlib inline"""

# 定义函数
def buy_lower(stock):
# 设置一个一行两列的可视化图标
_, axs = plt.subplots(nrows=1,ncols=2,figsize=(16,5))

# 绘制前 250 天的股票走势图 np.cumsum() 序列连续求和
axs[0].plot(np.arange(0,days - keep_days),
stock_day_train[stock].cumsum())

# 第 250 天开始 到第 500 天的股票走势
buy = stock_day[stock][days - keep_days:days].cumsum()

# 绘制从第 250 天到 500 天中股票的走势图
axs[1].plot(np.arange(days - keep_days,days),buy)

# 返回 从第 250 天开始 到第 500 天 计算盈亏的盈亏序列的最后一个值
return buy[-1]

# 假设 等权重地购买3只股票
profit = 0 # 盈亏比例

# 遍历 涨幅最大的3支股票序列序号
for stock in stock_lower:
# profit 即 3支 股票从 250 天 买入开始计算 ，直到最后一天的盈亏比例
profit += buy_lower(stock)
print("买入第{}支股票，凑够第250个交易日开始持有盈亏：{:.2f}%".format(stock,profit))