小编MSe*_*ert的帖子

我有一个计算项目,大量使用日志函数(对于整数),数十亿的调用.我发现numpy的日志性能出乎意料地慢了.

以下代码需要15到17秒才能完成:

import numpy as np
import time

t1 = time.time()
for i in range(1,10000000): 
    np.log(i)
t2 = time.time()
print(t2 - t1)

但是,math.log函数从3到4秒的时间要少得多.

import math
import time

t1 = time.time()
for i in range(1,10000000): 
    math.log(i)
t2 = time.time()
print(t2 - t1)

我还测试了matlab和C#,它们分别需要大约2秒和0.3秒.

MATLAB

tic
for i = 1:10000000
    log(i);
end
toc

C#

var t = DateTime.Now;
for (int i = 1; i < 10000000; ++i)
     Math.Log(i);
Console.WriteLine((DateTime.Now - t).TotalSeconds);

在python中有什么办法可以提高日志功能的性能吗？

我必须为每个密钥创建一个被阻止用户的列表.每个用户都有多个属性,如果这些属性中的任何一个属于键,则会阻止用户.

我编写了以下嵌套for-loop,它适用于我,但我想以更加pythonic的方式编写它,使用更少的行和更具可读性的方式.我怎样才能做到这一点？

for key in keys:
    key.blocked_users = []

for user in get_users():
    for attribute in user.attributes:
        for key in keys:
            if attribute.name == key.name:
                key.blocked_users.append(user)

假设我有一个生成器，它的__next__()功能有点贵，我想尝试并行化调用。我在哪里投入平行化？

更具体一点，请考虑以下示例：

# fast, splitting a file for example
raw_blocks = (b for b in block_generator(fin))
# slow, reading blocks, checking values ...
parsed_blocks = (block_parser(b) for b in raw_blocks)
# get all parsed blocks into a data structure
data = parsedBlocksToOrderedDict(parsed_blocks)

最基本的事情是将第二行更改为进行并行化的内容。是否有一些生成器魔法可以让一个人并行解压生成器（在第三行）？__next__()并行调用？

NumPy在创建数组时非常有用.如果第一个参数numpy.array包含a __getitem__和__len__方法,则可以使用它们,因为它可能是一个有效的序列.

不幸的是,我想创建一个包含dtype=objectNumPy"无用" 的数组.

分解为一个最小的例子,这个类是这样的:

import numpy as np

class Test(object):
    def __init__(self, iterable):
        self.data = iterable

    def __getitem__(self, idx):
        return self.data[idx]

    def __len__(self):
        return len(self.data)

    def __repr__(self):
        return '{}({})'.format(self.__class__.__name__, self.data)

如果"iterables"有不同的长度,一切都很好,我得到了我想要的结果:

>>> np.array([Test([1,2,3]), Test([3,2])], dtype=object)
array([Test([1, 2, 3]), Test([3, 2])], dtype=object)

但是如果NumPy恰好具有相同的长度,它会创建一个多维数组:

>>> np.array([Test([1,2,3]), Test([3,2,1])], dtype=object)
array([[1, 2, 3],
       [3, 2, 1]], dtype=object)

不幸的是,只有一个ndmin论点,所以我想知道是否有办法强制执行ndmax或以某种方式阻止NumPy将自定义类解释为另一个维度(不删除__len__或__getitem__)？

NotImplemented从__eq__python 3中的特殊方法返回的结果是什么(如果重要,则为3.5)？

文件不清楚; 我发现的唯一相关文字只是模糊地提到"其他一些后备":

当NotImplemented返回时,解释器将尝试在其他类型的,或其他一些后备的反射操作,取决于运营商.如果所有尝试的操作都返回NotImplemented,则解释器将引发适当的异常.有关更多详细信息,请参阅实现算术运算.

不幸的是,"更多细节"链接根本没有提到__eq__.

我对这段摘录的解读表明,下面的代码应该引发"适当的例外",但它不会:

class A:
  def __eq__(self, other):
    return NotImplemented

class B:
  def __eq__(self, other):
    return NotImplemented

# docs seems to say these lines should raise "an appropriate exception"
# but no exception is raised
a = A()
b = B()
a == b # evaluates as unequal
a == a # evaluates as equal

从实验开始,我认为当NotImplemented返回时__eq__,解释器的行为就好像__eq__首先没有定义一样(具体来说,它首先交换参数,如果这不能解决问题,它会使用 …

我正在使用熊猫并groupby进行聚合.我正在做以下事情:

data = {'ac' : ['a','a','a','a','a','a','a','a','b','b','b','b','b'],
        'cls'   ['wwww','wwww','wwww','xxxx','xxxx','zzzz','zzzz','yyyy','wwww','xxxx','zzzz','zzzz','yyyy'],
        'pl' : [1,1,1,1,1,1,1,1,1,1,1,1,1]}

df = pd.DataFrame(data)

grouped = df.groupby(['ac','cls']).agg({'pl':np.sum})


           pl
    ac cls     
    a  wwww   3
       xxxx   2
       yyyy   1
       zzzz   2
    b  wwww   1
       xxxx   1
       yyyy   1
       zzzz   2

有没有办法groupby在它填充ac列的位置,以便它如下所示？

             pl
    ac cls     
    a  wwww   3
    a  xxxx   2
    a  yyyy   1
    a  zzzz   2
    b  wwww   1
    b  xxxx   1
    b  yyyy   1
    b  zzzz   2

我有一个dataset有4个维度(现在......),我需要迭代它.

要访问中的值dataset,我这样做:

value = dataset[i,j,k,l]

现在,我可以得到shape为dataset:

shape = [4,5,2,6]

值in shape表示维度的长度.

考虑到维度的数量,我可以如何迭代数据集中的所有元素？这是一个例子:

for i in range(shape[0]):
    for j in range(shape[1]):
        for k in range(shape[2]):
            for l in range(shape[3]):
                print('BOOM')
                value = dataset[i,j,k,l]

在未来,shape可能会改变.因此,例如,shape可能有10个元素而不是当前的4个元素.

使用Python 3有一个很好的,干净的方法吗？

是否有与JavaScript中Python的itertools类似的库？我对排列和组合特别感兴趣。

我没有使用Node.js。

我想做这样的事情：

array = ['a', 'b', 'c', 'd'];

//return non-duplicate combinations of length 2
['a', 'b']
['a', 'c']
['a', 'd']
['b', 'c']
['b', 'd']
['c', 'd']

谢谢！:)

在我的研究中，我发现在 Python 3 中这三种类型的类定义是同义词：

class MyClass:
    pass

class MyClass():
    pass

class MyClass(object):
    pass

但是，我无法找出推荐哪种方式。我应该使用哪一个作为最佳实践？

我正在使用 numba 来制作一些包含 numpy 数组循环的函数。

一切都很好，花花公子，我可以使用jit并且我学会了如何定义签名。

现在我尝试在带有可选参数的函数上使用 jit，例如：

from numba import jit
import numpy as np

@jit(['float64(float64, float64)', 'float64(float64, optional(float))'])
def fun(a, b=3):
    return a + b

这有效，但如果不是optional(float)我使用optional(float64)它，则无效（与int或相同int64）。我花了 1 个小时试图弄清楚这个语法（实际上，我的一个朋友偶然发现了这个解决方案，因为他忘记64在浮动之后写），但是，为了我的爱，我不明白为什么会这样。我在互联网上找不到任何东西，而且 numba 关于该主题的文档充其量是稀缺的（并且他们指定optional应该采用 numba 类型）。

有谁知道这是如何工作的？我错过了什么？