数据分析学习笔记（二）－－numpy：数组对象相关操作
数组和标量的运算
- 加、减、乘、除、平方等运算
arr1 = np.array([np.arange(5), np.arange(5,10)])
arr2 = np.array(np.arange(5))
arr1
'''
[[0 1 2 3 4]
[5 6 7 8 9]]
'''
arr2
'''[0 1 2 3 4]'''
arr1+arr2
'''
[[ 0 2 4 6 8]
[ 5 7 9 11 13]]
'''
arr1-arr2
'''
[[0 0 0 0 0]
[5 5 5 5 5]]
'''
arr1*arr2
'''
[[ 0 1 4 9 16]
[ 0 6 14 24 36]]
'''
arr1.dot(arr2) # 标准的矩阵相乘
np.dot(arr1,arr2) # 标准的矩阵相乘
'''
[30 80]
'''
arr2**2
''' [ 0 1 4 9 16]'''
arr2/2
'''[0. 0.5 1. 1.5 2. ]'''
# 下面的几种python内置运算有些只能对一维数组有效，多维数组需要取出其元素才能进一步操作
arr3 = np.array(np.arange(-5,5),dtype=np.float)
# python内置的几个数学函数
abs(arr3) # 取绝对值 [5. 4. 3. 2. 1. 0. 1. 2. 3. 4.]
max(arr3) # 取最大 4.0
pow(arr3,3) # 次方 [-125. -64. -27. -8. -1. 0. 1. 8. 27. 64.]
# 下面的会出错：TypeError: type numpy.ndarray doesn't define __round__ method
round(arr3) # 四舍五入
# 改：分别取出元素进行运算
[round(item) for item in arr3]
# math中的运算
arr4 = np.array(np.arange(1,5))
math.sqrt(arr4) # 出错：TypeError: only size-1 arrays can be converted to Python scalars
# 改：分别取出元素进行运算
[math.sqrt(item) for item in arr4]
'''
[1.0, 1.4142135623730951, 1.7320508075688772, 2.0]
'''
- numpy中内置的运算
arr1 = np.array([np.arange(5), np.arange(5,10)])
arr2 = np.array(np.arange(5))
# 最小和最大索引
np.argmin(arr1) # 0
np.argmax(arr1) # 9
# 均值
arr1.mean() # 等同于 np.mean(arr1) 或 np.average(arr1)
'''4.5'''
# 中位数
np.median(arr1) # 中位数
'''4.5'''
# 累加
arr1.cumsum() # 累加，等同于 np.cumsum(arr1)
'''[ 0 1 3 6 10 15 21 28 36 45]'''
# 累差
np.diff(arr1)
'''[[1 1 1 1]
[1 1 1 1]]
'''
# 标准矩阵相乘
arr1.dot(arr2) # 等同于 np.dot(arr1,arr2)
'''[30 80]'''
# 将所有非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵
np.nonzero(arr1)
'''
(array([0, 0, 0, 0, 1, 1, 1, 1, 1]), array([1, 2, 3, 4, 0, 1, 2, 3, 4])) # (0,0)位置的值为0，被排除
'''
# 排序，默认为快速排序
a = np.array([[2,3,1,5],[2,1,0,3]])
np.sort(a,axis=0) # 纵向排序
'''[[2 1 0 3]
[2 3 1 5]]
'''
np.sort(a,axis=1) # 横向排序
'''[[1 2 3 5]
[0 1 2 3]]
'''
# 限制元素的大小
np.clip(arr1,3,6)
'''[[3 3 3 3 4]
[5 6 6 6 6]]
'''数组的索引和切片
- 一维数组的索引和切片
# 创建测试数组
arr = np.arange(9) # [0 1 2 3 4 5 6 7 8]
arr
# 通过下标获取
arr[2] # 2
# 切片操作，操作和list是一致的
arr[2:6] # [2 3 4 5]
arr[::2] # [0 2 4 6 8]
arr[::-1] # [8 7 6 5 4 3 2 1 0]
# slice
s = slice(2,6)
arr[s] # 等同于 arr[2:6] -> [2 3 4 5]- 多维维数组的索引和切片
# 创建测试数组
arr = np.arange(24).reshape(2,3,4)
'''[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]'''
# []里的每个','的位置和创建时的位置对应，:表示所有，在有指定位置之前时必须明确给出，在之后则可以忽略
# 每个纬度上都是一维数组，操作都和一维数组一致, start:end:step
arr[:,0,0] # 所有的二维数组的第0行第0列的数 [ 0 12]
arr[0] # 等同于 arr[0,:,:] 和 arr[0,...]
arr[0,1] # 第一个二维数组的第1行 [4 5 6 7]
arr[0,1,::2] # 第一个二维数组的第1行，step为2 [4 6]
arr[...,1] # 所有的二维数组的第1列
'''[[ 1 5 9]
[13 17 21]]
'''
arr[::-1] # 反转所有的二维数组
'''[[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]]
'''
arr[::-1,::-1,::-1] # 反转所有的二维数组，亦反转其中的元素
'''[[[23 22 21 20]
[19 18 17 16]
[15 14 13 12]]
[[11 10 9 8]
[ 7 6 5 4]
[ 3 2 1 0]]]
'''
s = slice(None,None,-1)
arr[(s,s,s)] # 和上一例子一致
'''[[[23 22 21 20]
[19 18 17 16]
[15 14 13 12]]
[[11 10 9 8]
[ 7 6 5 4]
[ 3 2 1 0]]]
'''- 布尔索引
arr = np.arange(24).reshape(2,3,4)
# 输出arr值大于10的数据
arr[arr>10] # [11 12 13 14 15 16 17 18 19 20 21 22 23]
# arr值大于10的替换为0
arr[arr>10] = 0
'''[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 0]]
[[ 0 0 0 0]
[ 0 0 0 0]
[ 0 0 0 0]]]
'''- 花式索引
arr = np.arange(32).reshape((8, 4))
# 获取[1,5,2,6]行的数据
arr[[1,5,2,6]]
'''
[[ 4 5 6 7]
[20 21 22 23]
[ 8 9 10 11]
[24 25 26 27]]
'''
# 获取[0,1]列的数据
arr[:,[0,1]]
# 如果行列都给参数，则获取对应坐标上的数据，如获取[(1,0),(5,2),(2,1),(6,3),(0,2)]数据
# 注：行、列要一一对应
arr[[1,5,2,6,0],[0,2,1,3,2]]
'''
[ 4 22 9 27 2]
'''
# 获取一块区域的方法
# 先确定需要的行数据，如[1,5,2,6]
# 再默认所有行，确定需要的列，如[0,2]
arr[[1,5,2,6]][:,[0,2]]
'''[[ 4 6]
[20 22]
[ 8 10]
[24 26]]
'''
# 可以直接使用 ix_ 函数解决上述问题
arr[np.ix_([1,5,2,6],[0,2])]
'''[[ 4 6 5 7]
[20 22 21 23]
[ 8 10 9 11]
[24 26 25 27]]
'''数组转置
- 数组转置
# 我们可以使用numpy提供的方法达到转置的效果，行列反转
arr = np.arange(15).reshape((3, 5))
'''[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]'''
arr.T
'''[[ 0 5 10]
[ 1 6 11]
[ 2 7 12]
[ 3 8 13]
[ 4 9 14]]'''
arr.transpose() # 不传参数及，(0,1) -> (1,0)
'''[[ 0 5 10]
[ 1 6 11]
[ 2 7 12]
[ 3 8 13]
[ 4 9 14]]'''- 数组转置函数 transpose()
当transpose()参数为空时，默认参数是纬度序号的倒叙顺序，如(0,1) -> (1,0)，即行列交换
当纬度大于等于3时，可以交换维度顺序是先相应的转置
arr = np.arange(12).reshape(2,3,2)
'''[[[ 0 1]
[ 2 3]
[ 4 5]]
[[ 6 7]
[ 8 9]
[10 11]]]'''
# 深度变为行，行变为深度
arr = arr.transpose() # arr.transpose(2,1,0)
'''[[[ 0 6]
[ 2 8]
[ 4 10]]
[[ 1 7]
[ 3 9]
[ 5 11]]]'''
# 列变为行，行变为列
arr = arr.transpose(1,0,2)
'''[[[ 0 1]
[ 6 7]]
[[ 2 3]
[ 8 9]]
[[ 4 5]
[10 11]]]'''
#深度变为列，列变为深度
arr = arr.transpose(0,2,1)
'''[[[ 0 2 4]
[ 1 3 5]]
[[ 6 8 10]
[ 7 9 11]]]'''改变数组的纬度
# 创建一维数组
arr = np.arange(24)
# 通过reshape()改变纬度
arr = arr.reshape(2,3,4)
'''[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]'''
# 直接改变数组的shape，注：转换前后的元素数量要一致
arr.shape = (6,4)
'''[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]'''
# 通过resize()函数改变纬度
arr.resize(12,2)
'''[[ 0 1]
[ 2 3]
[ 4 5]
[ 6 7]
[ 8 9]
[10 11]
[12 13]
[14 15]
[16 17]
[18 19]
[20 21]
[22 23]]'''
'''reshape函数：不改变原数组维度，有返回值
resize函数：直接改变原数组维度，无返回值
shape属性：直接改变原数组维度'''
# 数组平铺
arr.ravel()
arr.flatten()
'''区别在于：ravel、flatten函数都返回一维数组的一个视图，但是flatten函数还会请求分配内存来保存结果'''数组的合并
# 数组的组合
a = np.arange(12).reshape(3,4)
'''[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
'''
b = a * 2
'''[[ 0 2 4 6]
[ 8 10 12 14]
[16 18 20 22]]
'''
# 横向合并
np.hstack((a,b)) # 等同于 np.concatenate((a, b), axis=1) axis:1为横向，0为纵向
'''
[[ 0 1 2 3 0 2 4 6]
[ 4 5 6 7 8 10 12 14]
[ 8 9 10 11 16 18 20 22]]
'''
# 纵向合并
np.vstack((a,b)) # 等同于 np.concatenate((a, b), axis=0)
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 2 4 6]
[ 8 10 12 14]
[16 18 20 22]]
'''
# 深度合并
np.dstack((a,b))
'''
[[[ 0 0]
[ 1 2]
[ 2 4]
[ 3 6]]
[[ 4 8]
[ 5 10]
[ 6 12]
[ 7 14]]
[[ 8 16]
[ 9 18]
[10 20]
[11 22]]]
'''
# 按列合并
np.column_stack((a, b)) # 等同于 np.hstack((a,b))
'''
[[ 0 1 2 3 0 2 4 6]
[ 4 5 6 7 8 10 12 14]
[ 8 9 10 11 16 18 20 22]]
'''
# 按行合并
np.row_stack((a, b)) # 等同于 np.vstack((a,b))
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 2 4 6]
[ 8 10 12 14]
[16 18 20 22]]
'''数组的分割
- 均等分割
a = np.arange(12).reshape(3, 4)
'''[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
'''
# 横向分割，分割数量必须是列数的约数1,2,4
np.hsplit(a,4) # 等同于 np.split(a, 4, axis=1) axis:1为横向，0为纵向
'''[array([[0],
[4],
[8]]),
array([[1],
[5],
[9]]),
array([[ 2],
[ 6],
[10]]),
array([[ 3],
[ 7],
[11]])]
'''
# 纵向分割，分割数量必须是行数的约数1,3
np.vsplit(a,3) # 等同于 np.split(a, 3, axis=0)
'''[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]'''- 非均等分割
np.array_split(a,3,axis=1) # 横向分割4列，成3份
'''[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
'''
np.array_split(a,4,axis=0) # 纵向分割3行，成4份，最后的那个数组为空数组
'''[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]]), array([], shape=(0, 4), dtype=int64)]'''数组的转换
b = np.array([ 1.+1.j, 3.+2.j])
# 将ndarray类型转换为python的list类型
list = b.tolist()
type(list) # <class 'list'>
print(list) # [(1+1j), (3+2j)]
# 将ndarray类型转换为python的string类型
string = b.tostring()
type(string) # <class 'bytes'>
print(string)
'''
b'\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x00@'
'''
# 将指定字符串转换为ndarray类型
c = np.fromstring(string, dtype=complex)
c # [1.+1.j 3.+2.j]
type(c) # <class 'numpy.ndarray'>
c.dtype # complex128
d = np.fromstring('20:42:52',sep=':', dtype=int)
d # [20 42 52]
d.dtype # int64