pandas的作用
我们知道numpy是矩阵运算的这么一个库，而pandas是数据处理这么一个库。其操作会基于numpy的内部函数。
- pandas读取需要处理的文件
import pandas
food_info=pandas.read_csv("food_info.csv")
print(type(food_info)) #DataFrame(类似于矩阵结构)
print(food_info.dtypes) #int64,float64,object(字符型)
print(help(pandas.read_csv))
#显示数据
food_info.head(m)#但m值不给定时，默认显示前5条数据
food_info.head(n)#但n值不给定时，默认显示后5条数据
food_info.colums()#显示列名
food_info.shape()#显示行与列
#取数据
food_info.loc[m] #取第m行数据
food_info.loc[m:n] #取第m-n行数据
food_info.loc[a,b,c] #a,b,c行的数据
ndb_col=foold_info["NDB_No"] #打印列名对应的这一列
Numpy的基本使用
下面介绍Numpy的基础知识与相关函数
创建数组及使用
#定义了一个二维数组，大小为（2，3）
>>> x=np.array([
[1.0,0.0,0.0],
[0.,1.,2.]
])
>>> x
array([[1., 0., 0.],
[0., 1., 2.]])
#数组维度数
>>> x.ndim
2
#数组的维数，返回的格式(n,m),其中n为行数，m为列数
>>> x.shape
(2, 3)
#数组元素的总数
>>> x.size
6
#数组元素类型
>>> x.dtype
#64位浮点型
dtype('float64')
#每个元素占有的字节大小
>>> x.itemsize
8
#数组元素的缓冲区
>>> x.data
<memory at 0x00000205227DAC18>
知识点扩展:
创建序列数组的函数arrange和linspace。（range函数类似）
- arange(a,b,c)
参数表示(开始值，结束值，步长) - linspace(a,b,c)
参数表示(开始值，结束值，元素数量) - 调用reshape()可以指定形状
>>> arange(6).reshape(2,3)
array([
[ 0, 1, 2],
[ 3, 4, 5],
[10, 11, 12]
])
>>> arange(1,5,2)
array([1, 3, 5])
>>> arange(0,1,0.5)
array([0. , 0.5, 1])
>>> linspace(0,2,9)
array([0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
特殊数组
- zeros数组：全零数组，元素全为零。
- ones数组：全1数组，元素全为1。
- empty数组：空数组，元素全近似为0。
>>> zeros((3,4))
array([
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]
])
>>> ones((2,3,4),dtype=int16)
array([
[
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]
],
[ [1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]
]
], dtype=int16)
>>> empty((5,3))
array([
[6.23042070e-307, 1.42417221e-306, 1.37961641e-306],
[1.11261027e-306, 1.11261502e-306, 1.42410839e-306],
[7.56597770e-307, 6.23059726e-307, 1.42419530e-306],
[7.56599128e-307, 1.11260144e-306, 6.89812281e-307],
[2.22522596e-306, 2.22522596e-306, 2.56761491e-312]
])
数组索引
Numpy数组通过索引访问
>>> c=arange(24).reshape(2,3,4)
>>> 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]
]
]
>>> print(c[1,2,:])
[20 21 22 23]
>>> print(c[0,1,2])
6
数组运算
数组的加减乘除以及乘方运算方式为:相应位置的元素分别进行运算。
>>> a=array([20,30,40,50])
>>> aa=arange(1,5)
>>> a/aa
array([20. , 15. , 13.33333333, 12.5 ])
>>> b=arange(4)
>>> b
array([0, 1, 2, 3])
>>> c=a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9], dtype=int32)
>>> A=array([
[1,1],
[0,1]
])
>>> B=array([
[2,0],
[3,4]
])
>>> A*B
array([
[2, 0],
[0, 4]
])
>>> A.sum()
3
>>> A.min()
0
>>> A.max()
1
数组的拷贝
拷贝有浅拷贝和深拷贝两种;
浅拷贝通过数组变量的赋值完成,浅拷贝只拷贝数组的引用，如果对拷贝进行修改，源数组也将修改;
深拷贝使用数组对象的copy方法，会复制一份和源数组一样的数组，新数组与源数组会存放在不同内存位置，因此对新数组的修改不会影响源数组。
案例一(浅拷贝)
>>> a=ones((2,3))
>>> a
array([
[1., 1., 1.],
[1., 1., 1.]
])
>>> b=a
>>> b[1,2]=2
>>> a
array([
[1., 1., 1.],
[1., 1., 2.]
])
>>> b
array([
[1., 1., 1.],
[1., 1., 2.]
])
案例二(深拷贝)
>>> a=ones((2,3))
>>> b=a.copy()
>>> b[1,2]=2
>>> a
array([
[1., 1., 1.],
[1., 1., 1.]
])
>>> b
array([
[1., 1., 1.],
[1., 1., 2.]
])
创建矩阵
矩阵与数组的区别
Numpy的矩阵对象与数组对象相似。其不同之处在于，矩阵对象的计算遵循矩阵数学运算律。矩阵使用matrix函数创建。
>>> A=matrix('1.0 2.0;3.0 4.0')
>>> A
matrix([
[1., 2.],
[3., 4.]
])
>>> B=matrix([
[1.0,2.0],
[3.0,4.0]
])
>>> B
matrix([
[1., 2.],
[3., 4.]
])
>>> type(A)
<class 'numpy.matrixlib.defmatrix.matrix'>
矩阵运算
>>> A.T #转置
matrix([
[1., 3.],
[2., 4.]
])
>>> x=matrix('5.0 7.0')
>>> y=x.T
>>> y
matrix([
[5.],
[7.]
])
>>> print(A*y) #矩阵乘法
[[26.]
[38.]]
>>> print(A.I) #逆矩阵
[[-2. 1. ]
[ 1.5 -0.5]]
Numpy线性代数相关函数
- numpy.dot()
此函数返回两个数组的点积。 对于二维向量，其等效于矩阵乘法。 对于一维数组，它是向量的内积。 对于 N 维数组，它是a的最后一个轴上的和与b的倒数第二个轴的乘积。
>>> a=np.array([[1,2],[3,4]])
>>> b=np.array([[11,12],[13,14]])
>>> np.dot(a,b)
array([[37, 40], #[[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]
[85, 92]])
- numpy.vdot()
此函数返回两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数id是多维数组，它会被展开。
>>> np.vdot(a,b)
130 #1*11+2*12+3*13+4*14=130
- numpy.inner()
此函数返回一维数组的向量内积。 对于更高的维度，它返回最后一个轴上的和的乘积。
>>> x=np.array([1,2,3])
>>> y=np.array([0,1,0])
>>> print(np.inner(x,y))
2 # 等价于 1*0+2*1+3*0
-
numpy.matmul()
函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。
另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。#对二维数组（列表），就相当于矩阵乘法
>>> a=[[1,0],[0,1]]
>>> b=[[4,1],[2,2]]
>>> print(np.matmul(a,b))
[[4 1]
[2 2]]
#二维和一维运算
>>> a=[[1,0],[0,1]]
>>> b=[1,2]
>>> print(np.matmul(a,b))
[1 2]
>>> print(np.matmul(b,a))
[1 2]
#维度大于2的
>>> a=np.arange(8).reshape(2,2,2)
>>> b=np.arange(4).reshape(2,2)
>>> print(np.matmul(a,b))
[[[ 2 3]
[ 6 11]]
[[10 19]
[14 27]]]
- numpy.linalg.det()
行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。
换句话说，对于矩阵[[a，b]，[c，d]]，行列式计算为ad-bc。 较大的方阵被认为是 2×2 矩阵的组合。
numpy.linalg.det()函数计算输入矩阵的行列式。
>>> a=np.array([[1,2],[3,4]])
>>> print(np.linalg.det(a))
-2.0000000000000004
>>> b=np.array([[6,1,1],[4,-2,5],[2,8,7]])
>>> print(b)
[[ 6 1 1]
[ 4 -2 5]
[ 2 8 7]]
>>> print(np.linalg.det(b))
-306.0
>>> print(6*(-2*7-5*8)-1*(4*7-5*2)+(4*8- -2*2))
-306
- numpy.linalg.solve()
该函数给出了矩阵形式的线性方程的解。
>>> x=np.array([[1,2],[3,4]])
>>> y=np.linalg.inv(x)
>>> x
array([[1, 2],
[3, 4]])
>>> y
array([[-2. , 1. ],
[ 1.5, -0.5]])
>>> np.dot(x,y)
array([[1.0000000e+00, 0.0000000e+00],
[8.8817842e-16, 1.0000000e+00]])
a=np.array([[1,1,1],[0,2,5],[2,5,-1]])
print('数组a:')
print(a)
ainv=np.linalg.inv(a)
print('a的逆矩阵')
print(ainv)
print('矩阵b:')
b=np.array([[6],[-4],[27]])
print(b)
print('计算：A^(-1)B:')
x=np.linalg.solve(a,b)
print(x)
数组分割
使用hsplit你能将数组沿着它的Y轴分割，或者指定返回相同形状数组的个数，或者指定在哪些列后发生分割。vsplit沿着X轴分割。
>>> a = floor(10*random.random((2,12)))
>>> a
array([
[ 8., 8., 3., 9., 0., 4., 3., 0., 0., 6., 4., 4.],
[ 0., 3., 2., 9., 6., 0., 4., 5., 7., 5., 1., 4.]
])
>>> hsplit(a,3) # Split a into 3
[array([
[ 8., 8., 3., 9.],
[ 0., 3., 2., 9.]
]),
array([
[ 0., 4., 3., 0.],
[ 6., 0., 4., 5.]
]),
array([
[ 0., 6., 4., 4.],
[ 7., 5., 1., 4.]]
)]
>>> hsplit(a,(3,4)) # Split a after the third and the fourth column
[
array([
[ 8., 8., 3.],
[ 0., 3., 2.]
]),
array([
[ 9.],
[ 9.]
]),
array([
[ 0., 4., 3., 0., 0., 6., 4., 4.],
[ 6., 0., 4., 5., 7., 5., 1., 4.]
])
]
扫一扫
416
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
