我要评论NumPy 快速入门：数组对象，数组属性，花式索引等基础介绍
1、NumPy 简介：
NumPy （Numerical Python的简称）是高性能科学计算和数据分析的基础包，是想利用 Python 进行数据分析人士必须了解的模块之一。
由于各种原因 NumPy 模块并不是 Python 的标准模块，故需安装使用：
pip install numpy
导入 NumPy 模块时通常约定写成：
import numpy as np
numpy 主要功能：
- 提供 ndarray 对象：具有矢量算数运算和复杂广播能力的多维数组；
- 提供了许多可对数组对象直接运算的标准数学函数，而无需编写循环；
- 提供了用于读写磁盘数据的工具及用于操作内存映射文件的工具；
- 提供了线性代数、随机生成及傅里叶变换功能；
- 用于集成由 C 、C++、Fortran 等语言编写的代码的工具。
2、ndarray 数组对象：
ndarray 是指 NumPy 中的N维数组对象，是一个快速而灵活地大数据集容器。
3、创建数组：
array 函数： 可接收一切序列对象（包括其他数组对象），然后产生一个新的 NumPy 数组。
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 参数 | 含义 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型，可选 |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
简单示例：
import numpy as np # 导入模块，后面示例不再写
data = [6,7.5,8,0,1]
arr1 = np.array(data)
print(arr1) # [6. 7.5 8. 0. 1. ]
接收一个嵌套序列：
data2 = [[1,2,3,4],[5,6,7,8]]
arr2 = np.array(data2)
print(arr2)
'''
[[1 2 3 4]
[5 6 7 8]]
'''
解析： 除非设置数据类型（数据类型稍后会详细介绍），或者 array 函数会根据传入的序列选择适合的数据类型。
如，在上面 arr1 中，传入的列表中有 7.5 浮点数，所以创建的 arr1 数组类型为浮点型。
查看创建的数组数据类型：
print(arr1.dtype) # float64
print(arr2.dtype) # int32 或 int64 ，和安装的 Python 版本有关
其他创建数组的方法：
zeros 函数： 创建全 0 数组
# 创建一维数组
print(np.zeros(10)) # [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
# 创建多维数组
print(np.zeros((3,6)))
'''
[[0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0.]]
'''
empty 函数：
print(np.empty((2,3,2)))
'''
[[[8.74e-322 0.00e+000]
[0.00e+000 0.00e+000]
[0.00e+000 0.00e+000]]
[[0.00e+000 0.00e+000]
[0.00e+000 0.00e+000]
[0.00e+000 0.00e+000]]]
'''
arange 函数： 是 Python 内置函数 range 的数组版
# arange 函数
print(np.arange(15))
# [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
eye 函数： 创建一个单位矩阵
print(np.eye(3,3))
'''
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
'''
4、数组的数据类型：
NumPy 的一个数组对象里所有的数据都是同质的，即数组内 数据类型一致 。
设置、查看数组对象数据类型：
arr3 = np.array([1,2,3],dtype=np.float)
arr4 = np.array([1,2,3],dtype=np.int)
print(arr3.dtype,arr4.dtype)
# 打印结果
# float64 int32
转换数组数据类型：
arr5 = np.array([1,2,3,4,5])
print(arr5.dtype) # int32
float_arr5 = arr5.astype(np.float)
print(float_arr5.dtype) # float64
注：astype 会创建一个新的数组对象
自定义数据类型：
NumPy 也提供了自定义数组对象的数据类型方法。自定义数据类型是一种异构数据类型，可以当做记录一行数据的结构。
如：创建一个存储商店库存信息的数据类型，该库存信息有：商品名称、库存数量、商品价格。
# 创建数据类型
my_type = np.dtype([('name',np.str,40),('numitems',np.int),('price',np.float)])
print(my_type) # [('name', '<U40'), ('numitems', '<i4'), ('price', '<f8')]
# 创建数组
my_array = np.array([('DVD',42,3.14),('Butter',13,2.72)],dtype= my_type)
# 查看数组数据类型
print(my_array.dtype)
# [('name', '<U40'), ('numitems', '<i4'), ('price', '<f8')]
5、数组的结构：
数组对象的结构指的是数组的维度、轴的概念。
查看数组结构：
b = np.arange(24)
print(b.shape) # (24,)
改变数组结构：
reshape 方法：生成一个新的数组对象。
c = b.reshape(2,3,4) # 改变数组维度
print(c)
'''
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
'''
print(c.shape) # (2, 3, 4)
resize 方法： 原位改变数组结构。
g = np.arange(6)
print(g.shape) # (6,)
g.resize(2,3) # 会在原位修改数组结构
print(g)
'''
[[0 1 2]
[3 4 5]]
'''
print(g.shape) # (2, 3)
注：reshape 方法和 resize 都可改变数组维度，但是 reshape 改变数组结构时，会产生一个新的数组对象；而 resize 则是直接修改原数组的维度。
数组的转置：
arr3 = np.arange(6).reshape(2,3)
print(arr3)
'''
[[0 1 2]
[3 4 5]]
'''
arr4 = arr3.transpose()
print(arr4)
'''
[[0 3]
[1 4]
[2 5]]
'''
6、数组的简单计算：
NumPy 数组对象与 Python 原生序列最显著的区别之一就是在对序列中的数据执行批量运算，数组对象进行批量运算时，不需要编写循环可直接进行计算，及数组的矢量化。
这样也令其在大量数据计算时，运行效率明显提升。
数组与标量之间的运算：
arr6 = np.array([[1,2,3],[4,5,6]],dtype=float)
print(arr6)
'''
[[1. 2. 3.]
[4. 5. 6.]]
'''
# 加法
print(arr6 + 2)
'''
[[3. 4. 5.]
[6. 7. 8.]]
'''
# 乘法：
print(arr6*0.5)
'''
[[0.5 1. 1.5]
[2. 2.5 3. ]]
'''
数组与数组之间的运算：
大小相同的数组之间的任何算术运算都会讲运算应用到元素级：
# 减法
print(arr6-arr6)
'''
[[0. 0. 0.]
[0. 0. 0.]]
'''
# 乘法
print(arr6*arr6)
'''
[[ 1. 4. 9.]
[16. 25. 36.]]
'''
7、数组切片与索引：
一维数组的切片与索引：
arr7 = np.arange(10)
print(arr7) # [0 1 2 3 4 5 6 7 8 9]
print(arr7[5]) # 5
print(arr7[5:8]) # [5 6 7]
以上操作的结果和 Python 列表切片索引操作现象一致。
切片赋值操作：
对一个切片对象赋值：
arr7[0] = 10
print(arr7)
# [10 1 2 3 4 5 6 7 8 9]
对切片组赋值：
arr7[5:8] = 12
print(arr7)
# [10 1 2 3 4 12 12 12 8 9]
注：当将一个标量值给一个切片时，该值会自动传播到整个选取，这是和Python列表切片最重要的区别 ！
arr_slice = arr7[5:8]
arr_slice[1] = 12345
print(arr7)
# [ 0 1 2 3 4 12 12345 12 8 9]
arr_slice[:] = 64
print(arr7) # [ 0 1 2 3 4 64 64 64 8 9]
这是因为NumPy的设计目的是处理大数据，如要将数据多次复制（创建新的对象），会产生非常大的性能和内存问题。
高维数组的索引及切片：
二维数组：
arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr2d[2]) # [7 8 9]
# 以下两种方式效果一致
print(arr2d[0][2]) # 3
print(arr2d[0,2]) # 3
三维数组：
arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print(arr3d)
print(arr3d.shape) # (2, 2, 3)
'''
一个 2 x 2 x 3 数组
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
'''
print(arr3d[0])
'''
[[1 2 3]
[4 5 6]]
'''
标量值和数组都可被赋值给切片对象，如：
old_value = arr3d[0].copy() # 复制数组对象
arr3d[0] = 42
print(arr3d)
'''
[[[42 42 42]
[42 42 42]]
[[ 7 8 9]
[10 11 12]]]
'''
arr3d[0] = old_value
print(arr3d)
'''
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
'''
print(arr3d[1,0]) # [7 8 9]
布尔值切片：
这也是和 Python 原序列切片很大的不同之处，如：
先建立一个布尔序列：
names = np.array(['bob','joe','will','bob','will','joe','joe'])
# 数组的比较运算也是矢量化的，会产生一个布尔型数组
print(names == 'bob')
# [ True False False True False False False]
用布尔序列对数组进行切片操作：
data = np.random.rand(7,4) # 生成一些正态分布的随机数据
print(data)
'''
[[0.64831166 0.53764074 0.05100258 0.86194823]
[0.75817438 0.68161727 0.23507438 0.06506362]
[0.31393836 0.3548072 0.52740244 0.07263428]
[0.03731951 0.3401235 0.25695301 0.08632226]
[0.84201383 0.54950122 0.38923988 0.77718169]
[0.14664734 0.59178141 0.62562549 0.2584329 ]
[0.03764809 0.1270825 0.39032711 0.09212854]]
'''
# 布尔型数组可用于数组索引
print(data[names == 'bob'])
'''
[[0.64831166 0.53764074 0.05100258 0.86194823]
[0.03731951 0.3401235 0.25695301 0.08632226]]
'''
注：布尔型数组的长度必须和被索引的轴长度一致。
布尔型数组也可以跟切片、整数混合使用：
print(data[names == 'bob', 2:])
'''
[[0.05100258 0.86194823]
[0.25695301 0.08632226]]
'''
print(data[names == 'bob',3])
'''
[0.86194823 0.08632226]
'''
注意以下的一种用法：
# 将data中的所有小于0.5的值设置为0
data[data<0.5] = 0
print(data)
'''
[[0.64831166 0.53764074 0. 0.86194823]
[0.75817438 0.68161727 0. 0. ]
[0. 0. 0.52740244 0. ]
[0. 0. 0. 0. ]
[0.84201383 0.54950122 0. 0.77718169]
[0. 0.59178141 0.62562549 0. ]
[0. 0. 0. 0. ]]
'''
这在实现筛选数据功能上非常方便！
花式索引：
花式索引：NumPy术语，指利用整数数组进行索引，如：
arr9 = np.empty((8,4))
for i in range(8):
arr9[i] = i
print(arr9)
'''
[[0. 0. 0. 0.]
[1. 1. 1. 1.]
[2. 2. 2. 2.]
[3. 3. 3. 3.]
[4. 4. 4. 4.]
[5. 5. 5. 5.]
[6. 6. 6. 6.]
[7. 7. 7. 7.]]
'''
print(arr9[[4,3,0,6]])
'''
[[4. 4. 4. 4.]
[3. 3. 3. 3.]
[0. 0. 0. 0.]
[6. 6. 6. 6.]]
'''
使用负数会从末尾开始选取行：
print(arr9[[-1,-3,-7]])
[[7. 7. 7. 7.]
[5. 5. 5. 5.]
[1. 1. 1. 1.]]
'''
多个花式索引结合：
arr10 = np.arange(32).reshape((8,4))
print(arr10)
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]]
'''
print(arr10[[1,5,7,2],[0,3,1,2]]) # [ 4 23 29 10]
print(arr10[[1,5,7,2]][:,[0,3,1,2]])
'''
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
'''
注：花式索引和切片不一样，它总是将数据复制到新数组中。
8、数组的组合与切割：
水平组合：
a1 = np.arange(9).reshape(3,3)
a2 = a1 * 2
a3 = np.hstack((a1,a2))
print(a3)
'''
[[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
'''
使用 concatenate 函数进行水平组合
a4 = np.concatenate((a1,a2),axis=1)
print(a4)
'''
[[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
'''
垂直组合：
# 垂直组合
a5 = np.vstack((a1,a2))
print(a5)
'''
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 0 2 4]
[ 6 8 10]
[12 14 16]]
'''
# 使用 concatenate 函数进行垂直组合
a6 = np.concatenate((a1,a2),axis=0)
print(a6)
'''
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 0 2 4]
[ 6 8 10]
[12 14 16]]
'''
深度组合：
a7 = np.dstack((a1,a2))
print(a7)
'''
[[[ 0 0]
[ 1 2]
[ 2 4]]
[[ 3 6]
[ 4 8]
[ 5 10]]
[[ 6 12]
[ 7 14]
[ 8 16]]]
'''
注：深度组合，改变了数组的维度。
print(a1.shape,a2.shape,a7.shape)
# (3, 3) (3, 3) (3, 3, 2)
列组合：
# 列组合
b1 = np.arange(2)
b2 = b1 * 2
b3 = np.column_stack((b1,b2))
print(b3)
'''
[[0 0]
[1 2]]
'''
# 注意一维数组的列组合与水平组合的区别
b4 = np.hstack((b1,b2))
print(b4)
'''
[0 1 0 2]
'''
# 对于二维数组，列组合与水平组合效果相同
b5 = np.column_stack((a1,a2))
print(b5)
'''
[[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
'''
注：对于二维数组，列组合与水平组合效果相同。
行组合：
# 行组合
b6 = np.row_stack((b1,b2))
print(b6)
'''
[[0 1]
[0 2]]
'''
# 同样需注意一维数组的行组合与垂直组合的区别
# 对于二维数组，行组合与垂直组合效果一致
b6 = np.row_stack((a1,a2))
print(b6)
'''
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 0 2 4]
[ 6 8 10]
[12 14 16]]
'''
数组分割：
对应数组的组合，也包括数组的水平分割、垂直分割、深度分割。
c1 = np.arange(9).reshape(3,3)
print(c1)
'''
[[0 1 2]
[3 4 5]
[6 7 8]]
'''
# 水平分割
c2 = np.hsplit(c1,3)
print(c2)
'''
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
'''
print(type(c2)) # 获得一个包含数组的列表
# <class 'list'>
# split 函数进行水平分割
c3 = np.split(c1,3,axis=1)
print(c3)
'''
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
'''
# 垂直分割
c4 = np.vsplit(c1,3)
print(c4)
'''
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
'''
# 同样也可以用 split 函数实现垂直分割
c5 = np.split(c1,3,axis=0)
print(c5) # [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
# 深度分割
d1 = np.arange(27).reshape(3,3,3)
print(d1)
'''
[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]]
[[ 9 10 11]
[12 13 14]
[15 16 17]]
[[18 19 20]
[21 22 23]
[24 25 26]]]
'''
print(d1.shape) # (3, 3, 3)
d2 = np.dsplit(d1,3)
print(d2)
'''
[array([[[ 0],
[ 3],
[ 6]],
[[ 9],
[12],
[15]],
[[18],
[21],
[24]]]), array([[[ 1],
[ 4],
[ 7]],
[[10],
[13],
[16]],
[[19],
[22],
[25]]]), array([[[ 2],
[ 5],
[ 8]],
[[11],
[14],
[17]],
[[20],
[23],
[26]]])]
'''
for d_ in d2:
print(d_.shape)
# 深度分割将一个 3x3x3 数组切割为一个包含3个 3x3x1 数组的列表
'''
(3, 3, 1)
(3, 3, 1)
(3, 3, 1)
'''
9、数组的属性：
ndim 获取数组维度或轴个数：
e1 = np.arange(24).reshape(2,12)
print(e1)
'''
[[ 0 1 2 3 4 5 6 7 8 9 10 11]
[12 13 14 15 16 17 18 19 20 21 22 23]]
'''
# ndim 获取数组维度或轴个数
print(e1.ndim) # 2
size 获取数组元素总个数：
print(e1.size) # 24
itemsize 获取数组中元素在内存中所占字节数：
print(e1.itemsize) # 4
nbytes 获取数组对象所占储存空间：
print(e1.nbytes) # 96
注：总是等于 itemsize 值与 size 值的乘积。
flat 获取数组对象的扁平迭代器(flatiter)：
e2 = np.arange(9).reshape(3,3)
print(e2)
'''
[[0 1 2]
[3 4 5]
[6 7 8]]
'''
e_flat = e2.flat # 这是获取 flatiter 对象的唯一方式
print(e_flat) # <numpy.flatiter object at 0x000000000A1306C0>
for item in e_flat:
print(item,end=',')
# 0,1,2,3,4,5,6,7,8,
结尾：
以上就是本篇博客全部内容，感谢阅读。
本文地址：https://blog.csdn.net/zhouz92/article/details/107250364
您可能感兴趣的文章:
如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！
网友评论