Skip to main content
 首页 » 编程设计

python之将一个类的属性设置一次固定以避免繁琐的计算

2025年05月04日7三少

我有两个类,即 PositionsD 和 makemock,它们的定义如下:

import numpy as np 
cdef class PositionsD(object): 
 
     property x: 
         def __get__(self): 
             return np.array(self._x) 
         def __set__(self,  x): 
             self._x = x 
 
     property y: 
         def __get__(self): 
             return np.array(self._y) 
         def __set__(self, y): 
             self._y = y 
 def __init__(self, positions): 
     self._x = positions[:,0] 
     self._y = positions[:,1] 
 
class makemock(object): 
    def __init__(self): 
        self.scale = 0.238 
        self.arcsec2rad = np.pi/180./60./60. 
        self.g1 = None 
        self.g2 = None 
        self.source_pos = None 
        self.z = None 
        self.h_pos = None 
        self.h_z = None 
 
    def get_pos(self):  
        return PositionsD(self.source_pos) 
    pos = property(get_shear_pos) 
 
    def get_center(self):  
        return PositionsD(self.h_pos) 
    center = property(get_center) 
 
    def get_dist(self): 
        dx_mpc = (self.pos.x-self.center.x)*self.arcsec2rad*self.scale 
        dy_mpc = (self.pos.y-self.center.y)*self.arcsec2rad*self.scale  
        return np.vectorize(complex)(dx_mpc, dy_mpc)   
    dist = property(get_dist) 
 
    def get_r(self): 
        return abs(self.dist)   
    r = property(get_r) 
 
    def get_norm(self): 
        return -self.dist/np.conjugate(self.dist) 
    norm = property(get_norm)   
 
 
    def get_gabs(self): 
        return np.sqrt(self.g1**2 + self.g2**2 ) 
    gabs = property(get_gabs) 
 
    def get_g(self): 
        phiell=np.arctan2(self.g2, self.g1) /2. 
        phipos=np.arctan2( (self.pos.y-self.center.y), (self.pos.x-self.center.x) ) 
        et = -self.gabs * np.cos( 2*(phiell-phipos) ) 
        ec = -self.gabs * np.sin( 2*(phiell-phipos) ) 
        return np.vectorize(complex)(et, ec)  
    obs_g = property(get_g) 
 
    def data2model(self,params): 
        rs = params 
        x  = self.r/rs 
        P  = len(self.r) 
        gamma  = np.zeros((P,), dtype=np.float64, order='C') 
        kappa  = np.zeros((P,), dtype=np.float64, order='C') 
        farcth = np.zeros((P,), dtype=np.float64, order='C') 
 
        m1 = np.where(x < 1.0)[0] 
        kappa[m1] = 2/(x[m1]**2 - 1) * \ 
             (1 - np.log((1 + ((1 - x[m1])/(x[m1] + 1))**0.5)/(1 - ((1 - x[m1])/(x[m1] + 1))**0.5))/(1 - x[m1]**2)**0.5) 
 
        farcth[m1]=0.5*np.log((1.+((1.-x[m1])/(x[m1]+1.))**0.5)/(1.-((1.-x[m1])/(x[m1]+1.))**0.5))/(1-x[m1]**2)**0.5 
 
        gamma[m1] = 4*(np.log(x[m1]/2) + 2*farcth[m1]) * x[m1]**(-2) - kappa[m1] 
        model_g = self.norm* gamma /(1. - kappa ) 
        e = (self.obs_g+model_g)/(1+np.conjugate(model_g)*self.obs_g) 
        mask=(abs(model_g)>1.) 
        if (np.sum(mask)>0): 
        e[mask]=1./np.conjugate(e[mask]) 
        return e 

我的问题是:

我需要在一个循环中为 params 的不同值运行 makemock 中的 data2model 方法。我认为这个过程很慢,而它似乎每次都在类的循环属性中计算,例如 r、dist、obs_g每次迭代。有什么方法可以设置一次,以提高循环速度?

请您参考如下方法:

在尝试找到一种在开始时初始化一些实例并避免在每个函数的每次迭代中计算它们的方法后,我发现最好使用 dict 并保留值这个字典中的每个实例,并在实例初始化结束时更新它们。这是我的解决方案:

class makemock(object): 
    def __init__(self, g1, g2, source_pos, z, h_pos, h_z, **kw): 
        self.scale = 0.238 
        self.arcsec2rad = np.pi/180./60./60. 
        self.g1 = g1 
        self.g2 = g2 
        self.source_pos = source_pos 
        self.z = z 
        self.h_pos = h_pos 
        self.h_z = h_z 
        pos= PositionsD(self.source_pos) 
        center=PositionsD(self.h_pos) 
        dx_mpc = (pos.x-center.x)*self.arcsec2rad*self.scale 
        dy_mpc = (pos.y-center.y)*self.arcsec2rad*self.scale  
        dist= np.vectorize(complex)(dx_mpc, dy_mpc)   
        r= abs(dist)   
        norm= -dist/np.conjugate(dist) 
        gabs= np.sqrt(self.g1**2 + self.g2**2 ) 
 
        phiell=np.arctan2(self.g2, self.g1) /2. 
        phipos=np.arctan2( (pos.y-center.y), (pos.x-center.x) ) 
        et = -gabs * np.cos( 2*(phiell-phipos) ) 
        ec = -gabs * np.sin( 2*(phiell-phipos) ) 
        obs_g=np.vectorize(complex)(et, ec)  
        self.__dict__.update(kw) 
        del kw 
        self.__dict__.update(locals())  
        del self.self 
    def dump(self): 
        print repr(self.__dict__) 
 
 
    def data2model(self,params): 
        rs = params 
        x  = self.r/rs 
        P  = len(self.r) 
        gamma  = np.zeros((P,), dtype=np.float64, order='C') 
        kappa  = np.zeros((P,), dtype=np.float64, order='C') 
        farcth = np.zeros((P,), dtype=np.float64, order='C') 
 
        m1 = np.where(x < 1.0)[0] 
        kappa[m1] = 2/(x[m1]**2 - 1) * \ 
             (1 - np.log((1 + ((1 - x[m1])/(x[m1] + 1))**0.5)/(1 - ((1 - x[m1])/(x[m1] + 1))**0.5))/(1 - x[m1]**2)**0.5) 
 
        farcth[m1]=0.5*np.log((1.+((1.-x[m1])/(x[m1]+1.))**0.5)/(1.-((1.-x[m1])/(x[m1]+1.))**0.5))/(1-x[m1]**2)**0.5 
 
        gamma[m1] = 4*(np.log(x[m1]/2) + 2*farcth[m1]) * x[m1]**(-2) - kappa[m1] 
        model_g = self.norm* gamma /(1. - kappa ) 
        e = (self.obs_g+model_g)/(1+np.conjugate(model_g)*self.obs_g) 
        mask=(abs(model_g)>1.) 
        if (np.sum(mask)>0): 
        e[mask]=1./np.conjugate(e[mask]) 
        return e