【Python】NumPy（一）：数据类型、创建数组及基本操作
小猪同学hy 2024-10-23 09:35:02 阅读 76
目录
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= 参数来指定类型。
我们来看例子：
<code># 将所需要用到的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’｝，按行或者按列存储数组。
示例：
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。
示例：
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，依次类推。
<code># 创建一个二维数组,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：用于指定新的形状；
注意：重置形状后的数组，如果没有赋给源数组，则原数组形状不会发送改变
示例：
<code>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'))code>
# 将二维数组按列展开
print(a.ravel(order='F'))code>
[ 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则是在原数组上直接进行操作。
两者区别在于 是否会影响到原数组。
以上就是本篇所有内容咯~
声明
本文内容仅代表作者观点，或转载于其他网站，本站不以此文作为商业用途
如有涉及侵权，请联系本站进行删除
转载本站原创文章，请注明来源及作者。