Question

我认为这应该是一个简单的问题......但它现在已经让我坚持了一段时间:(

我希望从指定最大值和增量的输入创建一个数字列表，以零为中心（原样）。所以，

max = 100
increment = 1

将返回

[-100,-99,-98,...,-1,0,1,...,99,100]

和

max = 35
increment = 0.2

将返回

[-35.0,-34.8,...,-0.2,0,0.2,...34.8,35.0]

如果增量没有整齐划分为最大值，则需要做一个简短的最后一步（例如，如果以0.3为增量计数到1，它将运行[-1.0,-0.6,-0.3,0.0,0.3,0.6,0.9,1.0]

list(numpy.linspace())似乎是要走的路，但我似乎对如何使用除了最简单的情况之外的任何描述的方式完成这项工作有一个完整的心理障碍。

建议赞赏！

编辑：我自己的解决方案是

def mylist(stop,step):
    a = list(np.arange(0,-stop,-step))+[-stop]
    a.reverse()
    b = list(a)
    c = list(np.arange(0,stop,step))+[stop]
    d = b+c
    d.remove(0)
    e = list(d)
    return e

这是非常笨重的，即使我可以看到。

最好的答案是：

def mirrored(maxval, inc):
    x = np.arange(inc, maxval, inc)
    if x[-1] != maxval:
        x = np.r_[x, maxval]
    return np.r_[-x[::-1], 0, x]

但是我将不得不谷歌更多地了解为什么有效（也不确定我是否要舍入...增量的输入可能合法地指定为超过小数点后一位）

Answer 1

如果您希望它围绕0进行严格镜像，（即始终包含0和端点，并且完全对称于0），则需要执行几个步骤。

首先，请注意@ NPE上面的评论。浮点数学与十进制数学不一样!!这可能看起来不合时宜，但会在某些情况下咬你。

这样做的方法不止一种。您是希望所有数字均匀分布，还是坚持增量并且只在端点处违反它？这种方法采用后两者。

import numpy as np

def mirrored(maxval, inc=1):
    x = np.arange(inc, maxval, inc)
    if x[-1] != maxval:
        x = np.r_[x, maxval]
    return np.r_[-x[::-1], 0, x]

print mirrored(1, 0.3)

这会产生：

[-1.  -0.9 -0.6 -0.3  0.   0.3  0.6  0.9  1. ]

如果您希望所有数字均匀分布（但不是您指定的确切增量），只需使用linspace：

import numpy as np

def mirrored2(maxval, inc=1):
    return np.linspace(-maxval, maxval, 2*maxval // inc)

print mirrored2(1, 0.3)

这会产生：

[-1.  -0.6 -0.2  0.2  0.6  1. ]

Answer 2

使用numpy.arange非常容易：

>>> import numpy as np
>>> max_val = 100
>>> increment = 1
>>> a = np.arange(start=-max_val, stop=max_val+increment, step=increment)
>>> print a
array([-100,  -99,  -98,  -97,  -96,  -95,  -94,  -93,  -92,  -91,  -90,
    -89,  -88,  -87,  -86,  -85,  -84,  -83,  -82,  -81,  -80,  -79,
    -78,  -77,  -76,  -75,  -74,  -73,  -72,  -71,  -70,  -69,  -68,
    -67,  -66,  -65,  -64,  -63,  -62,  -61,  -60,  -59,  -58,  -57,
    -56,  -55,  -54,  -53,  -52,  -51,  -50,  -49,  -48,  -47,  -46,
    -45,  -44,  -43,  -42,  -41,  -40,  -39,  -38,  -37,  -36,  -35,
    -34,  -33,  -32,  -31,  -30,  -29,  -28,  -27,  -26,  -25,  -24,
    -23,  -22,  -21,  -20,  -19,  -18,  -17,  -16,  -15,  -14,  -13,
    -12,  -11,  -10,   -9,   -8,   -7,   -6,   -5,   -4,   -3,   -2,
     -1,    0,    1,    2,    3,    4,    5,    6,    7,    8,    9,
     10,   11,   12,   13,   14,   15,   16,   17,   18,   19,   20,
     21,   22,   23,   24,   25,   26,   27,   28,   29,   30,   31,
     32,   33,   34,   35,   36,   37,   38,   39,   40,   41,   42,
     43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,
     54,   55,   56,   57,   58,   59,   60,   61,   62,   63,   64,
     65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
     76,   77,   78,   79,   80,   81,   82,   83,   84,   85,   86,
     87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   97,
     98,   99,  100])

如果增量值小于零，例如max_val = 1和increment = 0.3

输出将是：

[-1.  -0.7 -0.4 -0.1  0.2  0.5  0.8  1.1]

解决此问题的一种方法可能是：

>>> print a[np.where((a<=max_val) & (a>=-max_val))[0]]
[-1.  -0.7 -0.4 -0.1  0.2  0.5  0.8]

确保最大值和最小值在限制范围内。

Answer 3

纯蟒蛇，没有numpy：

def mirror(max, step):
    i = -max
    while i<= max:
        yield i
        i += step

print list(mirror(5, 0.5))

Answer 4

我认为一个简单的代码也可以工作。不是一堆“ defs”，“ fors”和“ whiles”。试试吧。

Obs：我以10到10的倍数写下它，但并没有获得广泛的结果。如果您需要一个从1到100的数字，请在第一行中删除“，10”。

onehundred = list(range(0,101,10))
onehundred.reverse()
mirror = onehundred + list(reversed(onehundred))
print(mirror)

Answer 5

这样可行，但结果列表的值需要舍入：

def mirror_list(max, increment):
        lst = [-max]
        while lst[-1] < max:
            lst.append(lst[-1] + increment)
        lst[-1] = max
        return lst

你可以像这样得到一个圆形列表：

lst = map(lambda x: round(x, 1), mirror_list(max=100, increment=0.2))

创建零附近镜像的数字列表（python）

5 个答案: