在函数或者类成员函数里面导入，是可以突破循环导入的限制的。

嘿嘿，我用滚轮（惯性滚轮，滚动之后自己会转，直到你轻触将其停下）在 vim 终端里面上下跳，楼主你是不是要从屏幕里面跳出来骂我呀？

说实在的，你说了这么多好用的 vim 命令，我就是记不住，也不想记住。平素我用 vim 机会本就不多，用的时候也就会 hjkl 上下左右条、按行号 gg、斜杠搜索、还有全局替换。别的我都不会，也不是活得好好的？偶尔还会用上之前提到的滚轮大法，这个不仅对 vim 有效，对所有终端程序都有效。

给楼上点赞。

现代编程语言为了解决运算符二义性，除了基本的优先级，还有左右优先级。你可以去查语法手册。

@laike9m 别误人子弟。dic.get 好好一成员函数，干嘛不能用？

https://docs.python.org/3/library/stdtypes.html?highlight=dict%20get#dict.get

@whoami9894 “函数”也是对象。dic.get 指的就是 dic.get 这个函数，没别的意思。

顺便 dic.get 是已经绑定了 dic 这个实例的 get 成员函数。如果你用 dict.get （所以说你用 dic 这个对象名太屎了），那就是 dict 类中未绑定实例的 get 成员函数。另外一个 bonus，你有时候可以使用 dict.get(dic, i) 来调用一个未绑定的成员函数。

根据我 Python 里面的经验，超过 10 个对象去重，set 就比 list 快了。

你 Java 怎么样不知道，但是这个界绝对大不过几百。

是的，同步是噩梦，iPad 写了点东西，你得确保它上传了，再确保 Mac 如实下载了，才能在 Mac 上改，否则必定丢失一端的改动。关键是它同步还不及时

@dwjgwsm
1、Cython 可以写函数。
2、Cython 最好不要用 map、列表推导之类的，直接用 for。
3、Cython 性能提升的关键是用上 C 一样的指针或者数组直接读写，不要用 Python 对象。
4、Cython 支持对 NumPy 数组进行直接读写。当然，不是直接用 NumPy 数组对象，你得查文档。

@dwjgwsm 我的看法是你用 @Kirscheis 的思路，上 Cython 吧。。。

@Kirscheis 老哥，这个问题的另一个难点是如何用 Python 高效地实现楼主的需求。

这么说吧，用 Python 裸写一个 for (n): c[i] = a[i] + b[i] 要比 NumPy 写 c = a + b 至少慢 20 倍。没办法，NumPy 用 C 写的，而且有些操作还有 Intel SIMD 指令集加成，比不过的。

NumPy 的基本操作大致有：任意维张量的（每个对应元素）加减乘除、比较（判等和大小，输出布尔向量），布尔向量当做整形向量参与运算，任意维两个张量后两维、前两维的点积（这个 carefully 优化过，相信是考虑过指令集和 cache line 之类的各种问题的）。

由于这个限制，Python + NumPy 写程序的时候通常会“多做一些运算”，以求更短的执行时间。比如：

flag = (a > b)
c = flag * a + (1 - flag) * b

换成 C 语言你相信这个比 for 循环更快？
- - - -

昨天我就看到这个问题了，但是恕我愚钝，我想不出利用 NumPy 在 Python 里面优雅地解决这个问题的方案。

@lihongjie0209 另外你太小看 IDE 了。Webstorm 完全可以重构代码里面看得到结构的对象（ return {a: xxx, b: xxx} 这种），用起来和 Java 定义过的结构没有本质区别。

@lihongjie0209 我觉得 @v2dead 说的很对。你举的这个例子，这么冗长复杂的配置文件，在别的语言里面是不受待见的。像 Python、JS 处理 JSON 对象，一般只会出现在 API 接口处，然后立刻就处理掉了，没多少机会传播到别的地方的。所以也就没有什么不容易重构的坑了。

@MrgHOST ctypes https://docs.python.org/3/library/ctypes.html

@dwjgwsm

In [8]: arr_list = list(np.arange(100000))

In [10]: t1 = time.time(); moving_average(arr_list, 5); t2 = time.time(); numba_moving_average(arr_list, 5); t3 = time.time()

In [11]: (t2 - t1, t3 - t2)
Out[11]: (0.0019309520721435547, 0.23806500434875488)

In [12]: t1 = time.time(); moving_average(arr_list, 5); t2 = time.time(); numba_moving_average(arr_list, 5); t3 = time.time()

In [13]: (t2 - t1, t3 - t2)
Out[13]: (0.0016407966613769531, 0.005582094192504883)

In [14]: t1 = time.time(); [moving_average(arr_list, 5) for i in range(100)]; t2 = time.time(); [numba_moving_average(arr_list, 5) for i in range(100)]; t3 = time.time()

In [15]: (t2 - t1, t3 - t2)
Out[15]: (0.18658995628356934, 0.12822914123535156)

In [16]: t1 = time.time(); [moving_average(arr_list, 5) for i in range(1000)]; t2 = time.time(); [numba_moving_average(arr_list, 5) for i in range(1000)]; t3 = time.time()

In [17]: (t2 - t1, t3 - t2)
Out[17]: (1.3983790874481201, 1.3098900318145752)

你这代码本来就不科学啊。data_window.pop 你这是想干嘛啊？还有 sum_tick 有你这种写法嘛？好好的 O(n) 算法你给写成 O(n*k) ？

In [1]: import numpy as np

In [2]: import numba

In [3]: def moving_average(data, k):
...: partial_sum = sum(data[:k])
...: ret = [partial_sum / k]
...: for old_d, new_d in zip(data[:-k], data[k:]):
...: partial_sum = partial_sum - old_d + new_d
...: ret.append(partial_sum / k)
...: return ret
...:

In [4]: numba_moving_average = numba.jit(moving_average)

In [5]: arr = np.arange(10000)


In [6]: arr_list = list(arr)

In [7]: %timeit moving_average(arr_liset)

In [8]: %timeit moving_average(arr_list, 5)
3.8 ms ± 9.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [9]: %timeit numba_moving_average(arr_list, 5)
722 µs ± 35.3 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

@zhicheng “对账用”

别的语言也是一样的，只不过他们输出的时候没输出这么多位而已。

任何浮点数，只要小数部分不能写成 2 的负整数次幂的和，就有误差。

比如 0.25 = 2^{-2}，所以是精确的。但是 0.1 无法写成任何 2 的负整数次幂，所以会有误差。

你可以给 PyCharm 提 issue 了。

@SlipStupig Tornado 性能确实不错，但是建立在你本身 Python 已经很厉害的基础上。如果是新手，还是老老实实用 Flask 或者 Django 吧。

@jakeyfly “跨平台性能好”->“跨平台效果好”，或者“跨语言效果好”。