文章目录
numpy学习笔记
NumPy（Numerical Python的简称）是Python科学计算的基础包。它提供以下功能：
1.快速高效的多维数组对象ndarray。
2.用于对数组执行元素级计算以及直接对数组执行数学运算的函数。
3.用于读写硬盘上基于数组的数据集的工具。
4.线性代数运算、傅里叶变换以及随机数生成。
基本属性：
- ndarray.shape():数组维度的元组
- ndarray.ndim():数组维度
- ndarray.size():数组中的元素数量
- ndarray.itemsize():一个数组元素的长度(字节)
- ndarray.dtype():数组元素的类型
生成数组的方法
生成0和1的数组
- np.ones(shape, dtype)
- np.ones_like(a, dtype)
- np.zeros(shape, dtype)
- np.zeros_like(a, dtype)
import numpy as np
import matplotlib.pyplot as plt
#np.ones(shape, dtype)
ones = np.ones([4,8])
ones
array([[1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1.]])
#np.zeros_like(a, dtype)
np.zeros_like(ones)
array([[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0.]])
从现有数组生成
- np.array(object, dtype)：从现有的数组当中创建
- np.asarray(a, dtype)：相当于索引的形式，并没有真正的创建一个新的
a = np.array([[1,2,3],[4,5,6]])
a1 = np.array(a)
a2 = np.asarray(a)
a[0,0]=123
a,a1,a2
(array([[123, 2, 3],
[ 4, 5, 6]]),
array([[1, 2, 3],
[4, 5, 6]]),
array([[123, 2, 3],
[ 4, 5, 6]]))
生成固定范围的数组
（1）np.linspace (start, stop, num, endpoint)
创建等差数组–指定数量
- start:序列的起始值
- stop:序列的终止值
- num:要生成的等间隔样例数量，默认为50
- endpoint:序列中是否包含stop值，默认为ture
#生成等间隔的数组
np.linspace(0, 100, 11)
array([ 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100.])
（2）np.arange(start,stop, step, dtype)
创建等差数组 — 指定步长
- step:步长,默认值为1
np.arange(10, 50, 2)
array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42,
44, 46, 48])
（3）np.logspace(start,stop, num)
创建等比数列
- num:要生成的等比数列数量，默认为50
# 生成10^x
np.logspace(0, 2, 3)
array([ 1., 10., 100.])
生成随机数组
使用np.random模块
(1)正态分布
-
np.random.randn(d0, d1, …, dn)：从标准正态分布中返回一个或多个样本值
-
np.random.normal(loc=0.0, scale=1.0, size=None)：
loc(float):此概率分布的均值（对应着整个分布的中心centre）
scale(float):此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）
size(int or tuple of ints):输出的shape，默认为None，只输出一个值 -
np.random.standard_normal(size=None):返回指定形状的标准正态分布的数组
#生成均值为1.75，标准差为1的正态分布数据，100000000个
# 生成均匀分布的随机数
x1 = np.random.normal(1.75, 1, 100000000)
# 画图看分布状况
# 1）创建画布
plt.figure(figsize=(20, 10), dpi=100)
# 2）绘制直方图
plt.hist(x1, 1000)
# 3）显示图像
plt.show()
（2）均匀分布
-
np.random.rand(d0, d1, …, dn)：返回[0.0，1.0)内的一组均匀分布的数。
-
np.random.uniform(low=0.0, high=1.0, size=None)：
- 功能：从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high。
- 参数介绍：
- low: 采样下界，float类型，默认值为0；
- high: 采样上界，float类型，默认值为1；
- size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出mnk个样本，缺省时输出1个值。
-
np.random.randint(low, high=None, size=None, dtype=‘l’)
- 从一个均匀分布中随机采样，生成一个整数或N维整数数组
- 取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。
# 生成均匀分布的随机数
x2 = np.random.uniform(-1, 1, 100000000)
# 画图看分布状况
# 1）创建画布
plt.figure(figsize=(10, 10), dpi=100)
# 2）绘制直方图
plt.hist(x=x2, bins=1000) # x代表要使用的数据，bins表示要划分区间数
# 3）显示图像
plt.show()
数组的去重
temp = np.array([[1, 2, 3, 4],[3, 4, 5, 6]])
np.unique(temp)
array([1, 2, 3, 4, 5, 6])
numpy矩阵和数组的区别
NumPy函数库中存在两种不同的数据类型（矩阵matrix和数组array），虽然它们很相似，但是执行相同的数学运算可能得到不同的结果。
#数组
np.random.rand(4,4)
array([[0.24728401, 0.30566626, 0.16665376, 0.31613607],
[0.69854146, 0.12248579, 0.80735438, 0.67191122],
[0.13186778, 0.87192134, 0.98263474, 0.81537693],
[0.65394809, 0.59672818, 0.46515222, 0.45614608]])
#矩阵
randMat=np.mat(np.random.rand(4,4)) #调用mat()函数可以将数组转化为矩阵
#.I操作符实现了矩阵求逆的运算
randMat.I
matrix([[-5.16731153, 3.03857101, 4.16555117, -3.13430872],
[ 2.23881498, -0.0392185 , -3.72695319, 2.64160129],
[-0.33096494, 0.74905744, 3.18708281, -3.1295268 ],
[ 3.22086795, -2.6253826 , -2.56275251, 3.33772304]])
#矩阵的乘法
invRandMat=randMat.I
randMat*invRandMat
#结果应该是单位矩阵，除了对角线是1，其余元素都是0，实际结果略有不同，留下了许多非常小的元素，这是计算机处理的误差结果
matrix([[ 1.0000000e+00, 0.0000000e+00, 0.0000000e+00, 4.4408921e-16],
[-8.8817842e-16, 1.0000000e+00, 0.0000000e+00, 4.4408921e-16],
[-8.8817842e-16, 0.0000000e+00, 1.0000000e+00, 0.0000000e+00],
[-4.4408921e-16, 0.0000000e+00, 4.4408921e-16, 1.0000000e+00]])
#单位矩阵
np.eye(4)
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
创建数组
NumPy最重要的一个特点就是其N维数组对象（即ndarray），该对象是一个快速而灵活的大数据集容器。
ndarray是一个通用的同构数据多维容器，也就是说，其中的所有元素必须是相同类型的。
常用函数:
(1)shape（一个表示各维度大小的元组,如果是2维的话，shape[0]表示行，shape[1]表示列）==>(1,2)表示1行2列;
(2)dtype（一个用于说明数组数据类型的对象）;
(3)size(展示的是数组a的规模，就是a的元素个数为多少);
(4)ndim(就是数组a有几个维度，比如3就代表数组a有三个维度);
(5)arange(是Python内置函数range的数组版,类似内置的range，但返回的是一个ndarray而不是列表);
使用np.array()直接创建
np.array([1,2,3])
array([1, 2, 3])
使用 np.ones()、np.zeros() 等方法
np.ones(3)
array([1., 1., 1.])
np.zeros(3)
array([0., 0., 0.])
np.random.randn(2,3)
array([[-0.23099872, -1.48754848, -0.99513359],
[-0.83090896, 0.46513491, -0.55575052]])
数组运算
加减运算
data=np.array([1,2])
ones=np.ones(2)
print(data+ones)
print(data-ones)
[2. 3.]
[0. 1.]
数组乘以数值
data*2
array([2, 4])
数组索引
#只取一个
data[0]
1
#取子串
data[0:2]
array([1, 2])
数组聚合
print(data.max())
print(data.min())
print(data.sum())
2
1
3
矩阵
创建矩阵
#直接创建
print(np.array([[1,2],[3,4]]))
#使用 np.ones()、np.zeros() 等方法
print(np.ones((3,2)))
print(np.zeros((3,2)))
print(np.random.random((3,2)))
[[1 2]
[3 4]]
[[1. 1.]
[1. 1.]
[1. 1.]]
[[0. 0.]
[0. 0.]
[0. 0.]]
[[0.33517696 0.29693719]
[0.73687262 0.22140264]
[0.5634523 0.66138066]]
矩阵运算
data=np.array([[1,2],[3,4]])
ones=np.ones((2,2))
print(data+ones)
ones_row=np.ones(2)
print(data+ones_row)
[[2. 3.]
[4. 5.]]
[[2. 3.]
[4. 5.]]
矩阵点积
np.matmul和np.dot的区别:
二者都是矩阵乘法。 np.matmul中禁止矩阵与标量的乘法。 在矢量乘矢量的內积运算中，np.matmul与np.dot没有区别。
data.dot(ones)
array([[3., 3.],
[7., 7.]])
np.dot(data,ones)
array([[3., 3.],
[7., 7.]])
矩阵索引
data
array([[1, 2],
[3, 4]])
print(data[0,1])
#取行
print(data[0,0:])
2
[1 2]
#取列
data[0:,0]
array([1, 3])
矩阵聚合
#求最值
print(data.max())
print(data.min())
print(data.sum())
4
1
10
#按行聚合
data.max(axis=0)
array([3, 4])
#按列聚合
data.max(axis=1)
array([2, 4])
矩阵转置
data.T
array([[1, 3],
[2, 4]])
矩阵重塑
data=np.array([1,2,3,4,5,6])
data.reshape(2,3)
array([[1, 2, 3],
[4, 5, 6]])
通用函数
通用函数（即ufunc）是一种对ndarray中的数据执行元素级运算的函数。
一元ufunc函数说明
abs、fabs：计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs；
sqrt：计算各元素的平方根。相当于arr** 0.5；
square：计算各元素的平方。相当于arr** 2；
exp：计算各元素的指数ex；
log、log10、 log2、 log1p：分别为自然对数(底数为e)、底数为10的log、底数为2的log、log(1 + x)；
sign：计算各元素的正负号: 1 (正数)、0 (零)、-1 (负数)；
ceil：计算各元素的ceiling值，即大于等于该值的最小整数；
floor：计算各元素的floor值，即小于等于该值的最大整数；
rint：将各元素值四舍五入到最接近的整数，保留dtype；
modf：将数组的小数和整数部分以两个独立数组的形式返回；
isnan：返回一个表示“哪些值是NaN (这不是一个数字)”的布尔型数组；
isfinite、isinf：分别返回一个表示“哪些元素是有穷的(非inf，非NaN)”或“哪些元素是无穷的”的布尔型数组；
cos、cosh、 sin、 sinh、tan、tanh：普通型和双曲型三角函数；
arccos、arccosh、 arcsin、arcsinh、arctan、 arctanh：反三角函数；
logical_ not：计算各元素notx的真值。相当于-arr；
二 元ufunc函数说明
add：将数组中对应的元素相加；
subtract：从第一个数组中减去第二个数组中的元素；
multiply：数组元素相乘；
divide. floor_ _divide：除法或向下圆整除法(丢弃余数)；
power：对第一个数组中的元素A，根据第二个数组中的相应元素B，计算A；
maximum、fmax：元素级的最大值计算。fmax 将忽略NaN；
minimum、fmin：元素级的最小值计算。fmin将忽略NaN；
mod：元素级的求模计算(除法的余数)；
copysign：将第二个数组中的值的符号复制给第一个数组中的值；
greater、greater_ equal、less、less_ equal、equal、not_ equal：执行元素级的比较运算，最终产生布尔型数组。相当于中缀运算符>、>=、<. <=. ==、!=
logical_ and、 logical _or、logical xor：执行元素级的真值逻辑运算。相当于中缀运算符&、| ^
线性代数
常用函数：
(1)diag:以一维数组的形式返回方阵的对角线(或非对角线)元素，或将一维数组转换为方阵(非对角线元素为0)；
(2)dot:矩阵点乘；
(3)trace：计算对角线元素的和；
(4)det：计算矩阵行列式；
(5)eig:计算方阵的特征值和特征向量；
(6)inv:计算方阵的逆；
(7)pinv:计算矩阵的Moore-Penrose伪逆；
(8)qr:计算QR分解；
(9)svd:计算奇异值分解(SVD)；
(10)solve:解线性方程组Ax=b，其中A为一个方阵；
(11)lstsq:计算Ax=b的最小二乘解；
数学和统计方法
可以通过数组上的一组数学函数对整个数组或某个轴向的数据进行统计计算。
(1)sum:对数组中全部或某轴向的元素求和。零长度的数组的sum为0；【arr.sum(1)是计算每行的和；arr.sum(0)是计算每列的和】
(2)mean：算术平均值，零长度的数组的mean为NaN；
(3)std、var:分别为标准差和方差，自由度可调(默认为n)；
(4)min、max:最小值和最大值；
(5)argmin、argmax:分别为最小值和最大值的索引；
(6)cumsum:所有元素的累计和；
(7)cumprod:所有元素的累计积；
案例：学生成绩统计运算
# 生成10名同学，5门功课的数据
score = np.random.randint(40, 100, (10, 5))
# 接下来对于前四名学生,进行一些统计运算
# 指定列 去统计
temp = score[:4, 0:5]
print("前四名学生,各科成绩的最大分：{}".format(np.max(temp, axis=0)))
print("前四名学生,各科成绩的最小分：{}".format(np.min(temp, axis=0)))
print("前四名学生,各科成绩波动情况：{}".format(np.std(temp, axis=0)))
print("前四名学生,各科成绩的平均分：{}".format(np.mean(temp, axis=0)))
print("前四名学生，各科成绩最高分对应的学生下标：{}".format(np.argmax(temp, axis=0)))
前四名学生,各科成绩的最大分：[76 94 90 76 97]
前四名学生,各科成绩的最小分：[42 55 46 40 52]
前四名学生,各科成绩波动情况：[13.73863166 14.23683602 17.97741639 13.19090596 17.33493582]
前四名学生,各科成绩的平均分：[55.5 77.75 69.75 56. 73. ]
前四名学生，各科成绩最高分对应的学生下标：[2 2 1 0 1]
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
