python的numpy库------数组（基础）
参考“李阳《Python数据之道》”，
一、numpy数据类型
import numpy as np
print(np.uint(120.56)) #输出120
print(np.float(102)) #输出102.0
二、 创建数组的方法
使用array方法创建
注释方式，单行“#”，多行“ ‘’’ ‘’’ ”,单行程序多行显示，每行末尾使用“ \ ”连接，多行程序单行显示使用“；”隔开
import numpy as np
#下面需要注意的是最外层的括号是array方法的，
#它的参数可以是元组或列表，np.array([1,3,5,4,6]),也可创建一个数组
#因此里边的括号表示参数是元组
a=np.array((1,3,5,4,6))
print(a) #显示[1,3,5,4,6]
#下面的二维数组,主义的是里面是一个以列表作为元素的列表
#也可以用元组，将中括号换成小括号即可，但注意最后位置和开始位置有三个小括号
b=np.array([[1,4,3,5],[4,4,6,3]])
'''输出显示为[[1 4 3 5] #该位置结尾是否有逗号可能与python版本有关系
[4 4 6 3]] '''
print(b)
使用arange创建数组
import numpy as np
arr1 = np.arange(5)
print(arr1) #显示[0 1 2 3 4]
arr2 = np.array([np.arange(3),np.arange(3)])
print(arr2)
'''显示为 [[0 1 2]
[0 1 2]] '''
使用arange和reshape创建数组
import numpy as np
'''注意的是必须2*3*4=24 '''
arr1 = np.arange(24).reshape(2,3,4)
print(arr1)
'''输出显示为
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
'''
数组的属性
dtype属性：指定数组的数据类型
import numpy as np
print(np.arange(1,4,dtype=float))
#显示为[. 2. 3.]
print(np.arange(4,dtype=complex))
print(np.arange(4,dtype="D"))
#上面两条输出都是[0.+0.j 1.+0.j 2.+0.j 3.+0.j]
#字母D相当于复数标识
ndim属性：数组的维数
shape属性：数组对象的尺寸，对于矩阵指的是n行m列
size属性：保存元素的数量
itemsize属性：返回数组中各个元素所占用的字节大小
nbytes属性：整个数组所需的字节数量
b=np.array([[1,2,3],[8,5,1]])
print(b.ndim) #输出2
print(b.shape) #输出为（2，3）
print(b.size) #输出为6
print(b.itemsize) #输出4
print(b.nbytes) #输出24,等于size属性乘以itemsize的值
T属性：数组的转置
c=np.arange(24).T #创建4行6列的数组
print(c)
'''结果
[[ 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 6 12 18]
[ 1 7 13 19]
[ 2 8 14 20]
[ 3 9 15 21]
[ 4 10 16 22]
[ 5 11 17 23]] '''
real和imag属性：复数的实部和虚部
d=np.array([1.2+2.0j,2.0+3.0j])
print(d.real) #[1.2 2. ]
print(d.imag) #[2. 3.]
flat 属性，返回一个 numpy.flatiter 对象，即可迭代的对象
将数组分解成可连续访问的元素
import numpy as np
a=np.arange(6).reshape(2,3)
print (a)
'''
结果为：
[[0 1 2]
[3 4 5]]
'''
b=a.flat
for x in b :
print (x,end="")
'''
结果为：
012345
'''
对数组flat属性赋值，相当于将该数组全部用这个值替换
import numpy as np
a=np.arange(6).reshape(2,3)
#此处输出同上例
a.flat=7
for x in a :
print (x)
'''
结果为：
[7 7 7]
[7 7 7]
'''
多维数组的切片
一维数组的切片同列表
二维数组的切片
在数组的中括号中，第一个是第一维度的范围，第二个切片为第二维度的切片
import numpy as np
a=np.arange(12).reshape(3,4)
print(a[0:3,0:4])
'''
第一个切片是第一个维度的范围
第二个切片是第二个维度的范围
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
'''
数组形状转换
reshape()和resize()
resize()改变数组本身，而reshape（）是将数组拷贝后变化返回
import numpy as np
a=np.arange(12)
print(a.reshape(3,4))
print(a)
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[ 0 1 2 3 4 5 6 7 8 9 10 11]
reshape虽然返回数组a改变后的形式，但并不是将a改变
'''
print("*"*50)
b=np.arange(12)
print(b.resize(3,4)) # None
print(b)
'''
说明resize直接改变了数组本身，而并未有返回值
None
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
'''
ravel()和flatten()
功能：将多维数组转换为一维数组，但自己在python3.8.0，通过测试输出了id()值也没有什么变化，都不改变原数组的形式。但在对每一个元素存取的时候ravel()使得原本的数据发生变化，但flatten()时，原数组未发生变化
import numpy as np
a=np.arange(12).reshape(3,4)
print(a)
a.ravel()[2]=33 #此处存取发生变化
print(a)
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[[ 0 1 33 3]
[ 4 5 6 7]
[ 8 9 10 11]]
'''
print("*"*50)
b=np.arange(12).reshape(3,4)
print(b)
b.flatten()[2]=33 #此处存取发生变化
print(b)
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
'''
'
另外几种指定数组形式
使用元组指定
使用shape和元组
import numpy as np
a=np.arange(12)
a.shape=(2,6)
print(a)
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
'''
通过transpose()函数实现转置
不改变原来数组的形式
import numpy as np
a=np.arange(12)
a.shape=(2,6)
print(a.transpose())
'''
[[ 0 6]
[ 1 7]
[ 2 8]
[ 3 9]
[ 4 10]
[ 5 11]]
'''
print(a)
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
'''
堆叠数组
数组乘以数：
表示每一个元素都相乘
import numpy as np
a=np.arange(12)
a.shape=(2,6)
b=a*2 #将数组中的每一个都执行相同变化
print(a)
print("*"*30)
print(b)
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
******************************
[[ 0 2 4 6 8 10]
[12 14 16 18 20 22]]
'''
数组数据的水平连接
hstack()函数和column_stack()
注意：函数中的参数是一个参数或元组
使用形式：nmpy.hstack((数组名1，数组名2))
#将两个数组以元组的形式传入
import numpy as np
a=np.arange(12)
a.shape=(2,6)
b=a*2 #将数组中的每一个都执行相同变化
print(a)
print("*"*30)
print(b)
print("*"*30)
print(np.hstack((a,b)))
# print(np.column_stack((a,b)))与上一行作用一样
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
******************************
[[ 0 2 4 6 8 10]
[12 14 16 18 20 22]]
******************************
[[ 0 1 2 3 4 5 0 2 4 6 8 10]
[ 6 7 8 9 10 11 12 14 16 18 20 22]]
'''
垂直连接
vstack()同row_stack()
注意：函数中的参数是一个参数或元组
import numpy as np
a=np.arange(12)
a.shape=(2,6)
b=a*2 #将数组中的每一个都执行相同变化
print(a)
print("*"*30)
print(b)
print("*"*30)
print(np.vstack((a,b)))
# print(np.row_stack((a,b)))
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
******************************
[[ 0 2 4 6 8 10]
[12 14 16 18 20 22]]
******************************
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[ 0 2 4 6 8 10]
[12 14 16 18 20 22]]
'''
使用concatenate()方法中的axis确定叠加方向
axis=1;沿水平方向叠加
axis=0；沿垂直方向叠加
import numpy as np
a=np.arange(12)
a.shape=(2,6)
b=a*2 #将数组中的每一个都执行相同变化
print(a)
print("*"*30)
print(b)
print("*"*30)
print(np.concatenate((a,b),axis=1))
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
******************************
[[ 0 2 4 6 8 10]
[12 14 16 18 20 22]]
******************************
[[ 0 1 2 3 4 5 0 2 4 6 8 10]
[ 6 7 8 9 10 11 12 14 16 18 20 22]]
'''
深度叠加dstack()
使用深度叠加会使数组的维数增加一个维度，将数组的每一个位置相同的数组合并看着更深一层，
下例中，两个（2，6）的数组合并成（2，6，2）的数组，而最后一个2根据合并的数组的个数决定
import numpy as np
a=np.arange(12)
a.shape=(2,6)
b=a*2 #将数组中的每一个都执行相同变化
print(a)
print("*"*30)
print(b)
print("*"*30)
print(np.dstack((a,b)))
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
******************************
[[ 0 2 4 6 8 10]
[12 14 16 18 20 22]]
******************************
[[[ 0 0]
[ 1 2]
[ 2 4]
[ 3 6]
[ 4 8]
[ 5 10]]
[[ 6 12]
[ 7 14]
[ 8 16]
[ 9 18]
[10 20]
[11 22]]]
'''
数组的拆分
与合并很像，有hsplit(),vsplit(),split(),dsplit()；分别指水平拆分，垂直拆分，使用axis的赋值拆分，深度拆分
水平拆分：hsplit()等价于split(,axis=1)
对于二维数组，将列平均分成几份，对应的列作为一个数组，每个元素是每一行上的元素所组成
结果就将一个数组分成了几个数组
import numpy as np
a=np.arange(12).reshape(2,6)
print(a)
print("*"*30)
print(np.hsplit(a,3))
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
******************************
[array([[0, 1],
[6, 7]]), array([[2, 3],
[8, 9]]), array([[ 4, 5],
[10, 11]])]
'''
垂直拆分：vsplit()等价于split(,axis=0)
对于二维，将行数经行平分，将平分后的行作为一个数组，但每一行在显示时会有回车换行的情况
import numpy as np
a=np.arange(12).reshape(6,2)
print(a)
print("*"*30)
print(np.vsplit(a,3))
'''
====================
[[ 0 1]
[ 2 3]
[ 4 5]
[ 6 7]
[ 8 9]
[10 11]]
******************************
[array([[0, 1],
[2, 3]]), array([[4, 5],
[6, 7]]), array([[ 8, 9],
[10, 11]])]
'''
深度分割dslipt()
该方式只能使用到三维或更高维的数组中，而且需要能够平均分割
import numpy as np
a=np.arange(12).reshape(2,2,3)
print(a)
print("*"*30)
print(np.dsplit(a,3))
'''
[[[ 0 1 2]
[ 3 4 5]]
[[ 6 7 8]
[ 9 10 11]]]
******************************
[array([[[0],
[3]],
[[6],
[9]]]), array([[[ 1],
[ 4]],
[[ 7],
[10]]]), array([[[ 2],
[ 5]],
[[ 8],
[11]]])]
'''
数组的类型转换
将数组转换成list，使用tolist()
import numpy as np
a=np.arange(12).reshape(3,4)
print(a)
print("*"*30)
print(a.tolist())
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
******************************
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
'''
将数组中的元素指定类型，astype()函数
import numpy as np
a=np.arange(12).reshape(3,4)
print(a)
print("*"*30)
print(a.astype(float))
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
******************************
[[ 0. 1. 2. 3.]
[ 4. 5. 6. 7.]
[ 8. 9. 10. 11.]]
'''
numpy常用统计函数
常用函数，使用时需要指定axis的值，否之默认整个数组
np.sum() ，返回求和
np.mean() ，返回均值
np.max() ，返回最大值
np.min() ，返回最小值
np.ptp() ，数组沿指定轴返回最大值减去最小值，即（ max-min ）
np.std() ，返回标准偏差（ standarddeviation ）
np.var() ，返回方差（ variance ）
np.cumsum() ，返回累加值
np.cumprod() ，返回累乘积值
import numpy as np
a=np.arange(12).reshape(2,6)
print(np.mean(a,axis=1))
print(np.sum(a))
print(np.max(a))
print(np.min(a))
print(np.ptp(a)) #可以指定轴的极差
print(np.std(a)) #标准差（standard deviation）
print(np.var(a)) #方差（variance）
print(np.cumsum(a)) #累加值
print(np.cumprod(a)) #累乘值
'''
[2.5 8.5]
66
11
0
11
3.452052529534663
11.916666666666666
[ 0 1 3 6 10 15 21 28 36 45 55 66]
[0 0 0 0 0 0 0 0 0 0 0 0]
'''
数组的广播
数组跟一个标量进行数学运算时，标量需要根据数组的形状进行扩展，然后执行运算。这个扩展的过程称为 “ 广播（ broadcasting ）