5

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

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

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]

但我将不得不多用谷歌来了解为什么会这样（也不确定我是否要四舍五入......增量的输入可能被合法地指定为多于一位小数）

4

5 回答 5

5

如果您希望它在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. ]
于 2013-08-10T16:11:51.460 回答
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]

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

于 2013-08-10T15:49:12.017 回答
1

纯 python，没有 nympy：

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

print list(mirror(5, 0.5))
于 2013-08-10T16:18:16.883 回答
0

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

Obs：我写了 10 到 10 篇，没有得到广泛的结果。如果您需要从 1 到 100 的数字，请删除第一行中的 ',10'。

onehundred = list(range(0,101,10))
onehundred.reverse()
mirror = onehundred + list(reversed(onehundred))
print(mirror)
于 2019-02-10T20:06:09.583 回答
-1

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

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))
于 2013-08-10T15:57:38.807 回答