Python Programme aus verschiedenen Bereichen
Python Programm Beispiele
Text-Analyse
Das folgende Programm liest eine txt-Datei ein und überprüft wieviele gleiche Worte (hier das Wort "über") enthalten sind.
import re
def zaehle_ueber(dateiname: str) -> int:
try:
with open(dateiname, 'r', encoding='utf-8') as f:
text = f.read()
except FileNotFoundError:
print(f"❌ Datei '{dateiname}' nicht gefunden.")
return 0
# Regex: exaktes Wort "über", unabhängig von Groß-/Kleinschreibung
muster = r"\büber\b"
treffer = re.findall(muster, text, flags=re.IGNORECASE)
return len(treffer)
# Beispielaufruf
anzahl = zaehle_ueber("text.txt")
print(f"✅ Das Wort 'über' kommt {anzahl} Mal vor.")
Newton-Iteration
Das folgende Programm führt eine Nullstellensuche nach dem Verfahren von Newton aus.
import sympy as sp
# Funktion definieren
x = sp.Symbol('x')
f_expr = x**2 - 2 # Beispiel: Nullstelle von x² - 2 (also √2)
f = sp.lambdify(x, f_expr, 'numpy')
f_prime = sp.lambdify(x, sp.diff(f_expr, x), 'numpy')
def iterate_formula(x0, max_iter=10, tol=1e-8):
xi = x0
for i in range(max_iter):
f_val = f(xi)
f_prime_val = f_prime(xi)
if f_prime_val == 0:
print(f"Iteration {i}: Ableitung ist 0, Abbruch.")
break
xi_next = xi * (f_val / f_prime_val)
print(f"Iteration {i+1}: x = {xi_next}")
if abs(xi_next - xi) < tol:
print("Konvergenz erreicht.")
break
xi = xi_next
return xi
# Startwert
startwert = 1.5
result = iterate_formula(startwert)
print(f"Ergebnis: {result}")
Funktions-Plot
Das folgende Programm plottet eine Funktion und deren Ableitung in einem Diagramm.
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Set seaborn style
sns.set(style="whitegrid")
# Define the function and its derivative
def f(x):
return x**3 - 2*x + 2
def f_prime(x):
return 3*x**2 - 2
# Generate x values
x = np.linspace(-2, 2, 400)
# Compute y values for the function and its derivative
y = f(x)
y_prime = f_prime(x)
# Create the plot
plt.figure(figsize=(10, 6))
plt.plot(x, y, label='f(x) = x³ - 2x + 2', color='blue')
plt.plot(x, y_prime, label="f'(x) = 3x² - 2", color='red', linestyle='--')
plt.title('Funktion und Ableitung von f(x) im Bereich [-2, 2]', fontsize=14)
plt.xlabel('x', fontsize=12)
plt.ylabel('Wert', fontsize=12)
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()
Erzeugung eine Binär-Datei
EEPROM Programmierung erfordert oft, einen Baustein mit Test-Daten zu füllen. Natürlich kann man die EEPROMS auch von Hand zu programmieren, aber weit sinnvoller ist es, dies natürlich mit Hilfe eines Programms zu machen, das die entsprechenden Daten in eine Datei schreibt, die dann von der Programmiersoftware eingelesen und auf den Chip geschrieben wird.
Für den Einsatz in 8-Bit Computersystemen wo der 6502 prozessor zum Einsatz kommen soll, passiert nach dem Spannung angelegt wird in den ersten 6 Takten nach dem Reset nichts sinnvolles, da können beliebige Daten im Speicher stehen. Ab dem 7. Takt wird aber zur Adresse 0xFFFc bzw. 0xFFFd gesprungen und die beiden Bytes bilden die Einsprungadresse für den Programmstart . In meinem Beispiel habe ich die Werte 0x00 und 0x80 eingegeben, und somit die Adresse 0x8000 definiert. An dieser Adresse beginnt dann die Programmausführung.
Hier ein Beispiel in Python: Der Aufbau ist ziemlich übersichtlich. Zuerst wird ein Array definiert, das der Größe des EEPROM entspricht und dann mit Daten gefüllt. Einzelne Stellen können dann noch manuell eingetragen werden. Anschliessend wird das Ganze dann als Datei mit dem Namen „rom.bin“ ausgegeben.
# EEPROM Programm-Datei erzeugen
rom = bytearray ([0xEA]*32768)
rom[0x7FFC] = 0x00
rom[0x7FFC] = 0x80
with open ("rom.bin","wb") as out_file:out_file.write(rom)
Klassischer Hex-Dump eeines Datenstroms
Python-Programm, dass es die serielle Ausgabe des Arduino Mega live als Hex-Dump darstellt, ähnlich wie man es von klassischen Speicher-Dumps kennt – mit Adresse, Datenwert und Lese-/Schreibrichtung.
# Hex-Dump
import serial
import time
# Serielle Verbindung öffnen (Port ggf. anpassen!)
ser = serial.Serial('COM3', 57600, timeout=1) # z. B. '/dev/ttyUSB0' unter Linux/Mac
print("📡 Starte Hex-Dump Monitor...\n")
print("Zeit | Adresse | R/W | Daten")
print("-----------------------------------")
try:
while True:
line = ser.readline().decode('utf-8').strip()
if line:
# Beispielzeile: " a5f3 r CC"
parts = line.split()
if len(parts) == 3:
hex_addr, rw, hex_data = parts
timestamp = time.strftime('%H:%M:%S')
print(f"{timestamp} | 0x{hex_addr.upper():>4} | {rw.upper()} | 0x{hex_data.upper():>2}")
except KeyboardInterrupt:
print("\n🛑 Monitor beendet.")
finally:
ser.close()
📡 Starte Hex-Dump Monitor...
Zeit | Adresse | R/W | Daten
-----------------------------------
14:06:01 | 0xA5F3 | R | 0xCC
14:06:02 | 0xA5F4 | W | 0x3A
14:06:03 | 0xA5F5 | R | 0xFF
Ein ähnliches Programm für den Arduino...es liest die Daten und Adressports eines 8-Bit Prozessors aus und stellt diese in Form eines Hex-Dumps dar:
// *******************************************
// Monitor Programm um Daten und Adress Bits
// mit Arduino Mega auszulesen
// nach Ben Eater modifiziert von
// ProfHof Sept 2022
// Version 1.0
// *******************************************
const char ADDR[] = {22, 24, 26, 28, 30, 32, 34, 36, 40, 42, 44, 46, 47, 49, 51, 53};
const char DATA[] = {14, 15, 16, 17, 18, 19, 20, 21};
#define CLOCK 2
#define READ_WRITE 3
void setup() {
for (int n = 0; n < 16; n += 1) {
pinMode(ADDR[n], INPUT);
}
for (int n = 0; n < 8; n += 1) {
pinMode(DATA[n], INPUT);
}
pinMode(CLOCK, INPUT);
pinMode(READ_WRITE, INPUT);
// sobald clock impulse am Eingang 2 dann wird
// Interrupt routinbe "Clock" aufgerufen
attachInterrupt(digitalPinToInterrupt(CLOCK), onClock, RISING);
Serial.begin(57600);
}
void onClock() {
char output[15];
unsigned int address = 0;
for (int n = 0; n < 16; n += 1) {
int bit = digitalRead(ADDR[n]) ? 1 : 0;
Serial.print(bit); // Umwandlung in ein Integerwert
address = (address << 1) + bit;
}
Serial.print(" ");
unsigned int data = 0;
for (int n = 0; n < 8; n += 1) {
int bit = digitalRead(DATA[n]) ? 1 : 0;
Serial.print(bit); // Umwandlung in ein Integerwert
data = (data << 1) + bit;
}
// Ausgabe hat das Format:
// 16bit Adresse __ 8Bit Data ___ HexAdr __ R/W __ HexData
sprintf(output, " %04x %c %02x", address, digitalRead(READ_WRITE) ? 'r' : 'W', data);
Serial.println(output);
}
void loop() {}
Farbige Darstellung im Jupyter Notebook
Jupyter Notebooks laufen im Browser und nutzen intern IPython, das HTML, Markdown und JavaScript interpretieren kann. IPython.display.HTML() erzeugt ein spezielles Objekt, das Jupyter als “rich output” erkennt und als visuelles HTML-Element dargestellt wird. Der Browser übernimmt die Formatierung – genau wie bei einer Webseite.
from IPython.display import HTML
HTML("Roter Text")
# oder ein weiteres Beispiel:
from IPython.display import HTML, display
def farbige_ausgabe(text, farbe="green", fett=True):
style = f"color:{farbe};"
if fett:
style += "font-weight:bold;"
html = f"{text}"
display(HTML(html))
farbige_ausgabe("✔ Optimale Paketmaße gefunden!", farbe="green")
farbige_ausgabe("Länge: 40.00 cm", farbe="blue")
farbige_ausgabe("Breite: 20.00 cm", farbe="blue")
farbige_ausgabe("Höhe: 30.00 cm", farbe="blue")
farbige_ausgabe("Maximales Volumen: 24,000 cm³", farbe="darkred")
Die nachfolgenden Screenshots geben einen Überblick wie das dann in der Praxis aussehen kann.
...
...
...