python数据分析 | numpy全面介绍及使用

本篇博客讲的是numpy，一个数据分析中我们常常接触和使用的模块，下面开始正文吧~

1 numpy介绍和安装

（1）Numpy是什么？
NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

（2）为什么会有Numpy?
Python中提供了list容器，可以当作数组使用。但列表中的元素可以是任何对象，因此list中保存的是对象的指针，这样一来，为了保存一个简单的列表，如[1,2,3]，就需要三个指针和三个整数对象。对于数值运算来说，这种结构显然不够高效。Python虽然也提供了array模块，但其只支持一维数组，不支持多维数组，也没有各种运算函数。因而不适合数值运算。NumPy的出现弥补了这些不足。

（3）Numpy有什么特点？
NumPy 是一个运行速度非常快的数学库，主要用于数组计算，有如下特点：

• 一个强大的N维数组对象 ndarray
• 提供了基于数组的便捷算术操作、进行快速的矩阵计算以及广播机制
• 整合 C/C++/Fortran 代码的工具
• 线对硬盘中数组数据进行读写操作

（4）Numpy应用在何处？
NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。

PS. （1）SciPy 是一个开源的 Python 算法库和数学工具包，包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
（2）Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API），学习见python数据分析 | Matplotlib全面介绍及使用。
应用参考菜鸟教程：NumPy 教程

（5）Numpy如何安装？
直接在dos命令行中pip install numpy 即可
具体信息和学习可见官网：https://numpy.org/devdocs/user/quickstart.html

2 Numpy的基础使用

2.1 创建N-维数组对象

NumPy的主要对象是齐次多维数组，称为ndarray（数组），别名 array。下面展示如何创建array。

（1）生成数组最简单的方式就是使用array函数。array函数接收任意的序列型对象，生成一个新的包含传递数据的Numpy数组。
（2）语法1：numpy.array(object)
（3）语法2：numpy.arange([start,] stop[, step,])
（4）注意：ndarray数组是一个通用的多维同类数据容器，意味着数组里面每一个元素均为相同类型

# 创建N-维数组对象示例
import numpy as np
li = [1,2,3,4]
a1 = np.array(li)
a1  # array([1, 2, 3, 4])
a2 = np.array(range(1,5))
a2  # array([1, 2, 3, 4])
a3 = np.arange(1,5)  
a3  # array([1, 2, 3, 4])

# ndarray数组是一个通用的多维同类数据容器，意味着数组里面每一个元素均为相同类型
# list 中元素可以任意类型 ，那ndarray呢?
li1 = ["1",0.5,50]
a4 = np.array(li1)
a4  # array(['1', '0.5', '50'], dtype='<U3')  数据都转为字符串

2.2 数组的数据类型

（1）数组的数据类型如下：

（2）查看数组数据类型 arr.dtype。 示例如下
注意： 创建数组时，np.array()会自动推断生成数组的数据类型

import numpy as np
arr = np.arange(1,5)
arr.dtype   # dtype('int32')

（3）指定数组的数据类型： numpy.array(object,dtype=None)，创建数组时通过dtype直接指定。示例如下

import numpy as np
arr = np.array([1,2,3],dtype='f8')
arr
arr.dtype # dtype('float64')

（4）修改数组的数据类型：arr.astype(dtype)。示例如下

import numpy as np
arr = np.array([1,2,3])
arr = arr.astype(np.float32)
arr.dtype

2.3 数组形状

介绍：Numpy官网中的一句话：It is a table of elements (usually numbers), all of the same type, indexed by a tuple of non-negative integers. In NumPy dimensions are called axes.
简单地说，Numpy是的维度（形状）是依据轴（axes）来划分的。

（1）数组的维度介绍：

• 一维数组： array([0, 1, 2, 3, 4, 5])
  axis = 0 --> x轴
  
• 二维数组：array([[1, 2, 3],[4, 5, 6]])
  axis = 0 --> 为行，x轴； axis =1 --> 为列，y轴
  
• 三维数组：array([[[ 1, 2, 3],[ 4, 5, 6]], [[ 7, 8, 9],[10, 11, 12]]])
  axis = 0 --> 为层（或块），z轴； axis = 1 --> 为列，x轴； axis = 2 --> 为列，y轴
  
  （2）查看数组的维度：arr.ndim
  注意此处是属性，不用加括号 查看数组的维度，返回值为整数
  （3）查看数组的形状：arr.shape
  注意此处是属性，不用加括号 查看数组的形状，返回值为元组

arr1 = np.array(range(6))
print(arr1.ndim)     # 1 --> 1维
print(arr1.shape)    # (6,) --> 1.元组 2.一维

arr2 = np.array([[1,2,3],[4,5,6]])  # 2行,3列
print(arr2.ndim)     # 2 --> 2维
print(arr2.shape)    # (2,3) --> 1.元组 2.一维

arr3 = np.array([[1,2,3],[4,5]])   # 注意：不对等的则是一维 把子列表当成独立的列表对象
arr3 # array([list([1, 2, 3]), list([4, 5])], dtype=object)

arr4 = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print(arr4.ndim)   # 3维
print(arr4.shape)  # (2, 2, 3)  2层 2行 3列

2.4 重塑数组形状

（1）一维转多维
语法：arr.reshape(shape,order="C")

• shape为数组重塑形状
• order表示重塑方向
• C顺序(行方向)重塑
• F顺序(列方向)重塑
• 注意：reshape()里面 行*列=一维数组的元素个数

import numpy as np
arr1 = np.arange(6)
print(arr1) # [0 1 2 3 4 5]
# 重塑为二维
arr2 = arr1.reshape(2,3) # 默认为行重塑
print(arr2) # [[0 1 2] [3 4 5]]
arr3 = arr1.reshape(2,3,order="C") # 默认为行重塑
print(arr3) # [[0 1 2] [3 4 5]]
arr4 = arr1.reshape(2,3,order="F")
print(arr4) # [[0 1 2] [3 4 5]]  # [[0 2 4] [1 3 5]]
# 重塑为三维
print(np.arange(24).reshape(2,3,4))   # 2*3*4 = 24   块，行，列  # 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]]])

（2）多维转一维
语法1： arr.flatten()
语法2：arr.ravel()

arr5 = np.arange(12).reshape(3,4)
arr5.shape    # (3, 4) 元组
# 将其二维 转为 一维
arr6 = arr5.flatten()   
arr7 = arr5.ravel()
print(arr6,'\n',arr7) 
'''
结果：
[ 0  1  2  3  4  5  6  7  8  9 10 11] 
[ 0  1  2  3  4  5  6  7  8  9 10 11]
'''

2.5 数组转置与换轴

语法1 ： arr.transepose() # 转置
语法2 ：arr.T 注意无加括号
语法3 ：arr.swapaxes() # 换轴

arr = np.arange(20).reshape(4,5)
a_t1 = arr.transpose()    # 转置 沿着对角线转置，对角线不变
print(arr,'\n',a_t1)
a_t2 = arr.T           # 转置
print(arr,'\n',a_t2)
a_t3 = arr.swapaxes(1,0)  # 交换轴 转置
print(arr,'\n',a_t3)

2.6 数组拷贝

（1）不拷贝

import numpy as np

arr = np.arange(12)
arr2 = arr
# 判断arr2与arr是否同时指向同一内存地址
arr2 is arr    # True 说明两者指向一致
arr2[1] = 20   # 当改变arr2时，arr也进行了更改 
arr  # array([ 0, 20,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

（2）浅拷贝

arr3 = arr.view()   # 浅拷贝
arr3 is arr   # False 说明两者不是同一个内存
arr3[0] = 10  # 注意：在改变 arr3的时候 是会影响到arr获取的值的  
arr # array([10, 20,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

（3）深拷贝

arr4 = arr.copy()  # 深拷贝
arr4 is arr        #False 两块在不同的栈区
arr4[2] = 30      # 修改arr4的元素时，并不影响arr 因为arr与arr4都不在一个堆区
arr  # array([10, 20,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

2.7 创建数组其他函数

# 示例 ：asarray与array的区别
# 当数据源为ndarray时，array()会拷贝副本，占用新的内存。但是asarray不会。
data = np.arange(1,5)
arr1 = np.array(data)
arr2 = np.asarray(data)

print(arr1)
print(arr2)

data[1] = 5

print(data)   # 变
print(arr1)   # 不变
print(arr2)   # 变

# 示例： np.ones()
a_one = np.ones(3)   # 创建一维的 全为1的数组
np.ones((2,3))      # 创建二维的 2行3列 值全为1的数组

# 示例： np.zeros()
np.zeros(3)     # 生成 一维 的 全为0的数组
np.zeros((3,3)) # 生成 二维 的 全为0的数组

# 示例：np.empty()
arr = np.empty(4)   # 生成没有初始化的空数组 

# 示例：np.full()
np.full(3,3)    # 生成 一维三个为3的元素
np.full((2,3),3) # 两行三列  值为全3的数组

# 示例：np.ones_like  同理存在的还有np.zeros_like、np.full_like等
arr2 = np.arange(12).reshape(3,4)
# 生成一个形状与 arr2 一致，但是值全为1的数组
np.ones_like(arr2)

3 Numpy的数组算术

数组之所以重要是因为它允许我们进行批量操作数据并且没有任何for循环。也被称为向量化。

3.1 数组与标量的算术操作

介绍：数组与标量的算术操作会把计算参数传递给数组的每一个元素。

import numpy as np
# 1维数组
arr1 = np.arange(6)
print(arr1 + 1)   # 每个元素都会进行加1(广播机制)
# 2维数组
arr2 = np.arange(6).reshape(2,3)
print(arr2 + 2)  # 每个元素+2  
print(arr2*2) # 每个元素*2 
print(arr2**2)  # 幂运算
print(arr2//2) # 整数除法

3.2 两个等尺寸数组的算术操作

介绍：两个等尺寸数组的算术操作实际上是逐元素操作

arr1 = np.arange(6).reshape(2,3)
arr2 = np.arange(1,7).reshape(2,3)
print(arr1+arr2)     # 对应位置相加 
print(arr1-arr2)     # 对应位置相减
print(arr2>arr1)    # 对应位置比较 返回 bool 值

3.3 广播机制

提问一个问题[数组形状不同的话可以做运算嘛？]，这里可以引入广播机制

广播机制规则：如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符或其中一方的长度为1，则认为他们是广播兼容的。广播会在缺失和（或）长度为1的维度上进行。（理解为：数组形状从后往前看：只要一个轴的长度为1，另一个轴的长度一致。则往轴长度为1的方向进行广播。）
下面分情形了解
（1）与列数相同并且只有1行的数组之间进行运算
（2）与行数相同并且只有1列的数组之间进行运算
（3）注意：在numpy当中，维度完全不一致的时候，无法进行广播

# 与列数相同并且只有1行的数组之间进行运算
arr1 = np.arange(12).reshape(4,3)   # (4,3)
arr1 = np.arange(3).reshape(1,3)    # (1,3)
print(arr1)
print(arr1)
print(arr1-arr2)

# 与行数相同并且只有1列的数组之间进行运算
arr3 = np.arange(12).reshape(4,3)   # (4,3)
arr4 = np.arange(4).reshape(4,1)    # (4,1)
print(arr3)
print(arr4)
print(arr3-arr4)

# 注意：在numpy当中，维度完全不一致的时候，无法进行广播
arr5 = np.arange(12).reshape(4,3)   # (4,3)
arr6 = np.arange(6).reshape(3,2)    # (3,2)
print(arr5)
print(arr6)
print(arr5-arr6)

3.4 数组拼接

• 垂直拼接：np.vstack()
• 水平拼接：np.hstack()
• 注意：水平拼接需要对应行数一致,垂直拼接需要对应列数一致。

a = np.arange(12).reshape(2,6)
b = np.arange(12,24).reshape(2,6)
print(a)
print(b)
# 垂直拼接 注意：参数为tup
v = np.vstack((a,b))
# 水平拼接 
h = np.hstack((a,b))

print(v,'\n',h)

#  当形状都不一致的时候，无法进行拼接
c = np.arange(12).reshape(2,6)
d = np.arange(12,24).reshape(3,4)
print(c)
print(d)
np.hstack((c,d))   # 报错
np.vstack((c,d))     # 报错

4 数组索引和切片

4.1 一维索引与切片

同python中的内建数据类型list一致

a1 = np.arange(10)
# 取2   索引默认从0开始
a1[2]   
# 取[0,1]  左闭右开
a1[:2]
# 取[1,3,5,7,9]
a1[1::2]
# 倒着取
a1[::-1]

4.2 二维的数组切片

（1）二维数组递归方式获取
（2）二维数组逗号分隔获取(行,列)

• 取单行 arr[x1,:]
• 取连续行 arr[x1:x2,:]
• 取分开行 arr[[x1,x2],:]
• 取子矩阵 arr[x1:x2,y1:y2]
• 取点 arr[[x1,x2],[y1,y2]]
• 注意
  （1） 当有需要修改数组当中的值时，我们可以直接取值进行赋值。
  （2）当数组与标量进行比较时，数组当中每个元素与标量进行比较，返回bool值。与此同时,该比较也可以作为索引，被称为布尔索引。比如arr[arr>20]

a2 = np.arange(24).reshape(4,6)
"""
递归方式取值
"""
# 取第二行
a2[1]

# 取7
a2[1][1]

"""
逗号分割方式来取
(0,1) --> (行,列)
(0,1,2) --> (块,行,列)
"""
a2.shape   # (4, 6) --> (行,列)
a2

# 取第二行
a2[1,:]

# 取2-3连续行  1.索引从0开始  2.左闭右开
a2[1:3,:]

# 取2,4行 
a2[1::2,:]   # 步长

# 取分开的1,3行
a2[::2,:]
a2[(0,2),:]      # 神奇索引

# 取 8,9,14,15 子矩阵
a2[1:3,2:4]
a2[(1,2),:][:,(2,3)]  # 可以实现需求

a2[(1,2),(2,3)]       # 注意：分开执行(1,2)与(2,3)  两个交点[8,15] 神奇索引

4.3 修改数组当中的值

a = np.arange(24).reshape(4,6)
a[:,1] = 0   # 将第二列 的值 全部修改为 0

4.4 满足某条件时才将数据选择出来

（1）利用bool索引

a = np.arange(24).reshape(4,6)
a<10     # 每个元素进行比较返回为 bool 值  满足条件：True  不满足条件：False

a[a<10]   # 通过布尔索引取值 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

a3[a3==0] = 20  # 将0值改为20
a3

"""
筛选出 >2 并且 <8 的值

- 逻辑运算符写法与python有所不同 不是 and 跟 or
- 而是 & |
"""
a[(a>2) & (a<8)]

（2）利用condition和clip函数

"""
numpy.where()函数是三元表达式 x if condition else y  的向量化版本。
np.where(condition,[x,y])
满足condition 则 x，不满足 则y
"""
# 将<10的变为0 将大于等于10变为10
np.where(a<10,0,10)

"""
numpy.clip(a, a_min, a_max, out=None)[source]
a是一个数组，后面两个参数分别表示最小和最大值
也就是说clip这个函数将将数组中的元素限制在a_min, a_max之间，大于a_max的就使得它等于 a_max，小于a_min,的就使得它等于a_min
"""
# a.clip :将小于等于5的替换为5 将大于10的替换为10 
np.clip(a,5,10)
a

5 Numpy操作本地数据

5.1 写入本地数据

语法：np.savetxt(fname, X, fmt='%.18e', delimiter=' ',newline='\n', header='',footer='', comments='# ', encoding=None,)

• name :文件路径
• X : 所需要写入的数据
• dtype : 数据类型
• delimiter : 分隔符
• fmt=’%.18e’: 写入文件的格式，例如：%d，%.2f，%.18e
• converters : 对数据预处理。比如{0:func}第0列进行func函数预处理
• header : 指定为表头

# np.savetxt??
# 随机生成数据 40*2  0,100  期末与期中成绩
scores = np.random.randint(0,100,size=(40,2))
print(scores)
print(scores.shape)
# 写入数据
np.savetxt("scores.csv",scores,fmt="%d",delimiter=",",header="期中,期末",comments="")

5.2 读取本地数据

语法：np.loadtxt(fname,dtype=<class 'float'>,comments='#',delimiter=None,converters=None,skiprows=0,usecols=None, unpack=False, ndmin=0,encoding='bytes',max_rows=None,)

• fname : 文件路径
• dtype : 数据类型
• delimiter : 分隔符
• skiprows : 跳过行，设置为1就是跳过1行，以此类推
• comment : 如果行的开头为 # 就会跳过该行
• usecols : 是指使用(0,2)两列
• unpack : 每一列当成一个向量输出,而不是合并在一起 如 是[1 4 7] [3 6 9]，而不是[[1 4 7],[3 6 9]]
• converters : 对数据预处理。比如{0:func}第0列进行func函数预处理 func是设置一个函数

更多可以参考学习：numpy.loadtxt() 用法

# np.loadtxt??
# numpy 中 ndarray 都是 同质性 
# 1.文件名  2.跳过表头 字符串 3.csv文件默认以逗号作为分隔符 否则，它会把整个30,30当成整体 
np.loadtxt("scores.csv",skiprows=1,delimiter=",")  
# 2.不常用，数据类型指定为字符串 
# np.loadtxt("scores.csv",delimiter=",",dtype="object")

5.3 合并数据集并读取示例

"""基础代码"""
# 1.读取云南白药的数据
ylby_stock = np.loadtxt("云南白药.csv",delimiter=",",dtype="object")
ylby_stock
# 2.读取五粮液的数据
wly_stock = np.loadtxt("五粮液.csv",delimiter=",",dtype="object")
wly_stock
# 数据行堆叠
v_data = np.vstack((ylby_stock,wly_stock))
# 保存至新的文件
np.savetxt("all_data.csv",v_data,delimiter=",",fmt="%s")

"""代码优化：函数封装，去掉重复的表头"""
# 定义函数 
def vstack_data(*args):  
    # 设置list保存需堆叠的数据
    vstack_li = []   
    
    # 遍历取出每个 文件名
    for index,file_name in enumerate(args):        
        # 第一个文件读取时保存表头，其他不保存
        if index == 0 :
            # 读取每个文件的 数据
            per_data = np.loadtxt(f"{file_name}",delimiter=",",dtype="object")        
            # 将这些数据 都放到 列表 或者 元组当中 
            vstack_li.append(per_data)
        else:
            # 读取每个文件的 数据
            per_data = np.loadtxt(f"{file_name}",skiprows=1,delimiter=",",dtype="object")        
            # 将这些数据 都放到 列表 或者 元组当中 
            vstack_li.append(per_data)                        
    # print(len(vstack_li))
    
    # 数据行堆叠
    v_data = np.vstack(vstack_li)
    
    # 保存文件
    np.savetxt("all_data2.csv",v_data,delimiter=",",fmt="%s")


# 总共合并的文件并不确定有多少个，怎么解决？ 使用可变长度参数实现
# **-->{}  *-->()
vstack_data("云南白药.csv","五粮液.csv")

6 NaN与inf

（1）NaN与inf介绍

• NaN：not a number 表示不是一个数字，属于浮点类。
• inf：np.inf 表示正无穷，-np.inf表示负无穷，属于浮点类。

# 赋值为nan
arr = np.arange(16).reshape(4,4)
## 数据同质性需要将数据类型改为浮点类型
arr1 = arr.astype("float")
arr1[1,2] = np.nan 
arr1

（2）NaN特点
1)nan与inf都是float类型

# 1)nan与inf都是float类型
c = np.nan
type(c)    # float
d = np.inf
type(d)    # float

2）两个nan是不相等的

• 该特性可以用来判断nan的个数
• np.count_nonzero() 计算非零的个数
• np.isnan() 判断数组元素是否是NaN，返回为bool值

a = np.arange(6).reshape(2,3).astype("float")
# 5 替换为 np.nan
a[1,2] = np.nan
# 怎么判断nan的个数？ 原理：两个nan是不相等的 np.nan != np.nan

# 法1：通过布尔索引 取出nan的数组 再来求其长度  
len(a[a!=a])
# 法2：利用True==1 False==0 计算非零的个数
True == 1
False == 0
# 计算非零的个数  
np.count_nonzero(a!=a)
# 法3:np.isnan() 判断元素是否为np.nan  返回的是bool
np.count_nonzero(np.isnan(a))

3）nan与任何值进行运算都是 nan
也正因为，np.nan与任何值计算都是nan所以在运算时，会带来较大的误差。一般我们都会将其处理掉。

# nan与任何值进行运算都是 nan
a+10000

（3）如何处理掉NaN
处理掉NaN，我们通常有两种做法。

• 第一种：删除存在nan的行，适用于数据量大。
• 第二种：用均值替代nan，适用于数据量小。

"""删除存在nan的行，适用于数据量大"""
b = np.arange(9).reshape(3,3).astype("float")
# 1,5 赋值为 nan
b[(0,1),(1,2)] = np.nan
print(b)
"""
np.where(condition)
- 只有condition
- 返回满足条件的元素的位置  (所在行,所在列)
"""
row_index = np.where(np.isnan(b)) # isnan()函数判断是否为nan，为nan的会返回索引位置
print(row_index)
# 将含有nan的行删除
"""
np.delete??
- arr 输入的数组
- obj 要移除的索引
- axis=0 表示移除行（二维数据）
- axis=1 表示移除列（二维数据）
"""
del_arr = np.delete(b,row_index,axis=0)
del_arr

"""用均值替代nan，适用于数据量小"""
# 将 exam.csv 文件的数据读取，并且将成绩为空的值替换为非空数据的均值
# 读取数据  存在缺失值，所以数据类型先指定为字符串
exam_data = np.loadtxt("exam.csv",skiprows=1,delimiter=",",dtype=np.str)
# 取出空格 赋值给0
exam_data[exam_data == ""] = 0
# 将数据转为float类型
exam_data = exam_data.astype(float)
# 将为0 的数据 赋值为 np.nan
exam_data[exam_data == 0] = np.nan
# 将 nan 替换为 非nan的均值
# 成绩是一列一列的 所以 循环取出每列
for exam_col in range(exam_data.shape[1]):
    # 取出每一列 数据
    exam_col = exam_data[:,exam_col]   
    # 取出 非nan 的值   
    non_nan_data = exam_col[exam_col == exam_col]    
    # 求 非nan 的均值 赋值给 nan 的值
    exam_col[exam_col != exam_col] = non_nan_data.mean()
    print(np.round(exam_col))

7 Random模块

介绍：np.random为我们提供了许多获取随机数的函数。其实是python内置random模块进行的封装。
学习网址：https://numpy.org/doc/stable/reference/random/legacy.html#numpy.random.RandomState
（1）np.random.seed
介绍：用于指定随机数生成时所用算法开始的整数值，如果使用相同的seed()值，则每次生成的随即数都相同，如果不设置这个值，则系统根据时间来自己选择这个值，此时每次生成的随机数因时间差异而不同。一般没有特殊要求不用设置。

np.random.seed(1)
print(np.random.rand()) 

（2）np.random.rand
生成一个值为[0,1)之间的数组.形状由参数指定，如果没有参数，那么将返回一个随机值。示例代码如下

data = np.random.rand() #生成一个0-1之间的随机数
print(data)

（3）np.random.randn
生成均值(μ)为0，标准差（σ）为1的标准正态分布的值。示例代码如下：

data = np.random.randn(2,3) #生成一个2行3列的数组，数组中的值都满足标准正太分布
print(data)

（4）np.random.randint
生成指定范围内的随机数，并且可以通过size参数指定维度。示例代码如下

data = np.random.randint(10,size=(3,5)) #生成值在0-10之间，3行5列的数组
print(data)

（5）np.random.choice
从一个列表或者数组中，随机进行采样。或者是从指定的区间中进行采样，采样个数可以通过参数指定

data = np.arange(100)
res = np.random.choice(data,size=(2,3)) #从data中随机采样，生成2行3列的数组
print(res)

（6）np.random.shuffle
把原来数组的元素的位置打乱，没有返回值 洗牌洗的是原有数据本身。

a = np.arange(10)
np.random.shuffle(a) #将a的元素的位置都会进行随机更换  无返回值
print(a)

8 Numpy常用函数

Numpy函数的使用可以去官网学习参考，这里只是罗列学习一些常用的！
摆上网址：https://numpy.org/devdocs/reference/index.html#reference
提问为什么 python当中有相应的内置方法，那为什么还要使用numpy中的函数？
原因在于专业性，运算得更快

%time sum(np.arange(100000000))   # 使用python内置的sum() 求和 所花时间 14.8 s

%time np.sum(np.arange(100000000)) # 使用numpy.sum() 求和  204 ms

8.1 聚合函数

arr = np.arange(12).reshape(3,4)

"""np.sum()函数"""
np.sum(arr)   # 将arr数组求和
np.sum(arr,axis=0)  # 计算0轴(向下)的累和
np.sum(arr,axis=1)  # 计算1轴(向右)的累和

"""np.mean()函数"""
np.mean(arr)  # 求均值
arr2 = np.mean(arr,axis=0,dtype=np.int) # # 计算0轴(向下)的均值
np.mean(arr,axis=1,dtype=np.int)   # 计算1轴(向右)的均值  int是只保留整数部位

"""np.min()函数"""
np.min(arr)   # arr整个数组的最小值
np.min(arr,axis=0)  # 求出了0轴的最小值
np.min(arr,axis=1)  # 求出了1轴的最小值

"""np.max函数"""
np.max(arr)   # arr整个数组的最大值
np.max(arr,axis=0)  # 求出了0轴的最大值
np.max(arr,axis=1)  # 求出了1轴的最大值

"""np.argmax()函数"""
np.argmax(arr) # 求最大值的索引位置
np.argmax(arr,axis=0) # 求0轴 最大值的索引位置
np.argmax(arr,axis=1) # 求1轴 最大值的索引位置

"""np.var()方差"""
# 样本数据 跟 均值之间的偏离程度 方差越小 数据也就越稳定
np.var(arr) 

""" np.std() 标准差"""
# 标准差是方差的算术平方根
# 反应数据的波动性 标准差越大 波动越大 
np.std(arr)

"""np.ptp()极值"""
np.ptp(arr,axis=0)   # max()-min() 

"""np.median() 中位数"""
np.median(arr)   # 中值 5+6/2
np.median(arr,axis=0)
np.median(arr,axis=1)

"""np.cumsum() 累积和"""
np.cumsum(arr)

"""np.nansum()会略过nan值,直接求和，如果直接用sum，求和得出的是nan"""
arr1 = arr.astype("float")
arr1[2,2] = np.nan
# np.sum(arr1)    # 如果说数据中含有nan的话，那么直接使用sum 进行求和 为 nan
np.nansum(arr1)   # 56.0  np.nansum() 会略过nan值

8.2 一元函数

"""随机生成一个-10~10的 三行五列 服从均匀分布的数据 """
arr = np.random.uniform(-10,10,size=(3,5))

"""np.abs() 求绝对值 """
np.abs(arr)

"""
np.sqrt 开根号
数据有定义域 x>=0   负数 开根号 为 nan
"""
np.sqrt(arr)

"""np.square 平方"""
arr1 = np.arange(4)
np.square(arr1)

"""np.exp 计算指数 e**x  """ 
np.exp(0)   # e**0 -->1.0 
np.exp(1)   # e**1 -->e   2.718281828459045
np.exp(2)   # e**2 --> 7.38905609893065

"""
# np.log 以e为底的对数
# np.log10 
# np.log2
# 通常使用底数进行数据收敛
"""
np.log(np.exp(1))   # 1  
np.log(1)           # 0.0

"""np.sign()    将数组中的值标签化 大于0的变成1 等于0变成0 小于0的变成-1"""
np.sign(arr)

"""np.ceil()向上取整"""
np.ceil(4.1)   # 向上取整
np.ceil(-6.6)  # 向上取整 

"""np.floor()向下取整"""
np.floor(4.9)   # 向下取整
np.floor(-6.6)  # 向下取整

"""np.rint()四舍六入五成偶"""
np.rint(4.4)   # 四舍
np.rint(4.6)   # 六入
np.rint(5.5)   # 五成偶 

"""np.modf()   将整数与小数分隔开来 形成两个数组"""
np.modf(arr)

"""
# np.sin()  
# 2pi = 360°
"""
np.sin(np.pi/2)

8.3 二元函数

a = np.arange(12).reshape(3,4)
b = np.arange(12,24).reshape(3,4)
print(a)
print(b)
np.add(a,b)
np.subtract(a,b)  # 其他以此类推

"""logical_and和logical_or相当于& |"""
# &
# 从a中取出<5 并且 >0的数
a[(a>0) & (a<5)]
a[np.logical_and(a>0,a<5)]

"""布尔函数"""
a1 = np.arange(10)  # 0,1,...9
np.any(a1)   # 只要有一个为True的 就会返回为True
np.all(a1)   # 只要有一个为False 则返回为False 

"""排序函数：np.sort()"""
a2 = np.random.randint(0,10,size=(4,4))
a2

"""划分等份 np.linspace()"""
# 将指定区间 平均分为多为多少份
np.linspace(0,10,15)  # 0-10 等分15份

"""去重：np.unique()"""
# 返回数组a3中的唯一值，并且在指定return_counts=True时，会返回每一个唯一值出现的次数
data = np.arange(6)
a3 = np.random.choice(data,(2,3))
np.unique(a3,return_counts=True)  # (array(不重复的元素),array(出现的次数))