Code iteriert nicht richtig

Question

Ich weiß, dass es auf dieser Seite viele ähnliche Probleme gibt, aber leider konnte ich meine eigene mit der vorhandenen Antwort nicht beheben .. Ich hoffe es macht Ihnen nichts aus mir zu helfen. Ich habe einen Code und versuche, Werte an eine Liste anzuhängen, während ich durch den Code iteriere. Allerdings läuft dabei etwas schief und ich habe den Wert 0. Ich bin noch nicht sehr gut im Debuggen, also kann ich das Problem nicht finden. Ich habe eine einfachere Version des Codes mit weniger Variablen unter:

`import math 
    from pylab import * 
    import numpy as np 

    #---------------------------INITIALIZATION----------------------- 

    #initializing the parameters of the model 
    Dt = 1 
    time_step = 50 

    #initializing the connection weights 
    w1 = 1 

    #initializing parameter values for the alogistic function 

    steepness_SS_a=1 

    speed_SS_a=1 

    threshold_SS_a=1 

    #--------------------THE FUNCTIONS--------------------------- 

    def initialize(): 
     global t, timesteps, WS_a, SS_a, new_WS_a, new_SS_a 
     #initialize model states 

     WS_a=1 
     SS_a=0 


     # initialize lists to update all states 

     new_SS_a=np.array([SS_a]) 


     #initializing time list 
     t=0. 
     timesteps=[t] 

    def observe(): 
     global t, timesteps, WS_a, SS_a, new_WS_a, new_SS_a 



     np.append(SS_a, new_SS_a) 


     timesteps.append(t) 

    def update(): 
     global t, timesteps, WS_a, SS_a, new_WS_a, new_SS_a 

     # for each state activation value, write how to update it in the form of new_WS(a)=function(WS(a)) 

     SS_a = SS_a + speed_SS_a * (((1/(1+math.exp(-steepness_SS_a * (w1 *   WS_a - threshold_SS_a))))-(1/(1+math.exp(steepness_SS_a *threshold_SS_a))))*  (1+math.exp(-steepness_SS_a*threshold_SS_a))-SS_a) 

     # for each state activation value now move the state value to new value 

     SS_a=new_SS_a 


     #updating the timestep 
     t = t + Dt 

    #--------------------THE PROGRAM----------------- 

    initialize() 

    while t<30.: 
     update() 
     observe() 

    #--------------------PLOTTING-------------------- 
    print SS_a 
    plot(new_SS_a) 

    show()` 

Answer 1

wie über dieses:

import math 
import numpy as np 
from pylab import plot, show 

def model(): 
    Dt = 1 
    time_step = 50 

    #initializing the connection weights 
    w1 = 1 

    #initializing parameter values for the alogistic function 
    steepness_SS_a=1 
    speed_SS_a=1 
    threshold_SS_a=1 

    #initialize model states 
    WS_a=1 
    SS_a=0 
    # initialize lists to update all states 
    new_SS_a=np.array([SS_a]) 
    #initializing time list 
    t=0.0 
    timesteps=[t]  

    while t<30.0: 
     ## update() 
     # for each state activation value, write how to update it in the form of new_WS(a)=function(WS(a)) 
     new = SS_a + speed_SS_a * (
        (
         (1/(1+math.exp(-steepness_SS_a * (w1 * WS_a - threshold_SS_a)))) 
         - 
         (1/(1+math.exp(steepness_SS_a *threshold_SS_a))) 
        ) 
        *   
        (1+math.exp(-steepness_SS_a*threshold_SS_a)) 
        - 
        SS_a 
       ) 
     new_SS_a = np.append(new_SS_a,new) 
     # for each state activation value now move the state value to new value 
     SS_a=new 
     #updating the timestep 
     t = t + Dt  

     ##observe() 
     #np.append(SS_a, new_SS_a) 
     timesteps.append(t) 

    print(SS_a) 
    print(new_SS_a) 
    print(timesteps) 
    plot(new_SS_a) 
    show()   

model() 

der Bürgermeister Änderung in SS_a = SS_a + speed_SS_a *... zunächst speichere ich diesen Wert wie new = SS_a + speed_SS_a *... dann füge ich diesen Wert zu new_SS_a mit new_SS_a = np.append(new_SS_a,new) (Sie müssen das Ergebnis davon zu fangen, sonst verlieren Sie es) und überschreiben Sie die alte in SS_a=new

Die andere Sache ist, dass ich mich gesetzt habe alle zusammen, weil die Verwendung von Globals auf diese Weise eine schlechte Übung ist, sollte global als Konstante verwendet werden und nicht geändert werden, wenn Sie es in der Basis zu einem Funktionsergebnis ändern müssen, dann diese Funktion den Wert zurückgeben und dann Nehmen Sie die Änderung an der globalen Konstante vor. Auch import * ist eine andere schlechte Praxis, weil Sie Ihren Namespace mit unnötigen Sachen verschmutzen und in einigen Fällen können diese Extras ohne Ihr Wissen andere überschreiben, die Sie brauchen, und schlimmer ist es, verwenden Sie mehrere von denen, weil das Debuggen schwieriger durch Verstecken vor es war kommen Sie jedes Zeug zwingt Sie zu zusätzlichen Lookup zu berechnen, welche Sachen zu jeder Bibliothek gehören, wenn Sie nicht wissen oder nicht erinnern, also immer explizite Importe verwenden