让我们用,例如, numpy.sin()
以下代码将返回数组的每个值的正弦值a:
import numpy
a = numpy.arange( 1000000 )
result = numpy.sin( a )
但我的机器有32个核心,所以我想利用它们.(对于类似的东西,开销可能不值得,numpy.sin()但我实际想要使用的功能要复杂得多,而且我将使用大量数据.)
这是最好的(阅读:最聪明或最快)方法:
from multiprocessing import Pool
if __name__ == '__main__':
pool = Pool()
result = pool.map( numpy.sin, a )
或者有更好的方法吗？
可能重复:
Python多处理全局变量更新未返回到父级
我使用的是具有多个内核的计算机,并且为了性能优势,我应该使用多个.但是,我很困惑为什么这些代码不能达到我的预期:
from multiprocessing import Process
var = range(5)
def test_func(i):
global var
var[i] += 1
if __name__ == '__main__':
jobs = []
for i in xrange(5):
p = Process(target=test_func,args=(i,))
jobs.append(p)
p.start()
print var
以及
from multiprocessing import Pool
var = range(5)
def test_func(i):
global var
var[i] += 1
if __name__ == '__main__':
p = Pool()
for i in xrange(5):
p.apply_async(test_func,[i])
print var
我希望结果是,[1, 2, 3, 4, 5]但结果是[0, 1, 2, 3, 4].
在使用全局变量和进程时,我必须要有一些微妙之处.这是偶然的方式还是我应该避免尝试以这种方式更改变量？
我想找到两个时间戳数组之间的偏移量.它们可以代表两个音轨中的哔哔声.
注意:两个轨道中可能有额外或缺少的开始.
我找到了一些关于互相关的信息(例如https://dsp.stackexchange.com/questions/736/how-do-i-implement-cross-correlation-to-prove-two-audio-files-are-similar)看起来很有希望.
我假设每个音轨的持续时间为10秒,并将哔哔声表示为"方波"的峰值,采样率为44.1 kHz:
import numpy as np
rfft = np.fft.rfft
irfft = np.fft.irfft
track_1 = np.array([..., 5.2, 5.5, 7.0, ...])
# The onset in track_2 at 8.0 is "extra," it has no
# corresponding onset in track_1
track_2 = np.array([..., 7.2, 7.45, 8.0, 9.0, ...])
frequency = 44100
num_samples = 10 * frequency
wave_1 = np.zeros(num_samples)
wave_1[(track_1 * frequency).astype(int)] = 1
wave_2 = np.zeros(num_samples)
wave_2[(track_2 * frequency).astype(int)] = 1
xcor = irfft(rfft(wave_1) * np.conj(rfft(wave_2)))
offset …我编写了这段代码来测试我的计算机上的Python多处理:
from multiprocessing import Pool
var = range(5000000)
def test_func(i):
return i+1
if __name__ == '__main__':
p = Pool()
var = p.map(test_func, var)
我使用Unix的time命令计时,结果如下:
real 0m2.914s
user 0m4.705s
sys 0m1.406s
然后,使用相同var和test_func()我定时:
var = map(test_func, var)
结果是
real 0m1.785s
user 0m1.548s
sys 0m0.214s
多处理代码不应该比普通的代码快得多map吗？
如果我有 HTML5video和audio元素，是否有一种干净的方法来使它们保持同步？它们应该像包含音轨的视频文件一样，因此手动推进一个音轨应该会同时带来另一个音轨。假设这两个曲目的持续时间相同。
我想要一个可以跨浏览器工作的解决方案，但我并不特别关心它是否可以在旧版浏览器上工作。如果可能的话，最好避免使用 JavaScript。否则，一个极其简单的 JavaScript 库将是最好的——它只要求同步哪些曲目并处理其余的事情。
我研究过mediagroup ...但看起来它只适用于 Safari。我研究过audioTracks ...但用户必须在Firefox 中启用该功能。
我研究了Popcorn.js，它是一个 JavaScript 框架，似乎是为这个任务设计的......但看起来一年多来没有任何活动。除此之外，我能找到的唯一演示是将文本或幻灯片等内容同步到视频，而不是音频到视频。
使用Python的fractions模块我可以做类似的事情：
>>> from fractions import Fraction
>>> import math
>>> target_number = str( 10 / math.pi )
>>> Fraction( target_number )
Fraction(39788735773, 12500000000)
但如果我想要十六分之一的分数该怎么办？那是，Fraction(51, 16)。仅使用limit_denominator(16)使得最大分母为 16：
>>> Fraction( target_number ).limit_denominator(16)
Fraction(35, 11)
有没有一种简单的方法可以使用fractions模块来做到这一点？
从http://docs.sqlalchemy.org/en/improve_toc/orm/extensions/declarative/mixins.html#augmenting-the-base我看到你可以在基类中定义方法和属性.
我想确保所有子类都实现一个特定的方法.但是,在尝试定义这样的抽象方法时:
import abc
from sqlalchemy.ext.declarative import declarative_base
class Base(metaclass=abc.ABCMeta):
@abc.abstractmethod
def implement_me(self):
pass
Base = declarative_base(cls=Base)
class Child(Base):
__tablename__ = 'child'
我收到了错误 TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases
我试图找到一些文档或示例来帮助我,但是很简单.
当我做出一个奇怪的发现时,我决定使用Python 实现睡眠排序(https://rosettacode.org/wiki/Sorting_algorithms/Sleep_sort)asyncio:它使用负值(并立即返回0)!
这是代码(你可以在这里运行https://repl.it/DYTZ):
import asyncio
import random
async def sleepy(value):
return await asyncio.sleep(value, result=value)
async def main(input_values):
result = []
for sleeper in asyncio.as_completed(map(sleepy, input_values)):
result.append(await sleeper)
print(result)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
input_values = list(range(-5, 6))
random.shuffle(input_values)
loop.run_until_complete(main(input_values))
正如预期的那样,代码需要5秒才能执行,但结果总是如此[0, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5].我可以理解0立即返回,但负值如何以正确的顺序返回？
对于像这样的表：
CREATE TABLE example (
totally_unique JSONB
);
如何限制所有键的值totally_unique必须不同？键和值可以是任何字符串，所以我不能只为每个可能的键编写单独的约束。
换句话说，如果{"a": "one", "b": "two"}在表中，我想阻止插入，{"a": "one", "b": "three"}因为该值totally_unique->>'a' = 'one'已经存在。
一个UNIQUE约束是不够的，但我看不出有什么样的约束或指数会工作。
我用这种逻辑编写了一个脚本，以便在生成许多记录时将其插入到 PostgreSQL 表中。
#!/usr/bin/env python3
import asyncio
from concurrent.futures import ProcessPoolExecutor as pool
from functools import partial
import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base
metadata = sa.MetaData(schema='stackoverflow')
Base = declarative_base(metadata=metadata)
class Example(Base):
__tablename__ = 'example'
pk = sa.Column(sa.Integer, primary_key=True)
text = sa.Column(sa.Text)
sa.event.listen(Base.metadata, 'before_create',
sa.DDL('CREATE SCHEMA IF NOT EXISTS stackoverflow'))
engine = sa.create_engine(
'postgresql+psycopg2://postgres:password@localhost:5432/stackoverflow'
)
Base.metadata.create_all(engine)
session = sa.orm.sessionmaker(bind=engine, autocommit=True)()
def task(value):
engine.dispose()
with session.begin():
session.add(Example(text=value))
async def infinite_task(loop):
spawn_task = partial(loop.run_in_executor, None, task)
while True:
await asyncio.wait([spawn_task(value) for …例如,如果我有一个元组列表,例如
a = [(1,2)] * 4
我如何创建每个元组的第一个元素的列表？就是这样[1, 1, 1, 1].