Ich hatte vor ein paar Wochen schon mal meinen Code präsentiert dieser war jedoch ziemlich durcheinander:
ALTER_CODE:
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 = "06: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(pfad_fertigdaten):
"""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"
ausgelesene_daten_als_df = pd.DataFrame(pd.read_csv(pfad_fertigdaten, sep ="|", header = None, parse_dates = True,
low_memory = False, na_values ="******", dtype = {"73":int}))#low_Memory = False da pandas nicht alle typen bestimmen kann
ausgelesene_daten_als_df[0] = pd.to_datetime(ausgelesene_daten_als_df[0])
ausgelesene_daten_als_df = ausgelesene_daten_als_df.set_index(0) # ausgelesene_daten_als_df = zuordnen dann bleibt 1 spalte erhalten
anfang_index = ausgelesene_daten_als_df.index.tolist()[0] # ermittelt den ersten Index eintrag
ende_index = ausgelesene_daten_als_df.index.tolist()[-1] # ermittelt den letzten Index eintrag
return ausgelesene_daten_als_df,anfang_index,ende_index
def datum_fuer_excel(datum):
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 nach Einträgen mit der Zeit 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(pfad_speicher, pfad_fertigdaten):
try:
ausgelsene_daten,anfangs_index,ende_index = daten_einlesen(pfad_fertigdaten)#Dataframe
excel_datum_jahr,excel_datum_monatszahl,excel_datum_monat_ausgeschrieben= datum_fuer_excel(anfangs_index)
pfad_zur_exceldatei = kopie_der_vorlage_erzeugen(pfad_speicher, 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_zur_exceldatei,excel_datum_jahr,excel_datum_monat_ausgeschrieben)
return pfad_zur_exceldatei
except Exception as e:
print(e)
return ""
# if __name__=="__main__":
# main()Ich habe diesen überarbeitet und wollte euch Fragen ob dieser mehr den Konventionen enspricht ?
NEUER_CODE:
Code: Alles auswählen
from pathlib import Path
import pandas as pd
# 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
fertigdaten = Path(
r"C:\Users\Marcel\PycharmProjects\Fertigdaten_2020_04.wrt")
KANALNUMMER = {
"DATUM": 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": "06:50:00",
"Uhrzeit_3": "13:50:00",
"Uhrzeit_4": "20:50:00",
"Uhrzeit_5": "23:59:00",
}
MONATE = {
1: "Januar",
2: "Februar",
3: "März",
4: "April",
5: "Mai",
6: "Juni",
7: "Juli",
8: "August",
9: "September",
10: "Oktober",
11: "November",
12: "Dezember"
}
UMRECHNUNGSFAKTOR = 3600
def daten_einlesen(pfad_fertigdaten):
"""
-Die Daten werden eingelesen
-Das Datum der Datei wird als Index festgelegt
"""
datensatz = pd.read_csv(
pfad_fertigdaten,
sep="|",
header=None,
parse_dates=True,
low_memory=False,
na_values="******",
usecols=[*KANALNUMMER.values()] # Holt sich die Spaltenzahlen aus dem Dictonary
)
datensatz[0] = pd.to_datetime(datensatz[0])
datensatz = datensatz.set_index(0) # Datum wird Index
datensatz = datensatz.fillna(int(-1))
return datensatz
def datum_fuer_excel(ausgelesene_daten):
"""
Aus dem Index der ausgelesenene_daten wird das jahr sowie der Monat extrahiert
"""
anfangs_index = ausgelesene_daten.index.tolist()[0]
jahr = str(anfangs_index).split("-")[0]
monat = int(str(anfangs_index).split("-")[1]) # damit aus 04->4 wird
monat_als_wort = MONATE.get(monat)
return jahr, monat_als_wort
def winddaten_erhalten(ausgelesene_daten):
"""
-Aus dem übergebenen Datensatz werden die KANÄLE WINDRICHTUNG & MAX_WIND extrahiert
-Danach werden wird für jedenTag der höchste MAX_Wind ermittelt und in abhängigkeit die dazugehörige WINDRICHTUNG
-Am Ende werden die Values mit -1 zu einem leeren string gewandelt
"""
winddaten = ausgelesene_daten[[KANALNUMMER.get("WINDRICHTUNG"), KANALNUMMER.get("MAX_WIND")]]
winddaten = winddaten.loc[winddaten.groupby(pd.Grouper(freq="D")).idxmax().iloc[:, 1]]
winddaten = winddaten.replace(-1, "")
return winddaten
def daten_mit_anderen_zeitindex(ausgelesene_daten, kanalnummer, intervall):
"""
Wir extrahieren die übergebene kanalnummer aus dem übergebenen Datensatz,danach erstellen wir einen neuen Index
in abhängigkeit von dem Übergebenen intervall und legen diesen über die extrahierten_daten.
Beispiel:
Wir übergebenen Uhrzeit_2 = "06:50:00" dann sieht unsere Series am Ende wie folgt aus
2020-04-01 06:50:00 1.56
2020-04-02 06:50:00 5.02
2020-04-03 06:50:00 5.95
...
"""
extrahierte_daten = ausgelesene_daten[kanalnummer]
neuer_index = extrahierte_daten.index.indexer_at_time(time=intervall)
extrahierte_daten_mit_neuem_index = pd.Series(extrahierte_daten.iloc[neuer_index], dtype=float)
extrahierte_daten_mit_neuem_index = extrahierte_daten_mit_neuem_index.replace(-1, "")
return extrahierte_daten_mit_neuem_index
def sonnenschein_erhalten(ausgelesene_daten):
"""Aus dem Datensatz wird die Spalte mit der SONNENSCHEINDAUER extrahiert diese sind jedoch in Sekunden daher wird
die Tagessumme ermittelt und diese durch den Umrechnungswert dividiert um die Tagessumme in Stunden zu erhalten
"""
sonnenschein = ausgelesene_daten[KANALNUMMER.get("SONNENSCHEINDAUER")]
sonnenschein = sonnenschein.groupby(pd.Grouper(freq=INTERVALLE.get("TAG"))).sum()
sonnenschein = sonnenschein.div(UMRECHNUNGSFAKTOR)
sonnenschein = sonnenschein.replace(-1, "")
return sonnenschein
def daten_zusammenfassen(winddaten, luft_temp0650, luft_temp1350, luft_temp2050, relativ_luftfeucht0650,
relativ_luftfeucht1350, relativ_luftfeucht2050, max_temp, min_temp, sonnenschein,
niederschlag):
"""
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 = winddaten.reset_index(drop=True)
wert2 = luft_temp0650.reset_index(drop=True)
wert3 = luft_temp1350.reset_index(drop=True)
wert4 = luft_temp2050.reset_index(drop=True)
wert6 = relativ_luftfeucht0650.reset_index(drop=True)
wert7 = relativ_luftfeucht1350.reset_index(drop=True)
wert8 = relativ_luftfeucht2050.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)
zusammengefasste_daten1 = pd.concat([wert1, wert2, wert3, wert4], axis=1)
zusammengefasste_daten2 = pd.concat([wert6, wert7, wert8], axis=1)
zusammengefasste_daten3 = pd.concat([wert10, wert11, wert12, wert13], axis=1)
return zusammengefasste_daten1, zusammengefasste_daten2, zusammengefasste_daten3
def daten_in_excel(fertigdaten_pfad, zfg_daten1, zfg_daten2, zfg_daten3, jahr, monat_als_wort):
"""
HINWEIS writer.sheets = {sheet.title: sheet for sheet in writer.book} sorgt dafür das die Daten in einer Arbeits
mappen angehängt da sonst immer eine neue Arbeitsmappe erstellt wird.
Die übergebenen Daten werden in 3 Teile aufgesteilt damit diese vorhandene Formeln in der Excel Datei behindern
"""
df1 = zfg_daten1.iloc[:10]
df1_1 = zfg_daten1.iloc[10:20]
df1_2 = zfg_daten1.iloc[20:]
df2 = zfg_daten2.iloc[:10]
df2_1 = zfg_daten2.iloc[10:20]
df2_2 = zfg_daten2.iloc[20:]
df3 = zfg_daten3.iloc[:10]
df3_1 = zfg_daten3.iloc[10:20]
df3_2 = zfg_daten3.iloc[20:]
datum = pd.Series([jahr])
monat = pd.Series([monat_als_wort])
with pd.ExcelWriter(fertigdaten_pfad, engine="openpyxl", mode="a") as writer:
writer.sheets = {sheet.title: sheet for sheet in writer.book}
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(fertigdaten_pfad):
ausgelesene_daten = daten_einlesen(fertigdaten_pfad)
jahr, monat_als_wort = datum_fuer_excel(ausgelesene_daten)
winddaten = winddaten_erhalten(ausgelesene_daten)
luft_temp0650 = daten_mit_anderen_zeitindex(ausgelesene_daten,
KANALNUMMER.get("LUFTTEMPERATUR"),
INTERVALLE.get("Uhrzeit_2"))
luft_temp1350 = daten_mit_anderen_zeitindex(ausgelesene_daten,
KANALNUMMER.get("LUFTTEMPERATUR"),
INTERVALLE.get("Uhrzeit_3"))
luft_temp2050 = daten_mit_anderen_zeitindex(ausgelesene_daten,
KANALNUMMER.get("LUFTTEMPERATUR"),
INTERVALLE.get("Uhrzeit_4"))
relativ_luftfeucht0650 = daten_mit_anderen_zeitindex(ausgelesene_daten,
KANALNUMMER.get("RELATIVE_LUFTFEUCHTIGKEIT"),
INTERVALLE.get("Uhrzeit_2"))
relativ_luftfeucht1350 = daten_mit_anderen_zeitindex(ausgelesene_daten,
KANALNUMMER.get("RELATIVE_LUFTFEUCHTIGKEIT"),
INTERVALLE.get("Uhrzeit_3"))
relativ_luftfeucht2050 = daten_mit_anderen_zeitindex(ausgelesene_daten,
KANALNUMMER.get("RELATIVE_LUFTFEUCHTIGKEIT"),
INTERVALLE.get("Uhrzeit_4"))
max_temp = daten_mit_anderen_zeitindex(ausgelesene_daten,
KANALNUMMER.get("MAX_TEMPERATUR"),
INTERVALLE.get("Uhrzeit_1"))
min_temp = daten_mit_anderen_zeitindex(ausgelesene_daten,
KANALNUMMER.get("MAX_TEMPERATUR"),
INTERVALLE.get("Uhrzeit_1"))
sonnenschein = sonnenschein_erhalten(ausgelesene_daten)
niederschlag = daten_mit_anderen_zeitindex(ausgelesene_daten,
KANALNUMMER.get("NIEDERSCHLAG"),
INTERVALLE.get("Uhrzeit_5"))
# zfg = zusammengefasste
zfg_daten1, zfg_daten2, zfg_daten3 = daten_zusammenfassen(winddaten, luft_temp0650, luft_temp1350, luft_temp2050,
relativ_luftfeucht0650, relativ_luftfeucht1350,
relativ_luftfeucht2050, max_temp, min_temp, sonnenschein,
niederschlag)
daten_in_excel(fertigdaten_pfad, zfg_daten1, zfg_daten2, zfg_daten3, jahr, monat_als_wort)
if __name__ == "__main__":
main(fertigdaten)