Das deutsche Python-Forum

Schönen guten Tag,

Ich habe die in der Suchfunktion leider keine konkreten Antworten dazu gefunden.

Ich komme momentan leider bei dem Thema nicht weiter Ich habe zwei Dateien einmal eine wo Ich eine gui erstellt habe und einmal eine wo quasi das eigentlich Programm drinne läuft.

(Den genauen Code kann Ich nachher posten wenn Ich zuhause bin)

In der Gui Datei lade Ich "die arbeitsdatei ohne Probleme rein " Ich habe dann ein startknopf verküpft mit deine Funktion in der die arbeitsdatei aufgerufen wird und abgearbeitet wird -> funktioniert alles.

Nun möchte Ich jedoch in der Arbeitsdatei ebenfalls die Gui Datei importieren da Ich je nach dem in welchen Abschnitt Ich mich in der Arbeitsdatei befinde eine Progressbar neue Werte zuweisen möchte ( diese befindet sich in der GUI Datei).

Wenn Ich jedoch in der Arbeitsdatei versuche etwas von der Gui Datei zu importieren bekomme Ich ein Import Error -> Ich denke mal das kommt dadurch das eine Art Schleife entsteht -> was soll zuerst aufgerufen werden wenn die Dateien auf den jeweils anderen verweisen.

Nun die Frage ist das was Ich da vorhabe überhaupt möglich -> da Ich nicht einzelne Funktionen der Arbeitsdatei importiere sondern nur die main Funktion in die alle anderen gekapselt sind.

Ich kann natürlich alles mit in meine GUI klatschen -> was ich nicht so gerne machen würde

Das Problem ist das mir in dem Fall glaube Ich auch keine dritte 3 Datei helfen würde ( den Tipp habe Ich zum teil im Netz gelesen) da Ich den Fortschritt der Arbeitsdatei ja wieder spiegeln möchte.

Was Ich dazu nocht erwähnen möchte die GUI.py und Arbeitsdatei.py liegen im gleichen Ordner -> ist das eventuell das Problem ?

@Bl3nder: Das wird so nicht gehen, denn solange Deine Arbeit läuft kann die an der GUI eh nichts ändern, denn Änderungen werden erst sichtbar wenn die `mainloop()` die Kontrolle wieder zurückbekommt. Die Programmlogik sollte auch nichts von der GUI wissen müssen, da würde man also eher eine Rückruffunktion an die Programmlogik übergeben, die mit aktualisiertem Fortschritt aufgerufen wird.

Es sollte eigentlich egal sein, in welchem Modul welche Funktion definiert wird. Es hört sich auch komisch an, wenn Du "die main Funktion in die alle anderen [Funktionen] gekapselt sind" schreibst. Wie sind denn die gekapselt?
Also stimmt irgendetwas nicht, wie Du die Module geschrieben hast. Man bräuchte auch den konkreten Fehler, den Du bekommst.
Wenn die "Arbeitsdatei" länger arbeitet, dann muß sie in einem separaten Thread laufen, damit die GUI nicht einfriert. Das ist ein Thema für sich.

Ich danke euch beiden Ich posten mal meine Datei :

"Arbeitsdatei":

Code: Alles auswählen

from pathlib import Path
import pandas as pd
import shutil
import time







#Einstellungen für Pandas:
pd.set_option('display.max_rows', None)
pd.set_option('display.max_columns', None)
pd.set_option('display.width', None)
pd.set_option('display.max_colwidth', -1)
pd.set_option('mode.chained_assignment', None)  # Schaltet SettingWithCopyWarning aus





# Pfade:
#HAUPTORDNER = Path(r"C:\Users\Marcel\Desktop\Dieter_Klimareport")
#ORDNER_MIT_DATEN = Path(HAUPTORDNER).joinpath("Dieter_Auswertung\Fertigdaten_2018_07.wrt")
#Pfad_Excel = Path(r"C:\Users\Marcel\Desktop\Dieter_Klimareport\Unterlagen_Manfred\Muster Klimazettel MAT.xlsx")



# Kanal-Nummern: # Excel-Nummer +1 da Datum später weggenommen wird
KEIN_KANAL = 0
LUFTTEMPERATUR = 3
RELATIVE_LUFTFEUCHTIGKEIT = 289
MAX_TEMPERATUR = 249
MIN_TEMPERATUR = 248
NIEDERSCHLAG = 261
SONNENSCHEINDAUER = 18
MAX_WIND = 139
WINDRICHTUNG = 73

#Intervalle
TAG = "D"
Uhrzeit_1 = "06:00:00"
Uhrzeit_2 = "6:50:00"
Uhrzeit_3 = "13:50:00"
Uhrzeit_4 = "20:50:00"
Uhrzeit_5 = "23:59:00"

#Umrechnungsfaktoren
STUNDE_IN_SEKUNDEN = 3600#(60*60)


#----------------------------------------Programm Anfang----------------------------------------------------------------




def daten_einlesen(daten):
    """Hier werden die Daten eingelesen und zurückgegeben"""

    "Anmerkung low_memory ist standardmäig auf True dadurch läuft zwar das Programm schneller und benutzt weniger" \
    "Arbeitsspeicher jedoch werden dadurch gemische Colums ( vom Typ her erzeugt da diese nicht so schenll zugeordnet" \
    "werden können um das zu beheneben habe Ich es auf False gesetzt"

    df = pd.DataFrame(pd.read_csv(daten,sep = "|",header = None,parse_dates = True,low_memory = False,na_values = "******",dtype = {"73":int} ))#low_Memory = False da pandas nicht alle typen bestimmen kann
    df[0] = pd.to_datetime(df[0])
    df = df.set_index(0)  # df = zuordnen dann bleibt 1 spalte erhalten
    anfang_index = df.index.tolist()[0]  # ermittelt den ersten Index eintrag
    ende_index = df.index.tolist()[-1]  # ermittelt den letzten Index eintrag
    return df,anfang_index,ende_index
def datum_fuer_excel(datum):
    #gui_klimareport.win.progressbar(20)
    MONATE = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November",
              "Dezember"]
    datum = str(datum).split("-")
    jahr = datum[0]
    monat_zahl = int(datum[1])
    monat_ausgeschrieben = MONATE[monat_zahl-1]
    return jahr,monat_zahl,monat_ausgeschrieben


def kopie_der_vorlage_erzeugen(pfad,jahr,monat):

    if monat <= 9:
        monat="0"+str(monat)
    monat = str(monat)
    jahr = str(jahr)

    if isinstance(pfad,str):
        pfad=Path(pfad)
    muster_original= pfad.joinpath("D:\Klimareport Dieter\Muster Klimazettel MAT.xlsx")
    zusatz_kopie ="\\Klimareport Dieter\\"+"\\Excel\\"+"MAT"+"_"+"Klimareport"+"_"+jahr+"_"+monat+".xlsx"
    kopie = pfad.joinpath(zusatz_kopie)
    print(kopie)
    if not kopie.exists():
        shutil.copy(muster_original,kopie)
    return kopie


def windgeschwindigkeit_mit_windrichtung(datensatz,kanalnummer_max_wind,kanalnummer_windrichtung,intervall):
    """Es wird ein neuer Datenframe erstellt mit der Windrichtung und dem Max Wind (nummer 73,139),in einem neuen Datenframe
    werden die beiden Spalten in Abnhänihkeit der rechten Spalte (1 = 139) mit der freq D gropiert | der Index und die Spalte 0
    werden Tageweise ausgewählt abhängig davon wo der Max Wert der Rechten Spalte war"""
    df = datensatz[[kanalnummer_windrichtung,kanalnummer_max_wind]]
    df_neu= df.loc[df.groupby(pd.Grouper(freq = intervall)).idxmax().iloc[:,1]]
    return df_neu
def daten_mit_zeit_index(datensatz,kanalnummer,intervall):
    """Wir extrahieren die Spalte kanalnummer_lufttemperatur aus dem Datenframe datensatz danach suchen
    wir im Index an Einträgen mit der Zeit intervalle in dem Fall übergeben wir diese zum Beispiel 06:50:00 und erhalten
    in Integerwerte zurück in welcher Reihe sich die Zeit befindet wodruch wir gleichzeitig mit dem Integerwert auf den
    Messwert zurgreifen können da es sich hier um 1 Dimensonale Werte handeln werden Series zurückgegeben"""
    series= datensatz[kanalnummer]
    index = series.index.indexer_at_time(time = intervall)
    series_mit_neuem_index = pd.Series(series.iloc[index],dtype = float)
    return series_mit_neuem_index
def series_zu_Datenframe(Werte1,Werte2,Werte3,Name1,Name2,Name3):
    """"Die übergebenen Werte ( Series) werden von ihrem Index getrennt damit Sie einen einheitlichen erhalten( 1....)
        danach werden Sie zusammengefasst zu einem Dataframe ,wird aktuell nicht benötigt da die Rechnung
        des Mittelwertes in Excel stattfindet"""
    Zeitraum1 = pd.Series(Werte1.reset_index(drop = True),name = Name1)
    Zeitraum2 = pd.Series(Werte2.reset_index(drop = True),name = Name2)
    Zeitraum3 = pd.Series(Werte3.reset_index(drop = True),name = Name3)
    Zeitraum4 = pd.Series(Werte3.reset_index(drop = True),name = "lufttemp_20_50")
    df = pd.concat([Zeitraum1,Zeitraum2,Zeitraum3,Zeitraum4],axis = 1)#axis 1 damit Sie nebeneinanderer gereiht werden ( 1 = Colum 0 = Index)
    return df
def sonnenscheindauer_in_std(datensatz,kanalnummer,Umrechnungsfaktor):
    """Aus dem Datensatz wird die Spalte mit den Sonnenwerten extrahiert diese sind jedoch in Sekunden daher wird die
    Tagessumme ermittelt und diese durch den Umrechnungswert dividiert um die Tagessumme in Stunden zu erhalten danch
    werden die Werte auf 2 Nachkommastellen gerunden damit diese nicht zu lang werden"""
    series = datensatz[kanalnummer]
    series_summe_pro_tag = series.groupby(pd.Grouper(freq = "D")).sum()
    sonnenstunden = series_summe_pro_tag.div(Umrechnungsfaktor)
    return sonnenstunden
def daten_zusammenfassen(windrichtung_abhaengigkeit_windgeschwindigkeit,lufttemp_06_50,lufttemp_13_50,lufttemp_20_50,tml,relativ_luftfeucht_06_50,relativ_luftfeucht_13_50,relativ_luftfeucht_20_50,tmf,max_temp,min_temp,sonnenschein,niederschlag):
    """HINWEIS AKTUELL WERDEN tml und tmf NICHT benutzt da diese in Excel zusammen gefasst werden
       Die Daten werden in mehreren Datenframes zusammengefasst damit diese nachher einzeln in die Excel Datei
       geschrieben werden können ( es befinden sich dort Spalten mit Formeln -> ein großer Datenframe würde da nur stören"""

    wert1 = windrichtung_abhaengigkeit_windgeschwindigkeit.reset_index(drop = True)
    wert2 = lufttemp_06_50.reset_index(drop = True)
    wert3 = lufttemp_13_50.reset_index(drop = True)
    wert4 = lufttemp_20_50.reset_index(drop = True)
    #wert5 = tml.reset_index(drop = True)
    wert6 = relativ_luftfeucht_06_50.reset_index(drop = True)
    wert7 = relativ_luftfeucht_13_50.reset_index(drop = True)
    wert8 = relativ_luftfeucht_20_50.reset_index(drop = True)
    #wert9 = tmf.reset_index(drop = True)
    wert10 = max_temp.reset_index(drop = True)
    wert11 = min_temp.reset_index(drop = True)
    wert12 = sonnenschein.reset_index(drop = True)
    wert13 = niederschlag.reset_index(drop = True)


    df1 = pd.concat([wert1,wert2,wert3,wert4],axis = 1)
    df2 = pd.concat([wert6,wert7,wert8],axis = 1)
    df3 = pd.concat([wert10,wert11,wert12,wert13],axis = 1)

    return df1,df2,df3
def daten_in_excel_schreiben(datenframe1,datenframe2,datenframe3,pfad,jahr,monat):

        df1 = datenframe1.iloc[:10]
        df1_1 = datenframe1.iloc[10:20]
        df1_2 = datenframe1.iloc[20:]
        df2 = datenframe2.iloc[:10]
        df2_1 = datenframe2.iloc[10:20]
        df2_2 = datenframe2.iloc[20:]
        df3 = datenframe3.iloc[:10]
        df3_1 = datenframe3.iloc[10:20]
        df3_2 = datenframe3.iloc[20:]

        datum = pd.Series([jahr])
        monat = pd.Series([monat])

        with pd.ExcelWriter(pfad, engine="openpyxl", mode="a") as writer:
            writer.sheets = {sheet.title: sheet for sheet in writer.book}  # sorgt dafür das kein neues Arbeitsblatt erschaffen wird
            datum.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 1,startcol = 13)
            monat.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 1,startcol = 11)
            df1.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None,startrow = 8, startcol = 1)
            df1_1.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 19, startcol = 1)
            df1_2.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 30, startcol = 1)
            df2.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 8, startcol = 7)
            df2_1.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 19, startcol = 7)
            df2_2.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 30, startcol = 7)
            df3.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 8, startcol = 11)
            df3_1.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 19, startcol = 11)
            df3_2.to_excel(writer, sheet_name = "Klimareport_MAT", header = None, index = None, startrow = 30, startcol = 11)






def main(HAUPTORDNER,ORDNER_MIT_DATEN):
    ausgelsene_daten,anfangs_index,ende_index = daten_einlesen(ORDNER_MIT_DATEN)#Dataframe
    excel_datum_jahr,excel_datum_monatszahl,excel_datum_monat_ausgeschrieben= datum_fuer_excel(anfangs_index)
    Pfad_Excel = kopie_der_vorlage_erzeugen(HAUPTORDNER,excel_datum_jahr,excel_datum_monatszahl)
    windrichtung_abhaengigkeit_windgeschwindigkeit = windgeschwindigkeit_mit_windrichtung(ausgelsene_daten,MAX_WIND,WINDRICHTUNG,TAG)#Dataframe,=> nachher in Excel
    lufttemp_06_50 = daten_mit_zeit_index(ausgelsene_daten, LUFTTEMPERATUR, Uhrzeit_2)#Series
    lufttemp_13_50 = daten_mit_zeit_index(ausgelsene_daten,LUFTTEMPERATUR,Uhrzeit_3)#Series
    lufttemp_20_50 = daten_mit_zeit_index(ausgelsene_daten,LUFTTEMPERATUR,Uhrzeit_4)#Series
    tml = series_zu_Datenframe(lufttemp_06_50,lufttemp_13_50,lufttemp_20_50,"lufttemp_06_50","lufttemp_13_50", "lufttemp_20_50")#Dataframe => nachher in Excel
    relativ_luftfeucht_06_50 = daten_mit_zeit_index(ausgelsene_daten, RELATIVE_LUFTFEUCHTIGKEIT, Uhrzeit_2)
    relativ_luftfeucht_13_50 = daten_mit_zeit_index(ausgelsene_daten,RELATIVE_LUFTFEUCHTIGKEIT,Uhrzeit_3)
    relativ_luftfeucht_20_50 = daten_mit_zeit_index(ausgelsene_daten,RELATIVE_LUFTFEUCHTIGKEIT,Uhrzeit_4)
    tmf = series_zu_Datenframe(relativ_luftfeucht_06_50,relativ_luftfeucht_13_50,relativ_luftfeucht_20_50," relativ_luftfeucht_06_50"," relativ_luftfeucht_13_50","relativ_luftfeucht_20_50")#Dataframe => nachher in Excel
    max_temp = daten_mit_zeit_index(ausgelsene_daten,MAX_TEMPERATUR,Uhrzeit_1)#Series ->nachher in Excel
    min_temp = daten_mit_zeit_index(ausgelsene_daten,MIN_TEMPERATUR,Uhrzeit_1)#Series ->nachher in Excel
    sonnenschein = sonnenscheindauer_in_std(ausgelsene_daten,SONNENSCHEINDAUER,STUNDE_IN_SEKUNDEN)#Series ->nachher in Excel
    niederschlag = daten_mit_zeit_index(ausgelsene_daten,NIEDERSCHLAG,Uhrzeit_5)#Series ->nachher in Excel
    datenframe1,datenframe2,datenframe3=daten_zusammenfassen(windrichtung_abhaengigkeit_windgeschwindigkeit,lufttemp_06_50,lufttemp_13_50,lufttemp_20_50,tml,relativ_luftfeucht_06_50,relativ_luftfeucht_13_50,relativ_luftfeucht_20_50,tmf,max_temp,min_temp,sonnenschein,niederschlag)
    daten_in_excel_schreiben(datenframe1,datenframe2,datenframe3,Pfad_Excel,excel_datum_jahr,excel_datum_monat_ausgeschrieben)
    return Pfad_Excel




if __name__=="__main__":
    main()

gui:

Code: Alles auswählen

import sys
from functools import partial
from pathlib import Path
from PyQt5.QtWidgets import QWidget, QApplication, QMessageBox, QFileDialog
from PyQt5 import uic
import Klimareport_Mat
import PDF

from Klimareport_Mat import main as hauptprogramm
from PDF import pdf_umwandlung








ui_datei = Path(r"D:\PyCharm Projekte\venv\Dieter_Klimareport\Klimareport\gui.ui")
fertigdatei_pfad = Path(r"C:\Daten\Fertigdaten")
speicher_pfad = Path(r"D:\Klimareport Dieter")






class gui(QWidget):
	def __init__(self):
		super().__init__()
		# Hier kommen Einstellungen für das Widgetrein
		self.win = uic.loadUi(ui_datei, self)
		self.initUI()

	def initUI(self):

		# Hier erfolgen nachher die aufrufe der Interaktionen
		self.pyqtSlot()
		self.meldung()
		self.show()

	def meldung(self):
		if not speicher_pfad.exists():
			self.msg = QMessageBox()
			self.msg.setIcon(QMessageBox.Information)
			self.msg.setText("Der angegebene Pfad" + str(speicher_pfad) + " ist nicht vorhanden!")
			self.msg.setWindowTitle("Information")
			self.msg.show()

	# Slots
	def pyqtSlot(self):

		self.win.Speicherpfad.mouseDoubleClickEvent = (
			partial(self.pfad_interaktion, name = "Speicherpfad", pfad = speicher_pfad))
		self.win.Dateipfad.mouseDoubleClickEvent = (
			partial(self.pfad_interaktion, name = "Fertigdateipfad", pfad = fertigdatei_pfad))

		self.win.Speicherpfad.textChanged.connect(self.start)
		self.win.Dateipfad.textChanged.connect(self.start)

		self.win.startknopf.clicked.connect(self.hauptprogramm_ablauf)



	def pfad_interaktion(self, event, name, pfad):
		options = QFileDialog.Options()
		options |= QFileDialog.DontUseNativeDialog
		pfad = str(pfad)
		if name == "Fertigdateipfad":
			global fertigdatei_pfad

			fertigdatei = QFileDialog.getOpenFileName(self, "Öffnen", directory = pfad,
													  filter = "*.wrt;;All Files(*)", options = options)
			if fertigdatei:
				self.win.Dateipfad.setText(fertigdatei[0])
				fertigdatei_pfad = Path(fertigdatei[0])
				self.win.setFocus()


		else:
			global speicher_pfad
			speicher_pfad_ausgewaehlt = QFileDialog.getExistingDirectory(options = options,
																		 directory = r"D:\Klimareport Dieter")
			self.win.Speicherpfad.setText(speicher_pfad_ausgewaehlt)
			# self.win.checkBox_speicherpfad.setDisabled(True)
			self.win.Speicherpfad.setEnabled(False)
			speicher_pfad = speicher_pfad_ausgewaehlt
			self.win.checkBox_speicherpfad.setChecked(False)
			self.win.setFocus()

	# self.myButton.clicked.connect(partial(self.myFunction, myArgument = 'something')) Notiz

	def start(self):
		pfad_speicher = self.win.Speicherpfad.text()
		pfad_datei = self.win.Dateipfad.text()

		if pfad_speicher and pfad_datei is not "":
			end_speicher = Path(pfad_speicher).exists()
			end_datei = Path(pfad_datei).exists()
			if end_speicher and end_datei == True:
				self.win.startknopf.setEnabled(True)
		else:
			self.win.startknopf.setEnabled(False)

	def hauptprogramm_ablauf(self):
		self.win.PDF_Radio_Button.setEnabled(False)
		self.win.Speicherpfad.setEnabled(False)
		self.win.Dateipfad.setEnabled(False)
		global speicher_pfad, fertigdatei_pfad
		erzeugte_datei = hauptprogramm(speicher_pfad, fertigdatei_pfad)
		print("Excel wurde erzeugt")
		if self.win.PDF_Radio_Button.isChecked():
			pdf_umwandlung(str(erzeugte_datei))
		print("PDF wurde erzeugt")
		self.win.PDF_Radio_Button.setEnabled(True)
		self.win.Speicherpfad.setEnabled(True)
		self.win.Dateipfad.setEnabled(True)
		self.win.Dateipfad.clear()
		
	def progressbar(self,value):
		self.win.progressBar.setValue(value)


if __name__=="__main__":
	app = QApplication(sys.argv)
	win = gui()
	sys.exit(app.exec_())

Leider habe Ich noch nie mit Threads gearbeitet.

Und Ich stehe da auch auf dem schlauch ... Ich habe versucht die ( da die Arbeitsdatei 8-11 sekunden braucht ) danach die progressbar laufen zu lassen nur als Anwender hat man da dann natürlich das gefühl das nicht passiert ...

Das wird so nicht gehen, denn solange Deine Arbeit läuft kann die an der GUI eh nichts ändern, denn Änderungen werden erst sichtbar wenn die `mainloop()` die Kontrolle wieder zurückbekommt. Die Programmlogik sollte auch nichts von der GUI wissen müssen, da würde man also eher eine Rückruffunktion an die Programmlogik übergeben, die mit aktualisiertem Fortschritt aufgerufen wird.

hmmm verstehe Ich leider nicht ganz -> da Ich sag mal die "Arbeitsdatei" fast "80 %" sind würde dann die Progressbar keinen Sinn machen wenn danach der Forschritt aktualisiert wird .... aber Ich habe mir das fast gedacht das das so nicht funktioniert...

Die genau Fehlermeldung lautet:

Also Beispiel wenn ich eine globale Variable erzeuge in der gui und diese in der Arbeitsdatei verwenden will

Arbeitsdatei:

Code: Alles auswählen

import gui_klimareport
test = gui_klimareport.test

bekomme Ich bei der Ausfrührung der gui den Fehler ->ImportError: cannot import name 'main' from 'Klimareport_Mat' (G:\Dieter_Klimareport\Klimareport\Klimareport_Mat.py)

Dieser Test wäre genau das gleich als wenn Ich so Versuchen würde die Classen Methode aufzurufen die dann nur set.value und den neuen Wert ändern würde

Nur um das dann zu verdeutlichen nicht das man aneinander vorbei redet

Meine Grundgedanke war folgender :

Arbeitsdatei wird ausgeführt:

Code: Alles auswählen

import "Klassen-Methode Progressbar" as pg
def daten_einlesen(daten):
   pg(10)
.
.
.

Gui würde dann einen 10 % balken machen also einfach dargestellt.

Das einzige was mir wie gesagt einfallen würde wäre statt der ganzen main die einzlenen Funktionen in der Gui aufzurufen danach könnte Ich dann immer die Schritt setzten nur Ich woltle das eigentlich trennen oder was haltet ihr davon?

Kurze Frage:

Findest du deinen Code eigentlich angenehm zu lesen?

Zumindest zwischen Funktionsdefinitionen sollte man Leerzeilen einfügen. Eingerückt wird immer mit 4 Leerzeichen pro Ebene, keine Tabs.
Die Schreibweise von Klassen und Variablen ist etwas durcheinander. Klassen schreibt man mit großem Anfangsbuchstaben `Gui` und Variablennamen schreibt man komplett klein.
`global` solltest Du sofort wieder vergessen. Du hast doch eine Klasse, da ist die Verwendung von globalen Variablen doch total unnötig.
In gui.py gibt es gar kein `main´, da ist die Fehlermeldung verständlich.

Qt verwende ich nicht, daher kann ich Dir beim Umsetzen mit QThread und Signalen nicht helfen.

Kurze Frage:

Findest du deinen Code eigentlich angenehm zu lesen?

Nein nur da Ich schnellst möglich ein fertiges tool benötige habe Ich es so runterprogrammiert -> sobald alles läuft versuche Ich mich mehr an die Konvention zu halten ausser das mit den Leerzeichen verstehe Ich ehrlich gesagt nicht da ein tab 4 Leerzeichen sind in Pycharm ? -> ist so eingestellt es ging hier auch ehr um den allgemeinen ablauf.

Und Blackjack hatte recht -> Ich habe mir heute nochmal einige Videos angeguckt dafür gibt es die Klasse QThread jedoch benötige Ich hier nochmal eure Meinung:

Es gebe die möglichkeit ein Thread zu starten in einer schleife bis ein Wert 100 % erreicht ( Ich könnte ein bisschen herumspielen ) die Zeit einstellen die die Arbeitsdatei benötigt -> dadurch hätte der Anwender das gefühl das etwas passiert und die Gui wäre noch von dem Hauptprogramm getrennt.

Jedoch würde es nicht den eigentlichen Fortschritt des Skriptes dastellen...

Eine andere Idee würde wie folgt aussehen :

Arbeitsdatei:

Code: Alles auswählen


Forschrittsdatei = 0
def Funktion1
	global Forschrittsdatei
	Fortschrittsdatei = 10
def Funtkion 2 
	global Forschrittsdatei
	Fortschrittsdatei = 20

Oder Ich übergebe die globale Variable immer wieder den Funktionen was aber auch nicht so schön ist ... und übergebe diese wieder eine andere Datei -> und diese andere Datei importiere Ich dann wieder in meine GUI ? Ich habe leider keinen Ansatz was hier am klügsten wäre oder wie man es am besten macht ( mir geht es dabei nicht um den Code sondern ehr um den Ablauf wie man sowas im allgemeinen macht ) Jetzt lege ICh die GUI über mein Arbeitdatei ( Sie wird dort importiert und jenachdem welche Aktion man start wird etwas ausgeführt so macht es für mich Sinn -> Ich bin nämlich zwischen durch auch schon auf die Idee gekommen um die Progressbar dazustellen diese in der Arbeitsdatei oder einer dritten Datei zu erzeugen. ...

Das deutsche Python-Forum

Anfänger -> Gegenseitiger Import

Anfänger -> Gegenseitiger Import

Re: Anfänger -> Gegenseitiger Import

Re: Anfänger -> Gegenseitiger Import

Re: Anfänger -> Gegenseitiger Import

Re: Anfänger -> Gegenseitiger Import

Re: Anfänger -> Gegenseitiger Import

Re: Anfänger -> Gegenseitiger Import

Re: Anfänger -> Gegenseitiger Import