Numpy数据操作

最新推荐文章于 2023-02-28 16:34:52 发布

黄乐荣

最新推荐文章于 2023-02-28 16:34:52 发布

阅读量458

点赞数 1

分类专栏：数据分析

本文链接：https://blog.csdn.net/weixin_43717681/article/details/104625474

版权

数据分析专栏收录该内容

20 篇文章 3 订阅

订阅专栏

Numpy数组

Numpy函数库中存在两种不同的数据类型（矩阵matrix和数组array），都可以用于处理行列表示的数字元素。虽然它们看起来相似，但是这两个数据类型上执行相同的数学运算可能会得到不同的结果。
Ndarray概述

N维数组对象ndarray是用于存放同类型元素的多维数组
ndarray中的每个元素在内存中都有相同存储大小的区域
ndarray中的每个元素是数据类型对象的对象（称为dtype）

ndarray之创建数组
创建ndarray：创建数组最简单的办法就是使用array函数。它接受一切序列型的对象，然后产生一个含有传入数据的numpy数组，其中，嵌套序列将会被转换为一个多维数组

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的样式，C为行，F为列，A为任意
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

除了np.array之外，还有一些函数可以创建数组：

zeros和ones分别可以创建指定长度或形状的全0或全1数组
empty可以创建一个没有任何具体值的数组
identity：给定大小的单位矩阵

import numpy as np
np.zeros(3)
输出：array([0., 0., 0.])
np.ones(3)
输出：array([1., 1., 1.])

创建随机数组

均匀分布
.rand：创建指定形状的数组
.uniform：创建指定范围内的一个数
.randint：创建指定范围内的一个整数
.normal：给定均值、标准差、维度的正态分布

import numpy as np
np.random.rand(10,10)
输出：array([[0.76393715, 0.96817822, 0.32923747, 0.04511742, 0.69208235,
        0.97669399, 0.43807862, 0.19550967, 0.59066671, 0.70667363],
       [0.22833402, 0.04034155, 0.57948893, 0.66752217, 0.60940425,
        0.57238994, 0.97762652, 0.88248939, 0.15422875, 0.97497574],
       [0.00762339, 0.25969942, 0.50359611, 0.07097208, 0.60328593,
        0.30817838, 0.52381471, 0.75711323, 0.7411559 , 0.59301013],
       [0.86939111, 0.61286564, 0.23512756, 0.68641693, 0.27365126,
        0.27152717, 0.03271575, 0.19063815, 0.2688887 , 0.57792151],
       [0.32032285, 0.6989478 , 0.11322757, 0.50078307, 0.77945129,
        0.01825861, 0.89894587, 0.14080562, 0.00294043, 0.37726216],
       [0.77466588, 0.38617068, 0.6311746 , 0.78047595, 0.66192023,
        0.86241676, 0.54777732, 0.28253651, 0.9505423 , 0.08779672],
       [0.81096072, 0.48171139, 0.79033677, 0.41595525, 0.14514202,
        0.71592634, 0.3544979 , 0.06182558, 0.44952992, 0.54444123],
       [0.66160149, 0.02419386, 0.01889194, 0.02659799, 0.01322671,
        0.13670801, 0.40596526, 0.78703012, 0.89827441, 0.70430044],
       [0.7636388 , 0.73881863, 0.54931836, 0.6313596 , 0.19213439,
        0.34307457, 0.00373815, 0.2257937 , 0.50235919, 0.01206267],
       [0.27031669, 0.9642228 , 0.54851943, 0.48219606, 0.5047966 ,
        0.88434059, 0.09266867, 0.61634516, 0.68186784, 0.18917805]])

import numpy
numpy.random.uniform(0,100)
输出：45.19444320633651

import numpy
numpy.random.randint(0,100)
输出：30

import numpy
numpy.random.normal(1.75,0.1,(2,3))
输出：
array([[1.84460749, 1.65007805, 1.69506786],
       [1.73967328, 1.79469128, 1.87053243]])In [ ]:

查看数组属性的用法

用法	说明
b.size	数组元素个数
b.shape	数组形状
b.dtype	数组元素类型
b.Itemsize	数组元素字节大小
b.ndim	数组维度

Numpy数组

从列表到一维数组
数据对象类型type，数组元素类型dtype

import numpy
list_of_ints=[1,2,3]
Array_1=numpy.array(list_of_ints)
print(Array_1)
print(type(Array_1))
print(Array_1.dtype)
输出：
[1 2 3]
<class 'numpy.ndarray'>
int32

控制内存大小
查看内存占用情况：.nbytes
.astype方法总是创建一个新的数组

print(Array_1.nbytes)
#指定元素合适的类型
Array_1=numpy.array(list_of_ints,dtype='int8')
#改变元素的数据类型
Array_1a=Array_1.astype('float32')
print(Array_1a)

异构列表
列表可以由整数、浮点数和字符串等异构元素组成
isinstance()函数是判断一个对象是否是一个已知的类型

import numpy
complex_list=[1,2,3]+[1.,2.,3.]+['a','b','c']
Array_1=numpy.array(complex_list[:3])
print(complex_list[:3],end='---')
print('complex_list[:3]',Array_1.dtype)
print(complex_list[:6],end='---')
print('complex_list[:6]',Array_1.dtype)
print(complex_list[:],end='---')
print('complex_list[:9]',Array_1.dtype)

print(isinstance(complex_list[0],numpy.number))
判断该元素是否为numpy.number类型，是输出True,否则False

从列表到多维数组
如果把包含数值或文本对象的列表描述成一维数组，那么：
- 列表的列表就可以转换成二维数组
- 列表的列表的列表就可以转换成三维数组
reshape操作是对原始数组进行动态地镜像，得到的结果
如果有必要改变原始数组，可采用.resize()函数，.shape()函数
使用arange函数，创建整数序列的Numpy数组，返回结果是具有一定间隔的整数序列（通常由零开始）

import numpy 
ordinal_values=numpy.arange(9).reshape(3,3)
ordinal_values
输出：
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

numpy.random.randint(low=3,high=7)
输出：
6

numpy.random.randint(low=3,high=13,size=(3,3)).reshape(3,3)
输出：
array([[ 6,  7,  9],
       [12, 12,  9],
       [ 4,  4,  7]])

分数步长（等差序列）

import numpy
fractions=numpy.linspace(start=0,stop=1,num=10)
fractions
输出：
array([0.        , 0.11111111, 0.22222222, 0.33333333, 0.44444444,
       0.55555556, 0.66666667, 0.77777778, 0.88888889, 1.        ])

对数步长（等比序列）

import numpy
growth=numpy.logspace(start=0,stop=1,num=10,base=10.0)
growth
输出：
array([ 1.        ,  1.29154967,  1.66810054,  2.15443469,  2.7825594 ,
        3.59381366,  4.64158883,  5.9948425 ,  7.74263683, 10.        ])

标准正态分布（均值：0、差：1）

import numpy
std_gaussian=numpy.random.normal(size=(3,3))
std_gaussian
输出：
array([[ 1.18810390e+00, -8.56725832e-01, -1.11417357e-01],
       [ 5.07346214e-01, -8.23772152e-04,  3.22451101e-01],
       [ 9.10391300e-01,  9.57289070e-01, -8.19836954e-01]])

正态分布（均值：1.0、差：3.0）

import numpy
gaussian=numpy.random.normal(loc=1.0,scale=3.0,size=(3,3))
gaussian
输出：
array([[ 4.62629046,  0.62142865,  5.47141209],
       [ 0.61503277,  6.41350563,  6.60821947],
       [-0.71254148, -0.34286294, -8.53423912]])

均匀分布

import numpy
rand=numpy.random.uniform(low=0.0,high=1.0,size=(3,3))
rand
输出：
array([[0.88554686, 0.20770666, 0.01000111],
       [0.34941369, 0.15293207, 0.10098957],
       [0.94873332, 0.01608739, 0.97316439]])

数组堆叠
.vstack()命令需要提供一个参数元组，元组包含两个需要连接的垂直数组
.hstack()命令的参数元组两个需要连接的水平数组
还可以使用column_stack()
.dstack()在进行第三轴数据操作时非常方便

import numpy
dataset=numpy.arange(10*5).reshape(10,5)
print(dataset)
print(end="---------------\n")
single_line=numpy.arange(1*5).reshape(1,5)
a_few_lines=numpy.arange(3*5).reshape(3,5)

print(numpy.vstack((dataset,single_line)))
print(end="---------------\n")
print(numpy.vstack((dataset,a_few_lines)))
print(end="---------------\n")
输出：
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]
 [25 26 27 28 29]
 [30 31 32 33 34]
 [35 36 37 38 39]
 [40 41 42 43 44]
 [45 46 47 48 49]]
---------------
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]
 [25 26 27 28 29]
 [30 31 32 33 34]
 [35 36 37 38 39]
 [40 41 42 43 44]
 [45 46 47 48 49]
 [ 0  1  2  3  4]]
---------------
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]
 [25 26 27 28 29]
 [30 31 32 33 34]
 [35 36 37 38 39]
 [40 41 42 43 44]
 [45 46 47 48 49]
 [ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
---------------

import numpy
dataset=numpy.arange(10*5).reshape(10,5)
bias=numpy.ones(10).reshape(10,1)
numpy.hstack((dataset,bias))
输出：
array([[ 0.,  1.,  2.,  3.,  4.,  1.],
       [ 5.,  6.,  7.,  8.,  9.,  1.],
       [10., 11., 12., 13., 14.,  1.],
       [15., 16., 17., 18., 19.,  1.],
       [20., 21., 22., 23., 24.,  1.],
       [25., 26., 27., 28., 29.,  1.],
       [30., 31., 32., 33., 34.,  1.],
       [35., 36., 37., 38., 39.,  1.],
       [40., 41., 42., 43., 44.,  1.],
       [45., 46., 47., 48., 49.,  1.]])

import numpy
dataset=numpy.arange(10*5).reshape(10,5)
bias=numpy.ones(10).reshape(10,1)
numpy.hstack((dataset,bias))
输出：
array([[[  0,   0,   0],
        [  1,   2,   3],
        [  2,   4,   6],
        [  3,   6,   9],
        [  4,   8,  12]],

       [[  5,  10,  15],
        [  6,  12,  18],
        [  7,  14,  21],
        [  8,  16,  24],
        [  9,  18,  27]],

       [[ 10,  20,  30],
        [ 11,  22,  33],
        [ 12,  24,  36],
        [ 13,  26,  39],
        [ 14,  28,  42]],

       [[ 15,  30,  45],
        [ 16,  32,  48],
        [ 17,  34,  51],
        [ 18,  36,  54],
        [ 19,  38,  57]],

       [[ 20,  40,  60],
        [ 21,  42,  63],
        [ 22,  44,  66],
        [ 23,  46,  69],
        [ 24,  48,  72]],

       [[ 25,  50,  75],
        [ 26,  52,  78],
        [ 27,  54,  81],
        [ 28,  56,  84],
        [ 29,  58,  87]],

       [[ 30,  60,  90],
        [ 31,  62,  93],
        [ 32,  64,  96],
        [ 33,  66,  99],
        [ 34,  68, 102]],

       [[ 35,  70, 105],
        [ 36,  72, 108],
        [ 37,  74, 111],
        [ 38,  76, 114],
        [ 39,  78, 117]],

       [[ 40,  80, 120],
        [ 41,  82, 123],
        [ 42,  84, 126],
        [ 43,  86, 129],
        [ 44,  88, 132]],

       [[ 45,  90, 135],
        [ 46,  92, 138],
        [ 47,  94, 141],
        [ 48,  96, 144],
        [ 49,  98, 147]]])

Numpy矩阵操作

Numpy中包含了一个矩阵库numpy.matlib，该模块中的函数返回的是一个矩阵，而不是ndarray对象
一个m*n的矩阵是一个由m行n列元素排列成的矩形阵列
矩阵里的元素可以是数字、符号或数学式
注意，对于矩阵来说，x[0,0]和x[0][0]的含义不一样，x[0,0]返回行下标和列下标都为0的元素

Numpy矩阵生成

numpy.matlib.empty(shape,dtype,order)
numpy.matlib.zeros()
numpy.matlib.ones()
numpy.matlib.eye(n,M,k,dtype){n：返回矩阵的行数，M：返回矩阵的列数，默认为n，k：对角线的索引，dtype：数据类型}

常用矩阵操作

矩阵与二维数组相互转换

import numpy
i=numpy.matrix('1,2;3,4')
print(i)
j=numpy.asarray(i)
print(j)
k=numpy.asmatrix(j)
print(k)
输出：
[[1 2]
 [3 4]]
[[1 2]
 [3 4]]
[[1 2]
 [3 4]]

矩阵转置

import numpy
x=numpy.matrix([[1,2,3],[4,5,6]])
y=numpy.matrix([1,2,3,4,5,6])
print(x.T,y.T,sep='\n\n')
输出：
[[1 4]
 [2 5]
 [3 6]]

[[1]
 [2]
 [3]
 [4]
 [5]
 [6]]
 对于二维数组，transpose在不指定参数时，默认是矩阵转置
 .transpose()括号内空着，是默认情况
 .transpose（（0，1））表示按照原坐标轴改变序列，也就是保持不变
 .transpose（（1，0））表示交换‘0’轴和‘1’轴

矩阵特征

import numpy
x=np.matrix([[1,2,3],[4,5,6],[7,8,9]])
print(x,'\n0===\n')
print(x.mean(),end='\n1===\n')#所有元素平均值
print(x.mean(axis=0),end='\n2===\n')#纵向平均值
print(x.mean(axis=0).shape,end='\n3===\n')#形状
print(x.mean(axis=1),end='\n4===\n')#横向平均值
print(x.sum(),end='\n5===\n')#所有元素之和
print(x.max(axis=1),end='\n6===\n')#横向最大值
print(x.argmax(axis=1),end='\n7===\n')#横向最大值下标
print(x.diagonal(),end='\n8===\n')#对角线元素
输出：
[[1 2 3]
 [4 5 6]
 [7 8 9]] 
0===

5.0
1===
[[4. 5. 6.]]
2===
(1, 3)
3===
[[2.]
 [5.]
 [8.]]
4===
45
5===
[[3]
 [6]
 [9]]
6===
[[2]
 [2]
 [2]]
7===
[[1 5 9]]
8===

矩阵运算

numpy.linalg中有一组标准的矩阵分解运算以及诸如求逆和行列式之类的东西

函数	说明
diag	以一维数组的形式返回方阵的对角线（或非对角线）元素，或将一维数组转换为方阵（非对角线元素为0）
dot	矩阵乘法
trace	计算对角线元素的和
det	计算矩阵行列式
eig	计算方阵的特征值和特征向量
inv	计算方阵的逆
svd	计算奇异值分解（SVD）
solve	解线性方程组Ax=b，其中A为一个方阵
Istsq	计算Ax=b的最小二乘解

import numpy
a=numpy.array([[1,1,1],[0,2,5],[2,5,-1]])#系数矩阵
b=numpy.array([6,-4,27])#系数矩阵
x=numpy.linalg.solve(a,b)#求解
print(x)
print(numpy.dot(a,x))#验证
输出：
[ 5.  3. -2.]
[ 6. -4. 27.]