NumPy库入门
目录
1、数据的维度
维度：一组数据的组织形式
-
一维数据
一维数据由对等关系的有序或无序数据构成，采用线性方式组织
3.1314,3.1415,3.1498,3.1678 对应列表、数组和集合等概念，其中数组类型是其他编程语言的数据类型
******************************
数组和列表都是一组有序结构的数据
数组：元素数据类型相同
列表：元素数据类型可以不同
******************************
-
二维数据
二维数据是由多个一维数据构成，是一维数据的组合形式
表格是典型的二维数据，其中表头是二位数的一部分
-
多维数据
多维数据由一维数据或二维数据在新维度（比如时间）上扩展形成
-
高维数据
高维数据仅利用最基本的二元关系展示数据间的复杂结构
高维数据就是使用键值对将数据组织起来形成的数据方式
{ 'first_name':"Tian", 'last_name':"Song", 'address':{ 'street_addr':'中关村南大街5号', 'city':"北京", 'zipcode':"100081" }, 'prof':["computer system","security"] }
2、数据维度的python表示
-
一维数据
列表和集合类型，其内包含的元素即为一维元素
-
二维数据
列表，以列表作为二维元素
-
多维数据
列表，以列表作为多维元素
-
高维数据
字典类型或者数据表示格式，
json,pickle等
3、NumPy
一个开源的python科学计算基础库
SciPy、Pandas等数据处理或科学计算库的基础
3.1 N维数组对象：ndarray
- ndarray 是一个多维数组对象，由两部分构成：
- 实际的数据
- 描述这些数据的元数据（数据维度，数据类型等）
- ndarray 数组一般要求所有元素类型相同（同质），数组下标从0开始
np.array()生成一个ndarray数组， ndarray在程序中的别名是：array，打印时以[]格式输出，元素间以空格分隔
In [9]:a = np.array([[1,2,3,4,5],[2,3,5,7,9],[4,6,7,8,10]])
In [10]:a
Out[10]:
array([[ 1, 2, 3, 4, 5],
[ 2, 3, 5, 7, 9],
[ 4, 6, 7, 8, 10]])
In [11]:print(a)
[[ 1 2 3 4 5]
[ 2 3 5 7 9]
[ 4 6 7 8 10]]
-
ndarray对象的属性
属性 说明 .ndim 秩，即轴的数量或维度的数量 .shape ndarray对象的尺度，对于矩阵，n行m列 .size ndarray对象元素的个数，相当于.shape中的n*m的值 .dtype ndarray对象元素的数据类型 .itemsize ndarray对象中每个元素的大小，以字节为单位 实例：
In [12]:a = np.array([[1,2,3,4],[4,5,7,8]]) In [13]:a.ndim Out[13]: 2 In [14]:a.shape Out[14]: (2, 4) In [15]:a.size Out[15]: 8 In [16]:a.dtype Out[16]: dtype('int32') In [17]:a.itemsize Out[17]: 4 -
ndarray的元素类型
- 有符号
数据类型 说明 bool 布尔类型，True或False intc 与C语言中的int类型一致，一般是int32或者int64 intp 用于索引的整数，与c语言中的ssize_t一致，int32或int64 int8 字节长度的整数，取值：[-128,127] int16 16位长度的整数，取值：[-32768,32767] int32 32位长度的整数，取值：[-231,231-1] int64 64位长度的整数，取值：[-263,263-1] - 无符号
数据类型 说明 uint8 8位无符号整数，取值：[0,255] uint16 16位无符号整数，取值：[0,65535] uint32 32位无符号整数，取值：[0,232-1] uint64 64位无符号整数，取值：[0,264-1] float16 16位半精度浮点数：1位符号位，5位指数，10位尾数 float32 32位半精度浮点数：1位符号位，8位指数，32位尾数 float64 64位半精度浮点数：1位符号位，11位指数，52位尾数 - 对比pyton:
- python仅支持整数，浮点数和复数三种数字类型
- 科学计算涉及数据较多，对存储和性能都有较高要求
- 对元素类型精确定义，有助于NumPy合理使用存储空间并优化性能
- 对元素类型精确定义，有助于程序员对程序规模有合理评估
-
ndarray数组非同质对象元素
- 当ndarray元素数据类型并不相同，或者每一个元素的维度数据数量不相同，那么ndarray将每一个元素认为是一个对象（object）
- 当naarray的每一个元素数据类型都是一个对象的时候，ndarray又是一个同质的数组类型，只有当使用数据的时候，会发现数据的类型是不同的或者每一个元素的维度数据数量是不相同的，因此将这种情况叫非同质的ndarray对象
- 非同质ndarray对象无法有效发挥NumPy优势，尽量避免使用
实例：
In [25]: a = np.array([[1,2,3,4],[2,3,5]]) In [26]: a.shape Out[26]: (2,) In [27]: a.dtype Out[27]: dtype('O') In [28]: a Out[28]: array([list([1, 2, 3, 4]), list([2, 3, 5])], dtype=object) In [29]: a.itemsize Out[29]: 8 In [30]: a.size Out[30]: 2
3.2 ndarray数组的创建和变换
3.2.1 创建
-
从python中锋列表、元组等类型创建ndarray数组
x = np.array(list/tuple)x = np.array(list/tuple,dtype=np.float32)指定每一个ndarray数组元素的数据类型当np.array()不指定数据类型时，NumPy会根据数据情况关联一个dtype类型
实例：
In [37]: a = np.array([[1,2,3],(2,3,5),(0.3,2.5,8)]) In [38]: print(a) [[1. 2. 3. ] [2. 3. 5. ] [0.3 2.5 8. ]] In [39]: a.dtype Out[39]: dtype('float64') In [40]: a = np.array((1,2,3,4)) In [41]: print(a) [1 2 3 4] In [42]: a.dtype Out[42]: dtype('int32') In [43]: a.shape Out[43]: (4,) ************************* -
使用NumPy中函数创建ndarray数组，如：arange，ones，zeros等
函数 说明 np.arange(n) 类似range()函数，返回ndarray类型，元素从0到n-1 np.ones(shape) 根据shape生成一个全1数组，shape是元组类型 np.zeros(shape) 根据shape生成一个全0数组，shape是元组类型 np.full(shape,val) 根据shape生成一个数组，每个元素值都是val np.eye(n) 创建一个正方的n*n单位矩阵，对角线为1，其余为0 np.ones_like(a) 根据数组a的形状生成一个全1数组 np.zeros_like(a) 根据数组a的形状生成一个全0数组 np.full_like(a,val) 根据数组a的形状生成一个数组，每个元素值都是val np.linspace() 根据起止数据等间距的填充数据，形成数组 np.concatenate() 将两个或多个数组合并成一个新的数组 实例：np.linspace()/np.concatenate()
In [3]: a = np.linspace(1,10,3) In [4]: a.shape Out[4]: (3,) In [5]: a Out[5]: array([ 1. , 5.5, 10. ]) In [6]: b = np.linspace(1,10,3,endpoint=False) In [7]: b.shape Out[7]: (3,) In [8]: b Out[8]: array([1., 4., 7.]) In [9]: c = np.concatenate((a,b)) # 只能拼接c.shape相等的数组 In [10]: c.shape Out[10]: (6,) In [11]: c Out[11]: array([ 1. , 5.5, 10. , 1. , 4. , 7. ])
3.2.2 变换
对于创建后的ndarray数组，可以对其进行维度变换和元素类型变换，需要注意的是，总元素个数不会改变
a = np.ones((2,3,4),dtype=np.int32)
- 维度变换
| 方法 | 说明 |
|---|---|
| .reshape(shape) | 不改变数组元素，返回一个shape形状的数组，原数组不变 |
| .resize(shape) | 与.reshsape(shape)功能一致，但是会修改原数组 |
| .swapaxes(ax1,ax2) | 将数组n个维度中的两个维度进行调换 |
| .flatten() | 对数组进行降维，返回折叠后的一维数组，原数组不变 |
-
数据类型变换
new_a = a.astype(new_type)astype()方法一定会创建新的数组（原始数据的一个拷贝，即使两个类型一致）
-
ndarray数组向列表的转换
ls = a.tolist()实例：
In [3]: a Out[3]: array([[[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]], [[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]]]) In [4]: lis = a.tolist() In [5]: lis Out[5]: [[[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]], [[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]]] In [6]: lis[0] Out[6]: [[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]] In [7]: lis[0][2] Out[7]: [25, 25, 25, 25]
3.3 数组的操作
3.3.1 数组的索引和切片
-
一维数组的索引和切片
与python的列表类似：
- 正向递增索引
- 反向递减索引
- 顾头不顾尾，按步长取值
-
多维数组的索引和切片
- 索引：给出目标元素所在各个维度的索引，以逗号分隔
- 切片：按照一维数组切片的方式，将每个维度分别切片，最终求得综合结果
实例：
In [3]: a = np.arange(24).reshape((2,3,4)) In [4]: a Out[4]: array([[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]]) In [5]: b = a[1,2,3] # 按索引取值 In [6]: b Out[6]: 23 In [7]: c = a[:,1:,::2] # 切片取值 In [7]: c Out[8]: array([[[ 4, 6], [ 8, 10]], [[16, 18], [20, 22]]])
3.3.2 数组与标量之间的运算
数组与标量之间的运算，作用于数组的每一个元素
实例：求数组a与a的平均值的商b
In [3]: a = np.arange(24).reshape((2,3,4))
In [4]: a
Out[4]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
In [5]: area = a.mean()
In [6]: area
Out[6]: 11.5
In [7]: b = a/area # 求数组的平均值
In [8]: b
Out[8]:
array([[[0. , 0.08695652, 0.17391304, 0.26086957],
[0.34782609, 0.43478261, 0.52173913, 0.60869565],
[0.69565217, 0.7826087 , 0.86956522, 0.95652174]],
[[1.04347826, 1.13043478, 1.2173913 , 1.30434783],
[1.39130435, 1.47826087, 1.56521739, 1.65217391],
[1.73913043, 1.82608696, 1.91304348, 2. ]]])
3.3.3 NumPy 一元函数
对ndarray中的数据执行元素级运算的函数
| 函数 | 说明 |
|---|---|
| np.rint(x) | 计算数组各元素的四舍五入值 |
| np.modf(x) | 将数组各元素的整数和小数部分以两个独立数组形式返回 |
| np.cos(x) np.cosh(x) | 计算数组各元素的普通型余弦函数和双曲余弦函数 |
| np.sin(x) np.sinh(x) | 计算数组各元素的普通型正弦函数和双曲正弦函数 |
| np.tan(x) np.tanh(x) | 计算数组各元素的正切函数和双曲正切函数 |
| np.exp(x) | 计算数组各元素值的指数值 |
| np.sign(x) | 计算数组各元素的符号值，1(+)，0，-1(-) |
实例：
In [2]：a = np.arange(24).reshape((2,3,4))
In [3]：b = np.square(a)
In [4]：a
Out[4]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
In [5]：b
Out[5]:
array([[[ 0, 1, 4, 9],
[ 16, 25, 36, 49],
[ 64, 81, 100, 121]],
[[144, 169, 196, 225],
[256, 289, 324, 361],
[400, 441, 484, 529]]], dtype=int32)
In [6]：a = np.sqrt(a)
In [7]：a
Out[7]:
array([[[0. , 1. , 1.41421356, 1.73205081],
[2. , 2.23606798, 2.44948974, 2.64575131],
[2.82842712, 3. , 3.16227766, 3.31662479]],
[[3.46410162, 3.60555128, 3.74165739, 3.87298335],
[4. , 4.12310563, 4.24264069, 4.35889894],
[4.47213595, 4.58257569, 4.69041576, 4.79583152]]])
In [8]：c = np.modf(a)
In [9]：c
Out[9]:
(array([[[0. , 0. , 0.41421356, 0.73205081],
[0. , 0.23606798, 0.44948974, 0.64575131],
[0.82842712, 0. , 0.16227766, 0.31662479]],
[[0.46410162, 0.60555128, 0.74165739, 0.87298335],
[0. , 0.12310563, 0.24264069, 0.35889894],
[0.47213595, 0.58257569, 0.69041576, 0.79583152]]]),
array([[[0., 1., 1., 1.],
[2., 2., 2., 2.],
[2., 3., 3., 3.]],
[[3., 3., 3., 3.],
[4., 4., 4., 4.],
[4., 4., 4., 4.]]]))
In [10]：c.shape
Traceback (most recent call last):
File "<ipython-input-10-d6049491b182>", line 1, in <module>
c.shape
AttributeError: 'tuple' object has no attribute 'shape'
In [11]：c[0].shape
Out[11]: (2, 3, 4)
3.3.4 NumPy 二元函数
| 函数 | 说明 |
|---|---|
| + - * / ** | 两个数组各元素进行对应运算 |
| np.maximum(x,y) np.fmax() | 元素级的最大值计算 |
| np.minimum(x,y) np.fmin() | 元素级的最小值计算 |
| np.mod(x,y) | 元素级的模运算 |
| np.copysign(x,y) | 将数组y中的各元素值的符号赋值给数组x中对应元素 |
| > < >= <= == != | 算数比较，产生布尔型数组 |
注意：
若运算结果有一个值为浮点型，则所有结果均为浮点型。（即自动调节为包含范围最大的类型）
实例：
In [2]: a = np.arange(24).reshape((2,3,4))
In [3]: b = np.sqrt(a)
In [4]: a
Out[4]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
In [5]: b
Out[5]:
array([[[0. , 1. , 1.41421356, 1.73205081],
[2. , 2.23606798, 2.44948974, 2.64575131],
[2.82842712, 3. , 3.16227766, 3.31662479]],
[[3.46410162, 3.60555128, 3.74165739, 3.87298335],
[4. , 4.12310563, 4.24264069, 4.35889894],
[4.47213595, 4.58257569, 4.69041576, 4.79583152]]])
In [6]: c = np.maximum(a,b)
In [7]: c
Out[7]:
array([[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]],
[[12., 13., 14., 15.],
[16., 17., 18., 19.],
[20., 21., 22., 23.]]])
In [8]: a+a
Out[8]:
array([[[ 0, 2, 4, 6],
[ 8, 10, 12, 14],
[16, 18, 20, 22]],
[[24, 26, 28, 30],
[32, 34, 36, 38],
[40, 42, 44, 46]]])
