数据分析学习笔记(二)--numpy:数组对象相关操作

版权声明:欢迎大家留言学习交流,若要转载请注明出处。 https://blog.csdn.net/LOLITA0164/article/details/79956108

数组和标量的运算

  • 加、减、乘、除、平方等运算
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
阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页