NumPy 超详细教程（1）：NumPy 数组

青旅半醒 2022-01-20 04:33 525阅读 0赞

## 系列文章地址 ##

*  [NumPy 最详细教程（1）：NumPy 数组][NumPy _1_NumPy]
 *  [NumPy 超详细教程（2）：数据类型][NumPy _2]
 *  [NumPy 超详细教程（3）：ndarray 的内部机理及高级迭代][NumPy _3_ndarray]

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

*Numpy* 是 *Python* 中科学计算的核心库，*NumPy* 这个词来源于 *Numerical* 和 *Python* 两个单词。它提供了一个高性能的多维数组对象，以及大量的库函数和操作，可以帮助程序员轻松地进行数值计算，广泛应用于机器学习模型、图像处理和计算机图形学、数学任务等领域。

## Numpy 数组：ndarray ##

*NumPy* 中定义的最重要的对象是称为 *ndarray* 的 *N* 维数组类型，它是描述**相同类型**的元素集合。*ndarray* 中的每个元素都是数据类型对象(dtype)的对象。*ndarray* 中的每个元素在内存中使用相同大小的块。

numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>object</td> 
   <td>任何暴露数组接口方法的对象</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>数据类型</td> 
  </tr> 
  <tr> 
   <td>copy</td> 
   <td>如果为 True，则 object 对象被复制，否则，只有当<code>__array__</code>返回副本，object 是嵌套序列，或者需要副本来满足任何其他要求（dtype，order等）时，才会生成副本。</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>指定阵列的内存布局。 如果 object 不是数组，则新创建的数组将按行排列（C），如果指定了（F），则按列排列。 如果 object 是一个数组，则以下成立。C（按行）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）</td> 
  </tr> 
  <tr> 
   <td>subok</td> 
   <td>默认情况下，返回的数组被强制为基类数组。 如果为 True，则返回子类。</td> 
  </tr> 
  <tr> 
   <td>ndmin</td> 
   <td>返回数组的最小维数</td> 
  </tr> 
 </tbody> 
</table>

**例一：最简单的示例**

import numpy as np
    
    a = [1, 2, 3]
    b = np.array(a)
    
    print(b)
    print(type(b))
    复制代码

**输出：**

[1 2 3]
    <class 'numpy.ndarray'>
    复制代码

> 注意：`list` 打印显示是 `[1, 2, 3]`，而 `ndarray` 打印显示是 `[1 2 3]`，当中没有逗号。

**例二：dtype 参数用法示例** *NumPy* 支持比 *Python* 更多种类的数值类型

import numpy as np
    
    a = [1, 2, 3]
    b = np.array(a, dtype=np.float_)
    # 或者
    b = np.array(a, dtype=float)
    
    print(b)
    print(b.dtype)
    print(type(b[0]))
    复制代码

**输出：**

[1. 2. 3.]
    float64
    <class 'numpy.float64'>
    复制代码

**例三：copy 参数的用法**

import numpy as np
    
    a = np.array([1, 2, 3])
    b = np.array(a, copy=True)
    a[0] = 0
    
    print(a)
    print(b)
    复制代码

**输出：**

[0 2 3]
    [1 2 3]
    复制代码

可以看到 `a` 和 `b` 的值不同，说明 `b` 是 `a` 的副本，两个是不同的对象。

import numpy as np
    
    a = np.array([1, 2, 3])
    b = np.array(a, copy=False)
    a[0] = 0
    
    print(a)
    print(b)
    复制代码

**输出：**

[0 2 3]
    [0 2 3]
    复制代码

`a` 改变同时引起了 `b` 的改变，说明 `a` 和 `b` 指向的是同一个对象。

**例四：ndmin 参数用法示例**

import numpy as np
    
    a = [1, 2, 3]
    b = np.array(a, ndmin=2)
    
    print(b)
    复制代码

**输出：**

[[1 2 3]]
    复制代码

可以看到结果已经变成了二维数组。

**例五：subok 参数用法示例**

看解释不是很清楚，看下面这个例子就会明白许多。其中 `matrix` 是矩阵，将在之后的内容中介绍。

import numpy as np
    
    a = np.matrix('1 2 7; 3 4 8; 5 6 9')
    print(type(a))
    print(a)
    at = np.array(a, subok=True)
    af = np.array(a, subok=False)
    print(type(at))
    print(type(af))
    复制代码

**输出：**

<class 'numpy.matrix'>
    [[1 2 7]
     [3 4 8]
     [5 6 9]]
    <class 'numpy.matrix'>
    <class 'numpy.ndarray'>
    复制代码

## NumPy 数组属性 ##

*NumPy* 数组的维度（又称维数）称为秩（*rank*），一维数组的秩为 1，二维数组的秩为 2，以此类推。 *NumPy* 中，每一个线性的数组称为是一个轴（*axis*），也就是维度（*dimensions*）。

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

### 1、ndarray.shape ###

返回一个包含数组维度的元组，对于矩阵，n 行 m 列，它也可以用于调整数组维度。 **例一：**

import numpy as np
    
    a = np.array([[1, 2, 3], [4, 5, 6]])
    print(a.shape)
    复制代码

**输出：**

(2, 3)
    复制代码

**例二：**

import numpy as np
    
    a = np.array([[1, 2, 3], [4, 5, 6]])
    a.shape = (3, 2)
    print(a)
    复制代码

**输出：**

[[1 2]
     [3 4]
     [5 6]]
    复制代码

**例三：** *NumPy* 也提供了`reshape()` 函数来调整数组维度。只是 `reshape()` 返回调整维度后的副本，而不改变原 *ndarray*。

import numpy as np
    
    a = np.array([[1, 2, 3], [4, 5, 6]])
    b = a.reshape(3, 2)
    print(b)  # a 没变
    复制代码

**输出：**

[[1 2]
     [3 4]
     [5 6]]
    复制代码

### 2、ndarray.ndim ###

返回数组的维度（秩）。 **例一：**

import numpy as np
    
    a = np.arange(24)
    print(a.ndim)
    
    # 现在调整其大小
    b = a.reshape(2, 4, 3)
    print(b.ndim)
    复制代码

**输出：**

1
    3
    复制代码

### 3、ndarray.flags ###

*ndarray.flags* 返回 *ndarray* 对象的内存信息，包含以下属性：

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>C_CONTIGUOUS</td> 
   <td>数据是在一个单一的C风格的连续段中</td> 
  </tr> 
  <tr> 
   <td>F_CONTIGUOUS</td> 
   <td>数据是在一个单一的Fortran风格的连续段中</td> 
  </tr> 
  <tr> 
   <td>OWNDATA</td> 
   <td>数组拥有它所使用的内存或从另一个对象中借用它</td> 
  </tr> 
  <tr> 
   <td>WRITEABLE</td> 
   <td>数据区域可以被写入，将该值设置为 False，则数据为只读</td> 
  </tr> 
  <tr> 
   <td>ALIGNED</td> 
   <td>数据和所有元素都适当地对齐到硬件上</td> 
  </tr> 
  <tr> 
   <td>WRITEBACKIFCOPY</td> 
   <td>UPDATEIFCOPY 已弃用，由 WRITEBACKIFCOPY 取代;</td> 
  </tr> 
  <tr> 
   <td>UPDATEIFCOPY</td> 
   <td>这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新</td> 
  </tr> 
 </tbody> 
</table>

import numpy as np
    
    a = np.array([[1, 2, 3], [4, 5, 6]])
    print(a.flags)
    复制代码

**输出：**

C_CONTIGUOUS : True
    F_CONTIGUOUS : False
    OWNDATA : True
    WRITEABLE : True
    ALIGNED : True
    WRITEBACKIFCOPY : False
    UPDATEIFCOPY : False
    复制代码

### 4、ndarray.real ###

import numpy as np
    
    x = np.sqrt([1+0j, 0+1j])
    print(x)
    print(x.real)
    print(x.real.dtype)
    复制代码

**输出：**

[1.        +0.j         0.70710678+0.70710678j]
    [1.         0.70710678]
    float64
    复制代码

## NumPy 中的常数 ##

*  正无穷：Inf = inf = infty = Infinity = PINF
 *  负无穷：NINF
 *  正零：PZERO
 *  负零：NZERO
 *  非数值：nan = NaN = NAN
 *  自然数e：e
 *  π：pi
 *  伽马：euler\_gamma
 *  None 的别名：newaxis

**示例：**

print(np.inf)
    print(np.NINF)
    print(np.PZERO)
    print(np.NZERO)
    print(np.nan)
    print(np.e)
    print(np.pi)
    print(np.euler_gamma)
    print(np.newaxis)
    复制代码

**输出：**

inf
    -inf
    0.0
    -0.0
    nan
    2.718281828459045
    3.141592653589793
    0.5772156649015329
    None
    复制代码

## NumPy 创建数组 ##

### 1、numpy.empty ###

此方法用来创建一个指定维度（shape）、数据类型（dtype）的未初始化的数组。

numpy.empty(shape, dtype=float, order='C')
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>shape</td> 
   <td>一个表示数组维度的元组</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>数据类型</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>有 "C" 和 "F" 两个选项</td> 
  </tr> 
 </tbody> 
</table>

**示例：**

import numpy as np
    
    x = np.empty([3, 2], dtype=int)
    print(x)
    复制代码

**输出：**

[[         0 1072693248]
     [         0 1072693248]
     [         0 1072693248]]
    复制代码

`empty()` 方法和 `zeros()` 方法不同，不会将数组值设置为零，因此可能会略微加快。另一方面，它要求用户手动设置数组中的所有值，并应谨慎使用。

### 2、numpy.zeros ###

创建指定维度，以 0 填充的新数组。

numpy.zeros(shape, dtype=float, order='C')
    复制代码

**示例：**

import numpy as np
    
    x = np.zeros(5)
    print(x)
    复制代码

**输出：**

[0. 0. 0. 0. 0.]
    复制代码

**注意：默认是 float 类型的**

### 3、numpy.ones ###

创建指定维度，以 1 填充的新数组。

numpy.ones(shape, dtype=float, order='C')
    复制代码

**示例：**

import numpy as np
    
    x = np.ones(5)
    print(x)
    复制代码

**输出：**

[1. 1. 1. 1. 1.]
    复制代码

### 4、numpy.full ###

返回给定维度和类型的新数组，填充 fill\_value。

numpy.full(shape, fill_value, dtype=None, order='C')
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>shape</td> 
   <td>返回数组的维度</td> 
  </tr> 
  <tr> 
   <td>fill_value</td> 
   <td>填充值</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>返回数组的数据类型，默认值 None 指：<code>np.array(fill_value).dtype</code></td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>在计算机内存中的存储元素的顺序，只支持 'C'（按行）、'F'（按列），默认 'C'</td> 
  </tr> 
 </tbody> 
</table>

**示例：**

import numpy as np
    
    a = np.full((2, 3), 9)
    print(a)
    复制代码

**输出：**

[[9 9 9]
     [9 9 9]]
    复制代码

## NumPy 从数值范围创建数组 ##

### 1、numpy.arange ###

该函数等效于 *Python* 内置 `range` 函数，但返回的是 *ndarray* 而不是列表。

arange([start,] stop[, step,], dtype=None)
    复制代码

> \[ \] 括起来的表示可选参数。

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>start</td> 
   <td>起始值，默认为 0</td> 
  </tr> 
  <tr> 
   <td>stop</td> 
   <td>终止值（不包含）</td> 
  </tr> 
  <tr> 
   <td>step</td> 
   <td>步长，默认为1</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>创建的 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型。</td> 
  </tr> 
 </tbody> 
</table>

**示例：**

import numpy as np
    
    a = np.arange(5)
    b = np.arange(10, 20, 2)
    print(a)
    print(b)
    复制代码

**输出：**

[0 1 2 3 4]
    [10 12 14 16 18]
    复制代码

### 2、numpy.linspace ###

创建一个一维等差数列的数组，与 `arange` 函数不同，`arange` 是固定步长，而 `linspace` 则是固定元素数量。

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>start</td> 
   <td>序列的起始值</td> 
  </tr> 
  <tr> 
   <td>stop</td> 
   <td>序列的终止值，如果 endpoint 为 True，则该值包含于数列中</td> 
  </tr> 
  <tr> 
   <td>num</td> 
   <td>要生成的等步长的样本数量，默认为 50</td> 
  </tr> 
  <tr> 
   <td>endpoint</td> 
   <td>该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。</td> 
  </tr> 
  <tr> 
   <td>retstep</td> 
   <td>如果为 True 时，生成的数组中会显示间距，反之不显示。</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>ndarray 的数据类型</td> 
  </tr> 
 </tbody> 
</table>

**例一：endpoint 参数的用法**

我特意挑了下面这个除不尽的例子来显示 `endpoint` 的效果。可以看到，`endpoint=False` 取值是 `endpoint=True`，并且 `num = num + 1` 的结果去掉终止值。这话有点拗口啊，对比一下下例中的 `num` 参数值及输出结果就明白了。

import numpy as np
    
    a = np.linspace(0, 5, 3, endpoint=False)
    b = np.linspace(0, 5, 4, endpoint=True)
    
    print(a)
    print(b)
    复制代码

**输出：**

[0.         1.66666667 3.33333333]
    [0.         1.66666667 3.33333333 5.        ]
    复制代码

**例二：retstep 参数的用法**

返回一个元组，第一个元素是 *numpy.ndarray*，第二个元素是步长。

import numpy as np
    
    a = np.linspace(0, 10, 5, retstep=True)
    print(a)
    复制代码

**输出：**

(array([ 0. ,  2.5,  5. ,  7.5, 10. ]), 2.5)
    复制代码

**例三：dtype 参数**

*dtype* 参数指定后会将结果强制转换成 *dtype* 指定的类型，如果是 float 转 int，最终值就可能不是等差的了。

import numpy as np
    
    a = np.linspace(0, 10, 5, dtype=int)
    print(a)
    复制代码

**输出：**

[ 0  2  5  7 10]
    复制代码

### 3、numpy.logspace ###

`numpy.logspace` 函数用于创建一个等比数列。

numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>start</td> 
   <td>序列的起始值为：<code>base ** start</code> （幂运算）</td> 
  </tr> 
  <tr> 
   <td>stop</td> 
   <td>序列的终止值为：<code>base ** stop</code>。如果 endpoint 为 True，该值包含于数列中</td> 
  </tr> 
  <tr> 
   <td>num</td> 
   <td>要生成的等步长的样本数量，默认为50</td> 
  </tr> 
  <tr> 
   <td>endpoint</td> 
   <td>该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。</td> 
  </tr> 
  <tr> 
   <td>base</td> 
   <td>对数 log 的底数。</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>ndarray 的数据类型</td> 
  </tr> 
 </tbody> 
</table>

**示例：**

其实没啥好说的，主要是注意 start 参数的值并非是真正的起始值。

import numpy as np
    
    a = np.logspace(1, 4, num=4)
    print(a)
    复制代码

**输出：**

[   10.   100.  1000. 10000.]
    复制代码

### 4、numpy.geomspace ###

创建一个一维等比数列。

numpy.geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0)
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>start</td> 
   <td>序列的起始值</td> 
  </tr> 
  <tr> 
   <td>stop</td> 
   <td>序列的终止值，如果 endpoint 为 True，该值包含于数列中</td> 
  </tr> 
  <tr> 
   <td>num</td> 
   <td>要生成的样本数量，默认为 50</td> 
  </tr> 
  <tr> 
   <td>endpoint</td> 
   <td>该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>ndarray 的数据类型</td> 
  </tr> 
  <tr> 
   <td>axis</td> 
   <td>1.16.0 版本中的新功能 ，没看懂怎么用，官网上连个例子都没有，值为 0 和 -1 的时候结果相同，其他时候都报错。</td> 
  </tr> 
 </tbody> 
</table>

**示例：**

import numpy as np
    
    a = np.geomspace(1, 8, num=4)
    print(a)
    复制代码

**输出：**

[1. 2. 4. 8.]
    复制代码

## NumPy 从已有的数组创建数组 ##

### 1、numpy.asarray ###

`numpy.asarray` 类似 `numpy.array`，但 `numpy.asarray` 的参数只有三个。

numpy.asarray(a, dtype=None, order=None)
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>a</td> 
   <td>输入数据，可以转换为数组的任何形式。 这包括列表，元组列表，元组，元组元组，列表元组和 ndarray。</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>数据类型</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>在计算机内存中的存储元素的顺序，只支持 'C'（按行）、'F'（按列），默认 'C'</td> 
  </tr> 
 </tbody> 
</table>

**示例：**

import numpy as np
    
    a = np.asarray([1, 2, 3])
    print(a)
    复制代码

**输出：**

[1 2 3]
    复制代码

### 2、numpy.frombuffer ###

`numpy.frombuffer` 用于实现动态数组。`numpy.frombuffer` 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

numpy.frombuffer(buffer, dtype=float, count=-1, offset=0)
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>buffer</td> 
   <td>实现了 <code>__buffer__</code> 方法的对象，（绝对不是菜鸟教程上说的任意对象都可以）</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>返回数组的数据类型</td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td>读取的数据数量，默认为 -1，读取所有数据。</td> 
  </tr> 
  <tr> 
   <td>offset</td> 
   <td>读取的起始位置，默认为 0。</td> 
  </tr> 
 </tbody> 
</table>

**例一：** buffer 是字符串的时候，*Python3* 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。

import numpy as np
    
    a = np.frombuffer(b'Hello World', dtype='S1')
    print(a)
    复制代码

**输出：**

[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
    复制代码

**例二：** 看了上面的例子，似乎对“实现动态数组”没啥感觉，那么我们来看这个例子。

import numpy as np
    import array
    
    a = array.array('i', [1, 2, 3, 4])
    print(a)
    
    na = np.frombuffer(a, dtype=np.int_)
    print(na)
    
    a[0] = 10
    print(a)
    print(na)
    复制代码

**输出：**

array('i', [1, 2, 3, 4])
    [1 2 3 4]
    array('i', [10, 2, 3, 4])
    [10  2  3  4]
    复制代码

`array.array` 创建的数组对象内存是连续的（这里不能用 list，会报：AttributeError: 'list' object has no attribute '`__buffer__`'），`numpy.frombuffer` 从 `array.array` 的内存中创建数组，从上例中可以看出，改变 `array.array` 的值，`numpy.frombuffer` 的值也会跟着改变，由此可见。

**例三：**

`array.array` 数组中的值改变是可以的，但是如果是添加值，那就不行了。

import numpy as np
    import array
    
    a = array.array("i", [1, 2, 3, 4])
    na = np.frombuffer(a, dtype=int)
    print(na)
    
    a.append(5)
    print(na)
    复制代码

**输出：**

[1 2 3 4]
    [140896288       381         3         4]
    复制代码

### 3、numpy.fromiter ###

`numpy.fromiter` 方法从可迭代对象中建立 ndarray 对象，返回一维数组。

numpy.fromiter(iterable, dtype, count=-1)
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>iterable</td> 
   <td>可迭代对象</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>返回数组的数据类型</td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td>读取的数据数量，默认为 -1，读取所有数据</td> 
  </tr> 
 </tbody> 
</table>

**例一：**

import numpy as np
    
    iterable = (x * x for x in range(5))
    a = np.fromiter(iterable, int)
    print(a)
    复制代码

**输出：**

[ 0  1  4  9 16]
    复制代码

> 看起来有点像 `numpy.array`，`array` 方法需要传入的是一个 list，而 `fromiter` 可以传入可迭代对象。

**例二：** 将上例换成 `array` 试试看。

import numpy as np
    
    iterable = (x * x for x in range(5))
    a = np.array(iterable)
    print(a)
    复制代码

**输出：**

<generator object <genexpr> at 0x000000001442DD00>
    复制代码

### 4、empty\_like ###

返回一个与给定数组具有相同维度和类型的**未初始化的**新数组。

numpy.empty_like(prototype, dtype=None, order='K', subok=True)
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>prototype</td> 
   <td>给定的数组</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>覆盖结果的数据类型，版本1.6.0中的新功能。</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>指定阵列的内存布局。C（按行）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）</td> 
  </tr> 
  <tr> 
   <td>subok</td> 
   <td>默认情况下，返回的数组被强制为基类数组。 如果为 True，则返回子类。</td> 
  </tr> 
 </tbody> 
</table>

**示例：**

import numpy as np
    a = np.empty_like([[1, 2, 3], [4, 5, 6]])
    print(a)
    复制代码

**输出：**\*

[[870   0   0]
     [  0   0   0]]
    复制代码

### 5、zeros\_like ###

numpy.zeros_like(a, dtype=None, order='K', subok=True)
    复制代码

参数同上。

**示例：**

import numpy as np
    a = np.zeros_like([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
    print(a)
    复制代码

**输出：**\*

[[0. 0. 0.]
     [0. 0. 0.]]
    复制代码

### 6、ones\_like ###

numpy.ones_like(a, dtype=None, order='K', subok=True)
    复制代码

参数同上。

**示例：**

import numpy as np
    a = np.ones_like([[1, 2, 3], [4, 5, 6]])
    print(a)
    复制代码

**输出：**\*

[[1 1 1]
     [1 1 1]]
    复制代码

### 7、numpy.full\_like ###

返回与给定数组具有相同维度和类型的并以 fill\_value 填充的数组。

numpy.full_like(a, fill_value, dtype=None, order='K', subok=True)
    复制代码

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>a</td> 
   <td>给定的数组</td> 
  </tr> 
  <tr> 
   <td>fill_value</td> 
   <td>填充值</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>返回数组的数据类型，默认值 None，则使用给定数组的类型</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>指定阵列的内存布局。C（按行）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）</td> 
  </tr> 
  <tr> 
   <td>subok</td> 
   <td>默认情况下，返回的数组被强制为基类数组。 如果为 True，则返回子类。</td> 
  </tr> 
 </tbody> 
</table>

zeros\_like、ones\_like 其实都是此方法的特例。

**示例：**

import numpy as np
    
    x = np.arange(6, dtype=int)
    print(x)
    print('-------------------')
    a = np.full_like(x, 1)
    b = np.full_like(x, 0.1)
    c = np.full_like(x, 0.1, dtype=np.double)
    
    print(a)
    print(b)
    print(c)
    复制代码

**输出：**

[0 1 2 3 4 5]
    -------------------
    [1 1 1 1 1 1]
    [0 0 0 0 0 0]
    [0.1 0.1 0.1 0.1 0.1 0.1]
    复制代码

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

欢迎关注我的公众号

**大龄码农的Python之路**

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

[NumPy _1_NumPy]: https://juejin.im/post/5c8b09b2f265da2dc13cc871
[NumPy _2]: https://juejin.im/post/5c8ee28ef265da67ff3000e8
[NumPy _3_ndarray]: https://juejin.im/post/5ca17073f265da30b2476570