Python基础 numpy中的常见函数有哪些

有些Python小白对numpy中的常见函数不太了解，今天小编就整理出来分享给大家。

我们提供的服务有：网站制作、成都网站建设、微信公众号开发、网站优化、网站认证、临汾ssl等。为超过千家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的临汾网站制作公司

Numpy是Python的一个科学计算的库，提供了矩阵运算的功能，其一般与Scipy、matplotlib一起使用。其实，list已经提供了类似于矩阵的表示形式，不过numpy为我们提供了更多的函数。

数组常用函数

1.where()按条件返回数组的索引值

2.take(a,index)从数组a中按照索引index取值

3.linspace(a,b,N)返回一个在(a,b)范围内均匀分布的数组，元素个数为N个

4.a.fill()将数组的所有元素以指定的值填充

5.diff(a)返回数组a相邻元素的差值构成的数组

6.sign(a)返回数组a的每个元素的正负符号

7.piecewise(a,[condlist],[funclist])数组a根据布尔型条件condlist返回对应元素结果

8.a.argmax(),a.argmin()返回a最大、最小元素的索引

改变数组维度

a.ravel(),a.flatten():将数组a展平成一维数组

a.shape=(m,n),a.reshape(m,n):将数组a转换成m*n维数组

a.transpose,a.T转置数组a

数组组合

1.hstack((a,b)),concatenate((a,b),axis=1)将数组a,b沿水平方向组合

2.vstack((a,b)),concatenate((a,b),axis=0)将数组a,b沿竖直方向组合

3.row_stack((a,b))将数组a,b按行方向组合

4.column_stack((a,b))将数组a,b按列方向组合

数组分割

1.split(a,n,axis=0),vsplit(a,n)将数组a沿垂直方向分割成n个数组

2.split(a,n,axis=1),hsplit(a,n)将数组a沿水平方向分割成n个数组

数组修剪和压缩

1.a.clip(m,n)设置数组a的范围为(m,n),数组中大于n的元素设定为n,小于m的元素设定为m

2.a.compress()返回根据给定条件筛选后的数组

数组属性

1.a.dtype数组a的数据类型

2.a.shape数组a的维度

3.a.ndim数组a的维数

4.a.size数组a所含元素的总个数

5.a.itemsize数组a的元素在内存中所占的字节数

6.a.nbytes整个数组a所占的内存空间7.a.astype(int)转换a数组的类型为int型

数组计算

1.average(a,weights=v)对数组a以权重v进行加权平均

2.mean(a),max(a),min(a),middle(a),var(a),std(a)数组a的均值、最大值、最小值、中位数、方差、标准差

3.a.prod()数组a的所有元素的乘积

4.a.cumprod()数组a的元素的累积乘积

5.cov(a,b),corrcoef(a,b)数组a和b的协方差、相关系数

6.a.diagonal()查看矩阵a对角线上的元素7.a.trace()计算矩阵a的迹，即对角线元素之和

以上就是numpy中的常见函数。更多Python学习推荐:PyThon学习网教学中心。

Python 数据处理（二十四）—— 索引和选择

如果你想获取 'A' 列的第 0 和第 2 个元素，你可以这样做:

这也可以用 .iloc 获取，通过使用位置索引来选择内容

可以使用 .get_indexer 获取多个索引:

警告 ：

对于包含一个或多个缺失标签的列表，使用 .loc 或 [] 将不再重新索引，而是使用 .reindex

在以前的版本中，只要索引列表中存在至少一个有效标签，就可以使用 .loc[list-of-labels]

但是现在，只要索引列表中存在缺失的标签将引发 KeyError 。推荐的替代方法是使用 .reindex() 。

例如

索引列表的标签都存在

先前的版本

但是，现在

索引标签列表中包含不存在的标签，使用 reindex

另外，如果你只想选择有效的键，可以使用下面的方法，同时保留了数据的 dtype

对于 .reindex() ，如果有重复的索引将会引发异常

通常，您可以将所需的标签与当前轴做交集，然后重新索引

但是，如果你的索引结果包含重复标签，还是会引发异常

使用 sample() 方法可以从 Series 或 DataFrame 中随机选择行或列。

该方法默认会对行进行采样，并接受一个特定的行数、列数，或数据子集。

默认情况下， sample 每行最多返回一次，但也可以使用 replace 参数进行替换采样

默认情况下，每一行被选中的概率相等，但是如果你想让每一行有不同的概率，你可以为 sample 函数的 weights 参数设置抽样权值

这些权重可以是一个列表、一个 NumPy 数组或一个 Series ，但它们的长度必须与你要抽样的对象相同。

缺失的值将被视为权重为零，并且不允许使用 inf 值。如果权重之和不等于 1 ，则将所有权重除以权重之和，将其重新归一化。例如

当应用于 DataFrame 时，您可以通过简单地将列名作为字符串传递给 weights 作为采样权重（前提是您要采样的是行而不是列）。

sample 还允许用户使用 axis 参数对列进行抽样。

最后，我们还可以使用 random_state 参数为 sample 的随机数生成器设置一个种子，它将接受一个整数（作为种子）或一个 NumPy RandomState 对象

当为该轴设置一个不存在的键时， .loc/[] 操作可以执行放大

在 Series 的情况下，这实际上是一个追加操作

可以通过 .loc 在任一轴上放大 DataFrame

这就像 DataFrame 的 append 操作

由于用 [] 做索引必须处理很多情况（单标签访问、分片、布尔索引等），所以需要一些开销来搞清楚你的意图

如果你只想访问一个标量值，最快的方法是使用 at 和 iat 方法，这两个方法在所有的数据结构上都实现了

与 loc 类似， at 提供了基于标签的标量查找，而 iat 提供了基于整数的查找，与 iloc 类似

同时，你也可以根据这些索引进行设置值

如果索引标签不存在，会放大数据

另一种常见的操作是使用布尔向量来过滤数据。运算符包括：

|(or) 、 (and) 、 ~ (not)

这些必须用括号来分组，因为默认情况下， Python 会将 df['A'] 2 df['B'] 3 这样的表达式评估为 df['A'] (2 df['B']) 3 ，而理想的执行顺序是 (df['A'] 2) (df['B'] 3)

使用一个布尔向量来索引一个 Series ，其工作原理和 NumPy ndarray 一样。

您可以使用一个与 DataFrame 的索引长度相同的布尔向量从 DataFrame 中选择行

列表推导式和 Series 的 map 函数可用于产生更复杂的标准

我们可以使用布尔向量结合其他索引表达式，在多个轴上索引

iloc 支持两种布尔索引。如果索引器是一个布尔值 Series ，就会引发异常。

例如，在下面的例子中， df.iloc[s.values, 1] 是正确的。但是 df.iloc[s，1] 会引发 ValueError 。

如何用python计算vwap

VWAP(Volume-Weighted Average Price 成交量加权平均价格)是一个非常重要的经济学量，它代表着金融资产的平均价格。某个价格的成交量越高，该价格所占的权重就越大。VMAP就是以成交量为权重计算出来的加权平均

VWAP(Volume-Weighted Average Price 成交量加权平均价格)是一个非常重要的经济学量，它代表着金融资产的”平均“价格。某个价格的成交量越高，该价格所占的权重就越大。VMAP就是以成交量为权重计算出来的加权平均值，常用于算法交易。

下面使用python来计算成交量加权平均价格：

1.将数据读入数组。

2.计算VWAP。

view plainprint?

import numpy as np

c,v=np.loadtxt('data.csv', delimiter=',', usecols=(6,7), unpack=True)

vwap = np.average(c, weights=v)

print "VMAP =", vwap

//The output is

VWAP = 350.589549353

这样我们就计算出了VWAP，我们仅仅调用了average函数，并将v作为权重参数使用，就完成了VWAP的计算。

python数据分析与应用第三章代码3-5的数据哪来的

savetxt

import numpy as np

i2 = np.eye(2)

np.savetxt("eye.txt", i2)

3.4 读入CSV文件

# AAPL,28-01-2011, ,344.17,344.4,333.53,336.1,21144800

c,v=np.loadtxt('data.csv', delimiter=',', usecols=(6,7), unpack=True) #index从0开始

3.6.1 算术平均值

np.mean(c) = np.average(c)

3.6.2 加权平均值

t = np.arange(len(c))

np.average(c, weights=t)

3.8 极值

np.min(c)

np.max(c)

np.ptp(c) 最大值与最小值的差值

3.10 统计分析

np.median(c) 中位数

np.msort(c) 升序排序

np.var(c) 方差

3.12 分析股票收益率

np.diff(c) 可以返回一个由相邻数组元素的差

值构成的数组

returns = np.diff( arr ) / arr[ : -1] #diff返回的数组比收盘价数组少一个元素

np.std(c) 标准差

对数收益率

logreturns = np.diff( np.log(c) ) #应检查输入数组以确保其不含有零和负数

where 可以根据指定的条件返回所有满足条件的数

组元素的索引值。

posretindices = np.where(returns 0)

np.sqrt(1./252.) 平方根，浮点数

3.14 分析日期数据

# AAPL,28-01-2011, ,344.17,344.4,333.53,336.1,21144800

dates, close=np.loadtxt('data.csv', delimiter=',', usecols=(1,6), converters={1:datestr2num}, unpack=True)

print "Dates =", dates

def datestr2num(s):

return datetime.datetime.strptime(s, "%d-%m-%Y").date().weekday()

# 星期一 0

# 星期二 1

# 星期三 2

# 星期四 3

# 星期五 4

# 星期六 5

# 星期日 6

#output

Dates = [ 4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 1. 2. 4. 0. 1. 2. 3. 4. 0.

1. 2. 3. 4.]

averages = np.zeros(5)

for i in range(5):

indices = np.where(dates == i)

prices = np.take(close, indices) #按数组的元素运算,产生一个数组作为输出。

a = [4, 3, 5, 7, 6, 8]

indices = [0, 1, 4]

np.take(a, indices)

array([4, 3, 6])

np.argmax(c) #返回的是数组中最大元素的索引值

np.argmin(c)

3.16 汇总数据

# AAPL,28-01-2011, ,344.17,344.4,333.53,336.1,21144800

#得到第一个星期一和最后一个星期五

first_monday = np.ravel(np.where(dates == 0))[0]

last_friday = np.ravel(np.where(dates == 4))[-1]

#创建一个数组，用于存储三周内每一天的索引值

weeks_indices = np.arange(first_monday, last_friday + 1)

#按照每个子数组5个元素，用split函数切分数组

weeks_indices = np.split(weeks_indices, 5)

#output

[array([1, 2, 3, 4, 5]), array([ 6, 7, 8, 9, 10]), array([11,12, 13, 14, 15])]

weeksummary = np.apply_along_axis(summarize, 1, weeks_indices,open, high, low, close)

def summarize(a, o, h, l, c): #open, high, low, close

monday_open = o[a[0]]

week_high = np.max( np.take(h, a) )

week_low = np.min( np.take(l, a) )

friday_close = c[a[-1]]

return("APPL", monday_open, week_high, week_low, friday_close)

np.savetxt("weeksummary.csv", weeksummary, delimiter=",", fmt="%s") #指定了文件名、需要保存的数组名、分隔符(在这个例子中为英文标点逗号)以及存储浮点数的格式。

0818b9ca8b590ca3270a3433284dd417.png

格式字符串以一个百分号开始。接下来是一个可选的标志字符：-表示结果左对齐，0表示左端补0，+表示输出符号(正号+或负号-)。第三部分为可选的输出宽度参数，表示输出的最小位数。第四部分是精度格式符，以”.”开头，后面跟一个表示精度的整数。最后是一个类型指定字符，在例子中指定为字符串类型。

numpy.apply_along_axis(func1d, axis, arr, *args, **kwargs)

def my_func(a):

... """Average first and last element of a 1-D array"""

... return (a[0] + a[-1]) * 0.5

b = np.array([[1,2,3], [4,5,6], [7,8,9]])

np.apply_along_axis(my_func, 0, b) #沿着X轴运动，取列切片

array([ 4., 5., 6.])

np.apply_along_axis(my_func, 1, b) #沿着y轴运动，取行切片

array([ 2., 5., 8.])

b = np.array([[8,1,7], [4,3,9], [5,2,6]])

np.apply_along_axis(sorted, 1, b)

array([[1, 7, 8],

[3, 4, 9],

[2, 5, 6]])

3.20 计算简单移动平均线

(1) 使用ones函数创建一个长度为N的元素均初始化为1的数组，然后对整个数组除以N，即可得到权重。如下所示：

N = int(sys.argv[1])

weights = np.ones(N) / N

print "Weights", weights

在N = 5时，输出结果如下：

Weights [ 0.2 0.2 0.2 0.2 0.2] #权重相等

(2) 使用这些权重值，调用convolve函数：

c = np.loadtxt('data.csv', delimiter=',', usecols=(6,),unpack=True)

sma = np.convolve(weights, c)[N-1:-N+1] #卷积是分析数学中一种重要的运算，定义为一个函数与经过翻转和平移的另一个函数的乘积的积分。

t = np.arange(N - 1, len(c)) #作图

plot(t, c[N-1:], lw=1.0)

plot(t, sma, lw=2.0)

show()

3.22 计算指数移动平均线

指数移动平均线(exponential moving average)。指数移动平均线使用的权重是指数衰减的。对历史上的数据点赋予的权重以指数速度减小，但永远不会到达0。

x = np.arange(5)

print "Exp", np.exp(x)

#output

Exp [ 1. 2.71828183 7.3890561 20.08553692 54.59815003]

Linspace 返回一个元素值在指定的范围内均匀分布的数组。

print "Linspace", np.linspace(-1, 0, 5) #起始值、终止值、可选的元素个数

#output

Linspace [-1. -0.75 -0.5 -0.25 0. ]

(1)权重计算

N = int(sys.argv[1])

weights = np.exp(np.linspace(-1. , 0. , N))

(2)权重归一化处理

weights /= weights.sum()

print "Weights", weights

#output

Weights [ 0.11405072 0.14644403 0.18803785 0.24144538 0.31002201]

(3)计算及作图

c = np.loadtxt('data.csv', delimiter=',', usecols=(6,),unpack=True)

ema = np.convolve(weights, c)[N-1:-N+1]

t = np.arange(N - 1, len(c))

plot(t, c[N-1:], lw=1.0)

plot(t, ema, lw=2.0)

show()

3.26 用线性模型预测价格

(x, residuals, rank, s) = np.linalg.lstsq(A, b) #系数向量x、一个残差数组、A的秩以及A的奇异值

print x, residuals, rank, s

#计算下一个预测值

print np.dot(b, x)

3.28 绘制趋势线

x = np.arange(6)

x = x.reshape((2, 3))

x

array([[0, 1, 2], [3, 4, 5]])

np.ones_like(x) #用1填充数组

array([[1, 1, 1], [1, 1, 1]])

类似函数

zeros_like

empty_like

zeros

ones

empty

3.30 数组的修剪和压缩

a = np.arange(5)

print "a =", a

print "Clipped", a.clip(1, 2) #将所有比给定最大值还大的元素全部设为给定的最大值，而所有比给定最小值还小的元素全部设为给定的最小值

#output

a = [0 1 2 3 4]

Clipped [1 1 2 2 2]

a = np.arange(4)

print a

print "Compressed", a.compress(a 2) #返回一个根据给定条件筛选后的数组

#output

[0 1 2 3]

Compressed [3]

b = np.arange(1, 9)

print "b =", b

print "Factorial", b.prod() #输出数组元素阶乘结果

#output

b = [1 2 3 4 5 6 7 8]

Factorial 40320

print "Factorials", b.cumprod()

#output

python实现资产配置(2)--Blacklitterman 模型

在 python实现资产配置(1)----Markowitz 投资组合模型 中, 我们已经见过如何使用Markowitz求得最优资产配比. 这是一种在已知未来各资产的概率分布,然后再求解的方法.

Markowitz模型输入参数包括历史数据法和情景分析法两种方法,情景分析法的缺点是主观因素,随意性太强,因此使用历史数据法, 将资产的均值和协方差输入模型是比较常见的作法. 不过, 不足之处很明显: 未来的资产收益率分布不一定与过去相同. 此外, Markowitz 模型结果对输入参数过于敏感.

Black-Litterman模型就是基于此的改进. 其核心思想是将投资者对大类资产的观点 (主观观点) 与市场均衡收益率 (先验预期收益率)相结合,从而形成新的预期收益率(后验预期收益率). 这里的先验预期收益率的分布可以是贝叶斯推断中的先验概率密度函数的多元正态分布形式,投资者的主观观点就是贝叶斯推断中的似然函数(可以看作新的信息, 因为做出主观判断必然是从外界获取得到了这些资产的收益率变化信息), 而相应的, 后验预期收益率也可以从后验概率密度函数中得到. 具体的推导可以看我的这篇文章: 从贝叶斯定理到贝叶斯推断 .

BL模型的求解步骤包括下面几步:

(1) 使用历史数据估计预期收益率的协方差矩阵作为先验概率密度函数的协方差.

(2) 确定市场预期之收益率向量, 也就是先验预期收益之期望值. 作为先验概率密度函数的均值. 或者使用现有的期望值和方差来反推市场隐含的均衡收益率(Implied Equilibrium Return Vector), 不过在使用这种方法时, 需要知道无风险收益率 的大小.

(3) 融合投资人的个人观点,即根据历史数据(看法变量的方差)和个人看法(看法向量的均值)

(4) 修正后验收益.

是均衡收益率协方差的调整系数,可以根据信心水平来判断. 是历史资产收益率的协方差矩阵, P是投资者的观点矩阵, 是似然函数(即投资者观点函数)中的协方差矩阵,其值为 的对角阵, 是先验收益率的期望值.

(5) 投资组合优化: 将修正后的期望值与协方差矩阵即 重新代入Markowitz投资组合模型求解.

(1)定义求解函数,输入为投资者观点P,Q以及目前资产的市场收益率矩阵,输出为后验的市场收益率和协方差矩阵.

(2) 实列分析

我们继续研究 python实现资产配置(1)----Markowitz 投资组合模型 中的五支股票: 白云机场, 福建高速, 华夏银行, 生益科技和浙能电力. 假设现在分析师的观点为:

获取股票数据, 并且获得后验的均值和方差:

这时候,已经可以使用Markowitz模型进行资产的配置. 定义新的函数blminVar以求解资产配置权重. 该函数的输入变量为blacklitterman函数的输出结果, 以及投资人的目标收益率goalRet.假设目标收益率为年化70%,则goalRet = 0.7:

输出结果为:

0-5分别对应上面的五只股票.

如何用python实现网络图节点权重的添加以及如何把一个非连通的大网络图分成多个小网络图

networkx是python的一个库，它为图的数据结构提供算法、生成器以及画图工具。近日在使用ryu进行最短路径获取，可以通过该库来简化工作量。该库采用函数方式进行调用相应的api，其参数类型通常为图对象。

函数API的调用，按照以下步骤来创建构建图：

1.networkx的加载

在python中调用networkx通常只需要将该库导入即可

import networkx as nx

2.图对象的创建

networkx提供了四种基本图对象：Graph，DiGraph，MultiGraph，MultiDiGraph。

使用如下调用方式，可以创建以上四种图对象的空图。

G=nx.Graph()

G=nx.DiGraph()

G=nx.MultiGraph()

G=nx.MultiDiGraph()

在 networkx中，图的各个节点允许以哈希表对象来表示，而对于图中边的各个参量，则可以通过与边相关联的方式来标识，一般而言，对于权重，用weight作为keyword，而对于其他的参数，使用者可以采用任何除weight以外的keyword来命名。

3.在2中，创建的只是一副空图，为了得到一个有节点、有边的图，一般采用下面这个函数：

1

2

G.add_edge(1,2) #default edge data=1

G.add_edge(1,2) #specify edge data=0.9

add_edge()函数，该函数在调用时需要传入两个参数u和v，以及多个可选参数

u和v即图中的两个节点，如果图中不存在节点，在调用时会自动将这两个节点添加入内，同时构建两个节点之间的连接关系，可选参数通常指这条边的权重等关系参量。需要注意的是，如果图中已经存在了这条边，重新进行添加时会对这条边进行跟新操作（也就是覆盖了原有的信息）。

对于该函数，除了上述的构建方式以外，还有以下几种方式来创建边：

1

2

3

G.add_edge(*e) # single edge as tuple of two nodes

G.add_edge(1, 3, weight=7, capacity=15, length=342.7) #using many arguements to create edge

G.add_edges_from( [(1, 2)] ) # add edges from iterable container

有时候，当采用默认方式创建边以后，我们可能还会往边里面添加边的相关参数，这时候，可以采用下面的方式来更新边的信息：

1

2

3

4

5

#For non-string attribute keys, use subscript notation.

G.add_edge(1, 2)

G[1][2].update({0: 5}) #更新边的信息

G.edges[1, 2].update({0: 5}) #更新边的信息

#上述两种更新方式，择一选取即可

细心的朋友可能注意到我在写创建图的内容的时候，提到了add_edges_from（）函数，该函数也是用来创建边的，该方式与add_edges()略有不同，比之add_edges()采用一个一个节点的方式进行创建，它来的更为便利。这个函数在调用时，需要一个节点元组作为参数以及多个可选参数作为边的信息。你可以这么传递：

默认创建节点之间的边：

1

G.add_edges_from([(u,v)])

也可以这么写，在创建的同时添加信息：

1

G.add_edges_from([(3, 4), (1, 4)], label='WN2898')　

通过上述方式，就构建了一个3-4-1的图的连接，并给每条边打上了标签。

由此你就可以创建出自己的图模型了。

网站栏目：python权重函数例题,python随机数权重
分享路径：http://scyingshan.cn/article/hdiosc.html