Numpy入门(二)：数组基本操作

点击跳转
《Numpy入门系列目录》

---

---

• Numpy提供两种基本对象
  • ndarrary（N-dimensional arrary object）
    • Numpy库的心脏
    • 多维数组，具有矢量运算能力，且快速、节省空间
    • 可对整组数据进行快速运算的标准数学函数、线性代数、随机数生成等功能
  • ufunc（Universal function object）

1. 创建数组对象

• 数组属性

  • ndarrary（数组）是存储单一数据类型的多维数组

  

• 数组创建

  • numpy.array(object, dtype=None, copy=True, order=‘K’, subok=False, ndmin=0)

    • 当dtype=None时，会自动匹配一个最小的类型

    

• 创建数组并查看数组属性

  • import numpy as np

    import numpy as np  # 导入numpy库
    
    arr1 = np.array([1, 2, 3, 4])  # 创建一维数组
    print('创建的数组为', arr1)
    arr2 = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]])  # 创建二维数组
    print('创建的数组为\n', arr2)
    print('数组维度为', arr2.shape)  # 数组维度为 (3, 4)
    print('数组类型为', arr2.dtype)  # 数组类型为 int32
    print('数组元素个数为', arr2.size)  # 数组元素个数为 12
    print('数组每个元素大小为', arr2.itemsize)  # 数组每个元素大小为 4
    

• 重新设置数组的shape属性

  

  arr2.shape = 4, 3  # 重新设置shape
  print('重新设置shape后的arr2：\n', arr2)	# (4, 3)
  

• 使用arange函数创建数组

  • 前闭后开区间（开始值, 终止值, 步长）

  import numpy as np  # 导入numpy库
  
  print(np.arange(0, 1, 0.1))
  '''
  [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
  '''
  

• 使用linspace函数创建等差数列

  • 闭区间（开始值, 终止值, 元素个数）

  import numpy as np
  
  print(np.linspace(0, 1, 12))
  '''
  [0.         0.09090909 0.18181818 0.27272727 0.36363636 0.45454545
   0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1.        ]
  '''
  

• 使用logspace函数创建等比数列

  • 闭区间（开始值, 终止值, 元素个数）

  import numpy as np
  
  print(np.logspace(0, 2, 20))	# 从10的0次方开始，到10的2次方结束
  '''
  [  1.           1.27427499   1.62377674   2.06913808   2.6366509
     3.35981829   4.2813324    5.45559478   6.95192796   8.8586679
    11.28837892  14.38449888  18.32980711  23.35721469  29.76351442
    37.92690191  48.32930239  61.58482111  78.47599704 100.        ]
  '''
  

• 使用zeros函数创建全0数组

  • 在参数中输入维数的元组

  import numpy as np
  
  print(np.zeros((2, 3)))
  '''
  [[0. 0. 0.]
   [0. 0. 0.]]
  '''
  

• 使用eye函数创建数组

  • 单位矩阵

  import numpy as np
  
  print(np.eye(3))
  '''
  [[1. 0. 0.]
   [0. 1. 0.]
   [0. 0. 1.]]
  '''
  

• 使用diag函数创建数组

  import numpy as np
  
  print(np.diag([1, 2, 3, 4]))
  '''
  [[1 0 0 0]
   [0 2 0 0]
   [0 0 3 0]
   [0 0 0 4]]
  '''
  

• 使用ones函数创建数组

  • 全1矩阵

  import numpy as np
  
  print(np.ones((5, 3)))
  '''
  [[1. 1. 1.]
   [1. 1. 1.]
   [1. 1. 1.]
   [1. 1. 1.]
   [1. 1. 1.]]
  '''
  

• 数组数据类型

  • Numpy基本数据类型与其取值范围

  • int64中，64表示占有内存的位数，范围为-2⁶³至2⁶³-1

  • uint64：0至2⁶⁴-1

  • float16

  • ……

    

• 数组数据类型转换

  import numpy as np
  
  print('转换结果为：', np.float64(42))     # 整型转换为浮点型，42.0
  print('转换结果为：', np.int8(42.0))      # 浮点型转换为整型，42
  print('转换结果为：', np.bool(42))        # 整型转换为布尔型，True
  print('转换结果为：', np.bool(0))         # 整型转换为布尔型，False
  print('转换结果为：', np.float(True))     # 布尔型转换为浮点型，1.0
  print('转换结果为：', np.float(False))    # 布尔型转换为浮点型，0.0
  

• 创建一个存储餐饮企业库存信息的数据类型

  • 其中，用一个长度为40个字符的字符串记录商品名称，用一个64位的整数记录商品库存数量，最后用一个64位的浮点数记录商品价格。类似结构数据类型

  • 创建数据类型

    import numpy as np
    
    df = np.dtype([("name", np.str_, 40), ("numitems", np.int64), ("price", np.float64)])	# 自定义数据类型的创建
    print('数据类型为', df)  # 数据类型为 [('name', '与其相反
    

  • 查看数据类型

    • 可以直接查看或者使用numpy.dtype函数查看

      import numpy as np
      
      df = np.dtype([("name", np.str_, 40), ("numitems", np.int64), ("price", np.float64)])
      print('数据类型为：', df["name"])             # 数据类型为： 
      print('数据类型为：', np.dtype(df["name"]))   # 数据类型为： 
      

  • 在使用array函数创建数组时，数组的数据类型默认是浮点型

    • 自定义数据数据，则可以预先指定数据类型

      import numpy as np
      
      df = np.dtype([("name", np.str_, 40), ("numitems", np.int64), ("price", np.float64)])
      itemz = np.array([("tomatoes", 42, 4.14), ("cabbages", 13, 1.72)], dtype=df)
      print('自定义数据为', itemz)  # 自定义数据为 [('tomatoes', 42, 4.14) ('cabbages', 13, 1.72)]
      

2. 生成随机数

• 生成的是伪随机数

• random模块常用随机数生成函数

  

• 当seed的值一样时，创建的伪随机数不会发生变化

import numpy as np
print(np.random.random(100))    # 生成100个在[0, 1)的随机数
print(np.random.rand(10, 5))    # 生成10行5列的在[0, 1)的服从均匀分布的随机数
print(np.random.randn(10, 5))   # 生成10行5列的服从正态分布的随机数
print(np.random.randint(2, 10, size=(2, 5)))    # 生成2*5的数组，数字范围在[2, 10)

3. 通过索引访问数组

• 一维数组的索引

  import numpy as np
  
  arr = np.arange(10)
  print('索引结果为：', arr[5])     # 用整数作为下标可以获取数组中的某个元素
  print('索引结果为：', arr[3:5])   # 用范围作为下标获取数组的一个切片，前闭后开
  print('索引结果为：', arr[:5])    # 省略开始下标，默认从0开始
  print('索引结果为：', arr[-1])    # 下标可以使用负数，-1表示从数组后往前数第一个元素
  arr[2:4] = 100, 101              # 下标还可以用来修改元素的值
  print('索引结果为：', arr)        
  print('索引结果为：', arr[1:-1:2])  # 第三个参数表示步长
  print('索引结果为：', arr[5:1:-2])  # 步长为负数时，开始下标必须大于结束下标
  

• 多维数组的索引

  import numpy as np
  
  arr = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
  print('索引结果为：', arr[0, 3:5])    # 第0行中第3和第4列的元素
  print('索引结果为：', arr[1:, 2:])    # 第1~2行中第2~4列的元素
  print('索引结果为：', arr[:, 2])      # 第2列的元素
  

  • 使用整数和布尔值索引访问数据

    import numpy as np
    
    arr = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
    # 从两个序列的对应位置取出2个整数来组成下标：arr[0,1], arr[1,2], arr[2,3]
    print('索引结果为：', arr[[(0, 1, 2), (1, 2, 3)]])
    print('索引结果为：', arr[1:, (0, 2, 3)])  # 第1~2行中第0, 2, 3列元素
    
    mask = np.array([1, 0, 1], dtype=np.bool)	# [True False True]
    # mask是一个布尔数组，索引第1, 3行中第2列的元素
    print('索引结果为：', arr[mask, 2])
    

4. 变换数组的形态

• array.reshape()

  import numpy as np
  
  arr = np.arange(12)
  print('创建的一维数组为', arr)
  print('新的二维数组为', arr.reshape(3, 4))  # 转换为3*4的二维数组
  print('数组维度为', arr.reshape(3, 4).ndim)  # 数组维度为 2
  

• array.ravel()

  • 横向展平数组（一行一行展平）

  import numpy as np
  
  arr = np.arange(12).reshape(3, 4)
  print('创建的二维数组为：', arr)
  print('数组展平后为', arr.ravel())    # 一维数组
  

• array.flatten()

  • 展平数组（默认横向展平）

  import numpy as np
  
  arr = np.arange(12).reshape(3, 4)
  print('数组展平为', arr.flatten())  		# 横向展平
  print('数组展平为', arr.flatten('F'))  	# 纵向展平
  

5. 组合数组

• np.hstack()

  • 实现数组横向组合，即行与行拼接在一起

  np.hstack((arr1, arr2))
  

• np.vstack()

  • 实现数组纵向组合，即列与列拼接在一起

  np.vstack((arr1, arr2))
  

• np.concatenate()

  • 实现数组横向组合

  np.concatenate((arr1, arr2), axis=1)
  

• np.concatenate()

  • 实现数组纵向组合

  np.concatenate((arr1, arr2), axis=0)
  

6. 切割组合

• np.hsplit()

  • 实现数组横向分割，按列分割成2个，需要方阵，并且维度是偶数

  import numpy as np
  
  arr = np.arange(16).reshape(4, 4)
  arr1, arr2 = np.hsplit(arr, 2)
  print(arr1)
  print(arr2)
  '''
  [[ 0  1]
   [ 4  5]
   [ 8  9]
   [12 13]]
  [[ 2  3]
   [ 6  7]
   [10 11]
   [14 15]]
  '''
  

• np.vsplit()

  • 实现数组纵向分割，按行分割成2个，需要方阵，并且维度是偶数

  import numpy as np
  
  arr = np.arange(16).reshape(4, 4)
  arr1, arr2 = np.vsplit(arr, 2)
  print(arr1)
  print(arr2)
  '''
  [[0 1 2 3]
   [4 5 6 7]]
  [[ 8  9 10 11]
   [12 13 14 15]]
  '''
  

• np.split()

  • 实现数组横向分割，需要方阵，并且维度是偶数

  import numpy as np
  arr = np.arange(16).reshape(4, 4)
  arr1, arr2 = np.split(arr, 2, axis=1)
  print(arr1)
    print(arr2)
    '''
    [[ 0  1]
     [ 4  5]
     [ 8  9]
     [12 13]]
    [[ 2  3]
     [ 6  7]
     [10 11]
     [14 15]]
    '''
  

  • 实现数组纵向分割，需要方阵，并且维度是偶数

  import numpy as np
  
  arr = np.arange(16).reshape(4, 4)
  arr1, arr2 = np.split(arr, 2, axis=0)
  print(arr1)
  print(arr2)
  '''
  [[0 1 2 3]
   [4 5 6 7]]
  [[ 8  9 10 11]
   [12 13 14 15]]
  '''np.split(arr, 2, axis=0)