什么是numpy
一个在Python中做科学计算的基础库,重在数值计算,也是大部分PYTHON科学计算库的基础库,多用于在大型、多维数组上执行数值运算。
创建数组
np.array()
(数据类型 type:ndarray)
# 多维数组ndarray-数据类型
import numpy as np
ar = np.array([1,2,3,4,5,6,7])
print(ar) # 输出数组,注意数组的格式:中括号,元素之间没有逗号(和列表区分)
print(ar.ndim) # 输出数组维度的个数(轴数),或者说“秩”,维度的数量也称rank
print(ar.shape) # 数组的维度,对于n行m列的数组,shape为(n,m)
print(ar.size) # 数组的元素总数,对于n行m列的数组,元素总数为n*m
print(ar.dtype) # 数组中元素的类型,类似type()(注意了,type()是函数,.dtype是方法)
#也可以在 np.array([1,2,3,4,5,6,7], dtype=np.bool)指定dtype类型
print(ar.itemsize) # 数组中每个元素的字节大小,int32l类型字节为4,float64的字节为8
print(ar.data) # 包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性。
ar # 交互方式下输出,会有array(数组)
# 数组的基本属性
# ① 数组的维数称为秩(rank),一维数组的秩为1,二维数组的秩为2,以此类推
# ② 在NumPy中,每一个线性的数组称为是一个轴(axes),秩其实是描述轴的数量:
# 比如说,二维数组相当于是两个一维数组,其中第一个一维数组中每个元素又是一个一维数组
# 所以一维数组就是NumPy中的轴(axes),第一个轴相当于是底层数组,第二个轴是底层数组里的数组。
# 而轴的数量——秩,就是数组的维数。
-----------------------------------------------
[1 2 3 4 5 6 7]
1
(7,)
7
int32
4
<memory at 0x00000255B60EBC40>
# 创建数组:array()函数,括号内可以是列表、元祖、数组、生成器等
ar1 = np.array(range(10)) # 整型
ar2 = np.array([1,2,3.14,4,5]) # 浮点型
ar3 = np.array([[1,2,3],('a','b','c')]) # 二维数组:嵌套序列(列表,元祖均可)
ar4 = np.array([[1,2,3],('a','b','c','d')]) # 注意嵌套序列数量不一会怎么样
print(ar1,type(ar1),ar1.dtype)
print(ar2,type(ar2),ar2.dtype)
print(ar3,ar3.shape,ar3.ndim,ar3.size) # 二维数组,共6个元素
print(ar4,ar4.shape,ar4.ndim,ar4.size) # 一维数组,共2个元素
-----------------------------------------
[0 1 2 3 4 5 6 7 8 9] <class 'numpy.ndarray'> int32
[1. 2. 3.14 4. 5. ] <class 'numpy.ndarray'> float64
[['1' '2' '3']
['a' 'b' 'c']] (2, 3) 2 6
[list([1, 2, 3]) ('a', 'b', 'c', 'd')] (2,) 1 2 #会成为一维数组
np.arange()
语法:**np.arange([start],stop[,step],dtype=None)**
参数:dtype 用于指定数据类型
# 创建数组:arange(),类似range(),在给定间隔内返回均匀间隔的值。
print(np.arange(10)) # 返回0-9,整型
print(np.arange(10.0)) # 返回0.0-9.0,浮点型
print(np.arange(5,12)) # 返回5-11
print(np.arange(5.0,12,2)) # 返回5.0-12.0,步长为2
print(np.arange(10000)) # 如果数组太大而无法打印,NumPy会自动跳过数组的中心部分,并只打印边角:
---------------------------------------
[0 1 2 3 4 5 6 7 8 9]
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
[ 5 6 7 8 9 10 11]
[ 5. 7. 9. 11.]
[ 0 1 2 ... 9997 9998 9999]
np.linspace()
# 创建数组:linspace():返回在间隔[开始,停止]上计算的num个均匀间隔的样本。
ar1 = np.linspace(2.0, 3.0, num=5)
ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)
ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)
print(ar1,type(ar1))
print(ar2)
print(ar3,type(ar3))
# numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# start:起始值,stop:结束值
# num:生成样本数,默认为50
# endpoint:如果为真,则停止是最后一个样本。否则,不包括在内。默认值为True。
# retstep:如果为真,返回(样本,步骤),其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖,第一个元素为array,第二个为步长实际值
----------------------------------------
[2. 2.25 2.5 2.75 3. ] <class 'numpy.ndarray'>
[2. 2.2 2.4 2.6 2.8]
(array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) <class 'tuple'>
np.zeros()
# 创建数组:zeros()/zeros_like()/ones()/ones_like()
ar1 = np.zeros(5)
ar2 = np.zeros((2,2), dtype = np.int)
print(ar1,ar1.dtype)
print(ar2,ar2.dtype)
print('------')
# numpy.zeros(shape, dtype=float, order='C'):返回给定形状和类型的新数组,用零填充。
# shape:数组纬度,二维以上需要用(),且输入参数为整数
# dtype:数据类型,默认numpy.float64
# order:是否在存储器中以C或Fortran连续(按行或列方式)存储多维数据。
ar3 = np.array([list(range(5)),list(range(5,10))])
ar4 = np.zeros_like(ar3)
print(ar3)
print(ar4)
print('------')
# 返回具有与给定数组相同的形状和类型的零数组,这里ar4根据ar3的形状和dtype创建一个全0的数组
ar5 = np.ones(9)
ar6 = np.ones((2,3,4))
ar7 = np.ones_like(ar3)
print(ar5)
print(ar6)
print(ar7)
# ones()/ones_like()和zeros()/zeros_like()一样,只是填充为1
------------------------------
[0. 0. 0. 0. 0.] float64
[[0 0]
[0 0]] int32
------
[[0 1 2 3 4]
[5 6 7 8 9]]
[[0 0 0 0 0]
[0 0 0 0 0]]
------
[1. 1. 1. 1. 1. 1. 1. 1. 1.]
[[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]]
[[1 1 1 1 1]
[1 1 1 1 1]]
np.eye()
# 创建数组:eye()
print(np.eye(5))
# 创建一个正方的N*N的单位矩阵,对角线值为1,其余为0
-------------------------
[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]
数组的复制
ar1 = np.arange(10)
ar2 = ar1
print(ar2 is ar1)
ar1[2] = 9
print(ar1,ar2)
# 回忆python的赋值逻辑:指向内存中生成的一个值 → 这里ar1和ar2指向同一个值,所以ar1改变,ar2一起改变
ar3 = ar1.copy()
print(ar3 is ar1)
ar1[0] = 9
print(ar1,ar3)
# copy方法生成数组及其数据的完整拷贝
# 再次提醒:.T/.reshape()/.resize()都是生成新的数组!!!
-----------------------------------
True
[0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
False
[9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
数组堆叠
a = np.arange(5) # a为一维数组,5个元素
b = np.arange(5,9) # b为一维数组,4个元素
ar1 = np.hstack((a,b)) # 注意:((a,b)),这里形状可以不一样
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
a = np.array([[1],[2],[3]]) # a为二维数组,3行1列
b = np.array([['a'],['b'],['c']]) # b为二维数组,3行1列
ar2 = np.hstack((a,b)) # 注意:((a,b)),这里形状必须一样
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
print('-----')
# numpy.hstack(tup):水平(按列顺序)堆叠数组
a = np.arange(5)
b = np.arange(5,10)
ar1 = np.vstack((a,b))
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
a = np.array([[1],[2],[3]])
b = np.array([['a'],['b'],['c'],['d']])
ar2 = np.vstack((a,b)) # 这里形状可以不一样
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
print('-----')
# numpy.vstack(tup):垂直(按列顺序)堆叠数组
a = np.arange(5)
b = np.arange(5,10)
ar1 = np.stack((a,b))
ar2 = np.stack((a,b),axis = 1)
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
print(ar2,ar2.shape)
# numpy.stack(arrays, axis=0):沿着新轴连接数组的序列,形状必须一样!
# 重点解释axis参数的意思,假设两个数组[1 2 3]和[4 5 6],shape均为(3,0)
# axis=0:[[1 2 3] [4 5 6]],shape为(2,3)
# axis=1:[[1 4] [2 5] [3 6]],shape为(3,2)
--------------------------------------------
[0 1 2 3 4] (5,)
[5 6 7 8] (4,)
[0 1 2 3 4 5 6 7 8] (9,)
[[1]
[2]
[3]] (3, 1)
[['a']
['b']
['c']] (3, 1)
[['1' 'a']
['2' 'b']
['3' 'c']] (3, 2)
-----
[0 1 2 3 4] (5,)
[5 6 7 8 9] (5,)
[[0 1 2 3 4]
[5 6 7 8 9]] (2, 5)
[[1]
[2]
[3]] (3, 1)
[['a']
['b']
['c']
['d']] (4, 1)
[['1']
['2']
['3']
['a']
['b']
['c']
['d']] (7, 1)
-----
[0 1 2 3 4] (5,)
[5 6 7 8 9] (5,)
[[0 1 2 3 4]
[5 6 7 8 9]] (2, 5)
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]] (5, 2)
数组拆分
ar = np.arange(16).reshape(4,4)
ar1 = np.hsplit(ar,2)
print(ar)
print(ar1,type(ar1))
# numpy.hsplit(ary, indices_or_sections):将数组水平(逐列)拆分为多个子数组 → 按列拆分
# 输出结果为列表,列表中元素为数组
ar2 = np.vsplit(ar,4)
print(ar2,type(ar2))
# numpy.vsplit(ary, indices_or_sections)::将数组垂直(行方向)拆分为多个子数组 → 按行拆
Numpy数据类型
支持的原始类型与 C 中的原始类型紧密相关:
Numpy 的类型 | C 的类型 | 描述 |
---|---|---|
np.bool | bool | 存储为字节的布尔值(True或False) |
np.byte | signed char | 平台定义 |
np.ubyte | unsigned char | 平台定义 |
np.short | short | 平台定义 |
np.ushort | unsigned short | 平台定义 |
np.intc | int | 平台定义 |
np.uintc | unsigned int | 平台定义 |
np.int_ | long | 平台定义 |
np.uint | unsigned long | 平台定义 |
np.longlong | long long | 平台定义 |
np.ulonglong | unsigned long long | 平台定义 |
np.half / np.float16 | 半精度浮点数:符号位,5位指数,10位尾数 | |
np.single | float | 平台定义的单精度浮点数:通常为符号位,8位指数,23位尾数 |
np.double | double | 平台定义的双精度浮点数:通常为符号位,11位指数,52位尾数。 |
np.longdouble | long double | 平台定义的扩展精度浮点数 |
np.csingle | float complex | 复数,由两个单精度浮点数(实部和虚部)表示 |
np.cdouble | double complex | 复数,由两个双精度浮点数(实部和虚部)表示。 |
np.clongdouble | long double complex | 复数,由两个扩展精度浮点数(实部和虚部)表示。 |
由于其中许多都具有依赖于平台的定义,因此提供了一组固定大小的别名:
Numpy 的类型 | C 的类型 | 描述 |
---|---|---|
np.int8 | int8_t | 字节(-128到127) |
np.int16 | int16_t | 整数(-32768至32767) |
np.int32 | int32_t | 整数(-2147483648至2147483647) |
np.int64 | int64_t | 整数(-9223372036854775808至9223372036854775807) |
np.uint8 | uint8_t | 无符号整数(0到255) |
np.uint16 | uint16_t | 无符号整数(0到65535) |
np.uint32 | uint32_t | 无符号整数(0到4294967295) |
np.uint64 | uint64_t | 无符号整数(0到18446744073709551615) |
np.intp | intptr_t | 用于索引的整数,通常与索引相同 ssize_t |
np.uintp | uintptr_t | 整数大到足以容纳指针 |
np.float32 | float | |
np.float64 / np.float_ | double | 请注意,这与内置python float的精度相匹配。 |
np.complex64 | float complex | 复数,由两个32位浮点数(实数和虚数组件)表示 |
np.complex128 / np.complex_ | double complex | 请注意,这与内置python 复合体的精度相匹配。 |
数据类型操作
指定数据类型
指定参数dtype
的值,详细参数如上表
>>> a = np.array([1,0,1,0],dtype=np.bool) #创建数组并指定数组类型
>>> a
array([ True, False, True, False])
>>> type(a)
<class 'numpy.ndarray'>
修改数据类型
使用astype()
方法
# 数组类型转换:.astype()
ar1 = np.arange(10,dtype=float)
print(ar1,ar1.dtype)
print('-----')
# 可以在参数位置设置数组类型
ar2 = ar1.astype(np.int32)
print(ar2,ar2.dtype)
print(ar1,ar1.dtype)
# a.astype():转换数组类型
# 注意:养成好习惯,数组类型用np.int32,而不是直接int32
修改不浮点型的小数
使用户round()
方法
>>> import random
>>> b = np.array([random.random() for i in range(10)]) #创建数组数据为浮点型
>>> b
array([0.21607487, 0.98672804, 0.19103604, 0.14028446, 0.41112204,
0.43134626, 0.53263665, 0.03445364, 0.42107014, 0.8563427 ])
>>> np.round(b,2) #保留小数2位
array([0.22, 0.99, 0.19, 0.14, 0.41, 0.43, 0.53, 0.03, 0.42, 0.86])
数据形状
查看数组形状:shape
修改数组形状:reshape(层数,行数,列数)
# 数组形状:.T/.reshape()/.resize()
ar1 = np.arange(10)
ar2 = np.ones((5,2))
print(ar1,'\n',ar1.T)
print(ar2,'\n',ar2.T)
print('------')
# .T方法:转置,例如原shape为(3,4)/(2,3,4),转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变
ar3 = ar1.reshape(2,5) # 用法1:直接将已有数组改变形状
ar4 = np.zeros((4,6)).reshape(3,8) # 用法2:生成数组后直接改变形状
ar5 = np.reshape(np.arange(12),(3,4)) # 用法3:参数内添加数组,目标形状
print(ar1,'\n',ar3)
print(ar4)
print(ar5)
print('------')
# numpy.reshape(a, newshape, order='C'):为数组提供新形状,而不更改其数据,所以元素数量需要一致!!
ar6 = np.resize(np.arange(5),(3,4))
print(ar6)
# numpy.resize(a, new_shape):返回具有指定形状的新数组,如有必要可重复填充所需数量的元素。
# 注意了:.T/.reshape()/.resize()都是生成新的数组!!!
-----------------------------------------
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
[[1. 1.]
[1. 1.]
[1. 1.]
[1. 1.]
[1. 1.]]
[[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]]
------
[0 1 2 3 4 5 6 7 8 9]
[[0 1 2 3 4]
[5 6 7 8 9]]
[[0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0.]]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
------
[[0 1 2 3]
[4 0 1 2]
[3 4 0 1]]
注意:修改数组形状时要注意seshape(行数,),seshape(行数,1),seshape(1,列数),的区别 flatten()方法修改为一维数组
>>> a.reshape(a.shape[0]*a.shape[1]) #计算数组元素个数,修改为一维数组
array([3, 4, 5, 6, 7, 8, 4, 5, 6, 7, 8, 9])
>>> a.reshape(a.shape[0]*a.shape[1],) #python3.8实测逗号可省略
array([3, 4, 5, 6, 7, 8, 4, 5, 6, 7, 8, 9])
>>> a.reshape(a.shape[0]*a.shape[1],1) #逗号后加1表示只有一列
array([[3],
[4],
[5],
[6],
[7],
[8],
[4],
[5],
[6],
[7],
[8],
[9]])
>>> a.reshape(1,a.shape[0]*a.shape[1]) #逗号前加1表示只有一行
array([[3, 4, 5, 6, 7, 8, 4, 5, 6, 7, 8, 9]])
>>> a.flatten() #使用flatten()方法
array([3, 4, 5, 6, 7, 8, 4, 5, 6, 7, 8, 9])
数组轴
在numpy中可以理解为方向,使用0,1,2…数字表示,对于一个一维数组,只有一个0轴,对于2维数组(shape(2,2)),有0轴和1轴,对于三维数组(shape(2,2, 3)),有0,1,2轴
Numpy读取数据
np.loadtxt(fname,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False)
Numpy位置转换
>>> t1= np.arange(24).reshape(4,6) #创建一维数组,修改为二维数组4行6列
>>> t1
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23]])
>>> t1.transpose() #行列转换
array([[ 0, 6, 12, 18],
[ 1, 7, 13, 19],
[ 2, 8, 14, 20],
[ 3, 9, 15, 21],
[ 4, 10, 16, 22],
[ 5, 11, 17, 23]])
>>> t1.T #行列转换,与transpose()方法相同
array([[ 0, 6, 12, 18],
[ 1, 7, 13, 19],
[ 2, 8, 14, 20],
[ 3, 9, 15, 21],
[ 4, 10, 16, 22],
[ 5, 11, 17, 23]])
t1.swapaxes(1,0) #交换轴
array([[ 0, 6, 12, 18],
[ 1, 7, 13, 19],
[ 2, 8, 14, 20],
[ 3, 9, 15, 21],
[ 4, 10, 16, 22],
[ 5, 11, 17, 23]])
数组索引和切片
# 基本索引及切片
ar = np.arange(20)
print(ar)
print(ar[4])
print(ar[3:6])
print('-----')
# 一维数组索引及切片
ar = np.arange(16).reshape(4,4)
print(ar, '数组轴数为%i' %ar.ndim) # 4*4的数组
print(ar[2], '数组轴数为%i' %ar[2].ndim) # 切片为下一维度的一个元素,所以是一维数组
print(ar[2][1]) # 二次索引,得到一维数组中的一个值
print(ar[1:3], '数组轴数为%i' %ar[1:3].ndim) # 切片为两个一维数组组成的二维数组
print(ar[2,2]) # 切片数组中的第三行第三列 → 10
print(ar[:2,1:]) # 切片数组中的1,2行、2,3,4列 → 二维数组
print('-----')
# 二维数组索引及切片
ar = np.arange(8).reshape(2,2,2)
print(ar, '数组轴数为%i' %ar.ndim) # 2*2*2的数组
print(ar[0], '数组轴数为%i' %ar[0].ndim) # 三维数组的下一个维度的第一个元素 → 一个二维数组
print(ar[0][0], '数组轴数为%i' %ar[0][0].ndim) # 三维数组的下一个维度的第一个元素下的第一个元素 → 一个一维数组
print(ar[0][0][1], '数组轴数为%i' %ar[0][0][1].ndim)
# **三维数组索引及切片
--------------------------------
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
4
[3 4 5]
-----
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]] 数组轴数为2
[ 8 9 10 11] 数组轴数为1
9
[[ 4 5 6 7]
[ 8 9 10 11]] 数组轴数为2
10
[[1 2 3]
[5 6 7]]
-----
[[[0 1]
[2 3]]
[[4 5]
[6 7]]] 数组轴数为3
[[0 1]
[2 3]] 数组轴数为2
[0 1] 数组轴数为1
1 数组轴数为0
Numpy中常用统计函数
- 获取最大值最小值的位置
- np.argmax(t,axis=0)
- np.argmin(t,axis=1)
- 创建一个全0的数组: np.zeros((3,4))
- 创建一个全1的数组:np.ones((3,4))
- 创建一个对角线为1的正方形数组(方阵):np.eye(3)
数组简单运算
ar = np.arange(6).reshape(2,3)
print(ar + 10) # 加法
print(ar * 2) # 乘法
print(1 / (ar+1)) # 除法
print(ar ** 0.5) # 幂
# 与标量的运算
print(ar.mean()) # 求平均值
print(ar.max()) # 求最大值
print(ar.min()) # 求最小值
print(ar.std()) # 求标准差
print(ar.var()) # 求方差
print(ar.sum(), np.sum(ar,axis = 0)) # 求和,np.sum() → axis为0,按列求和;axis为1,按行求和
print(np.sort(np.array([1,4,3,2,5,6]))) # 排序
---------------------------------------------------------
[[10 11 12]
[13 14 15]]
[[ 0 2 4]
[ 6 8 10]]
[[ 1. 0.5 0.33333333]
[ 0.25 0.2 0.16666667]]
[[ 0. 1. 1.41421356]
[ 1.73205081 2. 2.23606798]]
2.5
5
0
1.70782512766
2.91666666667
15 [3 5 7]
[1 2 3 4 5 6]
Numpy生成随机数
随机数生成
samples = np.random.normal(size=(4,4))
print(samples)
# 生成一个标准正太分布的4*4样本值
--------------------------------------
[[ 0.17875618 -1.19367146 -1.29127688 1.11541622]
[ 1.48126355 -0.81119863 -0.94187702 -0.13203948]
[ 0.11418808 -2.34415548 0.17391121 1.4822019 ]
[ 0.46157021 0.43227682 0.58489093 0.74553395]]
均匀分配
# numpy.random.rand(d0, d1, ..., dn):生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布
import matplotlib.pyplot as plt # 导入matplotlib模块,用于图表辅助分析
a = np.random.rand()
print(a,type(a)) # 生成一个随机浮点数
b = np.random.rand(4)
print(b,type(b)) # 生成形状为4的一维数组
c = np.random.rand(2,3)
print(c,type(c)) # 生成形状为2*3的二维数组,注意这里不是((2,3))
samples1 = np.random.rand(1000)
samples2 = np.random.rand(1000)
plt.scatter(samples1,samples2)
# 生成1000个均匀分布的样本值
plt.show()
----------------------------
0.2428951554890838 <class 'float'>
[0.81616687 0.40898948 0.92901508 0.34141405] <class 'numpy.ndarray'>
[[0.09740482 0.1495034 0.51564529]
[0.82057664 0.86850463 0.07113987]] <class 'numpy.ndarray'>
正态分布
# numpy.random.randn(d0, d1, ..., dn):生成一个浮点数或N维浮点数组 —— 正态分布
samples1 = np.random.randn(1000)
samples2 = np.random.randn(1000)
plt.scatter(samples1,samples2)
# randn和rand的参数用法一样
# 生成1000个正太的样本值
plt.show()