numpy学习

NumPy(Numeric Python)

多维数组对象和用于处理数组的例程集合组成的库

dtype(数据类型对象)

描述了对应于数组的固定内存块的解释，取决于以下几个方面：

数据类型（整数、浮点或者python对象）

数据大小

字节序（大端或小端）

在结构化类型的情况下，字段的名称每个字段的数据类型，和每个字段占用的内存块部分。

如果数据类型是子序列，它的形状和数据类型。

import numpy as np
dt=np.dtype(np.int32)
print(dt)
​
dt=np.dtype('i4')
print(dt)
​
dt=np.dtype('>i4')
print(dt)
​

数组属性

axis=0表示沿着第0轴进行操作，即对每一列进行操作；

axis=1表示沿着第1轴进行操作，即对每一行进行操作；

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息
ndarray.real	ndarray元素的实部
ndarray.imag	ndarray 元素的虚部
ndarray.data	包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

创建数组

numpy.zeros(shape,dtype=float,order='C')

参数说明：数组形状，数组类型，可选，‘C'用于C的行数组，或者’F‘用于FORTRAN

ndarray

一种多维数组对象，是一个通用的同构数据多维容器，其中所有的元素必须是相同类型的

import numpy as np
#1.创建数组
#使用array函数，接受一切序列型对象（包括其他数组），然后产生一个新的含有传入数据的numpy数组
data=[1,1,2,3]
print(np.array(data))#[1 1 2 3]
​
#嵌套序列,转化成多维数组
data2=[[1,1,1,1],[2,2,2,2]]
arr2=np.array(data2)
print(arr2)
#[[1 1 1 1]
 # [2 2 2 2]]
print(arr2.ndim)#2
print(arr2.shape)#(2, 4)
#创建全0，全1数组
print(np.zeros(10))
print(np.ones((3,5)))
print(np.empty((2,3,4)))
​
#2.数据类型
arr=np.array([1,2,3])
print(arr.dtype)#int32
float_array=arr.astype(np.float64)
print(float_array.dtype)#float64

numpy数组的运算

特点：矢量化(大小相等的数组之间的任何算术运算都会应用到元素级)、广播(数组与标量的算是运算会传播到各个元素)

arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.array([[2,3,4],[5,6,7]])
print(arr1+arr2)
# [[ 3  5  7]
 # [ 9 11 13]]
print(1/arr1)
# [[1.         0.5        0.33333333]
 # [0.25       0.2        0.16666667]]
# 大小相同的数组之间的比较生成布尔值数组
print(arr2>arr1)
# [[ True  True  True]
 # [ True  True  True]]

基本的切片和索引

将标量赋值给数组的切片也会广播

数组的切片是原始数组的视图，即数据不会被复制，视图上的任何修改都会直接反映到原数组上

arr3=np.arange(10)
print(arr3)#[0 1 2 3 4 5 6 7 8 9]
arr3[5:8]=10
print(arr3)#[ 0  1  2  3  4 10 10 10  8  9]
arr4=arr3[5:8]
arr4[:]=5
print(arr3)#[0 1 2 3 4 5 5 5 8 9]
arr4[1]=12345
print(arr3)#[    0     1     2     3     4     5 12345     5     8     9]
print(arr4)#[    5 12345     5]

如果想要得到ndarray切片的副本而非视图就需要明确地进行复制操作，例如arr[5:8].copy()

高维度数组的访问

#高维度数组的访问
arr5=np.array([[[1,2,3],[4,4,5]],[[3,3,6],[2,2,4]]])
print(arr5[0])
#[[1 2 3]
 # [4 4 5]]
arr5[1]=2
print(arr5)
# [[[1 2 3]
#   [4 4 5]]
# 
#  [[2 2 2]
#   [2 2 2]]]

切片索引

arr6=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr6[:2])#前两行，第0轴切片
# [[1 2 3]
#  [4 5 6]]
print(arr6[:2,1:])#前两行，第1列往后所有
# [[2 3]
#  [5 6]]
print(arr6[:,:1])#所有行，第0列
# [[1]
#  [4]
 # [7]]
arr6[:2,1:]=0
print(arr6)
# [[1 0 0]
#  [4 0 0]
#  [7 8 9]]

布尔型索引

names=np.array(['Amy','Cherry','Amy','Cindy','Cherry'])
data=np.random.randn(5,4)
print(data)
# [[-0.42072297  0.3761964   0.1811894   1.15924724]
#  [-2.06446226 -0.4948006  -0.1654302   0.6866528 ]
#  [ 1.62876039 -1.17275557 -1.28842686  1.34402062]
#  [ 0.37676664  0.49161573 -0.37323651  0.92192948]
#  [ 0.51845432 -0.03713897 -1.54457863  0.40845419]]
#假设每个名字对应data数组中的一行
choice=names=='Amy'
print(choice)#布尔型数组用于索引
# [ True False  True False False]
#注意：布尔型数组的长度必须跟被索引的轴长度一致data和索引数组长度一致
print(data[choice])
# [[-0.42072297  0.3761964   0.1811894   1.15924724]
#  [ 1.62876039 -1.17275557 -1.28842686  1.34402062]]
print(data[choice,2:])
# [[ 0.1811894   1.15924724]
#  [-1.28842686  1.34402062]]
#将data中所有负值设置为0
data[data<0]=0
print(data)
# [[0.         0.3761964  0.1811894  1.15924724]
#  [0.         0.         0.         0.6866528 ]
#  [1.62876039 0.         0.         1.34402062]
#  [0.37676664 0.49161573 0.         0.92192948]
#  [0.51845432 0.         0.         0.40845419]]

花式索引

特定顺序选取子集，传入指定顺序的整数列表或ndarray

arr=np.empty((8,4))
for i in range(8):
    arr[i]=i
print(arr[[4,0,1,2]])
# [[4. 4. 4. 4.]
#  [0. 0. 0. 0.]
#  [1. 1. 1. 1.]
#  [2. 2. 2. 2.]]
print(arr[[-4,-2]])
# [[4. 4. 4. 4.]
#  [6. 6. 6. 6.]]
#一次缠绕多个索引数组会有一点特别，返回的是一个一维数组，其中的元素对应各个索引元组
arr=np.arange(32).reshape((8,4))
print(arr[[1,5,7,2],[0,3,1,2]])
# [ 4 23 29 10]
print(arr[[1,5,7,2]][:,[0,3,1,2]])
# [[ 4  7  5  6]
#  [20 23 21 22]
#  [28 31 29 30]
#  [ 8 11  9 10]]