相关疑难解决方法(0)

简而言之

我想同时更改复杂的python对象,每个对象只由一个进程处理.我怎么能这样做(效率最高)？实施某种酸洗支持会有帮助吗？这会有效吗？

完整的问题

我有一个python数据结构ArrayDict,基本上由一个numpy数组和一个字典组成,并将任意索引映射到数组中的行.在我的例子中,所有键都是整数.

a = ArrayDict()

a[1234] = 12.5
a[10] = 3

print(a[1234])                               #12.5
print(a[10])                                 # 3.0

print(a[1234] == a.array[a.indexDict[1234]]) #true

现在我有多个这样的ArrayDicts并希望填写它们myMethod(arrayDict, params).由于myMethod价格昂贵,我想并行运行它.请注意,myMethod可能会添加许多行arrayDict.每个过程都会改变自己的过程ArrayDict.我不需要并发访问ArrayDicts.

在myMethod,我更改了条目arrayDict(即,我更改了内部numpy数组),我添加了条目arrayDict(也就是说,我向字典添加另一个索引并在内部数组中写入一个新值).最终,我希望能够在arrayDict内部numpy阵列变得太小时进行交换.这不会经常发生,如果没有更好的解决方案,我可以在程序的非并行部分执行此操作.即使没有阵列交换,我自己的尝试也没有成功.

我花了几天时间研究共享内存和python的多处理模块.由于我最终将在linux上工作,因此任务似乎相当简单:系统调用fork()允许有效地处理参数的副本.我的想法是ArrayDict在自己的进程中更改每个,返回对象的更改版本,并覆盖原始对象.为了节省内存并保存复制工作,我还使用了sharedmem数组来存储数据ArrayDict.我知道字典必须仍然被复制.

from sharedmem import sharedmem
import numpy as np

n = ...                   # length of …

我在 Python 中有一些字符串处理工作。我希望通过使用线程池来加快工作速度。字符串处理作业彼此之间没有依赖关系。结果将存储到 mongodb 数据库中。

我写了我的代码如下：

thread_pool_size = multiprocessing.cpu_count()
pool = ThreadPool(thread_pool_size)
for single_string in string_list:
    pool.apply_async(_process, [single_string ])
pool.close()
pool.join()

def _process(s):
    # Do staff, pure python string manipulation.
    # Save the output to a database (pyMongo).

我尝试在具有 8 个 CPU 内核的 Linux 机器上运行代码。事实证明，当我运行作业几分钟时，最大 CPU 使用率只能约为 130%（从顶部读取）。

我使用线程池的方法是否正确？有没有更好的方法来做到这一点？

我正在学习Python中的线程库。我不明白，如何并行运行两个线程？

这是我的python程序：

没有线程的程序（fibsimple.py）

def fib(n):
    if n < 2:
        return n
    else: 
        return fib(n-1) + fib(n-2)

fib(35)
fib(35)

print "Done"

运行时间：

$ time python fibsimple.py 
Done

real    0m7.935s
user    0m7.922s
sys 0m0.008s

带有线程的相同程序（fibthread.py）

from threading import Thread
def fib(n):
    if n < 2:
        return n
    else: 
        return fib(n-1) + fib(n-2)

t1 = Thread(target = fib, args = (35, ))
t1.start()

t2 = Thread(target = fib, args = (35, ))
t2.start()

t1.join()
t2.join()

print "Done"

运行时间：

$ …

我是多线程处理的新手,所以如果我屠宰条款或遗漏一些明显的东西,请原谅我.

下面的代码不会提供任何时间优势,而不是相继调用相同的两个函数的不同代码.

import time
import threading

start_time = time.clock()

def fibonacci(nth): #can be ignored
    first = 0
    second = 1
    for i in range(nth):
        third = first + second
        first = second
        second = third
    print "Fibonacci number", i + 1, "is", len(str(first)), "digits long"

def collatz(collatz_max): #can be ignored
    for n in range(collatz_max):
        n = n + 1 #avoid entering 0
        solution = []
        solution.append(n)
        while n != 1:
            if n % 2 == 0:
                n = n / …

我正在编写一个svn up并行运行的程序,它导致机器冻结.发生这种情况时,服务器没有遇到任何负载问题.

该命令使用运行ThreadPool.map()到subprocess.Popen():

def cmd2args(cmd):
    if isinstance(cmd, basestring):
        return cmd if sys.platform == 'win32' else shlex.split(cmd)
    return cmd

def logrun(cmd):
    popen = subprocess.Popen(cmd2args(cmd),
                             stdout=subprocess.PIPE,
                             stderr=subprocess.STDOUT,
                             cwd=curdir,
                             shell=sys.platform == 'win32')
    for line in iter(popen.stdout.readline, ""):
        sys.stdout.write(line)
        sys.stdout.flush()

...
pool = multiprocessing.pool.ThreadPool(argv.jobcount)
pool.map(logrun, _commands)

argv.jobcount是multiprocessing.cpu_count()运行的作业的较小者和数量(在这种情况下是4). _commands是一个字符串列表,其中包含下面列出的命令. 在Windows上shell设置为Trueshell,因此shell可以找到可执行文件,因为Windows没有which命令,并且在Windows上查找可执行文件有点复杂(以前的命令cd directory&&svn up ..也需要,shell=True但现在已经完成了cwd参数代替).

正在运行的命令是

  svn up w:/srv/lib/dktabular
  svn up w:/srv/lib/dkmath
  svn up w:/srv/lib/dkforms …

我对使用硒的python中的并行执行感到困惑。似乎有几种方法可以解决，但有些似乎已过时。

我想知道使用硒进行并行执行的最新方法是什么？

有一个名为python-wd-parallel的python模块，似乎有一些功能可以做到这一点，但这是从2013年开始的，现在仍然有用吗？

例如https://saucelabs.com/blog/parallel-testing-with-python-and-selenium-on-sauce-online-workshop-recap

我们还拥有并发。未来，这似乎更新了很多，但实现起来却不那么容易-有人在硒中有一个可以并行执行的有效示例吗？

也仅使用线程和执行程序来完成工作，但是我觉得这样做会比较慢，因为它没有使用所有内核，并且仍以串行形式运行。

我希望运行一个模拟，同时在一个 plot 中输出它的进度。我一直在查看很多线程和多处理的示例，但它们都非常复杂。所以我认为使用 Python 的新asyncio库应该会更容易。

我找到了一个例子（How to use 'yield' inside async function?）并为我的原因修改了它：

import matplotlib.pyplot as plt
import asyncio
import numpy as np


class DataAnalysis():
    def __init__(self):
        # asyncio so we can plot data and run simulation in parallel
        loop = asyncio.get_event_loop()
        try:
            loop.run_until_complete(self.plot_reward())
        finally:
            loop.run_until_complete(
                loop.shutdown_asyncgens())  # see: https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.AbstractEventLoop.shutdown_asyncgens
            loop.close()

    async def async_generator(self):
        for i in range(3):
            await asyncio.sleep(.4)
            yield i * i

    async def plot_reward(self):
        # Prepare the data
        x = …

我正在学习多处理和多线程。

据我了解，线程在同一个核心上运行，所以我想知道如果我在子线程中创建多个进程，它们也会被限制在该单个核心上吗？

我正在使用 python，所以这是一个关于该特定语言的问题，但我想知道它与其他语言是否相同？

我正在尝试将bash脚本迁移到Python.

bash脚本并行运行多个OS命令,然后在恢复之前等待它们完成,即:

command1&

command2&

.

命令与

等待

命令

我想使用Python子进程实现相同的功能.这可能吗？如何在恢复之前等待subprocess.call命令完成？

我有一个2d numpy数组X = (xrows, xcols),我想在数组的每个行组合上应用点积,以获得另一个形状的数组P = (xrow, xrow).

代码如下所示:

P = np.zeros((xrow, xrow))
for i in range(xrow):
   for j in range(xrow):
      P[i, j] = numpy.dot(X[i], X[j])

如果阵列X很小但是需要花费大量时间才能很好地工作X.有没有什么方法可以让它更快或更蟒蛇化,以便快速？