Python – speichern mit json

JSON (JavaScript Object Notation) ist eine Syntax zum Speichern und Austauschen von Daten. JSON ist Text, der mit JavaScript-Objektnotation geschrieben ist. Python verfügt über ein integriertes Paket namens json, das zum Arbeiten mit JSON-Daten verwendet werden kann.

Um mit JSON zu arbeiten muss es importiert werden:

import json

Ein paar andere Anwendungsfälle für das JSON-Format sind:

  1. Anwendungsprogrammierschnittstelle (APIs). JSON wird häufig für die Erstellung von APIs (Application Programming Interfaces) verwendet, die es verschiedenen Systemen und Anwendungen ermöglichen, miteinander zu kommunizieren. Viele webbasierte APIs verwenden zum Beispiel JSON als Datenformat für den Austausch von Daten zwischen verschiedenen Anwendungen, was die Integration mit verschiedenen Programmiersprachen und Plattformen erleichtert.
  2. Konfigurationsdateien. JSON bietet ein einfaches und leicht zu lesendes Format zum Speichern und Abrufen von Konfigurationsdaten. Dazu können Einstellungen für die Anwendung gehören, wie z. B. das Layout einer Benutzeroberfläche oder Benutzereinstellungen.
  3. IoT (Internet der Dinge).  IoT-Geräte erzeugen oft große Datenmengen, die mit JSON effizienter gespeichert und zwischen Sensoren und anderen Geräten übertragen werden können. 

Beispiel einer einfachen .json Datei:

{
    "name": "Mandy Seider",
    "alter": "48",
    "anstellungsart": "Vollzeit",
    "hobbies": [
      "Handarbeiten",
      "Sport",
      "EDV"
    ]
  }

Python-Bibliotheken für die Arbeit mit JSON-Daten

Es gibt einige beliebte Python-Pakete, die du für die Arbeit mit JSON-Dateien verwenden kannst:

  1. json. Dies ist ein eingebautes Python-Paket, das Methoden zur Kodierung und Dekodierung von JSON-Daten bereitstellt.
  2. simplejson. Dieses Paket bietet einen schnellen JSON-Encoder und -Decoder mit Unterstützung für Python-spezifische Typen.
  3. ujson. Dieses Paket ist ein ultraschneller JSON-Encoder und -Decoder für Python.
  4. jsonschema. Dieses Paket bietet eine Möglichkeit, JSON-Daten gegen ein bestimmtes Schema zu validieren.

Speichern von Daten in einer .json Datei:

json.load()

Mit dieser Funktion kannst du eine JSON-Datei lesen und ihren Inhalt in ein Python-Objekt parsen. Die Funktion load() nimmt ein einziges Argument, das Dateiobjekt, und gibt ein Python-Objekt zurück. Hier ist ein Beispiel:

import json

# read JSON file and parse contents
with open('data.json', 'r') as file:
    python_obj = json.load(file)
print(python_obj)  

# output: {'name': 'Mandy Seider', 'age': 48}

JSON zur Speicherung von Eingabedaten in Tkinter nutzen

Um Benutzereingaben aus Tkinter-Widgets wie Entry und Text in einer JSON-Datei zu speichern, gehst du wie folgt vor:

  1. Daten aus den Widgets auslesen Mit .get() liest du den Text aus einem Entry-Feld. Mit .get(„1.0“, tk.END) liest du den Text aus einem Text-Widget.
  2. Daten in ein Dictionary packen Erstelle ein Dictionary mit den ausgelesenen Werten, z.B.: python
    daten = {
    „bezeichnung“: e1.get(),
    „text“: t1.get(„1.0“, tk.END).strip()
    }
  3. Dictionary als JSON speichern Mit json.dump() schreibst du das Dictionary in eine Datei:


with open("data.json", "w", encoding="utf-8") as f:
                                           json.dump(daten, f, ensure_ascii=False, indent=4)

Das sorgt für eine gut lesbare und korrekte Speicherung im JSON-Format

Du möchtest, dass alle neu angelegten Buttons in einer Datei gespeichert werden, damit sie beim nächsten Start des Programms wieder geladen werden können. Aktuell überschreibst du aber immer nur einen Datensatz (daten) in der Datei data.json. Das Ziel ist, eine Liste aller Buttons (mit Bezeichnung und Text) dauerhaft zu speichern und beim Start wiederherzustellen.

Hier ist eine Schritt-für-Schritt-Anleitung und der überarbeitete Code:

1. Speichern aller Buttons in einer Liste

Statt nur einen Button zu speichern, verwaltest du eine Liste (buttons_list). Jedes Mal, wenn ein Button erstellt wird, fügst du ihn dieser Liste hinzu und speicherst die gesamte Liste in data.json.

2. Laden der Buttons beim Programmstart

Beim Start des Programms liest du die Datei data.json ein (falls vorhanden) und erstellst für jeden gespeicherten Button einen neuen Button im GUI.

import tkinter as tk
from tkinter import messagebox, filedialog
import json
import os

def NewFile():
    global buttons_list
    buttons_list = []
    save_buttons()
    for btn in created_buttons:
        btn.destroy()
    created_buttons.clear()
    print("Neue Datei erstellt.")

def OpenFile():
    filename = filedialog.askopenfilename()
    print("Datei geöffnet:", filename)
    # Hier könntest du die Datei laden und Buttons anzeigen, wenn du möchtest

def About():
    messagebox.showinfo("Über", "Programm erstellt von Mandy Seider")

def save():
    # Speichert nur den aktuellen Text im Clipboard, nicht die Buttons!
    daten = {
        "bezeichnung": e1.get(),
        "text": t1.get("1.0", tk.END).strip()
    }
    root.clipboard_clear()
    root.clipboard_append(daten["text"])
    root.update()
    messagebox.showinfo("Gespeichert", "Text wurde ins Clipboard kopiert.")

def save_buttons():
    with open("data.json", "w", encoding="utf-8") as f:
        json.dump(buttons_list, f, ensure_ascii=False, indent=4)

def create_custom_button():
    bezeichnung = e1.get()
    text = t1.get("1.0", tk.END).strip()

    if not bezeichnung:
        messagebox.showwarning("Fehler", "Bitte eine Button-Bezeichnung eingeben!")
        return
    if not text:
        messagebox.showwarning("Fehler", "Bitte einen Text eingeben!")
        return

    def show_text():
        messagebox.showinfo(bezeichnung, text)

    btn = tk.Button(root, text=bezeichnung, command=show_text)
    btn.pack(pady=5)
    created_buttons.append(btn)

    # Button-Daten speichern
    buttons_list.append({"bezeichnung": bezeichnung, "text": text})
    save_buttons()
    messagebox.showinfo("Gespeichert", "Button wurde gespeichert.")

def load_buttons():
    if os.path.exists("data.json"):
        with open("data.json", "r", encoding="utf-8") as f:
            try:
                loaded = json.load(f)
                for eintrag in loaded:
                    bezeichnung = eintrag["bezeichnung"]
                    text = eintrag["text"]
                    def make_show_text(b=bezeichnung, t=text):
                        return lambda: messagebox.showinfo(b, t)
                    btn = tk.Button(root, text=bezeichnung, command=make_show_text())
                    btn.pack(pady=5)
                    created_buttons.append(btn)
                return loaded
            except Exception as e:
                print("Fehler beim Laden:", e)
    return []

root = tk.Tk()
root.geometry('300x500')
root.title("Entwicklung Typeitin")

menu = tk.Menu(root)
root.config(menu=menu)
filemenu = tk.Menu(menu, tearoff=0)
menu.add_cascade(label="Datei", menu=filemenu)
filemenu.add_command(label="Neu", command=NewFile)
filemenu.add_command(label="Öffnen...", command=OpenFile)
filemenu.add_separator()
filemenu.add_command(label="Beenden", command=root.quit)
helpmenu = tk.Menu(menu, tearoff=0)
menu.add_cascade(label="Hilfe", menu=helpmenu)
helpmenu.add_command(label="Über...", command=About)

w1 = tk.Label(root, text="Button Bezeichnung eingeben")
w1.pack(fill=tk.X, padx=20)
e1 = tk.Entry(root)
e1.pack()
w2 = tk.Label(root, text="dazugehörigen Text eingeben")
w2.pack()
t1 = tk.Text(root, width=20, height=3)
t1.pack()

tk.Button(root, text='Speichern', command=save).pack(pady=10)
tk.Button(root, text='Button erstellen', command=create_custom_button).pack(pady=10)
tk.Button(root, text='Exit', command=root.quit).pack()

# Listen für Buttons
buttons_list = []
created_buttons = []

# Vorhandene Buttons laden
buttons_list = load_buttons()

root.mainloop()