Das deutsche Python-Forum

Hallo Zusammen,

ich bin sehr sehr neu hier und auch was Python angeht. Daher eine ziemlich dämliche Frage.

Ich schreibe jetzt, einfach zu Übungszwecken, ein größeres Programm für mich. Mir fällt auf dass es unmengen an Text wird. Speichert man das wirklich alles in einer Datei?

Es sind jetzt erst 309 Zeilen, aber ohne Kommentare wäre es schon ein Highlight. Wenn ich ans Ende denke müsste ich bei ~ 5000 >Zeilen liegen. Ist das normal?

Grüße

@Gismo1337: Das kommt unter anderem darauf an wie diese Zeilen aussehen. Anfänger oder Leute die von anderen Sprachen kommen schreiben beispielsweise manchmal Sachen *deutlich* zu kompliziert die man in „pythonisch“ in weniger Code schreiben könnte.

Ansonsten denke ich das 310 Zeilen für ein Modul noch nicht übermässig viel ist. 5K Zeilen wären das dann schon. Da würde man ein Package erstellen und sich eine sinnvolle Aufteilung auf Module überlegen.

So lange ich aber damit zurecht komme, spricht nichts dagegen?
Könnte also auch 100.000 Zeilen lang sein?

@Gismo1337: Das wäre ein bisschen zu lang. Wahrscheinlich auch technisch, ich kann mich dunkel daran erinnern das da mal jemand mit generiertem Quelltext an die maximale Bytecodegrösse bei CPython gestossen ist. Das waren glaube ich 64 Kilobyte weil Sprungoffsets in 16 Bit kodiert werden.

Die Frage ist ja nicht nur womit Du klar kommst, sondern andere Leser. Und eventuell auch Editoren. Und Browser.

@Gismo1337:
Für langen Spaghetticode hilft Zerschnippeln und wieder Zusammensetzen mit *include* weiter. Das kannst Du entweder per C-Prepräzessor machen, oder mit Python-Boardmitteln:

Code: Alles auswählen

def include(filename):
    pyc = compile(open(filename).read(), '<string>', 'exec')
    frame = globals()
    exec(pyc, frame)

Dann noch die Spaghettis verteilen auf verschiedene Dateien:

Code: Alles auswählen

a = 'a'
b = 1
print('huhu in 1.py')

# let the spaghetti grow
# ...

Code: Alles auswählen

from include import include

include('1.py')

# here comes even more noodles with refs to 1.py
print('in 2.py yeah')
print a
print b

Das ist viel besser als der Quatsch mit dem import, das zwingt nur zur strukturierten Programmierung und nimmt zu viele Freiheiten.

(Achtung Beitrag ist nicht ganz ernst gemeint)

NB: Ach ja, und das `from include import include` muss ich noch irgendwie loswerden, *kopfkratz*

Oh ja, das sieht nach dem Gedanken aus, den ich hatte. Verstehe ich das richtig:

Ich muss lediglich in der "Hauptdatei" folgendes einfügen:

Code: Alles auswählen

from include import include

# irgendwo im oberen teil:
def include(filename):
    pyc = compile(open(filename).read(), '<string>', 'exec')
    frame = globals()
    exec(pyc, frame)
    
# irgendwo im unteren teil: 
include('1.py')
include('2.py')
include('3.py')
# etc.

und habe ohne Weiteres genau an der Stelle die jeweilige Datei bzw beinhalteten code eingefügt?
Muss der Code aus z.B. 2.py ohne den Hauptteil lauffähig sein oder reicht es wenn er seine "Lebensnotwenigen Befehle" dann erst beim Include bekommt?

@Gismo1337:
Umm nein, bitte nicht benutzen. Mein Beitrag war ironisch gemeint. Python hat aus gutem Grund kein "ich klatsch alles in den globalen Namensraum an der Stelle des Aufrufs"-include ala PHP. Für Python und eigentlich generell gilt - strukturiere nach Zuständigkeit/Funktionalität, angefangen bei Funktionen, ggf. Klassen, dann Module (das sind separate .py Dateien, welche Du mit `import` laden kannst). Python hat ein ziemlich ausgebufftes Packaging-System, da sollte auch für Dich was dabei sein.

@jerch schoener Beleg dafuer, dass Ironie in Schriftform nicht funktioniert... ich wuerde deinen Beitrag ja eher loeschen, statt einfach nur drunter zu kommentieren. Denn irgendwer kommt bis genau dahin, und interessiert sich nicht fuer den Rest

Da ja strukturieren angesprochen wurde: Da finde ich das `goto`-Modul sehr praktisch. Insbesondere `comefrom` war hier schon öfter mal ein „life saver“!!!1!elf!!

SCNR

@__deets__: Ja Löschen geht leider nicht mehr.

@BlackJack: `goto` fehlt einfach mal im Standard, damit wird eine eigene Dimsension von Problemen aus der Sprachen verbannt. Schade

Ich sehe selbst in C++ Code, wo Leute fleissig `goto`s in Methoden und Funktionen packen. Zum Glück ist es in C-like Sprachen auf den Funktionsraum beschränkt, was bei halbwegs kurzen Funktionen noch zu durchschauen ist (longjmps hab ich noch nicht in bugfix Code gesehen).

Jetzt habt ihr mich komplett verwirrt.
Ich bin seit grade mal drei Tage mit Python unterwegs. Meine Kenntnisse beschränken sich auf html von 1996.

Ich poste mal was ich bisher habe. Wenn ihr jetzt schon sagt HAAAAAAAAAAAAAAALT STOPP! VOLL KACKE... dann sagt bitte bescheid-

Wenn es für den eigenen Gebraucht ohne das jemals irgendwer anders auf diesen Code gucken wird noch gut genug ist, dann bitte auch bescheid sagen.

Keine Lust jetzt 100h zu tippen und dann am Ende feststellen zu müssen, dass das nicht geht weil 1000 Zeilen überschritten.

Code: Alles auswählen

from tkinter import *
from openpyxl import load_workbook
from openpyxl import Workbook

"""
Aufträge aus der Datenbank ziehen für die Übersichtsliste
kommt dann später
"""
Auftrag1 = "SMnummer 1 "
Auftrag2 = "SMnummer 2 "
Auftrag3 = "SMnummer 3 "
Auftrag4 = "SMnummer 4 "
Auftrag5 = "SMnummer 5 "
Auftrag6 = "SMnummer 6 "

statusAuftrag1 = "(1/7)"
statusAuftrag2 = "(4/7)"
statusAuftrag3 = "(3/7)"
statusAuftrag4 = "(7/7)"
statusAuftrag5 = "(6/7)"

Kabel1 = "1"
Kabel2 = "2"


Trommel1 = "2545112"
Trommel2 = "2254642"
Trommel3 = "2346722"
Trommel4 = "8796322"
Trommel5 = "7434522"
Trommel6 = "7435632"
Trommel7 = "7454323"


EinzelLaenge = "30m"
DoppelLaenge = "60m"
Trommel = "010981238"
TrommelLaenge = "500m"
KabelTyp = "36 DA"
Kabelnummer = "1 + 2"

def create_window():  # Zu Kurz Popup
    window = Toplevel(root)

root = Tk()  # Fenster erzeugen
root.title("Kabelschneiden Benutzeroberfläche")  # Fenster Titel
root.geometry("1200x800")  # Fenster Abmessungen
root.configure(bg="darkblue")
root.resizable(width=False, height=False)

menubar = Menu(root)

# Menüleiste erstellen und erzeugen
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label="Öffnen")
filemenu.add_command(label="Speichern")
filemenu.add_separator()
filemenu.add_command(label="Beenden", command=root.quit)
menubar.add_cascade(label="Datei", menu=filemenu)

# Dropdownmenü erstellen
editmenu = Menu(menubar, tearoff=0)
editmenu.add_command(label="Ausschneiden")
editmenu.add_command(label="Kopieren")
editmenu.add_command(label="Einfügen")
menubar.add_cascade(label="Menu 2", menu=editmenu)

helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label="Über")
helpmenu.add_command(label="Sebastian")
menubar.add_cascade(label="Hilfe", menu=helpmenu)

# Menüleiste anzeigen
root.config(menu=menubar)


# Bilder deklarieren

logo = PhotoImage(file="images\colli.gif")

# Trommelauswahl

Trommelauswahlframe = LabelFrame(root, text="Kabel schneiden", height="220", width="1060", bg="darkblue", fg="white")
Trommelauswahlframe.place(x=12, y=2)  # Rahmen um den ersten Schritt

uAufLabel = Label(root, text="Kabeltrommel auswählen:", bg="darkblue", fg="white")  # Überschrift offene Aufträg
uAufLabel.place(x=20,  y=20)

eKabeltrommel = Entry(root)  # Kabeltrommel manuell wählen
eKabeltrommel.place(x=30, y=48)

ueAufBox = Listbox(root, bg="darkblue", fg="white", height="8", width="22")  # Auftragsliste generieren
ueAufBox.place(x=23, y=83)

ueAufBox.insert(END, Trommel1)  # muss noch definiert werden oben

for item in [Trommel2, Trommel3, Trommel4, Trommel5, Trommel6, Trommel7]:  # Die weiteren Listeneinträge
    ueAufBox.insert(END, item)

wb = load_workbook("database\datenbankZuschnitt.xlsx")      # Datei einlesen
ws = wb.active                                              # Sagen welche verwendet werden soll
ws['F5'] = "Das müsste jetzt in der Console stehen"         # Der text der eingetragen werden soll
print(wb.get_sheet_names())                                # ausgabe des datenblattnamen
sheet_ranges = wb['SchneidlistenOffen']                     # welches registerblatt gelesen werden soll
print(sheet_ranges["F5"].value)

for sheet in wb:
    a=(sheet.title)
    print(a)

# ausgabe des eingetragenden textes



# Übersicht Schneidaufträge auf aktiver Kabeltrommel

uSchneidliste = Label(root, text="Schneidliste der Trommel: (0012345678)", bg="darkblue", fg="white")
uSchneidliste.place(x=170,  y=20)  # Überschrift Dieses Kabel schneiden

uTrommellaengeSL = Label(root, text="Trommellänge: ", bg="darkblue", fg="white")  # Überschrift Kabelnummern
uTrommellaengeSL.place(x=170,  y=40)

uTrommellaengeSL = Label(root, text="500m ", bg="darkblue", fg="white")  # ############################################################# FAKETROMMEllänge
uTrommellaengeSL.place(x=170,  y=60)

uSMNummerSL = Label(root, text="SM Nummer: ", bg="darkblue", fg="white")  # Überschrift Sm Nummer
uSMNummerSL.place(x=280,  y=40)

lSMNummerSL1 = Label(root, text="0202135787 ", bg="darkblue", fg="white")  # ##################################################FAKESMNUMMER
lSMNummerSL1.place(x=280,  y=60)

lSMNummerSL2 = Label(root, text="0202135787 ", bg="darkblue", fg="white")  # ##################################################FAKESMNUMMER
lSMNummerSL2.place(x=280,  y=80)

lSMNummerSL3 = Label(root, text="0202135787 ", bg="darkblue", fg="white")  # ##################################################FAKESMNUMMER
lSMNummerSL3.place(x=280,  y=100)

lSMNummerSL4 = Label(root, text="0202135787 ", bg="darkblue", fg="white")  # ##################################################FAKESMNUMMER
lSMNummerSL4.place(x=280,  y=120)

lSMNummerSL5 = Label(root, text="0202135787 ", bg="darkblue", fg="white")  # ##################################################FAKESMNUMMER
lSMNummerSL5.place(x=280,  y=140)

lSMNummerSL6 = Label(root, text="0202135787 ", bg="darkblue", fg="white")  # ##################################################FAKESMNUMMER
lSMNummerSL6.place(x=280,  y=160)

lSMNummerSL7 = Label(root, text="0202135787 ", bg="darkblue", fg="white")  # ##################################################FAKESMNUMMER
lSMNummerSL7.place(x=280,  y=180)

lSMNummerSL8 = Label(root, text="0202135787 ", bg="darkblue", fg="white")  # ##################################################FAKESMNUMMER
lSMNummerSL8.place(x=280,  y=200)

uAuftragSL = Label(root, text="Kabellänge: ", bg="darkblue", fg="white")  # Überschrift Kabelänge
uAuftragSL.place(x=365,  y=40)

uAuftragSL = Label(root, text="180m (90m) ", bg="darkblue", fg="white")  # ###################################################FAKESKABELLÄNGE
uAuftragSL.place(x=365,  y=60)

uAuftragSL = Label(root, text="Ringe: ", bg="darkblue", fg="white")  # Überschrift Ring Anzahl
uAuftragSL.place(x=435,  y=40)

uAuftragSL = Label(root, text="3 (6) ", bg="darkblue", fg="white")  # ###################################################ANAZHL SCHNITTE
uAuftragSL.place(x=435,  y=60)

uRestSL = Label(root, text="Rest: ", bg="darkblue", fg="white")  # Überschrift Rest
uRestSL.place(x=170,  y=100)

uRestSL = Label(root, text="3m (90m) ", bg="darkblue", fg="white")  # ###################################################FAKESREST
uRestSL.place(x=170,  y=120)

uKabeltypSL = Label(root, text="Kabelart: ", bg="darkblue", fg="white")  # Überschrift Rest
uKabeltypSL.place(x=170,  y=160)

lKabeltypSL = Label(root, text="36 DA ", bg="darkblue", fg="white")  # ###################################################FAKESREST
lKabeltypSL.place(x=170,  y=180)

# Dieses Kabel Schneiden

uAuftragSchneiden = Label(root, text="Dieses Kabel schneiden:", bg="darkblue", fg="white")
uAuftragSchneiden.place(x=520,  y=20)  # Überschrift Dieses Kabel schneiden

uSMNummerAktiv = Label(root, text="SM Nummer: ", bg="darkblue", fg="white")  # Überschrift Kabelnummern
uSMNummerAktiv.place(x=520,  y=40)

labelSMNummerAktiv = Label(root, text=Auftrag1, bg="darkblue", fg="white")  # Text Kabelnummern
labelSMNummerAktiv.place(x=620,  y=40)

uKabelnummer = Label(root, text="Kabelnummer: ", bg="darkblue", fg="white")  # Überschrift Kabelnummern
uKabelnummer.place(x=520,  y=60)

labelKabelnummer = Label(root, text=Kabelnummer, bg="darkblue", fg="white")  # Text Kabelnummern
labelKabelnummer.place(x=620,  y=60)

labelEinzelLaenge2 = Label(root, text="Zwischenlänge: ", bg="darkblue", fg="white")  # Label Zwischenlänge
labelEinzelLaenge2.place(x=520,  y=80)

textEinzelLaenge2 = Label(root, text=EinzelLaenge + " " + "+ " + "0.250 Maschinenabhängige Zusatzlänge",
                          bg="darkblue", fg="white")  # Text Zwischenlänge
textEinzelLaenge2.place(x=620,  y=80)

uAuftragSchneiden = Label(root, text="Endlänge: ", bg="darkblue", fg="white")  # Überschrift Doppellänge
uAuftragSchneiden.place(x=520,  y=100)

labelDoppelLaenge2 = Label(root, text=DoppelLaenge, bg="darkblue", fg="white")  # Text Doppellänge
labelDoppelLaenge2.place(x=620,  y=100)

# Buttons für Schneidliste (Fertig, Überspringen, zu kurz

bKabelFertig = Button(root, text="Geschnitten (F1)", width="15", height="2",)  #Button erledigt
bKabelFertig.place(x=950,  y=20)

bKabelNichtFertig = Button(root, text="Überspringen (F2)", width="15", height="2",)  #Button Kabel nicht geschnitten
bKabelNichtFertig.place(x=950,  y=65)

bKabelZuKurz = Button(root, text="Zu Kurz (F3)", width="15", height="2", command=create_window)  #Button Zu Kurz
bKabelZuKurz.place(x=950,  y=110)

# Auftragsübersicht

Auftragsuebersichtframe = LabelFrame(root, text="Schneidlisten Status (Live)", height="220", width="600", bg="darkblue", fg="white") # Rahmen um die Auftragsübersicht
Auftragsuebersichtframe.place(x=12, y=240)

labelAuftrag1 = Label(root, text = "Auftrag 1: ", bg="darkblue", fg="white")  # Einzellänge
labelAuftrag1.place(x=20,  y=258)

tAuftrag1 = Label(root, text = Auftrag1, bg="darkblue", fg="white")        # Auftrag 1 text
tAuftrag1.place(x=80, y=258)

labelAuftrag2 = Label(root, text = "Auftrag 2:", bg="darkblue", fg="white")  # Überschrift Auzftrag 2
labelAuftrag2.place(x=20,  y=278)

tAuftrag2 = Label(root, text = Auftrag2, bg="darkblue", fg="white")        # Auftrag 2 text
tAuftrag2.place(x=80, y=278)

labelAuftrag3 = Label(root, text = "Auftrag 3:", bg="darkblue", fg="white")  # Überschrift Auftrag3
labelAuftrag3.place(x=20,  y=298)

tAuftrag3 = Label(root, text = Auftrag3, bg="darkblue", fg="white")        # Auftrag3 text
tAuftrag3.place(x=80, y=298)

labelAuftrag4 = Label(root, text = "Auftrag 4:", bg="darkblue", fg="white")  # Überschrift Auftrag4
labelAuftrag4.place(x=20,  y=318)

tAuftrag4 = Label(root, text = Auftrag4, bg="darkblue", fg="white")        # Auftrag4 ausgabe text
tAuftrag4.place(x=80, y=318)

labelAuftrag5 = Label(root, text = "Auftrag 5:", bg="darkblue", fg="white")  # Überschrift Auftrag5
labelAuftrag5.place(x=20,  y=338)

tAuftrag5 = Label(root, text = Auftrag5, bg="darkblue", fg="white")        # Auftrag5 ausgabe text
tAuftrag5.place(x=80, y=338)

# LIVE Status der offenen Aufträge (z.B. 3 von 4 geschnitten)

statusAuftrag1 = Label(root, text=statusAuftrag1, bg="darkblue", fg="white")        # 1 text
statusAuftrag1.place(x=310, y=258)

statusAuftrag2 = Label(root, text=statusAuftrag2, bg="darkblue", fg="white")        # 2 text
statusAuftrag2.place(x=310, y=278)

statusAuftrag3 = Label(root, text=statusAuftrag3, bg="darkblue", fg="white")        # 3 text
statusAuftrag3.place(x=310, y=298)

statusAuftrag4 = Label(root, text=statusAuftrag4, bg="darkblue", fg="white")        # 4 ausgabe text
statusAuftrag4.place(x=310, y=318)

statusAuftrag5 = Label(root, text=statusAuftrag5, bg="darkblue", fg="white")        # 5 ausgabe text
statusAuftrag5.place(x=310, y=338)

# Rechner für den letzten Ring (A1-E1)+(A2+E2)

Ringrechnerframe = LabelFrame(root, text="Berechnen des letzten Rings", height="220", width="450", bg="darkblue", fg="white") # Rahmen um den Ring Rechner
Ringrechnerframe.place(x=622, y=240)

Laenge1 = Label(root, text = "Kabelanfang (m): ", bg="darkblue", fg="white")  # Text erste Markierung des Kabels
Laenge1.place(x=630, y=258)

feld1 = Entry(root)                                             # Eingabe für erste Markierung
feld1.place(x=800, y=258)

Laenge2 = Label(root, text = "Kabelende (m)", bg="darkblue", fg="white")                   # Text zweite Markierung
Laenge2.place(x=630, y=278)

feld2 = Entry(root)                                             # Eingabe für zweite Markierung
feld2.place(x=800, y=278)

Laenge3 = Label(root, text = "Maß Kabelanfang (cm)", bg="darkblue", fg="white")            # Text gemessene Länge Kabelanfang
Laenge3.place(x=630, y=298)

feld3 = Entry(root)                                             # ingabe des gemeesenen Maß 1
feld3.place(x=800, y=298)

Laenge4 = Label(root, text = "Maß Kabelende (cm)", bg="darkblue", fg="white")              # Text gemessene Länge Kabel ende
Laenge4.place(x=630, y=318)

feld4 = Entry(root)                                             # ingabe des gemessenen Maß 2
feld4.place(x=800, y=318)

def lesen():                                                  #funktion zum rechnen / auslesen
    Ergebnis.configure(text=feld4.get())

def rechnen():
    a = float(feld1.get())
    b = float(feld2.get())
    c = float(feld3.get())
    d = float(feld4.get())
    Ergebnis.configure(text=(a-b)+(c+d))


Berechnen = Button(root, text = "Berechnen", command = rechnen, width="15", height="2",)                    #Knopf zum berechnen
Berechnen.place(x=950, y=410)

Ergebnis = Label(root, text = "Ergebnis (Layout wird noch geänder)", bg="darkblue", fg="white")        #Hier soll dann das Ergenis der Rechnung ausgegeben
Ergebnis.place(x=660, y=360)                                                #werden. Später dann mit "MSG" PopUp


Hinweis = Label(root, text = "PUNKT (.) anstelle von KOMMA (,) benutzen! Wird noch geändert", bg="darkblue", fg="white")
Hinweis.place(x=660, y=380)


# Ansicht Collianhänger 1

Kollidruckframe = LabelFrame(root, text="Druckvorschau Kollianhänger", height="220", width="450", bg="darkblue", fg="white") # Rahmen um den Ring Rechner
Kollidruckframe.place(x=12, y=480)

Kollibild = Label(root, image=logo)
Kollibild.place(x=20, y=500)

tEinzelLaenge = Label(root, text = EinzelLaenge)        # Einzellänge ausgabe text
tEinzelLaenge.place(x=280, y=620)

tTrommel = Label(root, text = "Trommel " + Trommel)        # Trommelnummer ausgabe text
tTrommel.place(x=260, y=565)

tKabelTyp = Label(root, text = KabelTyp)        # Trommelnummer ausgabe text
tKabelTyp.place(x=80, y=620)

tSMNummer = Label(root, text = Auftrag1)
tSMNummer.place(x=60, y=565)

tKabel1 = Label(root, text = "Kabel Nummer: " + Kabel1)
tKabel1.place(x=60, y=520)

# Ansicht Collianhänger 1

Kollidruckframe = LabelFrame(root, text="Druckvorschau Kollianhänger", height="220", width="450", bg="darkblue", fg="white") # Rahmen um den Ring Rechner
Kollidruckframe.place(x=472, y=480)

Kollibild = Label(root, image=logo)
Kollibild.place(x=480, y=500)

tEinzelLaenge = Label(root, text = EinzelLaenge)        # Einzellänge ausgabe text
tEinzelLaenge.place(x=710, y=620)

tTrommel = Label(root, text = "Trommel " + Trommel)        # Trommelnummer ausgabe text
tTrommel.place(x=710, y=565)

tKabelTyp = Label(root, text = KabelTyp)        # Trommelnummer ausgabe text
tKabelTyp.place(x=520, y=620)

tSMNummer = Label(root, text = Auftrag1)
tSMNummer.place(x=520, y=565)

tKabel2 = Label(root, text = "Kabel Nummer: " + Kabel1)
tKabel2.place(x=520, y=520)

bDruckenKolli = Button(root, text="Drucken", width="15", height="2",) #Button Kabel nicht geschnitten
bDruckenKolli.place(x=950,  y=500)

bDruckenVorschauKolli = Button(root, text="Vorschau", width="15", height="2",) #Button Kabel nicht geschnitten
bDruckenVorschauKolli.place(x=950,  y=550)

root.mainloop()  # Programm nicht beenden

@Gismo1337: Ja, äh, das kann man selbst mit `goto` wahrscheinlich nicht mehr besser, äh, unübersichtlicher machen. Nummerierte Namen, kryptische Typpräfixe, alles global auf Modulebene und Funktionsdefinitionen und Hauptprogramm vermischt, Sternchen-Import, Feste Fenstergrösse und absolute Positionen mit `place()`, und im Grunde gar keine sichtbare Strukturierung, weder bei Code, noch bei den Daten, noch bei der GUI.

Also: Bescheid!

@Gismo1337:
Bescheid! (das erstere von beiden)

Ich formuliere mal eine ganz einfache Anforderung an Deinen Code: Packt doch mal alles in logisch getrennte Funktionen. Die Funktionen sollten dabei echte Funktionen sein, die nur mit Parametern und Rückgabewerten arbeiten.

Eine Funktion erstellst Du so:

Code: Alles auswählen

def functionXY(param1, param2, ...):
    # do something with params
    return some_result

Nutzen kannst Du eine Funktion so:

Code: Alles auswählen

result = functionXY(a, b, ...)

Vllt. hilft das für den Anfang.

Das deutsche Python-Forum

Alles in eine *.py schreiben?

Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?

Re: Alles in eine *.py schreiben?