Lesedauer 5 Minuten

Python ist längst die Sprache der Wahl für Automatisierung. Und das nicht ohne Grund: Die Syntax ist verständlich und für praktisch jeden Automatisierungs-Fall findest du die passende Library.

Python wird immer dominanter bei den Profis, und Automatisierung ist und bleibt einer der Hauptgründe für diese Erfolgsgeschichte. Die Trend-Kurve zeigt steil nach oben. Dieser Beitrag zeigt Dir für jede Automatisierungs-Kategorie die passenden Python-Werkzeuge.

Die großen Automatisierungs-Kategorien und ihre Tools

Die typischen Automatisierungs-Szenarien lassen sich grob wie folgt einteilen:

1. Web- und Browser-Automatisierung

Du brauchst einen Bot, der durch Webseiten navigiert, Daten sammelt oder Formulare ausfüllt? Hier sind deine passenden Libraries:

Selenium ist der Klassiker. Selenium steuert echte Browser (Chrome, Firefox, Edge) und eignet sich perfekt, wenn du Seiten mit JavaScript-Rendering brauchst. Allerdings ist Selenium nicht die schnellste Option.

Playwright ist der moderne Herausforderer. Playwright bietet bessere Performance, bessere DevTools-Integration und parallele Ausführung. Meine Empfehlung für neue Projekte.

BeautifulSoup und Requests sind deine leichtgewichtigen Alternativen. Requests macht HTTP-Calls, BeautifulSoup parsed HTML. Perfekt für statische Seiten, viel schneller als Browser-Automatisierung.

Hier ein Beispiel mit Playwright:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto('https://example.com')

    # Daten extrahieren
    titles = page.query_selector_all('.product-title')
    for title in titles:
        print(title.text_content())

    # Formular ausfüllen und absenden
    page.fill('input[name="query"]', 'Python Automation')
    page.click('button[type="submit"]')
    page.wait_for_load_state('networkidle')

    browser.close()

from playwright.sync_api import sync_playwright

with sync_playwright() as p:

browser = p.chromium.launch(headless=True)

page = browser.new_page()

page.goto('https://example.com')

# Daten extrahieren

titles = page.query_selector_all('.product-title')

for title in titles:

print(title.text_content())

# Formular ausfüllen und absenden

page.fill('input[name="query"]', 'Python Automation')

page.click('button[type="submit"]')

page.wait_for_load_state('networkidle')

browser.close()

Dieser Code navigiert zu einer Seite, extrahiert Text und füllt ein Formular aus. Macht, was ein Mensch manuell tun würde, nur eben tausendmal schneller.

2. Dateien automatisiert verarbeiten

Die meisten Automatisierungsprojekte starten mit der einfachen Frage: “Wie kann ich CSV- und Excel-Dateien effektiver verarbeiten?”. Auch hier die passenden Python-Tools:

Polars ist das moderne Power-Tool für strukturierte Datenverarbeitung. Im Gegensatz zu Pandas ist Polars in Rust geschrieben, multi-threaded by default und bietet sowohl eager als auch lazy Evaluation. Für Automatisierungs-Szenarien mit größeren Datenmengen ist Polars um Größenordnungen schneller und speichereffizienter als Pandas.

OpenPyXL und XlsxWriter sind deine Tools für Excel-Automatisierung.

Hier ein praktisches Beispiel für Datei-Reorganisation mit Polars:

from pathlib import Path
import polars as pl
from datetime import datetime

# CSV-Datei mit Logs lesen und filtern
df = pl.read_csv('automation_logs.csv')

# Lazy Evaluation für Performance
result = (
    df.lazy()
    .filter(pl.col('status') == 'error')
    .group_by('date')
    .agg(
        pl.col('message').count().alias('error_count'),
        pl.col('duration').mean().alias('avg_duration')
    )
    .sort('date', descending=True)
    .collect()  # Erst hier wird tatsächlich berechnet
)

print(result)

# Ergebnis in optimiertes Parquet-Format speichern
result.write_parquet('error_summary.parquet')

from pathlib import Path

import polars as pl

from datetime import datetime

# CSV-Datei mit Logs lesen und filtern

df = pl.read_csv('automation_logs.csv')

# Lazy Evaluation für Performance

result = (

df.lazy()

.filter(pl.col('status') == 'error')

.group_by('date')

.agg(

pl.col('message').count().alias('error_count'),

pl.col('duration').mean().alias('avg_duration')

)

.sort('date', descending=True)

.collect() # Erst hier wird tatsächlich berechnet

)

print(result)

# Ergebnis in optimiertes Parquet-Format speichern

result.write_parquet('error_summary.parquet')

Warum Polars hier herausragt: Es liest die CSV, filtert nach Errors, aggregiert, sortiert und speichert alles in einem einzigen optimierten Query-Plan. Kein Datensatz wird zweimal in den Speicher geladen. Polars ist typischerweise 2-11x schneller als Pandas bei solchen Operationen.

3. Task-Scheduling und Workflow-Automatisierung

Nicht jede Automatisierung ist ein einmaliges Script. Manche Tasks müssen regelmässig laufen. Hier kommen Scheduler ins Spiel.

Schedule ist das einfachste Tool. Wenn du nur Python-Code brauchst ohne externe Dependencies.

APScheduler ist das Power-Tool für komplexere Anforderungen.

Airflow und Celery sind die großen Players für Enterprise-Workflows.

Beispiel mit dem schedule Modul:

import schedule
import time

def backup_databases():
    print(f'[{time.strftime("%H:%M:%S")}] Backup läuft...')
    # Dein Backup-Logic hier
    pass

def send_reports():
    print(f'[{time.strftime("%H:%M:%S")}] Reports werden versendet...')
    # Dein Report-Logic hier
    pass

# Schedule definieren
schedule.every().day.at('02:00').do(backup_databases)
schedule.every().monday.at('09:00').do(send_reports)
schedule.every(30).minutes.do(lambda: print('Healthcheck'))

# Scheduler starten
while True:
    schedule.run_pending()
    time.sleep(60)

import schedule

import time

def backup_databases():

print(f'[{time.strftime("%H:%M:%S")}] Backup läuft...')

# Dein Backup-Logic hier

pass

def send_reports():

print(f'[{time.strftime("%H:%M:%S")}] Reports werden versendet...')

# Dein Report-Logic hier

pass

# Schedule definieren

schedule.every().day.at('02:00').do(backup_databases)

schedule.every().monday.at('09:00').do(send_reports)

schedule.every(30).minutes.do(lambda: print('Healthcheck'))

# Scheduler starten

while True:

schedule.run_pending()

time.sleep(60)

Dieses Pattern läuft im Hintergrund und führt Tasks zu bestimmten Zeiten aus.

Best Practices für robuste Automatisierungs-Scripts

1. Logging ist nicht optional, es ist dein Freund

Die alte print()-Debugging-Phase war gestern. Professionelle Automatisierung nutzt logging:

import logging
from datetime import datetime

# Logger konfigurieren
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(f'automation_{datetime.now().strftime("%Y%m%d")}.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

def process_data(data):
    try:
        logger.info(f'Verarbeite {len(data)} Einträge')
        # Dein Code
        logger.info('Verarbeitung abgeschlossen')
    except Exception as e:
        logger.error(f'Fehler bei Verarbeitung: {str(e)}', exc_info=True)

import logging

from datetime import datetime

# Logger konfigurieren

logging.basicConfig(

level=logging.INFO,

format='%(asctime)s - %(levelname)s - %(message)s',

handlers=[

logging.FileHandler(f'automation_{datetime.now().strftime("%Y%m%d")}.log'),

logging.StreamHandler()

]

)

logger = logging.getLogger(__name__)

def process_data(data):

try:

logger.info(f'Verarbeite {len(data)} Einträge')

# Dein Code

logger.info('Verarbeitung abgeschlossen')

except Exception as e:

logger.error(f'Fehler bei Verarbeitung: {str(e)}', exc_info=True)

2. Error Handling und Retry-Logik

Deine Automation läuft nachts, und dann crasht sie wegen einer flüchtigen Netzwerkverbindung. Deshalb brauchst du Retry-Logik, z.B. mit tenacity:

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10)
)
def fetch_data_from_api(url):
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    return response.json()

# Versucht bis zu 3x, wartet exponentiell länger zwischen Versuchen

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(

stop=stop_after_attempt(3),

wait=wait_exponential(multiplier=1, min=2, max=10)

)

def fetch_data_from_api(url):

response = requests.get(url, timeout=10)

response.raise_for_status()

return response.json()

# Versucht bis zu 3x, wartet exponentiell länger zwischen Versuchen

3. Konfiguration externalisieren

Hardcodierte Werte sind der Feind von wartbarer Automatisierung. Nutze Environment-Variablen oder Config-Dateien mit dotenv:

import os
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv('API_KEY')
DATABASE_URL = os.getenv('DATABASE_URL')
BACKUP_SCHEDULE = os.getenv('BACKUP_SCHEDULE', '02:00')  # Mit Default

if not API_KEY:
    raise ValueError('API_KEY nicht in Umgebungsvariablen gesetzt')

import os

from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv('API_KEY')

DATABASE_URL = os.getenv('DATABASE_URL')

BACKUP_SCHEDULE = os.getenv('BACKUP_SCHEDULE', '02:00') # Mit Default

if not API_KEY:

raise ValueError('API_KEY nicht in Umgebungsvariablen gesetzt')

4. Testen deiner Automations-Scripts

Ja, du brauchst Tests. Auch für Automation. Pytest ist dein Tool:

import pytest
from automation import process_data

def test_process_data_success():
    result = process_data([1, 2, 3])
    assert result == 6

def test_process_data_empty():
    result = process_data([])
    assert result == 0

def test_process_data_error():
    with pytest.raises(ValueError):
        process_data(None)

import pytest

from automation import process_data

def test_process_data_success():

result = process_data([1, 2, 3])

assert result == 6

def test_process_data_empty():

result = process_data([])

assert result == 0

def test_process_data_error():

with pytest.raises(ValueError):

process_data(None)

Polars statt Pandas: Ein strategischer Shift für Automationen

Wenn deine Automatisierungen mit mittleren bis großen Datenmengen arbeiten, ist Polars die bessere Wahl. Hier’s warum:

Performance: Polars ist durchschnittlich 3-5x schneller als Pandas. Bei Parquet-Dateien oder komplexen Filters sogar 10x+. Wenn deine Automatisierung täglich läuft, sind diese Unterschiede real.

Memory-Effizienz: Polars arbeitet spaltenbasiert und materialisiert keine Zwischenergebnisse. Peak Memory-Nutzung ist minimal. Bei automatisierten Prozessen auf begrenzten Systemen (VM, Container) ist das entscheidend.

Lazy Evaluation: Du definierst den gesamten Transformations-Plan, Polars optimiert ihn, dann wird alles in einem Durchgang ausgeführt. Das ist eleganter als Pandas’ Eager-Evaluation.

Hier ein realistisches Szenario: Deine Automatisierung muss täglich 5GB Logdaten verarbeiten:

import polars as pl
import time

start = time.time()

# Polars: Lazy Evaluation mit Optimierungen
df = pl.scan_parquet('huge_logs_*.parquet')

error_summary = (
    df.filter(
        (pl.col('level') == 'ERROR') |
        (pl.col('duration_ms') > 1000)
    )
    .group_by('service', 'timestamp')
    .agg([
        pl.col('message').count().alias('error_count'),
        pl.col('duration_ms').mean().alias('avg_duration'),
        pl.col('status_code').unique().alias('status_codes')
    ])
    .sort('error_count', descending=True)
    .collect()  # Erst hier findet die tatsächliche Berechnung statt
)

print(f'Polars: {time.time() - start:.2f}s')
error_summary.write_parquet('error_summary_today.parquet')

import polars as pl

import time

start = time.time()

# Polars: Lazy Evaluation mit Optimierungen

df = pl.scan_parquet('huge_logs_*.parquet')

error_summary = (

df.filter(

(pl.col('level') == 'ERROR') |

(pl.col('duration_ms') > 1000)

)

.group_by('service', 'timestamp')

.agg([

pl.col('message').count().alias('error_count'),

pl.col('duration_ms').mean().alias('avg_duration'),

pl.col('status_code').unique().alias('status_codes')

])

.sort('error_count', descending=True)

.collect() # Erst hier findet die tatsächliche Berechnung statt

)

print(f'Polars: {time.time() - start:.2f}s')

error_summary.write_parquet('error_summary_today.parquet')

Mit Pandas? Würde etwa 3-4x länger dauern. Und deutlich mehr RAM brauchen.

Die Automatisierungs-Trends 2026

Wo bewegt sich die Automations-Landschaft hin?

AI-getriebene Automation:
Tools wie AutoKeras vereinfachen ML-basierte Automationen. Du musst nicht mehr tief in ML-Details gehen, um intelligente Automationen zu bauen.

Async-First Entwicklung:
Frameworks wie Wove machen High-Latency Operationen effizienter. Async bleibt relevant.

Low-Code Automation Plattformen:
Nicht immer braucht es pure Python. n8n und ähnliche Plattformen erlauben minimalen Code für maximale Integration.
Du kannst n8n Workflows in Python integrieren oder Python direkt in n8n Code-Nodes benuten.

DevSecOps in der Automatisierung:
Sicherheit wird nicht hinzugefügt, sondern ist von Anfang an eingebaut. Linting-Tools mit AI-Support flaggen Sicherheitslöcher früh.

Rust & Performance-First Data Processing:
Polars Aufstieg ist kein Zufall. Teams verlangen nach Tools, die Daten effizienter verarbeiten. Rust findet sich in immer mehr Python-Packages und steigert deren Perfomance um ein Vielfaches.

Dein erster Automatisierungs-Move

Wie fängst du konkret an?

Identifiziere deine schmerzlichsten Aufgaben.
Was dauert am längsten und ist am repetitivsten?
Fang klein an.
Ein einfaches Script, das eine Aufgabe erledigt. Nicht das ganze System umkrempeln.
Nutze Libraries statt alles selbst zu bauen.
Die Python-Community hat bereits die harten Probleme gelöst.
Teste deine Scripts lokal intensiv, bevor sie in Produktion gehen.
Schreibe Logging ein, nicht am Ende.
Dein zukünftiges Ich wird dir dankbar sein.
Dokumentiere die Automation.
Ein Kommentar spart dir Stunden beim nächsten Review.
Erwäge Polars statt Pandas.
Die Performance-Gewinne sind echt, und die Syntax ist ähnlich vertraut.

Die gute Nachricht:
Die Zeit, die du in deine erste Automatisierung investierst, zahlst du innerhalb von Tagen zurück. Und jede weitere Automatisierung wird schneller.

Fazit

Python-Automatisierung ist nicht der Zukunftstrend, es ist bereits die Gegenwart. Mit den richtigen Tools, Best Practices und einer durchdachten Herangehensweise automatisierst du schnell und zuverlässig.

Die Top-Takeaways:

Nutze Playwright statt Selenium für neue Web-Automatisierungen
Logging und Error-Handling von Anfang an einbauen
Konfiguration externalisieren
Tests schreiben
Mit kleinen, fokussierten Scripts starten
Für Dateiverarbeitung und strukturierte Daten: Polars ist die erste Wahl.

Und jetzt viel Erfolg beim Automatisieren :-)

Lies mehr zum Thema Automatisierung.

Hat Dir der Beitrag gefallen?

Wenn Du Fragen oder Anmerkungen zu diesem Beitrag hast, dann starte einen Kommentar. DANKE für Dein Feedback!

GRATIS: Hol Dir Pulse², die App zu meinem Blog.

Name	Borlabs Cookie
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte, Impressum
Zweck	Speichert die Einstellungen der Besucher, die in der Cookie Box ausgewählt wurden.
Cookie Name	borlabs-cookie
Cookie Laufzeit	1 Jahr

Name	Wordpress Application Firewall
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte.
Zweck	Essentielles Session-Cookie um die Sicherheit unserer Website zu gewährleisten. Identifiziert den Besucher anhand einer anonymen ID um mehrfache Hackversuche wiederkehrender Besucher zu verhindern.
Cookie Name	icwp-wpsf

Name	Wordpress Login Session
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte.
Zweck	Dieses Session Cookie speichert den Zustand unseres Login-Bereichs, um festzustellen ob ein User eingeloggt ist oder nicht.
Cookie Name	swpm_session

Name	PHP Session ID
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte
Zweck	Dieses Session-Cookie wird benötigt um die einwandfreie Navigation auf unseren Seiten zu gewährleisten. Es identifiziert den Besucher anhand einer anonymen ID.
Cookie Name	PHPSESSID

Name	WooCommerce
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte
Zweck	Dieses Cookie wird zur Funktionalität des WooCommerce Onlineshops benötigt.
Cookie Name	woocommerce_cart_hash, tk_ai

Python in 2026, Automatisierung meistern: Schneller, smarter, effizienter mit modernen Tools