数据处理与分析(1)：Numpy手册

介绍

本博客是对优秀学习资源进行整理，方便查阅和使用。详细内容请查阅参考资料。

• 参考
  • 莫烦Python：数据 Numpy & Pandas
• 优质学习资源
  • 英文官方文档

Numpy 与 Pandas

• 运算速度快；
• 消耗资源少：采用矩阵运算，基于C语言实现。

Numpy

属性

• ndim：维度
• shape：行数，列数
• size：元素个数

# 导入模块
import numpy as np
array = np.array([[1,2,3],[4,5,6]])
print(array)
print(array.ndim)		# 维度
print(array.shape)		# 行数和列数
print(array.size)		# 元素个数

关键字

以下代码中的rows: 行数；cols：列数。

• array ：创建数组。np.arrray([1,2,3])
• dtype ：指定数据类型。dtype = np.int
• zeros ：创建数据全为0。np.zeros((rows, cols))
• ones ：创建数据全为1。np.ones((rows, cols), dtype=np.int)
• empty ：创建数据接近0。np.empty((rows, cols))
• arrange ：按指定范围创建数据。np.arrange(start, end, step)
• linspace ：创建线段。np.linspace(start, end, numbers).reshape(rows, cols)
• reshape ：改变数据维度。np.arrange(num).reshape(rows, cols)

示例请查阅参考资料。

---

基本运算

• 一维矩阵

创建数据

import numpy as np
a = np.array([10, 20, 30, 40])
b = np.arrange(4)

两者维度相同，则可进行逐元素加减乘除运算，对应元素运算。如下：

c = a + b
c = a - b
c = a * b
c = b**2			# 各元素的二次方用双星号
c = np.sin(a)		# 矩阵中的每个元素进行函数运算，直接调用数学函数
c = b < 3			# 逻辑判断，返回bool类型的矩阵。

• 多维矩阵

创建数据

a = np.array([[1, 1], [0, 1]])
b = np.arrange(4).reshape(2, 2)

同样需要两者维度相同。多维矩阵乘法分为两种：对应元素相乘；标准乘法：行列的乘加和。

c = a * b				# 对应元素相乘
c = np.dot(a, b) 		# 标准矩阵乘法方式1
c = a.dot(b)			# 标准矩阵乘法方式2

• 函数运算

求和与极值

a = np.random.random((2, 4))	# 随机生成数字
								# 2行4列的矩阵，且每个元素为[0,1]之间的随机数
np.sum(a)		# 对所有元素求和
np.min(a)		# 对所有元素求最小值
np.max(a)		# 对所有元素求最大值

对矩阵的行或列进行查找运算，借助axis参数。

axis = 0 : 以 列 为查找单元
axis = 1 : 以 行 为查找单元

np.sum(a, axis=1)		# 对所有元素 按行 求和
np.min(a, axis=0)		# 对所有元素 按列 求最小值
np.max(a, axis=1)		# 对所有元素 按行 求最大值

更多函数运算

import numpy as np
A = np.arange(2,14).reshape((3,4)) 

# array([[ 2, 3, 4, 5]
#        [ 6, 7, 8, 9]
#        [10,11,12,13]])

'''求极值的索引值'''        
print(np.argmin(A))    # 0  返回矩阵中最小值的索引值（下标值）
print(np.argmax(A))    # 11 返回矩阵中最大值的索引值（下标值）
'''求均值'''
np.mean(A)			# 方式1
np.average(A)		# 方式2
A.mean()			# 方式3
'''求中位数'''
A.median()			# 求中位数

'''累加函数'''
np.cumsum(A)		# 生成的每一项矩阵元素均是从原矩阵首项累加到对应项的元素之和。
'''累差函数'''
np.cumsum(A)		# 每一行中后一项与前一项之差。（3， 4）=> (3, 3)

'''非零元素检查与坐标切分'''
print(np.nonzero(A))    
# (array([0,0,0,0,1,1,1,1,2,2,2,2]),array([0,1,2,3,0,1,2,3,0,1,2,3]))
# 这个函数将所有非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵。

B = np.arange(14,2, -1).reshape((3,4)) 

# array([[14, 13, 12, 11],
#       [10,  9,  8,  7],
#       [ 6,  5,  4,  3]])

'''排序函数'''
np.sort(B)  		# 对每一行进行从小到大排序操作： 

'''矩阵的转置'''
np.transpose(B)		# 方式 1 
A.T					# 方式 2

'''区间截断'''
np.clip(B, 5, 9)	# np.clip(Array, Array_min, Array_max)
# 将Array中的所有大于最大值或小于最小值的元素，分别指定为最大最小值。
# array([[ 9, 9, 9, 9]
#        [ 9, 9, 8, 7]
#        [ 6, 5, 5, 5]])

索引

A为一维数组，则A[num]代表行索引(下标)为num的数字；A为二维数组，则A[num]代表行索引(下标)为num的所在行的所有元素。

• A[num] ：num为行索引；一维矩阵则为单个元素，二维矩阵则为一行。
• A[row][col] ： row 为行索引；col为列索引。单个元素
• A[row, col_start:col_end]：切片

import numpy as np

'''一维索引'''
A = np.arange(3, 15)
# array([3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
A[3]		# 6  

'''二维索引'''
A = np.arange(3,15).reshape((3,4))
"""
array([[ 3,  4,  5,  6]
       [ 7,  8,  9, 10]
       [11, 12, 13, 14]])
"""
         
print(A[2])         # [11 12 13 14]
A[1][1]				# 单个元素，位于row行col列的元素
A[1, 1]				# 同上
A[1, 1:3]			# 切片，对一定范围内的元素操作

'''逐行进行打印操作'''
for row in A:
    print(row)
"""    
[ 3,  4,  5, 6]
[ 7,  8,  9, 10]
[11, 12, 13, 14]
"""
'''逐列进行打印操作'''
for column in A.T:		# 先转置，再逐行输出 == 逐列输出。
    print(column)
"""  
[ 3,  7,  11]
[ 4,  8,  12]
[ 5,  9,  13]
[ 6, 10,  14]
"""

'''多维矩阵展开成一行'''
print(A.flatten())   	# flatten：展开函数
# array([3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])

for item in A.flat:		# flat：迭代器
    print(item)
    
# 3
# 4
...
# 14

Array 合并

对array合并有按行、按列等多种方式：

• np.vstack((A,B))：vertical stack 上下合并
• np.hstack((A,B))：horizontal stack 左右合并
• np.newaxis： 新增维度，与切片结合使用。
• np.concatenate()：合并多个矩阵或序列。

import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])

'''上下合并'''         
print(np.vstack((A,B)))    # vertical stack
"""
[[1,1,1]
 [2,2,2]]
"""
C = np.vstack((A,B))      
print(A.shape,C.shape)		# A仅仅是一个拥有3项元素的数组（数列）
							# 而合并后得到的C是一个2行3列的矩阵。
# (3,) (2,3)

'''左右合并''' 
D = np.hstack((A,B))       # horizontal stack
print(D)
# [1,1,1,2,2,2]
print(A.shape,D.shape)
# (3,) (6,)

'''添加新维度'''
print(A[np.newaxis,:])			# 行 新增维度
# [[1 1 1]]
print(A[np.newaxis,:].shape)	# 具有3个元素的array转换为了1行3列的矩阵
# (1,3)

print(A[:,np.newaxis])			# 列 新增维度
"""
[[1]
[1]
[1]]
"""
print(A[:,np.newaxis].shape)	# 具有3个元素的array转换为3行1列的矩阵
# (3,1)

将合并操作与新增维度组合使用：

import numpy as np
A = np.array([1,1,1])[:,np.newaxis]
B = np.array([2,2,2])[:,np.newaxis]
         
C = np.vstack((A,B))   # vertical stack
D = np.hstack((A,B))   # horizontal stack

print(D)
"""
[[1 2]
[1 2]
[1 2]]
"""

print(A.shape,D.shape)
# (3,1) (3,2)

• 合并多个矩阵或序列：np.concatenate()

axis参数很好的控制了矩阵的纵向或是横向打印，相比较vstack和hstack函数显得更加方便。

C = np.concatenate((A,B,B,A),axis=0)

print(C)
"""
array([[1],
       [1],
       [1],
       [2],
       [2],
       [2],
       [2],
       [2],
       [2],
       [1],
       [1],
       [1]])
"""

D = np.concatenate((A,B,B,A),axis=1)

print(D)
"""
array([[1, 2, 2, 1],
       [1, 2, 2, 1],
       [1, 2, 2, 1]])
"""

array 分割

• np.split(array, num, axis=1)：将array数组分割成num组，axis=1：按行分割（纵向分割）。只能等量分割。
• np.split(array, num, axis=0)：将array数组分割成num组，axis=0：按列分割（横向分割）。只能等量分割。
• np.array_split(array, num, axis=1)：不等量分割
• np.vsplit(array, num)：等价于 np.split(array, num, axis=0)
• np.hsplit(array, num)：等价于 np.split(array, num, axis=1)

A = np.arange(12).reshape((3, 4))
print(A)
"""
array([[ 0,  1,  2,  3],
    [ 4,  5,  6,  7],
    [ 8,  9, 10, 11]])
"""

'''纵向分割'''
print(np.split(A, 2, axis=1))
"""
[array([[0, 1],
        [4, 5],
        [8, 9]]), array([[ 2,  3],
        [ 6,  7],
        [10, 11]])]
"""

'''横向分割'''
print(np.split(A, 3, axis=0))
# [array([[0, 1, 2, 3]]), 
#  array([[4, 5, 6, 7]]), 
#  array([[ 8,  9, 10, 11]])]

'''错误分割：不支持不等量分割'''
print(np.split(A, 3, axis=1))
# ValueError: array split does not result in an equal division

'''不等量的分割'''
print(np.array_split(A, 3, axis=1))
"""
[array([[0, 1],
        [4, 5],
        [8, 9]]), array([[ 2],
        [ 6],
        [10]]), array([[ 3],
        [ 7],
        [11]])]
"""

'''其他分割方式'''
print(np.vsplit(A, 3)) 	# 等于 print(np.split(A, 3, axis=0))
# [array([[0, 1, 2, 3]]), 
#  array([[4, 5, 6, 7]]), 
#  array([[ 8,  9, 10, 11]])]


print(np.hsplit(A, 2)) 	# 等于 print(np.split(A, 2, axis=1))
"""
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
        [ 6,  7],
        [10, 11]])]
"""

copy 与 deep copy

• = 的赋值方式会带有关联性 。
• copy() 的赋值方式没有关联性。

import numpy as np

a = np.arange(4)
# array([0, 1, 2, 3])

'''浅复制：`=` 的赋值方式会带有关联性'''
b = a
c = a
d = b
# 改变a的第一个值，b、c、d的第一个值也会同时改变。
a[0] = 11
print(a)
# array([11,  1,  2,  3])

# 确认b、c、d是否与a相同。

b is a  # True
c is a  # True
d is a  # True

# 同样更改d的值，a、b、c也会改变。

d[1:3] = [22, 33]   # array([11, 22, 33,  3])
print(a)            # array([11, 22, 33,  3])
print(b)            # array([11, 22, 33,  3])
print(c)            # array([11, 22, 33,  3])

'''深复制：copy() 的赋值方式没有关联性'''
b = a.copy()    # deep copy
print(b)        # array([11, 22, 33,  3])
a[3] = 44
print(a)        # array([11, 22, 33, 44])
print(b)        # array([11, 22, 33,  3])

为什么Numpy会慢？函数差别

• 出处：莫烦Python：为什么用 Numpy 还是慢, 你用对了吗?

1. Numpy：Array快于Python：list。
   Numpy 基于 C 的实现, 创建存储容器 “Array” 的时候是寻找内存上的一连串区域来存放, 而 Python 存放的时候则是不连续的区域。
2. Axis的差别
   Numpy创建二维矩阵，有两种数据内存的存放方式：按行和按列。应按照不同的矩阵合并方式axis选择合适的创建方式order。
   • 在 Numpy 中, 创建 2D Array 的默认方式是 “C-type” 以 row 为主在内存中排列。a = np.zeros((200, 200), order='C')
   • 如果是 “Fortran” 的方式创建的, 就是以 column 为主在内存中排列。b = np.zeros((200, 200), order='F')
3. 尽量使用np.concatenate
4. copy慢 view快

---

以上。
有时间看到新资料，会继续整理。