小编god*_*ygo的帖子

我试图制作一个纯python(没有外部依赖)两个序列的元素比较.我的第一个解决方案是

list(map(operator.eq, seq1, seq2))

然后我发现了starmap函数itertools,这看起来和我很相似.但在最坏的情况下,我的计算机上的速度提高了37%.由于对我来说不是很明显,我测量了从生成器中检索1个元素所需的时间(不知道这种方式是否正确):

from operator import eq
from itertools import starmap

seq1 = [1,2,3]*10000
seq2 = [1,2,3]*10000
seq2[-1] = 5

gen1 = map(eq, seq1, seq2))
gen2 = starmap(eq, zip(seq1, seq2))

%timeit -n1000 -r10 next(gen1)
%timeit -n1000 -r10 next(gen2)

271 ns ± 1.26 ns per loop (mean ± std. dev. of 10 runs, 1000 loops each)
208 ns ± 1.72 ns per loop (mean ± std. dev. of 10 runs, 1000 loops each)

在检索元素时,第二种解决方案的性能提高了24%.在那之后,他们都产生相同的结果list …

我已经阅读了很多"避免与numpy循环".所以,我试过了.我正在使用此代码(简化版).一些辅助数据:

 In[1]: import numpy as np
        resolution = 1000                             # this parameter varies
        tim = np.linspace(-np.pi, np.pi, resolution) 
        prec = np.arange(1, resolution + 1)
        prec = 2 * prec - 1
        values = np.zeros_like(tim)

我的第一个实现是for循环:

 In[2]: for i, ti in enumerate(tim):
           values[i] = np.sum(np.sin(prec * ti))

然后,我摆脱了显式for循环,并实现了这一点:

 In[3]: values = np.sum(np.sin(tim[:, np.newaxis] * prec), axis=1)

对于小型阵列来说,这个解决方案更快,但是当我扩大规模时,我有这样的时间依赖:

我缺少什么或是正常行为？如果不是,在哪里挖？

编辑:根据评论,这里有一些额外的信息.用IPython中的测量的时间%timeit和%%timeit,在新内核进行每一次运行.我的笔记本电脑是acer aspire v7-482pg(i7,8GB).我正在使用:

• python 3.5.2
• numpy 1.11.2 + mkl
• Windows 10

我无法弄清楚如何存储细胞魔法的结果 - %%timeit？我读了:

1. 你能捕获ipython魔法的输出吗？
2. 捕获IPython魔术函数的结果

而在这个问题中只回答线魔术.在行模式(%)这适用:

In[1]: res = %timeit -o np.linalg.inv(A)

但在单元格模式(%%)中它没有:

In[2]: res = %%timeit -o 
       A = np.mat('1 2 3; 7 4 9; 5 6 1')
       np.linalg.inv(A)

它只是执行单元格,没有魔法.这是一个错误还是我做错了什么？

阅读有趣的书"从Python到Numpy"我遇到了一个例子,其描述如下:

让我们考虑一个简单的例子,我们想要从具有dtype的数组中清除所有值np.float32.如何写它以最大化速度？

提供的结果让我感到惊讶,当我重新检查它们时,我得到了完全不同的行为.因此,我要求作者仔细检查,但他在下表中收到了与之前相同的结果(OS X 10):

这些变体在三台不同的计算机上定时:我的(Win10,Win7)和作者(OSX 10.13.3).使用Python 3.6.4和numpy 1.14.2,其中每个变体定时为固定的100循环,最好是3.

编辑:这个问题不是关于这样一个事实:在不同的计算机上,具有不同的特征,我得到不同的时间 - 这是显而易见的:) 问题是两个操作系统上的行为是非常不同的 - 这不是那么明显？(如果是这样的话,如果有人可以仔细检查,我会很高兴).

设置是: Z = np.ones(4*1000000, np.float32)

| Variant                     | Windows 10 | Ubuntu 17.10 | Windows 7 | OSX 10.13.3 |
|                             |       computer 1          |   comp 2  |    comp 3   |
| --------------------------- | ------------------------- | --------- | ----------- |
| Z.view(np.float64)[...] = 0 …

有人可以解释为什么我在数组分配期间获得如此奇怪和不同的时间,结果是分配稍大一些数组并切片它比分配所需大小的数组要快25倍:

%timeit arr = np.zeros((360, 360))
207 µs ± 4.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%%timeit
arr = np.zeros((362, 362))
arr = arr[:360]
8.4 µs ± 651 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

是否有一些普遍背后的东西,或者是一些与Windows相关的问题？虽然这种情况特定(360, 360) size在我的电脑附近,但我不知道它是否会出现在其他地方.

编辑:虽然这个问题被标记为重复,但该问题的答案并不能完全解释问题:

%timeit -n10 -r10 arr = np.zeros((361, 361))
243 µs ± 56.6 µs per loop (mean ± std. dev. of 10 runs, 10 loops …

我正在尝试使用 matplotlib 中的刻度标签进行一些操作。但似乎代码没有做我想要的，我不知道为什么？没有标签。

In[1]: import matplotlib.pyplot as plt
       import numpy as np

In[2]: x = np.arange(0,10)

In[3]: plt.plot(x,x)

       locs, labs = plt.xticks()
       plt.xticks(locs[1:], labs[1:])

       plt.show()

请任何帮助！我想要的是删除 x 轴上的第一个标签：

我正在使用：
python 3.5.2
matplotlib 1.5.3
win 10

我正在尝试在交互式shell(IPython在我的情况下)中工作时从分析中实现漂亮的结果.这是某种映射,顺序对我来说很重要,所以我试图继承OrderedDict和覆盖__repr__方法,但这种方法不起作用.最低测试示例:

 In[1]: from collections import OrderedDict

 In[2]: class Result(OrderedDict):
            def __repr__(self):
                if self.keys():
                    report = []
                    for k, v in self.items():
                        report.append(k.ljust(10) + ': ' + repr(v))
                    return "\n".join(report)
                else:
                    return self.__class__.__name__ + "()"

 In[3]: res = Result()
        res['all'] = 10
        res['some'] = 11
        res
Out[3]: Result([('all', 10), ('some', 11)])

但是当我继承自dict(class Result(dict):)时,这种方法按预期工作,结果如下:

Out[3]: all       : 10
        some      : 11

但订单无法保证.我不知道,为什么第一种方法不起作用？

编辑:
Python 3.6.1
IPython 6.0.0

这是在Python 3.5+中制作浅层副本的几种替代方法list.显而易见的是:

• some_list.copy()
• some_list[:]
• list(some_list)
• [*some_list]
• 和别的...

哪种方法最快？

注意:虽然此问题与"列表副本"有关,但它仅涉及Python 3.5+中的性能.如果您需要回答" 为什么需要Python中的列表副本？ "或" Python中列表的浅层和深层复制有什么区别？ "的问题,请阅读以下内容: 如何克隆或复制清单？