NumPy库学习笔记

目录

​ NumPy的数据类型

​ 数组

​ 数组的属性

​ 创建数组

​ 数组的运算

​ 数组的索引与切片

​ 数组的合并

​ 数组的分割

关于NumPy

Numeric Python，NumPy是一个由多维数组对象和用于处理数组的历程集合而成的库。可用于数据分析。ndarray是numpy中一种重要的N维数组类型，ndarray中的每个元素在内存中使用相同大小的块。

• NumPy可以实现矩阵的运算，线代的计算
• NumPy用于数组的运算

引入NumPy库

import numpy as np

​ 这样’'可以用np来指代NumPy，让代码更简洁一些

NumPy的数据类型

序号	数据类型及描述
1.	bool_ 存储为一个字节的布尔值（真或假）
2.	int_ 默认整数，相当于 C 的long，通常为int32或int64
3.	intc 相当于 C 的int，通常为int32或int64
4.	intp 用于索引的整数，相当于 C 的size_t，通常为int32或int64
5.	int8 字节（-128 ~ 127）
6.	int16 16 位整数（-32768 ~ 32767）
7.	int32 32 位整数（-2147483648 ~ 2147483647）
8.	int64 64 位整数（-9223372036854775808 ~ 9223372036854775807）
9.	uint8 8 位无符号整数（0 ~ 255）
10.	uint16 16 位无符号整数（0 ~ 65535）
11.	uint32 32 位无符号整数（0 ~ 4294967295）
12.	uint64 64 位无符号整数（0 ~ 18446744073709551615）
13.	float_ float64的简写
14.	float16 半精度浮点：符号位，5 位指数，10 位尾数
15.	float32 单精度浮点：符号位，8 位指数，23 位尾数
16.	float64 双精度浮点：符号位，11 位指数，52 位尾数
17.	complex_ complex128的简写
18.	complex64 复数，由两个 32 位浮点表示（实部和虚部）
19.	complex128 复数，由两个 64 位浮点表示（实部和虚部）

这里的表格是来自CSDN的博客：Python之Numpy详细教程_cs_程序猿的博客-CSDN博客_python numpy

数组

数组的属性

• array.shape可以输出数组形状：（行，列）
• array.size可以输出数组的大小（数组内包含数字的个数）
• array.ndim可以输出数组的维度

输入：

a=np.array([[1,1,1],[2,2,2]])
print(a.shape)
print(a.size)
print(a.ndim)

输出：

(2, 3)
6
2

创建数组

array的定义以及参数

​ np.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

• object 是需要被返回为数组的对象

• dtype 是数组所需要的数据类型

  ​ 输入：

  a=np.array([1, 2, 3], dtype='float')
  print(a)
  a=np.array([1, 2, 3], dtype='int')
  print(a)
  

  ​ 输出：

  [1. 2. 3.]
  [1 2 3]
  

  ​ 数组中的数据类型发生了变化

• copy 表示对象是否被复制，默认值True

  ​ 输入：

  a=np.array([1, 2, 3])
  b=np.array(a, copy=True)
  c=np.array([1, 2, 3])
  d=np.array(c, copy=False)
  print(b, d)
  a[0]=0
  c[0]=0
  print(b, d)
  

  ​ 输出：

  [1 2 3] [1 2 3]
  [1 2 3] [0 2 3]
  

  ​ 数组b通过copy参数实现了对数组a的深拷贝，而数组d则是对数组c进行了浅拷贝

• order 中‘C’表示按行储存数据，‘F’是按列储存数据，‘A’是任意 (决定以哪种内存布局创建数组)（还不清楚这个参数的作用）

• subok 决定了object的类，默认值为False

• ndmin 是对返回数组最小维度的设定

  ​ 输入：

  a=np.array([1,2,3], ndmin=1)
  b=np.array([1,2,3], ndmin=2)
  print(a)
  print(b)
  

  ​ 输出：

  [1 2 3]
  [[1 2 3]]
  

  ​ 这样，一维数组b就变成了2维的啦！！！

arange的定义以及参数

arange是类似range的，返回的数组是给定范围内按步长递增的数组成的

​ np.arange(start, stop, step, dtype)

• start 是起始值，默认0，包含在范围中
• stop 是终止值，不包含在范围中
• step 步长，默认1
• dtype 数据类型

linspace的定义以及参数

用于构造等差数列

linspace是将给定的范围进行划分，划为几等分则为操作者决定，返回的数组是给定范围内按划分间距递增的数组成的

​ np.linspase(start, stop, num, endpoint=True, retstep=False, dtype=None)

• start 是起始值
• stop 是终止值
• num 要生成的元素的数量，决定了几等分
• endpoint 是否包含终止值，默认‘是’
• relstep 是否显示间距
• dtype 数据类型

a = np.arange(1,10,1)
b = np.linspace(1,10,4)
print(a)
print(b)

输出：

[1 2 3 4 5 6 7 8 9]
[ 1.  4.  7. 10.]

logspace的定义以及参数

用于构造等比数组

​ np.logspace(start, stop, num, endpoint=True, base=10.0, dtype=None)

• start 幂的起始值
• stop 幂的终止值
• num 要生成的元素个数
• endpoint 是否包含终止值
• base 底数，默认10
• dtype 数据类型

a=np.logspace(0,9,9,endpoint=False,base=2,dtype=int)
print(a)

[  1   2   4   8  16  32  64 128 256]

其他

在numpy中也可以创建出空数组（列表也可以作为对象）

np.empty((2, 2))

[[6.23040373e-307 1.60219035e-306]
 [1.33508676e-307 6.23037996e-307]]

以及零数组

np.zeros((2, 2))

[[0. 0.]
 [0. 0.]]

空数组并不是全部数为零的零数组，空数组的数组元素为随机值，而且这些值都特别小

同样的，我们还可以创建全部为1的数组

a=np.ones((2, 2))

[[1. 1.]
 [1. 1.]]

创建随机数组：

a=np.random.random((2, 2))

[[0.90523976 0.73388109]
 [0.7964381  0.42749055]]

以上都是形状为（2，2）的数组

想要改变数组的形状为（1，4），可以

a=np.ones((2, 2))
b=a.reshape(1,4)

这样b就是改变了形状的a数组了

[[1. 1. 1. 1.]]

a = np.arange(1,10).reshape(3,3)

数组的运算

基本运算

四则运算 + - * / ，被执行运算的数组的行列相同，那结果就是元素与元素的运算

当两个数组的维度不同，但是低维度的数组通过追加维度达到两个数组形状一致，就会广播

a = np.array([[0,0,0],[10,10,10],[20,20,20],[30,30,30]])
b = np.array([1,2,3])
print(a+b)

[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

次方 ** 数组中每一个元素都次方

np.sin(a)，np.cos(a)，np.tan(a)对a数组中每一个元素取三角函数

矩阵运算

矩阵乘法

c=np.dot(a,b)
c=a.dot(b)

数组翻转

c=a.T
c=np.transpose(a)

对数组的统计运算

• 求数组中最大值：np.max(a)

• 求数组中最小值：np.min(a)

• 求数组的和：np.sum(a)

• 求数组的平均值：np.mean(a)

• 求数组的中位数：np.median(a)

• 返回数组的逐步叠加结果：np.cumsum(a)

  a=np.arange(12).reshape(3,4)
  print(np.cumsum(a))
  

  [ 0  1  3  6 10 15 21 28 36 45 55 66] #类似前缀和
  

• 返回相邻项的差：np.diff(a)

  a=np.arange(12).reshape(3,4)
  print(np.diff(a))
  

  [[1 1 1]
   [1 1 1]
   [1 1 1]]
  

• 找出数组中非零数：np.nonzero(a)

  a=np.arange(12).reshape(3,4)
  print(a)
  print(np.nonzero(a))
  

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

​ 对于这个返回结果，第一个array数组表示非零数在行的索引，第二个数组是非零数在列的索引

• 对数组的每一行进行排序：np.sort(a)

对于某行某列求平均值：

a=np.arange(12).reshape(3,4)
print(a)
print('axis为1，表示找出每行的最大值：', np.max(a,axis=1))
print('axis为0，表示找出每列的最大值：', np.max(a,axis=0))

输出：

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
axis为1，表示找出每行的最大值： [ 3  7 11]
axis为0，表示找出每列的最大值： [ 8  9 10 11]

同理，也可以通过axis参数来实现对每行每列的求和、求平均值

通过索引可以找出指定的某行某列的最小、最大值等…

数组的索引与切片

对一指定数组进行切片：

a=np.arange(12).reshape(3,4)
b=a[1]
c=a[1][2]
print(a)
print(b)
print(c)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[4 5 6 7]
6

当数组是多维的:

如 [1]，将返回与该索引相对应的行的数据

如是[1] [2]，将返回与该索引相对应的单个元素的数据

对于想切出一列的情况，可先将数组翻转，在切出行

a=np.arange(12).reshape(3,4)
b=a.T[1]
print(a)
print(b)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[1 5 9]

使用“ : ”，可以切出指定范围内的数

A[a:b+1 , c:d+1] 表示切出A数组中第a到b行，第c到d列的子数组

a=np.arange(12).reshape(4,3)
b=a[1:3]
c=a[1:]
d=a[0:2,1:3]
print(a, '\n')
print(b, '\n')
print(c, '\n')
print(d)

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]] 

[[3 4 5]
 [6 7 8]] 

[[ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]] 

[[1 2]
 [4 5]]

还可以使用反向的索引来切片：[-1]为最后一项

使用np.argmin(a)、np.argmax(a)，可以返回a数组中最小或最大的数的索引

该索引是从左往右，从上向下递增的

a=np.random.random((3,3))
print(a)
print(np.argmin(a))
print(np.argmax(a))

[[0.64407985 0.58074517 0.04224706]
 [0.89746915 0.31821219 0.89343054]
 [0.98018158 0.57462442 0.17798726]]
2
6

数组的合并

将a，b两个数组进行合并，可以上下合并，也可以左右合并

vstack

• 使用 np.vstack((a,b,…)) 进行纵向的合并 （列数应该是要一样的）

  a=np.array([1,1])
  b=np.array([2,2])
  print(np.vstack((a,b)))
  print(np.vstack((b,a)))
  

  [[1 1]
   [2 2]]
  [[2 2]
   [1 1]]
  

hstack

• 使用 np.hstack((a,b,…)) 进行横向合并 （行数应该是要一样的）

  a=np.array([1,1])
  b=np.array([2,2])
  print(np.hstack((a,b)))
  print(np.hstack((b,a)))
  

  [1 1 2 2]
  [2 2 1 1]
  

  可见a，b的顺序会对结果造成影响

concatenate

• 使用 np.concatenate((a,b,…),axis=0) 可以进行横纵向合并，只需要改变axis参数的值

  a=np.array([[1,1,1],[1,1,1]])
  b=np.array([[2,2,2],[2,2,2]])
  c=np.array([[3,3,3],[3,3,3]])
  print(np.concatenate([a,b,c], axis=1),'\n')
  print(np.concatenate([a,b,c], axis=0))
  

  [[1 1 1 2 2 2 3 3 3]
   [1 1 1 2 2 2 3 3 3]] 
  
  [[1 1 1]
   [1 1 1]
   [2 2 2]
   [2 2 2]
   [3 3 3]
   [3 3 3]]
  

  但是如果是一行的一维数组，则会报错

数组的分割

使用 np.split(a,num,axis=0) 可以将数组分割，其中num表示要进行几等分，参数axis则是决定纵向或横向分割

a=np.arange(12).reshape(3,4)
print(np.split(a,4,axis=1))

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

np.vsplit(a,num) 与 np.hsplit(a,num) 也可以对数组进行纵向或横向分割

先记这些，学到新的再来补充（> ▽ <）