Numpy（一）简介与基本使用
一、Numpy简介
1.Numpy是一个运行速度非常快的数学库，主要用于数组计算
2.包含：N维数组对象ndarray、广播功能函数、整合C/C++/Fortran代码工具、包含线性代数/傅里叶变换/随机数生成等功能
3.优点：对于数值计算，Numpy比Python要快捷高效、Numpy经常和Scipy（Scientfic python）和Matplotlib（绘图库）一起使用。
二、Ndarray对象
1.介绍：
1.Numpy最重要的一个特点是其N维数组对象Ndarray，它是一些列同类型数据的集合，以0为下标开始进行集合中元素的索引。
2.Ndarray对象是用于存放同类型元素的多维数组。
3.Ndarray中的每个元素在内存中都有相同存储大小的区域。
包含：
1.一个指向数据（内存或者内存映射文件的一块数据）的指针
2.数据类型（data-type）————描述数组中固定值大小
3.表示数组形状的元组，各维度大小的元组（几维矩阵）
三、Numpy的数据类型
1.Numpy支持的数据类型比Python多，与C语言数据类型基本对应。
| 符号 |
注释 |
| bool_ |
布尔型数据类型（True或False）判断逻辑语句的真伪 |
| int_ |
默认的整数数据类型（类似于C语言中的int32、int64、long） |
| intc |
与C语言的int一样，一般是int32或int64 |
| intp |
用于索引的数据类型（类似于C用于的ssize_t，一般情况下还是int32或int64） |
| int8 |
8字节（-128-127） |
| int16 |
16字节（-32768-32767） |
| int32 |
32字节（-232-232-1） |
| int64 |
64字节（-264-264-1） |
| uint8 |
无符号整数8字节（0-127） |
| uint16 |
无符号整数16字节（0-32767） |
| uint32 |
无符号整数32字节 |
| uint64 |
无符号整数64字节 |
| float_ |
float64类型的简写 |
| float16 |
半精度浮点数（1个符号位 、5个指数位、10个尾数位） |
| float32 |
单精度浮点数（1个符号位 、8个指数位、23个尾数位） |
| float64 |
双精度浮点数（1个符号位 、11个指数位、52个尾数位） |
| complex_ |
complex128简写，表示128位复数 |
| complex64 |
复数，表示双32位浮点数 |
| complex128 |
复数，表示双64位浮点数 |
简写：
| 符号 |
注释 |
| b |
布尔型 |
| i |
有符号整型 |
| u |
无符号整型 |
| f |
浮点型 |
| c |
复数浮点型 |
| m |
时间间隔（timedelta） |
| M |
日期时间（datatime） |
| O |
python对象 |
| S,a |
字符串 |
| U |
Unicode |
| V |
原始数据（void） |
四、创建一维数组
1.基本语法：
numpy.array(object,dtype=none,copy=true,order=none,subok=flase,ndmin=0)
| 参数 |
说明 |
| object |
数组或嵌套的数列 |
| dtype |
数组元素的数据类型 |
| copy |
对象是否需要复制 |
| order |
创建数组的样式，C为行方向，F为列方向 |
| subok |
默认返回一个与基类类型一致的数组 |
| ndmin |
指定生成数组的最小维度 |
2.创建数组
①创建一维数组
import numpy as np
a=np.array([1,2,3,4,5])//创建[1，2，3，4，5]的一维数组
print(a)//打印该数组
print(type(a))//打印数据类型
[1 2 3 4 5]
<class 'numpy.ndarray'>
*创建数组数据要一致，否则按照优先级来（字符型（串）>float>int）
import numpy as np
a=np.array([1,2,3,4.5,5])//此时将里面一位数字改为浮点数float
print(a)
[1. 2. 3. 4.5 5. ]//整体数组改为浮点型
②创建多维数组
import numpy as np
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
print(type(a))
[[1 2 3]
[4 5 6]
[7 8 9]]
<class 'numpy.ndarray'>
*与matlab区别：matlab使用分号将多行数组隔开！
③改变最小维度
import numpy as np
a=np.array([[1,2,3],[5,6,7],[2,3,4]],ndmin=1)
print(a)
④改变数组的数据类型
import numpy as np
a=np.array([[1,2,3],[5,6,7],[2,3,4]],dtype=float)//此时将数据类型改为浮点型
print(a)
[[1. 2. 3.]
[5. 6. 7.]
[2. 3. 4.]]
3.创建特殊数组的一些函数
①empty（）
语法规则：
numpy.empty(shape,dtype=float,order='C')
作用：创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组
| 参数 |
说明 |
| shape |
数组形状 |
| dtype |
数据类型 |
| order |
行优先或列优先 |
创建一个随机数组
import numpy as np
a=np.empty([2,2],dtype=int)
print(a)
[[ -156566546 2057024226]
[ 617057341 -1551763911]]
②zeros()
语法规则：
numpy.zeros(shape,dtype=float,order='C')
作用：创建指定大小的数组，数组元素用0代替
创建0元素数组
import numpy as np
a=np.zeros([3,3],dtype=float,order='c')
print(a)
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
import numpy as np
a=np.zeros(6,dtype=float,order='c')
print(a)
[0. 0. 0. 0. 0. 0.]
③ones()
语法规则：
numpy.ones(sharp,dtype=float,order='c')
作用：创建指定大小的数组，数组元素用1代替
创建1元素的数组
import numpy as np
a=np.ones([2,2],dtype='i4')
print(a)
④full()
语法规则：
numpy.full(shape,fill_value,dtype=float,order='c')
作用：创建指定大小的数组，数组内元素用fill_value代替
创建一个fill_value大小为100的数组
import numpy as np
a=np.full([2,3],fill_value=100)
print(a)
⑤eye()
语法规则：
numpy.eye(N，M,dtype=int,order='C')
这里N指行，M指列，如果不表达列则默认N与M值相同
作用：创建指定大小（行列值）的数组，其对角线位置的数字为1，其余数字为0
创建10*10的对角1矩阵
import numpy as np
a=np.eye(10,dtype=int)
print(a)
[[1 0 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0 0 0]
[0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 1]]
创建一个10*9的对角1的矩阵
import numpy as np
a=np.eye(M=10,N=9,dtype=int)
print(a)
[[1 0 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0 0 0]
[0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 1 0]]
⑥arange()
语法规则：
numpy.arange(start,stop,step,dtype)
| 参数 |
注释 |
| start |
起始下标 |
| stop |
终止下标 |
| step |
步长 |
作用：创建数值范围并返回ndarray对象，依据start与stop指定的范围以及step设定的步长生成一个数组。
*创建一个[0，10）步长为0.5的数组
import numpy as np
a=np.arange(0,10.0,0.5,dtype=float)
print(a)
[0. 0.5 1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5
9. 9.5]
⑦frombuffer()
语法规则：
numpy.frombuffer( buffer,dtype=float,count=-1,offset=0)
| 参数 |
说明 |
| buffer |
可以是任意对象，会以流的形式读入 |
| dtype |
返回数组的数据类型 |
| count |
读取的数据，默认是-1（读取所有元素） |
| offset |
读取起始位置，默认为0（读取第一个（0位置）位置） |
作用：给定一个字符串，通过frombuffer()函数读取该字符串的字符
eg：读取该字符串的字符（默认count=-1读取所有元素）
import numpy as np
x=b"I Like study and I like learn python"//这里用到python3在所给定的字符串前面加b
a=np.frombuffer(x,dtype='S1')
print(a)
[b'I' b' ' b'L' b'i' b'k' b'e' b' ' b's' b't' b'u' b'd' b'y' b' ' b' '
b'a' b'n' b'd' b' ' b'I' b' ' b'l' b'i' b'k' b'e' b' ' b'l' b'e' b'a'
b'r' b'n' b' ' b'p' b'y' b't' b'h' b'o' b'n']
eg：读取三个元素
import numpy as np
x=b"I Like study and I like learn python"
a=np.frombuffer(x,dtype='S1',count=3)
print(a)
[b'I' b' ' b'L']
eg：从位置4读取元素
import numpy as np
x=b"I Like study and I like learn python"
a=np.frombuffer(x,dtype='S1',offset=4)
print(a)
[b'k' b'e' b' ' b's' b't' b'u' b'd' b'y' b' ' b' ' b'a' b'n' b'd' b' '
b'I' b' ' b'l' b'i' b'k' b'e' b' ' b'l' b'e' b'a' b'r' b'n' b' ' b'p'
b'y' b't' b'h' b'o' b'n']
⑧linspace()
语法规则：
numpy.linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None)
作用：创建一个一维数组，数组是有一个等差数列构成的。
| 参数 |
注释 |
| start |
序列的起始值 |
| stop |
序列的终止值 |
| num |
生成步长的样本数量，默认为50 |
创建一个（1-100）的等差数列步长为20
import numpy as np
x=np.linspace(1,100,20,dtype='i4')
print(x)
[ 1 6 11 16 21 27 32 37 42 47 53 58 63 68 73 79 84 89
94 100]
⑨logspace()
语言规则：
numpy.logspace(start,stop,num=50,base=10.0,dtype=None)
作用：创建一个等比数列
| 参数 |
注释 |
| start |
序列的起始位置 |
| stop |
序列的终止位置 |
| num |
序列的步长 |
| base |
对数log的底数，默认是10 |
生成一个底数是10，从101—102的数组，分成10份等比
import numpy as np
x=np.logspace(1,2,10,dtype='f4')
print(x)
[ 10. 12.915497 16.681005 21.544348 27.825594 35.938137
46.41589 59.948425 77.42637 100. ]
3.随机数创建数组
法一：使用random.rand()创建数组
①生成一个随机数
语法规则：
numpy.random.rand()
作用：生成一个[0，1）的随机数，用字符型表示。
实例：
import numpy as np
x=np.random.rand()
print(x)
0.03294766604498356
②生成含有三个元素的一维数组
语法规则：
numpy.random.rand(num)
*num为一维数组中元素的个数
实例
import numpy as np
x=np.random.rand(3)
print(x)
[0.40174655 0.00897811 0.55320899]
③生成含有N行M列的二维数组
语法规则：
numpy.random.rand(N,M)
*N代表行数，M代表列数
实例
import numpy as np
x=np.random.rand(3,2)
print(x)
[[0.65287452 0.92300411]
[0.14517632 0.29018207]
[0.12989397 0.44906311]]
④生成含有N行M列的S维的数组
语法规则：
numpy.random.rand(N,M,S)
*S=维数-1
实例
import numpy as np
x=np.random.rand(3,2,2)
print(x)
[[[0.0033195 0.42253443]
[0.36875234 0.29957679]]
[[0.61087282 0.9155903 ]
[0.57799805 0.16467769]]
[[0.47333421 0.19336464]
[0.62533259 0.31438229]]]
法二：利用random.random()创建一维数组
①创建一个随机数
import numpy as np
x=np.random.random()
print(x)
0.3192154894500221
②创建一维随机数组
import numpy as np
x=np.random.random(6)
print(x)
[0.37145277 0.38638417 0.92033279 0.60777345 0.69340799 0.49806382]
*此方法只能创建一维数组！
法三：创建一顶范围内的随机数组
①语法规则：
numpy.random.randint(low,high,size)
| 参数 |
含义 |
| low |
下边界值 |
| high |
上边界值（不包含） |
| size |
元素个数 |
实例：构建一个[5，8）含有6个元素的一维随机数组
import numpy as np
x=np.random.randint(5,8,6)
print(x)
[6 7 6 5 7 7]
法四：创建一组符合标准正态分布的一维数组
*标准正态分布：又称u分布，以0为均值，以1为标准差的正态分布，N(0,1)
语法规则：
numpy.random.randn()
eg.建立一个符合正态分布的随机数组
import numpy as np
x=np.random.randn(2,4)
print(x)
[[-0.25729227 0.09670748 0.77541419 0.55263664]
[ 0.25588823 -0.23929083 0.69356251 0.33543219]]
五、Ndarray数组属性
1.Ndarray数组介绍
Numpy数组的维数称之为秩(rank)，一维数组的秩为1，二维数组的秩为2，以此类推。在Numpy中，每一个线性的数组称之为一个轴(axis)，也就是维度(dimensions)。
2.常用属性
| 属性 |
说明 |
| ndim |
秩，即轴的数量或维度的数量 |
| shape |
数组的维度 |
| size |
数组元素的总个数，相当于shape中n*m值 |
| dtype |
数据类型 |
| itemsize |
对象中每个元素的大小，以字节为单位 |
| flags |
ndarrary对象的 内存信息 |
| real |
ndarry元素的实部 |
| imag |
ndarry元素的虚部 |
| data |
元素缓冲区 |
3.属性用法
①ndim（）————统计矩阵维度或轴的数量
import numpy as np
a=np.random.rand(3,3,4)————构建3维数组
print(a)————打印构建的三维随机数组
print(a.ndim)————打印维度
[[[0.15824291 0.98394574 0.71166123 0.47091615]
[0.27895798 0.62258469 0.86294268 0.77535747]
[0.60240049 0.98353132 0.57134778 0.36794952]]
[[0.44186638 0.71088624 0.39417474 0.23225202]
[0.63075121 0.96369931 0.70764624 0.56386642]
[0.57312328 0.11007869 0.68119825 0.97775468]]
[[0.06722779 0.86284405 0.25857728 0.14816577]
[0.65173668 0.65740552 0.80361287 0.92018257]
[0.51990904 0.57557527 0.53189146 0.84094672]]]
3
②reshape（）————重新构造矩阵的型/修改矩阵维度
import numpy as np
a=np.random.rand(6)
b=a.reshape(2,3)————将一维矩阵修改为二维矩阵
print(a)
print(a.ndim)
print(b)
print(b.ndim)
[0.70871458 0.76700232 0.04056928 0.2205189 0.7598584 0.8095149 ]
1
[[0.70871458 0.76700232 0.04056928]
[0.2205189 0.7598584 0.8095149 ]]
2
③shape————表示数组的维度，以元组的形式表示（行，列）
import numpy as np
a=np.array([[1,2,3],[4,5,6]])
print(a)
print(a.shape)
[[1 2 3]
[4 5 6]]
(2, 3)
*a.shape调整数组的维度
方法一：利用shape直接规定数组的维度
import numpy as np
a=np.array([[1,2,3],[4,5,6]])
a.shape=(3,2)——————将原先矩阵的（2，3）改为现在的（3，2）
print(a.shape)
print(a)
(3, 2)
[[1 2]
[3 4]
[5 6]]
方法二：利用reshape修改维度
import numpy as np
a=np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10],[9,8,7,6]])
b=a.reshape(2,8)
print(a)
print(a.shape)
print(b)
print(b.shape)
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]
[ 9 8 7 6]]
(4, 4)
[[ 1 2 3 4 4 5 6 7]
[ 7 8 9 10 9 8 7 6]]
(2, 8)
Process finished with exit code 0
④size————统计数组内元素总个数
import numpy as np
a=np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10],[9,8,7,6]])
print(a)
print(a.size)
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]
[ 9 8 7 6]]
16
⑤dtype————识别数组内元素的数据类型
import numpy as np
a=np.array([[1,2,3],[4,5,6]])
b=np.random.rand(2,3)
print(a)
print(a.dtype)
print(b)
print(b.dtype)
[[1 2 3]
[4 5 6]]
int32
[[0.3275208 0.17867393 0.5683612 ]
[0.36704931 0.07051842 0.27552977]]
float64
⑥itemsize————以字节的的形式返回数组每一个元素的大小
import numpy as np
a=np.array([[1,2,3],[4,5,6]])
print(a)
print(a.dtype)
print(a.itemsize)
b=np.random.rand(2,3)
print(b)
print(b.dtype)
print(b.itemsize)
c=np.arange(0,10,1)
print(c)
print(c.dtype)
print(c.itemsize)
d=np.array([[1+2j]])
print(d)
print(d.dtype)
print(d.itemsize)
[[1 2 3]
[4 5 6]]
int32
4
[[0.73846614 0.12767507 0.70801391]
[0.55624904 0.27666238 0.81485625]]
float64
8
[0 1 2 3 4 5 6 7 8 9]
int32
4
[[1.+2.j]]
complex128
16
Process finished with exit code 0
六、数组转置
1.什么是转置
A.一维数组不能进行转置
B.转置后的数组交替——（m,n）—>(n,m)
[1,2,3] [1,4,7]
[4,5,6] 转置结果： [2,5,8]
[7,8,9] [3,6,9]
C.对于向量而言（a0,a1,a2…an-1,an）—>(an,an-1…a2,a1,a0)
2.矩阵转置的操作（a.T）
import numpy as np
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
print("原始矩阵为：",a)
b=a.T
print("转置后的矩阵为：",b)
原始矩阵为： [[1 2 3]
[4 5 6]
[7 8 9]]
转置后的矩阵为： [[1 4 7]
[2 5 8]
[3 6 9]]
练习题目
1.编写一个从30到50的所有偶数的数组
tips：np.arange(30,50,2) start=30 stop=50 step=2
import numpy as np
a=np.arange(30,50,2)
print(a)
[30 32 34 36 38 40 42 44 46 48]
2.从给定数组中提取奇数
tips：a%2==1
import numpy as np
a=np.array([[1,2,3],[34,56,78],[22,55,77]])
print(a[a%2==1])
[ 1 3 55 77]
