Ihr nächstes Coding-Projekt: Ein interaktives Periodensystem mit PyQt6 programmieren

Bist du auf der Suche nach einem spannenden und lehrreichen Coding-Projekt, das deine Python-Fähigkeiten auf die nächste Stufe hebt? Wie wäre es mit einem interaktiven Periodensystem, das du mit PyQt6 erstellst? Dieses Projekt bietet dir die Möglichkeit, deine Kenntnisse in GUI-Entwicklung, Datenvisualisierung und objektorientierter Programmierung zu vertiefen. In diesem Artikel führen wir dich Schritt für Schritt durch die Entwicklung eines solchen Periodensystems, von der Einrichtung der Entwicklungsumgebung bis hin zur Implementierung interaktiver Features.

Warum ein interaktives Periodensystem?

Ein interaktives Periodensystem ist mehr als nur eine digitale Version einer Tabelle. Es ermöglicht Benutzern, auf spielerische Weise Informationen über die chemischen Elemente zu entdecken. Durch Anklicken eines Elements können detaillierte Informationen wie Atomgewicht, Elektronenkonfiguration, Schmelzpunkt und vieles mehr angezeigt werden. Dies macht es zu einem idealen Lernwerkzeug für Schüler, Studenten und alle, die sich für Chemie interessieren.

Darüber hinaus bietet die Entwicklung eines solchen Projekts zahlreiche Vorteile für deine Programmierkenntnisse:

• GUI-Entwicklung: Du lernst, wie man mit PyQt6 ansprechende und intuitive Benutzeroberflächen erstellt.
• Datenvisualisierung: Du übst den Umgang mit Daten und deren Darstellung in einer visuell ansprechenden Form.
• Objektorientierte Programmierung (OOP): Du wendest OOP-Prinzipien an, um den Code modular und wartbar zu gestalten.
• Datenquellen: Du lernst, wie man Daten aus externen Quellen (z.B. CSV-Dateien oder APIs) einliest und verarbeitet.
• Interaktivität: Du implementierst Interaktionsmöglichkeiten, die die Benutzererfahrung verbessern.

Voraussetzungen

Bevor wir mit der Entwicklung beginnen, stelle sicher, dass du die folgenden Voraussetzungen erfüllst:

• Grundlegende Kenntnisse in Python.
• Eine installierte Python-Umgebung (Version 3.7 oder höher wird empfohlen).
• Die PyQt6-Bibliothek. Du kannst sie mit pip installieren: pip install PyQt6
• Optional: Ein Code-Editor deiner Wahl (z.B. VS Code, PyCharm).

Schritt 1: Projektstruktur und Einrichtung

Erstelle zunächst ein neues Verzeichnis für dein Projekt und lege darin folgende Dateien an:

• main.py: Die Hauptdatei, die das Programm startet.
• periodictable.py: Die Klasse, die das Periodensystem darstellt.
• element.py: Die Klasse, die ein einzelnes chemisches Element darstellt.
• data/elements.csv: Eine CSV-Datei, die die Daten für die chemischen Elemente enthält. Du kannst eine solche Datei leicht im Internet finden oder selbst erstellen.

Eine mögliche CSV-Datei (data/elements.csv) könnte so aussehen:

Atomic Number,Symbol,Name,Atomic Mass,Electronegativity
1,H,Hydrogen,1.008,2.20
2,He,Helium,4.0026,
3,Li,Lithium,6.94,0.98
...

Schritt 2: Die Element-Klasse (element.py)

Beginnen wir mit der Definition der Element-Klasse. Diese Klasse repräsentiert ein einzelnes Element im Periodensystem.

„`python
# element.py
class Element:
def __init__(self, atomic_number, symbol, name, atomic_mass, electronegativity):
self.atomic_number = atomic_number
self.symbol = symbol
self.name = name
self.atomic_mass = atomic_mass
self.electronegativity = electronegativity

def __str__(self):
return f”{self.name} ({self.symbol})”
„`

Diese Klasse speichert die grundlegenden Informationen über ein Element. Die __str__-Methode ermöglicht eine einfache Ausgabe des Elementnamens und -symbols.

Schritt 3: Die Periodensystem-Klasse (periodictable.py)

Als Nächstes erstellen wir die PeriodicTable-Klasse. Diese Klasse lädt die Daten aus der CSV-Datei und speichert sie als Liste von Element-Objekten.

„`python
# periodictable.py
import csv
from element import Element

class PeriodicTable:
def __init__(self, data_file=”data/elements.csv”):
self.elements = self.load_elements(data_file)

def load_elements(self, data_file):
elements = []
with open(data_file, ‘r’) as file:
reader = csv.DictReader(file)
for row in reader:
try:
atomic_number = int(row[‘Atomic Number’])
symbol = row[‘Symbol’]
name = row[‘Name’]
atomic_mass = float(row[‘Atomic Mass’])
electronegativity = float(row[‘Electronegativity’]) if row[‘Electronegativity’] else None #Handle missing Electronegativity values
elements.append(Element(atomic_number, symbol, name, atomic_mass, electronegativity))
except ValueError as e:
print(f”Skipping row due to data error: {row} – {e}”)
return elements

def get_element_by_symbol(self, symbol):
for element in self.elements:
if element.symbol == symbol:
return element
return None
„`

Die load_elements-Methode liest die CSV-Datei zeilenweise und erstellt für jede Zeile ein Element-Objekt. Es wird auch eine Fehlerbehandlung für fehlende oder ungültige Daten implementiert. Die get_element_by_symbol-Methode ermöglicht das Abrufen eines Elements anhand seines Symbols.

Schritt 4: Die Hauptanwendung (main.py)

Nun erstellen wir die Hauptanwendung mit PyQt6. Hier wird das Fenster erstellt, das Periodensystem dargestellt und die Interaktivität implementiert.

„`python
# main.py
import sys
from PyQt6.QtWidgets import (QApplication, QWidget, QGridLayout, QLabel,
QPushButton, QVBoxLayout, QDialog, QTextEdit)
from PyQt6.QtGui import QFont
from periodictable import PeriodicTable

class ElementDialog(QDialog):
def __init__(self, element):
super().__init__()
self.setWindowTitle(element.name)

layout = QVBoxLayout()
text_edit = QTextEdit()
text_edit.setReadOnly(True)
text_edit.setText(f”Name: {element.name}nSymbol: {element.symbol}nAtomic Number: {element.atomic_number}nAtomic Mass: {element.atomic_mass}nElectronegativity: {element.electronegativity}”)
layout.addWidget(text_edit)

self.setLayout(layout)

class PeriodicTableApp(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle(„Interaktives Periodensystem”)
self.table = PeriodicTable()
self.layout = QGridLayout()
self.setup_ui()

def setup_ui(self):
#Dummy Daten für die Anordnung der Buttons, muss angepasst werden
element_positions = {
„H”: (0, 0), „He”: (0, 17),
„Li”: (1, 0), „Be”: (1, 1), „B”: (1, 12), „C”: (1, 13), „N”: (1, 14), „O”: (1, 15), „F”: (1, 16), „Ne”: (1, 17),
„Na”: (2, 0), „Mg”: (2, 1), „Al”: (2, 12), „Si”: (2, 13), „P”: (2, 14), „S”: (2, 15), „Cl”: (2, 16), „Ar”: (2, 17),
„K”: (3, 0), „Ca”: (3, 1), „Sc”: (3, 2), „Ti”: (3, 3), „V”: (3, 4), „Cr”: (3, 5), „Mn”: (3, 6), „Fe”: (3, 7), „Co”: (3, 8), „Ni”: (3, 9), „Cu”: (3, 10), „Zn”: (3, 11), „Ga”: (3, 12), „Ge”: (3, 13), „As”: (3, 14), „Se”: (3, 15), „Br”: (3, 16), „Kr”: (3, 17)
}

font = QFont(„Arial”, 10)

for element in self.table.elements:
if element.symbol in element_positions:
row, col = element_positions[element.symbol]
button = QPushButton(element.symbol)
button.setFont(font)
button.clicked.connect(lambda checked, element=element: self.show_element_details(element))
self.layout.addWidget(button, row, col)

self.setLayout(self.layout)

def show_element_details(self, element):
dialog = ElementDialog(element)
dialog.exec()

if __name__ == ‘__main__’:
app = QApplication(sys.argv)
window = PeriodicTableApp()
window.show()
sys.exit(app.exec())
„`

In diesem Code wird eine PeriodicTableApp-Klasse erstellt, die ein QWidget ist. Die setup_ui-Methode erstellt die Schaltflächen für jedes Element und platziert sie in einem QGridLayout. Die show_element_details-Methode öffnet einen Dialog mit detaillierten Informationen über das angeklickte Element. Die Positionen der Elemente werden durch das Dictionary `element_positions` bestimmt, das an die tatsächliche Anordnung des Periodensystems angepasst werden muss.

Schritt 5: Interaktivität hinzufügen

Die obige Implementierung ist bereits funktionsfähig, aber es gibt noch viel Raum für Verbesserungen. Hier sind einige Ideen, wie du die Interaktivität weiter verbessern kannst:

• Farben: Verwende unterschiedliche Farben für verschiedene Elementgruppen (z.B. Alkalimetalle, Halogene).
• Suchfunktion: Ermögliche Benutzern, nach Elementen anhand ihres Namens oder Symbols zu suchen.
• Filter: Füge Filter hinzu, um Elemente nach bestimmten Eigenschaften (z.B. Aggregatzustand) anzuzeigen.
• Animationen: Füge Animationen hinzu, um das Programm visuell ansprechender zu gestalten.
• Datenquellen erweitern: Integriere weitere Datenquellen, z.B. APIs, um noch mehr Informationen über die Elemente anzuzeigen.

Fazit

Die Entwicklung eines interaktiven Periodensystems mit PyQt6 ist ein großartiges Coding-Projekt, um deine Python-Fähigkeiten zu verbessern. Es bietet dir die Möglichkeit, GUI-Entwicklung, Datenvisualisierung und objektorientierte Programmierung zu kombinieren. Mit den hier vorgestellten Schritten und Ideen kannst du ein ansprechendes und lehrreiches Programm erstellen, das sowohl Spaß macht als auch nützlich ist. Viel Erfolg beim Programmieren!