目录

​NumPy初识

1.什么是NumPy？

NumPy的应用

NumPy数据类型

Python基本数据类型

NumPy数据类型

NumPy数组

创建数组

1.使用numpy.array() 

2.使用arange()方法创建

3.使用linspace()创建等差数列

4使用zeros()创建数组

5.使用ones()创建数组

6.利用eye()方法创建数组

7.利用rand()创建随机数组

ndarray数组的属性

数组的基本操作

重置形状reshape

数组展开ravel

数组堆叠

数组轴移动moveaxis

数组轴位置交换swapaxes

数组拆分

数组插入insert

数组删除delete

 数组附加append

重设尺寸resize

resize和reshape的区别

---

NumPy初识

1.什么是NumPy？

NumPy作为数据分析的三剑客之一，是Python中用于科学计算和数据分析的一个开源扩展库，包含了一个强大的N维数组对象和一组函数，可以用来处理各种数组和矩阵运算。NumPy的核心是ndarray对象，是一个功能强大的N维数组对象，封装了n维同类数组，与Python内置的列表相比，NumPy数组的计算速度更快，适合处理大量的数据。

NumPy的应用

NumPy通常与SciPy（算法库）、Pandas（数据分析库）和Matplotlib（绘图库）一起使用。这种组合广泛应用于替代MatLab，进行数据分析或者机器学习。

NumPy数据类型

NumPy支持的数据类型要比Python内置的数据类型要多，基本上可以和C语言的数据类型对应，我们先来回顾一下Python的基本数据类型。

Python基本数据类型

在python中，支持的数字类型有以下5种：

类型	说明
int	整型，通常为int32或int64
long	仅在Python2中存在
float	浮点型
bool	布尔型
complex	复数型

NumPy数据类型

NumPy支持的数值类型更多，有以下：

类型	说明
bool_	布尔型数据类型（True或者False）
int_	默认的整数类型（类似C语言中的long，int32或int64）
intc	与C的int类型一样，一般是int32或int64
intp	用于索引的整数类型（类似C的ssize_t,一般情况下仍然是int32或int64）
int8	字节（-128 ~ 127）
int16	整数（-32768 ~ 32767）
int32	整数（-2147483648 ~ 2147483647）
int64	整数（-9223372036854775808 ~ 9223372036854775807）
uint8	无符号整数（0 ~ 255）
unit16	无符号整数（0 ~ 65535）
uint32	无符号整数（0 ~4294967295）
uint64	无符号整数（0 ~18446744073709551615）
float_	float64类型的缩写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

Numpy的这些数值类型都归于 dtype对象实例中。我们可以用 numpy.dtype(object，align，copy）来指定数据类型。若我们使用array，则可以在创建数组的同时，用 dtype= 参数来指定类型。

我们来看例子：

# 将所需要用到的Numpy导入
import numpy as np
# 利用NumPy中的array来创建数组,同时指定类型为int8
arr = np.array([1,2,3,4],dtype=np.int8)
# 查看数组同时查看类型
print(arr,arr.dtype)
# 如果想更改数组的类型，可以使用变量名.astype(type)
arr=arr.astype('float')
# 查看数组同时查看类型
print(arr,arr.dtype)

如果我们想要更改数组的数据类型，那么我们可以使用 数组名.astype('type') 的方式来更改，同时需要让数组重新接收一下返回的数组。

输出如下：

[1 2 3 4] int8
[1. 2. 3. 4.] float64

NumPy数组

在Numpy中，最核心的一个就是ndarray多维数组对象。区别于Python的标准类，有着处理高维数组的能力，也是数值计算中缺一不可的重要特性。

ndarray类具有以下6个参数：

• shape：数组的形状；
• dtype：数据类型；
• buffer：对象暴露缓存区接口；
• offset：偏移量；
• strides：步长；
• order：｛‘C’，‘F’｝，以行或列为主排列顺序。

创建数组

在NumPy中，创建 ndarray的方式有很多种，这里我们讲下常见的几种

1.使用numpy.array() 

array中的参数：

array（object，dtype=None，copy=True，order=None，subok=False，ndmin=0）

• object：表示一个数组序列。列表、元组等；
• dtype：可选参数，通过它可以改变数组的数据类型；
• copy：可选参数，当数据源是ndarray时，表示数组能否被复制，默认是True。
• order：可选参数，以哪种内存布局创建数组，有3个可选值：C（行序列）、 F（列序列）、 A（默认）；
• ndmin：可选参数，用于指定数组的维度；
• subok：可选参数，类型为bool值，默认是False。为True，使用object的内部数类型；False：使用object数组的数据类型。

示例：

# 创建一个一维数组
arr = np.array([1,2,3,4,5])
print('arr:',arr)

# 创建一个二维数组
arr2 = np.array([
    [1,2,3],
    [4,5,6]
])
print('arr2:',arr2)
#也可以使用元组
arr3 = np.array([
    (1,2,3,4),
    (5,6,7,8)
])
print('arr3:',arr3)

结果：

arr: [1 2 3 4 5]
arr2: [[1 2 3]
 [4 5 6]]
arr3: [[1 2 3 4]
 [5 6 7 8]]

2.使用arange()方法创建

除了上述的array(),我们还可以使用arange()方法来创建，

numpy.arange(start,stop,step,dtype)

•  stop：起始值，默认为0；
• stop：终止值（不包含）
• step：步长，即每次+/-的长度，默认1；
• dtype：返回ndarray的数据类型，如果没提供，会使用输入数据的类型。

示例：

# 若arange中的参数只有一个，说明要生成以步长为1，范围在[0,所给值)的新数组
arr = np.arange(20)
print(arr)
# 新建范围在[10,50)，步长为2的新数组
arr1 = np.arange(10,50,2)
print(arr1)

结果：

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48]

3.使用linspace()创建等差数列

linspace和arange一样，都能创建均匀间隔的数组。

linspace（start,stop,num=50,endpoint=True,retstep=False,dtype=None）

• start：序列的起始值；
• step：序列的结束值；
• num：生成的样本数，默认50；
• endpoint：布尔值，如果为真，则结束值（最后一个值恰好是结束值）也包含在序列中；
• retstep：布尔值，如果为真，返回间距；
• dtype：数组的类型。 

示例：

# 生成在1~10 ，总数为10个的数组
arr = np.linspace(1,10,num=10,endpoint=True)
print(arr)
#不包含10
arr = np.linspace(1,10,num=10,endpoint=False)
print(arr)

结果：

[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
[1.  1.9 2.8 3.7 4.6 5.5 6.4 7.3 8.2 9.1]

4使用zeros()创建数组

利用zeros()方法，我们可以创建一个全部为0的多维数组。

numpy.zeros(shape,dtype=None,order='C')

• shape：用于指定数组的形状，例如：（2，3）表示创建一个2行3列的全0数组；
• dtype：数据类型；
• order：｛‘C’，‘F’｝，按行或者按列存储数组。

示例：

# 新建一个2行3列的全0整型数组,
arr = np.zeros((2,3),'int64')
arr,arr.dtype

结果：

(array([[0, 0, 0],
        [0, 0, 0]], dtype=int64),
 dtype('int64'))

5.使用ones()创建数组

与上面的zeros()的参数一致，不过填充的是1。

示例：

# 新建一个2行3列的全1整型数组,
arr = np.ones((2,3),'int64')
arr,arr.dtype

结果：

(array([[1, 1, 1],
        [1, 1, 1]], dtype=int64),
 dtype('int64'))

6.利用eye()方法创建数组

numpy.eye() 用于创建一个二维数组，特点是k对角线上的值为1，其余值为0，可以理解为单位矩阵E。

eye(N,M=None,k=0,dtype=<type 'float'>)

• N：输出数组的行数；
• M：输出数组的列数；
• k：对角线索引：0（默认）是主对角线，正值指上对角线，负值表示下对角线。 

示例：

arr = np.eye(4,4)
arr,arr.dtype

结果：

(array([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]]),
 dtype('float64'))

7.利用rand()创建随机数组

在处理一些需要模拟随机数据的情况下，可以使用随机数组。会生成一个具有特点形状和大小的数组。

在NumPy中，random类下有三种方法：

random.rand() ：这个函数的参数是数组的维度；

random.randn()：这个函数的参数是数组的维度；

random.randint(low,high=None,size=None,dtype='|'):

• low：随机数最小值；
• high：随机数的最大值（不包含）;
• size：数组维度;
• dtype：数据类型，默认int。

示例：

# 生成3行4列的随机数数组
arr = np.random.rand(3,4)
arr,arr.dtype

# 生成4行4列的随机数数组
arr = np.random.randn(4,4)
arr,arr.dtype

# 生成4行4列的随机数数组
arr = np.random.randn(4,4)
arr,arr.dtype

结果：

(array([[0.66930943, 0.6543889 , 0.67554026, 0.95700263],
        [0.91809325, 0.45346589, 0.14391797, 0.29588364],
        [0.34052777, 0.38234875, 0.71249733, 0.19030281]]),
 dtype('float64'))

(array([[ 1.16236082,  0.25761912, -0.69193693, -0.45389874],
        [ 0.4289053 , -0.33901307,  3.15225338, -0.5902022 ],
        [ 1.021301  ,  0.22364381,  0.08164906,  0.04529836],
        [-0.49172765, -0.40732204, -0.97332439,  1.47626338]]),
 dtype('float64'))

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

ndarray数组的属性

 1.ndarray.ndim：表示数组的秩，一维数组的秩为1，二维数组的秩为2，三维为3，依次类推。

# 创建一个二维数组,reshape用于重新设置数组的形状
arr = np.arange(20).reshape(4,5)
print('arr:',arr)
print('数组的秩为：',arr.ndim)

arr: [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
数组的秩为： 2

2.ndarray.shape ：输出数组的形状

依旧用上面的例子：

print('数组的形状：',arr.shape)

数组的形状： (4, 5)

3.ndarray.size：输出数组元素个数

print('数组元素个数：',arr.size)

数组元素个数： 20

4.ndarray.itemsize：输出一个数组元素的字节数.

print('数组元素所占字节：',arr.itemsize)

数组元素所占字节： 4

5.ndarray.real 用来输出数组包含元素的实部。

print('数组的实部为：',arr.real)

数组的实部为： [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

6.ndarray.imag 用来输出数组包含元素的虚部。

print('数组的虚部为：',arr.imag)

数组的实部为： [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

7.ndarray.T用于数组的转值，与.transpose() 相同。

print('转置前：\n',arr)
print('数组转置后：\n',arr.T)

转置前：
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
数组转置后：
 [[ 0  5 10 15]
 [ 1  6 11 16]
 [ 2  7 12 17]
 [ 3  8 13 18]
 [ 4  9 14 19]]

数组的基本操作

在数组中，一个一维数组称为向量，二维数组称为矩阵，三维称为数据立方。

重置形状reshape

reshape可以在不改变数组数据的同时，改变数组的形状。

numpy.reshape(a,newshape) 

<==>

ndarray.reshape(newtype)

• a：表示原数组；
• newshape：用于指定新的形状； 

注意：重置形状后的数组，如果没有赋给源数组，则原数组形状不会发送改变

示例：

a = np.arange(20).reshape(4,5)
print('原数组为：\n',a)
print('改变后，数组为：\n',a.reshape(5,4))
# 重置形状后的数组，如果没有赋给源数组，则原数组形状不会发送改变

原数组为：
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
改变后，数组为：
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]]

数组展开ravel

ravel 的目的是将任意形状的数组变成一个一维数组。

numpy.ravel(a , oder='C')

a为要处理的数组

'F'：按列读取

'C'：按行读取

 示例：

# 将二维数组按行展开
print(a.ravel(order='C'))
# 将二维数组按列展开
print(a.ravel(order='F'))

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[ 0  5 10 15  1  6 11 16  2  7 12 17  3  8 13 18  4  9 14 19]

数组堆叠

在numpy中，相关的堆叠函数有：

• stack(arrays,axis)：沿着新轴连接数组的序列；
• column_stack()：将一维数组作为列堆叠到二维数组中；
• hstack()：按水平方向堆叠数组；
• vstack()：按竖直方向堆叠数组。

示例：

a = np.array([1,2,3])
b = np.array([4,5,6])
# 将a和b堆叠,按行堆叠（2*3）（水平方向）
print(np.stack((a,b),axis=0))
# 按列堆叠，生成3*2的数组（沿竖直方向）
print(np.stack((a,b),axis=1))

[[1 2 3]
 [4 5 6]]
[[1 4]
 [2 5]
 [3 6]]

数组轴移动moveaxis

moveaxis 可以将数组的轴移动到新的位置，改变数组的形状。

numpy.moveaxis(a, source , destination) 

• a：数组；
• source：要移动的轴的原始位置；
• destination：要移动的轴的目标位置。 

示例：

a = np.array([
    [  
        [1,2,3],
        [4,5,6]
    ],
    [  
        [7,8,9],
        [10,11,12]
    ]
])
print('数组的形状：',a.shape,'\na:',a)
a=np.moveaxis(a,0,-1)
print('数组改变轴位置后的形状：',a.shape,'\na:',a)

数组的形状： (2, 2, 3) 
a: [[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]
数组改变轴位置后的形状： (2, 3, 2) 
a: [[[ 1  7]
  [ 2  8]
  [ 3  9]]

 [[ 4 10]
  [ 5 11]
  [ 6 12]]]

数组轴位置交换swapaxes

和上面的moveaxis不同，这个是直接交换两个轴的位置。

numpy.swapaxes( a , axis1 ,axis2) 

• a：数组；
• axis1：需要交换的轴位置1；
• axis2：需要交换的轴位置2. 

示例：

a = np.array([
    [  
        [1,2,3],
        [4,5,6]
    ],
    [  
        [7,8,9],
        [10,11,12]
    ]
])

print('数组的形状：',a.shape)
np.swapaxes(a,0,-1).shape

数组的形状： (2, 2, 3)
(3, 2, 2)

数组拆分

在numpy中，数组拆分split有一系列相关的方法：

• split(arrays,indices_or_sections,axis):将数组拆分为多个子数组;
• dsplit(arrays,indices_or_sections)：按照深度方向将数组拆分为多个子数组;
• hsplit(arrays,indices_or_sections)：按照水平方向将数组拆分为多个子数组；
• vsplit(arrays,indices_or_sections)：按照垂直方向将数组拆分为多个子数组。

示例：

# 首先创建一个3*3的数组，
a = np.arange(9).reshape((3,3))
print(a)
# 再把数组a拆分成3个子数组，每个子数组的元素个数为3
np.split(a,3)

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

数组插入insert

 insert（arr，obj，values，axis）

•  arr：所要插入的数组；
• obj：要插入数组的目标位置；
• values：要插入的值或数组；
• anix：水平方向插入axis=0，竖直插入axis=1

示例：

a = np.arange(20).reshape(4,5)
b = np.arange(5)
print(a)
print(b)
#在a中按照水平方向插入第3行的位置
np.insert(a,2,b,axis=0)

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
[0 1 2 3 4]
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [ 0,  1,  2,  3,  4],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

数组删除delete

delete(arr, obj, axis) 

沿特定轴删除数组中的子数组，与insert类似。

示例：

以上面的插入为基础，删除插入的子数组。

# 删除第3行子数组
np.delete(a,2,axis=0)

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

 数组附加append

 numpy.append(arr, values, axis)

数组附加，其实就是在原数组的基础上按照设置的附加值和轴位置来附加即可。只能在添加到数组末尾。

注意：附加后，会返回一个一维数组。

示例：

a = np.arange(10).reshape(2,5)
b = np.arange(4)
np.append(a,b)

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

重设尺寸resize

除了前面的reshape，那么我们还可以使用resize，对数组的形状进行改变。

 resize(a ,new_shape)

 示例：

# 对数组的形状进行重设(先生成一个4*5的数组)
a = np.arange(20).reshape(4,5)
print(a.shape,'\n',a)

#进行重设，需要注意重设的行列乘积要等于原本的行列乘积
a.resize(2,10)
print(a.shape,'\n',a)

(4, 5) 
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
(2, 10) 
 [[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]]

resize和reshape的区别

两个方法都能改变数组的形状，但是reshape在改变数组的形状的时候，不会影响原数组，相当于拷贝了一份，而resize则是在原数组上直接进行操作。

两者区别在于 是否会影响到原数组。

---

以上就是本篇所有内容咯~