Numpy进阶

Myth丶恋晨 2023-02-23 08:53 21阅读 0赞

### 文章目录 ###

*  一、基础知识
 *  二、数组创建
 *  三、打印数组
 *  四、基本操作
 *  五、通函数
 *  六、索引、切片和迭代
 *  七、形状操纵
 *   *  7.1 改变数组的形状
     *  7.2 将不同数组堆叠在一起
     *  7.3 将一个数组拆分成几个较小的数组
     *  7.4 拷贝和视图
     *   *  7.4.1 完全不复制
         *  7.4.2 视图或浅拷贝
         *  7.4.3 深拷贝
 *  八、功能和方法概述

# 一、基础知识 #

NumPy的主要对象是同构多维数组。  
NumPy的数组类被调用 ndarray 。它也被别名所知 array 。请注意， numpy.array 这与标准Python  
库类不同 array.array ，后者只处理一维数组并提供较少的功能。ndarray 对象更重要的属性是：

import numpy as np
    
    a = np.arange(15).reshape(3, 5)
    print(a)
    print(a.shape)# 数组的维度：(3, 5)
    print(a.ndim)# 数组的轴（维度）的个数：2
    print(a.dtype)#  一个描述数组中元素类型的对象：int32
    print(a.itemsize)#  数组中每个元素的字节大小# 4
    print(a.data)# 该缓冲区包含数组的实际元素# <memory at 0x0000026DD80E32E8>
    print(a.size)# 数组元素的总数：15
    print(type(a)) # 数组类型：<class 'numpy.ndarray'>

# 二、数组创建 #

（1）你可以使用array函数从常规Python列表或元组中创建数组。得到的数组的类型是从Python列表中元素的类型推导出来的。

import numpy as np
    
    a = np.array([2,3,4])
    print(a)# [2 3 4]
    print(a.dtype)# int32
    b = np.array([1.2,3.5,5.1])
    print(b.dtype)# float64

一个常见的错误，就是调用 array 的时候传入多个数字参数，而不是提供单个数字的列表类型作为参数。

a = np.array(1,2,3,4) # WRONG
    a = np.array([1,2,3,4]) # RIGHT

（2）array 还可以将序列的序列转换成二维数组，将序列的序列的序列转换成三维数组，等等

c = np.array([[(1.4,2.4),(2.1,3.4),(2.3,2.2)]])
    print(c)
    [[[1.4 2.4]
      [2.1 3.4]
      [2.3 2.2]]]

（3）也可以在创建时显式指定数组的类型

c = np.array([[1, 2], [3, 4]], dtype=complex)
    print(c)
    [[1.+0.j 2.+0.j]
     [3.+0.j 4.+0.j]]

（4）NumPy提供了几个函数来创建具有初始占位符内容的数组。这就减少了数组增长的必要，因为数组增长的操作花费很大。

函数 zeros 创建一个由0组成的数组，  
函数 ones 创建一个完整的数组，  
函数 empty 创建一个数组，其初始内容是随机的，取决于内存的状态。  
默认情况下，创建的数组的dtype是 float64 类型的。

a = np.zeros((3,4))
    b = np.ones((2,3,4),dtype=np.int16)
    c = np.empty((2,3))
    print(a)
    print(b)
    print(c)

（5）NumPy提供了一个类似于 range 的函数，该函数返回数组而不是列表。

a = np.arange(10,30,5)
    b = np.arange(0,2,0.3)
    print(a)# [10 15 20 25]
    print(b)# [0.  0.3 0.6 0.9 1.2 1.5 1.8]

（6）linspace 函数来接收我们想要的元素数量的函数。

a = np.linspace( 0, 2, 9 )# 0到2的9个数
    print(a)
    [0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]
    
    x = np.linspace(0,2*np.pi,100)
    f = np.sin(x)

（7）其他函数

# 三、打印数组 #

当打印数组时，NumPy以与嵌套列表类似的方式显示它，但具有以下布局：

*  最后一个轴从左到右打印，
 *  倒数第二个从上到下打印，
 *  其余部分也从上到下打印，每个切片用空行分隔。

然后将一维数组打印为行，将二维数据打印为矩阵，将三维数据打印为矩数组表。

如果**数组太大而无法打印**，NumPy会自动跳过数组的中心部分并仅打印角点。要禁用此行为并强制NumPy打印整个数组，可以使用更改打印选项 **set\_printoptions** 。

import numpy as np
    import sys
    
    np.set_printoptions(threshold=sys.maxsize)
    print(np.arange(10000).reshape(100, 100))

# 四、基本操作 #

数组上的算术运算符会应用到 元素 级别。  
加减乘除、矩阵乘法dot/@、布尔运算

import numpy as np
    
    a = np.array( [20,30,40,50] )
    b = np.arange( 4 )
    c = a-b
    print(c)
    print( b**2)
    print(10*np.sin(a))
    print(a<35)

import numpy as np
    
    A = np.array([[1, 1], [0, 1]])
    B = np.array([[2, 0], [3, 4]])
    print(A * B)
    print(A @ B)
    print(A.dot(B))

某些操作（例如 += 和 \*= ）会更直接更改被操作的矩阵数组而不会创建新矩阵数组。

import numpy as np
    
    a = np.ones((2, 3), dtype=int)
    b = np.random.random((2,3))
    a*=3
    print(a)
    b+=a
    print(b)
    a+=b
    print(a)# 报错（原因：b不会自动转换为整数类型）

当使用不同类型的数组进行操作时，结果数组的类型对应于更一般或更精确的数组（称为向上转换的行  
为）。

import numpy as np
    
    a = np.ones(3, dtype=np.int32)
    b = np.linspace(0,np.pi,3)
    print(a.dtype)# int32
    print(b.dtype)# float64
    c = a+b
    print(c.dtype)# float64
    d = np.exp(c*1j)
    print(d.dtype)# complex128

许多一元操作，例如计算数组中所有元素的总和，都是作为 ndarray 类的方法实现的。默认情况下，这些操作适用于数组，就像它是一个数字列表一样，无论其形状如何。但是，通过指定  
axis 参数，可以**沿数组的指定轴应用操作**。

import numpy as np
    
    b = np.arange(12).reshape(3,4)
    print(b)
    print(np.sum(b,axis=0))
    print(b.min(axis=1))
    print(b.cumsum(axis=1))# axis=0，按照行累加。axis=1，按照列累加。

out:

[[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
     
    [12 15 18 21]
    
    [0 4 8]
    
    [[ 0  1  3  6]
     [ 4  9 15 22]
     [ 8 17 27 38]]

# 五、通函数 #

NumPy提供熟悉的数学函数，例如sin，cos和exp。  
其他：  
![在这里插入图片描述][20200716153122173.png]

import numpy as np
    
    a = np.arange(3)
    print(a)
    print(np.exp(a))
    print(np.sqrt(a))
    b = np.array([2.,-1.,4.])
    print(np.add(a,b))

out：

[0 1 2]
    [1.         2.71828183 7.3890561 ]
    [0.         1.         1.41421356]
    [2. 0. 6.]

# 六、索引、切片和迭代 #

**一维的数组**可以进行索引、切片和迭代操作的，就像 列表 和其他Python序列类型一样。

import numpy as np
    
    a = np.arange(10)**3
    print(a)
    print(a[2])
    print(a[2:5])
    a[:6:2] = -1000
    print(a)
    print(a[::-1])

out：

[  0   1   8  27  64 125 216 343 512 729]
    8
    [ 8 27 64]
    [-1000     1 -1000    27 -1000   125   216   343   512   729]
    [  729   512   343   216   125 -1000    27 -1000     1 -1000]

**多维数组**的索引：

import numpy as np
    
    def f(x, y):
        return 10 * x + y
    
    b = np.fromfunction(f, (5, 4), dtype=int)
    print(list(map(lambda x: x ** 2, range(7))))
    # [0, 1, 4, 9, 16, 25, 36]
    """
    map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。（需要用list接收一下）
    
    np.fromfunction()作用是从函数中创建数组；fromfunction的第二个参数定义了输出数组的形状，也表示i的取值范围。
    """
    print(b)
    print(b[0:5, 1])
    print(b[1:3, :])

out：

[[ 0  1  2  3]
     [10 11 12 13]
     [20 21 22 23]
     [30 31 32 33]
     [40 41 42 43]]
    [ 1 11 21 31 41]
    [[10 11 12 13]
     [20 21 22 23]]

当提供的索引少于轴的数量时，缺失的索引被认为是完整的切片 :

print(b[-1])
    # [40 41 42 43]

b\[i\] 方括号中的表达式 i 被视为后面紧跟着 : 的多个实例，用于表示剩余轴。NumPy也允许你使用三个点写为 b\[i,…\] 。  
三个点（ … ）表示产生完整索引元组所需的冒号。例如，如果 x 是rank为的5数组（即，它具有5个轴），则：  
![在这里插入图片描述][20200717142807882.png]

import numpy as np
    
    a = np.array([[[ 0, 1, 2],
                [ 10, 12, 13]],
                [[100,101,102],
                [110,112,113]]])
    print(a.shape)
    print(a[1,...]) # same as c[1,:,:] or c[1]
    print(a[...,2]) # same as c[:,:,2]

out：

(2, 2, 3)
    [[100 101 102]
     [110 112 113]]
    [[  2  13]
     [102 113]]

对多维数组进行 迭代（Iterating） 是相对于第一个轴完成的：

import numpy as np
    
    def f(x, y):
        return 10 * x + y
    b = np.fromfunction(f, (5, 4), dtype=int)
    print(b)
    for row in b:
        print(row)

out：

[[ 0  1  2  3]
     [10 11 12 13]
     [20 21 22 23]
     [30 31 32 33]
     [40 41 42 43]]
     
    [0 1 2 3]
    [10 11 12 13]
    [20 21 22 23]
    [30 31 32 33]
    [40 41 42 43]

但是，如果想要对数组中的每个元素执行操作，可以使用 flat 属性，该属性是数组的所有元素的迭代器：

import numpy as np
    
    def f(x, y):
        return 10 * x + y
    b = np.fromfunction(f, (5, 4), dtype=int)
    print(b)
    for element in b.flat:
        print(element)

out:

0
    1
    2
    3
    10
    11
    12
    ...
    33
    40
    41
    42
    43

# 七、形状操纵 #

## 7.1 改变数组的形状 ##

一个数组的形状是由每个轴的元素数量决定的：可以使用各种命令更改数组的形状。

import numpy as np
    
    a = np.floor(10*np.random.random((3,4)))
    print(a)
    print(a.ravel())# 展平,如果没有必要，不会产生源数据的副本
    print(a.flatten())# 展平,返回源数据的副本(分配了新的内存）
    print(a.reshape(6,2))
    print(a.T)

如果在 reshape 操作中将 size 指定为-1，则会自动计算其他的 size 大小：

import numpy as np
    
    a = np.floor(10*np.random.random((3,4)))
    z = a.reshape(2,-1)
    print(z.shape)# （2,6）

## 7.2 将不同数组堆叠在一起 ##

np.floor()：向下取整  
np.ceil()：向上取整  
np.around()：四舍五入  
np.where()：条件选取（numpy.where(condition\[, x, y\]) 根据条件 condition 从 x 和 y 中选择元素，当 condition 为 True 时，选 x，否则选 y。）  
np.vstack()：按垂直方向（行顺序）堆叠数组构成一个新的数组  
np.hstack()：按水平方向（列顺序）堆叠数组构成一个新的数组

import numpy as np
    
    a = np.floor(10*np.random.random((2,2)))
    b = np.floor(10*np.random.random((2,2)))
    print(np.vstack((a,b)))
    print(np.hstack((a,b)))

out：

[[0. 2.]
     [2. 5.]
     [7. 8.]
     [8. 0.]]
     
    [[0. 2. 7. 8.]
     [2. 5. 8. 0.]]

column\_stack 将 1D数组作为列堆叠到2D数组中。仅相当于 hstack 2D数组

import numpy as np
    
    a = np.array([4.,2.])
    b = np.array([3.,8.])
    print(np.column_stack((a,b)))# 将1D数组作为列堆叠到2D数组中。
    print(np.hstack((a,b)))

out：

[[4. 3.]
     [2. 8.]]
    [4. 2. 3. 8.]

np.newaxis：插入新维度

import numpy as np
    
    a = np.array([4.,2.])
    print(a[:,np.newaxis])
    [[4.]
     [2.]]

在复杂的情况下， r\_ 和c c\_ 于通过沿一个轴堆叠数字来创建数组很有用。它们允许使用范围操作符(“：”)。  
np.r\_是按列连接两个矩阵，就是把两矩阵上下相加，要求列数相等。  
np.c\_是按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等。

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

out：

[1 2 3 0 4]
    [[1 2 3 4 5 6]
     [7 8 9 1 2 3]]
    [[7 1]
     [8 2]
     [9 3]]

## 7.3 将一个数组拆分成几个较小的数组 ##

使用 hsplit ，可以沿数组的水平轴拆分数组，方法是指定要返回的形状相等的数组的数量，或者指定应该在其之后进行分割的列：  
np.vsplit()函数的作用：np.vsplit()函数的用法基本与np.hsplit相同,只不过它的作用为纵向切分数组。

import numpy as np
    
    a = np.floor(10*np.random.random((2,12)))
    print(a)
    print(np.hsplit(a,3))# 将数组a横向等分成三个数组
    print(np.hsplit(a,(3,4)))# 在数组a第三个和第四个索引前横向切分数组

out：

[[2. 1. 5. 0. 7. 7. 3. 9. 2. 0. 1. 1.]
     [0. 3. 3. 0. 7. 7. 8. 8. 5. 9. 5. 7.]]
    [array([[2., 1., 5., 0.],
           [0., 3., 3., 0.]]), array([[7., 7., 3., 9.],
           [7., 7., 8., 8.]]), array([[2., 0., 1., 1.],
           [5., 9., 5., 7.]])]
    [array([[2., 1., 5.],
           [0., 3., 3.]]), array([[0.],
           [0.]]), array([[7., 7., 3., 9., 2., 0., 1., 1.],
           [7., 7., 8., 8., 5., 9., 5., 7.]])]

## 7.4 拷贝和视图 ##

当计算和操作数组时，有时会将数据复制到新数组中，有时则不会。有三种情况：

### 7.4.1 完全不复制 ###

简单分配不会复制数组对象或其数据。

import numpy as np
    
    a = np.arange(12)
    b = a
    print(b is a)
    print(b.shape)
    print(a.shape)
    True
    (12,)
    (12,)

Python将可变对象作为引用传递，因此函数调用不会复制。

import numpy as np
    
    a = np.arange(12)
    def f(x):
        print(id(x))
    
    print(id(a))
    f(a)
    #1629425767408
    #1629425767408

### 7.4.2 视图或浅拷贝 ###

不同的数组对象可以共享相同的数据。view 方法创建一个查看相同数据的新数组对象。

import numpy as np
    
    a = np.arange(12)
    b = a
    b.shape = 3,4
    c = a.view()
    print(c is a)# False
    print(c.base is a)# True
    print(c.flags.owndata)# False
    c.shape = 2,6
    print(c.shape)# (2,6)
    print(a.shape)# (3,4)
    c[0,5] = 1234
    print(a)
    [[   0    1    2    3]
     [   4 1234    6    7]
     [   8    9   10   11]]

切片数组会返回一个视图：

s = a[:,1:3]
    print(s)
    s[:]= 10
    print(a)

out：

[[ 0 10 10  3]
     [ 4 10 10  7]
     [ 8 10 10 11]]

### 7.4.3 深拷贝 ###

copy 方法生成数组及其数据的完整副本。

import numpy as np
    
    a = np.arange(12).reshape(3,4)
    d = a.copy()
    print(d is a)
    print(d.base is a)
    s = a[ : , 1:3]
    s[:] = 10
    print(a)
    d[0,0] = 9999
    print(a)

out：

False
    False
    [[ 0 10 10  3]
     [ 4 10 10  7]
     [ 8 10 10 11]]
    [[ 0 10 10  3]
     [ 4 10 10  7]
     [ 8 10 10 11]]

有时，如果不再需要原始数组，则应在切片后调用 copy 。例如，假设a是一个巨大的中间结果，最终  
结果b只包含a的一小部分，那么在用切片构造b时应该做一个深拷贝：

a = np.arange(int(1e8))
    b = a[:100].copy()
    del a # the memory of ``a`` can be released.

如果改为使用 b = a\[:100\] ，则 a 由 b 引用，并且即使执行 del a 也会在内存中持久存在。

# 八、功能和方法概述 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70]

[20200716153122173.png]: https://img-blog.csdnimg.cn/20200716153122173.png
[20200717142807882.png]: https://img-blog.csdnimg.cn/20200717142807882.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200717161445113.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhMXR6eQ==,size_16,color_FFFFFF,t_70