小编Jac*_*cky的帖子

最近,我需要实现一个程序,以尽可能快地将文件上传到Amazon EC2中的S3到S3.文件大小为30KB.

我尝试了一些解决方案,使用多线程,多处理,协同例程.以下是我在Amazon EC2上的性能测试结果.

3600(文件数量)*30K(文件大小)~~ 105M(总计)--->

       **5.5s [ 4 process + 100 coroutine ]**
       10s  [ 200 coroutine ]
       14s  [ 10 threads ]

代码如下所示

对于多线程

def mput(i, client, files):
    for f in files:
        if hash(f) % NTHREAD == i:
            put(client, os.path.join(DATA_DIR, f))


def test_multithreading():
    client = connect_to_s3_sevice()
    files = os.listdir(DATA_DIR)
    ths = [threading.Thread(target=mput, args=(i, client, files)) for i in range(NTHREAD)]
    for th in ths:
        th.daemon = True
        th.start()
    for th in ths:
        th.join()

对于协程

client = connect_to_s3_sevice()
pool = …

我是 SQLAlchemy 的新手。而现在我需要查询一些数据，如下

def get_xx():
    sess = Session()
    return sess.query(xx).filter(
        xx.id == 3, xx.status == 1
    ).first()

隔离级别是repeatable read并且自动提交是关闭的；因此，即使值已更新，我也总是得到相同的结果。

现在，问题出现了，sess.close() 和 sess.commit()，我应该使用哪种方法？

我尝试使用的最终解决方案如下，但是我不确定它是否足够好（提交后关闭）？

@contextmanager
def auto_session():
    sess = Session()
    try:
        yield sess
        sess.commit()
    except:  # swallow any exception
        sess.rollback()
    finally:
        sess.close()

并且源代码改变了

def get_xx():
    with auto_session() as sess:
        return sess.query(xx).filter(
            xx.id == 3, xx.status == 1
        ).first()

为什么 Paxos 需要两个阶段（prepare/promise+ accept/accepted）而不是一个阶段？也就是说，仅使用prepare/promise部分，如果提议者收到了大多数接受者的回复，则选择该值。

问题出在哪里，它是否破坏了安全性或活力？

在python的信号处理语义中，只有主线程才能设置信号处理程序，并且只有主线程才能调用信号处理程序。

为什么要这样设计？

我正在生成一个随机数据集。我的数据集是连续的，并且有上限和下限。在某些随机点，我希望我的数据集具有高于和低于限制的异常值。这是我的代码。

generated_data = (12) * np.random.rand(100) + 630
outlier_data = (12) * np.random.rand(20) + (*HERE'S THE PROBLEM)
merged_data = np.concatenate((generated_data, outlier_data))

之后，我想我会重新整理 merged_data。但我不知道如何正确生成异常值。

在uWSGi文档中,有一句话说,如果没有线程启动uWSGI,则不会启用Python GIL,因此应用程序生成的线程永远不会运行

我想知道uWSGi如何禁用python GIL？

请考虑以下情况:有一个慢速服务器使用大约200毫秒来处理请求(不包括网络传输时间).现在,我们需要每秒发送一堆请求.

阅读这篇文章后,我尝试了多线程,多进程,twisted(agent.request)和eventlet.但最大的加速只有6倍,这是通过twisted和eventlet实现的,两者都使用了epoll.

以下代码显示了带有eventlet的测试版本,

import eventlet
eventlet.monkey_patch(all=False, socket=True)

import requests

def send():
    pile = eventlet.GreenPile(30)
    for i in range(1000):
        pile.spawn(requests.get, 'https://api.???.com/', timeout=1)
    for response in pile:
        if response:
            print response.elapsed, response.text

任何人都可以帮助我明确为什么加速这么低？有没有其他机制可以使它更快？

我曾经使用过AWS EC2来部署一个Python应用程序，该应用程序使用来自Apache Kafka的数据。最近几天，我发现当传入数据变大时，CPU的窃取时间将变得太高（大约35％）。

使用的EC2实例是t2.medium，2个CPU和4G内存。任何人都可以告诉我为什么会发生这种情况，有什么办法可以避免这种情况。

我将python bin文件夹添加到环境变量中PATH，

export PATH=$PATH:/Library/Frameworks/Python.framework/Versions/2.7/bin

但以下语句失败

set: Warning: path component /usr/local/bin:/Library/Frameworks/Python.framework/Versions/2.7/bin may not be valid in PATH.
set: No such file or directory
set: Did you mean 'set PATH $PATH /Library/Frameworks/Python.framework/Versions/2.7/bin'?
set: Warning: path component /usr/bin:/Library/Frameworks/Python.framework/Versions/2.7/bin may not be valid in PATH.
set: No such file or directory
set: Did you mean 'set PATH $PATH /Library/Frameworks/Python.framework/Versions/2.7/bin'?
set: Warning: path component /bin:/Library/Frameworks/Python.framework/Versions/2.7/bin may not be valid in PATH.
set: No such file or directory
set: Did you mean 'set PATH …

为什么下面的代码返回两个False对？

from itertools import groupby

content = '1\t2\t3\n4\t5\t\n7\t8\t9'

result = groupby((line.split('\t') for line in content.splitlines()),
                 key=lambda x: x[2] == '')

for k, v in result:
    print '--->', k, id(k)
    print list(v)

结果如下图所示

---> False 505954168
[['1', '2', '3']]
---> True 505954192
[['4', '5', '']]
---> False 505954168
[['7', '8', '9']]

为什么代码中的注释说“所花费的时间与匹配的字符数无关”？

在我看来，所花费的时间应该取决于字符的数量。

代码是从Django复制的，crypto.py

def constant_time_compare(val1, val2):
    """
    Returns True if the two strings are equal, False otherwise.

    The time taken is independent of the number of characters that match.

    For the sake of simplicity, this function executes in constant time only
    when the two strings have the same length. It short-circuits when they
    have different lengths. Since Django only uses it to compare hashes of
    known expected length, this is acceptable.
    """
    if len(val1) != len(val2):
        return …