numpy学习(二)

作者: pigdaqiang | 来源:发表于2020-02-13 22:23 被阅读0次

numpy 统计函数

从数组中查找最小元素, 最大元素, 百分位标准差, 和方差灯

numpy.amin()和numpy.amax()

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。

numpy.amax() 用于计算数组中的元素沿指定轴的最大值。

import numpy as np

a = np.array([[3,5,7],[8,4,3],[2,4,9]])
print ('原数组')
print (a)
print ('\n')
print ('调用amin()函数')
print (np.amin(a,1))
print ('\n')
print ('再次调用amin')
print (np.amin(a,0))
print ('调用amax')
print (np.amax(a))
print ('\n')
print ('再次调用amax')
print (np.amax(a, axis = 0))


原数组
[[3 5 7]
 [8 4 3]
 [2 4 9]]


调用amin()函数
[3 3 2]


再次调用amin
[2 4 3]
调用amax
9


再次调用amax
[8 5 9]

numpy.ptp()

计算元素最大值与最小值的差(最大值-最小值)

import numpy as np

a = np.array([[3,5,7],[8,4,3],[2,4,9]])
print (a)
print ('\n')
print ('调用ptp函数')
print (np.ptp(a))
print ('\n')
print ('沿轴1调用ptp函数')
print (np.ptp(a,axis = 1))
print ('\n')
print ('沿轴0调用ptp函数')
print (np.ptp(a,axis = 0))


[[3 5 7]
 [8 4 3]
 [2 4 9]]


调用ptp函数
7


沿轴1调用ptp函数
[4 5 7]


沿轴0调用ptp函数
[6 1 6]

numpy.percentile()

百分数是统计中使用的度量, 表示小于这个值的观察值的百分比.

numpy.percentile(a, q, axis)

a 输入数组

q 要计算的百分位数, 在0-100之间

axis 沿着它计算百分位数的轴

首先明确百分位数：

第 p 个百分位数是这样一个值，它使得至少有 p% 的数据项小于或等于这个值，且至少有 (100-p)% 的数据项大于或等于这个值。

举个例子：高等院校的入学考试成绩经常以百分位数的形式报告。比如，假设某个考生在入学考试中的语文部分的原始分数为 54 分。相对于参加同一考试的其他学生来说，他的成绩如何并不容易知道。但是如果原始分数54分恰好对应的是第70百分位数，我们就能知道大约70%的学生的考分比他低，而约30%的学生考分比他高。

这里的 p = 70。

import numpy as np

a = np.array([[10,7,4], [3,2,1]])
print (a)
print ('调用percentile函数')
# 50%的分位数就是a里排序之后的中位数
print (np.percentile(a, 50))
# axis为0 , 在纵列上求
print (np.percentile(a,50, axis = 0))
# 横行上求
print (np.percentile(a, 50, axis = 1))
# 维度不变
print (np.percentile(a, 50, axis = 1, keepdims = True))


[[10  7  4]
 [ 3  2  1]]
调用percentile函数
3.5
[ 6.5  4.5  2.5]
[ 7.  2.]
[[ 7.]
 [ 2.]]

numpy.median()

函数用于计算数组a中元素的中位数(中值)

import numpy as np

a = np.array([[30,65,70,],[80, 95, 10], [50, 90, 60]])
print ('原数组')
print (a)
print ('\n')
print ('调用median')
print (np.median(a))
print ('\n')
print ('沿轴0调用median函数')
print (np.median(a, axis = 0))
print ('\n')
print ('沿轴1调用median函数')
print (np.median(a, axis = 1))


原数组
[[30 65 70]
 [80 95 10]
 [50 90 60]]


调用median
65.0


沿轴0调用median函数
[ 50.  90.  60.]


沿轴1调用median函数
[ 65.  80.  60.]

numpy.mean()

函数返回数组中元素的算术平均值, 如果提供了轴, 则沿其计算, 算术平均值是沿轴的元素总和除以元素的数量

import numpy as np

a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print ('我们的数组是')
print (a)
print ('\n')
print ('调用mean')
print (np.mean(a))
print ('\n')
print ('沿轴0调用mean函数')
print (np.mean(a, axis = 0))
print ('\n')
print ('沿轴1 调用mean函数')
print (np.mean(a, axis = 1))


我们的数组是
[[1 2 3]
 [3 4 5]
 [4 5 6]]


调用mean
3.66666666667


沿轴0调用mean函数
[ 2.66666667  3.66666667  4.66666667]


沿轴1 调用mean函数
[ 2.  4.  5.]

numpy.average()

函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

该函数可以接受一个轴参数。如果没有指定轴，则数组会被展开。

加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。

考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)

import numpy as np

a = np.array([1,2,3,4])
print ('原数组')
print (a)
print ('\n')

print ('调用average函数')
print (np.average(a))
print ('\n')
# 不指定权重时相当于mean函数
wts = np.array([4,3,2,1])
print ("再次调用average函数")
print (np.average(a, weights = wts))
print ('\n')
# 如果returned参数设为true, 则返回权重的和
print ('权重的和:')
print (np.average([1,2,3,4], weights = [4,3,2,1], returned = True))


原数组
[1 2 3 4]


调用average函数
2.5


再次调用average函数
2.0


权重的和:
(2.0, 10.0)

多维数组中, 可以指定用于计算的轴

import numpy as np

a = np.arange(6).reshape(3,2)
print ('原数组')
print (a)
print ('\n')
print ('修改之后的数组')
wt = np.array([3,5])
print (np.average(a, axis = 1, weights = wt))
print ('\n')
print ('修改后的数组')
print (np.average(a, axis = 1, weights = wt, returned = True))


原数组
[[0 1]
 [2 3]
 [4 5]]


修改之后的数组
[ 0.625  2.625  4.625]


修改后的数组
(array([ 0.625,  2.625,  4.625]), array([ 8.,  8.,  8.]))

标准差std()

标准差是一组数据平均值分散程度的一种度量。

标准差是方差的算术平方根。

标准差公式如下：

std = sqrt(mean((x - x.mean())**2))

如果数组是 [1，2，3，4]，则其平均值为 2.5。因此，差的平方是 [2.25,0.25,0.25,2.25]，并且其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。

import numpy as np

print (np.std([1,2,3,4]))


1.11803398875

方差var()

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。

换句话说，标准差是方差的平方根。

import numpy as np

print (np.var([1,2,3,4]))

1.25

numpy排序, 条件刷选函数

NumPy 提供了多种排序的方法。这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。下表显示了三种排序算法的比较。

种类	速度	最坏情况	工作空间	稳定性
`'quicksort'`（快速排序）	1	`O(n^2)`	0	否
`'mergesort'`（归并排序）	2	`O(n*log(n))`	~n/2	是
`'heapsort'`（堆排序）	3	`O(n*log(n))`	0	否

numpy.sort()

返回输入数组的排序副本

numpy.sort(a, axis, kind, order)

a 要排序的数组

axis 沿着它排序数组的轴, 如果没有数组会被展开, 沿着最后的轴排序, axis = 0 按列排序, axis=1 按行

kind 默认为quicksort (快速排序)

order 如果数组包含字段, 则是要排序的字段

import numpy as np

a = np.array([[3,7],[9,1]])
print ('原数组')
print (a)
print ('\n')
print ('调用sort函数')
print (np.sort(a))
print ('\n')
print ('按列排序')
print (np.sort(a, axis = 0))
print ('\n')
# 在sort函数中排序字段
dt = np.dtype([('name','S10'), ('age', int)])
a = np.array([('raju', 21), ('anil', 25), ('ravi',17), ('amar', 27)], dtype = d
t)
print ('原数组')
print (a)
print ('\n')
print ('按name排序')
print (np.sort(a,order = 'name'))


原数组
[[3 7]
 [9 1]]


调用sort函数
[[3 7]
 [1 9]]


按列排序
[[3 1]
 [9 7]]


原数组
[(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]


按name排序
[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]

numpy.argsort()

返回数组值从小到大的索引值

import numpy as np

x = np.array([3,1,2])
print ('原数组')
print (x)
print ('\n')
print ('对x调用argsort函数')
y = np.argsort(x)
print (y)
print ('\n')
print ('以排序后的顺序重构原数组')
print (x[y])
print ('\n')
print ('使用循环重构原数组')
for i in y:
    print (x[i], end = ' ')


原数组
[3 1 2]


对x调用argsort函数
[1 2 0]


以排序后的顺序重构原数组
[1 2 3]


使用循环重构原数组
1 2 3

numpy.lexsort()

用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

这里举一个应用场景：小升初考试，重点班录取学生按照总成绩录取。在总成绩相同时，数学成绩高的优先录取，在总成绩和数学成绩都相同时，按照英语成绩录取…… 这里，总成绩排在电子表格的最后一列，数学成绩在倒数第二列，英语成绩在倒数第三列。

import numpy as np

nm = ('raju', 'anil', 'ravi', 'amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')
ind = np.lexsort((dv, nm))
print ('调用lexsort函数')
print (ind)
print ('\n')
print ('使用这个索引来获取排序后的数据')
print ([nm[i] + ', ' + dv[i] for i in ind])


调用lexsort函数
[3 1 0 2]


使用这个索引来获取排序后的数据
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

上面传入一个np.lexsort的是一个ruple, 排序是首先排nm, 顺序为amar, anil, raju, ravi 综上排序结果为[3 1 0 2]

msort sort_complex partition argpartition

函数	描述
msort(a)	数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。
sort_complex(a)	对复数按照先实部后虚部的顺序进行排序。
partition(a, kth[, axis, kind, order])	指定一个数，对数组进行分区
argpartition(a, kth[, axis, kind, order])	可以通过关键字 kind 指定算法沿着指定轴对数组进行分区

>>> import numpy as np
>>> np.sort_complex([5,3,6,2,1])
array([ 1.+0.j,  2.+0.j,  3.+0.j,  5.+0.j,  6.+0.j])
>>> np.sort_complex([1+2j, 2-1j, 3-2j, 3-3j, 3+5j])
array([ 1.+2.j,  2.-1.j,  3.-3.j,  3.-2.j,  3.+5.j])
>>>

import numpy as np

a = np.array([3,4,2,1])
print (np.partition(a,3)) # 将数组a中的所有元素(包括重复元素) 从小到大排列, 3 
表示的是排序数组索引为3的数字, 比该数字小的排在该数字前面, 比该数字大的排在该数
字的后面
print (np.partition(a, (1,3))) # 小于1的在前面, 大于3的在后面, 1和3之间的在中间
'''
找到数组的第三小(index=2)的值和第二大index=-2的值
'''
arr = np.array([46,57,23,39,1,10,0,120])
print (arr[np.argpartition(arr, 2)[2]])
print (arr[np.argpartition(arr, -2)[-2]])
'''
同时找到第三和第四小的值, 注意这里用[2,3]同时将第3和第四小的排序, 然后可以分别
通过下标[2]和[3]取得
'''
print (arr[np.argpartition(arr, [2,3])[2]])
print (arr[np.argpartition(arr, [2,3])[3]])


[2 1 3 4]
[1 2 3 4]
10
57
10
23

numpy.argmax()和numpy.argmin()

函数分别沿给定轴返回最大和最小值的索引

import numpy as np

a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print ('原数组')
print (a)
print ('\n')
print ('调用argmax函数')
print (np.argmax(a))
print ('\n')
print ('展开数组')
print (a.flatten())
print ('\n')
print ('沿轴0的最大值索引')
maxindex = np.argmax(a, axis = 0)
print (maxindex)
print ('\n')
print ('沿轴1的最大值索引')
maxindex = np.argmax(a, axis = 1)
print (maxindex)
print ('\n')
print ('调用argmin函数')
minindex = np.argmin(a)
print (minindex)
print ('\n')
print ('展开数组中的最小值')
print (a.flatten()[minindex])
print ('\n')
print ('沿轴0的最小值索引')
minindex = np.argmin(a, axis = 0)
print (minindex)
print ('\n')
print ('沿轴1的最小值索引')
minindex = np.argmin(a, axis = 1)
print (minindex)


原数组
[[30 40 70]
 [80 20 10]
 [50 90 60]]


调用argmax函数
7


展开数组
[30 40 70 80 20 10 50 90 60]


沿轴0的最大值索引
[1 2 0]


沿轴1的最大值索引
[2 0 1]


调用argmin函数
5


展开数组中的最小值
10


沿轴0的最小值索引
[0 1 1]


沿轴1的最小值索引
[0 2 0]

numpy.nonzero()

函数返回输入数组中非0元素的索引

import numpy as np

a = np.array([[30,40,0],[0,20,10],[50,0,60]])
print ('我们的数组是')
print (a)
print ('\n')
print ('调用nonzero函数')
print (np.nonzero(a))


我们的数组是
[[30 40  0]
 [ 0 20 10]
 [50  0 60]]


调用nonzero函数
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

numpy.where()

返回输入数组中满足给定条件的元素的索引

import numpy as np

x = np.arange(9.).reshape(3, 3)
print ('我们的数组是')
print (x)
print ('大于3的元素的索引')
y = np.where(x >3)
print (y)
print ('使用这些索引来获取满足条件的元素')
print (x[y])

我们的数组是
[[ 0.  1.  2.]
 [ 3.  4.  5.]
 [ 6.  7.  8.]]
大于3的元素的索引
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
使用这些索引来获取满足条件的元素
[ 4.  5.  6.  7.  8.]

numpy.extract()

根据某个条件从数组中抽取元素, 返回满条件的元素

import numpy as np

x = np.arange(9.).reshape(3,3)
print ('原数组')
print (x)
# 定义条件, 选择偶数元素
condition = np.mod(x,2) == 0
print ('按元素的条件值')
print (condition)
print ('使用条件提取元素')
print (np.extract(condition, x))


原数组
[[ 0.  1.  2.]
 [ 3.  4.  5.]
 [ 6.  7.  8.]]
按元素的条件值
[[ True False  True]
 [False  True False]
 [ True False  True]]
使用条件提取元素
[ 0.  2.  4.  6.  8.]

numpy字节交换

在几乎所有的机器上，多字节对象都被存储为连续的字节序列。字节顺序，是跨越多字节的程序对象的存储规则。

大端模式：指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。
小端模式：指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。

例如在 C 语言中，一个类型为 int 的变量 x 地址为 0x100，那么其对应地址表达式&x的值为 0x100。且x的四个字节将被存储在存储器的 0x100, 0x101, 0x102, 0x103位置。

字节交换

numpy.ndarray.byteswap()

将ndarray中每个元素中的字节进行大小端转换

import numpy as np

a = np.array([1, 256, 8755], dtype = np.int16)
print ('原数组')
print (a)
print ('以16进制表示内存中的数据')
print (map(hex, a))
# btypeswap()函数通过传入true来原地交换
print ('调用byteswap函数')
print (a.byteswap(True))
print ('16进制')
print (map(hex, a))
# 字节交换


原数组
[   1  256 8755]
以16进制表示内存中的数据
<map object at 0x7fc8ff886898>
调用byteswap函数
[  256     1 13090]
16进制
<map object at 0x7fc8fa7d2ef0>

副本和视图(深拷贝和浅拷贝)

副本是一个数据的完整的拷贝，如果我们对副本进行修改，它不会影响到原始数据，物理内存不在同一位置。

视图是数据的一个别称或引用，通过该别称或引用亦便可访问、操作原有数据，但原有数据不会产生拷贝。如果我们对视图进行修改，它会影响到原始数据，物理内存在同一位置。

视图一般发生在：

1、numpy 的切片操作返回原数据的视图。
2、调用 ndarray 的 view() 函数产生一个视图。

副本一般发生在：

Python 序列的切片操作，调用deepCopy()函数。
调用 ndarray 的 copy() 函数产生一个副本。

无复制

简单的赋值不会创建数组对象的副本。相反，它使用原始数组的相同id()来访问它。 id()返回 Python 对象的通用标识符，类似于 C 中的指针。

此外，一个数组的任何变化都反映在另一个数组上。例如，一个数组的形状改变也会改变另一个数组的形状。

矩阵(Matrix)

NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。

一个 [图片上传失败...(image-bf5fd9-1581603303589)]的矩阵是一个由[图片上传失败...(image-49809c-1581603303589)]行（row）[图片上传失败...(image-3e2b2c-1581603303589)]列（column）元素排列成的矩形阵列。

矩阵里的元素可以是数字、符号或数学式。以下是一个由 6 个数字元素构成的 2 行 3 列的矩阵：

[图片上传失败...(image-6461e6-1581603303589)]

matlib.empty()

返回一个新矩阵

numpy.matlib.empty(shape, dtype, order)

shape 定义新矩阵的整数或整数元组

dtype可选, 数据类型

order c或者f

import numpy.matlib
import numpy as np

print (np.matlib.empty((2,2)))
# 填充为随机数

[[  6.91000091e-310   4.68077452e-310]
 [  6.90999951e-310   0.00000000e+000]]

numpy.matlib.zeros()

创建一个以0填充的矩阵

import numpy.matlib
import numpy as np

print (np.matlib.zeros((2,2)))

[[ 0.  0.]
 [ 0.  0.]]

numpy.matlib.ones()

创建一个以1填充的矩阵

numpy.matlib.ones((2,2))

numpy.matlib.eye()

返回一个矩阵, 对角元素为1, 其他位置为0

numpy.matlib.eye(n, M, k, dtype)

n 返回矩阵的行数

M 返回矩阵的列数, 默认为n

k 对角线的索引

dtype数据类型

import numpy.matlib
import numpy as np

print (np.matlib.eye(n = 3, M = 4, k = 0, dtype = float))


[[ 1.  0.  0.  0.]
 [ 0.  1.  0.  0.]
 [ 0.  0.  1.  0.]]

numpy.matlib.identity()

返回给定大小的单位矩阵

单位矩阵是个方阵, 从左上角到右下角的对角线(称为主对角线)上的元素均为1, 除此以外全都为0

import numpy.matlib
import numpy as np

print (np.matlib.identity(5, dtype = float))
# 大小为5, 类型为浮点数

[[ 1.  0.  0.  0.  0.]
 [ 0.  1.  0.  0.  0.]
 [ 0.  0.  1.  0.  0.]
 [ 0.  0.  0.  1.  0.]
 [ 0.  0.  0.  0.  1.]]

numpy.matlib.rand()

创建一个给定大小的矩阵, 数据是随机填充的

numpy.matlib.rand(3,3)

矩阵是二维的, ndarray是一个n维数组, 两个对象是可互换的

import numpy.matlib
import numpy as np

i = np.matrix('1,2;3,4')
print (i)
[[1 2]
 [3 4]]

j = np.asarray(i)
print (j)

[[1 2]
 [3 4]]

k = np.asmatrix(j)
print (k)

[[1 2]
 [3 4]]

线性代数

NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能，可以看看下面的说明：

函数	描述
`dot`	两个数组的点积，即元素对应相乘。
`vdot`	两个向量的点积
`inner`	两个数组的内积
`matmul`	两个数组的矩阵积
`determinant`	数组的行列式
`solve`	求解线性矩阵方程
`inv`	计算矩阵的乘法逆矩阵

numpy.dot()

numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。

numpy.dot(a, b, out=None)

a ndarray数组

bndarray 数组

out ndarray 可选用来保存dot()的计算结果

import numpy.matlib
import numpy as np

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print (np.dot(a, b))
    
[[37 40]
 [85 92]]

计算公式

[[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]

numpy.vdot()

两个向量的点积, 如果第一个参数是复数, 那么它的共轭复数用于计算, 如果参数是多维数组, 他会被展开

import numpy as np

a = np.array([[1,2], [3, 4]])
b = np.array([[11, 12], [13, 14]])
# vdot 将数组展开计算内积
print (np.vdot(a, b))


130

计算公式

1*11 + 2*12 + 3*13 + 4*14 = 130

numpy.inner()

返回一维数组的向量内积, 对于更高的维度, 返回最后一个轴上的和的乘积

import numpy as np

print (np.inner(np.array([1,2,3]), np.array([0, 1,0])))
# 等价于1*0+2*1+3*0


2

多维数组::

import numpy as np

a = np.array([[1,2], [3, 4 ]])
print ('数组a')
print (a)
b = np.array([[11, 22], [13, 14]])
print ('数组b')
print (b)
print ('内积')
print (np.inner(a, b))


数组a
[[1 2]
 [3 4]]
数组b
[[11 22]
 [13 14]]
内积
[[ 55  41]
 [121  95]]
 
 1*11+2*12, 1*13+2*14 
3*11+4*12, 3*13+4*14

numpy.matmul

numpy.matmul 函数返回两个数组的矩阵乘积。虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。

另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。

对于二维数组，它就是矩阵乘法：

import numpy.matlib
import numpy as np

a = [[1, 0], [0, 1]]
b = [[4, 1], [2, 2]]
print (np.matmul(a,b))


[[4 1]
 [2 2]]

二维和一维运算

import numpy.matlib
import numpy as np

a = [[1, 0], [0, 1]]
b = [1, 2]
print (np.matmul(a, b))
print (np.matmul(b, a))


[1 2]
[1 2]

维度大于二

import numpy.matlib
import numpy as np

a = np.arange(8).reshape(2,2,2)
b = np.arange(4).reshape(2,2)
print (np.matmul(a, b))

[[[ 2  3]
  [ 6 11]]

 [[10 19]
  [14 27]]]

numpy.linalg.det()

numpy.linalg.det() 函数计算输入矩阵的行列式。

行列式在线性代数中是非常有用的值。它从方阵的对角元素计算。对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。

换句话说，对于矩阵[[a，b]，[c，d]]，行列式计算为 ad-bc。较大的方阵被认为是 2×2 矩阵的组合。


import numpy as np

a = np.array([[1, 2], [3, 4]])
print (np.linalg.det(a))


-2.0

import numpy as np

b = np.array([[6, 1, 1], [4, -2, 5], [2, 8, 7]])
print (b)
print (np.linalg.det(b))
print (6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2))


[[ 6  1  1]
 [ 4 -2  5]
 [ 2  8  7]]
-306.0
-306

numpy.linalg.solve()

给出了矩阵形式的线性方程的解

x + y + z = 6

2y + 5z = -4

2x + 5y - z = 27

如果矩阵成为A, X和B方程变为

AX = B

或

X = A^(-1)B

numpy.linalg.inv()

numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。

逆矩阵（inverse matrix）：设A是数域上的一个n阶矩阵，若在相同数域上存在另一个n阶矩阵B，使得： AB=BA=E ，则我们称B是A的逆矩阵，而A则被称为可逆矩阵。注：E为单位矩阵。

import numpy as np

x = np.array([[1, 2], [3, 4]])
y = np.linalg.inv(x)
print (x)
print (y)
print (np.dot(x, y))

[[1 2]
 [3 4]]
[[-2.   1. ]
 [ 1.5 -0.5]]
[[  1.00000000e+00   1.11022302e-16]
 [  0.00000000e+00   1.00000000e+00]]

import numpy as np

a = np.array([[1,1,1], [0, 2,5 ], [2,5,-1]])
print ("数组a")
print (a)
ainv = np.linalg.inv(a)
print ('a的逆矩阵')
print (ainv)
print ('矩阵b')
b = np.array([[6],[-4],[27]])
print (b)
print ('计算a^(-1)b')
x = np.linalg.solve(a, b)
print (x)
# 线性方向x=5 y=3 z=-2的解


数组a
[[ 1  1  1]
 [ 0  2  5]
 [ 2  5 -1]]
a的逆矩阵
[[ 1.28571429 -0.28571429 -0.14285714]
 [-0.47619048  0.14285714  0.23809524]
 [ 0.19047619  0.14285714 -0.0952381 ]]
矩阵b
[[ 6]
 [-4]
 [27]]
计算a^(-1)b
[[ 5.]
 [ 3.]
 [-2.]]

x = np.dot(ainv, b)

numpy IO

可以读写磁盘上的文本数据或者二进制数据. 为ndarray对象引入了一个简单的文本格式, npy

npy文件用于存储重建ndarray所需的数据, 图形, dtype和其他信息.

常用IO函数有:

load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。
savze() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。
loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)

numpy.save()

将数组保存到以.npy为扩展名的文件中

numpy.save(file, arr, allow_pickle=True, fix_imports=True)

file：要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上。
arr: 要保存的数组
allow_pickle: 可选，布尔值，允许使用 Python pickles 保存对象数组，Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。
fix_imports: 可选，为了方便 Pyhton2 中读取 Python3 保存的数据。

import numpy as np

a = np.array([1,2,3,4,5])
# 保存到outfile.npy文件上
np.save('outfile.npy', a)
# 保存到outfile2.npy文件上, 如果文件 路径末尾没有.npy, 则会自动加上
np.save('outfile2', a)


pig@deep:~/Desktop/note/python/numpy$ cat outfile.npy
�NUMPY�F{'descr': '<i8', 'fortran_order': False, 'shape': (5,), }            
����pig@deep:~/Desktop/note/python/numpy$ cat outfile2.npy 
�NUMPY�F{'descr': '<i8', 'fortran_order': False, 'shape': (5,), }            
����p

可以看出文件是乱码的，因为它们是 Numpy 专用的二进制格式后的数据。

我们可以使用 load() 函数来读取数据就可以正常显示了：

import numpy as np
b = np.load('outfile.npy')
print (b)


[1 2 3 4 5]

numpy.savez

将多个数组保存到以npz为拓展名的文件中

numpy.savez(file, *arg, **kwds)

file：要保存的文件，扩展名为 .npz，如果文件路径末尾没有扩展名 .npz，该扩展名会被自动加上。
args: 要保存的数组，可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 arr_0, arr_1, …　。
kwds: 要保存的数组使用关键字名称。

import numpy as np

a = np.array([[1,2,3], [4,5,6]])
b = np.arange(0,1.0,0.1)
c = np.sin(b)
# c使用了关键字参数sin_array
np.savez('savez.npz', a, b, sin_array = c)
r = np.load('savez.npz')
print (r.files) # 查看个数组名称
print (r['arr_0']) # 数组a
print (r['arr_1'])
print (r['sin_array']) # 数组c


['arr_1', 'sin_array', 'arr_0']
[[1 2 3]
 [4 5 6]]
[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]
[ 0.          0.09983342  0.19866933  0.29552021  0.38941834  0.47942554
  0.56464247  0.64421769  0.71735609  0.78332691]

savetxt()

是以简单的文本格式存储数据 , 对应的使用loadtxt函数来获取数据

np.loadtxt(FILENAME, dtype=int, delimiter='')
np.savetxt(FILENAME, a, fmt='%d', delimiter=",")

delimiter可以指定各种分隔符, 针对特定列的转换器函数, 需要跳过的行数等.

import numpy as np

a = np.array([1,2,3,4,5])
np.savetxt('out.txt', a)
b = np.loadtxt('out.txt')
print (b)


[ 1.  2.  3.  4.  5.]

使用delimiter参数:

import numpy as np

a = np.arange(0, 10, 0.5).reshape(4,-1)
np.savetxt('out2.txt', a, fmt="%d", delimiter="*") # 改为保存整数, 以逗号分隔
b = np.loadtxt("out2.txt", delimiter="*") # load时也要指定为相同符号分隔
print (b)


[[ 0.  0.  1.  1.  2.]
 [ 2.  3.  3.  4.  4.]
 [ 5.  5.  6.  6.  7.]
 [ 7.  8.  8.  9.  9.]]

matplotlib

Matplotlib 是 Python 的绘图库。它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。它也可以和图形工具包一起使用，如 PyQt 和 wxPython。

wim下安装matplotlib:

python -m pip install -U pip setuptools
python -m pip install matplotlib

linux下:

sudo apt-get install python-matplotlib

mac:

sudo python -mpip install matplotlib

查看是否安装完成:

python -m pip list | grep matplotlib
matplotlib                    2.2.4

实例

import numpy as np
from matplotlib import pyplot as plt

x = np.arange(1,11)
y = 2 * x + 5
plt.title("test demo")
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x, y)
plt.show()

plt1

以上实例中, np.arange()函数创建x轴上的值, y轴上对应值存储在另一个数组对象y中, 这些值使用matplotlib软件包的pyplot子模块plot()函数来绘制, 由show()函数来显示

图形中文显示

默认情况下不支持中文, 可以使用以下方法(下载字体)https://www.fontpalace.com/font-details/SimHei/

SimHei.ttf文件放在当前执行的代码文件中.

import numpy as np 
from matplotlib import pyplot as plt 
import matplotlib
 
# fname 为 你下载的字体库路径，注意 SimHei.ttf 字体的路径
zhfont1 = matplotlib.font_manager.FontProperties(fname="SimHei.ttf") 
 
x = np.arange(1,11) 
y =  2  * x +  5 
plt.title("测试", fontproperties=zhfont1) 
 
# fontproperties 设置中文显示，fontsize 设置字体大小
plt.xlabel("x 轴", fontproperties=zhfont1)
plt.ylabel("y 轴", fontproperties=zhfont1)
plt.plot(x,y) 
plt.show()

此外还可以使用系统字体:

from matplotlib import pyplot as plt
import matplotlib
a = sorted([f.name for f in matplotlib.font_manager.fontManager.ttflist])
for i in a:
    print (i)
    
打印出你的font_manage的ttflist中所有注册的名字, 找一个看中文字体例如:STFangsong(仿宋)然后添加以下代码即可:
plt.rcParams['font.family']=['STFangsong']

实例:

import numpy as np
from matplotlib import pyplot as plt
import matplotlib

# 导入系统字体库
plt.rcParams['font.family']=['CESI_HT_GB18030']
x = np.arange(0, 2 * np.pi, 0.001)
y = np.sin(x)
plt.title("测试")
plt.xlabel("x轴")
plt.ylabel("y轴")
plt.plot(x, y)
plt.show()

plt2

作为线性图的替代，可以通过向 plot() 函数添加格式字符串来显示离散值。可以使用以下格式化字符。

字符	描述
`'-'`	实线样式
`'--'`	短横线样式
`'-.'`	点划线样式
`':'`	虚线样式
`'.'`	点标记
`','`	像素标记
`'o'`	圆标记
`'v'`	倒三角标记
`'^'`	正三角标记
`'<'`	左三角标记
`'>'`	右三角标记
`'1'`	下箭头标记
`'2'`	上箭头标记
`'3'`	左箭头标记
`'4'`	右箭头标记
`'s'`	正方形标记
`'p'`	五边形标记
`'*'`	星形标记
`'h'`	六边形标记 1
`'H'`	六边形标记 2
`'+'`	加号标记
`'x'`	X 标记
`'D'`	菱形标记
`'d'`	窄菱形标记
`'\|'`	竖直线标记
`'_'`	水平线标记

以下是颜色的缩写：

字符	颜色
`'b'`	蓝色
`'g'`	绿色
`'r'`	红色
`'c'`	青色
`'m'`	品红色
`'y'`	黄色
`'k'`	黑色
`'w'`	白色

要显示圆来代表点，而不是上面示例中的线，请使用 ob 作为 plot() 函数中的格式字符串。

import numpy as np
from matplotlib import pyplot as plt

x = np.arange(0, 2 * np.pi, 0.1)
y = np.cos(x)
plt.title("sin")
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x, y, ".b")
plt.show()

plt3.png

绘制正弦波

import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0, 3 * np.pi, 0.1)
y = np.sin(x)
plt.title("sine")
plt.plot(x, y, '.b')
plt.show()

subplot()

允许在同一图中绘制不同的东西

正弦余弦

import numpy as np
import matplotlib.pyplot as plt

# 计算正弦和余弦曲线上的点x和y坐标
x = np.arange(0, 2 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)

# 建立subplot网格 高为1, 宽为2
# 激活第一个subplot
plt.subplot(1, 2, 1)
# 绘制第一个图像
plt.plot(x, y_sin)
plt.title("sine")

# 激活第二个subplot并绘制第二个图像
plt.subplot(1, 2, 2)
plt.plot(x, y_cos)
plt.title("cosine")

# 展示图像
plt.show()

plt.subplot(1,2,1) 不同参数的区别

plt4

bar()

pyplot 子模块提bar()函数来生成条形图

实现两组x 和y数组的条形图

import matplotlib.pyplot as plt

x = [5, 8, 10]
y = [12, 16, 6]
x2 = [6, 9, 11]
y2 = [6, 15, 7]
plt.bar(x, y, align = 'center')
plt.bar(x2, y2, color = 'g', align = 'center')
plt.title('bar graph')
plt.ylabel('Y axis')
plt.xlabel('x axis')
plt.show()

bar

numpy.histogram()

是数据频率分布的图形表示, 水平尺寸相等的矩形对应于类间隔, 称为bin, 变量height对应与频率

将输入数组和bin作为两个参数, bin数组中连续元素用作每个bin的边界

a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
np.histogram(a,bins =  [0,20,40,60,80,100]) 
hist,bins = np.histogram(a,bins =  [0,20,40,60,80,100])  
print (hist) 
print (bins)

[3 4 5 2 1]
[  0  20  40  60  80 100]

plt()

Matplotlib 可以将直方图的数字表示转换为图形。 pyplot 子模块的 plt() 函数将包含数据和 bin 数组的数组作为参数，并转换为直方图。

from matplotlib import pyplot as plt 
import numpy as np  
 
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) 
plt.hist(a, bins =  [0,20,40,60,80,100]) 
plt.title("histogram") 
plt.show()

参考教程
 个人博客
 numpy学习(一)