Numpy库与多维数组
NumPy库简介
NumPy(Numerical Python)是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵,比Python自身的嵌套列表(nested list structure)结构要高效的多(该结构也可以用来表示矩阵(matrix)),支持大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。
一个用python实现的科学计算,包括:1、一个强大的N维数组对象Array;2、比较成熟的(广播)函数库;3、用于整合C/C++和Fortran代码的工具包;4、实用的线性代数、傅里叶变换和随机数生成函数。numpy和稀疏矩阵运算包scipy配合使用更加方便。
NumPy(Numeric Python)提供了许多高级的数值编程工具,如:矩阵数据类型、矢量处理,以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用,以及核心的科学计算组织如:Lawrence Livermore,NASA用其处理一些本来使用C++,Fortran或Matlab等所做的任务。
NumPy 的前身为 Numeric ,最早由 Jim Hugunin 与其它协作者共同开发,2005 年,Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色,并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。
创建数组和操作
array函数创建多维数组
NumPy 最重要的一个特点是其 N 维数组对象 ndarray,它是一系列同类型数据的集合,以 0 下标为开始进行集合中元素的索引。
ndarray 对象是用于存放同类型元素的多维数组。
ndarray 中的每个元素在内存中都有相同存储大小的区域。
按参数创建
创建一个 ndarray 只需调用 NumPy 的 array 函数即可:
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
参数说明:
名称 描述
object 数组或嵌套的数列
dtype 数组元素的数据类型,可选
copy 对象是否需要复制,可选
order 创建数组的样式,C为行方向,F为列方向,A为任意方向(默认)
subok 默认返回一个与基类类型一致的数组
ndmin 指定生成数组的最小维度
实例
接下来可以通过以下实例帮助我们更好的理解。
实例 1
import numpy as np
a = np.array([1,2,3])
print (a)
输出结果如下:
[1 2 3]
实例 2
# 多于一个维度
import numpy as np
a = np.array([[1, 2], [3, 4]])
print (a)
输出结果如下:
[[1 2]
[3 4]]
实例 3
# 最小维度
import numpy as np
a = np.array([1, 2, 3, 4, 5], ndmin = 2)
print (a)
输出如下:
[[1 2 3 4 5]]
实例 4
# dtype 参数
import numpy as np
a = np.array([1, 2, 3], dtype = complex)
print (a)
输出结果如下:
[1.+0.j 2.+0.j 3.+0.j]
ndarray 对象由计算机内存的连续一维部分组成,并结合索引模式,将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格,即前述的F样式)来保存元素。
创建全部为1的数组
示例代码:
x=np.ones((2,2)) #构建2行、2列,数值为1的数组
print(x)
返回:
[[1. 1.]
[1. 1.]]
创建全部为0的数组
x=np.zeros((2,2)) #构建2行、2列,数值为0的数组
print(x)
返回:
[[0. 0.]
[0. 0.]]
创建无意义数组
x=np.empty([5,6]) #构建5行、6列数组
print(x[0,1])
注意:由于不需指定具体值,该方法是创建数组最快的方法,但是由于创建的是无意义的数组,结果不可控,可能是任意未初始化的垃圾值,尽量少用,了解即可
arange函数生成数组
说明:
Numpy 中 arange() 主要是用于生成数组,具体用法如下
语法
numpy.arange(start, stop, step, dtype = None)
在给定间隔内返回均匀间隔的值。
值在半开区间 [开始,停止]内生成(换句话说,包括开始但不包括停止的区间),返回的是 ndarray 。
参数
start —— 开始位置,数字,可选项,默认起始值为0
stop —— 停止位置,数字
step —— 步长,数字,可选项, 默认步长为1,如果指定了step,则还必须给出start。
dtype —— 输出数组的类型。 如果未给出dtype,则从其他输入参数推断数据类型。
返回:
arange:ndarray
均匀间隔值的数组。
注意:对于浮点参数(参数为浮点),结果的长度为ceil((stop - start)/ step)) 由于浮点溢出,此规则可能导致最后一个元素大于stop。因此要特别注意
实例
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from numpy import * # 引入numpy
A = arange(5) # 只有结束项
print(A) # 结果 [0 1 2 3 4] 结果不包含结束项
print(type(A)) # 结果 <class 'numpy.ndarray'>
A = arange(1, 5) # 起点为1,步长默认为1
print(A) # 结果 [1 2 3 4]
A = arange(1, 5, 2) # 步长默认为2
print(A) # 结果 [1 3]
A = arange(1, 5.2, 0.6) # 浮点数参数,结果就不一定完全符合了
print(A) # 结果 [1. 1.6 2.2 2.8 3.4 4. 4.6 5.2]
数组元素索引与切片
基本切片操作
>>> import numpy as np
>>> arr=np.arange(10)
>>> arr
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> arr[5]
5
>>> arr[5:8]
array([5, 6, 7])
切片赋值操作
通过索引提取:array[start:end:step] 提取单个元素:array[start]
特殊方法提取:提取多个元素:array[start:end]
通过索引值来提取数组中的元素或者对数组进行切片,提取的新数组与原来数组共享数据内存空间。
1.切片赋一个值对应原来数组中的值也会变
>>> arr[5:8]=12
>>> arr
array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])
>>> import numpy as np
>>> arr=np.arange(10)
>>> arr_slice=arr[5:8]
>>> arr_slice[0]=-1
>>> arr_slice
array([-1, 6, 7])
>>> arr
array([ 0, 1, 2, 3, 4, -1, 6, 7, 8, 9])
2.给数组中所有元素赋值
>>> arr[:]=-1
>>> arr
array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1])
3.如果想使用复制的方法,使用copy方法
>>> arr_copy=arr[:].copy()
>>> arr_copy
array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1])
>>> arr_copy[:]=0
>>> arr_copy
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
>>> arr
array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1])
高阶数组索引
二维及以上数组元素提取:思维与一维相同,只不过要考虑各个维度上的索引值。
除了整型数组以外,整型列表也可以当作索引。若提取三维数组的多个值,则可以在每一轴上分别定义一个整型数组或者整型列表作为索引值,但是三个轴上的整型数组或者整型列表的长度要相等。
1. 单个元素的索引
#1.1.一维array,单个元素的索引使用整数
import numpy as np
a = np.array([3, 5, 1, 2, 7, 9])
print('a:', a)
b = a[1]
print('b:', b)
b = 77
print('a:', a)#改变b的值不会影响a的值
输出:
a: [3 5 1 2 7 9]
b: 5
a: [3 5 1 2 7 9]
# 1.2.多维array,单个元素的索引使用整数序列
#1.2.1 二维array
a = np.arange(12).reshape((3, 4))
print('a:\n', a)
b = a[1, 2] #注意b = a[1, 2]等价于b = a[1][2], 索引a中第2行第3列的值, 实际上a[1][2]是先索引第一个维度得到一个array,在此基础上再索引
print('b:\n', b)
b = 77
print('a:\n', a) #改变b的值不会影响a
输出:
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
b:
6
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
#1.2.2 多维array
a = np.arange(96).reshape((2,3,4,4))
print('a:\n', a)
b = a[1, 2, 2, 2] #注意b = a[1, 2, 2, 2]等价于b = a[1][2][2][2], 按每个维度一次索引,可以把a看做两张4*4的RGB图片,
# 则索引的是第2张图的第三个通道的第3行第3列
print('b:\n', b)
b = 9999
print('a:\n', a) #改变b的值不会影响a
输出:
a:
[[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]]
[[32 33 34 35]
[36 37 38 39]
[40 41 42 43]
[44 45 46 47]]]
[[[48 49 50 51]
[52 53 54 55]
[56 57 58 59]
[60 61 62 63]]
[[64 65 66 67]
[68 69 70 71]
[72 73 74 75]
[76 77 78 79]]
[[80 81 82 83]
[84 85 86 87]
[88 89 90 91]
[92 93 94 95]]]]
b:
90
a:
[[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]]
[[32 33 34 35]
[36 37 38 39]
[40 41 42 43]
[44 45 46 47]]]
[[[48 49 50 51]
[52 53 54 55]
[56 57 58 59]
[60 61 62 63]]
[[64 65 66 67]
[68 69 70 71]
[72 73 74 75]
[76 77 78 79]]
[[80 81 82 83]
[84 85 86 87]
[88 89 90 91]
[92 93 94 95]]]]
2.多个元素的索引
#2.1用少于array的维度的个数索引值去索引该array
a = np.arange(12).reshape((3, 4))
print('a:\n', a)
b = a[2] #a的维度为2,但是只用一个索引值去索引第一个维度,得到b为一个array,shape由未被索引的维度组成
print('b:\n', b)
print('改变b中的值,会影响a')
b[1] = 77
print('a:\n', a) #改变b中的值,会影响a
print('给b整体赋值并不会影响a')
b = np.array([11, 11, 11, 11])
print('a:\n', a) #给b整体赋值并不会影响a
print('改变a中对应的值, 会影响b')
a[2, 3] = 88
print('b:\n', b) #改变a中对应的值, 会影响b
输出:
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
b:
[ 8 9 10 11]
改变b中的值,会影响a
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 77 10 11]]
给b整体赋值并不会影响a
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 77 10 11]]
改变a中对应的值, 会影响b
b:
[11 11 11 11]
#应用:用少于array的维度的个数索引值去索引该array
#假设a为一个4维array,表示N个图像,(N,C,H,W),则从中取一张图像就可以直接这样索引:a[i]
a = np.arange(96).reshape((2, 4, 4, 3))
print(a[1])
print(a[1].shape) #shape由未被索引的维度组成
输出:
[[[48 49 50]
[51 52 53]
[54 55 56]
[57 58 59]]
[[60 61 62]
[63 64 65]
[66 67 68]
[69 70 71]]
[[72 73 74]
[75 76 77]
[78 79 80]
[81 82 83]]
[[84 85 86]
[87 88 89]
[90 91 92]
[93 94 95]]]
(4, 4, 3)
In [6]:
#2.2切片索引
a = np.arange(12).reshape((3, 4))
print('a:\n', a)
b = a[1:3, 2:4] #对每个维度依次切片,注意a[1:3][2:4]并不等价于a[1:3, 2:4], a[1:3][2:4]是先对a在第一个维度上切片后再切片
print('b:\n', b)
b[0][0] = 88
print('a:\n', a) #改变a的值会影响b
输出:
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
b:
[[ 6 7]
[10 11]]
a:
[[ 0 1 2 3]
[ 4 5 88 7]
[ 8 9 10 11]]
总结:用小于array维度的个数的索引值索引和切片索引创建的新的array都为原array的第一视图,改变新array中的值(不是对新的array整体赋值)会影响原array的值;改变原array对应的值也会影响新array的值
3.用array索引array
#3.1一维array索引一维array
a = np.array([1, 7, 8, 9, 11, 3])
print('a:\n', a)
b = a[np.array([1, 2, 4])] #用被索引的array的值替换索引array([1, 2, 4])
print('b:\n', b)
b[1] = 333
print('a:\n', a) #用array索引array创建的新的array是原array的一个copy,所以改变新的array不会改变原的array,下面不再验证这一点
输出:
a:
[ 1 7 8 9 11 3]
b:
[ 7 8 11]
a:
[ 1 7 8 9 11 3]
#3.2多维array索引一维array
a = np.array([1, 7, 8, 9, 11, 3])
print('a:\n', a)
b = a[np.array([[1, 2, 3], [4, 1, 2]])] #用被索引的array的值替换索引array([[1, 2, 3], [4, 1, 2]])
print('b:\n', b)
输出:
a:
[ 1 7 8 9 11 3]
b:
[[ 7 8 9]
[11 7 8]]
#3.3索引多维array
a = np.arange(12).reshape((3, 4))
print('a:\n', a)
b = a[np.array([1, 2]), np.array([1, 2])] #索引出的是a[1][1], a[2][2]
print('b:\n', b)
输出:
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
b:
[ 5 10]
a = np.arange(12).reshape((3, 4))
print('a:\n', a)
b = a[np.array([1, 2])] #索引出的是第2,3行
print('b:\n', b)
输出:
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
b:
[[ 4 5 6 7]
[ 8 9 10 11]]
4布尔值(mask)索引
In [11]:
a = np.arange(12).reshape((3, 4))
print('a:\n', a)
idx = a > 5
print('idx:\n', idx)
b = a[idx]
print('b:\n', b) #返回的值为一维array( The elements in the indexed array are always iterated and returned in row-major (C-style) order. )
b[1] = 77
print('a:\n', a)
输出:
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
idx:
[[False False False False]
[False False True True]
[ True True True True]]
b:
[ 6 7 8 9 10 11]
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
idx_slice = idx[:,1]
print('idx_slice:\n', idx_slice) #布尔索引值个数等于第一个维度
b = a[idx_slice] #索引第三行
print('b:\n', b)
输出
idx_slice:
[False False True]
b:
[[ 8 9 10 11]]
总结:用array去索引和布尔值索引都为高级索引,由此创建的新array为原array的一个copy,改变新array的值不会对旧array的值产生影响
图形化补充:
>>> import numpy as np
>>> arr2d=np.array([[1,2,3],[4,5,6],[7,8,9]])
>>> arr2d[2]
array([7, 8, 9])
>>> arr2d[0][2]
3
>>> arr2d[0,2] #写法与上面等同
3
![bcb59c46a31a71209f0c8cbf6097adb2.png](https://i-blog.csdnimg.cn/blog_migrate/4b9dae3b1ca4d75044b0383b87995502.png)
>>> import numpy as np
>>> arr2d=np.array([[1,2,3],[4,5,6],[7,8,9]])
>>> arr2d[2]
array([7, 8, 9])
>>> arr2d[0][2]
3
>>> arr2d[0,2]
3
>>> arr3d=np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
>>> arr3d
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
>>> arr3d[0]
array([[1, 2, 3],
[4, 5, 6]])
>>> old_values=arr3d[0].copy()
>>> arr3d[0]=42
>>> arr3d
array([[[42, 42, 42],
[42, 42, 42]],
[[ 7, 8, 9],
[10, 11, 12]]])
>>> arr3d[1,0]
array([7, 8, 9])
>>> x=arr3d[1]
>>> x
array([[ 7, 8, 9],
[10, 11, 12]])
>>> x[0]
array([7, 8, 9])
高维数组切片
>>> arr2d[:2]
array([[1, 2, 3],
[4, 5, 6]])
>>> arr2d[:2,1:]
array([[2, 3],
[5, 6]])
>>> arr2d[1,:2]
array([4, 5])
>>> arr2d[:2,2]
array([3, 6])
>>> arr2d[:,:1]
array([[1],
[4],
[7]])
![0847a2ce63453a6902106aad3598d286.png](https://i-blog.csdnimg.cn/blog_migrate/6a403642c16d23697618c3fff0917685.png)
布尔型索引
1.假设我们有一个用于存储数据的数组以及一个存储姓名的数组(含有重复项)。在这里,将使用numpy.random中的randn函数生成一些正态分布的随机数据:
>>> import numpy as np
>>> names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
>>> data=np.random.randn(7,4)#7行4列正太分布随机数组
>>> names
array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], dtype='<U4')
>>> data
array([[ 0.24724057, 2.86939948, -0.82061782, -0.65745818],
[-0.98602372, -0.69305692, -1.44431904, -0.85490816],
[-0.73613349, 0.12700976, -1.00588979, 1.10646269],
[ 1.59110894, 1.68597758, 0.39414277, 2.02308399],
[-1.05607115, -0.50354292, -0.65820553, -0.77610316],
[ 1.72237936, -0.07726577, 1.63462647, -0.41943148],
[ 0.66744687, -1.01756773, -0.59254343, 0.19080575]])
2.假设每个名字都对应data数组中的一行,而我们想要选出对应于名字"Bob"的所有行。跟算术运算一样,数组的比较运算(如==)也是矢量化的。因此,对names和字符串"Bob"的比较运算将会产生一个布尔型数组:
>>> names=='Bob'
array([ True, False, False, True, False, False, False])
3.布尔数组可以用于数组的索引
获取等于'Bob'的行
>>> data[names=='Bob']
array([[ 0.24724057, 2.86939948, -0.82061782, -0.65745818],
[ 1.59110894, 1.68597758, 0.39414277, 2.02308399]])
获取不同于'Bob'的行
>>> data[names!='Bob']
array([[-0.98602372, -0.69305692, -1.44431904, -0.85490816],
[-0.73613349, 0.12700976, -1.00588979, 1.10646269],
[-1.05607115, -0.50354292, -0.65820553, -0.77610316],
[ 1.72237936, -0.07726577, 1.63462647, -0.41943148],
[ 0.66744687, -1.01756773, -0.59254343, 0.19080575]])
4.对布尔索引进行列索引
>>> data[names=='Bob',2:]
array([[-0.82061782, -0.65745818],
[ 0.39414277, 2.02308399]])
>>> data[names=='Bob',3]
array([-0.65745818, 2.02308399])
5.反转条件符
>>> cond=names=='Will'
>>> cond
array([False, False, True, False, True, False, False])
>>> data[~cond]
array([[ 0.24724057, 2.86939948, -0.82061782, -0.65745818],
[-0.98602372, -0.69305692, -1.44431904, -0.85490816],
[ 1.59110894, 1.68597758, 0.39414277, 2.02308399],
[ 1.72237936, -0.07726577, 1.63462647, -0.41943148],
[ 0.66744687, -1.01756773, -0.59254343, 0.19080575]])
6.布尔条件的运算
除此之外,连接符还有|、&之类
>>> mask=(names=='Bob')|(names=='Will')
>>> mask
array([ True, False, True, True, True, False, False])
>>> data[mask]
array([[ 0.24724057, 2.86939948, -0.82061782, -0.65745818],
[-0.73613349, 0.12700976, -1.00588979, 1.10646269],
[ 1.59110894, 1.68597758, 0.39414277, 2.02308399],
[-1.05607115, -0.50354292, -0.65820553, -0.77610316]])
7.条件选取
普通条件选取
>>> data[data<0]=0
>>> data
array([[0.24724057, 2.86939948, 0. , 0. ],
[0. , 0. , 0. , 0. ],
[0. , 0.12700976, 0. , 1.10646269],
[1.59110894, 1.68597758, 0.39414277, 2.02308399],
[0. , 0. , 0. , 0. ],
[1.72237936, 0. , 1.63462647, 0. ],
[0.66744687, 0. , 0. , 0.19080575]])
布尔条件选取
>>> import numpy as np
>>> names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
>>> data=np.random.randn(7,4)#7行4列正太分布随机数组
>>> data
array([[-1.24077681, -0.48320904, 1.22145611, 0.00666619],
[-0.65078721, -0.03482355, 1.74232625, 0.2979584 ],
[-1.51669752, 2.04245014, 0.09453898, -0.85531867],
[-1.51334497, 0.36947066, -0.87016919, 1.35107873],
[-1.11285867, -2.20906849, 0.38269412, 1.85375798],
[ 0.95132554, -1.54193589, 1.98741745, -0.60608077],
[ 0.78902133, 1.41593836, 0.09430052, -0.25057659]])
>>> data[names!='Joe']=7
>>> data
array([[ 7. , 7. , 7. , 7. ],
[-0.65078721, -0.03482355, 1.74232625, 0.2979584 ],
[ 7. , 7. , 7. , 7. ],
[ 7. , 7. , 7. , 7. ],
[ 7. , 7. , 7. , 7. ],
[ 0.95132554, -1.54193589, 1.98741745, -0.60608077],
[ 0.78902133, 1.41593836, 0.09430052, -0.25057659]])
>>>
花式索引
1.传入单个索引数组
>>> import numpy as np
>>> arr=np.empty((8,4))#创建8行4列内容为空的数组
>>> for i in range(8):
arr[i]=i
>>> arr
array([[0., 0., 0., 0.],
[1., 1., 1., 1.],
[2., 2., 2., 2.],
[3., 3., 3., 3.],
[4., 4., 4., 4.],
[5., 5., 5., 5.],
[6., 6., 6., 6.],
[7., 7., 7., 7.]])
>>> arr[[4,3,0,6]]#选特定的索引下标,选取第4,3,0,6行
array([[4., 4., 4., 4.],
[3., 3., 3., 3.],
[0., 0., 0., 0.],
[6., 6., 6., 6.]])
花式索引高阶玩法:
import numpy as np
na1=np.array([[1,2,3], [4,5,6], [7,8,9]])
print(na1[[1,2,1],[2,1,2]]) #可以拆成:左边的1,2,1代表分别选择第2行、第3行、第2行;右边的2,1,2代表分别选择对应行的第3列、第2列、第3列
#输出:
array([6, 8, 6])
2.传入多个索引数组
>>> arr=np.arange(32).reshape((8,4))
>>> arr
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23],
[24, 25, 26, 27],
[28, 29, 30, 31]])
>>> arr[[1,5,7,2],[0,3,1,2]]#选取(1,0),(5,3),(7,1),(2,2)对应元素
array([ 4, 23, 29, 10])
>>> arr[[1,5,7,2]][:,[0,3,1,2]]#先选取第1,5,7,2行,再将每行按照0,3,1,2这个顺序交换
array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
数组运算
数组的乘法
>>> import numpy as np
>>> arr=np.array([[1,2,3],[4,5,6]])
>>> arr
array([[1, 2, 3],
[4, 5, 6]])
>>> arr*arr
array([[ 1, 4, 9],
[16, 25, 36]])
数组的减法
>>> arr-arr
array([[0, 0, 0],
[0, 0, 0]])
数组的标量运算
数组的标量运算会传播到数组中的每一个元素
>>> import numpy as np
>>> arr=np.array([[1,2,3],[4,5,6]])
>>> arr
array([[1, 2, 3],
[4, 5, 6]])
>>> 1/arr
array([[1. , 0.5 , 0.33333333],
[0.25 , 0.2 , 0.16666667]])
>>> arr**2
array([[ 1, 4, 9],
[16, 25, 36]], dtype=int32)
数组比较
大小相同的数组之间的比较会生成布尔值数组:
>>> import numpy as np
>>> arr1=np.array([[1,2,3],[4,5,6]])
>>> arr2=np.array([1,1,1],[1,1,1])
>>> arr2=np.array([[1,1,1],[1,1,1]])
>>> arr2>arr1
array([[False, False, False],
[False, False, False]])
产生随机数
numpy中的random模块包含了很多方法可以用来产生随机数
1、numpy.random.rand(d0, d1, ..., dn)
作用:产生一个给定形状的数组(其实应该是ndarray对象或者是一个单值),数组中的值服从[0, 1)之间的均匀分布。
参数:d0, d, ..., dn : int,可选。如果没有参数则返回一个float型的随机数,该随机数服从[0, 1)之间的均匀分布。
返回值:ndarray对象或者一个float型的值
例子:
# [0, 1)之间均匀分布的随机数,3行2列
a = np.random.rand(3, 2)
print(a)
# 不提供形状
b = np.random.rand()
print(b)
输出:
[[0.26054323 0.28184468]
[0.7783674 0.71733674]
[0.90302256 0.49303252]]
0.6022098740124009
2、numpy.random.uniform(low=0.0, high=1.0, size=None)
作用:返回一个在区间[low, high)中均匀分布的数组,size指定形状。
参数:
low, high:float型或者float型的类数组对象。指定抽样区间为[low, high),low的默认值为0.0,hign的默认值为1.0
size:int型或int型元组。指定形状,如果不提供size,则返回一个服从该分布的随机数。
例子:
# 在[1, 10)之间均匀抽样,数组形状为3行2列
a = np.random.uniform(1, 10, (3, 2))
print(a)
# 不提供size
b = np.random.uniform(1, 10)
print(b)
输出:
[[5.16545387 6.3769087 ]
[9.98964899 7.88833885]
[1.37173855 4.19855075]]
3.899250175275188
3、numpy.random.randn(d0, d1, ..., dn)
作用:返回一个指定形状的数组,数组中的值服从标准正态分布(均值为0,方差为1)。
参数:d0, d, ..., dn : int,可选。如果没有参数,则返回一个服从标准正态分布的float型随机数。
返回值:ndarray对象或者float
例子:
# 3行2列
a = np.random.randn(3, 2)
print(a)
# 不提供形状
b = np.random.randn()
print(b)
输出:
[[-1.46605527 0.35434705]
[ 0.43408199 0.02689309]
[ 0.48041554 1.62665755]]
-0.6291254375915813
4、numpy.random.normal(loc=0.0, scale=1.0, size=None)
作用:返回一个由size指定形状的数组,数组中的值服从 μ=loc,σ=scale 的正态分布。
参数:
loc : float型或者float型的类数组对象,指定均值 μ
scale : float型或者float型的类数组对象,指定标准差 σ
size : int型或者int型的元组,指定了数组的形状。如果不提供size,且loc和scale为标量(不是类数组对象),则返回一个服从该分布的随机数。
输出:ndarray对象或者一个标量
例子:
# 标准正态分布,3行2列
a = np.random.normal(0, 1, (3, 2))
print(a)
# 均值为1,标准差为3
b = np.random.normal(1, 3)
print(b)
输出:
[[ 0.34912031 -0.08757564]
[-0.99753101 0.37441719]
[ 2.68072286 -1.03663963]]
5.770831320998463
5、numpy.random.randint(low, high=None, size=None, dtype='l')
作用:返回一个在区间[low, high)中离散均匀抽样的数组,size指定形状,dtype指定数据类型。
参数:
low, high:int型,指定抽样区间[low, high)
size:int型或int型的元组,指定形状
dypte:可选参数,指定数据类型,比如int,int64等,默认是http://np.int
返回值:如果指定了size,则返回一个int型的ndarray对象,否则返回一个服从该分布的int型随机数。
例子:
# 在[1, 10)之间离散均匀抽样,数组形状为3行2列
a = np.random.randint(1, 10, (3, 2))
print(a)
# 不提供size
b = np.random.randint(1, 10)
print(b)
# 指定dtype
c = np.random.randint(1, 10, dtype=np.int64)
print(c)
type(c)
输出:
[[3 1]
[3 3]
[5 8]]
6
2
numpy.int64
6、numpy.random.random(size=None)
作用:返回从[0, 1)之间均匀抽样的数组,size指定形状。
参数:
size:int型或int型的元组,如果不提供则返回一个服从该分布的随机数
返回值:float型或者float型的ndarray对象
例子:
# [0, 1)之间的均匀抽样,3行2列
a = np.random.random((3, 2))
print(a)
# 不指定size
b = np.random.random()
print(b)
输出:
[[0.80136714 0.63129059]
[0.04556679 0.04433006]
[0.09643599 0.53312761]]
0.32828505898057136