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，从10^1—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]