numpy的常用函数

numpy的常用函数

读取文件

逻辑上可被解释为二维数组的文本文件：
数据项1<分隔符>数据项2<分隔符>…<分隔符>数据项n
…
数据项1<分隔符>数据项2<分隔符>…<分隔符>数据项n
…
numpy.loadtxt(
文件路径,如果相对路径读取不到用绝对路径。
delimiter=分隔符(缺省一个空格),
usecols=列序列(缺省读取所有列，注意是按列读取),
unpack=是否展开列(缺省False，为True时将读取的二维矩阵转换为一维格式),
dtype=元素类型(缺省float),
**converters=转换器字典(在读取数据的时候进行处理，缺省不做转换))**返回值：一个二维数组(unpack=False)或多个一维数组(unpack=True)
画k线图

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import datetime as dt
import numpy as np
import matplotlib.pyplot as mp
import matplotlib.dates as md


# 将日-月-年格式的日期变为年-月-日格式的转换器函数
def dmy2ymd(dmy):
        # 将UTF-8编码的字节串转换为UCS-4编码字符串
    dmy = str(dmy, encoding='utf-8')
    '''
    d, m, y = dmy.split('-')
    ymd = y + "-" + m + "-" + d
    '''
    # 将日-月-年格式的日期字符串解析为datetime
    # 类型的对象，再取其date类型的日期子对象
    date = dt.datetime.strptime(
        dmy, '%d-%m-%Y').date()
    # 将date类型的日期对象格式
    # 化为年-月-日形式的字符串
    ymd = date.strftime('%Y-%m-%d')
    return ymd


# 从aapl.csv文件中读取苹果公司一段时间内的
# 股票价格：开盘价，最高价，最低价和收盘价
#读取数据
dates, opening_prices, highest_prices, \
    lowest_prices, closing_prices = np.loadtxt(
        '../../data/aapl.csv', delimiter=",",
        usecols=(1, 3, 4, 5, 6), unpack=True,
        dtype='M8[D], f8, f8, f8, f8',
        converters={1: dmy2ymd})
mp.figure('Candlestick', facecolor='lightgray')
mp.title('Candlestick', fontsize=20)
mp.xlabel('Date', fontsize=14)
mp.ylabel('Price', fontsize=14)
ax = mp.gca()
# 主刻度表示每个星期的星期一
ax.xaxis.set_major_locator(
    md.WeekdayLocator(byweekday=md.MO))
# 次刻度表示每一天
ax.xaxis.set_minor_locator(md.DayLocator())
# 设置主刻度的标签格式：日 月(英文缩写) 年
ax.xaxis.set_major_formatter(
    md.DateFormatter('%d %b %Y'))
mp.tick_params(labelsize=10)
mp.grid(axis='y', linestyle=':')
# Numpy.datetime64[D]->
#     Matplotlib.dates.datetime.datetime
dates = dates.astype(md.datetime.datetime)
生成一个数组，存储正确与否
rise = closing_prices - opening_prices >= 0.01
fall = opening_prices - closing_prices >= 0.01
#生成空数组
fc = np.zeros(dates.size, dtype='3f4')
ec = np.zeros(dates.size, dtype='3f4')
#按照fc的参数为true或false确定是否获取值，只有为true时才会赋值。此处比较奇葩，对矩阵的操作不太熟练。
fc[rise], fc[fall] = (1, 1, 1), (0, 0.5, 0)
ec[rise], ec[fall] = (1, 0, 0), (0, 0.5, 0)
#画线
mp.bar(dates, highest_prices - lowest_prices,
       0, lowest_prices, color=fc, edgecolor=ec)
#画矩形
mp.bar(dates, closing_prices - opening_prices,
       0.8, opening_prices, color=fc, edgecolor=ec)
mp.gcf().autofmt_xdate()
mp.show()

算数平均值

样本：S = [s1, s2, …, sn]
算数平均值：m = (s1+s2+…+sn) / n
s1 = s+d1
s2 = s+d2
…
sn = s+dn
m = (s1+s2+…+sn) / n
=(s+s+…+s) / n + (d1+d2+…+dn)/n
=s + (d1+d2+…+dn)/n
n->oo
算数平均值表示对真值的无偏估计。
numpy.mean(S)->m

import numpy as np
closing_prices = np.loadtxt(r'C:\Users\Cs\Desktop\数据分析\DS+ML\DS\data\aapl.csv', delimiter=',',
    usecols=(6), unpack=True)
mean = 0
for closing_price in closing_prices:
    mean += closing_price
mean /= closing_prices.size
print(mean)
mean = np.mean(closing_prices)
print(mean)

加权平均值

样本：S = [s1, s2, …, sn]
权重：W = [w1, w2, …, wn]
加权平均值：
a = (s1w1+s2w2+…+snwn)/(w1+w2+…+wn)
numpy.average(S, weights=W)->a
VWAP - 成交量加权平均价格

import numpy as np
closing_prices, volumes = np.loadtxt(
    '../../data/aapl.csv', delimiter=',',
    usecols=(6, 7), unpack=True)
vwap, wsum = 0, 0
for closing_price, volume in zip(
        closing_prices, volumes):
    vwap += closing_price * volume
    wsum += volume
vwap /= wsum
print(vwap)
vwap = np.average(closing_prices, weights=volumes)
print(vwap)

TWAP - 时间加权平均价格

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import datetime as dt
import numpy as np
def dmy2days(dmy):
    dmy = str(dmy, encoding='utf-8')
    date = dt.datetime.strptime(dmy, '%d-%m-%Y').date()
    days = (date - dt.date.min).days
    return days


days, closing_prices = np.loadtxt(
    '../../data/aapl.csv', delimiter=',',
    usecols=(1, 6), unpack=True,
    converters={1: dmy2days})
twap = np.average(closing_prices, weights=days)
print(twap)

各类最值

1)max/min: 返回一个数组中最大/最小元素
2)argmax/argmin: 返回一个数组中最大/最小元素的下标。不论其为几维数组，返回的只是一维状态下的下标。
3)maximum/minimum: 将两个同维数组中对应元素中最大/最小元素构成一个新的数组
4)ptp: 返回一个数组中最大值和最小值之差

import numpy as np
# 产生9个介于[10, 100)区间的随机数
a = np.random.randint(10, 100, 9).reshape(3, 3)
print(a)
print(np.max(a), np.min(a), np.ptp(a))
print(np.argmax(a), np.argmin(a))
b = np.random.randint(10, 100, 9).reshape(3, 3)
print(b)
print(np.maximum(a, b), np.minimum(a, b), sep='\n')

中位数

中位数
np.median(无序样本)->中位数

import numpy as np
closing_prices = np.loadtxt(
    '../../data/aapl.csv', delimiter=',',
    usecols=(6), unpack=True)
size = closing_prices.size
sorted_prices = np.msort(closing_prices)
median = (sorted_prices[int((size - 1) / 2)] +
          sorted_prices[int(size / 2)]) / 2
print(median)
median = np.median(closing_prices)
print(median)

波动范围与波动幅度

波动范围=最高价格-最低价格
价格波动幅度百分比=（最高价格-最低价格）÷平均价格x100%

标准差

样本：S = [s1, s2, …, sn]
平均值：m = (s1+s2+…+sn)/n
离差：D = [d1, d2, …, dn], di = si-m
离差方：Q = [q1, q2, …, qn], qi = di^2
总体方差：v = (q1+q2+…+qn)/n
总体标准差：s = sqrt(v)，方均根
样本方差：v’ = (q1+q2+…+qn)/(n-1)
样本标准差：s’ = sqrt(v’)，方均根

numpy.std(S)->s
numpy.std(S, ddof=1)->s’

import numpy as np
closing_prices = np.loadtxt(
    '../../data/aapl.csv', delimiter=',',
    usecols=(6), unpack=True)
mean = np.mean(closing_prices)         # 算数平均值
devs = closing_prices - mean           # 离差
dsqs = devs ** 2                       # 离差方
pvar = np.sum(dsqs) / dsqs.size        # 总体方差
pstd = np.sqrt(pvar)                   # 总体标准差
svar = np.sum(dsqs) / (dsqs.size - 1)  # 样本方差，注意，样本方差需要减1，但是总体方差不需要
sstd = np.sqrt(svar)                   # 样本标准差
pstd = np.std(closing_prices)          # 总体标准差
sstd = np.std(closing_prices, ddof=1)  # 样本标准差

时间处理

按星期取平均值

np.where(条件)：数组中满足该条件的元素的下标数组，会以数组形式返回，所以遍历的时候需要多处理一个[]
np.take(数组，下标数组)：数组中与下标数组相对应的元素组相对应的元素所构成的子数组。
数组[掩码数组（True ,False）]数组中与掩码数组为true对应的元素所构成的子数组。

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import datetime as dt
import numpy as np


# 转换器函数：将日-月-年格式的日期字符串转换为星期
def dmy2wday(dmy):
    dmy = str(dmy, encoding='utf-8')
    date = dt.datetime.strptime(
        dmy, '%d-%m-%Y').date()
    wday = date.weekday()  # 用0~6表示周一到周日
    return wday


wdays, closing_prices = np.loadtxt(
    '../../data/aapl.csv', delimiter=',',
    usecols=(1, 6), unpack=True,
    converters={1: dmy2wday})
print(wdays)
ave_closing_prices = np.zeros(5)
for wday in range(ave_closing_prices.size):
    '''
    ave_closing_prices[wday] = np.take(
        closing_prices, np.where(wdays == wday)).mean()
    '''
    '''
    ave_closing_prices[wday] = \
        closing_prices[np.where(wdays == wday)].mean()
    '''
    ave_closing_prices[wday] = \
        closing_prices[wdays == wday].mean()
for wday, ave_closing_price in zip(
        ['MON', 'TUE', 'WED', 'THU', 'FRI'],
        ave_closing_prices):
    print(wday, np.round(ave_closing_price, 2))

数组的轴向汇总

np.apply_along_axis(处理函数, 轴向, 数组)
沿着数组中所指定的轴向，调用处理函数，并将每次调用的返回值重新组织成数组返回。

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import datetime as dt
import numpy as np

def dmy2wday(dmy):
    dmy = str(dmy, encoding='utf-8')
    date = dt.datetime.strptime(dmy, '%d-%m-%Y').date()
    wday = date.weekday()
    return wday

wdays, opening_prices, highest_prices, \
    lowest_prices, closing_prices = np.loadtxt(
        r'C:\Users\Cs\Desktop\数据分析\DS+ML\DS\data\aapl.csv',
        delimiter=',', usecols=(1, 3, 4, 5, 6),
        unpack=True, converters={1: dmy2wday})
wdays = wdays[:16]
print(wdays)
opening_prices = opening_prices[:16]
highest_prices = highest_prices[:16]
lowest_prices = lowest_prices[:16]
closing_prices = closing_prices[:16]
# 第一个星期一的索引
print(np.where(wdays == 0))
first_monday = np.where(wdays == 0)[0][0]
print(first_monday)
print(np.where(wdays == 0)[0])
last_friday = np.where(wdays == 4)[0][-1]
indices = np.arange(first_monday, last_friday + 1)
indices = np.split(indices, 3)

def week_summary(indices):
    opening_price = opening_prices[indices[0]]
    highest_price = highest_prices[indices].max()
    lowest_price = lowest_prices[indices].min()
    closing_price = closing_prices[indices[-1]]
    return opening_price, highest_price, \
        lowest_price, closing_price


summaries = np.apply_along_axis(
    week_summary, 1, indices)
print(summaries)
np.savetxt('../../data/summary.csv', summaries,
           delimiter=',', fmt='%g')

卷积积分

定义：在每段时间域中f1(t)*f2(t)与t的函数关系。它适用于任何两个信号的卷积积分计算。通常,在每个分段时间域中,若函数f1( )和f2(t- )两波形的后沿值(即函数不为零的最小值)分别为tr1和tr2,两波形前沿值(即函数右边界
激励函数：g(t)
单位激励下的响应函数：f(t)
/
响应函数：| g(t)f(t)dt
/
a = [1 2 3 4 5]
b = [6 7 8]
c = numpy.convolve(a, b, 卷积类型)
40 61 82 - 有效卷积(valid)
19 40 61 82 67 - 同维卷积(same)
6 19 40 61 82 67 40 - 完全卷积(full)
0 0 1 2 3 4 5 0 0
8 7 6
8 7 6
8 7 6
8 7 6
8 7 6
8 7 6
8 7 6

import numpy as np
a = np.array([1, 2, 3, 4, 5])   # 被卷积序列
b = np.array([6, 7, 8])         # 卷积核序列
c = np.convolve(a, b, 'full')   # 完全卷积
print(c)
d = np.convolve(a, b, 'same')   # 同维卷积
print(d)
e = np.convolve(a, b, 'valid')  # 有效卷积
print(e)

移动均线

股票的五日均线
a b c d e f g h i j [1/5 1/5 1/5 1/5 1/5]
(a+b+c+d+e)/5
(b+c+d+e+f)/5
(c+d+e+f+g)/5
…
(f+g+h+i+j)/5
[A, B, C, D, E]
S=A+B+C+D+E
(aA+bB+cC+dD+eE)/S
aA/S+bB/S+cC/S+dD/S+eE/S
[A/S, B/S, C/S, D/S, E/S]

import datetime as dt
import numpy as np
import matplotlib.pyplot as mp
import matplotlib.dates as md
def dmy2ymd(dmy):
    dmy = str(dmy, encoding='utf-8')
    date = dt.datetime.strptime(dmy, '%d-%m-%Y').date()
    ymd = date.strftime('%Y-%m-%d')
    return ymd

dates, closing_prices = np.loadtxt(
    '../../data/aapl.csv', delimiter=',',
    usecols=(1, 6), unpack=True,
    dtype='M8[D], f8', converters={1: dmy2ymd})
sma52 = np.convolve(
    closing_prices, np.ones(5) / 5, 'valid')
sma10 = np.convolve(
    closing_prices, np.ones(10) / 10, 'valid')
mp.figure('Simple Moving Average',
          facecolor='lightgray')
mp.title('Simple Moving Average', fontsize=20)
mp.xlabel('Date', fontsize=14)
mp.ylabel('Price', fontsize=14)
ax = mp.gca()
# 设置水平坐标每个星期一为主刻度
ax.xaxis.set_major_locator(md.WeekdayLocator(
    byweekday=md.MO))
# 设置水平坐标每一天为次刻度
ax.xaxis.set_minor_locator(md.DayLocator())
# 设置水平坐标主刻度标签格式
ax.xaxis.set_major_formatter(md.DateFormatter(
    '%d %b %Y'))
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')
dates = dates.astype(md.datetime.datetime)
mp.plot(dates, closing_prices, c='lightgray',
        label='Closing Price')
mp.plot(dates[4:], sma52, c='limegreen', alpha=0.5,
        linewidth=6, label='SMA-5(2)')
mp.plot(dates[9:], sma10, c='dodgerblue',
        label='SMA-10')
mp.legend()
mp.gcf().autofmt_xdate()
mp.show()