标签: optimization

我有一个Python脚本,它将整数列表作为输入,我需要一次使用四个整数.不幸的是,我无法控制输入,或者我将它作为四元素元组列表传入.目前,我正在以这种方式迭代它:

for i in xrange(0, len(ints), 4):
    # dummy op for example code
    foo += ints[i] * ints[i + 1] + ints[i + 2] * ints[i + 3]

它看起来很像"C-think",这让我怀疑有更多的pythonic方式来处理这种情况.迭代后会丢弃该列表,因此无需保留.也许这样的事情会更好吗？

while ints:
    foo += ints[0] * ints[1] + ints[2] * ints[3]
    ints[0:4] = []

但是,仍然没有"感觉"正确.: - /

相关问题:如何在Python中将列表拆分为大小均匀的块？

有没有之间的性能差异i++而++i如果结果不能用？

是的,我知道这个主题已经被覆盖过了(这里,这里,这里,这里),但据我所知,除了一个之外,所有解决方案都在这样的列表中失败:

L = [[[1, 2, 3], [4, 5]], 6]

期望的输出是什么

[1, 2, 3, 4, 5, 6]

或者甚至更好,一个迭代器.我看到的唯一适用于任意嵌套的解决方案可以在这个问题中找到:

def flatten(x):
    result = []
    for el in x:
        if hasattr(el, "__iter__") and not isinstance(el, basestring):
            result.extend(flatten(el))
        else:
            result.append(el)
    return result

flatten(L)

这是最好的型号吗？我忽略了什么吗？任何问题？

有没有什么好方法可以帮助识别项目中未使用的CSS定义？一堆css文件被拉进来,现在我正在尝试清理一些东西.

以下哪种技术是将整数除以2的最佳选择,为什么？

技巧1:

x = x >> 1;

技术2:

x = x / 2;

这x是一个整数.

回答另一个Stack Overflow问题(这个)我偶然发现了一个有趣的子问题.排序6个整数数组的最快方法是什么？

由于问题是非常低的水平:

• 我们不能假设库可用(并且调用本身有它的成本),只有普通的C.
• 避免排空指令流水线(具有非常高的成本),我们也许应该尽量减少分支机构,跳跃,和所有其他类型的控制流断裂的(像那些隐藏在背后的序列点&&或||).
• 房间受限制,最小化寄存器和内存使用是一个问题,理想情况下,排序可能是最好的.

真的这个问题是一种高尔夫,其目标不是最小化源长度而是执行时间.我把它叫做"Zening"代码在本书的标题中的代码优化禅由迈克尔·亚伯拉什及其续集.

至于为什么它很有趣,有几个层次:

• 这个例子很简单,易于理解和衡量,并没有太多的C技能
• 它显示了为问题选择好算法的效果,以及编译器和底层硬件的效果.

这是我的参考(天真的,未优化的)实现和我的测试集.

#include <stdio.h>

static __inline__ int sort6(int * d){

    char j, i, imin;
    int tmp;
    for (j = 0 ; j < 5 ; j++){
        imin = j;
        for (i = j + 1; i < 6 ; i++){
            if (d[i] < d[imin]){
                imin = i;
            }
        }
        tmp = d[j];
        d[j] = d[imin];
        d[imin] = …

我有一个非常大的MySQL表,大约有150,000行数据.目前,当我尝试并运行时

SELECT * FROM table WHERE id = '1';

代码运行正常,因为ID字段是主索引.但是,最近对于项目的开发,我必须通过另一个字段搜索数据库.例如

SELECT * FROM table WHERE product_id = '1';

此字段以前没有编入索引,但是,我已将其添加为索引,但是当我尝试运行上述查询时,结果非常慢.EXPLAIN查询显示,当我已经添加了一个索引时,product_id字段没有索引,因此查询从20分钟到30分钟的任何位置返回单行.

我的完整EXPLAIN结果是:

| id | select_type | table | type | possible_keys| key  | key_len | ref  | rows  | Extra       |
+----+-------------+-------+------+--------------+------+---------+------+-------+------------------+
|  1 | SIMPLE      | table | ALL  | NULL         | NULL | NULL    | NULL |157211 | Using where |
+----+-------------+-------+------+--------------+------+---------+------+-------+------------------+

注意我刚看了一眼,ID字段存储为INT,而PRODUCT_ID字段存储为VARCHAR,这可能会有所帮助.这可能是问题的根源吗？

我正在尝试优化一个在JavaScript中对字符串进行二进制搜索的函数.

二进制搜索要求您知道密钥是==枢轴还是<枢轴.

但这需要在JavaScript中进行两次字符串比较,这与C具有strcmp()返回三个值(-1, 0, +1)(小于,等于,大于)的函数的类似语言不同.

JavaScript中是否存在这样的本机函数,它可以返回三元值,以便在二进制搜索的每次迭代中只需要进行一次比较？

PEP 08指出:

导入总是放在文件的顶部,就在任何模块注释和文档字符串之后,以及模块全局变量和常量之前.

但是,如果我导入的类/方法/功能仅在极少数情况下使用,那么在需要时进行导入肯定会更有效率吗？

不是这个:

class SomeClass(object):

    def not_often_called(self)
        from datetime import datetime
        self.datetime = datetime.now()

比这更有效率？

from datetime import datetime

class SomeClass(object):

    def not_often_called(self)
        self.datetime = datetime.now()

可能重复:
这两个for循环中的哪一个在时间和缓存性能方面更有效

下面是两个几乎相同的程序,除了我切换i和j变量.它们都运行在不同的时间.有人能解释为什么会这样吗？

版本1

#include <stdio.h>
#include <stdlib.h>

main () {
  int i,j;
  static int x[4000][4000];
  for (i = 0; i < 4000; i++) {
    for (j = 0; j < 4000; j++) {
      x[j][i] = i + j; }
  }
}

版本2

#include <stdio.h>
#include <stdlib.h>

main () {
  int i,j;
  static int x[4000][4000];
  for (j = 0; j < 4000; j++) {
     for (i = 0; i < 4000; i++) {
       x[j][i] = i …