我认为这应该是一个简单的问题...但它已经支撑了我一段时间了:(
我希望从指定最大值和增量的输入中创建一个数字列表，以零为中心(可以说是(。所以
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]
但我将不得不多谷歌一下才能理解为什么有效(也不确定我是否要四舍五入......增量的输入可能合法地指定为小数点后一位以上(
如果您希望它严格镜像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. ]
使用 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]
这可确保最大值和最小值在限制范围内。
纯 python，不带同名词：
def mirror(max, step):
i = -max
while i<= max:
yield i
i += step
print list(mirror(5, 0.5))
我认为一个简单的代码也可以工作。不是一堆"defs"，"fors"和"whiles"。试试吧。
Obs：我写了10到10，没有广泛的结果。如果您需要从 1 到 100 的一个接一个的数字，请删除第一行中的"，10"。
onehundred = list(range(0,101,10))
onehundred.reverse()
mirror = onehundred + list(reversed(onehundred))
print(mirror)
这有效，但结果列表的值需要四舍五入：
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))