Globale Variablen

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
Hellstern
User
Beiträge: 13
Registriert: Mittwoch 4. Januar 2023, 08:14

Hallo zusammen
Ich lese über eine Funktion 6 Variablen aus einem Konfigurations-File und speichere diese in der Funktion als lokale Variablen.
Diese Variablen benötige ich in anderen Funktionen, also müssten diese Global sein.
Jetzt habe ich gelesen, dass Globale Variablen schlechter Programmierstil sei.
Wie kann man das denn anders lösen?

Gruss
Thomas
Nach oben
Benutzeravatar
Dennis89
User
Beiträge: 1169
Registriert: Freitag 11. Dezember 2020, 15:13

Hallo,

mit `return` können Funktionen "etwas" zurück geben, in dem Fall deine Variablen.

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
Nach oben
Hellstern
User
Beiträge: 13
Registriert: Mittwoch 4. Januar 2023, 08:14

Return funktioniert aber nur für 1 Variable, ich habe aber 6 Variablen
Nach oben
Benutzeravatar
__blackjack__
User
Beiträge: 13135
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:
Kontaktdaten von __blackjack__

@Hellstern: ``return`` funktioniert nur für einen *Wert*, der kann aber eine Datenstruktur oder ein Objekt mit Attributen sein.
“There will always be things we wish to say in our programs that in all known languages can only be said poorly.” — Alan J. Perlis
Nach oben
Hellstern
User
Beiträge: 13
Registriert: Mittwoch 4. Januar 2023, 08:14

Vielen Dank

Vor lauter Bäumen sieht man manchmal den Wald nicht

Gruss
Thomas
Nach oben
oldboyJR
User
Beiträge: 33
Registriert: Donnerstag 28. März 2024, 16:19

zum schreiben

Code: Alles auswählen

# -*- coding: iso-8859-1 -*-
#!/usr/bin/env python

#Schreibt ein dict in eine Datei .bin
import pickle
from pathlib import Path
# Schreiben

s = {"Wert1": "dat1",
     "Wert2": "dat2",
     "Wert3": "dat3",
     "Wert4": "dat4",
     "Wert5": "dat5",
     "Wert6": "dat6"
     }
print(s)
a = 50 # diese Zeile habe ich eingefügt um zu zeigen das man einen Wert aus dem Programm
s["Wert1"] = str(a)#in einen Wert eines dict überführen kann
print(s)
path = Path.home() / "ad.bin"
with path.open("wb") as f:
    pickle.dump(s, f)
    f.close()
zum lesen

Code: Alles auswählen

# -*- coding: iso-8859-1 -*-
#!/usr/bin/env python
"""
Created on Wed Apr 24 12:43:45 2024

@author: GBT B650M GamingX AX
"""
import pickle

from pathlib import Path

path = Path.home() / "ad.bin"
with path.open("rb") as f:
    s = pickle.load(f)
    print(s)
    print(s['Wert1'])
die Import können am Anfang deines Programms stehen
wenn man z.B. ein Programm schreibt und möchte das eine def ff(): hast du nach diesem Eintrag keinen zugriff auf die zuvor erzeugten werte mit der lesefunktion direkt danach hast du die werte in diesem Teil. Neue werte innerhalb dieses teils mit der schreibefunktion geschrieben werden sind überall lesbar weil es ein globaler Text ist der nicht schaden kann.
Nach oben
Benutzeravatar
sparrow
User
Beiträge: 4202
Registriert: Freitag 17. April 2009, 10:28

Eine Konfigurationsdatei mit Pickle zu schreiben ist ein bisschen unmständich.
Pickle serialisiert ein Python Objekt und kann es hinterher wieder laden. Die Daten in der Datei sind aber nicht von Menschen lesbar. Das ist ja aber, was man als Konfigurationsdatei haben möchte.

Hier bieten sich eher Formate wie JSON an oder das Modul configparser.
Nach oben
oldboyJR
User
Beiträge: 33
Registriert: Donnerstag 28. März 2024, 16:19

PS: Meine feststellung in allen Programmiersprachen ist es das selbe Problem. Man denkt innerhalb eines Progamms sind alle Variablen überall greifbar. Das ist es aber nicht. Auch die class mit setter und getter führten zu keinem Ergebnis wenn sie nicht in eine Oberfläche sprich Felder und Co. zwischengespeichert wurden und aus denen man sie dann zurück lesen kann. WXgladde ist zum Beispiel eigendlich eine gute Sache es gibt auch ein schönes Deutsches Tutorial mit dem Fußweg zur Programmierung. Die NUmmer 002 finde empfinde ich als besonders leerreich. Und den Fußweg für Visual Studeo finde ich ebenfalls nachahmungswert. Ich lade solche Videos gerne mit 4kVideo herunter weil man sie dann anschließend in einem Videoplayer aufrufen und die Schritte jeweils anhalten kann.

https://www.youtube.com/playlist?list=P ... 6DNIhGufC0
Nach oben
Benutzeravatar
__blackjack__
User
Beiträge: 13135
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:
Kontaktdaten von __blackjack__

@oldboyJR: Nee das ist nicht in allen Programmiersprachen das selbe Problem. Es gibt auch welche die haben tatsächlich nur *einen* Namensraum. *Das* ist tatsächlich schnell ein Problem. 🙂

Was Du mit der Klasse und Getter und Setter sagen willst, ist mir nicht so wirklich klar. Mal davon abgesehen dass so etwas in Python für triviale Getter und Setter unüblich ist, und für nicht-triviales `property()` existiert, ist das Wort „Oberfläche“ hier ziemlich sicher falsch.

Ich lade Videos auch gerne runter um sie dann in Ruhe mit Kodi auf dem ”Fernseher” laufen zu lassen. Dazu benutze ich yt-dlp. OpenSource und in einer ganz tollen Programmiersprache geschrieben. 😇
“There will always be things we wish to say in our programs that in all known languages can only be said poorly.” — Alan J. Perlis
Nach oben
oldboyJR
User
Beiträge: 33
Registriert: Donnerstag 28. März 2024, 16:19

Ich mag es wenn man eine Fensteroberfläche hat und dort seine verschiedenen Werte einträgt anstatt sie in die shell zu kloppen. Dann kann man einfacher andere werte eingeben und testen. Meine Testumgebung sieht folgender Weise aus:

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
#
# generated by wxGlade 1.0.5 on Sat Apr 27 18:01:14 2024
#

import wx
import pickle
from pathlib import Path
# begin wxGlade: dependencies
# end wxGlade

# begin wxGlade: extracode
# end wxGlade
s = {"Wert1": "dat1",
     "Wert2": "dat2",
     "Wert3": "dat3",
     "Wert4": "dat4",
     "Wert5": "dat5",
     "Wert6": "dat6",
     "Wert7": "dat7",
     "Wert8": "dat8",
    "Wert9": "dat9",
    "Wert10": "dat10",
    "Wert11": "dat11",
    "Wert12": "dat12",
    "Wert13": "dat1",
     "Wert14": "dat2",
     "Wert15": "dat3",
     "Wert16": "dat4",
     "Wert17": "dat5",
     "Wert18": "dat6",
     "Wert19": "dat7",
     "Wert20": "dat8",
    "Wert21": "dat9",
    "Wert22": "dat10",
    "Wert23": "dat11",
    "Wert24": "dat12",
     }
s1=[]
path = Path.home() / "ad.bin"
with path.open("wb") as f:
     pickle.dump(s, f)
     f.close()

class MyFrame(wx.Frame):
    import wx
    import pickle
    from pathlib import Path
    s =  {"Wert1": "dat1",
         "Wert2": "dat2",
         "Wert3": "dat3",
         "Wert4": "dat4",
         "Wert5": "dat5",
         "Wert6": "dat6",
         "Wert7": "dat7",
         "Wert8": "dat8",
        "Wert9": "dat9",
        "Wert10": "dat10",
        "Wert11": "dat11",
        "Wert12": "dat12",
        "Wert13": "dat1",
         "Wert14": "dat2",
         "Wert15": "dat3",
         "Wert16": "dat4",
         "Wert17": "dat5",
         "Wert18": "dat6",
         "Wert19": "dat7",
         "Wert20": "dat8",
        "Wert21": "dat9",
        "Wert22": "dat10",
        "Wert23": "dat11",
        "Wert24": "dat12",
         }
    s1=[]
    path = Path.home() / "ad.bin"
    with path.open("wb") as f:
        pickle.dump(s, f)
        f.close()
    
    def __init__(self, *args, **kwds):
        # begin wxGlade: MyFrame.__init__
        kwds["style"] = kwds.get("style", 0) | wx.DEFAULT_FRAME_STYLE
        wx.Frame.__init__(self, *args, **kwds)
        self.SetSize((828, 547))
        self.SetTitle("frame")

        # Menu Bar
        self.frame_menubar = wx.MenuBar()
        wxglade_tmp_menu = wx.Menu()
        item = wxglade_tmp_menu.Append(wx.ID_ANY, "Show Dialog", "")
        self.Bind(wx.EVT_MENU, self.show_modal, item)
        self.frame_menubar.Append(wxglade_tmp_menu, "Menu")
        self.SetMenuBar(self.frame_menubar)
        # Menu Bar end

        self.panel_1 = wx.Panel(self, wx.ID_ANY)

        sizer_1 = wx.BoxSizer(wx.VERTICAL)

        sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_1.Add(sizer_2, 1, wx.EXPAND, 0)

        self.text_ctrl_1 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "texo2")
        self.text_ctrl_1.SetMinSize((110, 23))
        sizer_2.Add(self.text_ctrl_1, 0, 0, 0)

        self.text_ctrl_2 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_2.SetMinSize((113, 23))
        sizer_2.Add(self.text_ctrl_2, 0, 0, 0)

        self.text_ctrl_3 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_3.SetMinSize((113, 23))
        sizer_2.Add(self.text_ctrl_3, 0, 0, 0)

        self.text_ctrl_4 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_4.SetMinSize((113, 23))
        sizer_2.Add(self.text_ctrl_4, 0, 0, 0)

        sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_1.Add(sizer_3, 1, wx.EXPAND, 0)

        self.text_ctrl_5 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_5.SetMinSize((113, 23))
        sizer_3.Add(self.text_ctrl_5, 0, 0, 0)

        self.text_ctrl_6 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_6.SetMinSize((110, 23))
        sizer_3.Add(self.text_ctrl_6, 0, 0, 0)

        self.text_ctrl_7 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_7.SetMinSize((113, 23))
        sizer_3.Add(self.text_ctrl_7, 0, 0, 0)

        self.text_ctrl_8 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_8.SetMinSize((110, 23))
        sizer_3.Add(self.text_ctrl_8, 0, 0, 0)

        sizer_4 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_1.Add(sizer_4, 1, wx.EXPAND, 0)

        self.text_ctrl_9 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_9.SetMinSize((110, 23))
        sizer_4.Add(self.text_ctrl_9, 0, 0, 0)

        self.text_ctrl_10 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_10.SetMinSize((110, 23))
        sizer_4.Add(self.text_ctrl_10, 0, 0, 0)

        self.text_ctrl_11 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_11.SetMinSize((110, 23))
        sizer_4.Add(self.text_ctrl_11, 0, 0, 0)

        self.text_ctrl_12 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "" )
        self.text_ctrl_12.SetMinSize((113, 23))
        sizer_4.Add(self.text_ctrl_12, 0, 0, 0)

        sizer_5 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_1.Add(sizer_5, 1, wx.EXPAND, 0)

        self.text_ctrl_13 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_13.SetMinSize((110, 23))
        sizer_5.Add(self.text_ctrl_13, 0, 0, 0)

        self.text_ctrl_14 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_14.SetMinSize((110, 23))
        sizer_5.Add(self.text_ctrl_14, 0, 0, 0)

        self.text_ctrl_15 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_15.SetMinSize((110, 23))
        sizer_5.Add(self.text_ctrl_15, 0, 0, 0)

        self.text_ctrl_16 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_16.SetMinSize((110, 23))
        sizer_5.Add(self.text_ctrl_16, 0, 0, 0)

        sizer_6 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_1.Add(sizer_6, 1, wx.EXPAND, 0)

        self.choice_1 = wx.Choice(
            self.panel_1, wx.ID_ANY, choices=["choice 1"])
        self.choice_1.SetMinSize((100, 55))
        self.choice_1.SetSelection(0)
        sizer_6.Add(self.choice_1, 0, 0, 0)

        self.combo_box_1 = wx.ComboBox(
            self.panel_1, wx.ID_ANY, choices=[], style=wx.CB_DROPDOWN)
        self.combo_box_1.SetMinSize((111, 55))
        sizer_6.Add(self.combo_box_1, 0, 0, 0)

        self.list_box_1 = wx.ListBox(
            self.panel_1, wx.ID_ANY, choices=["choice 1"])
        self.list_box_1.SetMinSize((100, 55))
        sizer_6.Add(self.list_box_1, 0, 0, 0)

        self.check_list_box_1 = wx.CheckListBox(
            self.panel_1, wx.ID_ANY, choices=["choice 1"])
        self.check_list_box_1.SetMinSize((101, 55))
        sizer_6.Add(self.check_list_box_1, 0, 0, 0)

        sizer_7 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_1.Add(sizer_7, 1, wx.EXPAND, 0)

        self.button_2 = wx.Button(self.panel_1, wx.ID_ANY, "button_2")
        self.button_2.SetMinSize((100, 32))
        sizer_7.Add(self.button_2, 0, 0, 0)

        self.button_3 = wx.Button(self.panel_1, wx.ID_ANY, "button_3")
        self.button_3.SetMinSize((100, 32))
        sizer_7.Add(self.button_3, 0, 0, 0)

        self.button_4 = wx.Button(self.panel_1, wx.ID_ANY, "button_4")
        self.button_4.SetMinSize((100, 32))
        sizer_7.Add(self.button_4, 0, 0, 0)

        self.button_5 = wx.Button(self.panel_1, wx.ID_ANY, "button_5")
        self.button_5.SetMinSize((100, 32))
        sizer_7.Add(self.button_5, 0, 0, 0)

        sizer_8 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_1.Add(sizer_8, 1, wx.EXPAND, 0)

        self.button_1 = wx.Button(self.panel_1, wx.ID_ANY, "button_1")
        self.button_1.SetMinSize((800, 20))
        sizer_8.Add(self.button_1, 0, 0, 0)

        sizer_9 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_1.Add(sizer_9, 1, wx.EXPAND, 0)

        self.text_ctrl_24 = wx.TextCtrl(self.panel_1, wx.ID_ANY, "")
        self.text_ctrl_24.SetMinSize((800, 200))
        sizer_9.Add(self.text_ctrl_24, 0, 0, 0)

        self.panel_1.SetSizer(sizer_1)

        self.Layout()

        self.Bind(wx.EVT_TEXT, self.aa, self.text_ctrl_1)
        self.Bind(wx.EVT_TEXT_ENTER, self.aat, self.text_ctrl_1)
        self.Bind(wx.EVT_TEXT, self.bb, self.text_ctrl_2)
        self.Bind(wx.EVT_TEXT_ENTER, self.bt, self.text_ctrl_2)
        self.Bind(wx.EVT_TEXT, self.cc, self.text_ctrl_3)
        self.Bind(wx.EVT_TEXT_ENTER, self.cct, self.text_ctrl_3)
        self.Bind(wx.EVT_TEXT, self.dd, self.text_ctrl_4)
        self.Bind(wx.EVT_TEXT_ENTER, self.ddt, self.text_ctrl_4)
        self.Bind(wx.EVT_TEXT, self.ee, self.text_ctrl_5)
        self.Bind(wx.EVT_TEXT_ENTER, self.eet, self.text_ctrl_5)
        self.Bind(wx.EVT_TEXT, self.ff, self.text_ctrl_6)
        self.Bind(wx.EVT_TEXT_ENTER, self.fft, self.text_ctrl_6)
        self.Bind(wx.EVT_TEXT, self.gg, self.text_ctrl_7)
        self.Bind(wx.EVT_TEXT_ENTER, self.ggt, self.text_ctrl_7)
        self.Bind(wx.EVT_TEXT, self.hh, self.text_ctrl_8)
        self.Bind(wx.EVT_TEXT_ENTER, self.hht, self.text_ctrl_8)
        self.Bind(wx.EVT_TEXT, self.ii, self.text_ctrl_9)
        self.Bind(wx.EVT_TEXT_ENTER, self.iit, self.text_ctrl_9)
        self.Bind(wx.EVT_TEXT, self.jj, self.text_ctrl_10)
        self.Bind(wx.EVT_TEXT_ENTER, self.jjt, self.text_ctrl_10)
        self.Bind(wx.EVT_TEXT, self.kk, self.text_ctrl_11)
        self.Bind(wx.EVT_TEXT_ENTER, self.kkt, self.text_ctrl_11)
        self.Bind(wx.EVT_TEXT, self.ll, self.text_ctrl_12)
        self.Bind(wx.EVT_TEXT_ENTER, self.llt, self.text_ctrl_12)
        self.Bind(wx.EVT_TEXT, self.mm, self.text_ctrl_13)
        self.Bind(wx.EVT_TEXT_ENTER, self.mmt, self.text_ctrl_13)
        self.Bind(wx.EVT_TEXT, self.nn, self.text_ctrl_14)
        self.Bind(wx.EVT_TEXT_ENTER, self.nnt, self.text_ctrl_14)
        self.Bind(wx.EVT_TEXT, self.oo, self.text_ctrl_15)
        self.Bind(wx.EVT_TEXT_ENTER, self.oot, self.text_ctrl_15)
        self.Bind(wx.EVT_TEXT, self.pp, self.text_ctrl_16)
        self.Bind(wx.EVT_TEXT_ENTER, self.ppt, self.text_ctrl_16)
        self.Bind(wx.EVT_CHOICE, self.choi1, self.choice_1)
        self.Bind(wx.EVT_COMBOBOX, self.comb_01, self.combo_box_1)
        self.Bind(wx.EVT_TEXT, self.combt01, self.combo_box_1)
        self.Bind(wx.EVT_TEXT_ENTER, self.comge01, self.combo_box_1)
        self.Bind(wx.EVT_LISTBOX, self.list_b01, self.list_box_1)
        self.Bind(wx.EVT_LISTBOX_DCLICK, self.listbcl_01, self.list_box_1)
        self.Bind(wx.EVT_CHECKLISTBOX, self.cheb_01, self.check_list_box_1)
        self.Bind(wx.EVT_BUTTON, self.but02, self.button_2)
        self.Bind(wx.EVT_BUTTON, self.but03, self.button_3)
        self.Bind(wx.EVT_BUTTON, self.but04, self.button_4)
        self.Bind(wx.EVT_BUTTON, self.but5, self.button_5)
        self.Bind(wx.EVT_BUTTON, self.bot_001, self.button_1)
        self.Bind(wx.EVT_TEXT, self.tex_001, self.text_ctrl_24)
        # end wxGlade

    def show_modal(self, event):  # wxGlade: MyFrame.<event_handler>
        print("Event handler 'show_modal' not implemented!")
        event.Skip()

    def aa(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_1.GetValue())
        s['Wert1'] = str(myInfrom )
        mySave()
        
        event.Skip()
        

    def aat(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_1.GetValue())
        s['Wert1'] = str(myInfrom)
        mySave()
        event.Skip()

    def bb(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_2.GetValue())
        s['Wert2'] = str(myInfrom)
        mySave()
        event.Skip()

    def bt(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_2.GetValue())
        s['Wert2'] = str(myInfrom)
        mySave()
        event.Skip()

    def cc(self, event):  # wxGlade: MyFrame.<event_handler>
       myload()
       myInfrom = (self.text_ctrl_3.GetValue())
       s['Wert3'] = str(myInfrom)
       mySave()
       event.Skip()

    def cct(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_3.GetValue())
        s['Wert3'] = str(myInfrom)
        mySave()
        event.Skip()

    def dd(self, event):# wxGlade: MyFrame.<event_handler>
        
        myload()
        myInfrom = (self.text_ctrl_4.GetValue())
        s['Wert4'] = str(myInfrom)
        mySave()
        event.Skip()

    def ddt(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_4.GetValue())
        s['Wert4'] = str(myInfrom)
        mySave()
        event.Skip()

    def ee(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_5.GetValue())
        s['Wert5'] = str(myInfrom)
        mySave()
        event.Skip()

    def eet(self, event):  # wxGlade: MyFrame.<event_handler>
       myload()
       myInfrom = (self.text_ctrl_5.GetValue())
       s['Wert5'] = str(myInfrom)
       mySave()
       event.Skip()

    def ff(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_6.GetValue())
        s['Wert6'] = str(myInfrom)
        mySave()
        event.Skip()

    def fft(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_6.GetValue())
        s['Wert6'] = str(myInfrom)
        mySave()
        event.Skip()

    def gg(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_7.GetValue())
        s['Wert7'] = str(myInfrom)
        mySave()
        event.Skip()

    def ggt(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_7.GetValue())
        s['Wert7'] = str(myInfrom)
        mySave()
        event.Skip()

    def hh(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_8.GetValue())
        s['Wert8'] = str(myInfrom)
        mySave()
        event.Skip()

    def hht(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_8.GetValue())
        s['Wert8'] = str(myInfrom)
        mySave()
        event.Skip()

    def ii(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_9.GetValue())
        s['Wert9'] = str(myInfrom)
        mySave()
        event.Skip()

    def iit(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_9.GetValue())
        s['Wert9'] = str(myInfrom)
        mySave()
        event.Skip()

    def jj(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_10.GetValue())
        s['Wert10'] = str(myInfrom)
        mySave()
        event.Skip()

    def jjt(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_10.GetValue())
        s['Wert10'] = str(myInfrom)
        mySave()
        event.Skip()

    def kk(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_11.GetValue())
        s['Wert11'] = str(myInfrom)
        mySave()
        event.Skip()

    def kkt(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_11.GetValue())
        s['Wert11'] = str(myInfrom)
        mySave()
        event.Skip()

    def ll(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_12.GetValue())
        s['Wert12'] = str(myInfrom)
        mySave()
        event.Skip()

    def llt(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_12.GetValue())
        s['Wert12'] = str(myInfrom)
        mySave()
        event.Skip()

    def mm(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_13.GetValue())
        s['Wert13'] = str(myInfrom)
        mySave()
        event.Skip()

    def mmt(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_13.GetValue())
        s['Wert13'] = str(myInfrom)
        mySave()
        event.Skip()

    def nn(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_14.GetValue())
        s['Wert14'] = str(myInfrom)
        mySave()
        event.Skip()

    def nnt(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_14.GetValue())
        s['Wert14'] = str(myInfrom)
        mySave()
        event.Skip()

    def oo(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_15.GetValue())
        s['Wert15'] = str(myInfrom)
        mySave()
        event.Skip()

    def oot(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_15.GetValue())
        s['Wert15'] = str(myInfrom)
        mySave()
        event.Skip()

    def pp(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_16.GetValue())
        s['Wert16'] = str(myInfrom)
        mySave()
        event.Skip()

    def ppt(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_16.GetValue())
        s['Wert16'] = str(myInfrom)
        mySave()
        event.Skip()

    def choi1(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_17.GetValue())
        s['Wert17'] = str(myInfrom)
        mySave()
        event.Skip()

    def comb_01(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_17.GetValue())
        s['Wert17'] = str(myInfrom)
        mySave()
        event.Skip()

    def combt01(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_18.GetValue())
        s['Wert18'] = str(myInfrom)
        mySave()
        event.Skip()

    def comge01(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_18.GetValue())
        s['Wert18'] = str(myInfrom)
        mySave()
        event.Skip()

    def list_b01(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        
       
       
        
        mySave()
        event.Skip()

    def listbcl_01(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_19.GetValue())
        
        s['Wert19'] = str(myInfrom)
        mySave()
        event.Skip()

    def cheb_01(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_20.GetValue())
        s['Wert20'] = str(myInfrom)
        mySave()
        event.Skip()

    def but02(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        allmywert()
        self.text_ctrl_24.SetValue(str(s))
        mySave()
        event.Skip()

    def but03(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        s['Wert21'] = "but3"
        mySave()
        event.Skip()

    def but04(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        s['Wert21'] = "but4"
        mySave()
        event.Skip()

    def but5(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        s['Wert22'] = "but5"
        mySave()
        event.Skip()

    def bot_001(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        s['Wert23'] = "butbig1"
        mySave()
        with open("ausgabe.txt", "r") as file:
            s1 = (file.read())
            self.text_ctrl_24.SetValue(s1)
            
        event.Skip()
        
    def tex_001(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_24.GetValue())
        s['Wert24'] = (myInfrom)
        mySave()
        event.Skip()
        self.text_ctrl_24.SetValue(s1)
        
        

def myload():
    from pathlib import Path
    path = Path.home() / "ad.bin"
    with path.open("rb") as f:
        s = pickle.load(f)
def mySave():
    s
    path = Path.home() / "ad.bin"
    with path.open("wb") as f:
        pickle.dump(s, f)
        f.close()


def allmywert():
    ergebnis =[(s["Wert1"],
                   s["Wert2"],
                   s["Wert3"],
                   s["Wert4"],
                   s["Wert5"],
                   s["Wert6"],
                   s["Wert7"],
                   s["Wert8"],
                   s["Wert9"],
                   s["Wert10"],
                   s["Wert11"],
                   s["Wert12"],
                   s["Wert13"],
                   s["Wert14"],
                   s["Wert15"],
                   s["Wert16"],
                   s["Wert17"],
                   s["Wert18"],
                   s["Wert19"],
                   s["Wert20"],
                   s["Wert21"],
                   s["Wert22"],
                   s["Wert23"],
                   s["Wert24"])]
    
    with open("ausgabe.txt", "w") as fobj:
        fobj.write(str(ergebnis))
        return ((str(ergebnis)))
        fobj.close()
        Neutral_laden()


def Neutral_laden():
    with open("ausgabe.txt", "r") as file:
        s1 = (file.read())
        return (s1)
     
        



# end of class MyFrame


class MyApp(wx.App):
    def OnInit(self):
        self.frame = MyFrame(None, wx.ID_ANY, "")
        self.SetTopWindow(self.frame)
        self.frame.Show()
        return True

# end of class MyApp


if __name__ == "__main__":
    app = MyApp(0)
    app.MainLoop()

Code: Alles auswählen

def aa(self, event):  # wxGlade: MyFrame.<event_handler>
        myload()
        myInfrom = (self.text_ctrl_1.GetValue())
        s['Wert1'] = str(myInfrom )
        mySave()
        
        event.Skip()
Eintrag in das Textfeld< self.self.text_ctrl_1 löst< myload() aus welches alle bisherigen dict werte in s in diese funktion einliest. Danach wird die Information die ich in das Textfeld eingetragen habe self.text_ctrl_1 mittels myInfrom = (self.text_ctrl_1.GetValue()) geändert und mit mySave() in die Textdatei übergeben zwischen def und eventSkip sind ohne myload() keine dict Komponenten verfügbar. wenn ich ein Return auslöse gibt es keinen Wert den ich in der nächsten Eventfunktion wieder aufrufen kann In Java schafft man das wenn man die variable überläd. Wie überläd man mehr als eine Variable oder 200. Innerhalb der Eventfunktion nützte das get und setten nichts weil es die class innerhalb der Funktion unbekannt ist. Mir scheint auch das die lite IDE's nicht den vollen Funktionsumfang haben oder?
Nach oben
Sirius3
User
Beiträge: 17768
Registriert: Sonntag 21. Oktober 2012, 17:20

Dein Problem ist, dass man keine globalen Variablen verwenden darf und Du munter lokalen und globalen Namensraum mischst.
Programmierer sind faul, bedeutet, sie möchten nicht 16fach kopierten Code anpassen müssen, sondern immer nur eine Stelle. Dazu benutzen sie Schleifen. Ebenso sind sie faul und möchten sich nicht die Bedeutung von 30 kryptische Variablennamen merken, sondern benutzen sprechende Namen, die man ohne nachzudenken versteht, wenn man sie liest.

Innerhalb des Klassennamensraums schreibt man keinen ausführbaren Code, sondern nur Definitionen. Der Code zum Lesen und Speichern Deiner Daten sollten Methoden der Klasse sein, und der Zustand ein Attribut der Klasse.
Nach oben
Sirius3
User
Beiträge: 17768
Registriert: Sonntag 21. Oktober 2012, 17:20

Prinzipiell kann man den Code noch etwas aufräumen. Importe gehören alle an den Anfang der Datei. Du hast die Default-Werte für Deine Settings an zwei Stellen im Code sowie das Laden an mehreren Stellen. Dateinamen sollten nicht fix im Code stehen, und wenn, dann als Konstante einmal ganz am Anfang.
Präfixe wie My- tragen nichts zum Verständnis bei. Finde gute Namen.
Pickle ist ein schlechtes Datenformat für Deinen Zweck. Im anderen Thread von Dir hier im Forum wurde das ja schon ausführlich diskutiert.
Ich weiß nicht, wie das bei Glade ist, aber Fenstergrößen sollten nicht fix vorgegeben werden.
Variablennamen sollten niemals Nummern tragen.
Das ganze könnte also ungefähr so aussehen:

Code: Alles auswählen

#!/usr/bin/env python3
import wx
import json
from pathlib import Path
from functools import partial

DEFAULT_SETTINGS = {
    "Wert1": "dat1",
    "Wert2": "dat2",
    "Wert3": "dat3",
    "Wert4": "dat4",
    "Wert5": "dat5",
    "Wert6": "dat6",
    "Wert7": "dat7",
    "Wert8": "dat8",
    "Wert9": "dat9",
    "Wert10": "dat10",
    "Wert11": "dat11",
    "Wert12": "dat12",
    "Wert13": "dat1",
    "Wert14": "dat2",
    "Wert15": "dat3",
    "Wert16": "dat4",
    "Wert17": "dat5",
    "Wert18": "dat6",
    "Wert19": "dat7",
    "Wert20": "dat8",
    "Wert21": "dat9",
    "Wert22": "dat10",
    "Wert23": "dat11",
    "Wert24": "dat12",
}
SETTINGS_PATH = Path.home() / "ad.json"

def load_settings():
    with path.open("rb") as f:
        return json.load(f)

def save_settings(settings):
    with path.open("w") as f:
        json.dump(settings, f)


class SettingsFrame(wx.Frame):
    def __init__(self, *args, **kw):
        kw["style"] = kw.get("style", 0) | wx.DEFAULT_FRAME_STYLE
        super().__init__(*args, **kw)
        self.settings = load_settings()
        self.SetSize((828, 547))
        self.SetTitle("frame")

        # Menu Bar
        self.frame_menubar = wx.MenuBar()
        menu = wx.Menu()
        item = menu.Append(wx.ID_ANY, "Show Dialog", "")
        self.Bind(wx.EVT_MENU, self.show_modal, item)
        self.frame_menubar.Append(menu, "Menu")
        self.SetMenuBar(self.frame_menubar)
        # Menu Bar end

        self.panel = wx.Panel(self, wx.ID_ANY)

        self.controls = {}
        vertical_sizer = wx.BoxSizer(wx.VERTICAL)
        for index, name in list(DEFAULT_SETTINGS.keys())[:16]:
            if index % 4 == 0:
                horizontal_sizer = wx.BoxSizer(wx.HORIZONTAL)
                vertical_sizer.Add(horizontal_sizer, 1, wx.EXPAND, 0)

            text_control = wx.TextCtrl(self.panel, wx.ID_ANY, "texo2")
            text_control.SetMinSize((110, 23))
            self.Bind(wx.EVT_TEXT, partial(self.save_value, name=name), text_control)
            self.Bind(wx.EVT_TEXT_ENTER, partial(self.save_value, name=name), text_control)
            horizontal_sizer.Add(text_control, 0, 0, 0)
            self.controls[name] = text_control

        horizontal_sizer = wx.BoxSizer(wx.HORIZONTAL)
        vertical_sizer.Add(horizontal_sizer, 1, wx.EXPAND, 0)

        choice = wx.Choice(
            self.panel, wx.ID_ANY, choices=["choice 1"])
        choice.SetMinSize((100, 55))
        choice.SetSelection(0)
        self.Bind(wx.EVT_CHOICE, partial(self.save_value, name="Wert17"), choice)
        self.controls["Wert17"] = choice
        horizontal_sizer.Add(choice, 0, 0, 0)

        combo_box = wx.ComboBox(
           self.panel, wx.ID_ANY, choices=[], style=wx.CB_DROPDOWN)
        combo_box.SetMinSize((111, 55))
        self.Bind(wx.EVT_COMBOBOX, partial(self.save_value, name="Wert18"), combo_box)
        self.Bind(wx.EVT_TEXT, partial(self.save_value, name="Wert18"), combo_box)
        self.Bind(wx.EVT_TEXT_ENTER, partial(self.save_value, name="Wert18"), combo_box)
        self.controls["Wert18"] = combo_box
        horizontal_sizer.Add(combo_box, 0, 0, 0)

        list_box = wx.ListBox(self.panel, wx.ID_ANY, choices=["choice 1"])
        list_box.SetMinSize((100, 55))
        horizontal_sizer.Add(list_box, 0, 0, 0)
        # self.Bind(wx.EVT_LISTBOX, partial(self.save_value, name="Wert19"), list_box)
        self.Bind(wx.EVT_LISTBOX_DCLICK, partial(self.save_value, name="Wert19"), list_box)
        self.controls["Wert19"] = list_box

        check_list_box = wx.CheckListBox(self.panel, wx.ID_ANY, choices=["choice 1"])
        check_list_box.SetMinSize((101, 55))
        horizontal_sizer.Add(check_list_box, 0, 0, 0)
        self.Bind(wx.EVT_CHECKLISTBOX, partial(self.save_value, name="Wert20"), check_list_box)
        self.controls["Wert20"] = check_list_box

        horizontal_sizer = wx.BoxSizer(wx.HORIZONTAL)
        vertical_sizer.Add(horizontal_sizer, 1, wx.EXPAND, 0)

        button = wx.Button(self.panel, wx.ID_ANY, "button_2")
        button.SetMinSize((100, 32))
        horizontal_sizer.Add(button, 0, 0, 0)
        self.Bind(wx.EVT_BUTTON, do_something, self.button)

        button = wx.Button(self.panel, wx.ID_ANY, "button_3")
        button.SetMinSize((100, 32))
        horizontal_sizer.Add(button, 0, 0, 0)
        self.Bind(wx.EVT_BUTTON, partial(self.save_static_value, name="Wert21", value="but3"), button)

        button = wx.Button(self.panel, wx.ID_ANY, "button_4")
        button.SetMinSize((100, 32))
        horizontal_sizer.Add(button, 0, 0, 0)
        self.Bind(wx.EVT_BUTTON, partial(self.save_static_value, name="Wert21", value="but4"), button)

        button = wx.Button(self.panel, wx.ID_ANY, "button_5")
        button.SetMinSize((100, 32))
        horizontal_sizer.Add(self.button_5, 0, 0, 0)
        self.Bind(wx.EVT_BUTTON, partial(self.save_static_value, name="Wert22", value="but5"), button)

        horizontal_sizer = wx.BoxSizer(wx.HORIZONTAL)
        vertical_sizer.Add(horizontal_sizer, 1, wx.EXPAND, 0)

        button = wx.Button(self.panel, wx.ID_ANY, "button_1")
        button.SetMinSize((800, 20))
        horizontal_sizer.Add(button, 0, 0, 0)
        self.Bind(wx.EVT_BUTTON, partial(self.save_static_value, name="Wert23", value="butbig1"), button)

        horizontal_sizer = wx.BoxSizer(wx.HORIZONTAL)
        vertical_sizer.Add(horizontal_sizer, 1, wx.EXPAND, 0)

        text_ctrl = wx.TextCtrl(self.panel, wx.ID_ANY, "")
        text_ctrl.SetMinSize((800, 200))
        horizontal_sizer.Add(text_ctrl, 0, 0, 0)
        self.Bind(wx.EVT_TEXT, partial(self.save_value, name="Wert24"), text_ctrl)
        self.controls["Wert24"] = check_list_box

        self.panel.SetSizer(vertical_sizer)
        self.Layout()

    def show_modal(self, event):
        print("Event handler 'show_modal' not implemented!")
        event.Skip()

    def save_value(self, event, name):
        value = self.text_controls[name].GetValue()
        self.settings[name] = value
        save_settings(self.settings)
        event.Skip()

    def save_static_value(self, event, name, value):
        self.settings[name] = value
        save_settings(self.settings)
        event.Skip()

    def do_something(self, event):
        # keine Ahnung, was hier eigentlich passieren soll
        # myload()
        # allmywert()
        # self.text_ctrl_24.SetValue(str(s))
        # mySave()
        event.Skip()

class App(wx.App):
    def OnInit(self):
        self.frame = SettingsFrame(None, wx.ID_ANY, "")
        self.SetTopWindow(self.frame)
        self.frame.Show()
        return True

def main():
    app = App(0)
    app.MainLoop()

if __name__ == "__main__":
    main()
Nach oben
oldboyJR
User
Beiträge: 33
Registriert: Donnerstag 28. März 2024, 16:19

Aber das was ich hier mit meinem Programm ausdrücke ist. Ich stimme überein das Globale Namensgebungen gefährlich sind. Mein Trick hier ist das ich durch laden eines Textes oder oder anderer Dateiformate eine unschädliche Form einer überall ereichbaren Keinglobalen Variable geschaffen habe. Es sei denn das .bin Format ist eine Globale Variable? Meine Namensgebungen im Programm sind sowas wie eine Vorskizze. Ich glaube eine Globale Namensgebung ist nicht so einfach weil die anderen Programmierer ja auch nach dem gleichen Verfahren Namensgebungen bilden.
Nach oben
Sirius3
User
Beiträge: 17768
Registriert: Sonntag 21. Oktober 2012, 17:20

Egal ob kleinglobal oder irgendwie anders global, gewöhn Dir von Anfang an eine saubere Programmierung an. Dazu gehört, dass man globale Variablen vermeidet und dazu gehören sprechende Namen, auch wenn das nur eine Vorskizze ist. Wie soll denn die Skizze helfen, wenn man sie nicht versteht. Und versuche auch deine Texte hier im Forum so zu formulieren, dass sie für andere leicht zu verstehen sind.
Nach oben
oldboyJR
User
Beiträge: 33
Registriert: Donnerstag 28. März 2024, 16:19

Ich verstehe deine Kritik sirius3. Eine Vorskizze ist zum Übermalen: Wenn es dir gefällt und du ein besseres Verständnis einfach solche nam_en_ brau_chst dann ersetze "Wert1" mit ersetzen zu "kon_to_stand-ol_d_boy_jr" und schaue dir die Wege dann an. Ich glaube damit habe ich auch einen Namensraum benutze der Global angewendet werden darf? Ich könnte mir auch vorstellen das hinter jr noch eine Verschachtelung kommt die einen Hachcode zurückgibt? Oder sollte ich eigendlich self."kon_to_stand-ol_d_boy_jr" verwenden?

Code: Alles auswählen

 {"kon_to_stand-ol_d_boy_jr": "dat1", #Regel der erste Teil ist der Schlüssel und steht auch für den Feldnamen
     "datum_von_buch_boy_jr": "dat2",  #datx ist ein automatischer wert der durch das Programm geändert wird  
     "Soll_wert-ol_d_boy_jr": "dat3",
     "Flag_soll_stand-ol_d_boy_jr": "dat4",
     "^Haben_wert-ol_d_boy_jr": "dat5",
     "flag_hab-ol_d_boy_jr": "dat6",
     "flag_strom-ol_d_boy_jr": "dat7",
     "flag_handw-ol_d_boy_jr": "dat8",
    "flag_krankenkasse-ol_d_boy_j": "dat9",
    "flag_versich PV_boy_j": "dat10",
    "flag_versich_HV_boy_j": "dat11",
    "flag_versich_Leb_ol_d_boy_j": "dat12",
    "sum_janfanf-ol_d_boy_j": "dat1",
     "sum_janfend-ol_d_boy_j": "dat2",
     "sum_hab_m-ol_d_boy_j": "dat3",
     "sum_solm_ol_d_boy_j": "dat4",
     "flag_priv-ol_d_boy_j": "dat5",
     "flag_sonst-ol_d_boy_j": "dat6",
     "lim_tag-ol_d_boy_j": "dat7",
     "flag_reture_ol_d_boy_j": "dat8",
    "flag_beruf-ol_d_boy_j": "dat9",
    "flag_vorteu-ol_d_boy_j": "dat10",
    "flag_Aush-ol_d_boy_j": "dat11",
    "flag_rent-ol_d_boy_j": "dat12",
     } als globale Variable benutzen? Um deinen Wunsch zu entsprechen ?
Nach oben
Benutzeravatar
sparrow
User
Beiträge: 4202
Registriert: Freitag 17. April 2009, 10:28

@oldboyJR: Irgendwie wirken deine Antworten auf mich zunehmend zusammenhanglos.

Natürlich kannt du all die Hinweise ignorieren, die dir hier gegeben werden. Nur... welchen Sinn ziehst du daraus? Klar, du kannst den Hinweis ins Lächerliche ziehen, dass venünftige Namen Sinn machen. Aber das ist dann schon speziell.

Es geht übrigens nicht darum, dass globale Variablen "gefährlich" sind und man das "sicher" machen muss.
Sie machen ein Programm unnötig kompliziert, unübersichtlich und fehleranfällig. Also verwendet man sie nicht.
Da kannst du jetzt versuchen gegen zu argumentieren - aber Argumente finde ich in deinen Posts nicht. Oder du freust dich, dass du etwas gelernt hast. Oder irgendwas dazwischen. Ich habe so eine Vermutung.
Nach oben
oldboyJR
User
Beiträge: 33
Registriert: Donnerstag 28. März 2024, 16:19

Es ist überhaupt kein bestreben etwas ins lächerliche zu ziehen. Aber wenn ich in ein Lehrbuch sehe stehen da auch nicht die richtigen Namensgebungen sondern das was ich in meinem Programm eingebaut habe. so steht dort auch im Lehrbuch:
>> d = {"schlüssel1": "wert1", "schlüssel2": "wert2"}
Über einen Schlüssel können Sie auf den dahinterliegenden Wert zugreifen. Dazu werden ähnlich wie bei den Listen eckige Klammern verwendet:
>>> d["schlüssel1"]'wert1'
>>> d["schlüssel2"]'wert2'
Über diese Zugriffsoperation können Sie auch Werte modifizieren bzw. neue Schlüssel-Wert-Paare in das Dictionary eintragen:
>>> d["schlüssel2"] = "wert2.1"
>>> d["schlüssel2"]'
wert2.1'
>>> d["schlüssel3"] = "wert3"
>>> d["schlüssel3"]'
wert3'
>>> d{'schlüssel1': 'wert1', 'schlüssel2': 'wert2.1', 'schlüssel3': 'wert3'}
Sowohl Schlüssel als auch Werte können andere Datentypen haben als die an dieser Stelle verwendeten Strings. Darauf werden wir zu gegebener Zeit zurückkommen.

Und kein Programmierer versteht diese Erklärung nicht.

Und noch einmal wo habe ich in meinem Programm einen globalen Namen erstellt?
Und warum erreiche ich diesen Namen dann nicht unter
def wieder_mal_de_n_wert():
ohne ihn aus einer Datei zu holen?
Nach oben
oldboyJR
User
Beiträge: 33
Registriert: Donnerstag 28. März 2024, 16:19

Der erste Poster diese Artikels will gerne eine globale Variable benutzen aber ... Windows hat auch einen globalen Namensraum wie Name, Vorname, welches jede App benutzt wenn man es zulässt. Wenn man mal in Mikrosoft Outlook in den Entwicklungsmodus geht kann man die globalen Variablen sehen. Und wenn man eigene Masken und Namesgebungen dazu verwendet und anschließend alles als Standartvorlage abspeichert kann man diese Masken auch benutzen. Auch Open office verwendet wohl globale Variablen. Es sei denn beide Programme greifen auf den selben Trick zurück. Ich vermute mal indirekt über Regedit bzw. Regist dwort und co oder wie ich über die Vorlagen als Grundgerüst?
Nach oben
Benutzeravatar
__blackjack__
User
Beiträge: 13135
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:
Kontaktdaten von __blackjack__

@oldboyJR: Mal davon abgesehen das es auch schlechte Lehrbücher gibt sind das da sehr allgemeine Beispiele in einem interaktiven Interpreter. Bessere Namen gehen da ja schon deshalb nicht weil es gar keine Bedeutung gibt, die man zur Namensgebung heranziehen kann.

`s`, `s1`, `path`, `f`, `MyFrame.s`, `MyFrame.s1`, `MyFrame.f`, und `app` sind die globalen Variablen, die in Deinem Code-Beispiel existieren, das aber nicht sollten.
“There will always be things we wish to say in our programs that in all known languages can only be said poorly.” — Alan J. Perlis
Nach oben
Antworten

Zurück zu „Allgemeine Fragen“