Nach einer Exception mit Schleife fortfahren?

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
vdv84
User
Beiträge: 19
Registriert: Montag 20. Januar 2014, 00:06

Hallo,

ich habe zu Beginn meines Python Quellcodes einige Exceptions definiert und lasse danach eine Schleife durchlaufen, die mir Daten auswerfen soll. Wenn ein Problem mit der Datenverarbeitung auftritt, erhalte ich eine Exception Nachricht und der Interpreter steigt sofort aus der Schleife aus. Ich möchte jedoch, dass der Interpreter nach einer Exception wieder zum Beginn der Schleife springt und mit einem weiteren Datensatz weitermacht.
Ich habe schon versucht hinter jeder definierten Klasse einer exception ein "continue" einzubauen, alerdings bekomme ich dann:

SyntaxError: 'continue' not properly in loop

als Fehlermeldung.
Ich habe auch schon überlegt, die exceptions ans ende der schleife zu packen und danach das continue einzufügen. Aber ich denke mir, der Interpreter muss doch schon bevor ein Fehler auftritt wissen, welche exception er auswerfen soll.

Kann mir jemand dabei behilflich sein, was der richtige Weg dabei ist?
Unten zu sehen ist als Bsp. eine Exception Definition ganz am Anfang des Codes und nach den definierten Exceptions beginnt die Schleife, die durchlaufen werden soll.

Vielen Dank und freundliche Grüße
vdv84

Code: Alles auswählen

class PyaErrTemplate(Exception):
  
  def __init__(self, what, errType, where=None, why=None, solution=None, addInfo=None):
    """
      The PyA error class template.
      
      Parameters:
       - 'what' - What has happened?
       - 'errType' - Description of the type of error.
       - 'where' - Where did it happen?
       - 'why' - Why did it happen?
       - 'solution' - string or list of strings, How can the problem be solved?
       - 'addInfo' - Whatever additional information may be available.
      
      All parameters are strings of not stated otherwise.
      Of the parameters, only the first (what) and second (errType) are mandatory; the latter
      should be provided by every more specialized exception class.
      
      .. note;: The template should never be raised directly, but specialized derived classes
		should be used.
    """
    self.what = what
    self.errorType = errType
    self.where = where
    self.why = why
    # Check whether solution is iterable
    self.solution = solution
    if solution is not None:
      if hasattr(solution, "__iter__"):
	self.solution = copy.deepcopy(solution)
      else:
	self.solution = [solution]
    self.addInfo = addInfo
   
Benutzeravatar
snafu
User
Beiträge: 6732
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

`continue` sollte aber eigentlich funktionieren. Man kann `continue` übrigens auch ganz vermeiden, indem man `try...except DeineException...else` nutzt. Im `else`-Zweig steht dann halt das, was passieren soll, wenn *keine* Exception aufgetreten ist.
BlackJack

@vdv84: Interessanter wäre der Code wo Du versuchst mit der Schleife fort zu fahren. Dir ist klar dass die Behandlung dieser Ausnahme(n) *in* der Schleife passieren müssen? Denn wenn der Kontrollfluss die Schleife erst einmal verlassen hat, dann kommst Du da nicht wieder rein.
vdv84
User
Beiträge: 19
Registriert: Montag 20. Januar 2014, 00:06

also ich habe jetzt mal versucht die exceptions in die schleife rein zu setzen und danach hab ich ein continue am ende der schleife eingesetzt (hier: Zeilen 13-17), allerdings trit jetzt immer noch dasselbe problem auf, der interpreter steigt ganz aus und springt nicht zurück zum beginn der schleife und macht nicht weiter.

hier der code am ende der schleife: (ich habe die exceptions dabei aus externen modulen importiert)

Code: Alles auswählen

  lines_of_text=("KeplerID = ", KeplerID, ", Period = ", Period, ", Inklination = ", Inklination, ", Große Halbachse in Sternradien = ", Halbachse, ", TransitT0 = ", TransitT0, ", Rp/Rs = ", RpRs, "\n")
  #fo.writelines(lines_of_text)
  ##exit()
  
  f = open("foo.py", "a")
  f.writelines(lines_of_text)
  
  #mpl.errorbar(xnorm, ynorm, yerr=yerr, fmt='bp', ms=2)
  #mpl.plot(time, y, 'rp', ms=2)
  ##mpl.hist(ynorm-y)
  #mpl.show()
  
  import pyaErrTemplate
  import pyaOtherErrors
  import warn
  import pyaValErrs
  continue
  
f.close()
EyDu
User
Beiträge: 4881
Registriert: Donnerstag 20. Juli 2006, 23:06
Wohnort: Berlin

In deinem Code ist keine Schleife.
Das Leben ist wie ein Tennisball.
vdv84
User
Beiträge: 19
Registriert: Montag 20. Januar 2014, 00:06

doch das eingerückte gehört zum ende der schleife. ich wollte jetzt nur nicht die komplette schleife hier rein posten weil die über 200 zeilen geht, ich dachte das wird vielleicht zu unübersichtlich, aber ich kann auch nochmal die komplette schleife hier rein posten.

hier sind meine exceptions in den zeilen 248 - 251 zu finden in externen modulen und darauffolgend ein continue.

Code: Alles auswählen

kepid=[11446443, 8554498, 10666592, 3861595, 10748390, 8191762]

for nobj in kepid:
  #print "ac[nobj]", ac[nobj] #anders zu readKepler_3
  nplanets = len(ac)
  print "nplanets", nplanets

  klc=ka.KeplerMultiLC(nobj)
  lcd=klc.getLCData(kid=nobj, quarter=3, slc=True, cols=["TIME", "PDCSAP_FLUX"], verbose=False)
  #anders zu readKepler_3

  print len(lcd)
  print lcd[0][:,1]

  c=kpc.getCandidateInfo(kid=nobj) #anders zu readKepler_3
  print c
  print "bjdT0", c[0]["bjdT0"]
  print "period", c[0]["period"]

  t0=c[0]["bjdT0"]
  print "t0", t0
  P=c[0]["period"]
  print "P", P
  a=c[0]["a\\rs"]
  print "a in RS", a
  b=c[0]["b"]
  print "b", b
  RS=c[0]["rs"]
  print "RS in R*", RS
  ibo=np.arccos(b/a)
  print "inc in Bogenmaß", ibo
  inc=ibo/(2*np.pi)*360.
  print "inc in Grad", inc
  p=c[0]["rp\\rs"]
  print "p=PR/SR", p
  dur=c[0]["dur"]
  print "dur in h", dur



  for i in range(len(lcd)):
    x=lcd[i][:,0]
    y=lcd[i][:,1]
    
    print "xmax, xmin", x.max(),x.min()
    ntransit=np.ceil((x[-1]-x[0])/P)
    print "ntransit", ntransit
    transit_offset=np.ceil((x.min()-t0)/P)
    print "transit_off", transit_offset
    xtransit=(np.arange(ntransit)+transit_offset)*P+t0
    xdelta=c[0]["dur"]/48. #anders zu readKepler_3 (dur in h, x in days, dur kompletter transit)
    print "xdelta", xdelta
    
    #a) 1. Weg Transits entfernen
    xwot=x
    ywot=y
    for xt in xtransit:
      ind=np.where(np.logical_and(xwot >= xt-xdelta, xwot <= xt+xdelta))[0]
      #mpl.plot(x[ind], y[ind], 'ks', markersize=3)
      xwot=np.delete(xwot,ind)
      ywot=np.delete(ywot,ind)
    print "xtransit", xtransit
    #anders zu readKepler_3
    #mpl.plot(xwot, ywot, 'ms', markersize=7)
    
    #b) 2. Weg Transits entfernen
    #xwot=x
    #ywot=y
    #for xt in xtransit:
      #ind=np.where(np.logical_or(xwot <= xt-xdelta, xwot >= xt+xdelta))[0]
      #xwot=xwot[ind]
      #ywot=ywot[ind]
    #mpl.plot(xwot, ywot, 'ms', markersize=7)
    
    #mpl.plot(x, y)
    #mpl.show()
    #continue
    #exit()
    
    #fit für inaktive Sterne
    #reg=np.polyfit(xwot, ywot, 2)
    #fit=np.polyval(reg, x)
    #fitwot=np.polyval(reg,xwot)
    #res=ywot-fitwot
    #std=np.std(res)
    #ausr=np.where(np.logical_or(res >= 3*std, res <= -3*std))[0]
    ##mpl.plot(xwot, ywot)
    ##mpl.plot(xwot[ausr], res[ausr], 'mp')
    #xwotwoa=np.delete(xwot, ausr)
    #ywotwoa=np.delete(ywot, ausr)
    #regbest=np.polyfit(xwotwoa, ywotwoa, 2)
    #fitbest=np.polyval(regbest, x)
    #mpl.plot(xwotwoa, fitbest, "r-")
    #mpl.plot(x, fit, "r-")
    #mpl.show()
      
    #fit für aktive Sterne
    #xwota=x
    #ywota=y
    indtransits=[]
    for xtact1 in xtransit:
      indtransitandcon=np.where(np.logical_and(x >= xtact1-1.5*xdelta, x <= xtact1+1.5*xdelta))[0]
      indtransits.extend(indtransitandcon)
      #xwota=np.delete(xwota, indtransitandcon)
      #ywota=np.delete(ywota, indtransitandcon)
      #xtransitandcon=np.append(x, indtransitandcon)
      #ytransitandcon=np.append(y, indtransitandcon)
      #
      #mpl.show()
    xtransitandcon=x[indtransits]
    ytransitandcon=y[indtransits]
  #mpl.plot(xtransitandcon, ytransitandcon, "b")
  #mpl.show()
  #mpl.plot(x, y)
  #mpl.show()
  #exit()
    
  xonlycon=xtransitandcon
  yonlycon=ytransitandcon
  for xtact2 in xtransit:
    indonlytran=np.where(np.logical_and(xonlycon >= xtact2-xdelta, xonlycon <= xtact2+xdelta))
    xonlycon=np.delete(xonlycon, indonlytran)
    yonlycon=np.delete(yonlycon, indonlytran)
    #regact=np.polyfit(xonlycon, yonlycon, 2)
    #fitact=np.polyval(regact, xonlycon)
    #yonlycon /= fitact
    #mpl.plot(xonlycon, yonlycon, "gp")
    #mpl.show()
  #exit()

  xnorm=xtransitandcon
  ynorm=ytransitandcon
  yerr = np.zeros(ynorm.size)

  for xtact3 in xtransit:
    contind=np.where(np.logical_and(xonlycon > xtact3-3*xdelta, xonlycon < xtact3+3*xdelta))
    if len(contind[0]) == 0: continue
    regact=np.polyfit(xonlycon[contind], yonlycon[contind], 2)

    ind=np.where(np.logical_and(xtransitandcon > xtact3-3*xdelta, xtransitandcon < xtact3+3*xdelta))  
    fitact=np.polyval(regact, xtransitandcon[ind])  
    ynorm[ind] /= fitact
    #mpl.plot(xtransitandcon, ynorm)
    #mpl.show()
    
    res=ynorm[contind]-1.0
    std=np.std(res)
    yerr[ind] += std
    
    #indau=np.where(np.logical_or(res >= 1.5*std, res <= -1.5*std))[0]
    #indnorm=np.delete(ind, indau)
    #xonlyconwoa=np.delete(xonlycon, indau)
    #yonlyconwoa=np.delete(yonlycon, indau)
    #regactwoa=np.polyfit(xonlyconwoa, yonlyconwoa, 2)
    #fitactwoa=np.polyval(regactwoa, xnorm[indnorm])
    #ynorm[indnorm] /= fitactwoa
    
  #mpl.errorbar(xnorm, ynorm, yerr=yerr, fmt='bp', ms=2)
  #mpl.show()
  #exit()


  #mpl.plot(x, y)
  #mpl.show()
  #exit()

    #ywot /= np.median(ywot)
    #for k in in range(len(x))
      #ysteig=(y[-1]-y[0])/(x[-1]-x[0])*x
      #y /= ysteig
    
    #mpl.plot(x, y)
    #for j in range(len(xtransit)): mpl.axvline(xtransit[j])
    #mpl.plot(xtransit, ytransit, color='k')
    #mpl.xlabel('time')
    #mpl.ylabel('flux')
    #mpl.title('Lichtkurve von kid=ac[0]')
    #mpl.xlim(0, 10)
    #mpl.ylim(-1.5, 2.0)
  #mpl.show()








  # ... and now the forTrans module
  from PyAstronomy.modelSuite import forTrans as ft
  # Load a simple timer for demonstration purposes
  import time as timerMod

  # Create MandelAgolLC object
  ma = ft.MandelAgolLC()

  # Set parameters
  ma["per"] = P
  #ma["i"] = 90.0
  ma["i"] = inc
  ma["a"] = a
  ma["T0"] = float(t0)
  ma["p"] = p #0.3
  ma["linLimb"] = 0.5
  ma["quadLimb"] = 0.5
  ma["b"] = 0.

  # Choose some (large) time axis
  time = xnorm
  #time = np.arange(xnorm.min(),xnorm.max(),.01)

  # ... and calculate model
  y = ma.evaluate(time)
  #y += np.random.normal(0.,.01,time.size)
  #yerr=np.ones(time.size)*.01

  # Let's see what happened ...
  #mpl.errorbar(time, y, yerr=yerr, fmt='kp', markersize=2)
  #mpl.show()

  ma.thaw(["per","T0","linLimb","quadLimb","a","i","p"])
  ma.fit(time,ynorm,yerr=yerr, maxiter=1e4, maxfun=1e4, xtol=1e-8, ftol=1e-8)
  ma.parameterSummary()
  fit=ma.evaluate(time)

  #fo = open("foo.txt", "a")
  KeplerID = str(nobj)
  #print "KeplerID", KeplerID
  #print "ma.parameterSummary(per)", ma["per"]
  Period = str(ma["per"])
  #print "Period", Period
  Inklination = str(ma["i"])
  Halbachse = str(ma["a"])
  TransitT0 = str(ma["T0"])
  RpRs = str(ma["p"])
  lines_of_text=("KeplerID = ", KeplerID, ", Period = ", Period, ", Inklination = ", Inklination, ", Große Halbachse in Sternradien = ", Halbachse, ", TransitT0 = ", TransitT0, ", Rp/Rs = ", RpRs, "\n")
  #fo.writelines(lines_of_text)
  ##exit()
  
  f = open("foo.py", "a")
  f.writelines(lines_of_text)
  
  #mpl.errorbar(xnorm, ynorm, yerr=yerr, fmt='bp', ms=2)
  #mpl.plot(time, y, 'rp', ms=2)
  ##mpl.hist(ynorm-y)
  #mpl.show()
  
  import pyaErrTemplate
  import pyaOtherErrors
  import warn
  import pyaValErrs
  continue
  
f.close()
Benutzeravatar
snafu
User
Beiträge: 6732
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Aha. Eine Schleife, die über 250 Zeilen geht, in jedem Schleifendurchlauf zig Importe macht und ein völlig sinnfreies `continue` am Ende eines Durchlaufs drinstehen hat. Ich hab ja schon viel Anfängercode gesehen, aber das ist echt mein persönliches Highlight. Respekt...!
zar1
User
Beiträge: 39
Registriert: Samstag 28. Dezember 2013, 01:08

kannst du nicht einfach in die except schleife PASS reinschreiben ?
BlackJack

@vdv84: Du hast Ausnahmen nicht verstanden würde ich mal sagen. Ob die Definition einer Ausnahme in der Schleife steht ist Wurst. Das tut sie hier übrigens auch nicht denn dort importierst Du nur die Module die dann wohl die definierten Ausnahmen enthalten. Du musst auftretende Ausnahmen in der Schleife *behandeln*, also der Code bei dem sie Auftreten können muss in einem ``try``-Block stehen.

Du müsstest übrigens auch keine 200-Zeilen lange Schleifenkörper zeigen wenn Du endlich mal anfangen würdest das sinnvoll auf Funktionen aufzuteilen. :roll:

@zar1: So etwas wie eine ``except``-Schleife gibt es nicht. Im gezeigten Quelltext ja nicht einmal einen ``try``-Block.
Benutzeravatar
/me
User
Beiträge: 3554
Registriert: Donnerstag 25. Juni 2009, 14:40
Wohnort: Bonn

vdv84 hat geschrieben:doch das eingerückte gehört zum ende der schleife. ich wollte jetzt nur nicht die komplette schleife hier rein posten weil die über 200 zeilen geht, ich dachte das wird vielleicht zu unübersichtlich, aber ich kann auch nochmal die komplette schleife hier rein posten.
Es ist schön, das mal gesehen zu haben. Jetzt kann man dir unabhängig von deinem aktuellen Problem noch einen weiteren Tipp geben: Strukturiere deinen Code. Teile ihn in sinnvolle Funktionen auf. Lies und beherzige den PEP-8 (Style Guide for Python Code). Dringend!
jqz4n
User
Beiträge: 21
Registriert: Sonntag 2. Februar 2014, 19:26

Zusäätzlich zu dem bisher Geschriebenen wäre deine Schleife erheblich kürzer, wenn du vor dem Posten den auskommentierten Code zwischen Zeile 63 und 99 sowie zwischen Zeile 150 und 188 entfernt hättest. (nämlich nur noch ca. 175 Zeilen)
Antworten