数据分析学习笔记（二）－－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. ]'''

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