NumPy
Numpy(Numerical Python) 是科学计算基础库，提供大量科学计算相关功能，比如数据统计，随机数生成等。其提供最核心类型为多维数组类型（ndarray），支持大量的维度数组与矩阵运算，Numpy支持向量处理ndarray对象，提高程序运算速度。
安装
安装 NumPy 最简单的方法就是使用 pip 工具，语法格式如下：
pip install numpy
pip install jupyter notebook
在pycharm打开jupyter notebook：
打开pycharm中的命令端，输入jupyter notebook，等待一会会自动跳转，若是不跳转，点击最下面的链接：
跳转页面后，创建新的程序，我们使用jupyter学习Numpy。
Numpy运行方法：Shift键 + Enter键。如：
写好代码后直接按下两键。更多具体的jupyter notebook界面操作方法，自行查找详细操作。
array创建数组
numpy模块的array函数可以生成多维数组。语法格式如下：
numpy.array(object, dtype = None, copy =True, order = None, subok = False, ndmin = 0)
object ：数组或嵌套的数列。 dtype ：数组元素的数据类型，可选。 copy： 对象是否需要复制，可选
order ：创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok ：默认返回一个与基类类型一致的数组。 ndmin ：指定生成数组的最小维度
创建一维
import numpy as np #导包
b=np.array([1,2,3,4,5,6])
print(b,b.shape) #shape显示数组的维度
----------- #红线下为输出结果
[1 2 3 4 5 6] (6,)
创建二维
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
print("a数组的维度：",a.shape)
--------------------------
[[1 2 3]
[4 5 6]
[7 8 9]]
a数组的维度： (3, 3)
ndmin参数的使用
#ndmin参数：
a = np.array([1,2,3,4,5,6],ndmin = 3) #指定生成数组的最小维度为3
print(a)
------------------
[[[1 2 3 4 5 6]]]
dtype参数的使用
#dtype参数:改变数组元素的数据类型
#将数组内的元素强制变成浮点型
a = np.array([1,2,3,4,5,6],dtype = np.float64)
print(a)
-----------------
[1. 2. 3. 4. 5. 6.]
arange创建数组
使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：
numpy.arange(start, stop, step, dtype)
start ：起始值，默认为0。 stop： 终止值（不包含）。 step ：步长，默认为1
dtype ：返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
#arange函数创建数值范围
#格式：numpy.arange(start,stop,step,dtype) 取值：左闭右开
#arange生成 0 到 5 的数组
x = np.arange(0,5,dtype=int)
print(x)
#-------------------------
#arange设置了起始值、终止值及步长
y = np.arange(10,20,2,dtype = np.float64)
print(y)
#--------------------
#创建二维数组
z = np.array([np.arange(1,4),np.arange(4,7),np.arange(7,10)])
print(z)
输出结果：
[0 1 2 3 4]
-------------------
[10. 12. 14. 16. 18.]
------------------------
[[1 2 3]
[4 5 6]
[7 8 9]]
随机数创建
numpy中的random模块包含了很多方法可以用来产生随机数。
随机数
#返回[0.0，1.0)范围的随机数
#格式：numpy.random.random(size=None) ---> size:表示数据长度维度
x=np.random.random(size=4)
print(x)
----------------
[0.39089737 0.27449493 0.67038824 0.18743961]
y = np.random.random(size=(3,4))
print(y)
-----------------
[[0.46791494 0.55568935 0.89622367 0.47164053]
[0.01337248 0.02821914 0.4660383 0.74495001]
[0.96514074 0.0456898 0.11795308 0.99197463]]
随机整数
#返回整数
#格式:numpy.random.randint(low,high,size)
x = np.random.randint(5,size=10) #---> size:表示数据长度维度
print(x)
y = np.random.randint(5,10,size=(3,4))
print(y)
$----------------------------------------$
[0 3 3 4 4 0 0 0 3 0]
---------------------
[[6 7 9 6]
[6 9 8 6]
[6 5 9 6]]
正太分布
#正太分布 具有标准正太分布(期望0 方差1)
#格式：numpy.random.randn(d0,d1,d2,…,dn)
x = np.random.randn()
print(x)
------------------------
0.6666711910611633
y = np.random.randn(2,4)
print(y)
---------------------
[[-0.11042552 0.03771884 0.70705774 0.49759948]
[-1.83386129 0.7898438 -0.76104361 -0.4511798 ]]
z = np.random.randn(2,3,4)
print(z)
---------------------
[[[ 1.43434958 0.73995544 0.14880011 0.7429944 ]
[-0.51394552 0.84819023 -0.56734252 0.27952588]
[ 0.11325095 -1.35043481 0.18511292 0.67372189]]
[[ 1.74016415 0.890556 0.55970424 0.42848806]
[ 1.3033731 0.52913202 -0.07831286 -1.33728252]
[-0.36403971 0.9837446 0.87700483 -0.19645756]]]
#指定期望和方差的正太分布 ---->格式：np.random.normal(loc,scale,size)
print(np.random.normal(loc = 3,scale = 4,size = (2,2,3)))
------------------
[[[-0.38508127 8.72575577 4.77984012]
[ 5.28413947 11.29557292 5.42547076]]
[[ 2.86169592 -3.9155134 1.19362943]
[ 4.2279321 -2.54565136 -1.06140229]]]
ndarray对象
Numpy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
x1 = np.random.randint(10,size = 6)
x2 = np.random.randint(10,size = (3,4))
x3 = np.random.randn(3,4,5)
print("ndim:",x1.ndim,x2.ndim,x3.ndim) #ndim表示查看维度
结果：ndim: 1 2 3
print("shape:",x1.shape,x2.shape,x3.shape) #查看尺度，对于矩阵，n行n列
结果：shape: (6,) (3, 4) (3, 4, 5)
print("dtype:",x1.dtype,x2.dtype,x3.dtype) #查看类型
结果：dtype: int32 int32 float64
print("size:",x1.size,x2.size,x3.size) #元素的个数，相当于shape中n*m
结果：size: 6 12 60
print("itemsize:",x1.itemsize,x2.itemsize,x3.itemsize) #ndarray对象中每个元素的大小，以字节为单位
结果：itemsize: 4 4 8
zeros创建
创建指定大小的数组，数组元素以 0 来填充，格式如下：
numpy.zeros(shape, dtype = float, order ='C')
#zeros创建
#格式:numpy.zeros(shape,dtype = float,order = 'c')
x = np.zeros(5) #创建的全0矩阵，默认是浮点型的
print(x)
结果：[0. 0. 0. 0. 0.]
#设置类型为整数
y = np.zeros((5,),dtype = int)
print(y)
结果：[0 0 0 0 0]
#创建二维全0数组
z = np.zeros((2,2))
print(z)
结果：[[0. 0.]
[0. 0.]]
zeros_like
根据传入的数组形状创建全为0的数组。
#zeros_like:根据传入的数组形状创建全为0的数组
a = np.array([np.arange(1,5),np.arange(4,8)])
z = np.zeros_like(a)
print(z)
--------------
array([[0, 0, 0, 0],
[0, 0, 0, 0]])
ones创建
创建指定形状的数组，数组元素以 1 来填充，格式如下：
numpy.ones(shape, dtype = None, order = 'C')
#ones创建 创建指定形状的数组，数组元素以1来填充
#格式:numpy.ones(shape,dtype = None,order = "c")
x = np.ones(5)
print(x)
结果：array([1., 1., 1., 1., 1.])
y = np.ones((2,3),dtype = int)
print(y)
结果：array([[1, 1, 1],
[1, 1, 1]])
ones_like
z = np.ones_like([np.arange(4,8),np.arange(2,6)])
print(z)
-------------------------
array([[1, 1, 1, 1],
[1, 1, 1, 1]])
empty创建
创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组，里面的元素的值是之前内存的值,格式如下：
numpy.empty(shape, dtype = float, order ='C')
#empty创建 创建一个指定形状、数据类型的数组，里面的元素值是之前内存里的，会变的
#格式：numpy.empty(shape,dtype = float,order = "c")
x = np.empty([3,2],dtype = int)
print(x)
--------------------
array([[ 3442, 946688],
[ 184156160, 1936288828],
[1836016500, 30817904]])
empty_like
y = np.empty_like([np.arange(1,5),np.arange(4,8)])
print(y)
-------------------------
array([[1136351920, 567, 0, 0],
[ 0, 0, 0, 0]])
empty创建数组的使用
#empty创建数组的使用
x = np.arange(5)
y = np.empty(10,dtype = int)
np.add(2,x,out=y[:5]) #将x的值追加2，赋给y的前五个值 未被接收，可以直接打印出结果
-----------------------------
array([2, 3, 4, 5, 6])
full()创建
创建全为某个指定值的数组,格式如下：
full(shape,fill_value)
# full的创建 创建全为某个指定值的数组
#格式：full(shape,fill_value)
a = np.full((2,2),3) #创建一个2*2的矩阵，里面全为3
print(a)
----------------
array([[3, 3],
[3, 3]])
full_like
#full_like
b = np.full_like(([np.arange(1,5),np.arange(4,8)]),4)
print(b)
------------------------
array([[4, 4, 4, 4],
[4, 4, 4, 4]])
创建单位矩阵
单位矩阵从左上角到右下角的对角线上的元素均为1,除此以外全都为0。任何矩阵与单位矩阵相乘都等于本身，而且单位矩阵因此独特性在高等数学中也有广泛应用。创建单位矩阵的两种方法：eye 和identity方法
eye方法
n1 = np.eye(3,dtype = int)
print(n1)
-----------------------------
array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
identity方法
n2 = np.identity(3,dtype = int)
print(n2)
-------------------
array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
linspace创建
linspace函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：
np.linspace(start, stop, num=50,endpoint=True, retstep=False, dtype=None)
start：序列的起始值。
stop：序列的终止值，如果endpoint为true，该值包含于数列中。
num：要生成的等步长的样本数量，默认为50。
endpoint：该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
retstep：如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype：ndarray 的数据类型
#linspace创建---->等差数列
#格式：np.linspace(start,stop,num = 50,endpoint=True,retstep=Flase,dtype=None)
#endpoint=True时----->[start,end], 否则[start,end)
x = np.linspace(1,10,5) #表示1-10的范围内，等差出5个数字
print(x)
结果：array([ 1. , 3.25, 5.5 , 7.75, 10. ])
y = np.linspace(1,10,5,endpoint=False) #endpoint=False,最后一位取不到10，不能以10结尾
print(y)
结果：array([1. , 2.8, 4.6, 6.4, 8.2])
#retstep显示等差间隔：
z = np.linspace(10,20,5,retstep=True)
print(z)
结果：(array([10. , 12.5, 15. , 17.5, 20. ]), 2.5)
logspace创建
logspace 函数用于创建一个于等比数列。格式如下：
np.logspace(start, stop, num=50,endpoint=True, base=10.0, dtype=None)
start：序列的起始值为：base ** start
stop：序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num：要生成的等步长的样本数量，默认为50
endpoint：该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
base：对数 log 的底数。
dtype：ndarray 的数据类型
#logspace创建----->等比数列
#格式：np.logspace(start,stop,num = 50,endpoint=True,base=10.0,dtype=None)
x = np.logspace(0,9,10,base = 2) #底数为2
print(x)
结果：array([ 1., 2., 4., 8., 16., 32., 64., 128., 256., 512.])
y = np.logspace(0,3,num = 4) #默认底数为10
print(y)
结果：array([ 1., 10., 100., 1000.])
总结
本篇介绍了一部分Numpy库中的方法，Numpy库很大很丰富，务必整理牢记，对接下来的学习很重要。
还有部分方法下期介绍哦~
4076
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
