Numpy

Numpy

一、数据分析简介

• 数据分析流程（得洗展建析）

  • Obtain（获得数据）
    Scrapy

  • Scrub（清洗数据）
    Numpy、Pandas

  • Explore（展示数据）
    Matplotlib\Seaborn

  • Model（数据建模）
    scikit-learn\SciPy\TensorFlow

  • iNterpret（解析数据）
    Bokeh\D3.js

二、Numpy 库

1. 功能：操作数组

数组元素必须是同一数据类型，列表元素可以是不同数据类型。
列表不可以进行四则运算，数组可以进行四则运算

2. 创建数组

• array()

  np.array(列表或元组)
  

• arange()-创建某个范围的数组，指定步长

  np.arange(start, end, step)
  

  -只有一个参数，表示只有结束值，默认开始值为0

  -只有两个参数，表示有开始值和结束值，左闭右开

  -只有三个参数，表示有开始值、结束值和步长，step可以是任意的数

• linspace()-创建某个范围的数组，指定个数

  np.linspace(start, end, step, endpoint=True或False，retstep = ture)
  # endpoint = False 表示范围为左闭右开,endpoint = True 表示范围为左闭右闭
  # retstep 为true返回一个步长
  

• zeros()-创建全是0的数组

  np.zeros(shape,dtype)
  """
  dtype = [('x', 'i4'), ('y', 'i4')]:
  这是一个数据类型说明符的列表，定义了复合数据类型的结构。
  -'x'和'y'是字段名称。
  -'i4'是NumPy的数据类型代码，表示一个32位的有符号整数（通常对应于C语言中的int类型）。
  """
  

• ones()-创建全是1的数组

  np.ones(shape,dtype)
  

3. 创建随机数组

• 随机整数数组

  np.random.randint(start,end,size = 元组或整数)
  

• 随机浮点数数组，范围[0,1)

  np.random.rand(m,n)
  #创建一个m*n的数组
  

• 随机浮点数数组，符合正态分布

  np.random.randn(m,n)
  #创建一个m*n的符合正态分布的随机数组
  

4. 数组属性

• ndim-说明纬度的个数
• dtype-说明数组中每个元素的类型
• size-说明数组的元素个数
• shape-说明数组的形状

5. 元素操作

• 访问元素-使用下标的方式

  arr[1,2]与arr[1] [2] 表达相同

• 修改元素-使用下标的方式

  修改一整行的数据arr[row_num] = [n1,n2,n3,……]

• 删除元素

  np.delete(arr,m,axis)
  # m表示根据axis来表示行或者列数(从0开始)，
  

• 添加元素

    np.append(arr,value,axis = n)
    # append是返回一个新的数组，不是在原来数组上进行修改
  

  axis = n 表示沿着“第n个下标”变化的方向进行操作,下面有两个说明的例子

import numpy as np
arr = np.array([[10,20,30],[40,50,60]])
result1 = np.append(arr,[[11,22,33]],axis = 0)
print(result1)

[[10 20 30]
 [40 50 60]
 [11 22 33]]

result2 = np.append(arr,[[11],[22]],axis = 1)
print(result2)
#当axis = 1 要求两个数组的行数必须相同否则将报错

[[10 20 30 11]
 [40 50 60 22]]

result3 = np.append(arr,[[11,22],[33,44]])
print(result3)
#当axis为空时，append将两个数组都打为一维数组，并组合为一起

[10 20 30 40 50 60 11 22 33 44]

• 切片的方式

  #切片操作的一般形式是：
  arr[start:stop:step]
  
  """
    start 是切片开始的位置索引。
    stop 是切片结束的位置索引（不包括该索引处的元素）。
    step 是步长，表示取元素的间隔。
  

  特殊用法 arr[::-1]:
  当 step 设置为 -1 时，切片操作将从数组的末尾开始向前取元素，这实现了反转的效果。
  “”"

6. 数组操作

• 修改形状

  arr.reshape(m,n)
  

• 修改维度

  np.array(arr,ndim = n)
  # 只能将低纬数组转换为高维数组
  

• 翻转数组:将“mn的数组”转换成“nm的数组”

  np.transpose(arr)
  

• 数组去重

  np.unique(arr)
  #uniqe()会将数组中重复的数字去除，然后将剩余的数字组成一个新的一位数组
  

• 合并数组
  • concatenate() 沿“现有轴”合并

    np.concatenate((arr1,arr2),axis)
    # arr1,arr2 是形状相同、元素类型相同的数组
    

  • hstack() 沿“现有轴”水平合并

    np.hstack((arr1,arr2))
    

  • vstack() 沿“现有轴”垂直合并

    np.vstack((arr1,arr2))
    

  • stack() 沿"新的轴"合并, 指的是创建一个新的轴并进行合并，数组维度更大

    np.stack((arr1,arr2),axis = n)
    # n是大于等于0的整数
    

import numpy as np
#使用concatenate
arr1 = np.array([[1,2],[3,4]])
arr2 = np.array([[5,6],[7,8]])

#沿着纵轴合并
result_1 = np.concatenate((arr1,arr2),axis = 0)
print("纵轴合并：\n",result_1)
#等价形式 np.vstack((arr1,arr2))


#沿着横轴合并
result_2 = np.concatenate((arr1,arr2),axis = 1)
print("横轴合并：\n",result_2)
#等价形式 np.hstack((arr1,arr2))

纵轴合并：
 [[1 2]
 [3 4]
 [5 6]
 [7 8]]
横轴合并：
 [[1 2 5 6]
 [3 4 7 8]]

#使用stack
result_3 = np.stack((arr1,arr2),axis = 0)
result_4 = np.stack((arr1,arr2),axis = 1)
print(result_3)
print("\n")
print(result_4)

[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

​
[[[1 2]
[5 6]]

 [[3 4]
  [7 8]]]

根据上述示例，

两个数组使用concatenate()合并后，还是一个二维数组；但是两个二维数组使用stack()数组后就变成了一个三维数组。

沿“现有轴”合并，指的是根据数组原有的轴进行合并，合并后的两个数组维度相同 ；沿“新的轴”合并，值得是创建一个新的轴进行合并，合并后的数组维度更大。

！！注意看上述示例代码的结果不同点

• 分割数组
  • split() 分割数组

  np.split(arr,section = 整数或数组，axis = n)
  # section 若为整数，则使用该整数进行平均分割
  # section 若为一个数组，包含分割点的索引，这些索引定义了分割的位置，该位置的数分配到后一个数组中
  

  • hsplit() 分割数组（沿着“横轴”）
  • vsplit() 分割数组（沿着“纵轴”）

arr3 = np.array([1,2,3,4,5,6,7,8,9])
arr4 = np.array([[1,2,3,4],[5,6,7,8]])
#一维+section数组
result_arr3 = np.split(arr3,[1,3])
print(result_arr3)
#一维+section为整数，横轴
result_arr4 = np.split(arr4,2,axis = 1)
print(result_arr4)
#二维+section数组，横轴
result_arr4_2 = np.split(arr4,[1,2],axis = 1)
print(result_arr4_2)

[array([1]), array([2, 3]), array([4, 5, 6, 7, 8, 9])]
[array([[1, 2],
       [5, 6]]), array([[3, 4],
       [7, 8]])]
[array([[1],
       [5]]), array([[2],
       [6]]), array([[3, 4],
       [7, 8]])]

6. 各种运算

• 加减乘除、求余、求幂（**）：对应位置的数相乘

• 、<、>=、<=、==、!=

• 标量运算 （+10、-10、*2、、10） ：数组中的每个数都做运算

• 数学函数 ：square()\abs()\sqrt()\around():四舍五入\ceil()、floor()\reciprocal():求倒数\sin()、cos()、tan()

• 统计函数

  • sum(arr，axis = n)

  • max(arr，axis = n)

  • min(arr，axis = n)

  • median(arr，axis = n)求中位数

  • mean(arr，axis = n)求平均数

  • var(arr，axis = n)求方差

  • std(arr，axis = n)求标准差或均方差

  • average(arr,axis = n)加权平均数

  • percentile(arr,q,axis = n)百分位数: q是一个百分比

  百分位数（Percentile）是统计学中用来描述一个数值在一组数据中的相对位置的量度。它将数据集划分为100个等份，每个等份包含数据集的1%。百分位数可以告诉我们一个特定的数值在数据集中的位置，例如，一个数值位于第50百分位数，意味着它高于数据集中50%的数值。

  计算方法：
  百分位数通常通过以下步骤计算：

  1. 将数据集从小到大排序。
  2. 确定所需百分位数的位置，公式为：$$P=(n+1)\ast p/100$$​,其中 n 是数据集中的数值数量，𝑝是所需的百分位数（以百分比表示）。
  3. 如果计算出的 𝑃 是一个整数，那么这个位置的数值就是百分位数。
  4. 如果 𝑃 是一个小数，那么百分位数是位于 𝑃和 𝑃+1 位置数值的平均值。

例子：
假设有一个数据集 [10, 20, 30, 40, 50]，我们要找到第30百分位数。

1. 数据集已经排序。
2. 使用公式计算位置：$$P=(5+1)\ast 30/100=1.8$$
3. 由于 𝑃是一个小数，我们取第1和第2个数值（10和20），计算它们的平均值.
4. 第30百分位数是 (10 + 20) / 2 = 15。

• bincount()和argmax()求众数

  arr = np.array([24,32,16,24,32,24])

  #返回一个数组，对应位置的值表示该位置所代表的数出现的次数
  count = np.bincount(arr)

  #返回count数组对应的参数值的最大值
  mode = np.argmax(count)
  print(mode)


  #输出结果：
  #  24

import numpy as np
arr5 = np.array([[1,2,3],[4,5,6]])
print("列的总计",np.sum(arr5,axis = 1))
print("行的平均数",np.mean(arr5,axis = 0))
print("列的方差",np.var(arr5,axis = 1))
print("行的标准差",np.std(arr5,axis = 0))
print("列的百分位数",np.percentile(arr5,20,axis = 1))

列的总计 [ 6 15]
行的平均数 [2.5 3.5 4.5]
列的方差 [0.66666667 0.66666667]
行的标准差 [1.5 1.5 1.5]
列的百分位数 [1.4 4.4]

7. 遍历数组

import numpy as np
arr = np.array([[1,2],[3,4],[5,6]])

for item in arr:
    print(item)

#flat属性:会“打平”arr
for item in arr.flat:
    print(item)

[1 2]
[3 4]
[5 6]
1
2
3
4
5
6

8. 大小排序

#语法：默认为升序
arr.sort(axis = n)
np.sort(arr,axis = n)
#实现逆序：arr[::-1]

三、Numpy 进阶

1. 深拷贝和浅拷贝

-深拷贝：对数组对象拷贝后，前后两个数组是不同的对象。两个数组的数据是不共享的。

arr.view()
#返回一个数组

-浅拷贝：对数组对象拷贝后，前后两个数组是不同搞得对象。两个数组的数据是共享的，其中一个数组的数据改变后，另外一个数组的数据也会改变。

arr.copy()
#返回一个数组

2. 广播机制

允许NumPy用不同大小的数组进行数学运算。在没有广播的情况下，进行数组运算要求所有参与运算的数组具有完全相同的形状。然而，通过广播，NumPy可以利用一些规则来扩展数组的形状，以便它们在数学运算中兼容。

两个数组的形状不同，符合下面两种情况中的任意一种，即可进行加、减、乘、除运算：
》 维数不同时，两个数组的“后缘维度”相同。
》 维数相同时，有一个数组的某个轴长度为1。

#例：维数不同
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = np.array([10,10,10])
#将一维扩展为二维
print(a+b)

[[11 12 13]
 [14 15 16]]

#例：维数相同，但存在一个数组某个轴的长度为1
a = np.array([[1,1,1],[2,2,2],[3,3,3],[4,4,4]])
b = np.array([[10],[20],[30],[40]])
#将每个维度的列进行扩展，即一列扩展为三列
print(a+b)

[[11 11 11]
 [22 22 22]
 [33 33 33]
 [44 44 44]]

#例：维数相同，数组多条轴的长度为1
a = np.array([[1,1,1],[2,2,2],[3,3,3],[4,4,4]])
b = np.array([[10]])
#将行和列都进行扩展
print(a+b)

[[11 11 11]
 [12 12 12]
 [13 13 13]
 [14 14 14]]

3. 读写文件

• 读文件

  np.loadtxt(path,delimiter = "分隔符")
  

import numpy as np
arr = np.loadtxt(r'test.csv',delimiter=',',dtype=int)
print(arr)

[[53 48 27 31]
 [88 35 65 50]
 [42 55 41 40]]

• 写文件

  np.savetxt(path,arr,delimiter = "分隔符")
  # arr是一个数组
  

arr = np.array([[53,28,27,31],[88,35,65,50],[42,55,41,40]])
np.savetxt(r'test.csv',arr,delimiter=',',fmt="%d")

4. 矩阵

矩阵（matrix）都是二维的，可以使用matlib模块来创建。
矩阵和数组是两种不同的数据类型，数组是ndarray对象，矩阵是matrix对象。
数据相对于矩阵会更加的灵活，速度更快，大多情况下我们使用二维数组来完成工作。

• 单位矩阵

  np.matlib.identity(m)
  #行数和列数都是m
  

• 随机矩阵

  np.matlib.rand(m,n)
  
  """
  m是行数，n是列数
  每一个元素的值在0~1
  """
  

42 55 41 40]]

• 写文件

  np.savetxt(path,arr,delimiter = "分隔符")
  # arr是一个数组
  

arr = np.array([[53,28,27,31],[88,35,65,50],[42,55,41,40]])
np.savetxt(r'test.csv',arr,delimiter=',',fmt="%d")

4. 矩阵

矩阵（matrix）都是二维的，可以使用matlib模块来创建。
矩阵和数组是两种不同的数据类型，数组是ndarray对象，矩阵是matrix对象。
数据相对于矩阵会更加的灵活，速度更快，大多情况下我们使用二维数组来完成工作。

• 单位矩阵

  np.matlib.identity(m)
  #行数和列数都是m
  

• 随机矩阵

  np.matlib.rand(m,n)
  
  """
  m是行数，n是列数
  每一个元素的值在0~1
  """