版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_24499745/article/details/88752076
Numpy的简介
NumPy，是科学计算基础的一个库，提供了大量关于科学计算的相关功能.
例如，线性变换，数据统计，随机数生成等。
其提供的最核心的类型为多维数组类型（ndarray）.
导入Numpy包
import numpy as np
ndarray数组的创建
# 使用 np.array来创建数组
np.array([1, 2, 3])
np.array([[1, 2, 3], [4, 5, 6]])
# 使用arange来创建 ndarray（步长可以指定浮点类型，其余的和range差不多）
np.arange(10)
np.arange(5, 10)
np.arange(1, 9, 2)
# 创建值全为1的数组，参数shape指定数组的形状。
np.ones(shape=(2, 3))
# 创建值全为1的数组，参数（数组）来指定数组的形状。
# 【创建一个与参数数组形状相同的数组。】
t = np.array([[1, 2], [3, 4]])
np.ones_like(t)
# 创建一个值全为0的数组。
np.zeros(shape=(5, 5))
# 创建一个值全为0的数组。数组的形状与参数数组的形状相同。
t = np.array([[1, 2], [3, 4]])
np.zeros_like(t)
# 创建一个数组，数组的元素是未经初始化的。【值依然是程序上一次运行所遗留的值。】
np.empty((5, 5))
# 创建一个数组，数组的元素是未经初始化的。通过参数（另外一个数组）指定创建数组的形状。
t = np.array([[1, 2], [3, 4]])
np.empty_like(t)
# 创建数组，第1个参数指定数组的形状，第2个参数指定填充值。
np.full((2, 3), 10)
# 创建数组，第1个参数（数组类型）指定数组的形状，第2个参数指定填充值。
np.full_like(t, 100)
# 创建单位矩阵，参数指定长度。
np.eye(5)
np.identity(5)
# 创建一个数组，数组的元素是等差数列。
# 第1个参数：起始点。
# 第2个参数：终止点。
# num: 指定的元素的个数，默认为50。
# endpoint: 是否包含终止点，默认为True。
np.linspace(1, 40, num=30, endpoint=False)
# 创建数组，数组元素在对数级别上等差，实际数值等比的数列。
# 第1个参数，起始点。base^start
# 第2个参数, 终止点: base^stop
# num：数组元素的个数。
# endpoint：是否包含终止点，默认为True。
# base：指定底数
np.logspace(1, 10, 10, base=2)
创建小结：
arange与linspace方法。
arange侧重的是固定的增量，设置起始值和终止值，固定的增量，生成固定区间、固定步长的数组
linspace侧重的固定的元素数量，设置起始值和终止值，固定数量，生成固定区间、固定数量的数组
ndarray数组的属性(a指创建出来的数组对象)
# 返回数组的维度。
a.ndim
# 返回数组的形状
a.shape
# 获取行数
a.shape[0]
# 获取列数
a.shape[1]
返回数组元素的类型。
# a.dtype
# 返回ndarray数组元素的个数。（从最低维计数）
a.size
# 返回元素占用的空间大小，以字节为单位。
a.itemsize
数据类型设置
# 如果我们在创建ndarray的时候，没有显示的指定数组的类型，那么就会自动的隐式判断数据类型
# 如果我们的数据中的元素的类型是不一致的，那就会选择一个兼容的数据类型
# 总之，ndarray数组的元素数据类型是一致的
# 显示的指定数组数据类型
a = np.array([1, 2, 3], dtype=np.float32)
# 使用 astype来修改数据的元素类型
a.astype("int32")
改变数组的形状
# 使用reshape来改变数组的形状
np.arange(12).reshape((-1, 4))
# 小技巧
在reshape改变形状时，我们可以将其中的一个维度指定为-1。
-1表示根据数组元素个数与其他维度的长度，自动进行计算。
如果在改变形状时指定-1，则最多只能将一个维度指定为-1。
索引与切片
# 简单的使用索引和切片
a[2]
a[1][2]
a[3:5]
# 使用索引和切片的特殊语法
a[高维, 低维, ……]
a[1, 2]
a[1, 1:4]
小知识点：
ndarray切片返回的是原数组对象的视图，而并非是拷贝。
视图对象与原ndarray数组对象并非同一个对象，但是会共享底层的数据。
如不愿一个数组的改变对其他数组造成影响，使用ndarray数组对象的copy方法，进行拷贝。
copy方法返回原数组的复制，而不是视图。
a.copy()
# 通过整数数组进行索引
# 定义一个数组，用来存储要提取元素的索引。
index = [0, 1, 4, 8]
# 使用该索引数组提取某数组对应位置的元素。
a[index]
小知识点：
当使用索引提取元素时，返回的是原数组的拷贝，而不是视图
# 如果要提取元素的数组是多维的，我们可以提供多个一维的索引数组，
# 每个一维的索引数组分别指定每个维度的索引。
# [[最高的索引], [次高维的索引],…… [最低维的索引]]
a = np.arange(30).reshape((5, 6))
a[[1, 3], [2, 4]]
# 通过布尔数组进行索引
a = np.array([1, 2, 3, 4])
b = [True, False, True, False]
a[b]
a[a > 2.5]
数组的扁平化（x代表多维数组对象）
# 我们可以使用ravel或者flatten来实现对于数组的扁平化处理(其实就是将多维的数组拉伸为一维的)
x.ravel()
x.flatten()
# 小知识点
# ravel与flatten都能够对数组进行扁平化操作。二者的区别在于：
# ravel返回的是原数组的视图，与原数组共享底层的数据。
# flatten返回的是原数组的拷贝，与原数组数据互不影响。
数组的存储顺序
# 我们在创建数组的时候，可以通过order来指定 数组元素的存储顺序
# order影响两个位置——扁平化与填充。
# C 以C程序为代表的行优先存储。
# F 以Fortran程序为代表的列优先存储。
np.array([[1, 2], [3, 4]], order="C")
通用函数(x为数组对象)
numpy提供了很多通用函数，这些函数实际上可以认为是 python中通用函数的矢量化版本
#计算整数、浮点数或复数的绝对值 abs / fabs
np.abs(x)
# 计算各元素的ceiling值，即大于等于该值的最小整数
np.ceil(x)
计算各元素的floor值，即小于等于该值的最大整数
np.floor(x)
# 计算各元素的指数
np.exp(x)
# log / log2 / log10,分别为自然对数(底数为e)、底数为2的log，底数为10的log
np.log(x)
# modf,将数组的小数和整数部分以两个独立的数组形式返回
np.modf(x)
# sin / sinh / cos
theta=np.linspace(0,np.pi,3) #180°均分成3份
np.sin # 正弦函数
np.cos(theta) #余弦函数
np.tan(theta) #正切函数
# sqrt,计算各元素平方根
np.sqrt(x)
统计函数
# 求均值
np.mean(x)
# 求和
np.sum(x)
# 求最小值，最大值
np.max(x), np.min(x)
# 求中位数。
np.median(x)
# 求最大值/最小值在数组中的位置（索引）
np.argmax(x), np.argmin(x)
# 求标准差 / 方差
np.std(x), np.var(x)
# 求累计和，累计乘积
np.cumsum(x), np.cumprod(x)
# 小技巧（二维数组统计）
# 当我们使用 统计函数对于 二维数组进行统计的时候，我们可以直接进行整个数组的统计
# 但是，我们也可以通过参数 axis来实现对于某一行或者一列进行统计
# axis =0 ，竖直方向
# axis = 1，水平方向
x = sum（axis = 0）
# 小技巧（多维数组统计）
# 轴（axis），代表着数组的维度，从0开始，第n个维度，轴就是n-1
# 统计三维或者是更高维数组的时候，我们同样可以使用axis来指定
# 统计方式，比如说三维数组，我们统计轴为1的：
# 三维数组用索引表示： [0][0][0]
# 那我们就让0轴和2轴不变，让1轴的下标发生改变，将得到的元素进行改变
随机函数
# 产生随机数（伪随机数），参数指定每个维度的大小。如果没有指定参数，则
# 返回一个标量值。随机数值的范围为[0, 1)。
# 产生一个二行三列的数组，每个元素在 0到1（不包括）之间随机生成
np.random.rand(2, 3)
# 实际上与 np.random.rand是一个意思，但是，这个函数指定行列的时候，
# 需要通过参数size传入一个值，元组的方式
np.random.random(size=(2, 3))
# 产生标准正态分布随机值（均值为0，标准差为1。）
np.random.randn(5, 5)
# 产生正态分布的随机值。可以指定均值与标准差。默认为标准正态分布。
np.random.normal(loc=2, scale=3.5, size=(5, 5))
# 产生参数范围内的随机整数。包含起始点，不包含终止点。
np.random.randint(1, 10, size=(5, 5))
# 设置随机种子，同一个随机种子得到的随机数是一样的
np.random.seed(5)
# 随机打乱数组元素的顺序。（洗牌操作）
x = np.arange(10)
np.random.shuffle(x)
# 在参数指定的区间，指定浮点类型的值
# 包括起始点，不包括终止点
np.random.uniform(-0.8,2,size=(3,3))
连接与拆分
# 使用concatenate 对于数组进行连接，就是将俩个数组合并在一起，axis指定连接的房向
# axis = 0 ，竖直房向连接
# axis = 1， 水平房向连接
# x,y 指俩个数组对象
np.concatenate((x, y), axis=0)
# 使用split 对于数组进行拆分，axis指定拆分的房向
# np.split(待拆分数组，拆分段数，拆分房向)
np.split(x, 3, axis=0)
# 我们在拆封的时候，可以将拆分的段数设置为一个数组，数组类型指定切分点
# 假如数组为 [a,b,c]，那么就会按照 [:a],[a:b],[b:c],[c:] 来拆分
np.split(x, [1, 3], axis=1)
其他常用的函数
# any,判断数组中有没有Ture的值，或者可以转化为True的值，要是有，就返回True
np.any([1,2,3])
# all,判断数组元素是不是全部都是True，或者可以转化为True的值，如果是，就返回True
np.all([1,2,3])
# transpose/T ，实现轴的颠倒，就是数组的转置(x为数组的对象)
x.Tx
#transpose可以实现通过参数，指定轴的具体替换规则
# 将原本的 0，1，2轴替换为 1，0，2轴
x.transpose(1, 0, 2)
# 交换参数指定的两个轴。参数的顺序不重要。
x.swapaxes(0, 1)
# dot运算(机器学习算法常用)
-----------------------------------------------------------------------------
# 数组与标量进行运算。此时会使用数组中的每个元素与标量进行相乘。
# 其实就相当于是*运算。
x = np.array([1, 2, 3])
y = 3
np.dot(x, y)
-----------------------------------------------------------------------------
# 一维对一维。此时会进行对位元素的相乘，然后相加。
x = np.array([1, 2, 3])
y = np.array([3, 2, 1])
np.dot(x, y)
-----------------------------------------------------------------------------
# 二维对二维。此时会进行数学上矩阵的点积运算。
x = np.array([[1, 2], [3, 4], [5, 6]])
y = np.array([[2, 1, 0], [4, 3, 5]])
np.dot(x, y)
# 实现矩阵点积运算时，可以使用@运算符。
x @ y
-----------------------------------------------------------------------------
# 多维对一维，左侧数组是多维数组，右侧数组是一维数组，
此时会使用左侧数组的最低维，与右侧数组进行对位相乘再相加的运算。
（保证：左侧数组的最低维长度与右侧数组的长度相同）
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([0, 1, 2])
np.dot(x, y)
-----------------------------------------------------------------------------
# 多维对多维，左侧数组是多维数组，右侧数组也是多维数组（都非二维数组）
此时，会使用左侧数组的最低维与右侧数组的倒数第二维进行对位相乘再相加的运算。
(保证：左侧数组的最低维与右侧数组的倒数第二维长度必须一致。)
x = np.arange(12).reshape((2, 3, 2))
y = np.array([[1, 2], [0, 1]])
np.dot(x, y)
# np.sort，对数组对象进行排序(x为数组对象)
x.sort()
# argsort,对数组进行排序，并且返回排序之后的元素在原数组中的索引(x为数组对象)
x.argsort()
# unique,返回去掉数组中的重复元素，并且对于数组元素进行排序
x = np.array([3,-1,4,6])
np.unique(x)
# np.where, 认为是数组中的if-else
# 如果条件为True，返回第一个元素，否则，返回第二个
# np.where(条件，第一个元素，第二个元素)
np.where(x>y,x,y)