python numpy数组(numpy.array函数)

- Numpy是Python语言中做科学计算的基础库。重在数值计算，也是大部分Python科学计算库的基础，多用于大型、多维数组上执行的数值运算

- 使用np.array()创建
- 使用创建
-np的routines函数创建

使用array()创建一个一维数组

import numpy as np
arr = np.array([1,2,3])#一维数组,dtype=''表示数组元素类型
arr

array([1, 2, 3])

多维数组

import numpy as np
arr = np.array([[1,2,3],[4,5,6]])#注意整理有一个[]
arr

array([[1, 2, 3],
       [4, 5, 6]])

数组和列表的区别是什么?

数组中存储的数据元素类型必须是统一类型优先级：

字符串>浮点型>整数

arr=np.array([1,2.2,'three'])#不同类型元素，数组输出后强制转换成字符串类型
arr

array(['1', '2.2', 'three'], dtype=' 
将外部的图片读取到numpy数组中，改变数组元素的数值查看对原始图片的影响
 
import matplotlib.pyplot as plt 
#当matplotlib读取png的时候，没有alpha通道，因此要设置参数
img_arr = plt.imread('./1.png',0)# 将文件中的图像读取到数组中，返回的数组，数组中装载的就是图片内容
plt.imshow(img_arr)#用于绘制热图，将numpy数组进行可视化展示
 

 
img_arr =img_arr - 100 #将每一个数组元素都减去100
plt.imshow(img_arr)
 

 
 
np.ones(shape=(3,4))#创造三行4列的数组，数组元素全为1
 
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])
 
np.linspace(0,100,num = 20)#一维的等差数列数组，num表示个数
 
array([  0.        ,   5.26315789,  10.52631579,  15.78947368,
        21.05263158,  26.31578947,  31.57894737,  36.84210526,
        42.10526316,  47.36842105,  52.63157895,  57.89473684,
        63.15789474,  68.42105263,  73.68421053,  78.94736842,
        84.21052632,  89.47368421,  94.73684211, 100.        ])
 
np.arange(10,50,step=2)#一维等差数列
 
array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42,
       44, 46, 48])
 
np.random.randint(0,100,size=(5,3))#随机数组，5行3列
 
array([[64, 47, 57],
       [15, 22, 12],
       [23, 35, 18],
       [72, 90, 45],
       [76, 13, 89]])
 
二、numpy属性
 
arr = np.random.randint(0,100,size=(5,6))
arr
 
array([[51, 65, 35, 74, 46, 14],
       [ 1, 31, 78, 51, 36,  1],
       [93,  3, 45,  7, 70, 46],
       [84, 59, 72,  7, 80, 48],
       [38, 58, 30, 96, 38, 47]])
 
arr.shape#返回数组的形状，几行几列
 
(5, 6)
 
arr.ndim#返回数组维度
 
2
 
arr.size#返回数字元素个数
 
30
 
arr.dtype#返回数组元素类型
 
dtype('int32')
 
type(arr)#数组的数据类型
 
numpy.ndarray
 
numpy的数据类型 
arr = np.array([1,2,3])
arr.dtype
 
dtype('int32')
 
#创建一个数组，指定数组元素类型为int32
arr = np.array([1,2,3],dtype='int32')
arr.dtype
 
dtype('int32')
 
arr.dtype ='uint8'#修改数组的元素类型
 
arr.dtype
 
dtype('uint8')
 
(三)numpy的索引和切片操作（重点）
 
索引操作和列表同理 
arr = np.random.randint(1,100,size=(5,6))
arr
 
array([[96, 53, 70, 27, 46, 66],
       [ 7, 11, 22, 97, 64, 80],
       [33, 46, 41, 62, 30, 54],
       [17, 75, 58, 30,  7, 25],
       [41, 21, 92, 73, 45, 61]])
 
arr[1]#去除numpy数组中的下标为1的行数据
 
array([ 7, 11, 22, 97, 64, 80])
 
arr[[1,3,4]]#去除多行
 
array([[ 7, 11, 22, 97, 64, 80],
       [17, 75, 58, 30,  7, 25],
       [41, 21, 92, 73, 45, 61]])
 
#切除arr数组的前两行数据
arr[0:2]#arr[行切片]
 
array([[96, 53, 70, 27, 46, 66],
       [ 7, 11, 22, 97, 64, 80]])
 
#切出arr数组中的前两列
arr[:,0:2]#arr[行切片，列切片]
 
array([[96, 53],
       [ 7, 11],
       [33, 46],
       [17, 75],
       [41, 21]])
 
#切出前两行的前两列数据
arr[0:2,0:2]
 
array([[96, 53],
       [ 7, 11]])
 
arr
 
array([[96, 53, 70, 27, 46, 66],
       [ 7, 11, 22, 97, 64, 80],
       [33, 46, 41, 62, 30, 54],
       [17, 75, 58, 30,  7, 25],
       [41, 21, 92, 73, 45, 61]])
 
#将数组的行倒置
arr[::-1]
 
array([[41, 21, 92, 73, 45, 61],
       [17, 75, 58, 30,  7, 25],
       [33, 46, 41, 62, 30, 54],
       [ 7, 11, 22, 97, 64, 80],
       [96, 53, 70, 27, 46, 66]])
 
#将数组的列倒置
arr[:,::-1]
 
array([[66, 46, 27, 70, 53, 96],
       [80, 64, 97, 22, 11,  7],
       [54, 30, 62, 41, 46, 33],
       [25,  7, 30, 58, 75, 17],
       [61, 45, 73, 92, 21, 41]])
 
#将所有元素倒置
arr[::-1,::-1]
 
array([[61, 45, 73, 92, 21, 41],
       [25,  7, 30, 58, 75, 17],
       [54, 30, 62, 41, 46, 33],
       [80, 64, 97, 22, 11,  7],
       [66, 46, 27, 70, 53, 96]])
 
#将一张图片进行左右翻转
img_arr = plt.imread('./1.png',0)
plt.imshow(img_arr)
 

 
 
img_arr.shape
 
(700, 700, 3)
 
#列倒置——左右翻转
plt.imshow(img_arr[:,::-1,:])#img_arr[行，列，颜色]
 

 
 
#图片上下翻转——行倒置
plt.imshow(img_arr[::-1,:,:])
 

 
 
#图片裁剪的功能
plt.imshow(img_arr[66:200,78:300,:])
 

 
 
变形reshape
 
arr#是一个5行6列的二维数组,一共30个元素
 
array([[96, 53, 70, 27, 46, 66],
       [ 7, 11, 22, 97, 64, 80],
       [33, 46, 41, 62, 30, 54],
       [17, 75, 58, 30,  7, 25],
       [41, 21, 92, 73, 45, 61]])
 
#将二维的数字变形成1维
arr_1 = arr.reshape((30,))#不能多不能少
arr_1
 
array([96, 53, 70, 27, 46, 66,  7, 11, 22, 97, 64, 80, 33, 46, 41, 62, 30,
       54, 17, 75, 58, 30,  7, 25, 41, 21, 92, 73, 45, 61])
 
#将一维变形成多维
arr_1.reshape((6,5))
 
array([[96, 53, 70, 27, 46],
       [66,  7, 11, 22, 97],
       [64, 80, 33, 46, 41],
       [62, 30, 54, 17, 75],
       [58, 30,  7, 25, 41],
       [21, 92, 73, 45, 61]])
 
级联操作
 
将多个numpy数组进行横向或纵向的拼接axis 轴向的理解 
  
0：列，y轴方向，竖直方向1：行，x轴方向，水平方向 问题： 
  
级联的两个数组维度一样，但是行列个数不一样会如何？  
import numpy as np
arr = np.random.randint(0,100,size=(5,6))
arr
 
array([[56, 73, 72, 11, 46, 22],
       [13, 10, 84, 22, 52, 56],
       [82, 42, 93, 58, 83,  1],
       [94, 25, 56, 93, 24, 38],
       [59, 62, 87, 86, 19, 51]])
 
np.concatenate((arr,arr),axis = 0)#axis = 0,进行列与列的拼接
 
array([[56, 73, 72, 11, 46, 22],
       [13, 10, 84, 22, 52, 56],
       [82, 42, 93, 58, 83,  1],
       [94, 25, 56, 93, 24, 38],
       [59, 62, 87, 86, 19, 51],
       [56, 73, 72, 11, 46, 22],
       [13, 10, 84, 22, 52, 56],
       [82, 42, 93, 58, 83,  1],
       [94, 25, 56, 93, 24, 38],
       [59, 62, 87, 86, 19, 51]])
 
np.concatenate((arr,arr),axis = 1)#axis = 0,进行行与行的拼接
 
array([[56, 73, 72, 11, 46, 22, 56, 73, 72, 11, 46, 22],
       [13, 10, 84, 22, 52, 56, 13, 10, 84, 22, 52, 56],
       [82, 42, 93, 58, 83,  1, 82, 42, 93, 58, 83,  1],
       [94, 25, 56, 93, 24, 38, 94, 25, 56, 93, 24, 38],
       [59, 62, 87, 86, 19, 51, 59, 62, 87, 86, 19, 51]])
 
arr_3 = np.concatenate((img_arr,img_arr,img_arr),axis = 1)
plt.imshow(arr_3)
 

 
 
常用的聚合操作 
sum,max,min,mean 
arr
 
array([[56, 73, 72, 11, 46, 22],
       [13, 10, 84, 22, 52, 56],
       [82, 42, 93, 58, 83,  1],
       [94, 25, 56, 93, 24, 38],
       [59, 62, 87, 86, 19, 51]])
 
arr.sum(axis = 1)#求数组每一行的值
 
array([280, 237, 359, 330, 364])
 
arr.max(axis = 1)#求每一行的最大值
 
array([73, 84, 93, 94, 87])
 
常用的数学函数 
Numpy 提供了标准的三角函数：sin(),cos(),tan()numpy.around(a,decimals)函数返回指定数字的四舍五入值 
  
参数说明： 
    
a:数组decimals：舍入的小数位数。默认值为0。如果为负，整数将四舍五入到小数点左侧的位置   
np.sin(arr)
 
array([[-0.521551  , -0.67677196,  0.25382336, -0.99999021,  0.90178835,
        -0.00885131],
       [ 0.42016704, -0.54402111,  0.73319032, -0.00885131,  0.98662759,
        -0.521551  ],
       [ 0.31322878, -0.91652155, -0.94828214,  0.99287265,  0.96836446,
         0.84147098],
       [-0.24525199, -0.13235175, -0.521551  , -0.94828214, -0.90557836,
         0.29636858],
       [ 0.63673801, -0.7391807 , -0.82181784, -0.92345845,  0.14987721,
         0.67022918]])
 
np.around(3.14)#四舍五入
 
3.0
 
np.around(3.14,-1)#decimals：舍入的小数位数。默认值为0。如果为负，整数将四舍五入到小数点左侧的位置
 
0.0
 
常用的统计函数 
 
numpy.amin() 和numpy.amax()，用于计算数组中的元素沿指定轴的最小、最大值。
  
numpy.ptp():计算数组中元素最大值与最小值的差(最大值 - 最小值)。
  
numpy.median() 函数用于计算数组 a 中元素的中位数(中值)
  
标准差std():标准差是一组数据平均值分散程度的一种度量。所有数据与均值的差的平方和除以元素个数开根号
 
  
 
公式：std = sqrt(mean((x - x.mean())**2))
  
如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。
   
方差var()：统计中的方差(样本方差)是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。换句话说，标准差是方差的平方根。
  
np.ptp(arr,axis=0)计算数组中每列元素最大值与最小值的差
 
array([81, 63, 37, 82, 64, 55])
 
arr[1].std()#一组数据的标准差
 
26.731691553909066
 
arr[1].var()#方差
 
714.5833333333334
 
矩阵相关 
 
Numpy中包含了一个矩阵库numpy.matlib,该模块中的函数返回的是一个矩阵，而不是ndarray对象。一个矩阵是一个由行列元祖排列成的矩形阵列
  
numpy.matlib.identity()函数返回给定大小的单位矩阵。单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为1，除此以外全都为0
  
np.eye(6)#eye返回一个标准的单位矩阵
 
array([[1., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0.],
       [0., 0., 0., 1., 0., 0.],
       [0., 0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 0., 1.]])
 
转置矩阵 
  
.T  
arr
 
array([[56, 73, 72, 11, 46, 22],
       [13, 10, 84, 22, 52, 56],
       [82, 42, 93, 58, 83,  1],
       [94, 25, 56, 93, 24, 38],
       [59, 62, 87, 86, 19, 51]])
 
arr.T#行列转置
 
array([[56, 13, 82, 94, 59],
       [73, 10, 42, 25, 62],
       [72, 84, 93, 56, 87],
       [11, 22, 58, 93, 86],
       [46, 52, 83, 24, 19],
       [22, 56,  1, 38, 51]])
 
矩阵相乘 
.dot() 
a1 = np.array([[2,1],[4,3]])
a2 = np.array([[1,2],[1,0]])
 
np.dot(a1,a2)
 
array([[3, 4],
       [7, 8]])