代码收藏家 【Python】NumPy（一）：数据类型、创建数组及基本操作
目录
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.] float64NumPy数组
在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）
示例：
# 创建一个一维数组
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)
示例：
# 若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）
示例：
# 生成在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')
示例：
# 新建一个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'>)
示例：
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='|'):
示例：
# 生成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]]
数组的秩为： 22.ndarray.shape ：输出数组的形状
依旧用上面的例子：
print('数组的形状：',arr.shape)数组的形状： (4, 5)3.ndarray.size：输出数组元素个数
print('数组元素个数：',arr.size)数组元素个数： 204.ndarray.itemsize：输出一个数组元素的字节数.
print('数组元素所占字节：',arr.itemsize)数组元素所占字节： 45.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 = 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中，相关的堆叠函数有：
示例：
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 = 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 = 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有一系列相关的方法：
示例：
# 首先创建一个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）
示例：
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则是在原数组上直接进行操作。
两者区别在于 是否会影响到原数组。
以上就是本篇所有内容咯~
作者：小猪同学hy
