numpy基础操作

56 阅读 0 评论 37 点赞

我是靠谱客的博主怕孤单衬衫，最近开发中收集的这篇文章主要介绍numpy基础操作，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

numpy基础操作

数据结构数组和向量

import numpy
vector=numpy.array([5,10,15,20]) #向量
A=numpy.array([[1,2],[4,4]])      #数组

#打印维度
print(vector.shape)
print(A.shape)
# (4,)
# (2, 2)

#numpy数组要求传入的值都是同一类型
print(A.dtype)
#int32

numpy导入文件，并以数组的形式存入
delimiter=’,’ 分割符为，
dtype=str 元素类型为str
skip_header=1 跳过首行

#a.txt
#1,2,3
#4,5,6
#7,8,9
date=numpy.genfromtxt('a.txt',delimiter=',',dtype=str，skip_header=1)
print(date)
 print(date[2]) #打印行
print(date[:,1]) #打印列

# [['1' '2' '3']
#  ['4' '5' '6']
#  ['7' '8' '9']]

# ['7' '8' '9']

# ['2' '5' '8']

创建数组以及索引

import numpy as np

# A=np.arange(15)  #创建索引
# A0=np.arange(10,15,2) #和列表调用方式相似，顾头不顾尾，末尾为间隔
# print(A0)
# A1=A.reshape(3,5) #创建数组
# print(A)
# print(A1)
# print(A1.shape)
# print(A1.ndim) #查看维度
# print(A1.size) #查看元素个数

创建全0，全1矩阵：

B=np.zeros((4,4))
print(B)

C=np.ones((2,3,4),dtype=np.int32)
print(C)

# [[0. 0. 0.]
#  [0. 0. 0.]
#  [0. 0. 0.]]
# [[1 1 1]
#  [1 1 1]
#  [1 1 1]]

创建随机矩阵,np.random模块下面还有很多函数，random只是其中一个，注意传入是一个参数，改参数是一个元组（2，3）

D=np.random.random((2,3))
print(D)

# [[0.2696847  0.57543336 0.80743221]
#  [0.40905307 0.90296892 0.168104  ]]

创建一维数组 inspcae(起点，终点，个数）

#linspcae(起点，终点，个数）
print(np.linspace(0,10,6))
# [ 0.  2.  4.  6.  8. 10.]

矩阵的运算

A=np.array([[1,2],[3,4]])
B=np.array([[2,1],[3,4]])
print('A-Bn',A-B)
print('A-1：n',A-1)
print("AB n",A/B)
print('A的3次方：n',A**3)
print('A<30:n',A<30)
print('*内积操作')
print(A*B)
print('矩阵相乘')
print(A.dot(B)) #np.dot(A,B)也是代表矩阵相乘
# 
# A-B
#  [[-1  1]
#  [ 0  0]]
# A-1：
#  [[0 1]
#  [2 3]]
# AB 
#  [[0.5 2. ]
#  [1.  1. ]]
# A的3次方：
#  [[ 1  8]
#  [27 64]]
# A<30:
#  [[ True  True]
#  [ True  True]]
# *内积操作
# [[ 2  2]
#  [ 9 16]]
# 矩阵相乘
# [[ 8  9]
#  [18 19]]

常见函数
A=np.arange(1,5,1)
e的幂操作
print(np.exp(A))
开方
print(np.sqrt(A))
np.floor向下取整
np.ravel()将矩阵转成列表
A.T求转置
np.linalg.inv(a) # 求逆

矩阵拼接

A=np.array([[1,1],[0,1]])
B=np.array([[2,0],[3,4]])
print('横向n',np.hstack((A,B)))#横向拼接
print('纵向n',np.vstack((A,B)))#上下拼接
# 横向
#  [[1 1 2 0]
#  [0 1 3 4]]
# 纵向
#  [[1 1]
#  [0 1]
#  [2 0]
#  [3 4]]

矩阵切分：

a=np.floor(10*np.random.random((4,8)))
print(a)
print('-----------横向平均切为4等分---------------')
print(np.hsplit(a,4))
print('-----------横向指定位置切-------------')
print(np.hsplit(a,(3,5)))
print('----------纵切均分2等分-----------------')
print(np.vsplit(a,2))

# [[2. 2. 2. 0. 6. 0. 8. 1.]
#  [3. 6. 8. 0. 4. 2. 0. 0.]
#  [8. 1. 3. 6. 9. 4. 3. 0.]
#  [6. 5. 4. 0. 7. 3. 5. 0.]]
# -----------横向平均切为4等分---------------
# [array([[2., 2.],
#        [3., 6.],
#        [8., 1.],
#        [6., 5.]]), array([[2., 0.],
#        [8., 0.],
#        [3., 6.],
#        [4., 0.]]), array([[6., 0.],
#        [4., 2.],
#        [9., 4.],
#        [7., 3.]]), array([[8., 1.],
#        [0., 0.],
#        [3., 0.],
#        [5., 0.]])]
# -----------横向指定位置切-------------
# [array([[2., 2., 2.],
#        [3., 6., 8.],
#        [8., 1., 3.],
#        [6., 5., 4.]]), array([[0., 6.],
#        [0., 4.],
#        [6., 9.],
#        [0., 7.]]), array([[0., 8., 1.],
#        [2., 0., 0.],
#        [4., 3., 0.],
#        [3., 5., 0.]])]
# ----------纵切均分2等分-----------------
# [array([[2., 2., 2., 0., 6., 0., 8., 1.],
#        [3., 6., 8., 0., 4., 2., 0., 0.]]), array([[8., 1., 3., 6., 9., 4., 3., 0.],
#        [6., 5., 4., 0., 7., 3., 5., 0.]])]

相等矩阵
a=b a,b，值相同，同步变换（（改变任意一个，两个值都会一起变），内存地址相等
c=a.view() a,c值相同，同步变换（改变任意一个，两个值都会一起变），内存地址不同，
d=a.copy() d复制a 值相同，不同步变换（改变a，d不变），内存地址不同

argmax 返回最大值的索引

#argmax 返回最大值的索引
a=np.floor(10*np.random.random((4,4)))
print(a)
print('axis=0 表示按列返回最大值的索引')
print(a.argmax(axis=0))
print('axis=1 表示按行返回最大值的索引')
print(a.argmax(axis=1))

# [[1. 8. 4. 2.]
#  [2. 0. 3. 9.]
#  [4. 6. 7. 2.]
#  [0. 7. 2. 5.]]
# axis=0 表示按列返回最大值的索引
# [2 0 2 1]
# axis=1 表示按行返回最大值的索引
# [1 3 2 1]

np.sort() 对矩阵进行排序

#np.sort() 对矩阵进行排序
a=np.floor(10*np.random.random((4,4)))
print(a)
print('axis=0 表示按列排序:')
print(np.sort(a,axis=0))
print('axis=1 表示按行排序:')
print(np.sort(a,axis=1))
print('按索引值排序，将矩阵排序后，列出原来的索引')
print(np.argsort(a[0]))
# [[6. 9. 3. 3.]
#  [7. 5. 4. 5.]
#  [0. 1. 8. 6.]
#  [2. 1. 4. 6.]]
# axis=0 表示按列排序:
# [[0. 1. 3. 3.]
#  [2. 1. 4. 5.]
#  [6. 5. 4. 6.]
#  [7. 9. 8. 6.]]
# axis=1 表示按行排序:
# [[3. 3. 6. 9.]
#  [4. 5. 5. 7.]
#  [0. 1. 6. 8.]
#  [1. 2. 4. 6.]]
# 按索引值排序，将矩阵排序后，列出原来的索引
# [2 3 0 1]