Py修行路 NumPy模块基本用法

  NumPy系统是Python的一种开源的数值计算扩展,一个用python实现的科学计算包。这种工具可用来存储和处理大型矩阵,比Python自身的嵌套列表(nested list structure)结构要高效的多(该结构也可以用来表示矩阵(matrix))。是python中的一款高性能,用于科学计算和数据分析的基础包。

  NumPy的主要对象是一个强大的、同种元素的、N维数组对象Array。这是一个所有的元素都是一种类型、通过一个正整数元组索引的元素表格(通常是元素是数字)。NumPy的数组类被称作 ndarray 。通常被称作数组。

  NumPy是高性能科学计算和数据分析的基础包。它是pandas等其他各种工具的基础。
  NumPy的主要功能:ndarray,一个多维数组结构,高效且节省空间;无需循环对整组数据进行快速运算的数学函数

安装方法:pip install numpy

引用方式:import numpy as np

ndarray  

  ndarray(以下简称数组)是numpy的数组类对象,需要注意的是:它是同构的,也就是说其中的所有元素必须是相同的类型【用于科学计算都是数字类型:整数,小数】。其中每个数组都有一个shape(维度,几行几列)和dtype(数据类型)。

  创建一个ndarray对象很简单,你可以使用 array 函数从常规的Python列表和元组创造数组,只要将一个list作为参数即可。所创建的数组类型由原序列中的元素类型推导而来。在NumPy中维度(dimensions)叫做轴(axis),轴的个数叫做秩(rank)。【0为行,1为列 用于做某一行或列操作】

  例如,在3D空间一个点的坐标 [1, 2, 3] 是一个秩为1的数组,因为它只有一个轴。那个轴长度为3.又例如,在以下例子中,数组的秩为2(它有两个维度).第一个维度长度为2,第二个维度长度为3.

array([[ 1., 0., 0.],
[ 0., 1., 2.]])

ndarray对象常用属性

ndarray.ndim
#数组轴的个数,在python的世界中,轴的个数被称作秩 ndarray.shape
#数组的维度。这是一个指示数组在每个维度上大小的整数元组。例如一个n排m列的矩阵,它的shape属性将是(2,3),这个元组的长度显然是秩,即维度或者ndim属性 ndarray.size
#数组元素的总个数,等于shape属性中元组元素的乘积。 ndarray.dtype
#一个用来描述数组中元素类型的对象,可以通过创造或指定dtype使用标准Python类型。另外NumPy提供它自己的数据类型。 ndarray.itemsize
#数组中每个元素的字节大小。例如,一个元素类型为float64的数组itemsiz属性值为8(=64/8),又如,一个元素类型为complex32的数组item属性为4(=32/8). ndarray.data
#包含实际数组元素的缓冲区,通常我们不需要使用这个属性,因为我们总是通过索引来使用数组中的元素。

创建ndarray方法:

array()	将列表转换为数组,可选择显式指定dtype
arange() range的numpy版,支持浮点数
linspace() 类似arange(),第三个参数为数组长度(数组元素个数)
zeros() 根据指定形状和dtype创建全0数组
ones() 根据指定形状和dtype创建全1数组
empty() 根据指定形状和dtype创建空数组(随机值)
reshape() 把一个arry类型的一维数组转成多维数组;参数为元组
eye() 根据指定边长和dtype创建单位矩阵

常用属性:

T	数组的转置(对高维数组而言)
dtype 数组元素的数据类型
dtype:bool_, int(8,16,32,64), uint(8,16,32,64), float(16,32,64)
数组的类型转换:astype()
size 数组元素的个数
ndim 数组秩的个数
shape 数组的维度大小(以元组形式)

数组的创建

  创建一个ndarray对象很简单,只要将一个list作为参数即可。

import numpy as np #引入numpy库
#创建一维的narray对象
a = np.array([1,2,3,4,5])
#创建二维的narray对象
a1 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
#创建多维对象以此类推 #执行结果
In [1]: import numpy as np
...: a = np.array([1,2,3,4,5])
...: a1 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
...:
In [2]: a,a1
Out[2]:
(array([1, 2, 3, 4, 5]), array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10]]))

数组的常用属性

import numpy as np #引入numpy库
a = np.array([1,2,3,4,5])
a1 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
a2 = np.array([[1.0,2.4,3.5],[8.1,6.3,7.6]])
print(type(a),type(a1),type(a2)) #查看数据类型
print(a.dtype,a1.dtype,a2.dtype) #查看数组的数据类型
print(a.ndim,a1.ndim,a2.ndim) #查看数组秩的个数
print(a1.size,a2.size) #数组内元素的总个数
print(a1.T) #数组转置
#执行结果
In [5]: import numpy as np #引入numpy库
...: a = np.array([1,2,3,4,5])
...: a1 = np.array([[1,2,3,4,5],[6,7,8,9,10]])
...: a2 = np.array([[1.0,2.4,3.5],[8.1,6.3,7.6]])
...: print(type(a),type(a1),type(a2)) #查看数据类型
...: print(a.dtype,a1.dtype,a2.dtype) #查看数组的数据类型
...: print(a.ndim,a1.ndim,a2.ndim) #查看数组秩的个数
...: print(a1.size,a2.size) #数组内元素的总个数
...: print(a1.T) #数组转置
...:
<class 'numpy.ndarray'> <class 'numpy.ndarray'> <class 'numpy.ndarray'>
int32 int32 float64
1 2 2
10 6
[[ 1 6]
[ 2 7]
[ 3 8]
[ 4 9]
[ 5 10]]
print(a.shape,a1.shape,a2.shape) #查看数组的维度 结果返回一个元组
n = a1.shape #获取数组a1的维度
print(n[0]) #获得行数
print(n[1]) #获得列数
#执行结果
In [6]: print(a.shape,a1.shape,a2.shape) #查看数组的维度 结果返回一个元组
...: n = a1.shape #获取数组a1的维度(几行几列)
...: print(n[0]) #获得行数
...: print(n[1]) #获得列数
...:
(5,) (2, 5) (2, 3)
2
5

数组类型可以在创建时可以指定

a = np.array([1,2,3,4,5],dtype='float64')
#执行结果
In [8]: a = np.array([1,2,3,4,5],dtype='float64') In [9]: a
Out[9]: array([ 1., 2., 3., 4., 5.])

利用函数创建数组
  1、为了创建一个数列,NumPy提供一个类似arange的函数返回一维数组而不是列表,同理也是顾头不顾尾:

import numpy as np
a = np.arange(12)
a1 = np.arange(0,12,3) #有步长的话,必须指定取值范围
#执行结果:
In [24]: import numpy as np
...: a = np.arange(12)
...: a1 = np.arange(0,12,3) #有步长的话,必须指定取值范围
...:
In [26]: a
Out[26]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) In [27]: a1
Out[27]: array([0, 3, 6, 9])

  2.1、也可以使用reshape()方法,把一个arry类型的一维数组转成多维数组。不管怎么得到的数据,只要是一维数组都可以使用reshape转换。【参数为元组】 但测试发现是普通数字或是列表也可以。

In [25]: a = np.arange(12)
#建立二维
In [28]: a.reshape(3,4) #3行4列
Out[28]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
#建立三维
In [32]: a.reshape([2,2,3])
Out[32]:
array([[[ 0, 1, 2],
[ 3, 4, 5]], [[ 6, 7, 8],
[ 9, 10, 11]]])
In [33]: a.reshape(2,2,3)
Out[33]:
array([[[ 0, 1, 2],
[ 3, 4, 5]], [[ 6, 7, 8],
[ 9, 10, 11]]])

  2.2、同时arange的步长可以为小数,也就是说我们可以得到浮点类型的数组,默认的dtype='float64';当需要生成浮点型数组时,需要指定范围

In [34]: b = np.arange(0,5,0.5)
In [35]: b
Out[35]: array([ 0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5]) In [39]: b.reshape((2,5))
Out[39]:
array([[ 0. , 0.5, 1. , 1.5, 2. ],
[ 2.5, 3. , 3.5, 4. , 4.5]])

  2.3、当 arange 使用浮点数参数时,由于有限的浮点数精度,通常无法预测获得的元素个数。因此,最好使用函数 linspace 去接收我们想要数组元素总个数来代替用range指定的步长。
  语法:linspace(a,b,size) 把某个范围分成多少份,size代表这个元组的大小或元组内的总个数。取值范围左右兼顾

In [56]: c = np.linspace(1,5,5)
In [57]: c
Out[57]: array([ 1., 2., 3., 4., 5.]) In [58]: c = np.linspace(0,2,6)
In [59]: c
Out[59]: array([ 0. , 0.4, 0.8, 1.2, 1.6, 2. ]) In [60]: c = np.linspace(0,2,5)
In [61]: c
Out[61]: array([ 0. , 0.5, 1. , 1.5, 2. ])

  通常,数组的元素开始都是未知的,但是它的大小已知。因此,NumPy提供了一些使用占位符创建数组的函数。这最小化了扩展数组的需要和高昂的运算代价。函数 zeros 创建一个全是0的数组,函数 ones 创建一个全1的数组,函数 empty 创建一个内容随机并且依赖于内存状态的数组。默认创建的数组类型(dtype)都是float64。

  ones创建全1矩阵
  zeros创建全0矩阵
  eye创建单位矩阵 (对角线)
  empty创建空矩阵(实际有值)

In [1]: import numpy as np

In [2]: a_ones = np.ones((3,4))# 创建3*4的全1矩阵
In [3]: a_ones
Out[3]:
array([[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]]) In [4]: a_zeros = np.zeros((3,4))# 创建3*4的全0矩阵
In [5]: a_zeros
Out[5]:
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]]) In [7]: a_eyes = np.eye((3))# 创建3阶单位矩阵
In [8]: a_eyes
Out[8]:
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]]) In [9]: a_empty = np.empty((3,4))# 创建3*4的空矩阵
In [10]: a_empty
Out[10]:
array([[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]])

  注意:使用ones,zeros,eys创建数组的时候,是在内存中开辟一块空间,然后在里边传值;而empty仅仅只是在内存中开辟一块空间,根据python的回收机制,当某块内存某段时间内不使用的话,python就会把这块内存释放但内部数据还未清除,如果此时利用empty创建一个数组而又不传值,他就会把这块内存内存储的数据显示出来(显示的数据随机)。

数组的索引及切片

  一维数组可以被索引、切片和迭代,就像列表一样;而多维数组是每行每列都有一个索引,当通过索引去取值的话,需要先取某一行数组然后再去取这一行某个值。

  当切片取值的时候,一维数组和列表操作完全一致,而多维数组切片,中括号内需要传递两个切片索引,中间以逗号隔开,第一部分代表是对行切,第二部分代表是对列切!

  与列表相同的是:当少于轴数的索引被提供时,缺失的索引被认为是整个切片;

#一维数组索引及切片操作
In [1]: import numpy as np
In [2]: a = np.arange(12) In [3]: a
Out[3]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
#索引
In [4]: a[0]
Out[4]: 0 In [5]: a[-1]
Out[5]: 11
#切片
In [6]: a[2:7]
Out[6]: array([2, 3, 4, 5, 6]) In [7]: a[7:]
Out[7]: array([ 7, 8, 9, 10, 11]) In [8]: a[::-1]
Out[8]: array([11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) #多维数组索引及切片操作
In [1]: import numpy as np
In [2]: b = np.arange(12).reshape((3,4)) In [3]: b
Out[3]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
#取多维数组的某行
In [4]: b[0]
Out[4]: array([0, 1, 2, 3]) In [5]: b[2]
Out[5]: array([ 8, 9, 10, 11])
#取数组内某一值(坐标为第3行和3列的数据)
In [6]: b[2][2]
Out[6]: 10
#多维数组切片
In [14]: b
Out[14]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]) In [15]: b[0:1]
Out[15]: array([[0, 1, 2, 3]]) In [16]: b[0:2]
Out[16]:
array([[0, 1, 2, 3],
[4, 5, 6, 7]]) #要求:取第1,2列前两行数据
#错误示范
In [17]: b[0:2][0:2]
Out[17]:
array([[0, 1, 2, 3],
[4, 5, 6, 7]]) In [18]: b[0:2][2]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-18-9d1e92fd5c9c> in <module>()
----> 1 b[0:2][2] IndexError: index 2 is out of bounds for axis 0 with size 2
#正确示范
In [19]: b[0:2,2]
Out[19]: array([2, 6]) In [20]: b[0:2,:2]
Out[20]:
array([[0, 1],
[4, 5]])

注意:

  1、数组也可以通过索引赋值;
  2、多维数组通过索引取值的话,如果是写的是一个中括号,那取的是这个多维数组中的某一行;要取某一值的话,就需要在这行的数据上再通过索引取值。
当对多维数组进行切片的时候,如果按照索引的方式操作的话,第一次的切片操作得到的还是一个多维数组,再进行第二次切片的时候,操作的对象是切片得到的多维数组,所以说会出现超出索引范围或是结果不对的情况。要得到多维数组某行某列的值就需要只针对这个多维数组操作,把对行和列的切片放在一起,中间以逗号隔开。切片内,[,]逗号代表分割,左边是行,右边是列

切片中,关于视图与拷贝问题:

  数组的切片与列表不同,数组切片时并不会自动复制,而是通过视图方法创造一个新的数组对象指向同一数据,当在切片数组上进行修改会影响原数组。(类似深拷贝)
  相应的解决办法就是通过.copy()的方式,把要切片得到的数据拷贝一份,这样再对切片数组操作的时候就不会影响原数组。(类似浅拷贝)

In [21]: b
Out[21]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]) #影响测试
In [22]: c = b[:,1:3]
In [23]: c
Out[23]:
array([[ 1, 2],
[ 5, 6],
[ 9, 10]]) In [24]: c[0][0]=11
In [25]: c
Out[25]:
array([[11, 2],
[ 5, 6],
[ 9, 10]]) In [26]: b
Out[26]:
array([[ 0, 11, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
#非影响 copy()数据测试
In [29]: d = b[:,2:].copy() In [30]: d
Out[30]:
array([[ 2, 3],
[ 6, 7],
[10, 11]]) In [31]: d[0][1] =33
In [32]: d
Out[32]:
array([[ 2, 33],
[ 6, 7],
[10, 11]]) In [33]: b
Out[33]:
array([[ 0, 11, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])

布尔索引
  原理:多维数组特有的一种索引,会以索引内的条件对数组内的每个元素进行判断,返回一个布尔数组;然后将同样大小的布尔数组传进索引,会返回一个由所有True对应位置的元素的数组。

#生成一个多维数组
In [34]: a = np.arange(12).reshape((3,4))
In [35]: a
Out[35]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
#得到布尔数组
In [36]: a>5
Out[36]:
array([[False, False, False, False],
[False, False, True, True],
[ True, True, True, True]], dtype=bool)
#通过布尔数组获取数组内所有大于5的数
In [37]: a[a>5]
Out[37]: array([ 6, 7, 8, 9, 10, 11])

布尔索引进阶 (布尔数组和逻辑运算【与 &,或 |,非 ~】)

In [38]: a
Out[38]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]) #选出数组中所有大于5的偶数。
In [39]: a[(a>5) & (a%2==0)]
Out[39]: array([ 6, 8, 10]) #选出数组中所有大于5的数和偶数。
In [40]: a[(a>5) | (a%2==0)]
Out[40]: array([ 0, 2, 4, 6, 7, 8, 9, 10, 11]) #选出数组中所有小于5的偶数。
In [43]: a[~(a>5) & (a%2==0)]
Out[43]: array([0, 2, 4])
#选出数组中所有大于5的奇数。
In [44]: a[(a>5) & (~(a%2==0))]
Out[44]: array([ 7, 9, 11])

花式索引:
  按照对应位置组成一个列表,逗号隔开;然后这个数组通过这个索引列表取出元素,组成新的数组。

#对于一个数组,选出其第1,3,4,6,7个元素,组成新的数组。
In [56]: b = np.arange(5,20)
In [57]: b
Out[57]: array([ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]) In [58]: b[[1,2,3,4,6,7]]
Out[58]: array([ 6, 7, 8, 9, 11, 12]) #对一个二维数组,选出其第一列和第三列,组成新的二维数组。
#创建一个二维数组
In [61]: a = np.arange(10).reshape(2,5)
In [62]: a
Out[62]:
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
#切片截取第一和第三列组成新的数组
In [64]: a[:,[0,2]]
Out[64]:
array([[0, 2],
[5, 7]])

数组运算

3.1、常用数组运算符
  大小相等的数组之间做任何算术运算都会将运算应用到元素级别。

运算符	说明
+ 矩阵对应元素相加
- 矩阵对应元素相减
* 矩阵对应元素相乘
/ 矩阵对应元素相除,如果都是整数则取商
% 矩阵对应元素相除后取余数
** 矩阵每个元素都取n次方,如**2:每个元素都取平方

注意:
  计算越界问题:当对整数进行乘法或是阶乘运算时,可能最后得到的结果超出了数组定义的数据类型范围,出现数据不正确的情况;
  解决办法:把元组内的数据转成浮点型,然后再做计算,结果会以科学计算法的形式展示。

In [12]: arr = np.arange(9).reshape((3,3))

In [13]: arr
Out[13]:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]]) In [14]: arr+1
Out[14]:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]) In [15]: arr*2
Out[15]:
array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]]) In [16]: arr**2
Out[16]:
array([[ 0, 1, 4],
[ 9, 16, 25],
[36, 49, 64]], dtype=int32) In [17]: arr1 = np.arange(9,18).reshape((3,3)) In [18]: arr1
Out[18]:
array([[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17]]) In [19]: arr/arr1
Out[19]:
array([[ 0. , 0.1 , 0.18181818],
[ 0.25 , 0.30769231, 0.35714286],
[ 0.4 , 0.4375 , 0.47058824]]) In [20]: arr+arr1
Out[20]:
array([[ 9, 11, 13],
[15, 17, 19],
[21, 23, 25]])

通用函数:
  通用函数:不用循环就能处理数组中所有的元素完成运算的函数
  明确两点:
    inf 无限大 例:5/0
    nan 不是数【not a number】 例:0/0
 常见通用函数:
  一元函数:

abs(绝对值),
sqrt,开跟号
exp,
log,
ceil, 向上取整
floor, 向下取整
rint/round,四舍五入变整数:
trunc, 向0取整,接近0的整数
modf, 把一个浮点类型数组转换成两个数组:一个是小数数组,一个是整数数组
isnan(判断数据类型是否是nan【not a number】),
isinf(判断数据类型那个是否是inf),
cos,
sin,
tan,

示例代码:

In [3]: a = np.arange(0,3,0.2)
In [4]: a
Out[4]:
array([ 0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ,
2.2, 2.4, 2.6, 2.8]) In [7]: np.ceil(3.4)
Out[7]: 4.0 In [8]: np.floor(3.4)
Out[8]: 3.0 In [9]: np.ceil(-3.4)
Out[9]: -3.0 In [10]: np.floor(-3.4)
Out[10]: -4.0 In [11]: np.trunc(-3.4)
Out[11]: -3.0 In [12]: np.trunc(3.4)
Out[12]: 3.0 In [13]: np.round(a)
Out[13]:
array([ 0., 0., 0., 1., 1., 1., 1., 1., 2., 2., 2., 2., 2.,
3., 3.]) In [14]: np.modf(a)
Out[14]:
(array([ 0. , 0.2, 0.4, 0.6, 0.8, 0. , 0.2, 0.4, 0.6, 0.8, 0. ,
0.2, 0.4, 0.6, 0.8]),
array([ 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 2., 2., 2.,
2., 2.])) In [15]: b = np.array([1,2,3,4,5])
In [16]: c = np.array([1,2,3,4,0]) In [17]: d = b/c
C:\Program Files\Python36\Scripts\ipython:1: RuntimeWarning: divide by zero encountered in
true_divide In [19]: d
Out[19]: array([ 1., 1., 1., 1., inf])
#判断是不是inf返回布尔值
In [20]: np.isinf(d)
Out[20]: array([False, False, False, False, True], dtype=bool)
#使用布尔索引,取不是inf的元素
In [21]: d[~np.isinf(d)]
Out[21]: array([ 1., 1., 1., 1.]) In [26]: a = np.array([1,2,3,4,0])
In [27]: b = np.array([1,2,3,4,0]) In [28]: c = a/b
C:\Program Files\Python36\Scripts\ipython:1: RuntimeWarning: invalid value encountered in
true_divide In [29]: c
Out[29]: array([ 1., 1., 1., 1., nan])
#判断是不是nan返回布尔值
In [30]: np.isnan(c)
Out[30]: array([False, False, False, False, True], dtype=bool)
#使用布尔索引,取不是nan的元素
In [32]: c[~np.isnan(c)]
Out[32]: array([ 1., 1., 1., 1.])

二元函数:

add, 加
substract,减
multiply, 乘
divide,除
power, 平方
mod,
maximum, 两数组对应位置上的元素相比较,取最大的数,组成一个新数组
mininum, 两数组对应位置上的元素相比较,取最小的数,组成一个新数组
In [1]: import numpy as np
#定义两个数组
In [2]: a = np.array([1,3,2,4,5])
In [3]: b = np.array([3,2,1,5,4]) In [6]: a
Out[6]: array([1, 3, 2, 4, 5])
In [7]: b
Out[7]: array([3, 2, 1, 5, 4])
#两比较取最大
In [8]: np.maximum(a,b)
Out[8]: array([3, 3, 2, 5, 5])
#两比较取最小
In [9]: np.minimum(a,b)
Out[9]: array([1, 2, 1, 4, 4])

NumPy 中数学和统计方法

常用函数:
sum 求和
umsum 求累计和 -- 当前位置的元素与前面元素相加的和
mean 求平均数
std 求标准差
var 求方差 -- 每个数到平均数的差的平方和再取平均值
min 求最小值 - 一个数组内最小值
max 求最大值 - 一个数组内最大值
argmin 求最小值索引 --一个数组内最小值下标
argmax 求最大值索引 --一个数组内最大值下标

示例代码:

最大最小值
获得矩阵中元素最大最小值的函数分别是max和min,可以获得整个矩阵、行或列的最大最小值。 import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.max()) #获取整个矩阵的最大值 结果: 6
print(a.min()) #结果:1 # 可以指定关键字参数axis来获得行最大(小)值或列最大(小)值
# axis=0 行方向最大(小)值,即获得每列的最大(小)值
# axis=1 列方向最大(小)值,即获得每行的最大(小)值 print(a.max(axis=0)) # 结果为 [4 5 6]
print(a.max(axis=1)) # 结果为 [3 6] # 要想获得最大最小值元素所在的位置,可以通过argmax函数来获得
print(a.argmax(axis=1)) # 结果为 [2 2] 平均值
获得矩阵中元素的平均值可以通过函数mean()。同样地,可以获得整个矩阵、行或列的平均值。 import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.mean()) #结果为: 3.5 # 同样地,可以通过关键字axis参数指定沿哪个方向获取平均值
print(a.mean(axis=0)) # 结果 [ 2.5 3.5 4.5]
print(a.mean(axis=1)) # 结果 [ 2. 5.] 方差
方差的函数为var(),方差函数var()相当于函数mean(abs(x - x.mean())**2),其中x为矩阵。 import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.var()) # 结果 2.91666666667
print(a.var(axis=0)) # 结果 [ 2.25 2.25 2.25]
print(a.var(axis=1)) # 结果 [ 0.66666667 0.66666667] 标准差
标准差的函数为std()。 std()相当于sqrt(mean(abs(x - x.mean())**2)),或相当于sqrt(x.var())。 import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.std()) # 结果 1.70782512766
print(a.std(axis=0)) # 结果 [ 1.5 1.5 1.5]
print(a.std(axis=1)) # 结果 [ 0.81649658 0.81649658] 中值
中值指的是将序列按大小顺序排列后,排在中间的那个值,如果有偶数个数,则是排在中间两个数的平均值。
例如序列[5,2,6,4,2],按大小顺序排成 [2,2,4,5,6],排在中间的数是4,所以这个序列的中值是4。
又如序列[5,2,6,4,3,2],按大小顺序排成 [2,2,3,4,5,6],因为有偶数个数,排在中间两个数是3、4,所以这个序列中值是3.5。
中值的函数是median(),调用方法为numpy.median(x,[axis]),axis可指定轴方向,默认axis=None,对所有数去中值。 import numpy as np
x = np.array([[1,2,3],[4,5,6]])
print(np.median(x)) # 对所有数取中值
# 结果 3.5 print(np.median(x,axis=0)) # 沿第一维方向取中值
# 结果 [ 2.5 3.5 4.5] print(np.median(x,axis=1)) # 沿第二维方向取中值
# 结果[ 2. 5.] 求和
矩阵求和的函数是sum(),可以对行,列,或整个矩阵求和 import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.sum()) # 对整个矩阵求和
# 结果 21
print(a.sum(axis=0)) # 对行方向求和
# 结果 [5 7 9]
print(a.sum(axis=1)) # 对列方向求和
# 结果 [ 6 15] 累积和
某位置累积和指的是该位置之前(包括该位置)所有元素的和。
例如序列[1,2,3,4,5],其累计和为[1,3,6,10,15],即第一个元素为1,第二个元素为1+2=3,……,第五个元素为1+2+3+4+5=15。
矩阵求累积和的函数是cumsum(),可以对行,列,或整个矩阵求累积和。 import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.cumsum()) # 对整个矩阵求累积和
# 结果 [ 1 3 6 10 15 21]
print(a.cumsum(axis=0)) # 对行方向求累积和
# 结果
[[1 2 3]
[5 7 9]]
print(a.cumsum(axis=1)) # 对列方向求累积和
# 结果
[[ 1 3 6]
[ 4 9 15]]

random 生成随机数

  实质上就是重写了Python的random模块

常用函数
rand 给定形状产生随机数组(0到1之间的数)
randint 给定形状产生随机整数 (数组)
choice 给定形状产生随机选择
shuffle 与random.shuffle相同 (洗牌)
uniform 给定形状产生随机小数(数组)

示例代码:

In [66]: import numpy as np

#rand测试
In [67]: np.random.rand()
Out[67]: 0.31627484569427544
In [68]: np.random.rand()
Out[68]: 0.27011813480098346
#randint测试
In [69]: np.random.randint(1,3)
Out[69]: 2
In [70]: np.random.randint(1,3)
Out[70]: 2
In [71]: np.random.randint(1,3)
Out[71]: 2
In [72]: np.random.randint(1,3)
Out[72]: 1 In [2]: np.random.randint(1,3,10)
Out[2]: array([1, 1, 1, 1, 1, 1, 2, 1, 2, 1]) In [73]: l = [1,2,3,4,5]
#choice测试
In [74]: np.random.choice(l)
Out[74]: 1
In [75]: np.random.choice(l)
Out[75]: 5
In [76]: np.random.choice(l)
Out[76]: 2 In [85]: np.random.choice(l,4)
Out[85]: array([2, 1, 4, 3])
In [86]: np.random.choice(l,3)
Out[86]: array([3, 4, 1]) #洗牌测试
In [77]: np.random.shuffle(l)
In [78]: l
Out[78]: [5, 4, 3, 2, 1]
In [79]: np.random.shuffle(l)
In [80]: l
Out[80]: [5, 4, 1, 2, 3] #范围内小数测试
In [81]: np.random.uniform(1,2)
Out[81]: 1.3473541275258798 In [82]: np.random.uniform(1,2)
Out[82]: 1.2320202461818281 In [83]: np.random.uniform(1,2)
Out[83]: 1.6726333608929713 In [84]: np.random.uniform(l)
Out[84]: array([ 1.49064608, 1.46376829, 1. , 1.49454 , 2.51421719])

补充:

  关于数组的显示问题:当数组内的数据不多的时候会全部显示,当数据大到足以会显示首尾,中间的以...略过,数据是真实存在的只是隐藏了!一维数组被打印成行,二维数组成矩阵,三维数组成矩阵列表。

参考博客:

NumPy的详细教程

numpy基本用法

试验性的Numpy教程

上一篇:Numpy的简单用法


下一篇:Windows API获取系统配置文件的配置参数