python数据分析-Numpy

2.Numpy

numpy能将 序列数据(列表、元组、数组和其他序列类型) 转换为ndarray数组，ndarray是一个同构数据容器，当创建好一个ndarray数组时，同时会在内存中存储ndarray的shape和dtype。shape是ndarray维度大小的元组，dtype是ndarray数据类型的对象。

1.ndarray多维数组

• 1.创建ndarray数组

  • zeros、zeros_like

    创建指定长度或者形状的全0数组
    np.zeros(8)
    np.zeros((3,4))
    like以另一个数组为参考，根据形状和dtype创建全0数组。
    np.zeros_like(arr1)

  • ones、ones_like

    创建指定长度或者形状的全1数组
    np.ones(8)
    np.ones((3,4))
    like以另一个数组为参考，根据形状和dtype创建全1数组。
    np.ones_like(arr1)

  • empty、empty_like

    创建一个没有具体值得数组（即垃圾值）
    np.empty(8)
    np.empty((3,4))
    like以另一个数组为参考
    np.empty_like(arr1)

  • arrange

    arrange函数类似于python内置的range函数
    np.arange(10)
    结果为0~9
    np.arange(0, 10, 1)
    第一个数为开始值，第二个数为终值，1代表步长

    • 区别于python 内置的range(x, y ,z)

  • linspace

    np.linspace(0,10,10)
    前两个值代表开始值和终值，第三个为指定元素个数，均匀增加

  • eye、identity

    np.eye(5)
    np.identity(5)
    为5*5单位矩阵

• 2.ndarray对象属性

  • .ndim

    • 秩，即数据轴的个数

  • .shape

    • 数组的维度

  • .size

    • 元素的总个数

  • .dtype

    • 数据类型

  • .itemsize

    • 数组中每一个元素的字节大小

• 3.ndarray数据类型

  • 1.创建时指定数据类型

    通过dtype给创建的数组指定数据类型
    arr2 = np.arange(5,dtype=‘float64’)

  • 2.数据类型转化

    arr1 = np.arange(6)
    arr2 = arr1.astype(np.float64)
    注意：
    1、将浮点数转为整数，并不是使用四舍五入的方式来转换，而是元素的小数部分都会被截断；
    2、astype方法会创建一个新的数组，并不会改变原有数组的数据类型。
    arr3 = arr1.astype(arr2.dtype)

• 4.数组变换

  • 1.数组重塑

    • reshape()

      arr = np.arange(12).reshape((3,-1))

    • ravel()

      arr = np.arange(10).reshape((5,2))
      arr.ravel()
      array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

    • flatten()

      arr = np.arange(10).reshape((5,2))
      arr.flatten()
      array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

  • 2.数组合并

    • concatenate()

      arr1 = np.arange(12).reshape(3,4)
      arr2 = np.arange(12,24).reshape(3,4)
      np.concatenate([arr1, arr2],axis=0) # 按照第0轴进行合并，按行
      np.concatenate([arr1, arr2],axis=1) # 按照第1轴进行合并，按列

    • vstack()

      arr1 = np.arange(12).reshape(3,4)
      arr2 = np.arange(12,24).reshape(3,4)
      np.vstack((arr1,arr2))
      array([[ 0, 1, 2, 3],
      [ 4, 5, 6, 7],
      [ 8, 9, 10, 11],
      [12, 13, 14, 15],
      [16, 17, 18, 19],
      [20, 21, 22, 23]])

    • hstack()

      arr1 = np.arange(12).reshape(3,4)
      arr2 = np.arange(12,24).reshape(3,4)
      np.hstack((arr1,arr2))
      array([[ 0, 1, 2, 3, 12, 13, 14, 15],
      [ 4, 5, 6, 7, 16, 17, 18, 19],
      [ 8, 9, 10, 11, 20, 21, 22, 23]])

  • 3.数组拆分

    • split()

      split方法可以将数组拆分为多个数组
      arr = np.arange(12).reshape((6,2))
      array([[ 0, 1],
      [ 2, 3],
      [ 4, 5],
      [ 6, 7],
      [ 8, 9],
      [10, 11]])
      np.split(arr,[2, 4]) # 按照索引进行拆分
      [array([[0, 1],
      [2, 3]]), array([[4, 5],
      [6, 7]]), array([[ 8, 9],
      [10, 11]])]

  • 4.数组转置和轴对称

    • transpose()

      arr = np.arange(12).reshape(3,4)
      array([[ 0, 1, 2, 3],
      [ 4, 5, 6, 7],
      [ 8, 9, 10, 11]])
      arr.transpose((1,0))
      array([[ 0, 4, 8],
      [ 1, 5, 9],
      [ 2, 6, 10],
      [ 3, 7, 11]])

    • T属性

      arr = np.arange(12).reshape(3,4)
      arr.T
      array([[ 0, 4, 8],
      [ 1, 5, 9],
      [ 2, 6, 10],
      [ 3, 7, 11]])

    • swapaxes()

      将一个数组的第0轴和第1轴进行交换
      a = np.arange(10).reshape(2,5)
      array([[0, 1, 2, 3, 4],
      [5, 6, 7, 8, 9]])
      b = a.swapaxes(0,1)
      array([[0, 5],
      [1, 6],
      [2, 7],
      [3, 8],
      [4, 9]])

• 5.numpy的随机数函数

  在numpy.random模块中，提供了多种随机数生成函数。

  • rand()

    产生均匀分布的样本值

  • randn()

    产生正态分布的样本值
    arr = np.random.randn(2, 3, 5)
    array([[[ 1.57552831, -0.03844265, -1.57687329, 1.63434437,
    2.08640694],
    [ 1.14522244, 0.13930427, 1.18958565, -1.53746026,
    2.05324272],
    [-1.55497165, -0.66612201, -1.23153962, 1.22749603,
    -0.47564033]],
    [[-0.95279727, 0.63247826, 0.30504872, 0.66735843,
    -0.74636145],
    [-1.31301376, 0.24397392, 1.40681137, 0.08472011,
    0.75561781],
    [-1.19416579, 0.19543635, -0.50820577, 1.05192733,
    0.07255312]]])

  • normal(loc,scale,size)

    产生焗油宝正态分布的数组，loc表示均值，scale表示标准差。
    arr = np.random.normal(4, 5, size=(3,5))
    array([[-0.15532185, 4.30119323, 3.29916695, 3.84670708, 0.50111216],
    [ 6.07242058, -0.22697321, 2.60556393, 2.14626198, 7.32173104],
    [ 3.45775388, 9.48129733, 2.47439643, 1.28317488, 6.38279118]])

  • uniform(low,high,size)

    产生具有均匀分布的数组，low为起始值，high为结束值，size表示形状。

  • poisson(lam,size)

    产生具有泊松分布的数组，lam表示随机事件发生率

  • randint()

    给定范围内取随机整数。
    arr = np.random.randint(100, 200, size=(5, 4))
    array([[189, 100, 113, 115],
    [109, 146, 191, 130],
    [111, 102, 151, 187],
    [131, 153, 119, 104],
    [121, 142, 106, 170]])

  • seed()

    随机数种子

  • permutation()

    对一个序列随机排序，不改变原数组。
    arr = np.random.randint(100, 200, size=(5, 4))
    array([[111, 133, 182, 174],
    [167, 170, 143, 172],
    [100, 141, 192, 127],
    [135, 166, 156, 143],
    [106, 125, 154, 113]])
    np.random.permutation(arr)
    array([[100, 141, 192, 127],
    [111, 133, 182, 174],
    [167, 170, 143, 172],
    [135, 166, 156, 143],
    [106, 125, 154, 113]])
    arr
    array([[111, 133, 182, 174],
    [167, 170, 143, 172],
    [100, 141, 192, 127],
    [135, 166, 156, 143],
    [106, 125, 154, 113]])

  • shuffle()

    对一个序列随机排序，改变原数组。
    arr = np.random.randint(100, 200, size=(5, 4))
    array([[198, 127, 176, 177],
    [163, 181, 134, 130],
    [129, 183, 127, 166],
    [194, 173, 119, 197],
    [119, 199, 196, 192]])
    np.random.shuffle(arr)
    array([[163, 181, 134, 130],
    [129, 183, 127, 166],
    [194, 173, 119, 197],
    [198, 127, 176, 177],
    [119, 199, 196, 192]])
    arr
    array([[163, 181, 134, 130],
    [129, 183, 127, 166],
    [194, 173, 119, 197],
    [198, 127, 176, 177],
    [119, 199, 196, 192]])
    

2.数组的索引和切片

从1,2可以看出，数组的切片返回的是原始数组的视图
视图就是原始数组的表现形式
切片操作不会产生新数据，这意味着在视图上的操作都是会使原数组发生变化。

数组的切片和索引返回都是原始数组的视图。

• 1.数组的索引

  • 一维

    arr = np.arange(10)
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    arr[3]
    3
    arr[-1]
    9
    arr[2] = 123
    arr
    array([ 0, 1, 123, 3, 4, 5, 6, 7, 8, 9])
    arr[3] = 88
    arr
    array([ 0, 1, 123, 88, 4, 5, 6, 7, 8, 9])

  • 二维

    arr = np.arange(15).reshape(3,5)
    arr
    array([[ 0, 1, 2, 3, 4],
    [ 5, 6, 7, 8, 9],
    [10, 11, 12, 13, 14]])
    arr[0]
    array([0, 1, 2, 3, 4])
    arr[2]
    array([10, 11, 12, 13, 14])
    arr[0][3]
    3
    arr[2,3] #两种方法等价
    13

  • 三维

    arr = np.arange(12).reshape(2,2,3)
    arr
    array([[[ 0, 1, 2],
    [ 3, 4, 5]],
    [[ 6, 7, 8],
    [ 9, 10, 11]]])
    arr[0]
    array([[0, 1, 2],
    [3, 4, 5]])
    old = arr[0].copy()
    arr[0] = 12
    arr
    array([[[12, 12, 12],
    [12, 12, 12]],
    [[ 6, 7, 8],
    [ 9, 10, 11]]])
    arr[0] = old
    arr
    array([[[ 0, 1, 2],
    [ 3, 4, 5]],
    [[ 6, 7, 8],
    [ 9, 10, 11]]])
    arr[1, 1]
    array([ 9, 10, 11])
    arr[0, 1, 2]
    5

• 2.数组的切片

  arr1 = arr[-3:-1]
  arr1
  array([7, 8])
  arr1[:] = 77
  arr
  array([ 0, 1, 123, 88, 4, 5, 6, 77, 77, 9])

  • 如果需要的并非视图而是要复制数据，则可以通过copy方法来实现。

    array([ 0, 1, 123, 88, 4, 5, 6, 77, 77, 9])
    arr1 = arr[1].copy()
    arr1 = 34
    arr
    array([ 0, 1, 123, 88, 4, 5, 6, 77, 77, 9])
    原数组未变

  • 一维

    arr = np.arange(6)
    arr
    array([0, 1, 2, 3, 4, 5])
    arr[2:5]
    array([2, 3, 4])

  • 二维

    arr = np.arange(12).reshape(4,3)
    arr
    array([[ 0, 1, 2],
    [ 3, 4, 5],
    [ 6, 7, 8],
    [ 9, 10, 11]])
    arr[2:]
    array([[ 6, 7, 8],
    [ 9, 10, 11]])
    arr[:, 1]
    array([ 1, 4, 7, 10])
    arr[:, 1:2]
    array([[ 1],
    [ 4],
    [ 7],
    [10]])
    arr
    array([[ 0, 1, 2],
    [ 3, 4, 5],
    [ 6, 7, 8],
    [ 9, 10, 11]])
    arr[2:, 1:]
    array([[ 7, 8],
    [10, 11]])

• 3.布尔型索引

  fruits = np.array([‘apple’, ‘banana’, ‘pear’, ‘banana’, ‘pear’, ‘apple’, ‘pear’])
  datas = np .random.randint(-1, 1, size=(7,5))
  fruits
  array([‘apple’, ‘banana’, ‘pear’, ‘banana’, ‘pear’, ‘apple’, ‘pear’],
  dtype=’<U6’)
  datas
  array([[-1, -1, -1, -1, -1],
  [-1, -1, 0, -1, 0],
  [ 0, -1, 0, -1, -1],
  [-1, -1, -1, 0, 0],
  [-1, 0, -1, 0, -1],
  [-1, 0, -1, 0, 0],
  [-1, 0, -1, 0, -1]])
  fruits == ‘pear’
  array([False, False, True, False, True, False, True])
  datas[fruits == ‘pear’]
  array([[ 0, -1, 0, -1, -1],
  [-1, 0, -1, 0, -1],
  [-1, 0, -1, 0, -1]])
  datas[fruits != ‘pear’]
  array([[-1, -1, -1, -1, -1],
  [-1, -1, 0, -1, 0],
  [-1, -1, -1, 0, 0],
  [-1, 0, -1, 0, 0]])
  datas[(fruits == ‘apple’) | (fruits == ‘banana’)]
  array([[-1, -1, -1, -1, -1],
  [-1, -1, 0, -1, 0],
  [-1, -1, -1, 0, 0],
  [-1, 0, -1, 0, 0]])
  datas[fruits == ‘pear’,2:]
  array([[ 0, -1, -1],
  [-1, 0, -1],
  [-1, 0, -1]])
  datas[fruits == ‘pear’,2]
  array([ 0, -1, -1])

• 4.花式索引

  可以通过 整数列表或者数组 进行索引。

  arr = np.arange(12).reshape(4,3)
  arr
  array([[ 0, 1, 2],
  [ 3, 4, 5],
  [ 6, 7, 8],
  [ 9, 10, 11]])
  arr[[1, 3, 2]] # 通过列表索引
  array([[ 3, 4, 5],
  [ 9, 10, 11],
  [ 6, 7, 8]])
  arr[[3, 2]][:, [2, 1]]
  array([[11, 10],
  [ 8, 7]])

  • 可以通过np.ix_()完成同样的操作

    arr = np.arange(12).reshape(4,3)
    arr
    array([[ 0, 1, 2],
    [ 3, 4, 5],
    [ 6, 7, 8],
    [ 9, 10, 11]])
    arr[np.ix_([3,2],[2, 1])]
    array([[11, 10],
    [ 8, 7]])
    

3.数组的运算

a = [1, 2, 3] #一般数组(列表)
b = []
for i in a:
b.append(i * 10)
b
[10, 20, 30]
arr = np.array([1, 2, 3]) # ndarray结构
arr * 10 #矢量化
array([10, 20, 30])

元素级运算

arr * arr
array([1, 4, 9])
arr - arr
array([0, 0, 0])

• 1.通用函数

  arr = np.random.randn(3,3)
  arr
  array([[-0.56060259, 0.45181362, 0.85494956],
  [-1.55298021, -1.28275044, 0.09774885],
  [-0.26200043, 1.46159921, -0.78007124]])
  np.abs(arr)
  array([[0.56060259, 0.45181362, 0.85494956],
  [1.55298021, 1.28275044, 0.09774885],
  [0.26200043, 1.46159921, 0.78007124]])
  np.square(arr)
  array([[0.31427526, 0.20413555, 0.73093874],
  [2.41174754, 1.64544869, 0.00955484],
  [0.06864422, 2.13627226, 0.60851114]])

  • add()

    arr1 = np.random.randint(1, 10, size=(5))
    arr1
    array([4, 1, 3, 7, 7])
    arr2 = np.random.randint(1, 10, size=(5))
    arr2
    array([1, 6, 9, 1, 5])
    np.add(arr1, arr2)
    array([ 5, 7, 12, 8, 12])

    • 用于两个数组的相加

  • minimum()

    arr1 = np.random.randint(1, 10, size=(5))
    arr1
    array([4, 1, 3, 7, 7])
    arr2 = np.random.randint(1, 10, size=(5))
    arr2
    array([1, 6, 9, 1, 5])
    np.minimum(arr1, arr2)
    array([1, 1, 3, 1, 5])

    • 计算两个数组中元素的最小值

  • modf()

    arr = np.random.normal(2,4,size=(6,))
    arr
    array([-0.50969949, 6.61860107, -0.44542936, 0.98450502, 11.37290483,
    6.76379218])
    np.modf(arr)
    (array([-0.50969949, 0.61860107, -0.44542936, 0.98450502, 0.37290483,
    0.76379218]), array([-0., 6., -0., 0., 11., 6.]))

    • 可以返回数组元素的小数和整数部分

• 2.条件逻辑运算 P28页

  • np.where(表达式, 正确, 错误)

    arr1 = np.array([1, 2, 3, 4])
    arr2 = np.array([5, 6, 7, 8])
    cond = np.array([True, False, False, True])
    result = [(x if c else y) for x, y, c in zip(arr1, arr2, cond)]
    result
    [1, 6, 7, 4]
    以上存在两个问题：
    1、对大规模数组处理速度不是很快
    2、无法用于多维数组
    result = np.where(cond, arr1, arr2)
    result
    array([1, 6, 7, 4])
    arr = np.random.randn(4, 4)
    arr
    array([[ 0.71091011, -1.61141374, 0.52514722, -1.48200707],
    [ 1.65531395, -0.70807484, 0.78206514, -0.57778063],
    [-0.57520915, -0.74006714, 0.88082954, 0.11892153],
    [-2.18927778, -0.07032852, 0.4527424 , 0.56645266]])
    new_arr = np.where(arr > 0, 1, -1)
    new_arr
    array([[ 1, -1, 1, -1],
    [ 1, -1, 1, -1],
    [-1, -1, 1, 1],
    [-1, -1, 1, 1]])

    嵌套

    arr = np.random.randint(1, 300, size=(3,3))
    arr
    array([[166, 33, 159],
    [111, 29, 195],
    [299, 299, 111]])
    new_arr = np.where(arr > 200, 3,
    np.where(arr > 100, 2, 1))
    new_arr
    array([[2, 1, 2],
    [2, 1, 2],
    [3, 3, 2]])

• 3.统计运算

  • sum()

    arr = np.random.randn(4, 4)
    arr
    array([[-0.02607772, -2.372853 , 0.14145354, 2.15116076],
    [ 0.51029922, -0.43316864, -0.25205585, 0.90836388],
    [ 0.39917432, -0.74033444, -2.30525874, 0.3605075 ],
    [ 0.41131976, 1.19119329, 0.14672981, 0.9664657 ]])
    arr.sum()
    1.0569193804475678
    arr.sum(axis=0) #指定轴==>arr.sum(0)
    array([ 1.29471558, -2.35516279, -2.26913124, 4.38649783])

    • 求和

  • mean()

    arr = np.random.randn(4, 4)
    arr
    array([[-0.02607772, -2.372853 , 0.14145354, 2.15116076],
    [ 0.51029922, -0.43316864, -0.25205585, 0.90836388],
    [ 0.39917432, -0.74033444, -2.30525874, 0.3605075 ],
    [ 0.41131976, 1.19119329, 0.14672981, 0.9664657 ]])
    arr.mean()
    0.06605746127797299
    arr.mean(axis=1)
    array([-0.02657911, 0.18335965, -0.57147784, 0.67892714])

    • 算法平均数

  • std()、var()

    arr = np.random.randn(4, 4)
    arr
    array([[-0.02607772, -2.372853 , 0.14145354, 2.15116076],
    [ 0.51029922, -0.43316864, -0.25205585, 0.90836388],
    [ 0.39917432, -0.74033444, -2.30525874, 0.3605075 ],
    [ 0.41131976, 1.19119329, 0.14672981, 0.9664657 ]])
    arr.std()
    1.1247450504274712

    • 标志差和方差

  • min()、max()

    • 最小值和最大值

  • argmin()、argmax()

    • 最小和最大元素的索引

  • cumsum()

    arr = np.arange(9).reshape(3,3)
    arr
    array([[0, 1, 2],
    [3, 4, 5],
    [6, 7, 8]])
    arr.cumsum(0)
    array([[ 0, 1, 2],
    [ 3, 5, 7],
    [ 9, 12, 15]], dtype=int32)

    • 所有元素的累计和

  • cumprod()

    arr = np.arange(9).reshape(3,3)
    arr
    array([[0, 1, 2],
    [3, 4, 5],
    [6, 7, 8]])
    arr.cumprod(1)
    array([[ 0, 0, 0],
    [ 3, 12, 60],
    [ 6, 42, 336]], dtype=int32)

    • 所有元素的累计乘

• 4.布尔型数组运算

  arr = np.random.randn(20)
  arr
  array([ 0.70561778, -1.5575664 , -1.30383575, 0.16117604, 0.72044146,
  1.39715875, 0.02320483, 1.67274238, -0.23307639, -0.7110304 ,
  -1.46205799, 0.96488753, 1.03576526, -0.25936295, -0.3195715 ,
  0.56488814, -0.53047122, 1.26923247, -0.28068091, 0.84082391])
  (arr > 0).sum()
  11

  • any()

    arr = np.array([True, False, False, True])
    arr
    array([ True, False, False, True])
    arr.any()
    True

    • 用于测试数组中是否存在一个或者多个Ture

  • all()

    arr = np.array([True, False, False, True])
    arr
    array([ True, False, False, True])
    arr.all()
    False

    • 用于检查数组中的所有值是否为Ture

• 5.排序

  arr = np.random.randn(10)
  arr
  array([-0.01698758, -1.05885854, -0.04676058, -0.53817172, 1.23444601,
  0.20956774, -1.37186925, 1.39811486, 1.5994996 , -0.31663337])
  arr.sort()
  arr
  array([-1.37186925, -1.05885854, -0.53817172, -0.31663337, -0.04676058,
  -0.01698758, 0.20956774, 1.23444601, 1.39811486, 1.5994996 ])
  arr = np.random.randn(5,3)
  arr
  array([[ 1.3268483 , -0.65161236, 0.70938893],
  [ 0.92519118, 0.4418409 , -0.08406218],
  [-1.29632815, -0.17069917, -1.17039167],
  [ 1.10217509, -0.42712203, -1.09580594],
  [ 1.05888685, 0.09851792, -1.58275576]])
  arr.sort(1) # 按行排序
  arr
  array([[-0.65161236, 0.70938893, 1.3268483 ],
  [-0.08406218, 0.4418409 , 0.92519118],
  [-1.29632815, -1.17039167, -0.17069917],
  [-1.09580594, -0.42712203, 1.10217509],
  [-1.58275576, 0.09851792, 1.05888685]])

  • sort()

• 6.集合运算

  • np.unique(x)

    fruits = np.array([‘apple’, ‘banana’, ‘pear’, ‘banana’, ‘pear’, ‘apple’, ‘pear’])
    fruits
    array([‘apple’, ‘banana’, ‘pear’, ‘banana’, ‘pear’, ‘apple’, ‘pear’],
    dtype=’<U6’)
    np.unique(fruits)
    array([‘apple’, ‘banana’, ‘pear’], dtype=’<U6’)

    • 唯一值

  • np.inld(x,y)

    arr = np.array([2, 3, 5, 7])
    arr
    array([2, 3, 5, 7])
    np.in1d(arr, [2, 7])
    array([ True, False, False, True])

    • x的元素是否在y中，返回一个布尔数组

  • intersect1d(x,y)

    arr = np.array([2, 3, 5, 7])
    arr
    array([2, 3, 5, 7])
    np.intersect1d(arr,[1,2,5])
    array([2, 5])

    • 公共元素

  • union1d(x,y)

    arr = np.array([2, 3, 5, 7])
    arr
    array([2, 3, 5, 7])
    np.union1d(arr,[1,2,5])
    array([1, 2, 3, 5, 7])

    • 并集

  • setdiff1d(x,y])

    arr = np.array([2, 3, 5, 7])
    arr
    array([2, 3, 5, 7])
    np.setdiff1d(arr,[1,2,5])
    array([3, 7])

    • 集合的差

  • setxor1d(x,y])

    arr = np.array([2, 3, 5, 7])
    arr
    array([2, 3, 5, 7])
    np.setxor1d(arr,[1,2,5])
    array([1, 3, 7])

    • 集合取反

• 7.线性代数

  • dot()

    arr1 = np.array([[1, 2, 3], [4, 5, 6]])
    arr1
    array([[1, 2, 3],
    [4, 5, 6]])
    arr2 = np.arange(9).reshape(3,3)
    arr2
    array([[0, 1, 2],
    [3, 4, 5],
    [6, 7, 8]])
    np.dot(arr1,arr2)
    array([[24, 30, 36],
    [51, 66, 81]])

    • 矩阵乘法

  • 行列式

    from numpy.linalg import det
    arr = np.array([[1, 2], [3, 4]])
    arr
    array([[1, 2],
    [3, 4]]
    det(arr)
    -2.0000000000000004

4.数组的存储