Numpy学习与总结

Numpy环境安装

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple numpy 

NumPy Ndarray 对象

1. N 维数组对象 ndarray：

   • ndarray 是 NumPy 中用于存放同类型元素的多维数组，可以是一维、二维等多维度的数组。

2. 以 0 下标为开始进行集合中元素的索引：

   • 与 Python 中的列表类似，NumPy 数组也是从 0 开始索引的。

3. 每个元素在内存中有相同存储大小的区域：

   • 大部分情况下正确。NumPy 数组中的元素通常是同一数据类型，因此它们在内存中占用的空间是固定的，但在某些情况下（比如使用结构化数组或对象数组），元素可能有不同的大小。

4. ndarray 内部的组成：

   • 描述了ndarray 的基本组成部分：

     • 指向数据的指针，即数组在内存中的起始位置。

     • 数据类型（dtype），描述数组中元素的类型。

     • 形状（shape），表示数组每个维度的大小。

     • 跨度（strides），是一个元组，指示在内存中移动到当前维度的下一个元素所需跨过的字节数。

5. 负数的跨度：

   • 跨度可以是负数。负的跨度意味着在某个维度上数组是后向移动的。例如，使用 obj[::-1] 或 obj[:,::-1] 这样的切片操作会在对应的维度上逆序访问数组的元素。

参数说明：

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的内存存储样式，C为行方向，F为列方向，A为任意方向（默认）
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

NumPy 数组属性

1. 秩（rank）：

   • 在 NumPy 中，秩指的是数组的维数，即它有多少个轴。一维数组的秩为 1，二维数组的秩为 2，以此类推。

2. 轴（axis）：

   • 轴是数组的一个维度。例如，对于二维数组，第一个轴是沿着行的方向，第二个轴是沿着列的方向。

3. 声明 axis：

   • 在 NumPy 操作中，很多函数和方法可以接受一个参数 axis，用来指定沿着哪个轴进行操作。例如，axis=0 表示沿着第 0 轴（行）进行操作，而 axis=1 表示沿着第 1 轴（列）进行操作。

4. 一维数组和轴：

   • 一维数组在 NumPy 中也被视作有一个轴。这个轴是数组中唯一的维度，通常用于表示线性的数据序列。

5. 二维数组的理解：

   • 二维数组可以看作是一系列一维数组的集合，其中每个一维数组称为一个轴（axis）。第一个轴（axis 0）是整个数组中的每一行，第二个轴（axis 1）是每一列。

NumPy 的数组中比较重要 ndarray 对象属性有：

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息

1、ndarray.ndim

#用于返回数组的维数，等于秩。
import numpy as np  
a=np.array(20)
print(a.ndim)
b=np.array([[2,5],[1,4]])
print(a.ndim)

2、ndarray.shape

#表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。
import numpy as np
a=np.array([[13,3,4],[1,4,23]])
import numpy as np  
a=np.array([[13,3,4],[1,4,23]])
print(a.shape)
调整数组大小
#1*
a=np.array([1,2,3,4,5,6,7,8])
a.shape=(4,2)
print(a)
a.shape=(2,2,2)
print(a)
#2*
a=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
b=a.reshape(3,4)
print(b)

NumPy 创建数组

1、numpy.empty

"""
创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：
numpy.empty(shape, dtype = float, order = 'C')
"""
import numpy as np
x=np.empty([2,2],dtype=int)
print(x)

2、numpy.zeros

"""
创建指定大小的数组，数组元素以 0 来填充:
numpy.zeros(shape, dtype = float, order = 'C')
"""
import numpy as np
x=np.zeros(10)#默认为浮点数
print(x)
y=np.zeros((2,),dtype=int)
print(y)

3、numpy.ones

​
"""
创建指定形状的数组，数组元素以1来填充：
numpy.ones(shape, dtype = None, order = 'C')
"""
import numpy as np
x=np.ones(6)#默认为浮点数
print(x)
x=np.ones([3,3],dtype=complex)
print(x)

4、numpy.zeros_like

"""
创建一个与给定数组具有相同形状的数组，数组元素以0来填充
numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
"""
import numpy as np
arr=np.array([[1,2],[3,4]])
zeros_arr=np.zeros_like(arr)
print(zeros_arr)

5、numpy.ones_like

"""
创建一个与给定数组具有相同形状的数组，数组元素以1来填充：
numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)
"""
import numpy as np
arr=np.array([[1,2,3],[4,5,6],[7,8,9]])
ones_arr=np.ones_like(arr)
print(ones_arr)

NumPy 从已有的数组创建数组

1、numpy.asarray

"""
numpy.asarray(a, dtype = None, order = None)
"""
#将列表,元组，元组列表转化为ndarray
import numpy as np
x=[1,2,2]
y=(3,4)
z=[x,y]
print(np.asarray(x))
print(np.asarray(y))
print(np.asarray(z))
#转化并且设置dtype参数
X=[1,2,3]
a=np.asarray(X,dtype=float)
print(a)

2、numpy.fromiter

"""
从可迭代对象中建立 ndarray 对象，返回一维数组:
numpy.fromiter(iterable, dtype, count=-1)
"""
import numpy as np
list=range(10)
item=iter(list)
a=np.fromiter(item,dtype=float)
print(a)

NumPy 从数值范围创建数组

1、numpy.arange

"""
使用 arange 函数创建数值范围并返回 ndarray 对象:
numpy.arange(start, stop, step, dtype)
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
"""
import numpy as np
x=np.arange(10) #stop=10
print(x)
x=np.arange(2,5)#start=2,stop=5
print(x)
x=np.arange(3,12,2)#start=3,stop=12,step=2
print(x)

2、numpy.linspace

"""
创建一个一维数组，数组是一个等差数列构成的
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
"""
import numpy as np
a=np.linspace(1,10,10)
print(a)
a=np.linspace(1,1,5)
print(a)
a=np.linspace(10,20,5,endpoint=False)
print(a)
a=np.linspace(1,10,10,retstep=True)
print(a)
b=np.linspace(1,10,10).reshape([10,1])
print(b)

NumPy 切片

#切片
import numpy as np
a=np.arange(10)
s=slice(2,5,2)
print(a[s])
b=a[2:5:2]
print(b)
b=a[5]
print(b)
print(a[2:])
print(a[1:4])
a=np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a[1:])
print(a[...,1])
print(a[1,...])
print(a[...,1:])

练习

#test:10x10
"""
随机生成10X10的数组，x_trian为前9列的80%的数据，x_test为前9列的20%的数据，y_trian为剩下一列的80%，y_test为剩下一列的20%
"""
arr=np.arange(100).reshape(10,10)
print(arr)
x=arr[:,:9]
y=arr[:,9]
split=int(0.8 * arr.shape[0])
x_train=x[:split,:]
x_test=x[split:,:]
y_train=y[:split]
y_test=y[split:]
print("x_train,\n",x_train)
print("x_test,\n",x_test)
print("y_train,\n",y_train)
print("y_test,\n",y_test)

NumPy 高级索引

1.高级索引
整数数组索引
import numpy as np
x=np.array([[1,2],[3,4],[5,6]])
y=x[[0,1,2],[0,1,0]]#(0,0) (1,1)  (2,0)
print(y)

获取 3x4 数组中的四个角的元素
x = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(x)
print(x.shape)
rows=np.array([[0, 0], [2, 2]])
cols=np.array([[0, 3], [0, 3]])
y=x[rows, cols]
print(y)

可以借助切片 : 或 … 与索引数组组合

import numpy as np
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
b=a[1:2,2:3]
c=a[1:3,[1,2]]
d=a[...,1:]
print(b)
print(c)
print(d)

2.布尔索引
取大于 5 的元素
import numpy as np
x=np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(x[x>5])
使用 ~（取补运算符）来过滤 NaN
a=np.array([1,3,np.nan,5,4])
print(a[~np.isnan(a)])
从数组中过滤掉非复数元素
a = np.array([2,  1+3j,  5,  1.5+4j])
print (a[np.iscomplex(a)])

3.花式索引
import numpy as np
x=np.arange(6)
x1=x[[0,4]]
print(x1)
print(x1[0])
传入顺序索引数组
x=np.arange(24).reshape(6,4)
print(x)
print(x[[2,3,1,5]])
print(x[[2,3,1,5],[1,3,2,0]])
传入倒序索引数组
x=np.arange(24).reshape(6,4)
print(x[[-2,-3,-1,-5]])