Python_数据分析_numpy模块

numpy可以说是Python运用于人工智能和科学计算的一个重要基础，关于库的引入不做赘述，主要分享一些总结的numpy库的用法。

1. numpy数组对象

Numpy中的多维数组称为ndarray，这是Numpy中最常见的数组对象。ndarray对象通常包含两个部分：

• ndarray数据本身
• 描述数据的元数据

Numpy数组的优势

• Numpy数组通常是由相同种类的元素组成的，即数组中的数据项的类型一致。这样有一个好处，由于知道数组元素的类型相同，所以能快速确定存储数据所需空间的大小。
• Numpy数组能够运用向量化运算来处理整个数组，速度较快；而Python的列表则通常需要借助循环语句遍历列表，运行效率相对来说要差。
• Numpy使用了优化过的C API，运算速度较快

2 numpy数组（ndarray）的创建

2.1 array()

通过array方式创建，向array中传入一个list实现

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

print(array1)
print(array2)

[Runing] ============
[1 2 3]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

2.2 arange()

通过arange创建数组：下例中创建一个0~1间隔为0.1的行向量，从0开始，不包括1，第二个例子通过对齐广播方式生成一个多维的数组。

import numpy as np

array1 = np.arange(0, 1, 0.1)
array2 = np.arange(1, 70, 10).reshape(-1, 1) + np.arange(0, 7)
array3 = np.arange(24).reshape(2,3,4)

print(array1)
print(array2)
print(arrat3)

[Running]=======
[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

[[ 1  2  3  4  5  6  7]
 [11 12 13 14 15 16 17]
 [21 22 23 24 25 26 27]
 [31 32 33 34 35 36 37]
 [41 42 43 44 45 46 47]
 [51 52 53 54 55 56 57]
 [61 62 63 64 65 66 67]]
 
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]]])

2.3 linspace()&logspace()

通过linspace函数创建数组：下例中创建一个0~1间隔为1/9的行向量（按等差数列形式生成），从0开始，包括1.
通过logspace函数创建数组：下例中创建一个1~100，有20个元素的行向量（按等比数列形式生成），其中0表示10^{0=1，2表示10}2=100，从1开始，包括100

import numpy as np

array1 = np.linspace(0, 1, 10)
array2 = np.logspace(0, 2, 20)

print(array1)
print(array2)

[Running]===========
[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
 0.66666667 0.77777778 0.88888889 1.        ]
[  1.           1.27427499   1.62377674   2.06913808   2.6366509
   3.35981829   4.2813324    5.45559478   6.95192796   8.8586679
  11.28837892  14.38449888  18.32980711  23.35721469  29.76351442
  37.92690191  48.32930239  61.58482111  78.47599704 100.        ]

2.4 生成特殊数列

• ones、ones_like，根据形状创建一个全1的数组、后者可以复制其他数组的形状
• zeros、zeros_like，类似上面，全0
• empty、empty_like，创建新数组、只分配空间
• eye、identity，创建对角线为1的对角矩阵
  注意要指定数组的规模（用一个元组指定），同时要指定元素的类型，否则会报错。这部分函数较简单，不进行测试

2.5 生成随机数组

简单使用随机数生成数组和arange（）方法生成类似，更多生成方法可以更详细的查找阅读。

import numpy as np
from numpy.random import randn

arr = randn(12).reshape(3, 4)
print(arr)

[Running]========
 [[ 0.98655235  1.20830283 -0.72135183  0.40292924]
  [-0.05059849 -0.02714873 -0.62775486  0.83222997]
  [-0.84826071 -0.29484606 -0.76984902  0.09025059]]
 

3. dtype

Numpy的全部数据类型如下：

每一种数据类型都有相应的数据转换函数，创建数组是可以用dtype进行说明

import numpy as np

array1 = np.ones((2, 3), dtype = 'float')
array2 = np.array([1. ,2. ,3. ], dtype = 'int32')

print(array1)
print(array2)

[Running] =========
[[1. 1. 1.]
 [1. 1. 1.]]
 
[1 2 3]

4. ndarray()属性

4.1 dtype属性

ndarray数组的数据类型，数据类型的种类，前面已描述。
需要注意的是，复数的虚部符号为j，且不能转化为float数据类型

4.2 ndim属性

ndim用来描述数组的维度，需要注意的是这个属性比较实用二维数组，当数组维度是三维时，只能返回倒数第二个维度。

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.ndim)
print(array2.ndim)

【Running】========
3
2

4.3 shape属性

数组对象的尺度，对于矩阵，即n行m列,shape是一个元组（tuple），相比于ndim属性，反映的更全面。

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.shape)
print(array2.shape)

【Running】=========
(2, 3, 4)
(2, 4)

4.4 size属性

size属性是数组中保存元素的数量

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.size)
print(array2.size)

【Running】=======
24
8

4.5 itemsize属性

itemsize属性返回数组中各个元素所占用的字节数大小。

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.itemsize)
print(array2.itemsize)

【Running】==========
8
8

4.6 nbytes属性

如果想知道整个数组所需的字节数量，可以使用nbytes属性。其值等于数组的size属性值乘以itemsize属性值。

import numpy as np

array1 = np.ones(24).reshape(2,3,4)
array2 = np.ones(8).reshape(2,4)

print(array1.nbytes)
print(array2.nbytes)

【Running】===========
192
64

4.7 T属性

import numpy as np

array1 = np.arange(24).reshape(4,6)

print(array1)
print(array1.T)

【Running】=======
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]

4.8 real&imag属性

real和imag分别返回数组的实部和虚部，这里不进行举例说明。

4.9 flat属性

flat属性，返回一个numpy.flatiter对象，即可迭代的对象。

import numpy as np

array1 = np.arange(6).reshape(2,3)
f = array1.flat

print(array1)
for i in f:
	print(i)

【Running】==========
[[0 1 2]
 [3 4 5]]
0
1
2
3
4
5

flat属性生成迭代器后，能够进行一些赋值和索引操作

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array1.flat = 7
print(array1)
【Running】=======
[[7 7 7 7]
 [7 7 7 7]
 [7 7 7 7]]

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
f = array1.flat
print(f[[1,4]])
【Running】==========
[12 21]

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
f = array1.flat
f[[1,5]] = 7
print(array1)
【Running】=======
[[11  7 13 14]
 [21  7 23 24]
 [31 32 33 34]]

5. adarray切片与索引

adarray的索引和列表相似，有几个维度就可用几个维度来引用

import numpy as np

array1 = np.array([1, 2, 3, 4])

array2 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1[2])     # 一维数组索引
print(array2[0][0])  # 二维数组索引
print(array2[0])     # 二维数组索引行
print(array2.T[0])   # 二维数组索引列

【Running】===========
3
11
[11 12 13 14]
[11 21 31]

6. shape变化

6.1 形状变换

6.1.1 shape & resize

shape 和 resize都能改变数组的维度，resize是将原本的数组改变，shape是改变单次视图

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.reshape(2,6))
array1.resize(4,3)
print(array1)

【Running】============
[[11 12 13 14 21 22]
 [23 24 31 32 33 34]]
[[11 12 13]
 [14 21 22]
 [23 24 31]
 [32 33 34]]

6.1.2 ravel() & flatten()

ravel() 和 flatten()，都是讲多维数组转为一维数组。两者的区别在于返回拷贝（copy）还是返回视图（view），flatten()返回一份拷贝，需要分配新的内存空间，对拷贝所做的修改不会影响原始矩阵，而ravel()返回的是视图（view），会影响原始矩阵。

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.flatten())
array1.flatten()[0] = 0
print(array1)

print(array1.ravel())
array1.ravel()[0] = 0
print(array1)

【Running】===========
[11 12 13 14 21 22 23 24 31 32 33 34]
[[11 12 13 14]
 [21 22 23 24]
 [31 32 33 34]]
[11 12 13 14 21 22 23 24 31 32 33 34]
[[ 0 12 13 14]
 [21 22 23 24]
 [31 32 33 34]]

6.1.3 转置

前面描述了数组转置的属性（T），也可以通过transpose()函数来实现

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.transpose())

【Running】============
[[11 21 31]
 [12 22 32]
 [13 23 33]
 [14 24 34]]

6.2 堆叠数组

6.2.1 hstack() & column_stack()

hstack()是水平堆叠，即将两个数组水平连接，进行水平堆叠时要注意有相同的行

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 * 2
print(np.hstack((array1,array2)))

【Running】=================
[[11 12 13 14 22 24 26 28]
 [21 22 23 24 42 44 46 48]
 [31 32 33 34 62 64 66 68]]

6.2.2 vstack() & row_stack()

vstack()是垂直叠加

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 * 2
print(np.vstack((array1,array2)))

【Running】=========
[[11 12 13 14]
 [21 22 23 24]
 [31 32 33 34]
 [22 24 26 28]
 [42 44 46 48]
 [62 64 66 68]]

6.2.3 concatenate()

通过设置axis的值来设置叠加方向，axis=1时，沿水平方向叠加；axis=0时，沿垂直方向叠加

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 * 2
print(np.concatenate((array1,array2),axis=1))
print(np.concatenate((array1,array2),axis=0))

【Running】===========
[[11 12 13 14 22 24 26 28]
 [21 22 23 24 42 44 46 48]
 [31 32 33 34 62 64 66 68]]
[[11 12 13 14]
 [21 22 23 24]
 [31 32 33 34]
 [22 24 26 28]
 [42 44 46 48]
 [62 64 66 68]]

6.2.4 dstack()

dstack()是深度叠加，即增加一个维度，如两个（2，3）进行深度叠加后得到（2，3，2）的数组

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 * 2
print(np.dstack((array1,array2)))
print(np.dstack((array1,array2)).shape)

【Running】=================
[[[11 22]
  [12 24]
  [13 26]
  [14 28]]

 [[21 42]
  [22 44]
  [23 46]
  [24 48]]

 [[31 62]
  [32 64]
  [33 66]
  [34 68]]]
(3, 4, 2)

6.3 数组拆分

数组的拆分与叠加类似，有 hsplit()、vsplit()、dsplit() 以及split()函数，前三个分别对应横向拆分，纵向拆分和深度拆分，split中输入axis参数，axis=1时，沿水平方向拆分；axis=0时，沿垂直方向拆分。

7. 数组类型转换

7.1 tolist()

tolist()能将数组转换成list

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.tolist())

【Running】================
[[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34]]

7.2 astype()

astype()能将数组转换成指定类型

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])

print(array1.astype(float))

【Running】=================
[[11. 12. 13. 14.]
 [21. 22. 23. 24.]
 [31. 32. 33. 34.]]

8. numpy常用统计函数

请注意函数在使用时需要指定axis轴的方向，若不指定，默认统计整个数组。

• np.sum()，返回求和
• np.mean()，返回均值
• np.max()，返回最大值
• np.min()，返回最小值
• np.ptp()，数组沿指定轴返回最大值减去最小值，即（max-min）
• np.std()，返回标准偏差（standard deviation）
• np.var()，返回方差（variance）
• np.cumsum()，返回累加值
• np.cumprod()，返回累乘积值

9. 数组的广播

当数组跟一个标量进行数学运算时，标量需要根据数组的形状进行扩展，然后执行运算。这个扩展的过程称为“广播（broadcasting）”
如我们前面用到的乘法

import numpy as np

array1 = np.array([[11, 12, 13, 14],
	               [21, 22, 23, 24],
	               [31, 32, 33, 34]])
array2 = array1 + 5
array3 = array1 * 2
print(array2)
print(array3)

【Running】=============
[[16 17 18 19]
 [26 27 28 29]
 [36 37 38 39]]
[[22 24 26 28]
 [42 44 46 48]
 [62 64 66 68]]