我正在用matplotlib创建几个pdf图,它由400个子图组成.每个只有5个数据点.在一台好的电脑上需要420秒才能保存5张pdf图片.有没有办法优化代码,或者matplotlib是正常的？

绘图的部分代码:

plot_cnt = 1
for k in np.arange(K_min, K_max + 1):
    for l in np.arange(L_min, L_max + 1):
        ax = plt.subplot(grid[0], grid[1], plot_cnt)
        plot_cnt += 1
        plt.setp(ax, 'frame_on', False)
        ax.set_ylim([-0.1, 1.1])
        ax.set_xlabel('K={},L={}'.format(k, l), size=3)
        ax.set_xlim([-0.1, 4.1])
        ax.set_xticks([])
        ax.set_yticks([])
        ax.grid('off')
        ax.plot(np.arange(5), (data['S1']['Azimuth'][:, k - 1, l + offset_l] + \
                data['S1']['Delta Speed'][:, k - 1, l + offset_l] + \
                data['S1']['Speed'][:, k - 1, l + offset_l]) / 3,
                'r-o', ms=1, mew=0, mfc='r')
        ax.plot(np.arange(5), data['S2'][case][:, k - 1, l + …

在上一个问题中,我问过多处理,使用多个内核使程序运行得更快,有人告诉我:

通常情况下,使用更好的代码可以获得100x +优化,而使用多处理可以获得4倍的改进和额外的复杂性

然后他们建议我应该:

使用分析器来了解什么是慢,然后专注于优化.

所以我回答了这个问题:你如何描述一个脚本？

在这里,我发现cProfile并将其实现到一些测试代码中,以了解它是如何工作的.

这是我的代码:

import cProfile

def foo():
    for i in range(10000):
        a = i**i
        if i % 1000 == 0:
            print(i)

cProfile.run('foo()')

然而,在运行之后,这就是我得到的:

0
1000
2000
3000
4000
5000
6000
7000
8000
9000
         1018 function calls in 20.773 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000   20.773   20.773 <string>:1(<module>)
      147    0.000    0.000    0.000    0.000 rpc.py:150(debug)
       21    0.000    0.000    0.050    0.002 rpc.py:213(remotecall)
       21    0.000    0.000    0.002    0.000 …

我有一个非常大的netCDF文件,我正在使用python中的netCDF4阅读

我无法一次读取此文件,因为它的尺寸(1200 x 720 x 1440)太大,整个文件不能同时在内存中.第一维代表时间,下一个分别代表纬度和经度.

import netCDF4 
nc_file = netCDF4.Dataset(path_file, 'r', format='NETCDF4')
for yr in years:
    nc_file.variables[variable_name][int(yr), :, :]

然而,一次阅读一年是非常缓慢的.如何加快以下用例的速度？

- 编辑

chunksize是1

1. 我可以阅读一系列年份:nc_file.variables [variable_name] [0:100,:,]

2. 有几个用例:

   多年来:

   numpy.ma.sum(nc_file.variables[variable_name][int(yr), :, :])
   

   Run Code Online (Sandbox Code Playgroud)

# Multiply each year by a 2D array of shape (720 x 1440)
for yr in years:
    numpy.ma.sum(nc_file.variables[variable_name][int(yr), :, :] * arr_2d)

# Add 2 netcdf files together 
for yr in years:
    numpy.ma.sum(nc_file.variables[variable_name][int(yr), :, :] + 
                 nc_file2.variables[variable_name][int(yr), :, :])

我在Pygame中写了一个简单的自上而下的RPG,我发现它很慢......虽然我不希望python或pygame匹配用C/C++或事件Byte Compiled等编译语言制作的游戏的FPS像Java一样,但目前的pygame的FPS仍然是15.我尝试渲染16色Bitmaps而不是PNG或24位图,这略微提高了速度,然后在绝望中,我将所有内容切换为黑白单色位图,使FPS达到35.但不是更多.现在根据我读过的大多数游戏开发书籍,为了让用户对游戏图形完全满意,2d游戏的FPS至少应该是40,那么有什么方法可以提高pygame的速度吗？

这个问题在这里是半基础的:

你怎么能描述一个python脚本？

我认为在我的一些程序上运行这是一个好主意.虽然可以按照上述答案中的说明从批处理文件进行分析,但我认为在Eclipse中使用此选项会更好.同时,使我的整个程序成为一个函数并分析它意味着我必须改变源代码？

我如何配置eclipse,以便能够在现有程序上运行profile命令？

欢迎任何提示或建议!

背景

我正在研究使用芹菜(3.1.8)来处理每个文本文件(~30GB).这些文件采用fastq格式,包含大约118M的测序"读数",基本上每个都是标题,DNA序列和质量字符串的组合.此外,这些序列来自配对末端测序运行,因此我同时迭代两个文件(通过itertools.izip).我希望能够做的是将每对读取,发送到队列,并在我们集群中的一台机器上处理它们(不关心哪些)以返回清理后的版本如果清洁需要发生(例如,基于质量).

我已经建立了芹菜和兔子,我的工作人员如下:

celery worker -A tasks --autoreload -Q transient 

并配置如下:

from kombu import Queue

BROKER_URL = 'amqp://guest@godel97'
CELERY_RESULT_BACKEND = 'rpc'
CELERY_TASK_SERIALIZER = 'pickle'
CELERY_RESULT_SERIALIZER = 'pickle'
CELERY_ACCEPT_CONTENT=['pickle', 'json']
CELERY_TIMEZONE = 'America/New York'
CELERY_ENABLE_UTC = True
CELERYD_PREFETCH_MULTIPLIER = 500

CELERY_QUEUES = (
    Queue('celery', routing_key='celery'),
    Queue('transient', routing_key='transient',delivery_mode=1),
)

我选择使用rpc后端和pickle序列化来提高性能,以及不在"瞬态"队列中写入任何内容(通过delivery_mode).

芹菜创业

要设置芹菜框架,我首先在64路盒子上启动rabbitmq服务器(3.2.3,Erlang R16B03-1),将日志文件写入fast/tmp磁盘.工作进程(如上所述)在群集上的每个节点(大约34个)上启动,范围从8路到64路SMP,总共688个核心.因此,我有大量可用的CPU供工作人员用于处理队列.

工作提交/表现

芹菜启动并运行后,我通过ipython笔记本提交作业,如下所示:

files = [foo, bar]
f1 = open(files[0])
f2 = open(files[1])
res = []
count = 0
for r1, r2 in izip(FastqGeneralIterator(f1), FastqGeneralIterator(f2)):
    count += 1 …

我正在修读一门关于密码学的课程,我被困在一项任务上.说明如下:

明文plain6.txt已使用DES加密加密6.dat,使用64位密钥作为8个字符的字符串给出(64位,每8位被忽略),所有字符都是字母(小写或更高 - case)和数字(0到9).

要完成分配,请在23.59年2月12日之前将加密密钥发送给我.

注意:我希望得到一个8字节(64位)的密钥.每个字节应该与我的密钥中的相应字节一致,除了在DES中没有使用的最低有效位,因此可以是任意的.

这是我在Python中第一次尝试的代码:

import time
from Crypto.Cipher import DES

class BreakDES(object):
    def __init__(self, file, passwordLength = 8, testLength = 8):
        self.file = file
        self.passwordLength = passwordLength
        self.testLength = testLength
        self.EncryptedFile = open(file + '.des')
        self.DecryptedFile = open(file + '.txt')
        self.encryptedChunk = self.EncryptedFile.read(self.testLength)
        self.decryptedChunk = self.DecryptedFile.read(self.testLength)
        self.start = time.time()
        self.counter = 0
        self.chars = range(48, 58) + range(65, 91) + range(97, 123)
        self.key = False
        self.broken = False

        self.testPasswords(passwordLength, 0, '')

        if not self.broken:
            print "Password not …

我有一组定义为2D数组的曲线(点数,坐标数).我正在使用Hausdorff距离计算它们的距离矩阵.我目前的代码如下.不幸的是,它太慢,有500-600条曲线,每条曲线有50-100个3D点.那有更快的方法吗？

def distanceBetweenCurves(C1, C2):
    D = scipy.spatial.distance.cdist(C1, C2, 'euclidean')

    #none symmetric Hausdorff distances
    H1 = np.max(np.min(D, axis=1))
    H2 = np.max(np.min(D, axis=0))

    return (H1 + H2) / 2.

def distanceMatrixOfCurves(Curves):
    numC = len(Curves)

    D = np.zeros((numC, numC))
    for i in range(0, numC-1):
        for j in range(i+1, numC):
            D[i, j] = D[j, i] = distanceBetweenCurves(Curves[i], Curves[j])

    return D

我实施了一种遗传算法来解决增强的旅行商问题(边缘的权重随着时间的推移而变化).目前我正在评估我的模拟的不同参数,我偶然发现了一个我无法向自己解释的相关性:

突变率越高,运行时间越短.就个人而言,我会假设相反,因为更高的突变率会产生更多的操作.(25%的突变率比5%快12%)

突变率为8%(5%优于10%,25%表现最差(0%除外)),效果最佳.适应值越低越好.

迭代计数由生成参数设置,在所有测试用例中设置为10.000.

每个测试用例执行10次.

我在变异中的实现(在python中)看起来像这样:

def mutate(self,p):
    for i in self.inhabitants:
        r = random()
        if r <= p:
            i.mutate()

p 是突变率

突变看起来像这样

def mutate(self):
    r1 = randint(0,self.locations.size()-1)
    r2 = randint(0,self.locations.size()-1)
    self.locations.swap(r1,r2)

为什么更高的突变率会导致更快的执行时间？

编辑:我实际上在我的Raspberry Pi上运行了相同的测试(速度慢了9倍),结果相同:

我已经创建了一个(相当大的)程序,需要很长时间才能完成,我开始研究加速程序的方法.

我发现如果我在程序运行时打开任务管理器,则只使用一个核心.

经过一些研究,我找到了这个网站: 为什么多重处理在导入numpy后只使用一个核心？这提供了一个解决方案os.system("taskset -p 0xff %d" % os.getpid()),但这对我不起作用,我的程序继续在单核上运行.

然后我发现这个: python是否能够在多个内核上运行？,指向使用多处理.

因此,在研究了多处理之后,我遇到了关于如何使用它的纪录片https://docs.python.org/3/library/multiprocessing.html#examples

我试过这段代码:

from multiprocessing import Process

def f(name):
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

a = input("Finished")

运行代码后(不是在IDLE中)它说:

Finished
hello bob
Finished

注意:说完之后我第一次按下回车

所以在此之后我现在更加困惑,我有两个问题

第一:它仍然没有多核运行(我有一个8核Intel i7)

第二:为什么在它甚至运行if语句代码之前输入"Finished"(它甚至还没有完成!)