python数据结构：numpy

Posted 2021-01-31 大数据开发程序猿

一、 numpy概述

numpy（Numerical Python）提供了python对多维数组对象ndarray（应该是N-dimension array）的支持，具有矢量运算能力，快速、节省空间。numpy支持高级大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

二、实操

1. 创建ndarray数组

ndarray：N维数组对象（矩阵），所有元素必须是相同类型。
ndarray属性：ndim属性，表示维度个数；shape属性，表示各维度大小；dtype属性，表示数据类型。

2.生成指定维度的随机数组

　　(1)生成一个3行4列的随机数组，然后计算数组的各个属性

# 生成指定维度的随机数组
data = np.random.rand(3,4) #随机生成一个3行4列的随机数组
print(data)
print(type(data))   #数据结构是：<class \'numpy.ndarray\'>

　　[[0.9866426 0.54835475 0.69859764 0.32483656]
　　[0.27492952 0.23119927 0.97028605 0.08145471]
　　[0.28869387 0.2712937 0.91773528 0.95094582]]

 

# 打印出数组的各个属性
print(\'数组的维数\',data.ndim)  #number of dimension  数组的维数  2 
print(\'数组的大小\',data.shape)   #描述数组各维度的大小      (3,4)
print(\'数据类型\',data.dtype)     #描述数组的数据类型     float

　　(2)将列表转换为np.array形式

# 将list转换为二维数组
list = range(0,10)
data = np.array(list)   #实现将python列表的数据结构转换为np的array的数据结构
print(data)   #[0 1 2 3 4 5 6 7 8 9]
print(type(data))   #<class \'numpy.ndarray\'>
print(data.ndim)   #1
print(data.shape)   #(10,)
print(data.dtype)   #int32

　　(3)将嵌套序列转换为ndarray的形式

#将嵌套序列转换为ndarray
l1 = [range(10),range(10)]
data = np.array(l1)
print(\'数据类型\',type(data))
print(\'数据的维度的大小为：\',data.shape)
print(\'数组的维数为：\',data.ndim)

　　(4)np.zeros(shape, dtype=float, order=\'C\')   #注意这里shape是一个元组，对于其他的几个数据结构同理

#np.zeros np.ones 和np.empty
#np.zeros
zeros_arr = np.zeros((3,4),dtype=float)   #生成一个3行4列的全0数组 ，其中的数据类型是int
print(\'zeros_arr\',zeros_arr)

ones_arr = np.ones((3,4),dtype=float)    #生成一个3行4列的全1数组数据类型为float类型
print(\'ones_arr\',ones_arr)

empty_arr = np.empty((3,4))
print(\'empty_arr\',empty_arr)

empty_int_arr = np.empty((3,4),dtype=int)
print(\'empty_int_arr\',empty_int_arr)

　　(5)np.arange()

print(np.arange(10))   #生成0到9的数组
print(type(np.arange(10)))   #数据类型是numpy.ndarray的数据类型

　　(6)生成一个全0的矩阵

zero_float_arr = np.zeros((3,4),dtype=np.float)
print(zero_float_arr)
print(type(zero_float_arr))   #数组的数据类型是numpy.ndarray
print(zero_float_arr.dtype)    #

# 使用astype做数据类型的转换
zero_int_arr = zero_float_arr.astype(np.int)
print(type(zero_int_arr))
print(zero_int_arr.dtype)

　　(7)矢量的计算

arr = np.array([[1,2,3],[4,5,6]])　　#生成一个列表，使用np.array方法将一个列表转换为np.array
print(arr)   
print(type(arr))   #打印出数组的数据类型
print(arr.dtype)　　#打印出数据类型

　　(8)矩阵的运算

#产生一个2行3列的二维矩阵
arr = np.array([[1,2,3],[4,5,6]])
print(arr)
print(type(arr))
print(arr.dtype)

# 将矩阵进行相乘的运算，这个地方要注意，直接将矩阵进行乘法运算，是将矩阵中元素进行位置上的乘法运算
print(\'矩阵中的元素相乘arr*arr\',arr*arr)

#将矩阵进行加法的运算
print(\'arr+arr\',arr+arr)

# 实现矢量与标量的运算，矢量与标量运算的时候需要进行广播
print(\'1/arr=\\n\',1./arr)   #矩阵的除法
print(\'2*arr=\\n\',2*arr)

　　(9)数组的切片操作

arr1 = np.arange(10)   #产生一个10个元素的数组
print(type(arr1))    #数据结构仍然是numpy.ndarray
print(arr1.dtype)   #元素的数据类型仍然是int32类型
print(arr1)     #
print(arr1[2:5])   #切片操作 ，左闭右开的切片

arr2 = np.arange(12).reshape(3,4)   #产生一个3行4列的二维数组
print(arr2)
print(arr2[1])    #切片操作，切出数组中第一行的数据，出数组的第一行
print(arr2[0:2,1:])  #切片操作，切除第0行第一行以及第一列之后的数组
print(arr2[:,1:3])  #切片操作，切出所有的行，以及第1列，第2列的数据

　　(10)条件索引

#找出data_arr中2015年以后的数据
data_arr = np.random.rand(3,3)   # 创建一个3行3列的二维随机数组
print(\'data_arr \\n\',data_arr)

year_arr = np.array([[2000,2001,2000],[2005,2002,2009],[2001,2003,2010]])
print(\'year_arr \\n\',year_arr)

filtered_arr=data_arr[year_arr>2005]
print(\'filtered_arr \\n\',filtered_arr)

#多条件索引

#多个条件索引
filtered_arr = data_arr[(year_arr<=2005) & (year_arr%2==0)]   #打印出年份小于2005年并且为偶数年份的数据
# print(year_arr[(year_arr<=2005) & (year_arr%2==0)])
print(\'filtered_arr\',filtered_arr)

　　(11)二维矩阵的转置

arr1 = np.random.rand(2,3)  #生成一个2行3列的二维数组
print(\'arr1=\\n\',arr1)
print(\'arr1数组的转置为:\\n\',arr1.transpose())

　　(12)三维矩阵及其转置

#3维矩阵
arr3d = np.random.rand(2,3,4)
print(\'arr3d=\\n\',arr3d)
print(\'================================\')
print(arr3d.transpose((1,0,2)))

　　(13)常见运算（np.around、np.floor、np.ceil、np.where）

　　　　①p.ceil 函数返回输入值的上限,就是向上取整，即对于输入 x ，返回最小的整数 i ，使得 i> = x。

arr = np.random.randn(2,3)   #生成量行3列的随机数组
print(arr)

　　　　②np.floor 返回不大于输入参数的最大整数。 即对于输入值 x ，将返回最大的整数 i ，使得 i <= x。 注意在Python中，向下取整总是从 0 舍入。

print(\'np.floor(arr)=\\n\',np.floor(arr))

　　　　③np.rint()是根据四舍五入取整

print(\'np.rint(arr)=\\n\',np.rint(arr))

　　　　④np.isnan(arr)是判断数组的每个元素是不是NaN数据类型

print(\'np.isnan(arr)=\\n\',np.isnan(arr))

　　　　⑤np.where(condition, x, y)，满足条件(condition)，输出x，不满足输出y。

#np.where
arr1 = np.random.rand(3,4)
print(arr1)
print(np.where(arr1>0.5,1,-1))

　　　14.数组求和

arr1 = np.random.rand(5,2)
print(\'arr1=\\n\',arr1)
print(\'np.sum(arr1)=\\n\',np.sum(arr1))  #对数组进行求和
print(\'np.sum(arr1),axis=0\',np.sum(arr1,axis=0))   #在列的方向进行求和
print(\'np.sum(arr1),axis=1\',np.sum(arr1,axis=1))   #在行的方向进行求和

　　　15.

　　　　np.array.any()是或操作，将np.array中所有元素进行或操作，然后返回True或False

　　　　np.array.all()是与操作，将np.array中所有元素进行与操作，然后返回True或False

arr1 = np.random.randn(2,3)
print(arr1)
print(np.any(arr1>0))
print(np.all(arr1>0))

[[-0.03475223 0.21371993 0.84167799]
[ 1.60330052 0.02812848 1.37971765]]
True
False

　　　　16unique操作

arr1 = np.array([[1,2,1],[2,3,4]])
print(\'arr1\',arr1)
print(\'np.unique(arr1)\',np.unique(arr1))