[Python] Passare perametri a/tra classi

[M@T]

> A chi ha postato la domanda inizialmente: ignora questo link. Oppure, se
> lo leggi, salta direttamente alle conclusioni (dove dice *come* si usa
> super, evidentemente dopo che gli hanno corretto tutte le cappellate che ha
> scritto prima).
Ciao
Rieccomi.
Scusate se non ho risposto prima ma stavo cercando di arrangiarmi (anche 
leggendo l'articolo sopra), ma ho ancora qualche problema...

Ho modificato il codice così:
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
class Cwt(object):
     fourierwl=1.00

     def _log2(self, x):
         return int( NP.log(float(x))/ NP.log(2.0)+0.0001 )

     def __init__(self, data, largestscale=1, notes=0, order=2, 
scaling='linear',omega0=5):
     super(Morlet, self).__init__(data, largestscale=1, notes=0, 
order=2, scaling='linear')
     self._omega0 = omega0
         ndata = len(data)

         self.order=order
         self.scale=largestscale
         self._setscales(ndata,largestscale,notes,scaling)
         self.cwt= NP.zeros((self.nscale,ndata), NP.complex64)
         omega= 
NP.array(range(0,ndata/2)+range(-ndata/2,0))*(2.0*NP.pi/ndata)
         datahat=NP.fft.fft(data)
         self.fftdata=datahat
         for scaleindex in range(self.nscale):
             currentscale=self.scales[scaleindex]
             self.currentscale=currentscale  # for internal use
             s_omega = omega*currentscale
             psihat=self.wf(s_omega)
             psihat = psihat *  NP.sqrt(2.0*NP.pi*currentscale)
             convhat = psihat * datahat
             W    = NP.fft.ifft(convhat)
             self.cwt[scaleindex,0:ndata] = W
         return

     def _setscales(self,ndata,largestscale,notes,scaling):
         if scaling=="log":
             if notes<=0: notes=1
             # adjust nscale so smallest scale is 2
             noctave=self._log2( ndata/largestscale/2 )
             self.nscale=notes*noctave
             self.scales=NP.zeros(self.nscale,float)
             for j in range(self.nscale):
                 self.scales[j] = 
ndata/(self.scale*(2.0**(float(self.nscale-1-j)/notes)))
         elif scaling=="linear":
             nmax=ndata/largestscale/2
             self.scales=NP.arange(float(2),float(nmax))
             self.nscale=len(self.scales)
         else: raise ValueError, "scaling must be linear or log"
         return

     def getdata(self):
         return self.cwt
     def getcoefficients(self):
         return self.cwt
     def getpower(self):
         return (self.cwt* NP.conjugate(self.cwt)).real
     def getscales(self):
         return self.scales
     def getnscale(self):
         return self.nscale
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
# wavelet classes
class Morlet(Cwt):
     _omega0=0.001 ##5.0
     fourierwl=4* NP.pi/(_omega0+ NP.sqrt(2.0+_omega0**2))
     def wf(self, s_omega):
         H=(s_omega>0)*1.
     xhat=0.75112554*( NP.exp(-(s_omega-self._omega0)**2/2.0))*H
         return xhat

"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
Se lo richiamo con

cw=Morlet(A,maxscale,notes,scaling=scaling,omega0=5)

Mi da errore:
super(Morlet, self).__init__(data, largestscale=1, notes=0, order=2, 
scaling='linear')
RuntimeError: maximum recursion depth exceeded while calling a Python object

Spero di non spazientirvi troppo.
Ho provato l'esempio dell'articolo ma non mi funziona... quindi non 
riesco a fare prove accurate.
Lo scopo (penso si sia capito) è di attribuire un determinato valore a 
_omega0 nella classe Morlet
Quindi non dovrebbe essere così il comando super??

     def __init__(self, data, largestscale=1, notes=0, order=2, 
scaling='linear',omega0=5):
     super(Morlet, self).__init__(omega0=5)
     self._omega0 = omega0

Idee?
Scusate l'ingnoranza ma sto cercando di imparare
Grazie a tutti per le risposte
Ciao
Matteo