小编WKP*_*lus的帖子

令人惊讶的是,我发现startswith速度比in:

In [10]: s="ABCD"*10

In [11]: %timeit s.startswith("XYZ")
1000000 loops, best of 3: 307 ns per loop

In [12]: %timeit "XYZ" in s
10000000 loops, best of 3: 81.7 ns per loop

众所周知,in操作需要搜索整个字符串,startswith只需要检查前几个字符,所以startswith应该更有效率.

什么时候s足够大,startswith速度更快:

In [13]: s="ABCD"*200

In [14]: %timeit s.startswith("XYZ")
1000000 loops, best of 3: 306 ns per loop

In [15]: %timeit "XYZ" in s
1000000 loops, best of 3: 666 ns per loop

所以看起来调用 …

最近,我被std :: map operator []函数搞糊涂了.在MSDN库中,它说:"如果找不到参数键值,那么它将与数据类型的默认值一起插入." 我试图更准确地搜索这个问题的解释.例如: std :: map default value 在这个页面中,Michael Anderson说"默认值是由默认构造函数(零参数构造函数)构造的".

现在我的任务是:"内置类型的默认值是什么？".编译器是否相关？或者c ++标准委员会是否有这个问题的标准？

我在visual studio 2008上对"int"类型进行了测试,发现"int"类型的构造值为0.

我正在学习使用tmux,我发现当我在tmux窗口中时,双击选择并复制功能不再起作用.

我可以使用双击来选择和复制iterm2吗？

我用谷歌搜索了一段时间,但没有找到一个简短而明确的答案.我已经setw -g mode-mouse on在tmux配置文件中添加了.

有一段时间我对此感到困惑:我们是否需要在Python中使用丰富的比较？

我在这里阅读官方文档,但它只是给出了它的工作原理,而不是我们需要它的原因.

该文档的片段:

事实x==y并非暗示这x!=y是错误的.可以描述一个我们需要丰富比较的场景.在这个场景中,我们可以制作__eq__并且__ne__都返回False以禁用比较或任何其他目的.(我们可以通过使用实现这个 __cmp__)

但这只是猜测,我从未在真正的项目中遇到过这样的要求.

有没有人需要使用丰富的比较,还是有任何其他需要在理论上使用丰富的比较的场景？

也许是我的例子x==y并x!=y引起了一些混乱,对不起.让我更清楚一点:
有没有丰富的比较可以帮助但__cmp__不能帮助的情况？

我知道一个.pyc文件是由python解释器生成的,并且包含字节代码,正如这个问题所说的那样.

我以为python解释器正在使用时间戳来检测a .pyc是否比a更新.py,如果是,则在执行时跳过再次编译.(makefile的做法)

所以,我做了一个测试,但似乎我错了.

1. 我写了t.py包含print '123'和t1.py包含import t.运行命令python t1.py给出了输出123并生成了t.pyc所有内容.
2. 然后我编辑t.py的print '1234'和更新的时间戳 t.pyc使用touch t.pyc.
3. 再跑python t1.py一次,我以为我会得到123但1234 确实如此.所以似乎python解释器仍然知道t.py 更新.

然后我想知道python解释器是否会在t.pyc每次运行时编译和生成python t1.py.但是当我python t1.py多次运行时,我发现t.pyc未更新时t.py不会更新.

所以,我的问题是:python解释器如何知道何时编译和更新.pyc文件？

更新

由于python解释器使用存储在.pyc文件中的时间戳.我认为这.pyc是上次更新时间的记录.导入时,将其与.py文件的时间戳进行比较 .

所以我试图以这种方式破解它:将操作系统时间更改为较旧的时间,然后编辑.py文件.我想再次导入时,.py看起来比较旧 …

我们用namedtuple这样的:

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p=Point(1,2)
>>> p.x
1

我发现第一个论点namedtuple似乎没用,因为:

首先,我们不能使用它(例如,创建一个实例):

>>> from collections import namedtuple
>>> P = namedtuple('Point', ['x', 'y'])
>>> p = Point(1,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'Point' is not defined

其次,似乎没有约束(例如,我们不必使其独特):

>>> P1 = namedtuple('Point', ['x', 'y'])
>>> P2 = namedtuple('Point', ['x', 'y', 'z'])
>>> p1 = P1(1,2)
>>> p2 = P2(1,2,3)
>>> p1
Point(x=1, …

在python空闲中:

>>> a=1.1
>>> b=1.1
>>> a is b
False

但是当我将代码放入脚本并运行它时,我会得到不同的结果:

$cat t.py
a=1.1
b=1.1
print a is b
$python t.py
True

为什么会这样？我知道is比较id两个对象,为什么两个对象的id在python脚本/空闲中是相同/唯一的？

我还发现,如果我使用一个小的int,例如1,而不是1.1,结果将在python脚本和python空闲中相同.为什么小型int和小型浮动有不同的行为？

我正在使用CPython 2.7.5.

我找到了一些有趣的东西,这里有一段代码:

class A(object):
    def __init__(self):
        print "A init"

    def __del__(self):
        print "A del"

class B(object):
    a = A()

如果我运行此代码,我会得到:

A init

但是,如果我更改class B(object)到class B(),我会得到:

A init
A del

我在__del__ doc中找到了一个注释:

无法保证为解释器退出时仍然存在的对象调用del()方法.

然后,我想这是因为当解释器存在时B.a仍然引用(由类引用B).

所以,我del B在解释器手动存在之前添加了一个,然后我发现它a.__del__()被调用了.

现在,我对此感到有些困惑.为什么a.__del__()在使用旧样式时调用？为什么新旧风格的行为有不同的行为？

我在这里发现了类似的问题,但我认为答案还不够明确.

起初,我认为Bottle会同时处理请求,所以我写了下面的测试代码:

import json
from bottle import Bottle, run, request, response, get, post
import time

app = Bottle()
NUMBERS = 0


@app.get("/test")
def test():
    id = request.query.get('id', 0)
    global NUMBERS
    n = NUMBERS
    time.sleep(0.2)
    n += 1
    NUMBERS = n
    return id


@app.get("/status")
def status():
    return json.dumps({"numbers": NUMBERS})


run(app, host='0.0.0.0', port=8000)

然后我用jmeter请求/test10个线程循环20次的url.

在那之后,/status给我{"numbers": 200},看起来那瓶不同时处理请求.

我误解了什么吗？

UPDATE

我做了另一个测试,我认为它可以证明瓶子一个接一个地处理请求(没有并发).我对这个test功能做了一些改动:

@app.get("/test")
def test():
    t1 = time.time()
    time.sleep(5)
    t2 = time.time()
    return {"t1": t1, "t2": t2}

当我 …

由于GIL,我认为多线程python进程一次只能运行一个线程,因此cpu使用率不能超过100%.

但我发现下面的代码可以占用顶部950%的CPU使用率.

import threading
import time

def f():
    while 1:
        pass


for i in range(10):
    t = threading.Thread(target=f)
    t.setDaemon(True)
    t.start()

time.sleep(60)

这与Python解释器使用高达130%的CPU的问题不同.怎么可能？.在那个问题中,OP表示他正在进行I/O密集型负载测试,这可能会释放GIL.但在我的程序中,没有I/O操作.

测试在CPython 2.6.6上运行.