python：numpy分享（保姆级教程）

一、概念

numpy 是数据分析必不可少的第三方库，具有高性能的特点，多用于做数组分析。
主要用于数组计算，支持多维数组。

• 包含：
  • 一个强大的N维数组对象 ndarray
  • 广播功能函数
  • 整合 C/C++/Fortran 代码的工具
  • 线性代数、傅里叶变换、随机数生成等功能

二、相关属性

ndim:获取数组的维度
shape:获取数组的形状
size:获取数组的元素个数
dtype:获取数组元素的数据类型
type:查看数组的类型
itemsize:获取数组中元素的大小

例：
import numpy as np  #导入包
y_list1=[1,2,3,4,5,6,7,8,9,10]
n1=np.array(my_list1)
print(n1.ndim)
print(n1.shape)
print(n1.dtype)
print(n1.size)
print(n1.itemsize)
print(n1.nbytes)
print(n1.nbytes)

三、ndarray及其实例创建

（一） ndarray介绍

• NumPy数组是一个多维的数组对象（矩阵），称为ndarray(N-Dimensional Array)
• 具有矢量算术运算能力和复杂的广播能力，并具有执行速度快和节省空间的特点
• 注意：ndarray的下标从0开始，且数组里的所有元素必须是相同类型。

• **array()的功能是通过数据创造数组，生成ndarray的一个实例。

（二）zeros（）、ones（）、empty（）函数

函数zeros创建一个全是0的数组，

函数ones创建一个全1的数组，

函数empty创建一个内容随机并且依赖于内存状态的数组。
创建数组：

例：
import numpy as np  #导入包
 a1=np.array([[1,2,3],[4,5,6]])    #生成二维数组
#zeros()函数
 a2=np.zeros((2,2,3))
 print(a2,a2.shape)
#ones()函数
 a3=np.ones((2,2,3))
 print(a3,a3.shape)
#empty()函数
 a4=np.empty((2,2,3))
 print(a4,a4.shape)

（三）arange(), 类似 python 的 range() ，创建一个一维 ndarray 数组。

例：
 a5=np.arange(10,20,2)  #10为起始值，20为结束值（不包括20），2为步长
 print(a5,a5.shape)

a3=np.arange(10) #默认0开始，步长1，默认共10个值，不包括10
print(a3,a3.shape)

a4=np.arange(10,15) #10开始，默认步长1，不包括15，共5个值
print(a4,a4.shape)

a5=np.arange(10,15,2)#10开始，步长2，不包括15，共3个值
print(a5,a5.shape)

（四）matrix(), 是 ndarray 的子类，只能生成 2 维的矩阵

例：
a6=np.matrix([[3,2,1],[6,5,4]])#需要每个列表相同个数数据
print(a6,a6.shape)

（五）rand（）、randn（）、randint（）、uniform（）（都是numpy.random下的函数）

rand()的功能是生成一个指定形状的随机浮点数数组,范围默认是0-1之间；
randn()的功能是生成生成 标准正态分布（均值为 0，标准差为 1）的随机数；
randint()的功能是生成一个指定形状的随机整数数组,范围必须指定（至少指定low）,且必须是整数，形状用size指定；
uniform()的功能是生成一个指定形状的随机浮点数数组,范围需要指定（不指定，则默认0-1）,形状用size指定。

例：
#randn生成正态分布随机数，一行两列
 a=np.random.randn(1,2)
 print(a,a.shape)
 
# rand生成0-1的随机数，5个
 b1=np.random.rand(5)
#rand生成2行3列的0-1之间的随机数
b2=np.random.rand(2,3)
#rand生成2组3行5列的0-1之间的随机数
 b3=np.random.rand(2,3,5)
 print(b1,b1.shape)
print(b2,b2.shape)
print(b3,b3.shape)

#randint生成 [1, 10) 的随机整数
x1 = np.random.randint(1, 10, size=5)  # 如 [3, 7, 2, 9, 5]
# randint生成 2x3 的 [5, 20) 的随机整数数组
y1 = np.random.randint(5, 20, size=(2, 3))  


# uniform生成 [1.0, 10.0) 的随机浮点数
x2 = np.random.uniform(1.0, 10.0, size=5)  # 如 [4.2, 1.5, 9.8, 3.7, 6.0]
#uniform生成 2x3 的 [0.0, 10.0) 的随机浮点数数组
y2= np.random.uniform(0.0,10.0, size=(2, 3))  
#另一种写法
 y3= np.random.uniform(low=0.0, high=10.0, size=(2, 3))
#注意，uniform如果low和high不指定，将默认生成0.0-1.0之间的浮点数。

（六）astype（）

修改数组的数据类型,注意:返回新的，不更改原数组类型。

例：
arr_str = np.array(["1", "2", "3"])
arr_num = arr_str.astype(np.float64)  # 字符串转浮点数

（七）logspace()函数

功能是生成一个等比数组

例：
a2=np.logspace(0,10,base=2)  #默认个数50
print(a2,a2.shape)

（八）linspace()

功能是生成一个等差数组

例：
a1=np.linspace(0,10,5)
print(a1,a1.shape)

四、Numpy的内置函数

（一）基本函数

np.ceil(): 向上最接近的整数，参数是 number 或 array
np.floor(): 向下最接近的整数，参数是 number 或 array
np.rint(): 四舍五入，参数是 number 或 array
np.isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
np.multiply(): 元素相乘，参数是 number 或 array
np.divide(): 元素相除，参数是 number 或 array
np.abs()：元素的绝对值，参数是 number 或 array
np.where(condition, x, y): 三元运算符，x if condition else y
注意: 需要注意multiply/divide 如果是两个ndarray进行运算 shape必须一致

例(列举重点）：
c=np.ceil(a)
print(c,c.shape)

d=np.floor(a)
print(d,d.shape)

e=np.isnan(a)
print(e,e.shape)

f=np.multiply(a1,a2)
print(f,f.shape)

g=np.divide(a1,a2)
print(g,g.shape)

（二）统计函数

np.mean(), np.sum():所有元素的平均值，所有元素的和，参数是 number 或 array

np.max(), np.min():所有元素的最大值，所有元素的最小值，参数是 number 或 array

np.std(), np.var():所有元素的标准差，所有元素的方差，参数是 number 或 array

np.argmax(), np.argmin():最大值的下标索引值，最小值的下标索引值，参数是 number 或 array

np.cumsum(), np.cumprod():返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array

注意：多维数组默认统计全部维度，axis参数可以按指定轴心统计，axis=0则按列统计，axis=1则按行统计。

例（列举重点）：
a6=np.array([[3,2,1],[6,5,4]])
print(a6,a6.shape)
#分别打印分列和分行统计的和
 print(a6.sum(axis=0))   #按列统计和
# print(a6.sum(axis=1))   #按行统计和
# print(a6.sum())

# #打印最大值索引和最小值索引
# print(a6.argmax())
# print(a6.argmin())

# #打印累积和、累积乘积
# print(a6.cumsum())
# print(a6.cumprod())
# #打印标准差、均值、方差
# print(a6.std())   #标准差
# print(a6.mean())
# print(a6.mean(axis=0))#纵向计算平均值
# print(a6.mean(axis=1))#横向计算平均值
# print(a6.var())    #方差

（三）比较函数

np.any(): 至少有一个元素满足指定条件，返回True
假如我们想要知道矩阵a和矩阵b中对应元素是否有一个相等，我们需要使用any方法。

np.all(): 所有的元素满足指定条件，返回True
假如我们想要知道矩阵a和矩阵b中所有对应元素是否相等，我们需要使用all方法，

例：
arr = np.array([1, -2, 3, -4])

# 检查是否有正数，有一个正数就为true
has_negative = np.any(arr >0)  # True

# 检查是否全为正数，如果全是就是true
all_positive = np.all(arr > 0)  # False

（四）去重函数

np.unique():找到唯一值并返回排序结果，类似于Python的set（集合）

例：
arr = np.array([3, 1, 2, 2, 3, 1, 4])
unique_values = np.unique(arr)
print(unique_values)  # 输出: [1 2 3 4]

（五）排序函数

numpy.sort(数组):函数排序, 返回排序后的副本
数组.sort():在原数据上进行修改

例：
a6=np.array([[3,2,1],[6,5,4]])
print(a6,a6.shape)

print(np.sort(a6))#默认从小到大（升序）排序
print(-np.sort(-a6)) #从大到小（降序）排序
print(np.sort(a6)[::-1]) #上下颠倒（降序）排序

#扩展：
# 上下（行）颠倒排序方式
gg = np.argsort(-a6[:,col]) #从大到小返回索引
print(gg)
jj=a6[gg]
print(jj)

# 每行从小到大（降序）排序
gg1= np.argsort(a6[col,:])  #从小到大返回索引
print(gg1)
jj1=a6[:,gg1]
print(jj1)

五、Numpy运算

（一）数组元素间加减乘除

基本步骤：

1.两个ndarray, 一个是arr_a 另一个是arr_b；

2.它们俩之间进行 arr_a + arr_b 或 arr_a - arr_b 或 arr_a * arr_b 这样计算的前提是 shape相同；

3.计算的时候, 位置对应的元素 进行 加减乘除的计算, 计算之后得到的结果的shape 跟arr_a /arr_b 一样。

例：
import numpy as np

a = np.array([20, 30, 40, 50])
b = np.arange(4)

#加法运算
c1= a + b
print("数组a:", a)
print("数组b:", b)
print("数组运算a+b:", c1)

#减法运算
c2 = a - b
print("数组a:", a)
print("数组b:", b)
print("数组运算a-b:",c2)

#乘法运算
c3= a * b
print("数组a:", a)
print("数组b:", b)
print("数组运算a*b:", c3)

*除法运算
c4 = a / b
print("数组a:", a)
print("数组b:", b)
print("数组运算a/b:", c4)

（二）矩阵运算

arr_a.dot(arr_b) ，前提： arr_a 列数 = arr_b行数

矩阵加法和矩阵减法与数组间元素加减无甚区别，重点是矩阵乘法（因为乘法不可逆，所以没有直接的矩阵除法操作，矩阵除法可以通过函数计算，类似于解线性方程，但此处不讲解）。矩阵乘法与矩阵除法与元素间相乘相除都有本质区别。

import numpy as np

x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([[6, 23], [-1, 7], [8, 9]])
print(x)
print(y)
print(x.dot(y))     #矩阵乘法的一种写法
print(np.dot(x, y))   #矩阵乘法的另一种写法

输出结果：
[[ 28  64]
 [ 67 181]]   #x行与y的列元素相乘再加在一块，有两列就得两个值，然后两行，一共4值
[[ 28  64]      #比如28=1*6+2*（-1）+3*8，得到第一个值，一次类推
 [ 67 181]]     #矩阵乘法与元素间乘法（x*y或np.multiply(x, y)）本质不同。

今天的分享到此结束，欢迎交流。