Python Numpy入门基础（二）数组操作

川长思鸟来 2023-10-14 09:14 57阅读 0赞

![9a6d821e8f414c749ef1143368e115ee.png][]

## 入门基础（二） ##

NumPy是Python中一个重要的数学运算库，它提供了了一组多维数组对象和一组用于操作这些数组的函数。以下是一些NumPy的主要特点：

1.  多维数组对象：NumPy的核心是ndarray对象，它是一个多维数组对象，可以容纳任意数据类型。
2.  矢量化操作：使用NumPy的函数，可以对整个数组进行操作，而不需要显式循环。
3.  广播：NumPy的广播机制允许对不同形状的数组执行算术操作，而无需进行显式循环或手动对齐。
4.  易于扩展：NumPy可以用C或C++扩展，以加速大型数值计算任务。
5.  强大的函数库：NumPy提供了许多用于线性代数、傅里叶分析、随机数生成等领域的函数。
6.  易于使用：NumPy与Python的内置数据结构无缝集成，因此可以轻松地将Python代码转换为使用NumPy。

### 数组操作 ###

#### 组索引和切片 ####

索引从0开始，索引值不能超过长度，否则会报IndexError错误。

##### 一维数组的索引和切片 #####

>>> import numpy as np
    >>> a = np.array([1,2,3,4,5])
    >>> a[2]
    3
    >>> a[1:4:2]
    array([2, 4])
    >>> a[1:3]
    array([2, 3])
    >>> a[0::2]
    array([1, 3, 5])
    >>> a[5]
    Traceback (most recent call last):
      File "<pyshell#15>", line 1, in <module>
        a[5]
    IndexError: index 5 is out of bounds for axis 0 with size 5

##### 多维数组的索引 #####

>>> import numpy as np
    >>> a = np.arange(24).reshape((2,3,4))
    >>> a
    array([[[ 0,  1,  2,  3],
            [ 4,  5,  6,  7],
            [ 8,  9, 10, 11]],
    
           [[12, 13, 14, 15],
            [16, 17, 18, 19],
            [20, 21, 22, 23]]])
    >>> a[1,2,3]
    23
    >>> a[-1,-2,-3]
    17
    >>> a[0,2,2]
    10
    >>> a[0,3,3]
    Traceback (most recent call last):
      File "<pyshell#12>", line 1, in <module>
        a[0,3,3]
    IndexError: index 3 is out of bounds for axis 1 with size 3

##### 多维数组切片 #####

>>> import numpy as np
    >>> a = np.arange(24).reshape((2,3,4)) + 1
    >>> a
    array([[[ 1,  2,  3,  4],
            [ 5,  6,  7,  8],
            [ 9, 10, 11, 12]],
    
           [[13, 14, 15, 16],
            [17, 18, 19, 20],
            [21, 22, 23, 24]]])
    >>> a[:1,2]
    array([[ 9, 10, 11, 12]])
    >>> a[:,1:3,:]
    array([[[ 5,  6,  7,  8],
            [ 9, 10, 11, 12]],
    
           [[17, 18, 19, 20],
            [21, 22, 23, 24]]])
    >>> a[:,:,::2]
    array([[[ 1,  3],
            [ 5,  7],
            [ 9, 11]],
    
           [[13, 15],
            [17, 19],
            [21, 23]]])
    >>> a[:,:,1::2]
    array([[[ 2,  4],
            [ 6,  8],
            [10, 12]],
    
           [[14, 16],
            [18, 20],
            [22, 24]]])
    >>> a[1:3,:,:]
    array([[[13, 14, 15, 16],
            [17, 18, 19, 20],
            [21, 22, 23, 24]]])
    >>> a[1:3,1:3,:]
    array([[[17, 18, 19, 20],
            [21, 22, 23, 24]]])
    >>> a[1:3,1:3,1:3]
    array([[[18, 19],
            [22, 23]]])

##### 通过布尔数组访问数组元素 #####

>>> import numpy as np
    >>> a = np.array([1, 2, 3, 4, 5])
    >>> b = np.array([True, False, True, False, True])
    >>> a[b]
    array([1, 3, 5])
    >>> b = np.array([False, True, False, True, False])
    >>> a[b]
    array([2, 4])
    >>> b = a<=3
    >>> a[b]
    array([1, 2, 3])
    >>> b = a%2==0
    >>> a[b]
    array([2, 4])
    >>> b = a%2==1
    >>> a[b]
    array([1, 3, 5])

--------------------

#### 数组的整体操作 ####

##### 数组的拼接 #####

在 NumPy 中，可以使用多种方法来拼接数组。以下是一些常用的方法：

###### numpy.concatenate() ######

这个函数用于连接两个数组，沿指定的轴在末尾添加第二个数组的元素。

>>> a = np.array([[1, 2], [3, 4]])
    >>> b = np.array([[5, 6]])
    >>> np.concatenate((a, b), axis=0)
    array([[1, 2],
          [3, 4],
          [5, 6]])
    >>> np.concatenate((a, b.T), axis=1)
    array([[1, 2, 5],
          [3, 4, 6]])
    >>> np.concatenate((a, b), axis=None)
    array([1, 2, 3, 4, 5, 6])

###### numpy.vstack() ######

这个函数用于垂直方向拼接数组，即行方向添加第二个数组的元素。

>>> a = np.array([1, 2, 3])
    >>> b = np.array([4, 5, 6])
    >>> np.vstack((a,b))
    array([[1, 2, 3],
          [4, 5, 6]])
    
    >>> a = np.array([[1], [2], [3]])
    >>> b = np.array([[4], [5], [6]])
    >>> np.vstack((a,b))
    array([[1],
          [2],
          [3],
          [4],
          [5],
          [6]])

###### numpy.hstack() ######

这个函数用于水平方向拼接数组，即列方向添加第二个数组的元素。

>>> a = np.array((1,2,3))
    >>> b = np.array((4,5,6))
    >>> np.hstack((a,b))
    array([1, 2, 3, 4, 5, 6])
    >>> a = np.array([[1],[2],[3]])
    >>> b = np.array([[4],[5],[6]])
    >>> np.hstack((a,b))
    array([[1, 4],
           [2, 5],
           [3, 6]])

###### numpy.row\_stack() ######

这个函数是vstack的alias，别名就是同一个函数。

>>> import numpy as np
    >>> a = np.array([[1, 2], [3, 4]])
    >>> b = np.array([[5, 6]])
    >>> np.row_stack((a, b))
    array([[1, 2],
           [3, 4],
           [5, 6]])

在使用这些函数时，需要确保拼接的数组具有相同的维度，或者在使用 numpy.column\_stack() 时具有相同的列数。如果维度不同，可以使用 numpy.reshape() 函数对数组进行重塑。

##### 数组的翻转 #####

在 NumPy 中，也有多种方法可以翻转数组。以下是一些常用的方法：

numpy.flip()

这个函数用于沿指定的轴翻转数组。

> Examples  
> \--------  
> >>> A = np.arange(8).reshape((2,2,2))  
> >>> A  
> array(\[\[\[0, 1\],  
> \[2, 3\]\],  
> \[\[4, 5\],  
> \[6, 7\]\]\])  
> >>> np.flip(A, 0)  
> array(\[\[\[4, 5\],  
> \[6, 7\]\],  
> \[\[0, 1\],  
> \[2, 3\]\]\])  
> >>> np.flip(A, 1)  
> array(\[\[\[2, 3\],  
> \[0, 1\]\],  
> \[\[6, 7\],  
> \[4, 5\]\]\])  
> >>> np.flip(A)  
> array(\[\[\[7, 6\],  
> \[5, 4\]\],  
> \[\[3, 2\],  
> \[1, 0\]\]\])  
> >>> np.flip(A, (0, 2))  
> array(\[\[\[5, 4\],  
> \[7, 6\]\],  
> \[\[1, 0\],  
> \[3, 2\]\]\])  
> >>> A = np.random.randn(3,4,5)  
> >>> np.all(np.flip(A,2) == A\[:,:,::-1,...\])  
> True

numpy.flipud()

这个函数用于垂直方向翻转数组，即行方向翻转。

> Examples  
> \--------  
> >>> A = np.diag(\[1.0, 2, 3\])  
> >>> A  
> array(\[\[1., 0., 0.\],  
> \[0., 2., 0.\],  
> \[0., 0., 3.\]\])  
> >>> np.flipud(A)  
> array(\[\[0., 0., 3.\],  
> \[0., 2., 0.\],  
> \[1., 0., 0.\]\])  
>   
> >>> A = np.random.randn(2,3,5)  
> >>> np.all(np.flipud(A) == A\[::-1,...\])  
> True  
>   
> >>> np.flipud(\[1,2\])  
> array(\[2, 1\])

numpy.fliplr()

这个函数用于水平方向翻转数组，即列方向翻转。

> Examples  
> \--------  
> >>> A = np.diag(\[1.,2.,3.\])  
> >>> A  
> array(\[\[1., 0., 0.\],  
> \[0., 2., 0.\],  
> \[0., 0., 3.\]\])  
> >>> np.fliplr(A)  
> array(\[\[0., 0., 1.\],  
> \[0., 2., 0.\],  
> \[3., 0., 0.\]\])  
>   
> >>> A = np.random.randn(2,3,5)  
> >>> np.all(np.fliplr(A) == A\[:,::-1,...\])  
> True

在使用这些函数时，需要确保数组的维度适合进行翻转。

##### 数组的复制 #####

> Examples  
> \--------  
> Create an array x, with a reference y and a copy z:  
>   
> >>> x = np.array(\[1, 2, 3\])  
> >>> y = x  
> >>> z = np.copy(x)  
>   
> Note that, when we modify x, y changes, but not z:  
>   
> >>> x\[0\] = 10  
> >>> x\[0\] == y\[0\]  
> True  
> >>> x\[0\] == z\[0\]  
> False  
>   
> Note that, np.copy clears previously set WRITEABLE=False flag.  
>   
> >>> a = np.array(\[1, 2, 3\])  
> >>> a.flags\["WRITEABLE"\] = False  
> >>> b = np.copy(a)  
> >>> b.flags\["WRITEABLE"\]  
> True  
> >>> b\[0\] = 3  
> >>> b  
> array(\[3, 2, 3\])  
>   
> Note that np.copy is a shallow copy and will not copy object  
> elements within arrays. This is mainly important for arrays  
> containing Python objects. The new array will contain the  
> same object which may lead to surprises if that object can  
> be modified (is mutable):  
>   
> >>> a = np.array(\[1, 'm', \[2, 3, 4\]\], dtype=object)  
> >>> b = np.copy(a)  
> >>> b\[2\]\[0\] = 10  
> >>> a  
> array(\[1, 'm', list(\[10, 3, 4\])\], dtype=object)  
>   
> To ensure all elements within an \`\`object\`\` array are copied,  
> use \`copy.deepcopy\`:  
>   
> >>> import copy  
> >>> a = np.array(\[1, 'm', \[2, 3, 4\]\], dtype=object)  
> >>> c = copy.deepcopy(a)  
> >>> c\[2\]\[0\] = 10  
> >>> c  
> array(\[1, 'm', list(\[10, 3, 4\])\], dtype=object)  
> >>> a  
> array(\[1, 'm', list(\[2, 3, 4\])\], dtype=object)

##### 数组的排序 #####

> Examples  
> \--------  
> >>> a = np.array(\[\[1,4\],\[3,1\]\])  
> >>> np.sort(a) \# sort along the last axis  
> array(\[\[1, 4\],  
> \[1, 3\]\])  
> >>> np.sort(a, axis=None) \# sort the flattened array  
> array(\[1, 1, 3, 4\])  
> >>> np.sort(a, axis=0) \# sort along the first axis  
> array(\[\[1, 1\],  
> \[3, 4\]\])  
>   
> Use the \`order\` keyword to specify a field to use when sorting a  
> structured array:  
>   
> >>> dtype = \[('name', 'S10'), ('height', float), ('age', int)\]  
> >>> values = \[('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),  
> ... ('Galahad', 1.7, 38)\]  
> >>> a = np.array(values, dtype=dtype) \# create a structured array  
> >>> np.sort(a, order='height') \# doctest: +SKIP  
> array(\[('Galahad', 1.7, 38), ('Arthur', 1.8, 41),  
> ('Lancelot', 1.8999999999999999, 38)\],  
> dtype=\[('name', '|S10'), ('height', '<f8'), ('age', '<i4')\])  
>   
> Sort by age, then height if ages are equal:  
>   
> >>> np.sort(a, order=\['age', 'height'\]) \# doctest: +SKIP  
> array(\[('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),  
> ('Arthur', 1.8, 41)\],  
> dtype=\[('name', '|S10'), ('height', '<f8'), ('age', '<i4')\])

--------------------

#### 数组的数学操作 ####

##### 加法 #####

>>> added\_arr = arr1 + arr2

##### 减法 #####

>>> subtracted\_arr = arr1 - arr2

##### 乘法 #####

>>> multiplied\_arr = arr1 \* arr2

##### 除法 #####

>>> divided\_arr = arr1 / arr2

###### 幂运算 ######

>>> power\_arr = np.power(arr1, arr2)

--------------------

#### 数组的统计操作 ####

##### 均值 #####

mean = np.mean(arr)

> Examples  
> \--------  
> >>> a = np.array(\[\[1, 2\], \[3, 4\]\])  
> >>> np.mean(a)  
> 2.5  
> >>> np.mean(a, axis=0)  
> array(\[2., 3.\])  
> >>> np.mean(a, axis=1)  
> array(\[1.5, 3.5\])  
>   
> In single precision, \`mean\` can be inaccurate:  
>   
> >>> a = np.zeros((2, 512\*512), dtype=np.float32)  
> >>> a\[0, :\] = 1.0  
> >>> a\[1, :\] = 0.1  
> >>> np.mean(a)  
> 0.54999924  
>   
> Computing the mean in float64 is more accurate:  
>   
> >>> np.mean(a, dtype=np.float64)  
> 0.55000000074505806 \# may vary  
>   
> Specifying a where argument:  
>   
> >>> a = np.array(\[\[5, 9, 13\], \[14, 10, 12\], \[11, 15, 19\]\])  
> >>> np.mean(a)  
> 12.0  
> >>> np.mean(a, where=\[\[True\], \[False\], \[False\]\])  
> 9.0

##### 方差 #####

var = np.var(arr)

> Examples  
> \--------  
> >>> a = np.array(\[\[1, 2\], \[3, 4\]\])  
> >>> np.var(a)  
> 1.25  
> >>> np.var(a, axis=0)  
> array(\[1., 1.\])  
> >>> np.var(a, axis=1)  
> array(\[0.25, 0.25\])  
>   
> In single precision, var() can be inaccurate:  
>   
> >>> a = np.zeros((2, 512\*512), dtype=np.float32)  
> >>> a\[0, :\] = 1.0  
> >>> a\[1, :\] = 0.1  
> >>> np.var(a)  
> 0.20250003  
>   
> Computing the variance in float64 is more accurate:  
>   
> >>> np.var(a, dtype=np.float64)  
> 0.20249999932944759 \# may vary  
> >>> ((1-0.55)\*\*2 + (0.1-0.55)\*\*2)/2  
> 0.2025  
>   
> Specifying a where argument:  
>   
> >>> a = np.array(\[\[14, 8, 11, 10\], \[7, 9, 10, 11\], \[10, 15, 5, 10\]\])  
> >>> np.var(a)  
> 6.833333333333333 \# may vary  
> >>> np.var(a, where=\[\[True\], \[True\], \[False\]\])  
> 4.0

##### 标准差 #####

std = np.std(arr)

> Examples  
> \--------  
> >>> a = np.array(\[\[1, 2\], \[3, 4\]\])  
> >>> np.std(a)  
> 1.1180339887498949 \# may vary  
> >>> np.std(a, axis=0)  
> array(\[1., 1.\])  
> >>> np.std(a, axis=1)  
> array(\[0.5, 0.5\])  
>   
> In single precision, std() can be inaccurate:  
>   
> >>> a = np.zeros((2, 512\*512), dtype=np.float32)  
> >>> a\[0, :\] = 1.0  
> >>> a\[1, :\] = 0.1  
> >>> np.std(a)  
> 0.45000005  
>   
> Computing the standard deviation in float64 is more accurate:  
>   
> >>> np.std(a, dtype=np.float64)  
> 0.44999999925494177 \# may vary  
>   
> Specifying a where argument:  
>   
> >>> a = np.array(\[\[14, 8, 11, 10\], \[7, 9, 10, 11\], \[10, 15, 5, 10\]\])  
> >>> np.std(a)  
> 2.614064523559687 \# may vary  
> >>> np.std(a, where=\[\[True\], \[True\], \[False\]\])  
> 2.0

##### 最大值、最小值 #####

max\_value = np.max(arr)

> Examples  
> \--------  
> >>> a = np.arange(4).reshape((2,2))  
> >>> a  
> array(\[\[0, 1\],  
> \[2, 3\]\])  
> >>> np.amax(a) \# Maximum of the flattened array  
> 3  
> >>> np.amax(a, axis=0) \# Maxima along the first axis  
> array(\[2, 3\])  
> >>> np.amax(a, axis=1) \# Maxima along the second axis  
> array(\[1, 3\])  
> >>> np.amax(a, where=\[False, True\], initial=-1, axis=0)  
> array(\[-1, 3\])  
> >>> b = np.arange(5, dtype=float)  
> >>> b\[2\] = np.NaN  
> >>> np.amax(b)  
> nan  
> >>> np.amax(b, where=~np.isnan(b), initial=-1)  
> 4.0  
> >>> np.nanmax(b)  
> 4.0  
>   
> You can use an initial value to compute the maximum of an empty slice, or  
> to initialize it to a different value:  
>   
> >>> np.amax(\[\[-50\], \[10\]\], axis=-1, initial=0)  
> array(\[ 0, 10\])  
>   
> Notice that the initial value is used as one of the elements for which the  
> maximum is determined, unlike for the default argument Python's max  
> function, which is only used for empty iterables.  
>   
> >>> np.amax(\[5\], initial=6)  
> 6  
> >>> max(\[5\], default=6)  
> 5

min\_value = np.min(arr)

> Examples  
> \--------  
> >>> a = np.arange(4).reshape((2,2))  
> >>> a  
> array(\[\[0, 1\],  
> \[2, 3\]\])  
> >>> np.amin(a) \# Minimum of the flattened array  
> 0  
> >>> np.amin(a, axis=0) \# Minima along the first axis  
> array(\[0, 1\])  
> >>> np.amin(a, axis=1) \# Minima along the second axis  
> array(\[0, 2\])  
> >>> np.amin(a, where=\[False, True\], initial=10, axis=0)  
> array(\[10, 1\])  
>   
> >>> b = np.arange(5, dtype=float)  
> >>> b\[2\] = np.NaN  
> >>> np.amin(b)  
> nan  
> >>> np.amin(b, where=~np.isnan(b), initial=10)  
> 0.0  
> >>> np.nanmin(b)  
> 0.0  
>   
> >>> np.amin(\[\[-50\], \[10\]\], axis=-1, initial=0)  
> array(\[-50, 0\])  
>   
> Notice that the initial value is used as one of the elements for which the  
> minimum is determined, unlike for the default argument Python's max  
> function, which is only used for empty iterables.  
>   
> Notice that this isn't the same as Python's \`\`default\`\` argument.  
>   
> >>> np.amin(\[6\], initial=5)  
> 5  
> >>> min(\[6\], default=5)  
> 6

![9a6d821e8f414c749ef1143368e115ee.png][]

[9a6d821e8f414c749ef1143368e115ee.png]: https://img-blog.csdnimg.cn/9a6d821e8f414c749ef1143368e115ee.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASGFubiBZYW5n,size_20,color_FFFFFF,t_70,g_se,x_16