将函数参数间隔拆分为单独部分时出错。并行Python

Question

首先，对不起所有的代码。我很难想出一个具体的问题。我已经修补了一段时间，就是不能让它发挥作用。错误信息没有什么帮助。我非常感谢你的帮助。在

我想为不同的参数范围并行执行函数“ematcheatorrx（umin，umax，vmin，vmax，stepsize，pstep，alphamax，A，rot）：”的三个实例，以加快计算速度。在

umin、umax和vmin、vmax都定义了在u和v方向分别计算的值范围。我想把这个函数分成三个更小的范围。在

我已经通过运行以下代码演示了将函数拼接为三个独立部分然后重新连接的代码可以正确工作：

import pp
import sys

import numpy as N
import scipy as sp
from scipy import integrate as Int
from scipy import special as S
import math

cos=sp.cos
sin=sp.sin
exp=sp.exp
sqrt=sp.sqrt
j=S.jn
pi=N.pi
floor=N.floor

def EMatCreatorrx(umin,umax,vmin,vmax,stepsize,pstep,alphamax,A,rot): #pstep needs to be pi/n for n=0,1,2,3,... This is so there will be an odd number of samples when calculating the PSF. This is necessary to increase the accuracy of Simpson's method.   
    mnum=N.int(((umax-umin)/stepsize)+1)
    nnum=N.int(((vmax-vmin)/stepsize)+1)
    pnum=N.int((2*pi/pstep)+1)
    gridshape=(mnum,nnum,pnum)
    I0=N.zeros(gridshape,dtype=complex)
    I1=N.zeros(gridshape,dtype=complex)
    I2=N.zeros(gridshape,dtype=complex)
    E01=N.zeros(gridshape,dtype=complex) 
    E02=N.zeros(gridshape,dtype=complex) 
    E03=N.zeros(gridshape,dtype=complex)
    for m,u in enumerate(N.linspace(umin,umax,num=mnum)):
        for n,v in enumerate(N.linspace(vmin,vmax,num=nnum)):
            for i,p in enumerate(N.linspace(0,2*pi,num=pnum)):             
                vp = sqrt((v*cos(p))**2 + (v*sin(p)*cos(rot)-u*sin(rot))**2)
                up = (v*cos(p)*sin(rot) + u*cos(rot))
                pp= N.arctan2(v*sin(p)*cos(rot) - u*sin(rot), v*cos(p))  
                I0real=lambda theta: N.real((sqrt(cos(theta))*sin(theta))*(1+cos(theta))*  (j(0,vp*sin(theta)/sin(alphamax)))*exp((1j*up*cos(theta))/((sin(alphamax))**2)))
                I0imaginary=lambda theta: N.imag((sqrt(cos(theta))*sin(theta))*(1+cos(theta))*(j(0,vp*sin(theta)/sin(alphamax)))*exp((1j*up*cos(theta))/((sin(alphamax))**2)))
                I0real_integral= Int.quad(I0real, 0, alphamax)
                I0imag_integral= Int.quad(I0imaginary, 0, alphamax)
                I1real=lambda theta: N.real(sqrt(cos(theta))*((sin(theta))**2)*j(1,vp*sin(theta)/(sin(alphamax)))*exp((1j*up*cos(theta))/((sin(alphamax))**2)))
                I1imaginary=lambda theta: N.imag(sqrt(cos(theta))*((sin(theta))**2)*j(1,vp*sin(theta)/(sin(alphamax)))*exp((1j*up*cos(theta))/((sin(alphamax))**2)))
                I1real_integral= Int.quad(I1real, 0, alphamax)
                I1imag_integral= Int.quad(I1imaginary, 0, alphamax)
                I2real=lambda theta: N.real((sqrt(cos(theta))*sin(theta))*(1-cos(theta))*(j(2,vp*sin(theta)/sin(alphamax)))*exp((1j*up*cos(theta))/((sin(alphamax))**2)))
                I2imaginary=lambda theta: N.imag((sqrt(cos(theta))*sin(theta))*(1-cos(theta))*(j(2,vp*sin(theta)/sin(alphamax)))*exp((1j*up*cos(theta))/((sin(alphamax))**2)))   
                I2real_integral= Int.quad(I2real, 0, alphamax)
                I2imag_integral= Int.quad(I2imaginary, 0, alphamax)
                I0.real[m,n,i]=I0real_integral[0]
                I0.imag[m,n,i]=I0imag_integral[0]
                I1.real[m,n,i]=I1real_integral[0]
                I1.imag[m,n,i]=I1imag_integral[0]
                I2.real[m,n,i]=I2real_integral[0]
                I2.imag[m,n,i]=I2imag_integral[0]
                E01[m,n,i]=-A*(1j*(I0[m,n,i]+I2[m,n,i]*cos(2*pp)))
                E02[m,n,i]=-A*(cos(rot)*1j*I2[m,n,i]*sin(2*pp) - sin(rot)*2*I1[m,n,i]*cos(pp))
                E03[m,n,i]=-A*(sin(rot)*1j*I2[m,n,i]*sin(2*pp) + cos(rot)*2*I1[m,n,i]*cos(pp))
    return E01,E02,E03,pstep


#EMatCreatorrx(umin,umax,vmin,vmax,stepsize,pstep,alphamax,A,rot): #Enter parameters below in tuple "params."

params=-2,2,-2,2,.2,N.pi/10,1,1,0
##############################################################################################################

mnum=N.int(((params[1]-params[0])/params[4])+1)
nnum=N.int(((params[3]-params[2])/params[4])+1)
pnum=N.int((2*N.pi/params[5])+1)
phold=N.zeros((mnum,nnum,pnum), dtype=complex),N.zeros((mnum,nnum,pnum), dtype=complex),N.zeros((mnum,nnum,pnum), dtype=complex), params[5]

uindarr = [(m, u) for m,u in enumerate(N.linspace(params[0],params[1],num=mnum))]

ind_end1=floor(len(uindarr)/3)
spa_end1=uindarr[int(ind_end1)][1]

ind_beg2=ind_end1+1
spa_beg2=uindarr[int(ind_beg2)][1]
ind_end2=2*floor(len(uindarr)/3)
spa_end2=uindarr[int(ind_end2)][1]

ind_beg3=ind_end2+1
spa_beg3=uindarr[int(ind_beg3)][1]

job1 = EMatCreatorrx(params[0],spa_end1,params[2],params[3],params[4],params[5],params[6],params[7],params[8]) 
job2 = EMatCreatorrx(spa_beg2,spa_end2,params[2],params[3],params[4],params[5],params[6],params[7],params[8])
job3 = EMatCreatorrx(spa_beg3,params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8])

phold[0][:ind_end1+1,:,:]=job1[0]
phold[0][ind_beg2:ind_end2+1,:,:]=job2[0]
phold[0][ind_beg3:,:,:]=job3[0]

phold[1][:ind_end1+1,:,:]=job1[1]
phold[1][ind_beg2:ind_end2+1,:,:]=job2[1]
phold[1][ind_beg3:,:,:]=job3[1]

phold[2][:ind_end1+1,:,:]=job1[2]
phold[2][ind_beg2:ind_end2+1,:,:]=job2[2]
phold[2][ind_beg3:,:,:]=job3[2]

工作完成后，我尝试实现并行python，以便使用以下代码并行计算三个切片：

^{pr2}$

当我尝试运行上面的代码时，我得到以下文件结尾错误：

^{3}$

在这一点上，我有点迷茫。你们中有人以前遇到过这个错误吗？如果是，问题是什么？非常感谢您的任何意见。谢谢！在

Answer 1

我在使用并行Python时也遇到了这个问题，这也是由于一个标记化错误造成的。在我的例子中，我的一个helper函数有两个缩进（8个空格，由于复制粘贴现象，而函数声明在正确的缩进级别为零个空格）-Spyder的主解释器只处理了这个问题，但tokenize显然没有处理。在

在OP的例子中：根据上面代码的格式，以及这里tokenize顶部的注释，错误很可能是因为空行上没有空格；这将返回“”，注释说它被当作EOF处理。在