Das deutsche Python-Forum

Hallo Leute,
ich habe ein Programm geschrieben aber geht s immer Problem.
Könnte jemand mir helfen und genau zeigen, wo das Problem liegt ?

Vielen Dank
Grüss

das Ziel:

Ziel dieser Aufgabe ist es Threads in Python zu realisieren. Programmieren Sie dazu eine Klasse
MyThread, welche von der Klasse Thread abgeleitet werden soll.
Bei der Instanziierung übergeben Sie ihrem Thread die folgenden Parameter: Seinen Namen, die
Anzahl der Iterationen, die er durchlaufen soll, und die Länge der Pause, die zwischen den Iterationen
liegen soll (in Minuten). Der Thread soll bei jedem Schleifendurchlauf seinen Namen, den Index
der aktuellen Iteration ausgeben sowie die aktuelle Uhrzeit (z.B. Thread_1: 2 von 5,
10:55:15). Danach soll der Thread die angegebene Zeit pausieren, bevor er den nächsten Schleifendurchlauf
startet.
Demonstrieren Sie die Funktion Ihres Threads mit den folgenden Aufrufen:
thread1 = MyThread(“MyThread_1“,4,0.2)
thread2 = MyThread(“MyThread_2“,5,0.3)
thread3 = MyThread(“MyThread_3“,2,0.4)
thread4 = MyThread(“MyThread_4“,2,0.5)
thread1.start()
thread2.start()
thread3.start()
thread4.start()
Wie könnten Sie die Threads testen und welche Probleme (Nebenwirkungen) können dabei auftreten?
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------

mein programm
---------------------

Code: Alles auswählen

import threading
import time

class MyThread( threading.Thread ):
    
        def __init__(self, message, anzahl, sleep):
                                
                self.message = message  # thread id
                self.anzahl = anzahl  # Anzahl der Iterationen
                self.sleep = sleep  # Länge der Pause
                
                threading.Thread.__init__(self)
                
                
        def run(self):
                        

                for i in range(1, self.anzahl+1):
                        time_str = time.strftime(" %H:%M:%S", time.localtime())
                        print self.message, ":", i, " von ", self.anzahl," ", time_str
                        
                        
                        time.sleep(self.sleep*60.0)

       
                        
                        


thread1 = MyThread("MyThread_1", 4, 0.2)
thread2 = MyThread("MyThread_2", 5, 0.3)
thread3 = MyThread("MyThread_3", 2, 0.4)
thread4 = MyThread("MyThread_4", 2, 0.5)

thread1.start()
thread2.start()
thread3.start()
thread4.start()

Hallo bing4229!

Also mal wieder eine Schulaufgabe... aber du bist ja schon fleißig gewesen und stellst deine Fragen vernuenftig. Das ist gut... vielleicht nehmen sich andere mal ein Beispiel daran ^^

Nun zu deinem Problem:

Hast du dir die Einrueckung schonmal bedacht?
Weißt du wie ein PythonProgramm aufgebaut sein sollte?
Und ganz wichtig: Weißt du, dass es hier Code-Tags gibt? Du solltest sie nutzen...

hallo, danke schön für Antwort

ich habe keine Ahnung wie
man ein Programm schreiben sollte.

Ich suche mal jetzt , was Einrückung ist.

bing4229 hat geschrieben:Ich suche mal jetzt , was Einrückung ist.

Einrückung:

Code: Alles auswählen

def foo():
    print "bar"

Keine Einrückung:

Code: Alles auswählen

def foo():
print "bar"

Edit: Die ist bei Python übrigens zwingend: Ohne bzw. mit falscher Einrückung gibts Fehler.

Gruß, Phillip

Danke schön.
Aber ich finde meine Einrückung ist nicht falsch...

Hi, ich habe mal kleinigkeiten angepasst.

Code: Alles auswählen

import threading
import time

class MyThread(threading.Thread):
    def __init__(self,name,iterations,sleeptime):
        self.name = name
        self.iterations = iterations
        self.sleeptime = sleeptime
        threading.Thread.__init__(self)
    def run(self):
        for i in range(0,self.iterations):
            if i > 0:
                time.sleep(float(self.sleeptime)*60.0)
            print self.name+":",\
                  "Index:",i,\
                  "(Iteration",str(i+1),"of",str(self.iterations)+")",\
                  time.strftime("%H:%M:%S",time.localtime())
        print self.name+":","finished"

def main():
    thread1 = MyThread("MyThread_1", 4, 0.2)
    thread1.start()
    thread2 = MyThread("MyThread_2", 5, 0.3)
    thread2.start()
    thread3 = MyThread("MyThread_3", 2, 0.4)
    thread3.start()
    thread4 = MyThread("MyThread_4", 2, 0.5)
    thread4.start()

if __name__ == "__main__":
    main()

Ich würde allerdings noch überlegen hier mit einem Lock zu arbeiten, damit die Ausgaben sich nicht zufällig "vermischen"

vielen danke,

bei mir hat es wie folgendes gezeigt..

Code: Alles auswählen

MyThread_1: Index: 0 (Iteration 1 of 4)MyThread_2: Index: 
    self.text.insert("end-1c", "\n")
  File "C:\Python25\lib\idlelib\Percolator.py", line 25, in insert
    self.top.insert(index, chars, tags)
  File "C:\Python25\lib\idlelib\PyShell.py", line 315, in insert
    UndoDelegator.insert(self, index, chars, tags)
  File "C:\Python25\lib\idlelib\UndoDelegator.py", line 81, in insert
    self.addcmd(InsertCommand(index, chars, tags))
  File "C:\Python25\lib\idlelib\UndoDelegator.py", line 116, in addcmd
    cmd.do(self.delegate)
  File "C:\Python25\lib\idlelib\UndoDelegator.py", line 216, in do
    if text.compare(self.index1, ">", "end-1c"):
  File "C:\Python25\lib\lib-tk\Tkinter.py", line 2846, in compare
    self._w, 'compare', index1, op, index2))
TclError: expected boolean value but got ""

Versuch's mal ohne IDLE.

wow..
super, funtioniert gut, jetzt

vielen vielen dank euch

bing4229 hat geschrieben:Danke schön.
Aber ich finde meine Einrückung ist nicht falsch...

Solltest du aber, denn in Python ist die Einrueckung essenziell.

Man muss Bloecke gleichmaessig einruecken. Ein Block ist ein zusammengehoeriger CodeTeil. Und damit man weiß, wann dieser Teil zuEnde ist, gibts verschiedene Methoden.

In Ruby beginnt der Block mit dem entsprechenden Keyword endet mit einem End:

Code: Alles auswählen

def passe_liste_an(liste)
    liste.reverse
    liste.flatten.uniq
    return liste
end

In Pascal zB waere da Begin und End:

Code: Alles auswählen

program HelloWorld(output);
begin
    writeln('Hello, World!')
end.

In sehr vielen Sprachen sind es auch Klammern...
C/C++:

Code: Alles auswählen

function main() {
    printf("Hallo Welt");
}

Java:

Code: Alles auswählen

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Lisp:

Code: Alles auswählen

(if nil
   (list 1 2 "foo")
   (list 3 4 "bar"))

...und so weiter.

In Python ist es die Einrueckung die den Block bestimmt. Das ist intuitiv und sorgt auch gleich fuer einen sauberen Schreibstil:

Code: Alles auswählen

def a_function():
    print "hello world"
    print "I'm comming"
    print "And this is the End!"
    return True

# hier ist die Funktion zuEnde...
a_function()

Wenn du also in Python alles einfach uneingerueckt schreibst, weiß der Python-Interpreter doch garnicht was er welchem Block zuordnen soll!
Siehst du die Misere und das Problem mit deiner Einrueckung?

Gruß
nkoehring

Hallo Nkoehring,

ich habe Dich nicht ganz verstanden. Ich finde nur, das Programm von
"Frank aka Ch3ck3r" sieht viel schöner und logischer als meines.

Meinem Programm fehlt etwas drin, aber was (?) ,ich ...bin ...nicht ..so ..klar

ich gucke das morgen noch mal an und will ain Zukunft uf Einrückung achten.

Vielen Dank für Tipps

Gruss
Bing

BlackJack hat geschrieben:Versuch's mal ohne IDLE.

Und da ist es wieder

Hier nocheinmal die Variante mit einem Lock, die ich besser finde, da durch das Lock ein (rein theoretisch möglicher) "Mischmasch" der Ausgaben verhindert wird.

Code: Alles auswählen

import threading
import time

class MyThread(threading.Thread):
    def __init__(self,name,iterations,sleeptime,MyLock):
        self.name = name
        self.iterations = iterations
        self.sleeptime = sleeptime
        self.MyLock = MyLock
        threading.Thread.__init__(self)
    def run(self):
        i = 0
        while i < self.iterations:
            wait = False
            self.MyLock.acquire()
            print self.name+":",\
                  "Index:",i,\
                  "(Iteration",str(i+1),"of",str(self.iterations)+")",\
                  time.strftime("%H:%M:%S",time.localtime())
            if i == self.iterations-1:
                print self.name+":","finished"
            else:
                wait = True
            i = i+1
            self.MyLock.release()
            if wait:
                time.sleep(float(self.sleeptime)*60.0)

def main():
    MyLock = threading.Lock()
    MyThread("MyThread_1", 2, 0.2,MyLock).start()
    MyThread("MyThread_2", 4, 0.1,MyLock).start()
    MyThread("MyThread_3", 3, 0.15,MyLock).start()
    
if __name__ == "__main__":
    main()

Frank aka Ch3ck3r hat geschrieben:Hier nocheinmal die Variante mit einem Lock, die ich besser finde, da durch das Lock ein (rein theoretisch möglicher) "Mischmasch" der Ausgaben verhindert wird.

[...]

Ich find es wirklich nett von dir, dass du so gut hilfst, aber ich glaube der Threadstarter braucht erstmal essenzielle Grundlagen von Python. Was er von dir bekommt, ist eine fertige Loesung, die er weder verstehen kann (nicht boese gemeint, aber wenn man nichtmal weiß, dass man in Python Codebloecke einzuruecken hat?) noch zum lernen nutzen!

Das deutsche Python-Forum

bitte Helf suchen

bitte Helf suchen