numpy

最新推荐文章于 2024-04-18 09:20:11 发布

Pang_ling

最新推荐文章于 2024-04-18 09:20:11 发布

阅读量534

点赞数 1

分类专栏： python爬虫学习

本文链接：https://blog.csdn.net/Pang_ling/article/details/104066256

版权

python爬虫学习专栏收录该内容

23 篇文章 0 订阅

订阅专栏

1.Numpy简介

主要提供高性能的N维数数组实现以及计算能力，还提供和其他语言，如C/C++等集成能力，此外实现一些基础的数学算法，如线性代数相关，傅里叶变换以及随机数的生成等。
在这里插入图片描述
如上图，行数为2，列数为3

1.1Numpy数组的创建

在这里插入图片描述

#numpy python的科学计算包
arr=[]
arr1=[1,2,3]
arr2=[1,1,1]
print(arr1+arr2)   #[1, 2, 3, 1, 1, 1]
for i in range(len(arr1)):
    arr.append(arr1[i]+arr2[i])
print(arr)  #[2, 3, 4]


#Numpy数组的创建
#一维矩阵
import numpy as np
nd1=np.array(arr1)
nd2=np.array(arr2)
print(arr1)  #[1, 2, 3]
print(nd1)  #[1 2 3]
print(type(arr1))  #<class 'list'>
print(type(nd1))  #<class 'numpy.ndarray'>
print(nd1+nd2)   #[2 3 4]

#二维矩阵
nd3=np.array([[1,2,3,5],[3,4,5,6],[1,5,4,8]])
print(nd3)
# [[1 2 3 5]
#  [3 4 5 6]
#  [1 5 4 8]]

2.Numpy基本类型

在这里插入图片描述

import numpy as np
#二维矩阵
nd3=np.array([[1,2,3,5],[3,4,5,6],[1,5,4,8]])
print(nd3)
# [[1 2 3 5]
#  [3 4 5 6]
#  [1 5 4 8]]
#形状属性
print(nd3.shape)  #(3, 4)
#类型属性
print(nd3.dtype)  #int32
#维度属性
print(nd3.ndim)  #2
#元素个数属性
print(nd3.size)  #12
#字节属性
print(nd3.itemsize)    #4

3.Numpy基本操作

返回最大值的下标与最大值

#numpy的简单操作
nd4=np.array([3,2,8,6,8,4,6])
print(nd4)  #[3 2 8 6 8 4 6]
#返回第一个最大值的下标 argmax()
print(nd4.argmax()) #2
#返回矩阵内最大值 max()
print(nd4.max(axis=0))#axis默认是0
#8

当在一维数组将axis改为1时，返回错误

print(nd4.max(axis=1))#SyntaxError: unexpected EOF while parsing

#注意初始位置为0
nd4=np.array([[1,2,3,5],
              [3,4,5,6],
              [1,5,4,8]])
print("二维最大值")
#如果获取多维矩阵的最大值axis为0的话获取所有元素最大值
#如果axis为1时获取每一行的最大值
print(nd4.max())#8
print(nd4.max(axis=1))#[5 6 8]
print(nd4.argmax(axis=1))#[3 3 3]

将多维矩阵展开为一维矩阵 flatten()

#将多维矩阵展开为一维矩阵   flatten()
print(nd4.flatten())#[1 2 3 5 3 4 5 6 1 5 4 8]

在这里插入图片描述

Numpy切片和索引

ndarray对象的内容可以通过索引或切片来访问修改，与Python中的list的切片操作一样

ndarray数组可以基于0 ~ n的下标进行索引，切片对象可以通过冒号分割切片参数 start：stop：step
来进行切片操作

一维空间的切片与索引

print('切片和索引')
#切片和索引
#索引从0-n  切片通过  start:stop:step
nd3=np.array([[1,2,3,5],
               [3,4,5,6],
               [1,5,4,8]])
nd4=nd3.flatten()
nd5=nd4[:]
print(nd5)#[1 2 3 5 3 4 5 6 1 5 4 8]
nd5=nd4[2:]
print(nd5)#[3 5 3 4 5 6 1 5 4 8]
nd5=nd4[2:5]
print(nd5)#[3 5 3]
nd5=nd4[2:5:2]
print(nd5)#[3 3]
print(nd4[::-1])#矩阵反转 [8 4 5 1 6 5 4 3 5 3 2 1]

n维矩阵切片与索引

#n维矩阵索引和切片
print(nd3)
# [[1 2 3 5]
#  [3 4 5 6]
#  [1 5 4 8]]
print(nd3[2][3])#得到8
print(nd3[0:2])#只要第一二排元素
# [[1 2 3 5]
#  [3 4 5 6]]
print(nd3[:-1])
print('多维切片')
nd6=np.array([
    [[1,2,3]],
    [[4,5,6]],
    [[7,8,9]],
    [[10,11,12]]
             ])
print(nd6)
print(nd6[2][0][1])#得到8
print(nd6[:1])#[[[1 2 3]]]
print(nd6[:1][:1])#[[[1 2 3]]]

print(nd6[:3,:,:2])
# [[[1 2]]
#
#  [[4 5]]
#
#  [[7 8]]]

nd6=np.array([
    [[1,2,3],[1,2,3]],
    [[4,5,6],[1,2,3]],
    [[7,8,9],[1,2,3]],
    [[10,11,12],[1,2,3]]
             ])
print(nd6[:1,:1,::-1])#[[[3 2 1]]]

4.Numpy常用函数

常用函数ones()，zeros()创建全为1或0的矩阵
ones(shape,dtype= )
生成一个指定维数以及数据类型的值全为1的矩阵
第一个参数shape，也就是矩阵的行列（维度），使用(3,3),也就是3*3的矩阵
第二个参数dtype，设置的为矩阵数据类型，我们采用np内置的fioat，当然也可以是int等
eye()创建单位矩阵

#常用函数
#np.ones()
#创建指定形状的值全为1的矩阵
import numpy as np
nd1=np.ones((3,4),dtype=int)
print(nd1)
# [[1 1 1 1]
#  [1 1 1 1]
#  [1 1 1 1]]
nd1=np.ones((3,4),dtype=str)
print(nd1)
# [['1' '1' '1' '1']
#  ['1' '1' '1' '1']
#  ['1' '1' '1' '1']]

#创建指定形状的值全为0的矩阵
nd2=np.zeros((3,4))
print(nd2)
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

#创建对角线单位矩阵
nd3=np.eye((5))
print(nd3)
# [[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.]]

repeat（）
创建一个一维数组，将指定的值重复指代次数次。第一个参数是重复元素，第二个参数是重复次数

#repea 创建指定次数指定元素的一维数组
nd4=np.repeat(3,4)#将3重复4次创建一维数组
print(nd4)  #[3 3 3 3]

astype() 用另一种类型表示
nd.astype()

#改变数组元素类型
print(nd4.astype(str))#['3' '3' '3' '3']

arange()
类似python中的range生成一个指定区间的连续数组
当只有一个参数时候代表结束位，但并不包括。当有两个数组时候，代表开始位置与结束位置，包含开始位置但不包括结束位置

#产生一个区间的连续数组
nd1=np.arange(2,10,2)
print(nd1)#[2 4 6 8]

linspace() 等差数列

nd2=np.linspace(0,6,5)#生成一个等差数列，值区间在0-6，分为5等份
print(nd2)#[0.  1.5 3.  4.5 6. ]

reshape（）重新格式化矩阵格式为指定的格式
注意，reshape的时候，矩阵格式乘积要和原来的一致，否则报错

#重新格式化矩阵格式为指定的格式  reshape（）一定元素不能少
nd1=np.arange(2,10,1)
print(nd1)  #[2 3 4 5 6 7 8 9]
print(nd1.size)#8
print(nd1.reshape(2,4))
# [[2 3 4 5]
#  [6 7 8 9]]

print(nd1.reshape(2,2,2))
# [[[2 3]
#   [4 5]]
#
#  [[6 7]
#   [8 9]]]

random 随机数组
np.random.randint(low,high,size)

#随机数组random
#生成0-1之间的小数  np.random.random(size)
nd1=np.random.random((3,3))
print(nd1)
# [[0.02958568 0.99368978 0.10566601]
#  [0.51697432 0.14881421 0.70313792]
#  [0.910656   0.48068765 0.26989358]]


#产生随机整型数组  np.random.randint(low,high,size)
nd2=np.random.randint(2,8,(3,3))
print(nd2)

5.Numpy运算

数组和标量加法
每个元素均相加指定元素
减法除法乘法类似定义

nd1=np.arange(6)
print(nd1)#[0 1 2 3 4 5]
print(nd1+5)#[ 5  6  7  8  9 10]

矩阵的运算
矩阵加法乘法减法除法

#矩阵加法
nd1=np.random.randint(2,8,(3,3))
print(nd1)
# [[2 7 2]
#  [7 3 4]
#  [5 3 4]]
nd2=np.ones((3,3))
print(nd1+nd2)
# [[3. 8. 3.]
#  [8. 4. 5.]
#  [6. 4. 5.]]

矩阵的减法，乘法自行定义

注意，这里的乘法不是内积，而是对应位置元素相乘

矩阵内积：函数dot

#矩阵内积
nd1=np.random.randint(2,8,(3,3))
print(nd1)
# [[7 3 2]
#  [7 3 5]
#  [5 2 7]]
nd2=np.random.randint(2,8,(3,3))
print(nd2)
# [[2 7 7]
#  [2 6 5]
#  [4 6 3]]
print(np.dot(nd1,nd2))
# [[28 79 70]
#  [40 97 79]
#  [42 89 66]]

求矩阵的相关系数矩阵 corrcoef
计算矩阵的对角线 diag
化矩阵为上三角矩阵 triu
化矩阵为下三角矩阵 tril
计算矩阵的迹 trace
矩阵的转置 T或transpose

nd1=np.array([[0.003731,0.021066,-0.004854,0.006098,-0.00606],
              [-0.001838,0.001842,-0.016544,-0.003738,0.003752],
              [-0.003087,-0.000344,-0.033391,-0.007132,0.004597],
              [-0.024112,0.11704,-0.029563,-0.01457,0.16129]])
print(nd1)
# [[ 0.003731  0.021066 -0.004854  0.006098 -0.00606 ]
#  [-0.001838  0.001842 -0.016544 -0.003738  0.003752]
#  [-0.003087 -0.000344 -0.033391 -0.007132  0.004597]
#  [-0.024112  0.11704  -0.029563 -0.01457   0.16129 ]]

# 求矩阵的相关系数矩阵  corrcoef
print(np.corrcoef(nd1))
# [[1.         0.38215651 0.35309576 0.15591173]
#  [0.38215651 1.         0.99319488 0.73148499]
#  [0.35309576 0.99319488 1.         0.65519596]
#  [0.15591173 0.73148499 0.65519596 1.        ]]


#计算矩阵的对角线  diag
print(np.diag(nd1))
# [ 0.003731  0.001842 -0.033391 -0.01457 ]

#化矩阵为上三角矩阵   triu
print(np.triu(nd1))
# [[ 0.003731  0.021066 -0.004854  0.006098 -0.00606 ]
#  [ 0.        0.001842 -0.016544 -0.003738  0.003752]
#  [ 0.        0.       -0.033391 -0.007132  0.004597]
#  [ 0.        0.        0.       -0.01457   0.16129 ]]

#化矩阵为下三角矩阵  tril
print(np.tril(nd1))
# [[ 0.003731  0.        0.        0.        0.      ]
#  [-0.001838  0.001842  0.        0.        0.      ]
#  [-0.003087 -0.000344 -0.033391  0.        0.      ]
#  [-0.024112  0.11704  -0.029563 -0.01457   0.      ]]


#计算矩阵的迹    trace
print(np.trace(nd1))
# -0.042387999999999995

#矩阵的转置    T或transpose
print(np.transpose(nd1))
# [[ 0.003731 -0.001838 -0.003087 -0.024112]
#  [ 0.021066  0.001842 -0.000344  0.11704 ]
#  [-0.004854 -0.016544 -0.033391 -0.029563]
#  [ 0.006098 -0.003738 -0.007132 -0.01457 ]
#  [-0.00606   0.003752  0.004597  0.16129 ]]

矩阵的运算
numpy中有一个很重要的子模块linalg，是一个专门用来线性代数运算的工具包
求矩阵行列式 det
求逆矩阵 inv
特征值的分解 eig
奇异值的分解 svd

import numpy.linalg as la
nd1=np.random.random((4,4))
print(nd1)
# [[0.76694791 0.85075722 0.94962992 0.36201515]
#  [0.40849078 0.80694693 0.06806043 0.7860683 ]
#  [0.42458851 0.37943451 0.51926185 0.65448139]
#  [0.21065807 0.56787897 0.86785681 0.26961229]]


# 求矩阵行列式 det
print(la.det(nd1))
# -0.15557130563111662


# 求逆矩阵 inv
print(la.inv(nd1))
# [[ 1.92826971 -0.61620524  0.69380106 -2.47675401]
#  [ 0.1955781   1.36423493 -2.14256821  0.96096119]
#  [-0.2285036  -0.82491479  0.6805882   1.05977669]
#  [-1.18303904  0.26332702  1.78000611  0.20883382]]


# 特征值的分解 eig
print(la.eig(nd1))
# (array([ 2.17970819, -0.54493147,  0.32503551,  0.40295676]), array([[ 0.66682968,  0.42296056,  0.71094372, -0.00101272],
#        [ 0.45160541, -0.48747959,  0.28474773, -0.76059838],
#        [ 0.43320119, -0.39647572, -0.39147134,  0.55075562],
#        [ 0.4046325 ,  0.6528974 , -0.51012543,  0.34374022]]))


# 奇异值的分解 svd
print(la.svd(nd1))
# (array([[-0.6538528 , -0.34585539, -0.5542597 , -0.38165004],
#        [-0.44470419,  0.80793646, -0.20517549,  0.32768871],
#        [-0.42266373,  0.15696468,  0.7421452 , -0.49592132],
#        [-0.442798  , -0.45053837,  0.31610078,  0.70783148]]), array([2.28347107, 0.78002703, 0.32418994, 0.26941688]), array([[-0.41860208, -0.58111161, -0.54957708, -0.43017047],
#        [ 0.04681553,  0.20695363, -0.7473371 ,  0.62965527],
#        [-0.39237834, -0.54290299,  0.36827787,  0.64472242],
#        [-0.81769178,  0.56985598,  0.06183609, -0.05310951]]))

数组内的运算
Numpy还提供一些简单的统计功能，比如，求和，求平均值，求方差等
求和sum
axis=0 表示按列求和，axis=1表示按行求和。默认对所有元素求和
求乘积 prod
针对数组内部元素求乘积
axis=0 表示按列求乘积，axis=1表示按行求乘积。默认对所有元素求乘积
求最值 max，min
axis=0 表示按列求最值，axis=1表示按行求最值。默认对所有元素求最值
求均值 mean
axis=0 表示按列求均值，axis=1表示按行求均值。默认对所有元素求均值
求方差和标准差 var std
axis=0 表示按列求方差和标准差，axis=1表示按行求方差和标准差。默认对所有元素求方差和标准差
幂运算
对数组内每个元素计算开方，平方以及以e为底的指数次方，需要分别运用函数sqrt，square，exp

注，负数的开方为nan，表示无解
e-10表示10的-10次方

对数运算
对数组每个元素计算自然对数、底数为10的对数、底数为2的对数，需要分别运用log、log10、log2

nd1=np.random.randint(2,8,(3,3))
print(nd1)
# [[3 5 4]
#  [4 2 7]
#  [2 6 4]]

#求和sum  axis=0 表示按列求和，axis=1表示按行求和。默认对所有元素求和
print(nd1.sum())
#37

#求数组内元素的乘积
print(nd1.prod(axis=0))
# [ 24  60 112]
print(nd1.prod())
#161280

#求最值 max，min
print(nd1.max())
#7
print(nd1.min(axis=1))
#[3 2 2]

#求平均数 mean
print(nd1.mean())
#4.111111111111111

#求方差和标准差 var std
print(nd1.var())
#2.5432098765432096
print(nd1.std())
#1.594744454934147

#幂运算
#对数组内每个元素计算开方，平方以及以e为底的指数次方，需要分别运用函数sqrt，square，exp
print(np.sqrt(nd1))
# [[1.73205081 2.23606798 2.        ]
#  [2.         1.41421356 2.64575131]
#  [1.41421356 2.44948974 2.        ]]
print(np.square(nd1))
# [[ 9 25 16]
#  [16  4 49]
#  [ 4 36 16]]
print(np.exp(nd1))
# [[  20.08553692  148.4131591    54.59815003]
#  [  54.59815003    7.3890561  1096.63315843]
#  [   7.3890561   403.42879349   54.59815003]]


#对数运算
#对数组每个元素计算自然对数、底数为10的对数、底数为2的对数，需要分别运用log、log10、log2
print(np.log10(nd1))
# [[0.47712125 0.69897    0.60205999]
#  [0.60205999 0.30103    0.84509804]
#  [0.30103    0.77815125 0.60205999]]

6.Numpy广播机制

7.Numpy应用案例

Pang_ling

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
numpy

1.Numpy简介主要提供高性能的N维数数组实现以及计算能力，还提供和其他语言，如C/C++等集成能力，此外实现一些基础的数学算法，如线性代数相关，傅里叶变换以及随机数的生成等。如上图，行数为2，列数为31.1Numpy数组的创建#numpy python的科学计算包arr=[]arr1=[1,2,3]arr2=[1,1,1]print(arr1+arr2) #[1, 2,...
复制链接

扫一扫

专栏目录