NumPy
Numpy(Numerical Python) 是科学计算基础库，提供大量科学计算相关功能，比如数据统计，随机数生成等。其提供最核心类型为多维数组类型（ndarray），支持大量的维度数组与矩阵运算，Numpy支持向量处理ndarray对象，提高程序运算速度。
本期我们接着介绍numpy中的方法：
数学函数
Numpy支持向量处理ndarray对象，提高程序运算速度。
求每个元素的倒数
import numpy as np
#求每个元素的倒数
#numpy.reciprocal() 函数返回参数逐元素的倒数。
a=np.arange(1,10,dtype=float).reshape(3,3)
np.reciprocal(a)
---------------------------
array([[1. , 0.5 , 0.33333333],
[0.25 , 0.2 , 0.16666667],
[0.14285714, 0.125 , 0.11111111]])
square()函数
#square函数的使用------------->每个元素平方
#一维数组
a = np.arange(1,10)
np.square(a)
-------------
array([ 1, 4, 9, 16, 25, 36, 49, 64, 81], dtype=int32)
===============================================================
#二维数组
aa=np.arange(1,13).reshape(3,4)
np.square(aa)
---------------
array([[ 1, 4, 9, 16],
[ 25, 36, 49, 64],
[ 81, 100, 121, 144]], dtype=int32)
sign()函数
#sign()函数的使用--------->表示各元素的符号
a = np.arange(-5,5)
np.sign(a)
--------------
array([-1, -1, -1, -1, -1, 0, 1, 1, 1, 1])
modf()函数
#modf()函数的使用---------->将各元素的小数部分和整数部分分别打印出来
b = np.arange(-5,5,0.4)
np.modf(b)
----------------------
(array([-0.00000000e+00, -6.00000000e-01, -2.00000000e-01, -8.00000000e-01,
-4.00000000e-01, -1.00000000e+00, -6.00000000e-01, -2.00000000e-01,
-8.00000000e-01, -4.00000000e-01, -1.00000000e+00, -6.00000000e-01,
-2.00000000e-01, 2.00000000e-01, 6.00000000e-01, 5.32907052e-15,
4.00000000e-01, 8.00000000e-01, 2.00000000e-01, 6.00000000e-01,
7.10542736e-15, 4.00000000e-01, 8.00000000e-01, 2.00000000e-01,
6.00000000e-01]),
array([-5., -4., -4., -3., -3., -2., -2., -2., -1., -1., -0., -0., -0.,
0., 0., 1., 1., 1., 2., 2., 3., 3., 3., 4., 4.]))
三角函数
#三角函数的使用------------>计算三角函数值
x=np.linspace(1,10,10)
y = np.sin(x)
y
----------------------
array([ 0.84147098, 0.90929743, 0.14112001, -0.7568025 , -0.95892427,
-0.2794155 , 0.6569866 , 0.98935825, 0.41211849, -0.54402111])
around、floor、ceil函数
decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
numpy.floor() 返回数字的下舍整数。
numpy.ceil() 返回数字的上入整数。
#around、floor、ceil函数的使用
a = np.array([1.0,4.55,123,0.567,25.532])
#numpy.around() 函数返回指定数字的四舍五入值。
#格式：numpy.around(a,decimals）
np.around(a)
----------------
array([ 1., 5., 123., 1., 26.])
================================================
#numpy.floor() 返回数字的下舍整数。
np.floor(a)
--------------
array([ 1., 4., 123., 0., 25.])
===================================================
#numpy.ceil() 返回数字的上入整数。
np.ceil(a)
--------------
array([ 1., 5., 123., 1., 26.])
算术函数
如果参与运算的两个对象 都是ndarray，并且形状相同，那么会对位彼此之间进行（+ - * /）运算。NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。
算术函数的使用
#算术函数
a=np.arange(9,dtype=np.float).reshape(3,3)
b=np.array([10,5,2])
a
array([[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]])
==================================
#add函数（加）
np.add(a,b)
------------
array([[10., 6., 4.],
[13., 9., 7.],
[16., 12., 10.]])
==================================
#subtract函数（减）
np.subtract(a,b) #a-b
-----------------
array([[-10., -4., 0.],
[ -7., -1., 3.],
[ -4., 2., 6.]])
==================================
#multiply函数（乘）
np.multiply(a,b)
--------------------
array([[ 0., 5., 4.],
[30., 20., 10.],
[60., 35., 16.]])
====================================
#divide函数（除）
np.divide(a,b)
-----------------
array([[0. , 0.2, 1. ],
[0.3, 0.8, 2.5],
[0.6, 1.4, 4. ]])
算术函数中out参数
#算数函数中out参数的使用
x=np.arange(5)
y=np.empty_like(x)
np.multiply(x,10,out=y) #将x乘10赋值给y
y
-----------------
array([ 0, 10, 20, 30, 40])
mod()函数
numpy.mod() 计算输入数组中相应元素的相除后的余数。
#mod()函数的使用
#numpy.mod() 计算输入数组中相应元素的相除后的余数。
a=np.array([10,10,30])
b=np.array([3,5,7])
np.mod(a,b)
-------------------------
array([1, 0, 2], dtype=int32)
统计函数
power()函数
#power()函数的使用
# numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
x = np.arange(1,5)
y = np.empty_like(x)
np.power(x,2,out=y) #将x中的元素进行2次方，赋值给y
y
-----------------------
array([ 1, 4, 9, 16])
median ()函数
# median()函数的使用
a=np.array([4,2,1,5]) #计算偶数个元素的中位数（排序取平均）
np.median(a)
----
3.0
=================================
a=np.array([4,2,1]) #计算奇数个元素的中位数（排序取中值）
np.median(a)
----
2.0
==================================
a=np.arange(1,16).reshape(3,5)
print(np.median(a))
-------
8.0
==================================
#调用median函数，axis=1 行的中值
print(np.median(a,axis=1))
---------------
[ 3. 8. 13.]
================================
# 调用median函数，axis=0 列的中值
print(np.median(a,axis=0))
-----------------------------
[ 6. 7. 8. 9. 10.]
mean ()函数的
#mean ()函数的使用
#numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。
#算术平均值是沿轴的元素的总和除以元素的数量。
a=np.arange(1,11).reshape(2,5) #a=array([[ 1, 2, 3, 4, 5],
# [ 6, 7, 8, 9, 10]])
=====================
#所有元素和的平均值
np.mean(a)
--------
5.5
============
#每列的平均值
np.mean(a,axis=0)
------------------
array([3.5, 4.5, 5.5, 6.5, 7.5])
========================
#每行的平均值
np.mean(a,axis=1)
---------------------
array([3., 8.])
函数的使用
#函数的使用
a=np.random.randint(10,50,size=20) #10-50内，生成20个随机整数
a
array([39, 39, 35, 49, 42, 24, 15, 28, 15, 35, 15, 24, 38, 35, 39, 23, 48,
17, 12, 42])
=============================
#求最大值
np.max(a)
-----
49
==============
#求和
np.sum(a)
----
614
===================
#求最小值
np.min(a)
----
12
================
#计算一组数中最大值与最小值的差
np.ptp(a)
----
37
===============================
#删除数组中的重复数据，并进行排序
np.unique(a)
-------------
array([12, 15, 17, 23, 24, 28, 35, 38, 39, 42, 48, 49])
==================================
#返回数组中非0元素的索引
np.nonzero(a)
-------------------
(array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19], dtype=int64),)
数组排序
排序中主要用到的方法是np.sort和np.argsort。其中np.sort()是对数组直接排序。而np.argsort()是返回排序后的原始索引。
一维数组排序
#一维数组
a=np.array([5,2,4,6,1,9])
print('sort排序后：',np.sort(a))
print('argsort排序：',np.argsort(a))
-------------------------------
sort排序后： [1 2 4 5 6 9]
argsort排序： [4 1 2 0 3 5]
按最后一列进行排序
#按最后一列进行排序
#可以先获取最后一列的数组
a=np.random.randint(100,size=(4,6))
b=a[:,-1]
print(b)
--------------
[93 72 1 66]
============================
#获取最后一列数组排序后的原始索引
index=np.argsort(b)
index
----------
array([2, 3, 1, 0], dtype=int64)
====================================
#使用facy_indexing汇总数组
print(a[index])
---------------------
[[51 50 18 92 29 1]
[63 12 2 75 45 66]
[61 72 74 86 16 72]
[74 36 31 18 72 93]]
numpy广播机制
两个数组相加
# numpy广播机制
# 两个数组相加
b=np.array([5,5,5])
print(a+b)
-----------------
[5 6 7]
维度不相同的数组相加
广播的规则:
-
如果两个数组维度个数不同，那么小维度的数组形状会在左边补1
-
如果两个数组形状在任何一个维度上都不匹配，数组的形状会沿着维度为1的维度扩展到匹配上另一个数组的形状
-
如果没有维度形状为1，则会引发异常:
0 1 2 0 0 0
0 1 2 1 1 1
0 1 2 2 2 2
# 维度不相同的数组相加
a = np.arange(3) #一行
c = np.arange(3).reshape(3,1) #三行一列
print(a+c)
---------------------
[[0 1 2]
[1 2 3]
[2 3 4]]
如果没有维度形状为1，则会引发异常
a = np.arange(6).reshape(2, 3)
b = np.arange(6).reshape(3, 2)
print(a + b)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_12724\2190402067.py in <module>
1 a = np.arange(6).reshape(2, 3)
2 b = np.arange(6).reshape(3, 2)
----> 3 print(a + b)
ValueError: operands could not be broadcast together with shapes (2,3) (3,2)
总结
到这为止，我们的NumPy库常用基础知识学习完全了，方法非常多，务必好好整理。
4077
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
