关于np.linspace函数

Python初学者8号

正在学习matplotlib包
我遇到了linspace函数，我来研就一下他的作用。

这是函数的源文档：

Help on function linspace in module numpy:

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
    Return evenly spaced numbers over a specified interval.
   
    Returns `num` evenly spaced samples, calculated over the
    interval [`start`, `stop`].
   
    The endpoint of the interval can optionally be excluded.
   
    .. versionchanged:: 1.16.0
        Non-scalar `start` and `stop` are now supported.
   
    Parameters
    ----------
    start : array_like
        The starting value of the sequence.
    stop : array_like
        The end value of the sequence, unless `endpoint` is set to False.
        In that case, the sequence consists of all but the last of ``num + 1``
        evenly spaced samples, so that `stop` is excluded.  Note that the step
        size changes when `endpoint` is False.
    num : int, optional
        Number of samples to generate. Default is 50. Must be non-negative.
    endpoint : bool, optional
        If True, `stop` is the last sample. Otherwise, it is not included.
        Default is True.
    retstep : bool, optional
        If True, return (`samples`, `step`), where `step` is the spacing
        between samples.
    dtype : dtype, optional
        The type of the output array.  If `dtype` is not given, infer the data
        type from the other input arguments.
   
        .. versionadded:: 1.9.0
   
    axis : int, optional
        The axis in the result to store the samples.  Relevant only if start
        or stop are array-like.  By default (0), the samples will be along a
        new axis inserted at the beginning. Use -1 to get an axis at the end.
   
        .. versionadded:: 1.16.0
   
    Returns
    -------
    samples : ndarray
        There are `num` equally spaced samples in the closed interval
        ``[start, stop]`` or the half-open interval ``[start, stop)``
        (depending on whether `endpoint` is True or False).
    step : float, optional
        Only returned if `retstep` is True
   
        Size of spacing between samples.
   
   
    See Also
    --------
    arange : Similar to `linspace`, but uses a step size (instead of the
             number of samples).
    geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
                scale (a geometric progression).
    logspace : Similar to `geomspace`, but with the end points specified as
               logarithms.
   
    Examples
    --------
    >>> np.linspace(2.0, 3.0, num=5)
    array([2.  , 2.25, 2.5 , 2.75, 3.  ])
    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
    array([2. ,  2.2,  2.4,  2.6,  2.8])
    >>> np.linspace(2.0, 3.0, num=5, retstep=True)
    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)



    Graphical illustration:
   
    >>> import matplotlib.pyplot as plt
    >>> N = 8
    >>> y = np.zeros(N)
    >>> x1 = np.linspace(0, 10, N, endpoint=True)
    >>> x2 = np.linspace(0, 10, N, endpoint=False)
    >>> plt.plot(x1, y, 'o')
    [<matplotlib.lines.Line2D object at 0x...>]
    >>> plt.plot(x2, y + 0.5, 'o')
    [<matplotlib.lines.Line2D object at 0x...>]
    >>> plt.ylim([-0.5, 1])
    (-0.5, 1)
    >>> plt.show()

刚开始不是很懂num参数和endpoint概念，以及说明文档中的这句话

The end value of the sequence, unless `endpoint` is set to False.
        In that case, the sequence consists of all but the last of ``num + 1``
        evenly spaced samples, so that `stop` is excluded.  Note that the step
        size changes when `endpoint` is False.

这样理解这个参数，也是引用他们自己写的例子，我加了一点

1.     Examples
   
2.     --------
   
3.     >>> np.linspace(2.0, 3.0, num=5)
   
4.     array([2.  , 2.25, 2.5 , 2.75, 3.  ])
   
5.     >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
   
6.     array([2. ,  2.2,  2.4,  2.6,  2.8])
   
7.     >>> np.linspace(2.0, 3.0, num=5, retstep=True)
   
8.     (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)
   
9.     #我加的：
   
10.      >>>np.linspace(2.0, 3.0, num=6, endpoint=True)
    
11.      >>>array([2. , 2.2, 2.4, 2.6, 2.8, 3. ])

复制代码

所以作用就是增加num为num+1，然后删除最后一个数，然后输出num个数字，哈哈

Python初学者8号

1. linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

复制代码

好了，现在说说retstep参数：
首先看看doc的解释：

    retstep : bool, optional
        If True, return (`samples`, `step`), where `step` is the spacing
        between samples.

所以，从名字来说，它是return  step的缩写，作用来说 ，看下面：

1. >>> c= np.linspace(1, 3, num=3, endpoint=True, retstep=True, dtype=None, axis=0)
   
2. >>> c
   
3. (array([1., 2., 3.]), 1.0)

复制代码

Python初学者8号

哈哈，通过这个 命令找到了源代码了 哈哈

1. import numpy as np
   
2. import inspect
   
3. print(inspect.getsource(np.linspace))

复制代码

                               
登录/注册后可看大图

以下就是源代码

1. num = operator.index(num)
   
2.     if num < 0:
   
3.         raise ValueError("Number of samples, %s, must be non-negative." % num)
   
4.     div = (num - 1) if endpoint else num
   
5. 
   
6.     # Convert float/complex array scalars to float, gh-3504
   
7.     # and make sure one can use variables that have an __array_interface__, gh-6634
   
8.     start = asanyarray(start) * 1.0
   
9.     stop  = asanyarray(stop)  * 1.0
   
10. 
    
11.     dt = result_type(start, stop, float(num))
    
12.     if dtype is None:
    
13.         dtype = dt
    
14. 
    
15.     delta = stop - start
    
16.     y = _nx.arange(0, num, dtype=dt).reshape((-1,) + (1,) * ndim(delta))
    
17.     # In-place multiplication y *= delta/div is faster, but prevents the multiplicant
    
18.     # from overriding what class is produced, and thus prevents, e.g. use of Quantities,
    
19.     # see gh-7142. Hence, we multiply in place only for standard scalar types.
    
20.     _mult_inplace = _nx.isscalar(delta)
    
21.     if div > 0:
    
22.         step = delta / div
    
23.         if _nx.any(step == 0):
    
24.             # Special handling for denormal numbers, gh-5437
    
25.             y /= div
    
26.             if _mult_inplace:
    
27.                 y *= delta
    
28.             else:
    
29.                 y = y * delta
    
30.         else:
    
31.             if _mult_inplace:
    
32.                 y *= step
    
33.             else:
    
34.                 y = y * step
    
35.     else:
    
36.         # sequences with 0 items or 1 item with endpoint=True (i.e. div <= 0)
    
37.         # have an undefined step
    
38.         step = NaN
    
39.         # Multiply with delta to allow possible override of output class.
    
40.         y = y * delta
    
41. 
    
42.     y += start
    
43. 
    
44.     if endpoint and num > 1:
    
45.         y[-1] = stop
    
46. 
    
47.     if axis != 0:
    
48.         y = _nx.moveaxis(y, 0, axis)
    
49. 
    
50.     if retstep:
    
51.         return y.astype(dtype, copy=False), step
    
52.     else:
    
53.         return y.astype(dtype, copy=False)
    

复制代码