Absturz bei Dateinamen im String

[Peter18]

Ein freundliches Hallo an alle,

um Daten anzuzeigen nutze ich einen Dateinamen. Der Name wird in einem String aufbereitet und dann die Datei umbenannt. Damit kann ich die Daten sehen, ohne eine Datei öffnen zu müssen. Das findet in einer Procedure statt. (def Displayfile():)

Die Variablen sind am Anfang des Programmes initialisiert, also global. Wenn "if DispFile == "":" dann wird die Datei erzeugt. Sonst wird die Datei mit diesem Namen umbenannt und der neue Name in dieser Variablen gespeichert.

Das Problem ist, dass sich das Programm verabschiedet (Ohne Fehlermeldung) wenn "if DispFile == "":" ausgeführt wird. Auch bei "print( "DispFile: " + DispFile )" stürzt es ab. Verwende ich eine andere Variable, so funktioniert "print( "DispFile: " + DispFile )", aber mit der anderen Variablen stürzt das Programm dann ab.

Hat jemand eine Erklärung und vielleicht auch eine Lösung?

Grüße von der sonnigen Nordsee

Peter

[sparrow]

Zeig uns in einem nachvollziehbaren Beispiel (also Code und den bitte in Code-Tags) was nicht funktioniert.

[Peter18]

Hallo sparrow,

es ist im Wesentlichen vorhanden, aber gut.

Code: Alles auswählen

def Displayfile():
  NewFilenam = "{:20} \043 {:.2f} Grd C \043 {:.2f}% rel. Feuchte".format( ZeitAn, T, F )

  NewFilenam = NewFilenam.replace( ":", "_" )              # Doppelpunkt mit _ ersetzen
  if DispFile == "":
    print( "DispFile == leer" )
    DispFile  = DatPath + NewFilenam
    LDispFile = DatPath + NewFilenam
    log = file( DispFile, "w" )
    log.close()
  else:
    print( "DispFile: " + DispFile )
    DispFile_  = DatPath + NewFilenam
    os.rename( LDispFile, DispFile_ )
    LDispFile  = DispFile_

"print( "DispFile == leer" )" wird nicht mehr ausgeführt, die andere Druckanweisung auch nicht. Diesen Teil hatte ich in einem anderen Programm im Hauptprogramm, dort wurde es einwandfrei ausgeführt.

Code: Alles auswählen

DispFile   = "" 

steht am Anfang der Datei.

Das läuft auf einem Raspberry 3 unter python2.

Grüße von der noch immer sonnigen Nordsee

Peter

[Jankie]

Wo kommt denn DispFile und DatPath her?

Alle Variablen die eine Funktion benötigt sollte diese als Paramter übergeben bekommen. Man benutzt keine globalen Varaiblen auf Modulebene, außer Konstanten.

Um dir Helfen zu können müsstest du den ganzen Code posten.

Python2 sollte auch nicht mehr genutzt werden.

Variablen werden laut PEP8 Konvention klein_mit_unterstrich geschreiben, außnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (MixedCase), eingerückt wird wird 4 Leerzeichen, nicht 2.

String stückelt man nicht mit + zusammen, man benutzt Stringformatierung bzw. f-Strings. Stringformatierung benutzt du ja weiter oben schon. Für Pfade gibt es das pathlib Modul.

Man benutzt keine Abkürzungen, die Namen sollten eindeutig sein und passend.

LDispFile wird nur im if erzeugt, du benutzt es aber im else.

[Peter18]

hallo Jankie,

Man benutzt keine globalen Varaiblen auf Modulebene, außer Konstanten.

Was soll das heißen? Eine Vorschrift oder eine Konvention?

Da ich mit verschiedenen Sprachen opperiere, habe ich meine eigenen Konventionen!!

Die Konstrukte, die ich hier verwende habe ich aus verschiedenen Anleitungen zusammengesucht, weil ich erst seit kurzem in python programmiere und dort stand nichts von dem, was Du hier schreibst!

Sorry da ist mir in der Eile eine Zeile flöten gegangen:

Code: Alles auswählen

DispFile   = ""                                  # Name der Anzeigedatei
LDispFile  = ""                                  # Letzte Anzeigedate

Das ganze Programm kann ich nicht posten, da ich über Ports andere Komponenten anspreche. Wenn es Probleme mit globalen Variablen gibt wäre das ein Hinweis, weil ich bei anderen Versuchen auch damit Probleme hatte. Ich verwende globale Variablen, da ich keine Informationen bisher gefunden habe, wie Parameter verwendet werden. In Pascal ist das sehr eindeutig geregelt: "Var X" heißt, der Wert kann im Unterprogramm verändert werden und steht geändert im Hauptprogramm zur Verfügung. Ohne "Var" sieht das Hauptprugramm nichts von den Änderungen.

Grüße von der noch immer sonnigen Nordsee

Peter

[sparrow]

@Peter18: Ich kenne keine Programmiersprache, die Funktionen kennt und in der globale Variablen sinnvoll sind. Das gilt auch für Python und insbesondere für dein Programm. Deine eigenen Konventionen führen dich leider in eine Sackgasse, weil hier niemand deinen Code nachvollziehen kann, weil Variablen aus dem magischen Raum kommen.

Funktionen bekommen alles was sie brauchen als Parameter und geben das Ergebnis zurück.
Du hast keine Information darüber gefundene, wie Parameter verwendet werden? Da hilft ein Blick ins Tutorial.

Ich befürchte ja fast, dass du die Funktion schlicht niemals aufrufst.

[Jankie]

Natürlich funktioniert es auch mit globalen Varaiblen, das ist aber sehr fehleranfällig.
Konventionen sind dafür da, damit der Code lesbarer und besser zu warten ist. Wenn du deine eignen Konventionen stur beibehalten willst, dann wird es schwer jemanden zu finden der dir damit helfen kann, weil alles sehr unverständlich geschrieben ist und Variablen mysteriöserweise auf einmal aus dem nichts erscheinen.
Die Python Dokumentation ist ein guter Einstieg und zeigt auch, wie Parameter übergeben werden.
Mit den von dir genannten Infos kann ich dir leider nicht weiterhelfen.
Die Konstrukte, die du hier verwendest sind aber teilweise veraltet oder es gibt bessere Methoden. Viele Python Tutorials sind auch schlichtweg einfach schlecht gemacht. Die offizielle Dokumentation/das offizielle Tutorial ist meiner Meinung nach der beste Weg Python zu lernen.



Hier mal ein Minimalbeispiel, wie Werte von der main() in eine Funktion übergeben werden und das ergebnis zurück in die main() gegeben wird

Code: Alles auswählen

def multiply(multiplikator, multiplikand):
    return multiplikator * multiplikand

def main():
    erste_zahl = 3
    zweite_zahl = 2
    ergebnis = multiply(erste_zahl, zweite_zahl)
    print(ergebnis)

main()

[/me]

Die Konstrukte, die ich hier verwende habe ich aus verschiedenen Anleitungen zusammengesucht, weil ich erst seit kurzem in python programmiere und dort stand nichts von dem, was Du hier schreibst!

Da empfehle ich das Lesen, Verstehen und Beherzigen des offiziellen Style Guide for Python Code. Dort findest du diverse Konventionen an die sich so ziemlich jedes ernstzunehmende Projekt hält. Niemand schreibt dir die Einhaltung des Standards vor, aber du machst dir selbst das Leben leichter, wenn du es tust.

Da ich mit verschiedenen Sprachen opperiere, habe ich meine eigenen Konventionen!!

OK, wenn du nirgendwo im Team arbeitest geht das vielleicht. Es wird aber unpraktisch, wenn du mit deinem Code auf andere Entwickler triffst, die dann Schwierigkeiten beim Lesen haben und natürlich noch mehr Schwierigkeiten, wenn sie dann deinen Code in einer ihnen unbekannten Konvention bearbeiten sollen. Ich verwende einfach in jeder Sprache die für die jeweilige Sprache gültige Konvention. Das geht.

[Peter18]

Hallo sparrow, hallo Jankie, hallo /me,

Dank euch für Eure Antworten!

Ich möchte etwas klarstellen: Ich versuche mich in eine neue Programmierstrache einzuarbeiten. Dabei fange ich nicht bei Konventionen an! Ich forsche in Foren und Tutorials und Datenbanken, wie ich bestimmte Aufgaben lösen kann.

Python verwende ich, weil ich für diese Sprache Treiber für den Zugriff auf Sensoren gefunden habe, mit denen ich Messungen durchführen will. Mir wäre C oder Pascal aber auch Basic lieber gewesen, aber es spricht ja auch nichts dagegen eine neue Sprache zu lernen. So habe ich geforscht, wie ich die eine oder andere Aufgabe mit Python lösen kann. Das Programm ist gewachsen und nun habe ich ein Problem!

sparrow, ob globale Variablen Sinn machen hängt wohl kaum von der Programmiersprache ab, als von der Aufgabe! Meine Funktion wird aufgerufen, was ein Printanweisung bestätigt hat (Immer der erste Versuch!!!)! Mit Parametern kann ich umgehen, aber wenn es viele sind, wird es unübersichtlich. Call by reference und call by value habe ich nicht gefunden!!

Natürlich funktioniert es auch mit globalen Varaiblen, das ist aber sehr fehleranfällig.

Mit dieser Antwort kann ich etwas anfangen! Wenn das nicht zuverlässig funktioniert, muß ich mir etwas anderes überlegen!

Die Konstrukte, die du hier verwendest sind aber teilweise veraltet oder es gibt bessere Methoden.

Da wäre ein Tipp hilfreich! Denn das was ich verwende, habe ich in Tutorials oder Datenbänken gefunden!

Ich habe die Funktion oben beschrieben! Damit sollte unabhängig von Konventionen zu verstehen sein, was die Funktion machen soll. Bei dem Umfang sollte das auf jeden Fall nachvollzihbar sein. Ich bin mit Python am Anfang und möchte über mein Problem, auf das ich gestoßen bin, diskutieren aber nicht über Sinn und Unsinn von globalen Variablen oder Konventionen. Wenn globale Variablen unsicher sind, ist die Information hilfreich und ich kann nach anderen Lösungen suchen. Wenn jemand einen Tipp für ein andere Lösung hat hilft das auch, nein, es ist sogar noch besser!

Grüße von der wieder sonnigen Nordsee

Peter

[sparrow]

@Peter18: Globale Variablen sind in einer Programmiersprache, die Funktionen kennt, zu 99% falsch. Deine "Aufgabe" gehört nicht zu den 1%.

Es geht nicht um Konventionen. Es geht darum, dass niemand deinen Code ausprobieren kann, weil da auf magische Weise Werte auftauchen, die wir nicht kennen. Da es gerade zu einem klimabedingten starken Rauschen im präkognitiven Hellsehnetzwerk kommt, weiß niemand welche Werte du da versteckst. Deshalb kann niemand deinen Code ausprobieren - ergo kann dir auch niemand helfen.
Die Namen deiner Variablen sind leider so wenig aussagend wie die deiner Funktion. Deshalb weiß man auch leider nicht, was du da tust und was DispFile, DispFile_ und LDispFile sein sollen.

Ich habe doch oben schon geschrieben: Der Fehler ist, dass du die Funktion nicht aufrust.
Und ich frage dich, wie bereits in meiner ersten Antwort zu deinem Problem: Zeig uns einen Code, der das von dir beschriebene Problem zeigt. Und zwar Code, den wir auch ausführen können.

Wenn du das nicht kannst oder nicht willst, bleibt dir nichts anderes übrig als entweder den Code solange zu kürzen, bis du den Fehler identifiziert hast - oder von Grund auf neu zu schreiben, bis der Fehler auftritt und du ihn so entdeckst. Aber so kann dir halt niemand helfen, weil das Problem offensichtlich in den Teilen steckt, die du nicht zeigst.

Wenn man alle unwesentlichen Sachen entfernt und es ein bisschen hübsch macht, dann kommt in etwa der folgende Code heraus.
Wenn du den nun erweiterst - und zwar ohne globale Variablen - und das Problem wieder auftritt, dann sag doch, was man der Funktion als old_path übergeben muss, damit das von dir beschriebene Problem auftritt.

Code: Alles auswählen

def generate_filepath(zeit_an, temperatur, feuchte, old_path):
    new_filename = f"{zeit_an:20} # {temperatur:.2f} Grad C # {feuchte:.2f}% rel. Feuchte"
    print(f"new_filename: {new_filename}"
    if not old_path:
        print("es gibt keinen alten Pfad")
    else:
        print(f"der alte pfad war: {old_path}")


def main():
    generate_filepath("Jetzt", 15.12, 64.2, "")


if __name__ == "__main__":
    main()

[snafu]

Da im if- und im else-Teil die print()-Funktion aufgerufen wird, muss etwas auf dem Bildschirm landen, zumindest sofern die Ausgabe nicht woanders hingeleitet wird. Du schreibst, dass die Funktion auf jeden Fall betreten wird, weil es dir ein vorheriges print() innerhalb der Funktion bestätigt. Demnach landen Ausgaben ja offensichtlich ohne Umleitung auf dem Bildschirm. Dennoch führt dein Programm laut eigener Aussage diesen Teil scheinbar nicht aus, spuckt aber auch keinen Traceback (Fehlermeldung) aus.

An der Stelle kann man einfach nicht weiterhelfen, ohne weitere Details zu kennen. Was du beschreibst, müsste so funktionieren. Die Fehlerursache ist etwas, was du bewusst oder unbewusst auslässt. Entweder weil dein tatsächlicher Code eben doch an einem wesentlichen Punkt anders ist als gezeigt, oder weil deine Entwicklungsumgebung irgendwie dazwischen funkt. Nutzt du denn beim Ausführen das Python-Kommando direkt oder läuft es über eine IDE?

[Jankie]

Zu dem Tipp der dir hilfreich wäre wurde dir schon oft die offizielle Dokumentation bzw. das Grundlagentutorial empfohlen. Wenn ich eine Sprache lernen, dann arbeite ich erst einmal ein Grundlagentutorial durch.

Du hast die Funktions uns hier reinkopiert, aber keiner von uns weiß was DispFile ist oder was für ein Wert darin steckt oder ob und wann und wo die Funktion aufgerufen wird. Bei DatPath kann man sich ja noch denken dass es ein Pfad ist, da wäre aber datei_path oder file_path einfach verständlicher. Auch dazu habe ich dir schon ein hilfreichen Tipp gegeben welches Modul für Pfade empfehlenswert ist.

[__blackjack__]

@Peter18: Das ist keine Frage der Reihenfolge. Sprache und Konventionen gehören zusammen und die sollte man deshalb auch zusammen lernen wenn man tatsächlich in der Sprache programmieren will und nicht in Sprache X so wie in Sprache Y die man bereits kennt. Eine Sprache lernen heisst auch idiomatischen Code in dieser Sprache zu schreiben und den Konventionen zu folgen. Wenn man versucht so wie in einer anderen Sprache zu programmieren, wird man mindestens ein einigen Stellen dann gegen die Sprache programmieren und nicht mit ihr.

Ob globale Variablen Sinn machen hängt insofern von der Programmiersprache ab ob die Sprache es leicht ermöglicht die zu vermeiden. Falls ja, sind die nicht gut. Falls nein, ist die Sprache doof, aber es geht dann halt nicht anders.

Was allerdings davon unabhängig ist, ist das globale Variablen Code fehleranfälliger machen, unter anderem weil durch Kopplung schwerer verständlich und schlechter testbar. Das gilt ja auch für C und Pascal und für die BASIC-Dialekte bei denen man globale Variablen vermeiden kann. Bei C und Pascal werden Übersetzungseinheiten/Units öfter mal als Singletons gesehen, da sieht man dann auch globale Variablen, aber bei Python macht man das nicht weil das Mittel dafür die Klasse ist, auch wenn man nur ein Exemplar davon braucht.

Python kennt nur eine Art der Parameterübergabe: „call by sharing“. Sowohl Aufrufer als auch Aufgerufener teilen sich den Zugriff auf das *selbe* Objekt.

Warum steht das "#" eigentlich als oktale Escapesequenz "\043" in der Zeichenkette?

Deine Funktion könnte so ähnlich wie die im folgenden Code aussehen, und das würde sie letztlich auch in C oder Pascal. Selbst wenn man da den aktuellen Pfad in einer globalen Variable speichern würde, hätte man da nicht zwei globale Variablen.

Code: Alles auswählen

#!/usr/bin/env python3
from pathlib import Path

DATA_PATH = Path("...")


def display_file(display_file_path, time_on, temperature, humidity):
    filename = (
        f"{time_on:20} #"
        f" {temperature:.2f} Grd C #"
        f" {humidity:.2f}% rel. Feuchte"
    )
    new_display_file_path = DATA_PATH / filename.replace(":", "_")

    print(
        "old display file name ==",
        display_file_path.name if display_file_path else "leer",
    )
    print(f"new display file name: {new_display_file_path.name}")
    if display_file_path:
        display_file_path.rename(new_display_file_path)
    else:
        new_display_file_path.touch()

    return new_display_file_path


def main():
    display_file_path = None

    ...

    display_file_path = display_file(
        display_file_path, time_on, temperature, humidity
    )


if __name__ == "__main__":
    main()

[__blackjack__]

In C würde das genau so aussehen. Man hat halt zusätzlich die manuelle Speicherverwaltung. Und keine Fehlerbehandlung wenn man sie nicht selbst schreibt.

Code: Alles auswählen

#include <glib.h>
#include <glib/gstdio.h>

static const gchar *DATA_PATH = ".";

gchar* display_file(
    gchar *old_path, GDateTime *time_on, gdouble temperature, gdouble humidity
) {
    gchar *date_part = g_date_time_format(time_on, "%Y-%m-%d %H_%M_%S");
    gchar *new_filename = g_strdup_printf(
        "%s # %.2f Grd C # %.2f rel. Feuchte", date_part, temperature, humidity
    );
    g_free(date_part);
    gchar *new_path = g_build_filename(DATA_PATH, new_filename, NULL);
    
    if (old_path == NULL) {
        fclose(g_fopen(new_path, "wb"));
    } else {
        g_rename(old_path, new_path);
    }
    g_free(new_filename);
    
    return new_path;
}

int main(void)
{
    gchar *display_file_path = NULL;
    
    // ...
    
    GDateTime *time_on = g_date_time_new_now_local();
    gchar *tmp = display_file_path;
    display_file_path = display_file(display_file_path, time_on, 23.42, 47.11);
    g_free(tmp);
    g_date_time_unref(time_on);
    
    g_free(display_file_path);
    return 0;
}

[Peter18]

Hallo an alle,

dies ist mein letzter Beitrag in diesem Thread! Nach meinem Verständnis ist ein Forum dieser Art dazu da, jemandem der ein Problem hat, zu helfen dieses Problem zu lösen und nicht zur Selbstdarstellung (wer hat die meisten Beiträge geliefert)! Wäre ich Anfänger beim Programmieren, wäre mein Problem noch nicht gelöst! Denn die Diskussion sollte sich um das Problem drehen und nicht um die Sreibweise! Die Micky Maus-Routine, die ich oben vorgestellt habe, sollte jeder verstehen können, der programmieren kann, zumal die Funktion auch noch beschrieben wurde! Das ist ja anscheinend auch einigen gelungen. Sie haben es ja fertig gebracht sie in die "richtige" Form zu bringen. Aber löst das mein Problem???

Auch die Diskussion über Sprachelemente hilft nicht weiter! Es sind noch immer Elemente wie Break, Exit oder Goto selbst in modernen Sprachen vorhanden und werden in Beispielen und Tutorien verwendet! Aber löst das mein Problem???

Spekulationen ob die Routine aufgerufen wird sind ungemein hilfreich!!!!!! Woher weiß ich wohl, das das Programm genau an der Stelle abstürzt????????????

Offenbar handelte es sich um einen Compiler-/Interpreterfehler der bei globalen Stringvariablen auftritt. Compiler-/Interpreterfehler weil ein angebotenes Sprachelement auch funktionieren sollte!

Inzwischen habe ich einen work around gefunden, der mein Problem gelöst hat. Hat nur etwas mit dem Testen gedauert weil mein Programm manche Zustände erst nach Tagen erreicht.

Peter

[sparrow]

Hallo Peter,

so wie ich das sehe, haben hier eine Handvoll Leute ihre Freizeit damit verbracht, dein Problem zu lösen, inklusive Lösungsansätzen und sehr konkreten Aussagen, dass das von dir beschriebene Probleme so nicht auftreten kann. Bemühungen von dir, das Problem zu lösen, kann ich aber nirgends sehen. Natürlich kanst du jetzt den bösen Menschen die Schuld geben, die dir helfen wollen - ich würde hingegen tief durchatmen und den Thread noch einmal lesen und mich wundern, warum so viele erfahrene Leute sagen, dass das so nicht sein kann.

Viel Glück weiterhin.

[__deets__]

Offenbar handelte es sich um einen Compiler-/Interpreterfehler der bei globalen Stringvariablen auftritt. Compiler-/Interpreterfehler weil ein angebotenes Sprachelement auch funktionieren sollte!

Bullshit. Es gibt kein anderes Verhalten des Interpreters bei Strings abhaengig von ihrem Scope. Du hast dich einfach nur in deinem globalen Zustand verheddert. Den zu verwenden ein schlechte Idee genau aus diesem Grund ist. Was dir auch mitgeteilt wurde, aber dank deiner Borniertheit kannst du solche Hinweise nicht ernst nehmen, sondern lamentierst rum, dass dir nicht geholfen worden waere.

Wenn jemand fragt, ob ein Seil stark genug ist, sich damit zu erhaengen, dann gibt es Leute, die ihm das versuchen auszureden. Und das ist auch richtig so. Andere fragen, wieviel er wiegt, und wie weit runter er springen will, bis es knack macht. Du gehoerst offensichtlich zu denen.

[Sirius3]

@Peter18: Schön, dass Du das Problem jetzt selber lösen konntest. Du warst nicht in der Lage, ein Programmbeispiel zu posten, das den Fehler zeigt. Das liegt wahrscheinlich daran, dass der Fehler an einer ganz anderen Stelle auftritt, was Du aber nicht nachvollziehen kannst, weil Du globale Variablen benutzt. Im allgemeinen ist der Python-Interpreter fehlerfrei, Du machst also etwas, das an irgend einer anderen Stelle im Programm Python durcheinander bringt.
Da Du also nicht in der Lage warst, das Problem nachvollziehbar zu schildern, bleiben nur allgemeine Anmerkungen: benutze keine globalen Variablen. Dann wäre nämlich der Fehler wahrscheinlich dort aufgetreten, wo er wirklich passiert.

Viel Spaß bis zum nächsten unerklärlichen Fehler.

[/me]

Offenbar handelte es sich um einen Compiler-/Interpreterfehler der bei globalen Stringvariablen auftritt. Compiler-/Interpreterfehler weil ein angebotenes Sprachelement auch funktionieren sollte!

Ich glaube eher nicht an einen Fehler in Python. Du hast nie einen Code gezeigt, der für uns reproduzierbar diesen Fehler erzeugt. Warum eigentlich nicht? Zudem gehe ich davon aus, dass ein Fehler dieser Art längst einem anderen Entwickler aufgefallen wäre und ein entsprechender Bug-Eintrag existieren würde.

Du schreibst u.a. mit Hinweis auf "eigene Konventionen" bewusst Code, den dir jeder halbwegs erfahrene Coder um die Ohren hauen würde, verstehst dann das Ergebnis nicht, möchtest aber nichts ändern weil du dir dann einen eigenen Fehler eingestehen müsstest. Auf Dauer hilft es dir in deiner persönlichen Entwicklung als Softwareentwickler nicht weiter, wenn du kategorisch davon ausgehst, dass du keinen Fehler gemacht hast und somit zwangsläufig irgendetwas anderes (Laufzeitumgebung, OS, ...) schuld sein muss. Aber gut, ich predige hier vermutlich ohnehin nur tauben Ohren.

[DeaD_EyE]

Ich versuche mich in eine neue Programmierstrache einzuarbeiten. Dabei fange ich nicht bei Konventionen an!

Etwas falsch gelerntes wieder loszuwerden, ist gar nicht so einfach.