numpy - 基础数组操作

基础

• 数据分析及机器学习底层库，C语言实现，提供基础数值计算

• 核心是多维数组的操作，减少python对多维数组操作时的循环

• numpy.ndarray类表示n维数组类

• ndarray对象在内存中储存内容

  • 元数据：描述数组信息，如ndim、dimensions、dtype、data等
  • 实际数据：和元数据分离，一定程度减少实际数据访问，提高性能

• 特点

  • 同质性：数组所有元素必须是相同类型
  • 数组下标：从0开始

array对象

数据类型

• 日期 datetime64

  • 常见格式：‘年‘, ‘年-月-日‘, ‘年-月-日 时:分:秒‘
  • 规范化：可对不同精确度的时间精确到统一时间单位 array.astype(‘M8[Y/M/D/h/m/s]‘)
  • 可进行减操作得到时间差，精确到数据中最小时间单位

• 自定义复合类型

  # 实例
  data=[
  	(‘zs‘, [90, 80, 85], 15),
  	(‘ls‘, [92, 81, 83], 16),
  	(‘ww‘, [95, 85, 95], 15)
  ]
  
  # 方法一：字符串对应每条数据格式
  # 创建
  a = numpy.array(data,dtype=‘U3, 3int32, int32‘)
  # 访问
  a[0][‘f0‘] # ‘zs‘
  
  # 方法二：字典对应每条数据字段名称
  # 创建
  c = np.array(data, dtype={‘names‘: [‘name‘, ‘scores‘, ‘ages‘],
                            ‘formats‘: [‘U3‘, ‘3int32‘, ‘int32‘]})
  # 访问
  c[0][‘name‘] # ‘zs‘
  # 方法三：列表对应每条数据字段名称
  # 创建
  b = np.array(data, dtype=[(‘name‘, ‘str_‘, 2),
                      	  (‘scores‘, ‘int32‘, 3),
                      	  (‘ages‘, ‘int32‘, 1)])
  # 访问
  b[0][‘name‘] # ‘zs‘
  

创建：

• numpy.array([]) 普通一维数组
• numpy.arange(start,end,step) 从起始值到终止值按指定步长生成数组
• numpy.zeros(count,dtype=‘类型‘) 生成count个0组成的一维数组
• numpy.ones(count,dtype=‘类型‘) 生成count个1组成的一维数组

属性

可查看和修改部分属性

• 维度(每层元素个数) array.shape
• 维数 array.ndim
• 元素类型 array.dtype
• 个数类
  • 总元素个数 array.size [[1,2],[3,4]]的size为4
  • 最外层元素数 len(array) [[1,2],[3,4]]的len为2
  • 元素字节数 itemsize
  • 总字节数 nvytes
• 复数
  • 实数部 real
  • 虚数部 iamg
• 迭代器 flat
• array[索引] [0][0][0]==[0,0,0]

操作

• 偏移缩放转置：

  • 每个元素进行相同操作
  • +、-、*、/、**、T

• 遍历(扁平迭代器)

  • elem for elem in a.flat

• 类型转换：

  • array.astype(type) 类型强制转换

• 变维：

  • 就地变维：改变源数据格式
  • 视图变维：数据不同展示形式
  • 复制变维：复制出新的独立数据

  变维类型	方法	描述	数据是否共享
  就地变维	shape()	转为指定格式，无返回值	共享(本身)
  就地变维	resize()	转为指定格式，无返回值	共享(本身)
  视图变维	reshape()	转为指定格式，返回新数组对象	共享(同一数据)
  视图变维	reval()	退化为一维，返回新数组对象	共享共享(同一数据)
  复制变维	flatten()	退化为一维，返回新数组对象	不共享(不同数据)

  array1 = numpy.arange(1,9) # 1*8 一维数组
  array1.shape(2,4) # 2*4 二维数组
  array1.resize(2,4) # 2*4 二维数组
  array2 = array1.reshape(2,4) # 2*4 二维数组
  
  array1 = numpy.arange(1,9) # 1*8 一维数组
  array1.shape(2,2,2) # 2*2*2 三维数组
  array1.resize(2,2,2) # 2*2*2 三维数组
  array3 = array1.reshape(2,2，2) # 2*2*2 三维数组
  array4 = array3.reval() # 1*8 一维数组
  
  array1 = numpy.arange(1,9) # 1*8 一维数组
  array5 = array1.flatten() # 1*8 一维数组
  
  array1,array2,array3,array4 共享数据
  array5 独立数据
  
  案例：
  生成3*3*3的三维数组，元素为1到27
  array1 = numpy.arange(1,28).resize(3,3,3)
  

• 切片：

  • array([start: end: step，start: end: step，start: end: step]）根据维度切出指定页行列

  # 一维数组
  a = numpy.arange(1, 10)
  # 1 2 3 4 5 6 7 8 9
  # 正序
  print(a[::])  # 1 2 3 4 5 6 7 8 9
  print(a[:])  # 1 2 3 4 5 6 7 8 9
  # 倒序
  print(a[::-1])  # 9 8 7 6 5 4 3 2 1
  # 省略start，倒推到边界，step=1就end-1倒推，step=-1就end+1倒推
  print(a[:4:-1])  # 9 8 7 6 相当于[8:4:-1]
  print(a[:-4:-1])  # 9 8 7 相当于[-1:-4:-1]
  # 省略end，正推到边界，step=1就start+1正推，step=-1就start-正推
  print(a[7::-1])  # 8 7 6 5 4 3 2 1 相当于[7:-1:-1]
  print(a[-7::-1])  # 3 2 1 相当于[-7:-10:-1]
  

• 掩码：根据指定条件进行筛选

  array = numpy.arange(1, 5)
  mask = [True, False,True, False,True]
  print(array[mask])
  # array([1,3,5])
  print(array[array>3])
  # array([4,5])
  print(array>3)
  # array([False, False,True, True,True])
  

• 合并拆分

  • 水平方向

    • 合并 c = numpy.hstack((a,b))/row_stack((a,b))

    • 等分a,b = numpy.hsplit(c,2)

      a = numpy.arange(1,1+6).reshape(2,3)
      # array([[1,2,3],
      #		 [4,5,6]])
      b = numpy.arange(1+6,1+12).reshape(2,3)
      # array([[7,8,9],
      #		 [10,11,12]])
      c = numpy.hstack((a,b))
      # array([[1,2,3,7,8,9],
      #		 [4,5,6,10,11,12]])
      d,e = numpy.hsplit(c,2)
      # d同a，e同b
      

  • 垂直方向

    • 合并c = numpy.vstack((a,b))/column_stack((a,b))

    • 等分a,b = numpy.vsplit(c,2)

      a = numpy.arange(1,1+6).reshape(2,3)
      # array([[1,2,3],
      #		 [4,5,6]])
      b = numpy.arange(1+6,1+12).reshape(2,3)
      # array([[7,8,9],
      #		 [10,11,12]])
      c = numpy.vstack((a,b))
      # array([[1,2,3],
      #		 [4,5,6],
      #        [7,8,9],
      #		 [10,11,12]])
      d,e = numpy.vsplit(c,2)
      # d同a，e同b
      

  • 深度方向

    • 合并c = numpy.dstack((a,b))，等分a,b = numpy.dsplit(c,2)

      a = numpy.arange(1,1+6).reshape(2,3)
      # array([[1,2,3],
      #		 [4,5,6]])
      b = numpy.arange(1+6,1+12).reshape(2,3)
      # array([[7,8,9],
      #		 [10,11,12]])
      c = numpy.dstack((a,b))
      # array([[[1,7],
      #         [2,8],
      #         [3,9]],
      #        [[4,10],
      #         [5,11],
      #         [6,12]]])
      d,e = numpy.dsplit(c,2)
      # array([[[1],
      #         [2],
      #         [3]],
      #        [[4],
      #         [5],
      #         [6]]])
      

  • 通用方法

    • 合并c = numpy.concatenate((a,b),axis=0)
    • 等分a,b = numpy.dsplit(c,2,,axis=0)

原文：https://www.cnblogs.com/yangjunh/p/pythonmodule_numpy.html