- In [227]:
- import numpy as np
- In [ ]:
- # NumPy 是 Python 中科学计算的基础软件包.
- # 它是一个提供多了维数组对象, 多种派生对象 (如: 掩码数组, 矩阵) 以及用于快速操作数组的函数及 API,
- # 它包括数学, 逻辑, 数组形状变换, 排序, 选择, I/O , 离散傅立叶变换, 基本线性代数, 基本统计运算, 随机模拟等等.
- # NumPy 包的核心是 ndarray 对象.
- # 它封装了 python 原生的同数据类型的 n 维数组, 为了保证其性能优良, 其中有许多操作都是代码在本地进行编译后执行的.
- # NumPy 数组 和 标准 Python Array(数组) 之间 的区别
- # NumPy 数组在创建时具有固定的大小, 与 Python 的原生数组对象 (可以动态增长) 不同. 更改 ndarray 的大小将创建一个新数组并删除原来的数组.
- # NumPy 数组中的元素都需要具有相同的数据类型, 因此在内存中的大小相同. 例外情况: Python 的原生数组里包含了 NumPy 的对象的时候,
- # 这种情况下就允许不同大小元素的数组.
- # 安装
- # python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose
- In [2]:
- # NumPy 的主要对象是同类型的多维数组. 它是一张表, 所有元素 (通常是数字) 的类型都相同, 并通过正整数元组索引. 在 NumPy 中, 维度称为轴.
- # 轴的数目为 rank.
- # [1, 2, 1] 是 rank 为 1 的数组, 因为它具有一个轴. 该轴的长度为 3
- t1 = [[ 1., 0., 0.],
- [ 0., 1., 2.]]
- # t1 有两个轴 第一个轴 (维度) 的长度为 2, 第二个轴 (维度) 的长度为 3.
- In [3]:
- # 主要属性
- # ndarray.ndim: 数组的轴 (维度) 的个数. 在 Python 世界中, 维度的数量被称为 rank.
- # ndarray.shape: 数组的维度. 这是一个整数的元组, 表示每个维度中数组的大小. 对于有 n 行和 m 列的矩阵, shape 将是(n,m). 因此,
- # shape 元组的长度就是 rank 或维度的个数 ndim.
- # ndarray.size: 数组元素的总数. 这等于 shape 的元素的乘积.
- # ndarray.dtype: 一个描述数组中元素类型的对象. 可以使用标准的 Python 类型创建或指定 dtype. 另外 NumPy 提供它自己的类型.
- # 例如 numpy.int32,numpy.int16 和 numpy.float64.
- # ndarray.itemsize: 数组中每个元素的字节大小. 例如, 元素为 float64 类型的数组的 itemsize 为 8(=64/8), 而 complex32 类型的数组的
- # itemsize 为 4(=32/8). 它等于 ndarray.dtype.itemsize .
- # ndarray.data: 该缓冲区包含数组的实际元素. 通常, 我们不需要使用此属性, 因为我们将使用索引访问数组中的元素.
- In [50]:
- # 创建数组
- In [228]:
- # 1. 用普通的 python 列表创建数组
- a1 = np.array([1,2,3])
- print(a1.ndim)
- print(a1.dtype)
- print(a1.size)
- print(a1.shape)
- a1
- 2 int32 3 (1, 3)
- Out[228]:
- array([[1, 2, 3]])
- In [9]:
- a2 = a1 = np.array([[1,2,3], [3,4,5]], dtype='int')
- a2
- Out[9]:
- array([[1, 2, 3],
- [3, 4, 5]])
- In [12]:
- print(a2.ndim)
- print(a2.dtype)
- print(a2.size)
- print(a2.shape)
- 2 int32 6 (2, 3)
- In [ ]:
- # 用 nunpy 内置的方法来创建数组
- In [18]:
- #np.zeros(shape, dtype=None, order='C')
- # 创建 shape 是 3x5 的全 1(默认浮点型)数组
- a3= np.zeros((3,5), order='C')
- a3
- Out[18]:
- array([[0., 0., 0., 0., 0.],
- [0., 0., 0., 0., 0.],
- [0., 0., 0., 0., 0.]])
- In [17]:
- #np.zeros(shape, dtype=None, order='C')
- # 创建 shape 是 3x5 的全 1(默认浮点型)数组
- a4 = np.ones((3,5))
- a4
- Out[17]:
- array([[1., 1., 1., 1., 1.],
- [1., 1., 1., 1., 1.],
- [1., 1., 1., 1., 1.]])
- In [19]:
- #np.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
- # 创建一个形状为 N x N 的单位矩阵(二维数组)
- a5 = np.eye(3)
- a5
- Out[19]:
- array([[1., 0., 0.],
- [0., 1., 0.],
- [0., 0., 1.]])
- In [21]:
- #empty(shape, dtype=float, order='C')
- # 创建一个形状为 shape 的未初始化数组, 值为随机值
- a6 =np.empty(5, dtype='int')
- Out[21]:
- array([0, 0, 0, 0, 0])
- In [23]:
- a7 = np.empty((3,4))
- a7
- Out[23]:
- array([[1.50665937e-312, 0.00000000e+000, 8.76794447e+252,
- 2.15895723e+227],
- [6.48224638e+170, 3.67145870e+228, 7.58253645e-096,
- 9.03292329e+271],
- [9.08366793e+223, 1.41075687e+232, 1.16070543e-028,
- 1.54730878e+295]])
- In [34]:
- #np.full(shape, fill_value, dtype=None, order='C')
- # 创建 shape 是 3x5 的 (默认浮点型) 数组, 值 fill_value 都是 3.14
- a7 = np.full((3,5),5)
- a7
- Out[34]:
- array([[5, 5, 5, 5, 5],
- [5, 5, 5, 5, 5],
- [5, 5, 5, 5, 5]])
- In [35]:
- # 使用 arange 来创建
- # arange([start,] stop[, step,], dtype=None)
- a8 = np.arange(0,20,5)
- a8
- Out[35]:
- array([ 0, 5, 10, 15])
- In [230]:
- # 使用 linspace 来创建
- # np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
- a9= np.linspace(10,20,6)
- a9
- Out[230]:
- array([10., 12., 14., 16., 18., 20.])
- In [233]:
- # reshape
- a10 = a9.reshape(2,3)
- a10
- Out[233]:
- array([[10., 12., 14.],
- [16., 18., 20.]])
- In [51]:
- # 形状 和操作
- In [236]:
- aa = np.arange(20).reshape(4,5)
- aa
- Out[236]:
- array([[ 0, 1, 2, 3, 4],
- [ 5, 6, 7, 8, 9],
- [10, 11, 12, 13, 14],
- [15, 16, 17, 18, 19]])
- In [237]:
- print(aa.shape)
- print(aa.size)
- (4, 5) 20
- In [43]:
- aa.reshape(5,4) # 不改变数组本身
- Out[43]:
- array([[ 0, 1, 2, 3],
- [ 4, 5, 6, 7],
- [ 8, 9, 10, 11],
- [12, 13, 14, 15],
- [16, 17, 18, 19]])
- In [44]:
- aa
- Out[44]:
- array([[ 0, 1, 2, 3, 4],
- [ 5, 6, 7, 8, 9],
- [10, 11, 12, 13, 14],
- [15, 16, 17, 18, 19]])
- In [45]:
- aa.ravel() # 不改变数组本身
- Out[45]:
- array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
- 17, 18, 19])
- In [46]:
- aa
- Out[46]:
- array([[ 0, 1, 2, 3, 4],
- [ 5, 6, 7, 8, 9],
- [10, 11, 12, 13, 14],
- [15, 16, 17, 18, 19]])
- In [238]:
- aa
- Out[238]:
- array([[ 0, 1, 2, 3, 4],
- [ 5, 6, 7, 8, 9],
- [10, 11, 12, 13, 14],
- [15, 16, 17, 18, 19]])
- In [239]:
- aa.resize(5,4) # 改变数组本身
- In [240]:
- aa
- Out[240]:
- array([[ 0, 1, 2, 3],
- [ 4, 5, 6, 7],
- [ 8, 9, 10, 11],
- [12, 13, 14, 15],
- [16, 17, 18, 19]])
- In [241]:
- aa.reshape(5,-1) #reshape 操作中将维度指定为 - 1, 则会自动计算其他维度
- Out[241]:
- array([[ 0, 1, 2, 3],
- [ 4, 5, 6, 7],
- [ 8, 9, 10, 11],
- [12, 13, 14, 15],
- [16, 17, 18, 19]])
- In [52]:
- # 将不同的数组堆叠在一起
- In [243]:
- aa = np.floor(10*np.random.random((2,2)))
- aa
- Out[243]:
- array([[1., 8.],
- [4., 4.]])
- In [244]:
- bb = np.floor(10*np.random.random((2,2)))
- bb
- Out[244]:
- array([[7., 0.],
- [9., 0.]])
- In [245]:
- xx = np.vstack((aa,bb))
- xx
- Out[245]:
- array([[1., 8.],
- [4., 4.],
- [7., 0.],
- [9., 0.]])
- In [246]:
- np.hstack((aa, bb))
- Out[246]:
- array([[1., 8., 7., 0.],
- [4., 4., 9., 0.]])
- In [60]:
- # numpy 切片和索引
- In [61]:
- a = np.arange(10) a
- Out[61]:
- array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
- In [67]:
- s = slice(2,7,2)
- print(a[s])
- [2 4 6]
- In [68]:
- b = a[2:7:2] b
- Out[68]:
- array([2, 4, 6])
- In [250]:
- aa = np.floor(10*np.random.random((2,12)))
- aa
- Out[250]:
- array([[2., 2., 3., 9., 7., 8., 4., 6., 9., 3., 8., 6.],
- [1., 7., 4., 3., 2., 2., 0., 7., 3., 6., 3., 7.]])
- In [258]:
- aa
- Out[258]:
- array([[2., 2., 3., 9., 7., 8., 4., 6., 9., 3., 8., 6.],
- [1., 7., 4., 3., 2., 2., 0., 7., 3., 6., 3., 7.]])
- In [259]:
- np.hsplit(aa,3) # 平均分成 3 份
- Out[259]:
- [array([[2., 2., 3., 9.],
- [1., 7., 4., 3.]]), array([[7., 8., 4., 6.],
- [2., 2., 0., 7.]]), array([[9., 3., 8., 6.],
- [3., 6., 3., 7.]])]
- In [260]:
- np.hsplit(aa,(3,4)) # 0-3 3-4 4-
- Out[260]:
- [array([[2., 2., 3.],
- [1., 7., 4.]]), array([[9.],
- [3.]]), array([[7., 8., 4., 6., 9., 3., 8., 6.],
- [2., 2., 0., 7., 3., 6., 3., 7.]])]
- In [73]:
- # 分割
- aa = np.random.randint(1, 50,size=(7,7))
- aa
- Out[73]:
- array([[ 9, 23, 26, 3, 14, 18, 38],
- [14, 32, 24, 27, 47, 34, 7],
- [31, 23, 42, 21, 39, 12, 46],
- [32, 32, 42, 44, 24, 33, 19],
- [49, 37, 25, 27, 5, 30, 11],
- [40, 32, 40, 40, 35, 24, 9],
- [41, 8, 47, 7, 43, 3, 48]])
- In [74]:
- # np.split(arr,index,axis)
- # arr 为被切分的数组
- # index(整数或者数组)
- # 如果是一个整数 就把当前数组平均分成 index 份, 如果数组的 size 不能被 index 整除则报错,
- # 如果为一个数组, 则沿的数组的轴线进行切分, 比如:[2, 3] 则会被切割成[:2],[2:3],[3:]
- # axis 为切分的方向 默认为 0 横向 1 为竖向
- np.split(aa, [2,4,6], axis=1)
- Out[74]:
- [array([[ 9, 23],
- [14, 32],
- [31, 23],
- [32, 32],
- [49, 37],
- [40, 32],
- [41, 8]]), array([[26, 3],
- [24, 27],
- [42, 21],
- [42, 44],
- [25, 27],
- [40, 40],
- [47, 7]]), array([[14, 18],
- [47, 34],
- [39, 12],
- [24, 33],
- [ 5, 30],
- [35, 24],
- [43, 3]]), array([[38],
- [ 7],
- [46],
- [19],
- [11],
- [ 9],
- [48]])]
- In [75]:
- aa
- Out[75]:
- array([[ 9, 23, 26, 3, 14, 18, 38],
- [14, 32, 24, 27, 47, 34, 7],
- [31, 23, 42, 21, 39, 12, 46],
- [32, 32, 42, 44, 24, 33, 19],
- [49, 37, 25, 27, 5, 30, 11],
- [40, 32, 40, 40, 35, 24, 9],
- [41, 8, 47, 7, 43, 3, 48]])
- In [76]:
- aa[5]
- Out[76]:
- array([40, 32, 40, 40, 35, 24, 9])
- In [77]:
- aa[5,3]
- Out[77]:
- 40
- In [78]:
- aa[5:]
- Out[78]:
- array([[40, 32, 40, 40, 35, 24, 9],
- [41, 8, 47, 7, 43, 3, 48]])
- In [79]:
- aa[:,1:2]
- Out[79]:
- array([[23],
- [32],
- [23],
- [32],
- [37],
- [32],
- [ 8]])
- In [261]:
- a = np.array([[1,2,3],[3,4,5],[4,5,6]])
- print(a)
- print("-----------------")
- print (a[...,1]) # 第 2 列元素
- print("-----------------")
- print (a[1,...]) # 第 2 行元素
- print("-----------------")
- print (a[...,1:]) # 第 2 列及剩下的所有元素
- # 三个点 ( ... ) 表示产生完整索引元组所需的冒号. 例如, 如果 x 是 rank 为的 5 数组(即, 它具有 5 个轴), 则
- # x[1,2,...] 等于 x[1,2,:,:,:].
- # x[...,3] 等效于 x[:,:,:,:,3].
- [[1 2 3]
- [3 4 5]
- [4 5 6]]
- -----------------
- [2 4 5]
- -----------------
- [3 4 5]
- -----------------
- [[2 3]
- [4 5]
- [5 6]]
- In [263]:
- # 整数数组索引
- # 实例获取数组中 (0,0),(1,1) 和(2,0)位置处的元素.
- x = np.array([[1, 2], [3, 4], [5, 6]])
- print(x)
- print('--------------')
- y = x[[0,1,2], [0,1,0]]
- print (y)
- [[1 2]
- [3 4]
- [5 6]]
- --------------
- [1 4 5]
- In [85]:
- # 获取了 4X3 数组中的四个角的元素. 行索引是 [0,0] 和 [3,3], 而列索引是 [0,2] 和 [0,2].
- x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
- print ('我们的数组是:' )
- print (x)
- print ('\n')
- rows = np.array([[0,0],[3,3]])
- cols = np.array([[0,2],[0,2]])
- y = x[rows,cols]
- print ('这个数组的四个角元素是:')
- print (y)
我们的数组是:
- [[ 0 1 2]
- [ 3 4 5]
- [ 6 7 8]
- [ 9 10 11]]
这个数组的四个角元素是:
- [[ 0 2]
- [ 9 11]]
- In [264]:
- # 布尔索引
- x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
- print ('我们的数组是:')
- print (x)
- print ('\n')
- # 现在我们会打印出大于 5 的元素
- print ('大于 5 的元素是:')
- print(x>5)
- print (x[x> 5])
我们的数组是:
- [[ 0 1 2]
- [ 3 4 5]
- [ 6 7 8]
- [ 9 10 11]]
大于 5 的元素是:
- [[False False False]
- [False False False]
- [ True True True]
- [ True True True]]
- [ 6 7 8 9 10 11]
- In [86]:
- a = np.array([np.nan, 1,2,np.nan,3,4,5])
- print (a[~np.isnan(a)])
- [1. 2. 3. 4. 5.]
- In [92]:
- np.nan == np.nan
- Out[92]:
- False
- In [93]:
- # 花式索引
- # 花式索引指的是利用整数数组进行索引.
- # 花式索引根据索引数组的值作为目标数组的某个轴的下标来取值. 对于使用一维整型数组作为索引, 如果目标是一维数组,
- # 那么索引的结果就是对应位置的元素; 如果目标是二维数组, 那么就是对应下标的行.
- # 花式索引跟切片不一样, 它总是将数据复制到新数组中.
- # 1, 传入顺序索引数组
- In [265]:
- x=np.arange(32).reshape((8,4))
- print(x)
- print('--------------------')
- print (x[[4,2,1,7]])
- [[ 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]]
- --------------------
- [[16 17 18 19]
- [ 8 9 10 11]
- [ 4 5 6 7]
- [28 29 30 31]]
- In [266]:
- x=np.arange(32).reshape((8,4))
- print (x[[-4,-2,-1,-7]])
- [[16 17 18 19]
- [24 25 26 27]
- [28 29 30 31]
- [ 4 5 6 7]]
- In [268]:
- print (x[([1,5,7,2],[0,3,1,2])])
- [ 4 23 29 10]
- In [270]:
- print (x[np.ix_([1,5,7,2],[0,3,1,2])])
- [[ 4 7 5 6]
- [20 23 21 22]
- [28 31 29 30]
- [ 8 11 9 10]]
- In [226]:
- x = np.array([[1,2],[3,4],[5,6]])
- print(x)
- print('-----------')
- print(x[[0,1]])
- print('-------------')
- print(x[[0,1],[0,1]])
- print('------------------')
- # 使用 numpy.ix_()函数增强可读性
- print (x[np.ix_([0,1],[0,1])])
- print('--------------')
- x[[0,1],[0,1]] = [0,0]
- print(x) # [[0,2],[3,0],[5,6]]
- [[1 2]
- [3 4]
- [5 6]]
- -----------
- [[1 2]
- [3 4]]
- -------------
- [1 4]
- ------------------
- [[1 2]
- [3 4]]
- --------------
- [[0 2]
- [3 0]
- [5 6]]
- In [271]:
- # 迭代数组
- In [273]:
- # 迭代
- a = np.arange(6).reshape(2,3)
- print ('原始数组是:')
- print (a)
- print ('\n')
- print ('迭代输出元素:')
- for x in np.nditer(a):
- print (x, end="," )
- print ('\n')
原始数组是:
- [[0 1 2]
- [3 4 5]]
迭代输出元素:
- [0 1 2], [3 4 5],
- In [275]:
- # for x in np.nditer(a, order='F'):Fortran order, 即是列序优先;
- # for x in np.nditer(a.T, order='C'):C order, 即是行序优先;
- a = np.arange(6).reshape(2,3)
- print(a)
- print('------------')
- print(a.T)
- for x in np.nditer(a, order ='C'):
- print (x, end="," )
- print ('\n')
- [[0 1 2]
- [3 4 5]]
- ------------
- [[0 3]
- [1 4]
- [2 5]]
- 0, 1, 2, 3, 4, 5,
- In [117]:
- for i in a:
- print(i)
- [0 1 2] [3 4 5]
- In [123]:
- # 修改数组中元素的值
- # nditer 对象有另一个可选参数 op_flags. 默认情况下, nditer 将视待迭代遍历的数组为只读对象(read-only), 为了在遍历数组的同时,
- # 实现对数组元素值得修改, 必须指定 read-write 或者 write-only 的模式.
- a = np.arange(0,60,5)
- a = a.reshape(3,4)
- print ('原始数组是:')
- print (a)
- print ('\n')
- for x in np.nditer(a, op_flags=['readwrite']):
- x[...]=2*x
- print ('修改后的数组是:')
- print (a)
原始数组是:
- [[ 0 5 10 15]
- [20 25 30 35]
- [40 45 50 55]]
修改后的数组是:
- [[ 0 10 20 30]
- [ 40 50 60 70]
- [ 80 90 100 110]]
- In [124]:
- # numpy.ndarray.flat 是一个数组元素迭代器, 实例如下:
- a = np.arange(9).reshape(3,3)
- print ('原始数组:')
- for row in a:
- print (row)
- # 对数组中每个元素都进行处理, 可以使用 flat 属性, 该属性是一个数组元素迭代器:
- print ('迭代后的数组:')
- for element in a.flat:
- print (element)
原始数组:
- [0 1 2]
- [3 4 5]
- [6 7 8]
迭代后的数组:
- 0
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- In [125]:
- # 数组操作
- # numpy.ndarray.flatten 返回一份数组拷贝, 对拷贝所做的修改不会影响原始数组, 格式如下:
- # ndarray.flatten(order='C')
- # order:'C' -- 按行,'F' -- 按列,'A' -- 原顺序,'K' -- 元素在内存中的出现顺序.
- a = np.arange(8).reshape(2,4)
- print ('原数组:')
- print (a)
- print ('\n')
- # 默认按行
- print ('展开的数组:')
- print (a.flatten())
- print ('\n')
- print ('以 F 风格顺序展开的数组:')
- print (a.flatten(order = 'F'))
原数组:
- [[0 1 2 3]
- [4 5 6 7]]
展开的数组:
[0 1 2 3 4 5 6 7]
以 F 风格顺序展开的数组:
- [0 4 1 5 2 6 3 7]
- In [127]:
- # 翻转数组
- In [276]:
- # numpy.transpose 函数用于对换数组的维度 numpy.ndarray.T 类似 numpy.transpose
- a = np.arange(12).reshape(3,4)
- print ('原数组:')
- print (a )
- print ('\n')
- print ('对换数组:')
- print (np.transpose(a))
- print('-------------------')
- print(a.T)
原数组:
- [[ 0 1 2 3]
- [ 4 5 6 7]
- [ 8 9 10 11]]
对换数组:
- [[ 0 4 8]
- [ 1 5 9]
- [ 2 6 10]
- [ 3 7 11]]
- -------------------
- [[ 0 4 8]
- [ 1 5 9]
- [ 2 6 10]
- [ 3 7 11]]
- In [134]:
- # 轴的理解
- In [277]:
- a = np.array([[78, 34, 87, 25, 83], [25, 67, 97, 22, 13], [78, 43, 87, 45, 89]])
- print(a)
- print('-------------------')
- print(a.max(axis=0))
- print(a.max(axis=1))
- #axis=0 就是竖轴的数据 axis=1 就是横轴的
- [[78 34 87 25 83]
- [25 67 97 22 13]
- [78 43 87 45 89]]
- -------------------
- [78 67 97 45 89]
- [87 97 89]
- In [278]:
- a = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]])
- print(a.shape)
- print(a)
- print('--------------')
- print(a.max(axis=0))
- print('-----------')
- print(a.max(axis=1))
- print('-------------')
- print(a.max(axis=2))
- # 这里的最大值就是把一个一维数组当成了一个元素
- (2, 2, 2)
- [[[0 1]
- [2 3]]
- [[4 5]
- [6 7]]]
- --------------
- [[4 5]
- [6 7]]
- -----------
- [[2 3]
- [6 7]]
- -------------
- [[1 3]
- [5 7]]
- In [279]:
- # numpy.rollaxis 函数向后滚动特定的轴到一个特定位置
- # numpy.rollaxis(arr, axis, start)
- # arr: 数组
- # axis: 要向后滚动的轴, 其它轴的相对位置不会改变
- # start: 默认为零, 表示完整的滚动. 会滚动到特定位置.
- # 创建了三维的 ndarray
- a = np.arange(8).reshape(2,2,2)
- print ('原数组:')
- print (a)
- print ('\n')
- # 将轴 2 滚动到轴 0(宽度到深度)
- # 程序运行 np.rollaxis(a, 2)时, 讲轴 2 滚动到了轴 0 前面, 其他轴相对 2 轴位置不变(start 默认 0), 数组下标排序由 0,1,2 变成了 1,2,0
- print ('调用 rollaxis 函数:')
- print (np.rollaxis(a,2))
- # 将轴 0 滚动到轴 1:(宽度到高度)
- print ('\n')
- print ('调用 rollaxis 函数:')
- print (np.rollaxis(a,2,1))
原数组:
- [[[0 1]
- [2 3]]
- [[4 5]
- [6 7]]]
调用 rollaxis 函数:
- [[[0 2]
- [4 6]]
- [[1 3]
- [5 7]]]
调用 rollaxis 函数:
- [[[0 2]
- [1 3]]
- [[4 6]
- [5 7]]]
- In [136]:
- # numpy.swapaxes 函数用于交换数组的两个轴 numpy.swapaxes(arr, axis1, axis2)
- # arr: 输入的数组
- # axis1: 对应第一个轴的整数
- # axis2: 对应第二个轴的整数
- # 创建了三维的 ndarray
- a = np.arange(8).reshape(2,2,2)
- print ('原数组:')
- print (a)
- print ('\n')
- # 现在交换轴 0(深度方向)到轴 2(宽度方向)
- print ('调用 swapaxes 函数后的数组:')
- print (np.swapaxes(a, 2, 0))
原数组:
- [[[0 1]
- [2 3]]
- [[4 5]
- [6 7]]]
调用 swapaxes 函数后的数组:
- [[[0 4]
- [2 6]]
- [[1 5]
- [3 7]]]
- In [137]:
- # 随机数组
- In [280]:
- # 随机创建 指定形状的数组 0-1 之间的数
- np.random.rand(5)
- Out[280]:
- array([0.30169196, 0.9670064 , 0.47162448, 0.62679488, 0.73837024])
- In [281]:
- np.random.rand(5,5, 5)
- Out[281]:
- array([[[0.89417906, 0.70946608, 0.38672627, 0.76701869, 0.78554922],
- [0.8395321 , 0.6066907 , 0.92352055, 0.9223712 , 0.79842334],
- [0.48239551, 0.01127968, 0.23233443, 0.33877177, 0.84191728],
- [0.31445345, 0.69452591, 0.29333318, 0.46591799, 0.35955757],
- [0.83014411, 0.66361905, 0.2745486 , 0.44315133, 0.11167157]],
- [[0.2932468 , 0.51403315, 0.53770464, 0.81108324, 0.76383529],
- [0.97409406, 0.40976911, 0.21684626, 0.06193826, 0.99271513],
- [0.96543415, 0.6577333 , 0.28238376, 0.82693036, 0.29221568],
- [0.10894843, 0.40101362, 0.87845106, 0.84427336, 0.75716817],
- [0.07480796, 0.19393097, 0.7915619 , 0.4755644 , 0.52351122]],
- [[0.14791434, 0.90730496, 0.14768148, 0.93386785, 0.61918179],
- [0.27887145, 0.82167391, 0.96227453, 0.31035279, 0.96435175],
- [0.61742694, 0.3994602 , 0.9876201 , 0.17050054, 0.80599466],
- [0.93448767, 0.93377353, 0.17567329, 0.35896092, 0.86895971],
- [0.57438796, 0.2828866 , 0.39134851, 0.25140481, 0.37755792]],
- [[0.73122306, 0.41387161, 0.73493688, 0.56681141, 0.38409986],
- [0.62762826, 0.72740016, 0.03333494, 0.2724378 , 0.87094496],
- [0.36300417, 0.06047278, 0.19580073, 0.5297497 , 0.36031132],
- [0.27977137, 0.3582478 , 0.93715713, 0.77016022, 0.5999013 ],
- [0.48798223, 0.24158915, 0.97154431, 0.35866503, 0.54551312]],
- [[0.13168029, 0.61278339, 0.27324304, 0.12304226, 0.90762162],
- [0.98750724, 0.67448499, 0.44045933, 0.1650775 , 0.63162946],
- [0.65731927, 0.39280892, 0.72215663, 0.66654893, 0.53636512],
- [0.33444494, 0.92841366, 0.931691 , 0.06398883, 0.31514842],
- [0.01835854, 0.60237696, 0.03410581, 0.20646853, 0.23836661]]])
- In [282]:
- # 随机获取指定范围的一个数
- np.random.uniform(0,100)
- Out[282]:
- 22.56103050009125
- In [283]:
- # 随机获取指定范围的一个整数
- np.random.randint(0,52)
- Out[283]:
- 35
- In [284]:
- np.random.randint(0,20,size=(3,4))
- Out[284]:
- array([[ 7, 15, 8, 15],
- [ 6, 19, 10, 9],
- [ 0, 18, 16, 10]])
- In [144]:
- np.random.randint(0,20,size=(5,4))
- Out[144]:
- array([[15, 5, 16, 16],
- [ 0, 4, 2, 0],
- [13, 12, 15, 7],
- [14, 9, 10, 16],
- [11, 15, 10, 1]])
- In [145]:
- # np.random.choice(F,N,P)
- # 从 0-F 范围里面去 N 个数(不包含 N),P 表示概率
- np.random.choice(2,2)
- Out[145]:
- array([1, 1])
- In [288]:
- a1 = np.random.choice(5,3,p=[0.2,0,0.5,0.3,0])
- a1
- Out[288]:
- array([0, 3, 2], dtype=int32)
- In [150]:
- b = np.random.randint(0,20,size=(5,4))
- print(b)
- [[16 18 0 1]
- [ 3 2 5 19]
- [ 2 17 10 16]
- [10 5 1 7]
- [11 5 14 12]]
- In [151]:
- np.random.shuffle(b)
- print(b)
- [[ 2 17 10 16]
- [16 18 0 1]
- [ 3 2 5 19]
- [11 5 14 12]
- [10 5 1 7]]
- In [152]:
- # 计算
- In [153]:
- a = [1,2,3,4]
- b= np.array(a,dtype='float')
- b
- Out[153]:
- array([1., 2., 3., 4.])
- In [154]:
- b+1
- Out[154]:
- array([2., 3., 4., 5.])
- In [155]:
- b
- Out[155]:
- array([1., 2., 3., 4.])
- In [156]:
- a = np.array([1,3,5,7])
- a
- Out[156]:
- array([1, 3, 5, 7])
- In [157]:
- # 同纬度且个数相同的数组相加
- a+b
- Out[157]:
- array([ 2., 5., 8., 11.])
- In [289]:
- # 数组 a 中大于 3 的数就会显示 True 小于 3 的数就会显示 False
- a[a>3]
- Out[289]:
- array([4, 5, 6, 7])
- In [159]:
- print(a) a[a>3]
- [1 3 5 7]
- Out[159]:
- array([5, 7])
- In [161]:
- c = np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15])
- c
- Out[161]:
- array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
- In [290]:
- # 求出 c 中大于 5 且为偶数的元素
- c[(c>5) & (c%2==0)]
- Out[290]:
- array([ 6, 8, 10])
- In [292]:
- d=np.array([1.1,2.2,3.3,4.4,5.5,6.6,7.7])
- d
- Out[292]:
- array([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7])
- In [294]:
- # 向上取整
- print(np.ceil(d))
- # 向下取整
- print(np.floor(d))
- # 绝对值
- print(np.abs(d))
- # 开方
- print(np.sqrt(b))
- # 分别去除小数部分和整数部分
- print('------------------')
- print(np.modf(d))
- # e 为底的指数函数
- print(np.exp(d))
- print(np.log(d))
- # 四舍五入
- print(np.round(d))
- print('------------------')
- print(np.rint(d))
- # 向 0 取整
- print(np.trunc(d))
- # 是否不等于任何整数
- print(np.isnan(d))
- #
- print(np.cos(b))
- print(np.sin(b))
- print(np.tan(b))
- # 上述操作 对普通列表 也实用
[2. 3. 4. 5. 6. 7. 8.]
[1. 2. 3. 4. 5. 6. 7.]
- [1.1 2.2 3.3 4.4 5.5 6.6 7.7]
- [7.41619849 1. 1.41421356 1.73205081 2. 2.23606798
- 2.44948974 2.64575131 2.82842712 3. 3.16227766 3.31662479]
- ------------------
- (array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7]), array([1., 2., 3., 4., 5., 6., 7.]))
- [ 3.00416602 9.0250135 27.11263892 81.45086866 244.69193226
- 735.09518924 2208.34799189]
- [0.09531018 0.78845736 1.19392247 1.48160454 1.70474809 1.88706965
- 2.04122033]
[1. 2. 3. 4. 6. 7. 8.]
------------------
[1. 2. 3. 4. 6. 7. 8.]
[1. 2. 3. 4. 5. 6. 7.]
- [False False False False False False False]
- [ 0.02212676 0.54030231 -0.41614684 -0.9899925 -0.65364362 0.28366219
- 0.96017029 0.75390225 -0.14550003 -0.91113026 -0.83907153 0.0044257 ]
- [-0.99975517 0.84147098 0.90929743 0.14112001 -0.7568025 -0.95892427
- -0.2794155 0.6569866 0.98935825 0.41211849 -0.54402111 -0.99999021]
- [-4.51830879e+01 1.55740772e+00 -2.18503986e+00 -1.42546543e-01
- 1.15782128e+00 -3.38051501e+00 -2.91006191e-01 8.71447983e-01
- -6.79971146e+00 -4.52315659e-01 6.48360827e-01 -2.25950846e+02]
- In [295]:
- print(d)
- print('-------------------------')
- # 求和
- print(d.sum())
- # 平均值
- print(d.mean())
- # 等差数列
- print(d.cumsum())
- # 标准差
- print(d.std())
- # 方差
- print(d.var())
- # 最小值
- print(d.min())
- # 最大值
- print(d.max())
- print('---------------')
- # 最大值索引
- print(d.argmin())
- # 最小值索引
- print(d.argmax())
- [1.1 2.2 3.3 4.4 5.5 6.6 7.7]
- -------------------------
- 30.8
- 4.4
- [ 1.1 3.3 6.6 11. 16.5 23.1 30.8]
- 2.2
- 4.840000000000001
- 1.1
- 7.7
- ---------------
- 0
- 6
- In [297]:
- a = np.array( [20,30,40,50] )
- b = np.arange( 4 )
- print(a)
- print('-----')
- print(b)
- [20 30 40 50]
- -----
- [0 1 2 3]
- In [298]:
- c = a-b c
- Out[298]:
- array([20, 29, 38, 47])
- In [174]:
- b**2
- Out[174]:
- array([0, 1, 4, 9], dtype=int32)
- In [175]:
- 10*np.sin(a)
- Out[175]:
- array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])
- In [307]:
- # 与许多矩阵语言不同, 乘法运算符 * 的运算在 NumPy 数组中是元素级别的. 矩阵乘积可以使用 dot 函数或方法执行
- a = np.array( [[1,1,1],[0,1,1]] )
- a
- Out[307]:
- array([[1, 1, 1],
- [0, 1, 1]])
- In [317]:
- b = np.array( [[2,0], [3,4], [1,1] ])
- b
- Out[317]:
- array([[2, 0],
- [3, 4],
- [1, 1]])
- In [315]:
- a*b
- Out[315]:
- array([[2, 0, 1],
- [0, 4, 1]])
- In [318]:
- a.dot(b)
- Out[318]:
- array([[6, 5],
- [4, 5]])
- In [319]:
- a = np.ones((2,3), dtype=int)
- a
- Out[319]:
- array([[1, 1, 1],
- [1, 1, 1]])
- In [320]:
- a*=3 a
- Out[320]:
- array([[3, 3, 3],
- [3, 3, 3]])
- In [322]:
- b = np.random.randint(0,6, size=(2,3))
- b
- Out[322]:
- array([[1, 3, 2],
- [1, 0, 2]])
- In [323]:
- b+=a b
- Out[323]:
- array([[4, 6, 5],
- [4, 3, 5]])
- In [325]:
- print(a)
- print(b)
- a+=b
- a
- [[7 9 8]
- [7 6 8]]
- [[4 6 5]
- [4 3 5]]
- Out[325]:
- array([[11, 15, 13],
- [11, 9, 13]])
- In [ ]:
- # 复制和视图
- In [ ]:
- # NumPy 中, 数组的复制有三种方式:
- # Python 通用的地址复制: 通过 b = a 复制 a 的值, b 与 a 指向同一地址, 改变 b 同时也改变 a.
- # 通过视图 ndarray.view()仅复制值, 当对 c 值进行改变会改变 a 的对应的值, 而改变 c 的 shape 不改变 a 的 shape.
- # ndarray.copy() 进行的完整的拷贝, 产生一份完全相同的独立的复制.
- In [210]:
- a = np.arange(12) a
- Out[210]:
- array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
- In [211]:
- b=a a is b
- Out[211]:
- True
- In [212]:
- c = a.view() c
- Out[212]:
- array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
- In [326]:
- a is c
- Out[326]:
- False
- In [216]:
- c.shape = 2,6 c
- Out[216]:
- array([[ 0, 1, 2, 3, 4, 5],
- [ 6, 7, 8, 9, 10, 11]])
- In [217]:
- c [0,0] = 55 a
- Out[217]:
- array([55, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
- In [218]:
- d = a.copy() d is a
- Out[218]:
- False
- In [219]:
- d
- Out[219]:
- array([55, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
- In [221]:
- d.shape = 2,6 d
- Out[221]:
- array([[55, 1, 2, 3, 4, 5],
- [ 6, 7, 8, 9, 10, 11]])
- In [222]:
- d[1,1] = 22 a
- Out[222]:
- array([55, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
- In [ ]:
- In [ ]:
来源: http://www.bubuko.com/infodetail-3012722.html