numpy 简介

 

 

 

 

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的数组，因为它具有一个轴。该轴的长度为3t1  = [[ 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

 

2int323(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)

 

2int326(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.14a7 = 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]:

# reshapea10 = 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]迭代后的数组：012345678

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：默认为零，表示完整的滚动。会滚动到特定位置。# 创建了三维的 ndarraya = 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：对应第二个轴的整数# 创建了三维的 ndarraya = 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的数就会显示Falsea[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.84.4[ 1.1  3.3  6.6 11.  16.5 23.1 30.8]2.24.8400000000000011.17.7---------------06

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-bc

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*=3a

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 =ab

Out[323]:

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

In [325]:

print(a)print(b)a =ba

 

[[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=aa 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,6c

Out[216]:

array([[ 0,  1,  2,  3,  4,  5],       [ 6,  7,  8,  9, 10, 11]])

In [217]:

c [0,0] = 55a

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,6d

Out[221]:

array([[55,  1,  2,  3,  4,  5],       [ 6,  7,  8,  9, 10, 11]])

In [222]:

d[1,1] = 22a

Out[222]:

array([55,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

In [ ]: In [ ]: 来源：http://www.icode9.com/content-4-91601.html