python --Numpy详解(科学计算)

安装

pip install numpy

什么是Numpy：Numeric Python

NumPy系统是Python的一种开源的数值计算扩展

• 一个强大的N维数组对象Array
• 比较成熟的（广播）函数库
• 用于整合C/C++和Fortran代码的工具包
• 实用的线性代数、傅里叶变换和随机数生成函数
• numpy和稀疏矩阵运算包scipy配合使用更加强大

详解

导包

import numpy as np

查看版本

print(np.__version__)  # 获取当前numpy版本号
# 1.21.3

创建ndarray

import numpy as np

t = np.array([1, 2, 3, 4])   # 一维数组
print(t, type(t))   
输出:
  [1 2 3 4] 



t = np.array([[1,2,3],[4,5,6]])  # 二维数组
print(t)  
输出: [[1 2 3 4]
	  [4 5 6 7]]

使用np的routines函数创建

np.ones(shape, dtype=None, order=‘C’)

注:函数返回给定形状和数据类型的新数组，其中元素的值设置为1。

• shape 形状是一个int或一个int元组，用于定义数组的大小。 如果我们仅指定一个int变量，则将返回一维数组。 对于一个整数元组，将返回给定形状的数组。

• dtype是一个可选参数，默认值为float。 它用于指定数组的数据类型，例如int。

• order该顺序定义是在内存中以行优先（C风格）还是列优先（F风格）顺序存储多维数组。

    t = np.ones([3, 3])
    print(t)
    输出：
     [[1. 1. 1.]
     [1. 1. 1.]
     [1. 1. 1.]]
  
  
    t = np.ones([3, 3], dtype=int)
    print(t)
    输出:
     [[1 1 1]
     [1 1 1]
     [1 1 1]]
  

  numpy.full(shape, fill_value, dtype=None, order=‘C’)[source]
  注:返回一个根据指定shape和type,并用fill_value填充的新数组。

• shape：整数或整数序列新数组的形态，单个值代表一维，参数传元组，元组中元素个数就代表是几维，例如， (2, 3) or 2.

• fill_value： 标量(无向量)填充数组的值

• dtype：数据类型，可选默认值为None
  查看要填充数组的值数据类型：np.array(fill_value).dtype。

• order：{‘C’, ‘F’}, 可选是否在内存中以行为主（C风格）或列为主（Fortran风格）连续（行或列)顺序存储多维数据。

    np.full((2,3), 3)  # 2行3列,填充值为3
    输出: 
     [[3, 3, 3],
      [3, 3, 3]]
  

numpy.eye(N, M=None, k=0, dtype=, order=‘C’)
注: 返回一个二维数组，其对角线元素为1，其余位置元素为0。

• N返回数组的行数

• M列数(不常用)

• K对角线的索引：0（默认值）代表主对角线，正整数代表上三角内的对角线，负整数代表下三角内的对角线。

• dtype返回数组的数值类型

• {‘C’, 'F}，可选参数是否在内存中以C或fortran(行或列)顺序存储多维数据，版本1.14.0中的新特性

    np.eye(5,k=1)  # 5行5列,从第1个元素为对角填充1
    返回值:维度为(N,M)的多维数组  除了第k条对角线上元素为1以外，其余元素均为0的数组
    输出:
    	[[0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.],
       [0., 0., 0., 0., 0.]]
  
  
    np.eye(3,4)  # 3行4列
    输出:
    	[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.]]
  

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
在指定的大间隔内，返回固定间隔的数据。他将返回“num”个等间距的样本，在区间[start, stop]中。其中，区间的结束端点可以被排除在外。

当‘endpoint=False’时,不包含该点。在这种情况下，队列包含除了“num+1"以外的所有等间距的样本。
要注意的是，当‘endpoint=False’时，步长会发生改变。

np.linspace(0,10,5)  # 返回0到10的等差数列(默认包含10)
输出：
  	[ 0. ,  2.5,  5. ,  7.5, 10. ]


np.linspace(1,11, 6, retstep=True)  # 返回步进差值,二元组
输出:
	([ 1.,  3.,  5.,  7.,  9., 11.]), 2.0)



注意:np.arange([start, ]stop, [step, ]dtype=None) # 返回等差数列,

区别：
	arange()类似于内置函数range()，通过指定开始值、终值和步长创建表示等差数列的一维数组，注意
	得到的结果数组不包含终值。

	linspace()通过指定开始值、终值和元素个数创建表示等差数列的一维数组，可以通过endpoint参数
	指定是否包含终值，默认值为True，即包含终值

np.random.randint(low, high=None, size=None, dtype=‘l’)
随机数组

import numpy as np

r = np.random.randint(0, 10, 6)
print(r)
# 输出: [1 0 1 3 6 4]

np.random.randn(d0, d1, …, dn)

np.random.randn(10)
# 每次都不一样
# 输出结果：
array([-1.74976547,  0.3426804 ,  1.1530358 , -0.25243604,  0.98132079,
        0.51421884,  0.22117967, -1.07004333, -0.18949583,  0.25500144])


//
np.random.seed(100) #随机的种子，有了种子，每次都一样
np.random.randn(10)

# 输出结果：
array([ 0.37332715, -0.2887605 ,  0.04985088, -0.93815832, -0.4087037 ,
     1.13352254,  0.52713526, -0.76014192, -0.97292788,  0.16290446])

np.random.random(size=None)

np.random.random(100)
# 每次每次都不一样
# 输出结果：
array([ 0.01150584,  0.52951883,  0.07689008,  0.72856545,  0.26700953,
        0.38506149,  0.56252666,  0.59974406,  0.38050248,  0.14719008,
        0.6360734 ,  0.27812695,  0.73241298,  0.10904588,  0.57071762,
        0.56808218,  0.33192772,  0.61444518,  0.07289501,  0.86464595,
        0.71140253,  0.3221285 ,  0.92556313,  0.26511829,  0.8487166 ,
        0.38634413,  0.32169243,  0.80473196,  0.92050868,  0.17325157,
        0.63503329,  0.89463233,  0.02796505,  0.04396453,  0.20603116,
        0.77663591,  0.96595455,  0.77823865,  0.90867045,  0.39274922,
        0.89526325,  0.26002297,  0.38606984,  0.69176715,  0.3170825 ,
        0.86994578,  0.35648567,  0.19945661,  0.16109699,  0.58245076,
        0.20239367,  0.7099113 ,  0.41444565,  0.16725785,  0.01170234,
        0.79989105,  0.76490449,  0.25418521,  0.55082581,  0.29550998,
        0.02919009,  0.32737646,  0.29171893,  0.67664205,  0.24447834,
        0.49631976,  0.41136961,  0.82478264,  0.76439988,  0.78829201,
        0.24360075,  0.26151563,  0.51388418,  0.19823452,  0.44097815,
        0.53198973,  0.50187154,  0.72374522,  0.11090765,  0.63469357,
        0.69199977,  0.97093079,  0.35920669,  0.86493051,  0.01984456,
        0.32219702,  0.58608421,  0.26591245,  0.51851213,  0.7896492 ,
        0.04914308,  0.28711285,  0.36225247,  0.21299697,  0.99046025,
        0.11375325,  0.70964612,  0.06599185,  0.47323442,  0.62003386])

///
np.random.random([3,3])
# 输出结果：
array([[ 0.37590691,  0.15563239,  0.7754904 ],
       [ 0.40353019,  0.59708594,  0.57000741],
    [ 0.33286511,  0.15678606,  0.58814922]])

np.random.normal(loc=0.0, scale=1.0)

np.random.normal(loc=0.0, scale=1.0)
# 输出: 0.9705556599476601

np.random.rand(d0,d1,…dn)

注：使用方法与np.random.randn()函数相同 
作用： 
通过本函数可以返回一个或一组服从“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1)，不包括1。 
应用：在深度学习的Dropout正则化方法中，可以用于生成dropout随机向量（dl），例如（keep_prob表
示保留神经元的比例）：dl = np.random.rand(al.shape[0],al.shape[1]) < keep_prob

np.random.rand(1,2,3)

# 输出: 
[[[0.77655108 0.94720402 0.60342525]
[0.09466063 0.67177335 0.9059549 ]]]

ndarray的属性

ndim：维度
shape：形状（各维度的长度）
size：总长度
dtype：元素类型

np.random.seed(0)
x = np.random.randint(10,size=(3,4,5))
print(x)

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

       [[5, 9, 8, 9, 4],
        [3, 0, 3, 5, 0],
        [2, 3, 8, 1, 3],
        [3, 3, 7, 0, 1]],

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

# 维度：x.ndim
# 形状，各维度的长度：x.shape
# 总长度：x.size
元素类型：x.dtype

ndarray的基本操作

索引

# 一维与列表完全一致 多维时同理
np.random.seed(1)
x = np.random.randint(10,size=[3,4,5])
print(x[2,0,0])
print(x)

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

 [[1 7 0 6 9]
  [9 7 6 9 1]
  [0 1 8 8 3]
  [9 8 7 3 6]]

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

切片

   np.random.seed(0)
   x = np.random.randint(100,size = (10,4))
   x
   
   # 输出结果：
   array([[44, 47, 64, 67],
          [67,  9, 83, 21],
          [36, 87, 70, 88],
          [88, 12, 58, 65],
          [39, 87, 46, 88],
          [81, 37, 25, 77],
          [72,  9, 20, 80],
          [69, 79, 47, 64],
          [82, 99, 88, 49],
          [29, 19, 19, 14]])
   
   # 切片：
   
   x[7:10]
   # 切片结果：
   array([[69, 79, 47, 64],
          [82, 99, 88, 49],
       [29, 19, 19, 14]])

变形

# 使用reshape函数，注意参数是一个tuple！
x = np.arange(0,16).reshape(4,4)
x

# 执行结果：
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

# 类型是：
type(x.shape)

级联

np.concatenate() 级联需要注意的点：
级联的参数是列表：一定要加中括号
维度必须相同
形状相符
【重点】级联的方向默认是shape这个tuple的第一个值所代表的维度方向
可通过axis参数改变级联的方向

x = np.array([1,2,3])
y = np.array([1,5,6,7,3,20])
x
    # 输出 array([1, 2, 3])
    # 输出 array([ 1,  5,  6,  7,  3, 20])
    
z = np.concatenate([x,y])
z
    # 输出 array([ 1,  2,  3,  1,  5,  6,  7,  3, 20])
z.shape
	# 输出 (9,)




#二维
x = np.array([[1,2,3],[4,5,6]])
x
    
array([[1, 2, 3],
       [4, 5, 6]])
    
x.shape
     (2,3)
    
p = np.concatenate([x,x]).shape
p
      (4, 3)

axis

import numpy as np
  x = np.array([[[1,2,3],[2,2,3],[3,3,3]],[[4,4,4],[5,5,5],[6,6,6]]])
  print(x)
  print(x.shape)
  
  # 输出：
  [[[1 2 3]
    [2 2 3]
    [3 3 3]]
  
   [[4 4 4]
    [5 5 5]
    [6 6 6]]]
  (2, 3, 3)
  
  /
  w = np.concatenate([x,x],axis = 0)
  print(w.shape)
  print(w)
  # 输出：
  (4, 3, 3)
  [[[1 2 3]
    [2 2 3]
    [3 3 3]]
  
   [[4 4 4]
    [5 5 5]
    [6 6 6]]
  
   [[1 2 3]
    [2 2 3]
    [3 3 3]]
  
   [[4 4 4]
    [5 5 5]
    [6 6 6]]]
  /
  w = np.concatenate([x,x],axis = 1)
  print(w.shape)
  print(w)
  # 输出：
  (2, 6, 3)
  [[[1 2 3]
    [2 2 3]
    [3 3 3]
    [1 2 3]
    [2 2 3]
    [3 3 3]]
  
   [[4 4 4]
    [5 5 5]
    [6 6 6]
    [4 4 4]
    [5 5 5]
    [6 6 6]]]
  //
  w = np.concatenate([x,x],axis = 2)
  print(w.shape)
  print(w)
  
  # 输出：
  (2, 3, 6)
  [[[1 2 3 1 2 3]
    [2 2 3 2 2 3]
    [3 3 3 3 3 3]]
  
   [[4 4 4 4 4 4]
 [5 5 5 5 5 5]
 [6 6 6 6 6 6]]]

np.hstack与np.vstack 水平级联与垂直级联

x = np.array([[1,1],[2,2],[3,3]])
      y = np.array([1,2,3])
      print(np.hstack(x))
      print(np.vstack(y))
      
      # 输出：
      [1 1 2 2 3 3]
      [[1]
    [2]
    [3]]

切分

np.split()

x = np.arange(1,10)
x

# 输出：
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
//
x1,x2,x3 = np.split(x,[3,5])
print(x1,x2,x3)
输出： [1 2 3] [4 5] [6 7 8 9]

np.hsplit()

x = np.arange(16).reshape(4,4)
  x
  # 输出：
  array([[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11],
         [12, 13, 14, 15]])
  //
  print(np.hsplit(x,[2,3]))
  # 输出：
  [array([[ 0,  1],[ 4,  5], [ 8,  9], [12, 13]]),
	 array([[ 2],  [ 6],  [10], [14]]), 
  		 array([[ 3],  [ 7],  [11],  [15]])]

np.vsplit()

 x = np.arange(16).reshape(4,4)
  x
  # 输出：
  array([[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11],
         [12, 13, 14, 15]])
  
  print(np.vsplit(x,[2,3]))
  //
  # 输出：
	[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]

副本

所有赋值运算不会为ndarray的任何元素创建副本。对赋值后的对象的操作也对原来的对象生效。

 a = np.array([1,2,3])
      b=a
      print(a,b)
      
      # 输出：
      [1 2 3] [1 2 3]
      
      //
      b[0]=2
      a
   # 输出：
   array([2, 2, 3])

可使用copy()函数创建副本

  a = np.array([1,2,3])
  b = a.copy()
  b
  # 输出：
  [1,2,3]
  
  //
  b[0]=3
  print(a,b)
  输出:  [1 2 3] [3 2 3]

ndarray的聚合操作

求和np.sum

import numpy as np
np.random.seed(0)
a = np.random.randint(1000,size = 100)
print(np.sum(a))
//

b = np.random.randint(1000,size = (3,4,5))
print(np.sum(b))

# 输出：
52397
32865

//
# 计算求和时间
%timeit np.sum(a)

# 输出：
2.63 µs ± 34.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

//
l = [1,2,3]
np.sum(l)

最大最小值：np.max/ np.min

其他聚合操作

# 求平均值
    np.mean(heights)
# 求最大值
    np.max(heights)
# 求最小值
    np.min(heights)
 # 计算标准差
    heights.std()

ndarray的矩阵操作

算术运算符(加减乘除)：

a = np.array([[1,2,3],
[4,5,6]])
a
# 输出：
array([[1, 2, 3],
       [4, 5, 6]])

//
a+1
# 输出：
array([[2, 3, 4],
       [5, 6, 7]])

//
a*2
# 输出：
array([[ 2,  4,  6],
       [ 8, 10, 12]])

//
a+[[1,4,9],[3,3,3]]
# 输出：
array([[ 2,  6, 12],
       [ 7,  8,  9]])

//
a*2-2
# 输出：
 array([[ 0,  2,  4],
    [ 6,  8, 10]])

矩阵积

a = np.array([[1,2,3],
    [4,5,6]])
    a
    # 输出：
    array([[1, 2, 3],
           [4, 5, 6]])
    
    //
    b = np.array([[1,1],
    [1,1],
    [1,1]])
    b
    
    # 输出：
    array([[1, 1],
           [1, 1],
           [1, 1]])
    
    //
    np.dot(a,b)
    # 输出：
 array([[ 6,  6],
        [15, 15]])

广播机制

【重要】ndarray广播机制的两条规则
规则一：为缺失的维度补1
规则二：假定缺失元素用已有值填充

# 例1： m = np.ones((2, 3)) a = np.arange(3) 求m+a
m = np.ones((2,3))
m
# 输出：
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

a = np.arange(3)
a
# 输出：
array([0, 1, 2])

m+a
# 输出：
array([[ 1.,  2.,  3.],
       [ 1.,  2.,  3.]])

# 例2： a = np.arange(3).reshape((3, 1)) b = np.arange(3) 求a+b
a = np.arange(3).reshape((3,1))
a
# 输出：
array([[0],
       [1],
       [2]])

b = np.arange(3)
b
# 输出：
array([0, 1, 2])

a+b
# 输出：
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4]])

# 习题 a = np.ones((4, 1)) b = np.arange(4) 求a+b
a = np.ones((4,1))
b = np.arange(4)
a+b

# 输出：
array([[ 1.,  2.,  3.,  4.],
       [ 1.,  2.,  3.,  4.],
    [ 1.,  2.,  3.,  4.],
    [ 1.,  2.,  3.,  4.]])

ndarray的排序

选择排序

import numpy as np
a = np.array([33,2,67,9,88,22,34])
def selectSort(x):
    for i in range(len(x)):
 swap = np.argmin(x[i:])+i
        [x[i],x[swap]] = [x[swap],x[i]]
selectSort(a)
 a
 
 # 输出：
 array([ 2,  9, 22, 33, 34, 67, 88])

快速排序

# np.sort()与ndarray.sort()都可以，但有区别：
#  1. np.sort()不改变输入
#  2. ndarray.sort()本地处理，不占用空间，但改变输入

# np.sort()不改变输入
np.random.seed(10)
a = np.random.randint(0,100,10)
b = np.random.randint(0,100,10)
print(a,b)
print(np.sort(a),a)

# 输入：
[ 9 15 64 28 89 93 29  8 73  0] [40 36 16 11 54 88 62 33 72 78]
[ 0  8  9 15 28 29 64 73 89 93] [ 9 15 64 28 89 93 29  8 73  0]


# ndarray.sort()本地处理，不占用空间，但改变输入
np.random.seed(20)
a = np.random.randint(0,100,10)
b = np.random.randint(0,100,10)
print(a,b)
print(a.sort(),a)

# 输出：
[99 90 15 95 28 90  9 20 75 22] [71 34 96 40 85 90 26 83 16 62]
None [ 9 15 20 22 28 75 90 90 95 99]