是否有一个numpy函数用于生成类似于R＆se; sq函数的序列？

Question

在R中，您可以通过指定起点，终点和所需的输出长度来创建序列

seq(1, 1.5, length.out=10)
# [1] 1.000000 1.055556 1.111111 1.166667 1.222222 1.277778 1.333333 1.388889 1.444444 1.500000

在Python中，您可以以类似的方式使用numpy arange函数，但是没有简单的方法来指定输出长度。我能想到的最好：

np.append(np.arange(1, 1.5, step = (1.5-1)/9), 1.5)
# array([ 1.        ,  1.05555556,  1.11111111,  1.16666667,  1.22222222, 1.27777778,  1.33333333,  1.38888889,  1.44444444,  1.5       ])

是否有更简洁的方法来执行此操作？

Answer 1

是的！一种简单的方法是使用numpy.linspace

  

Numpy Docs

     

numpy.linspace（start，stop，num = 50，endpoint = True，retstep = False，dtype = None）

     

在指定的时间间隔内返回均匀间隔的数字   返回num均匀间隔的样本，在[start，stop]区间内计算   可以选择排除间隔的终点。

示例：

[In 1] np.linspace(start=0, stop=50, num=5)

[Out 1] array([  0. ,  12.5,  25. ,  37.5,  50. ])

请注意，起始值和停止值之间的距离均匀分布，即均匀地除以num=5。

对于那些在安装numpy时遇到问题的人（这些日子不太常见的问题），您可能会考虑使用anaconda（或miniconda）或其他类似的发布。

Answer 2

@PaulG的答案非常好，可以生成一系列浮点数。如果您要寻找1:5的R等效项来创建一个包含5个整数元素的numpy向量，请使用：

a = np.array(range(0,5))
a
# array([0, 1, 2, 3, 4])

a.dtype
# dtype('int64')

与R向量相反，Python列表和numpy数组的索引为零。通常，您将使用np.array(range(n))将值从0返回到n-1。

Answer 3

作为一种替代方法（对于那些感兴趣的人），如果想要R中的seq(start, end, by, length.out)的功能，则以下功能提供了完整的功能。

def seq(start, end, by = None, length_out = None):
    len_provided = True if (length_out is not None) else False
    by_provided = True if (by is not None) else False
    if (not by_provided) & (not len_provided):
        raise ValueError('At least by or n_points must be provided')
    width = end - start
    eps = pow(10.0, -14)
    if by_provided:
        if (abs(by) < eps):
            raise ValueError('by must be non-zero.')
    #Switch direction in case in start and end seems to have been switched (use sign of by to decide this behaviour)
        if start > end and by > 0:
            e = start
            start = end
            end = e
        elif start < end and by < 0:
            e = end
            end = start
            start = e
        absby = abs(by)
        if absby - width < eps: 
            length_out = int(width / absby)
        else: 
            #by is too great, we assume by is actually length_out
            length_out = int(by)
            by = width / (by - 1)
    else:
        length_out = int(length_out)
        by = width / (length_out - 1) 
    out = [float(start)]*length_out
    for i in range(1, length_out):
        out[i] += by * i
    if abs(start + by * length_out - end) < eps:
        out.append(end)
    return out

此功能比numpy.linspace慢一点（大约快4到5倍），但是使用numba的速度，我们可以获得的功能大约是{{1}的2倍}，同时保留R的语法。

np.linspace

我们可以像在R中一样执行此操作。

from numba import jit
@jit(nopython = True, fastmath = True)
def seq(start, end, by = None, length_out = None):
    [function body]

在上述实现中，它还允许（某种程度上）“ by”和“ length_out”之间的交换

seq(0, 5, 0.3)
#out: [3.0, 3.3, 3.6, 3.9, 4.2, 4.5, 4.8]

基准：

seq(0, 5, 10)
#out: [0.0,
 0.5555555555555556,
 1.1111111111111112,
 1.6666666666666667,
 2.2222222222222223,
 2.7777777777777777,
 3.3333333333333335,
 3.8888888888888893,
 4.444444444444445,
 5.0]

Answer 4

您可以找到更多示例here，它包含许多带有 numpy 包的 R 函数。