内容目录
NumPy 是一个基础科学的计算包，包含：一个强大的 N 维数组对象、sophisticated (broadcasting) functions、tools for integrating C/C++ and Fortran code、有用的线性代数、傅立叶转换和随机数生成函数
1.安装numpy模块
一条命令即可：
pip install numpy
测试是否安装成功：import numpy as np a=np.arange(10) print(a)
正常会输出如下内容：
[0 1 2 3 4 5 6 7 8 9]
这里输出的内容长得很像列表，但他其实不是列表，我们来看一下他的类型：
print(type(a))
输出居然是：
<class 'numpy.ndarray'>
网上查询到了一些关于ndarray的东西，貌似很重要，后面一定会很熟悉的：
- N-dimensional array的缩写，属于一个Python的类
- numpy中的ndarray为多维数组，是numpy中最为重要也是python进行科学计算非常重要和基本的数据类型。numpy中基本的运算符进行了重载，算数运算符和逻辑运算符都是逐元素操作的，还有广播机制，使得一个标量与多维数组相互运算的时候也是逐元素运算。
- 由多个具有相同类型和尺寸的元素组成的多维容器（通常具有固定尺寸）
2. numpy的基本使用
import numpy as np
b = np.array([1,2,3,4,5,6])
print(b)
print('b数组的维度：',b.shape)
```python
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)# ndarray 对象
# NumPy 最重要的一个特点是其N维数组对象ndarray，它是一系列同类型数据的集合，以0下标为开始进行集合中元素的索引。
# ndarray 对象是用于存放同类型元素的多维数组。
# ndarray 中的每个元素在内存中都有相同存储大小的区域。
import numpy as np
x1=np.random.randint(10,size=6)
print(x1)
x2=np.random.randint(10,size=(3,4))
print(x2)
x3=np.random.randn(3,4,5)
print('ndim 属性'.center(20,'*'))
print('ndim:',x1.ndim,x2.ndim,x3.ndim)
print('shape 属性'.center(20,'*'))
print('shape:',x1.shape,x2.shape,x3.shape)
print('dtype 属性'.center(20,'*'))
print('dtype:',x1.dtype,x2.dtype,x3.dtype)
print('size 属性'.center(20,'*'))
print('size:',x1.size,x2.size,x3.size)
print('itemsize 属性'.center(20,'*'))#一个字节是 8 位
print('itemsize:',x1.itemsize,x2.itemsize,x3.itemsize)[9 7 1 9 0 3]
[[3 8 2 3]
[8 9 1 2]
[0 6 3 6]]
******ndim 属性*******
ndim: 1 2 3
******shape 属性******
shape: (6,) (3, 4) (3, 4, 5)
******dtype 属性******
dtype: int32 int32 float64
******size 属性*******
size: 6 12 60
****itemsize 属性*****
itemsize: 4 4 8# 创建零矩阵
import numpy as np
x=np.zeros(5)
print(x)
#设置类型为整数
y=np.zeros((5,),dtype=int)
print(y)
z=np.zeros((2,2))
print(z)# 创建元素全为一的矩阵
import numpy as np
x=np.ones(5)
print(x)
y=np.ones((3,4),dtype=int)
print(y)[1. 1. 1. 1. 1.]
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]# numpy.empty() 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组，里面的元素的值是之前内存的值
import numpy as np
x=np.empty([3,2],dtype=int)
print(x)[[6 3]
[3 3]
[4 1]]# linspace函数用于创建一个一维数组，数组是一个等差数列构成的
# np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
import numpy as np
x=np.linspace(1,10,10)
print(x)
x=np.linspace(10,20,5,endpoint=True)
print(x)
x=np.linspace(0,1000,num=5,endpoint=True, retstep=True, dtype=int)
print(x)[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
[10. 12.5 15. 17.5 20. ]
(array([ 0, 250, 500, 750, 1000]), 250.0)# numpy.logspace 函数用于创建一个于等比数列。 格式如下：# np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
# base是对数 log 的底数
x=np.logspace(0,9,10,base=2)
print(x)[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]# 数组/矩阵的切片和索引
# 这里和python列表的操作是一样的
# 一维数组的索引和切片
import numpy as np
x=np.arange(10)
print('原数组： ',x)
y = x[2:7:2]
z = x[2:]
print('对数组进行[2:7:2]切片： ',y)
print('对数组进行[2:]切片： ',z)原数组： [0 1 2 3 4 5 6 7 8 9]
对数组进行[2:7:2]切片： [2 4 6]
对数组进行[2:]切片： [2 3 4 5 6 7 8 9]# 二维数组索引的使用
import numpy as np
x=np.arange(1,13)
a=x.reshape(4,3)
print('数组元素')
print(a)
print('获取第二行')
print(a[1])
print('获取第三行第二列')
print(a[2][1])数组元素
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
获取第二行
[4 5 6]
获取第三行第二列
8# 二维数组切片的使用
import numpy as np
x=np.arange(1,13)
a=x.reshape(4,3)
print('数组元素')
print(a)
#使用索引获取
print('所有行的第二列')
print(a[:,1])
print('奇数行的第一列')
print(a[::2,0])数组元素
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
所有行的第二列
[ 2 5 8 11]
奇数行的第一列
[1 7]# 二维数组索引的使用
import numpy as np
a = np.arange(1,13).reshape(4,3)
print('数组元素')
print(a)
print('获取第三行第二列的结果： ',a[2,1])
print('同时获取第三行第二列， 第四行第一列')
print('分别获取：',np.array((a[2,1],a[3,0])))
print('第一个元组是行索引， 第二个元组是列索引获取： ',a[(2,3),(1,0)])数组元素
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
获取第三行第二列的结果： 8
同时获取第三行第二列， 第四行第一列
分别获取： [ 8 10]
第一个元组是行索引， 第二个元组是列索引获取： [ 8 10]# 负索引的使用
import numpy as np
x=np.arange(1,13).reshape(4,3)
print('数组元素')
print(x)
print('获取最后一行')
print(a[-1])
print('行进行倒序')
print(a[::-1])
print('行列都倒序')
print(a[::-1,::-1])数组元素
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
获取最后一行
[10 11 12]
行进行倒序
[[10 11 12]
[ 7 8 9]
[ 4 5 6]
[ 1 2 3]]
行列都倒序
[[12 11 10]
[ 9 8 7]
[ 6 5 4]
[ 3 2 1]]# 所有切片取出来的数组，即使你把它赋值给了新的变量，它仍是原来数组的视图
# 这里有点像python列表的复制了，使用=复制就是浅复制，而使用deepcopy模块复制，就是重新开辟一份内存来存放复制出来的列表
import numpy as np
a=np.arange(1,13).reshape(3,4)
sub_array=a[:2,:2]
sub_array[0][0]=1000
print('原数组a：')
print(a)
print('切片后的数组sub_array：')
print(sub_array)
print('数组复制')
copy_sub_array=np.copy(a[:2,:2])
sub_array[0][0]=2000
print('原数组a：')
print(a)
print('复制数组copy_sub_array：')
print(copy_sub_array)原数组a：
[[1000 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
切片后的数组sub_array：
[[1000 2]
[ 5 6]]
数组复制
原数组a：
[[2000 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
复制数组copy_sub_array：
[[1000 2]
[ 5 6]]# 改变数组的维度
# Numpy 提供的大量API可以很轻松地完成这些数组的操作。
# 例如，通过 reshape方法可以将一维数组变成二维、三维或者多维数组。
# 通过ravel方法或flatten方法可以将多维数组变成一维数组。
# 改变数组的维度还可以直接设置Numpy数组的shape属性（元组类型），通过resize方法也可以改变数组的维度。
import numpy as np
#创建一维的数组
a=np.arange(24)
print(a)
print('数组 a 的维度： ',a.shape)
print('-'*30)
#使用 reshape 将一维数组变成三维数组
b=a.reshape(2,3,4)
print(b)
print('数组 b 的维度： ',b.shape)
print('-'*30)
#将 a 变成二维数组
c=a.reshape(3,8)
print(c)
print('数组 c 的维度： ',c.shape)
print('-'*30)
#使用 ravel 函数将三维的 b 变成一维的数组
a1=b.ravel()
print(a1)
print('-'*30)
#使用 flatten 函数将二维的 c 变成一维的数组
a2=c.flatten()
print(a2)
print('-'*30)[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
数组 a 的维度： (24,)
------------------------------
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
数组 b 的维度： (2, 3, 4)
------------------------------
[[ 0 1 2 3 4 5 6 7]
[ 8 9 10 11 12 13 14 15]
[16 17 18 19 20 21 22 23]]
数组 c 的维度： (3, 8)
------------------------------
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
------------------------------
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
------------------------------