Numpy数值计算

最新推荐文章于 2024-05-20 22:03:54 发布

抱抱宝

最新推荐文章于 2024-05-20 22:03:54 发布

阅读量1.3k

点赞数

分类专栏： Python数据分析与可视化文章标签： python 大数据

本文链接：https://blog.csdn.net/m0_64087341/article/details/123832456

版权

Python数据分析与可视化专栏收录该内容

24 篇文章 4 订阅

订阅专栏

Numpy是Python的一种开源的数值计算扩展库，它提供了两种基本的对象:

ndarray:是存储单一数据类型的多维数组。

ufunc:是一种能够对数组进行处理的函数。

Numpy常用的导入格式：

import numpy as np

1.Numpy数组

1.1创建数组

（1）array函数

data1=[1,3,5,7]
sz1=np.array(data1)
print(sz1)
#---------
[1 3 5 7]

（2）arange函数

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

（3）linspace函数

linspace函数通过指定起始值、终值、元素个数创建一维数组，默认包括终值。

w2=np.linspace(0,2,5)
print(w2)
#--------------------
[0.  0.5 1.  1.5 2. ]

（4）logspace函数

logspace函数的参数中，起始位和终止位代表的是10的幂。

w3=np.logspace(0,2,4)
print(w3)
#-------------------
[  1.           4.64158883  21.5443469  100.        ]

（5）zeros函数

zeros函数可以创建指定长度或形状的全0数组。

w4=np.zeros([3,3])
print(w4)
#------------------
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

（6）ones函数

ones函数可以创建指定长度或形状的全1数组。

w5=np.ones([2,3])
print(w5.astype(np.int32))
#-------------------------
[[1 1 1]
 [1 1 1]]

（7）diag函数

diag函数可以创建对角矩阵，即对角线元素为0或指定值，其他元素为0。

w6=np.diag([1,2,3])
print(w6)
#--------------------
[[1 0 0]
 [0 2 0]
 [0 0 3]]

（8）eye函数

eye函数可创建一条对角线位置为1、其他位置全为0的矩阵。

w7=np.eye(3)
print(w7.astype(np.int32))
#-------------------------
[[1 0 0]
 [0 1 0]
 [0 0 1]]

（9）生成随机数

w8=np.random.randint(10,50,size=(2,4))
print(w8)
#-------------------------------------
[[15 29 37 13]
 [18 48 49 33]]

2.数组变换

2.1数组重塑

可以通过reshape方法改变其数组维度，其中的一个参数可以设置为-1，表示数组的维度可以通过数据本身来推断。

ar1=np.arange(12)
print('ar1:',ar1)
ar2=ar1.reshape(3,-1)
print('ar2:',ar2)
#--------------------
ar1: [ 0  1  2  3  4  5  6  7  8  9 10 11]
ar2: [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]

数据散开（ravel）和数据扁平化(flatten)

ar3=ar2.ravel()
print('ar3:',ar3)
ar4=ar2.flatten()
print('ar4:',ar4)
#------------------
ar3: [ 0  1  2  3  4  5  6  7  8  9 10 11]
ar4: [ 0  1  2  3  4  5  6  7  8  9 10 11]

2.2数组合并

hstack：数组横向合并

vstack：数组纵向合并

concatenate函数可以实现数组的横向合并和纵向合并，当axis=1时进行横向合并，当axis=0时，进行纵向合并。

ar5=np.arange(6).reshape(3,2)
ar6=ar5*3
ar7=np.hstack((ar5,ar6))
print(ar7)
ar8=np.vstack((ar5,ar6))
print(ar8)
print('横向合并：\n',np.concatenate((ar5,ar6),axis=1))
print('纵向合并：\n',np.concatenate((ar5,ar6),axis=0))
#-----------------------------------------------------
[[ 0  1  0  3]
 [ 2  3  6  9]
 [ 4  5 12 15]]
[[ 0  1]
 [ 2  3]
 [ 4  5]
 [ 0  3]
 [ 6  9]
 [12 15]]
横向合并：
 [[ 0  1  0  3]
 [ 2  3  6  9]
 [ 4  5 12 15]]
纵向合并：
 [[ 0  1]
 [ 2  3]
 [ 4  5]
 [ 0  3]
 [ 6  9]
 [12 15]]

2.3数组分割

hsplit：实现数组的横向分割

vsplit：实现数组的纵向分割

split在参数axis=1时实现数组的横向分割，axis=0时实现数组的纵向分割

sz=np.arange(16).reshape(4,4)
print('横向分割:\n',np.hsplit(sz,2))
print('纵向分割:\n',np.vsplit(sz,4))
print('横向分割:\n',np.split(sz,1,axis=1))
print('纵向分割:\n',np.split(sz,2,axis=0))
#-----------------------------------------
横向分割:
 [array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), 
  array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
纵向分割:
 [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]
横向分割:
 [array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])]
纵向分割:
 [array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), 
  array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]

3.数组的运算

3.1常用的ufunc函数运算

（1）四则运算：加（+）、减（-）、乘（*）、除（/）、幂（**）。数组间的四则运算是对每个数组中的元素分别进行四则运算，所以形状必须相同。

（2）比较运算：>,<,==,>=,<=,!=。比较运算返回的结果是一个布尔数组，每个元素为每个数组对应元素的比较结果。

（3）逻辑运算：np.any函数表示逻辑“or”,np.all函数表示逻辑“and”,运算结果返回布尔值。

（4）ufunc函数的广播机制

广播是指不同形状的数组之间执行算术运算的方式。

aa1=np.array([[1,1,1],[2,2,2],[3,3,3]])
bb1=np.array([1,2,3])
print('aa1+bb1:\n',aa1+bb1)
#---------------------------------------
aa1+bb1:
 [[2 3 4]
 [3 4 5]
 [4 5 6]]

4.排序

numpy的排序方式有直接排序和间接排序，直接排序经常用sort函数，间接排序经常用argsort函数和lexsort函数。

直接排序：

sss=np.array([[3,6,8,2],[1,7,4,9],[6,4,8,3]])
sss.sort(axis=1)
print('横向排序：\n',sss)
sss.sort(axis=0)
print('纵向排序：\n',sss)
#-------------------------------------
横向排序：
 [[2 3 6 8]
 [1 4 7 9]
 [3 4 6 8]]
纵向排序：
 [[1 3 6 8]
 [2 4 6 8]
 [3 4 7 9]]

argsort函数间接排序：

arr=np.array([7,8,6,2,9,4,3,1,5,3])
print('原数组：\n',arr)
print('排序后：\n',arr.argsort())#返回值为数组排序后的下标序列
#----------------------------------------------------------
原数组：
 [7 8 6 2 9 4 3 1 5 3]
排序后：
 [7 3 6 9 5 8 2 0 1 4]

lexsort间接排序：

a=[1,5,7,4,3,0,2]
b=[9,5,2,0,6,8,7]
ind=np.lexsort((b,a))
print('数组a排序后的下标：\n',ind)
tmp=[(a[i],b[i])for i in ind]
print('数组a和b排序后的结果：\n',tmp)
#------------------------------------
数组a排序后的下标：
 [5 0 6 4 3 1 2]
数组a和b排序后的结果：
 [(0, 8), (1, 9), (2, 7), (3, 6), (4, 0), (5, 5), (7, 2)]

5.数据去重与重复

5.1数据去重

在numpy中，可以使用unique函数找到数组中的唯一值并返回已排序的结果，实现数据去重，当其中的参数return_counts设置为True时，即可返回每个取值出现的次数。

names=np.array(['a','b','b','a','c','b','c','a'])
print('原数组：',names)
print('去重后的数组：',np.unique(names))
print('字母出现次数:',np.unique(names,return_counts=True))
#-------------------------------------------------------
原数组： ['a' 'b' 'b' 'a' 'c' 'b' 'c' 'a']
去重后的数组： ['a' 'b' 'c']
字母出现次数: (array(['a', 'b', 'c'], dtype='<U1'), array([3, 3, 2], dtype=int64))

5.2数据重复

在numpy 中主要使用tile和repeat函数实现数据重复。

tile函数实现数据重复

sz=np.arange(3)
print('原数组：',sz)
sz1=np.tile(sz,3)
print('重复后的数组：',sz1)
#--------------------------
原数组： [0 1 2]
重复后的数组： [0 1 2 0 1 2 0 1 2]

repeat函数实现数据重复:axis=0表示按行进行元素重复，axis=1表示按列进行元素重复。

arr=np.diag([1,2,3])
print('原数组:\n',arr)
arr1=np.repeat(arr,2,axis=0)
print('按行重复:\n',arr1)
arr2=np.repeat(arr,2,axis=1)
print('按列重复:\n',arr2)
#---------------------------
原数组:
 [[1 0 0]
 [0 2 0]
 [0 0 3]]
按行重复:
 [[1 0 0]
 [1 0 0]
 [0 2 0]
 [0 2 0]
 [0 0 3]
 [0 0 3]]
按列重复:
 [[1 1 0 0 0 0]
 [0 0 2 2 0 0]
 [0 0 0 0 3 3]]

6.读写数组

6.1读写二进制文件

numpy中读/写二进制文件的方法有以下两种：

（1）numpy.load("文件名.npy"):从二进制的文件中读取数据。

（2）numpy.save("文件名[.npy]",arr):以二进制的格式保存数据。

a=np.arange(12).reshape(3,-1)
print('a:',a)
np.save('arr.npy',a)
b=np.load('arr.npy')
print('b:',b)
#------------------------
a: [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
b: [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

6.2读/写文本文件

numpy中读写文本文件的方法主要有以下三种：

(1)numpy.loadtxt("arr.txt",delimiter=","):把文件加载到一个二维数组中。

(2)numpy.savetxt("arr.txt",arr,fmt="%d",delimiter=","):将数组写到某种分隔符隔开的文本文件中。

(3)numpy.genfromtxt("arr.txt",delimiter=","):结构化数组和缺失数据。

a=np.arange(12).reshape(4,-1)
np.savetxt("szout.txt",a,fmt="%d",delimiter=",")
np.loadtxt("szout.txt",delimiter=",")
#------------------------------------------
array([[ 0.,  1.,  2.],
       [ 3.,  4.,  5.],
       [ 6.,  7.,  8.],
       [ 9., 10., 11.]])

码字不易，大家的阅读就是我创作的动力^_^ ^_^