Numpy入门
- 前言
- 一、numpy简介
- 二、Numpy的ndarray属性
- 2.1. 直接用 .属性的方法实现
- 2.2. 直接函数的方法实现
- 三、Numpy的ndarray的创建
- 3.1. ndarray介绍
- 3.2. 数组形式
- 3.3. zeros()、ones() 、 empty()
- 3.4. arange()，类似 python 的 range() ，创建一个一维 ndarray 数组。
- 3.5. matrix()，是 ndarray 的子类，只能生成 2 维的矩阵
- 3.6. 创建随机数矩阵
- 3.7. 等比数列
- 3.8. 等差数列
- 四、Numpy的内置函数
- 4.1. 基本函数
- 4.2. 统计函数
- 4.3. 比较函数
- 4.4. 去重函数
- 4.5. 排序函数
- 五、Numpy运算
- 5.1. 加减、点乘、除法
- 5.2. 矩阵相乘(外积)
- 总结
前言
numpy_13">一、numpy简介
- NumPy（Numerical Python）是Python数据分析必不可少的第三方库。
- NumPy重在数值计算，主要用于多维数组（矩阵）处理的库。用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多。
- 主要功能：
- 高性能科学计算和数据分析的基础包
- ndarray，多维数组，具有矢量运算能力，快速、节省空间
- 矩阵运算，无需循环，可完成类似Matlab中的矢量运算
- 用于读写磁盘数据的工具以及用于操作内存映射文件的工具
二、Numpy的ndarray属性
2.1. 直接用 .属性的方法实现
shape（示例）：
python"># 导包
import numpy as np
# 创建numpy的数组.
# arange(15) 等价于python的 range(15), 即: 获取 0 ~ 14的整数
# reshape(3, 5) 把上述数据封装到 3个一维数组中, 每个一维数组的长度为: 5, 然后把三个一维数组封装成1个 二维数组.
arr = np.arange(15).reshape(3, 5)
print(f'数组的维度: {arr.shape}') # (3, 5)
ndim（示例）：
python">print(f'数组轴的个数: {arr.ndim}') # 几维数组, 轴就是几, 2
dtype（示例）：
python">print(f'数组元素类型: {arr.dtype}') # int64
itemsize（示例）：
python">print(f'数组每个元素的占用字节数: {arr.itemsize}') # 8
size（示例）：
python">print(f'数组元素个数: {arr.size}') # 15
type（示例）：
python">print(f'数组类型: {type(arr)}') # <class 'numpy.ndarray'>
2.2. 直接函数的方法实现
代码如下（示例）：
python"># 上述的 shape, ndim, size属性 可以 函数写法 实现.
# 格式: np.函数名(数组)
print(f'数组的维度: {np.shape(arr)}') # (3, 5) 3个元素(一维数组), 每个元素(一维数组)又有5个元素(值)
print(f'数组轴的个数: {np.ndim(arr)}') # 几维数组, 轴就是几, 2
print(f'数组元素个数: {np.size(arr)}') # 15
print(f'数组类型: {type(arr)}') # <class 'numpy.ndarray'>
三、Numpy的ndarray的创建
3.1. ndarray介绍
- NumPy数组是一个多维的数组对象（矩阵），称为 ndarray(N-Dimensional Array)
- 具有矢量算术运算能力和复杂的广播能力，并具有执行速度快和节省空间的特点
- 注意：ndarray的下标从0开始，且数组里的所有元素必须是相同类型。
3.2. 数组形式
代码如下（示例）：
python">import numpy as np
a = np.array([2, 3, 4])
print('数组a元素类型: ', a) # [2, 3, 4]
print('数组a类型:', a.dtype) # int64
b = np.array([1.2, 3.5, 5.1])
print('数组b类型:', b.dtype) # float64
3.3. zeros()、ones() 、 empty()
函数zeros创建一个全是0的数组，
函数ones创建一个全1的数组，
函数empty创建一个内容随机并且依赖于内存状态的数组。默认创建的数组类型(dtype)都是float64
python">zero1 = np.zeros((3, 4)) # 3个一维数组, 每个长度为: 4
print('数组zero1: ', zero1) # 数组zero1: [[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]
ones1 = np.ones((2, 3, 4)) # 2个二维数组, 每个二维数组有3个一维数组, 每个一维数组有4个元素1, 整体放入1个数组中
print('数组one1: ', ones1) # 数组one1: [[[1. 1. 1. 1.]
# [1. 1. 1. 1.]
# [1. 1. 1. 1.]]
# [[1. 1. 1. 1.]
# [1. 1. 1. 1.]
# [1. 1. 1. 1.]]]
empty1 = np.empty((2, 3))
print('数组empty1: ', empty1) # 数组empty1: [[6.23042070e-307 5.11798224e-307 1.37961370e-306]
# [4.22795269e-307 9.34609790e-307 1.06101441e-312]]
print(zero1.dtype, ones1.dtype, empty1.dtype) # float64 float64 float64
python__range__ndarray__129">3.4. arange()，类似 python 的 range() ，创建一个一维 ndarray 数组。
代码如下（示例）：
python">np_arange = np.arange(10, 20, 5,dtype=int) # 起始, 结束, 步长, 类型
print("arange创建np_arange:", np_arange) # arange创建np_arange: [10 15]
print("arange创建np_arange的元素类型:", np_arange.dtype) # arange创建np_arange的元素类型: int32
print("arange创建np_arange的类型:", type(np_arange)) # arange创建np_arange的类型: <class 'numpy.ndarray'>
3.5. matrix()，是 ndarray 的子类，只能生成 2 维的矩阵
代码如下（示例）：
python">x1 = np.mat("1 2;3 4")
print(x1) # [[1 2]
# [3 4]]
x2 = np.matrix("1,2;3,4")
print(x2) # [[1 2]
# [3 4]]
x3 = np.matrix([[1, 2, 3, 4], [5, 6, 7, 8]])
print(x3) # [[1 2 3 4]
# [5 6 7 8]]
3.6. 创建随机数矩阵
代码如下（示例）：
python">import numpy as np
# 生成指定维度大小(3行4列)的随机多维浮点型数据(二维), rand固定区间0.0 ~ 1.0
arr = np.random.rand(3, 4)
print(arr) # [[0.09119117 0.6460204 0.50383065 0.67335935]
# [0.19701768 0.15571364 0.59120424 0.77497329]
# [0.22062685 0.2902945 0.38695936 0.81338176]]
print(type(arr)) # <class 'numpy.ndarray'>
# 生成指定维度大小(3行4列)的随机多维整型数据(二维), randint()可指定区间(-1, 5)
arr = np.random.randint(-1, 5, size=(3, 4))
print(arr) # [[ 1 3 4 1]
# [ 0 -1 4 0]
# [ 3 4 0 2]]
print(type(arr)) # <class 'numpy.ndarray'>
#生成指定维度大小(3行4列)的随机多维浮点型数据(二维), uniform()可以指定区间(-1, 5)产生-1到5之间均匀分布的样本值
arr = np.random.uniform(-1, 5, size=(3, 4))
print(arr) # [[ 1.13673297 1.48527364 3.24196413 0.86342194]
# [ 1.49173484 4.82213745 3.62326883 -0.20275583]
# [ 3.6385359 -0.47568918 0.35379637 3.20684058]]
print(type(arr)) # <class 'numpy.ndarray'>
3.7. 等比数列
代码如下（示例）：
python"># np.logspace 等比数列, logspace中，开始点和结束点是10的幂
# 我们让开始点为0，结束点为0，元素个数为10，看看输出结果。
a = np.logspace(0,0,10)
# 输出结果
print(a) # [1,1,1,1,1,1,1,1,1,1]
# 假如，我们想要改变基数，不让它以10为底数，我们可以改变base参数，将其设置为2
a = np.logspace(0,9,10, base=2)
# 输出结果
print(a) # [1.,2.,4.,8.,16.,32.,~~~~~~,512.]
3.8. 等差数列
代码如下（示例）：
python"># np.linspace等差数列
# np.linspace是用于创建一个一维数组，并且是等差数列构成的一维数组，它最常用的有三个参数。
# 第一个例子，用到三个参数，第一个参数表示起始点，第二个参数表示终止点，第三个参数表示数列的个数。
a = np.linspace(1,10,10)
print(a) # [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
# 可以使用参数endpoiint来决定是否包含终止值，默认值是True
a = np.linspace(1,10,10,endpoint=False)
print(a) # [1. 1.9 2.8 3.7 4.6 5.5 6.4 7.3 8.2 9.1]
四、Numpy的内置函数
4.1. 基本函数
1、np.ceil(): 向上最接近的整数，参数是 number 或 array
2、np.floor(): 向下最接近的整数，参数是 number 或 array
3、np.rint(): 四舍五入，参数是 number 或 array
4、np.isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
5、np.multiply(): 元素相乘，参数是 number 或 array
6、np.divide(): 元素相除，参数是 number 或 array
7、np.abs()：元素的绝对值，参数是 number 或 array
8、np.where(condition, x, y): 三元运算符，x if condition else y
python"># 注意: 需要注意multiply/divide 如果是两个ndarray进行运算 shape必须一致
arr = np.random.randn(2, 3)
print(arr) # [[0.22519249 -0.6241801 0.18576015]
# [1.79683596 0.36047647 -0.56127028]]
print(np.ceil(arr)) # [[ 1. -0. 1.]
# [ 2. 1. -0.]]
print(np.floor(arr)) # [[ 0. -1. 0.]
# [ 1. 0. -1.]]
print(np.rint(arr)) # [[ 0. -1. 0.]
# [ 2. 0. -1.]]
print(np.isnan(arr)) # [[False False False]
# [False False False]]
print(np.multiply(arr, arr)) # [[0.05071166 0.38960079 0.03450683]
# [3.22861945 0.12994329 0.31502433]]
print(np.divide(arr, arr)) # [[1. 1. 1.]
# [1. 1. 1.]]
print(np.where(arr > 0, 1, -1)) # [[ 1 -1 1]
# [ 1 1 -1]]
4.2. 统计函数
1、np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array
2、np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array
3、np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
4、np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
5、np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array
python"> # 多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。
arr = np.arange(12).reshape(3, 4)
print(arr) # [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 返回一个一维数组, 每个元素都是之前所有元素的 累加和
print(np.cumsum(arr)) # [ 0 1 3 6 10 15 21 28 36 45 55 66]
# 所有元素的和
print(np.sum(arr)) # 66
# 数组的按列统计和
print(np.sum(arr, axis = 0)) # [12 15 18 21]
#数组的按行统计和
print(np.sum(arr, axis = 1)) # [ 6 22 38]
4.3. 比较函数
- 假如我们想要知道矩阵a和矩阵b中所有对应元素是否相等，我们需要使用all方法
- 假如我们想要知道矩阵a和矩阵b中对应元素是否有一个相等，我们需要使用any方法
代码如下（示例）：
python"># np.any(): 至少有一个元素满足指定条件，返回True
# np.all(): 所有的元素满足指定条件，返回True
arr = np.random.randn(2, 3)
print(arr) # [[0.62062377 0.40942285 0.2950361 ]
# [0.21878013 0.92271838 1.67930325]]
print(np.any(arr > 0)) # True
print(np.all(arr > 0)) # True
4.4. 去重函数
np.unique():找到唯一值并返回排序结果，类似于Python的set集合
python">arr = np.array([[1, 2, 1], [2, 3, 4]])
print(arr) # [[1 2 1]
# [2 3 4]]
print(np.unique(arr)) # [1 2 3 4]
4.5. 排序函数
代码如下（示例）：
python">arr = np.array([1, 2, 34, 5])
print("原数组arr:", arr) # 原数组arr: [ 1 2 34 5]
# np.sort()函数排序, 返回排序后的副本
sortarr1 = np.sort(arr)
print("numpy.sort()函数排序后的数组:", sortarr1) # numpy.sort()函数排序后的数组: [ 1 2 5 34]
# ndarray直接调用sort, 在原数据上进行修改
arr.sort()
print("数组.sort()方法排序:", arr) # 数组.sort()方法排序: [ 1 2 5 34]
五、Numpy运算
5.1. 加减、点乘、除法
- 都是对应元素进行加减乘除，所以要求两个数组的行列都要一样
代码如下（示例）：
python">import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[1, 2, 3], [4, 5, 6]])
c = a - b
d = a + b
e = a * b
f = a / b
print("数组a:", a) # 数组a: [[1 2 3]
# [4 5 6]]
print("数组b:", b) # 数组b: [[1 2 3]
# [4 5 6]]
print("数组运算a-b:", c) # 数组运算a-b: [[0 0 0]
# [0 0 0]]
print("数组运算a+b:", d) # 数组运算a+b: [[ 2 4 6]
# [ 8 10 12]]
print("数组运算a*b:", e) # 数组运算a*b: [[ 1 4 9]
# [16 25 36]]
print(np.multiply(a, b)) # 效果同上
print("数组运算a/b:", f) # 数组运算a/b: [[1. 1. 1.]
# [1. 1. 1.]]
5.2. 矩阵相乘(外积)
arr_a.dot(arr_b) 前提` arr_a 列数 = arr_b行数
python">import numpy as np
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([[6, 23], [-1, 7], [8, 9]])
print(x) # [[1 2 3]
# [4 5 6]]
print(y) # [[ 6 23]
# [-1 7]
# [ 8 9]]
# 就是拿 x的行乘以y 的列 乘积相加 1*6 + 2*(-1) + 3*8 = 28
# 1*23 + 2*7 + 3*9 = 64
# 4*6 + 5*(-1) + 6*8 = 67
# 4*23 + 5*7 + 6*9 = 181
print(x.dot(y)) # [[ 28 64]
# [ 67 181]]
print(np.dot(x, y)) # [[ 28 64]
# [ 67 181]]
总结
- 以上就是numpy中的属性跟函数。
