Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Code Mit Codeaktionen in Quick Automate können Sie benutzerdefinierte Logik mithilfe von Python-Codeblöcken implementieren, was über das hinausgeht, was standardmäßige Automatisierungsaktionen unterstützen. Sie eignen sich gut für komplexe Datentransformationen und Berechnungen und werden aus Sicherheitsgründen in einer eingeschränkten Python-Umgebung ausgeführt. **Zwei Arten von Code-Aktionen:** + **Einzeilige Ausdrücke:** Schnelle, einzeilige Operationen, die Variablen ändern, ohne Werte zurückzugeben + **Benutzerdefinierte Codeblöcke:** Multi-line Python-Funktionen für komplexe Logik mit Parametern und Rückgabewerten **Wann sollten Code-Aktionen verwendet werden:** Verwenden Sie Codeblöcke, wenn Sie: + Führen Sie komplexe Datentransformationen durch, die in Standardaktionen nicht verfügbar sind + Implementieren Sie benutzerdefinierte Geschäftslogik oder Berechnungen + Verarbeiten oder manipulieren Sie Datenstrukturen (Listen, Wörterbücher, JSON) + Arbeiten Sie auf benutzerdefinierte Weise mit Datum, Uhrzeit und Zeitzonen + Analysieren oder formatieren Sie Zeichenketten mit komplexen Mustern + Optimieren Sie die Automatisierungsleistung, indem Sie mehrere Aktionen in einem Codeblock konsolidieren **Wann sollten Codeaktionen nicht verwendet werden:** Vermeiden Sie Codeblöcke, wenn: + Für Ihren Anwendungsfall ist bereits eine standardmäßige Automatisierungsaktion vorhanden + Die Bedienung ist einfach genug für integrierte Aktionen + Sie müssen mit externen APIs interagieren (verwenden Sie stattdessen die REST-API-Integration) + Sie müssen auf Dateisysteme oder Datenbanken zugreifen (entsprechende Integrationen verwenden) **So greifen Sie auf Code-Aktionen zu:** Codeblöcke sind über mehrere Schnittstellen verfügbar: + **Bedienfeld „Aktionen“ (empfohlen):** + Öffnen Sie Ihre Automatisierung im Automation Builder + Klicken Sie auf der rechten Seite auf das Aktionsfeld + Suchen Sie im Abschnitt Code-Aktionen nach „Benutzerdefinierter Code-Block“ + Ziehen Sie den Codeblock per Drag-and-Drop in Ihren Automatisierungs-Workflow + **Mit Assistant erstellen:** + Verfügbar während der Planerstellung, wenn der Assistent feststellt, dass benutzerdefinierter Code benötigt wird + Der Assistent schlägt automatisch Codeblöcke für komplexe Operationen vor + Sie können Codeblöcke anfordern, indem Sie Ihre individuellen Logikanforderungen beschreiben **Verfügbare Aktionen:** ## Einzeilige Ausdrücke Einzeilige Ausdrücke führen einzeilige Python-Anweisungen aus, die Operationen ausführen, ohne einen Wert zurückzugeben. Sie eignen sich ideal für schnelle Änderungen an vorhandenen Variablen wie das Anhängen an Listen, das Aktualisieren von Wörterbüchern oder das Durchführen einfacher Berechnungen, die den Status ändern. **Eigenschaften:** + Ausdruck (erforderlich): Der Python Python-Ausdruck (z. B. „my\_list.append ('new item')“) **Beispiele:** + **An die Liste anhängen** ``` my_list.append("1") my_list.append(new_item) ``` + **Listenelemente werden entfernt** ``` task_list.remove(completed_task) ``` ## Benutzerdefinierter Codeblock Benutzerdefinierte Codeblöcke sind mehrzeilige Python-Funktionen, die komplexe Logik ausführen, Parameter akzeptieren und Werte zurückgeben. Sie sind die Ausweichoption, wenn Standard-Automatisierungsaktionen und einzeilige Ausdrücke für Ihre Anforderungen nicht ausreichen. **Eigenschaften:** + **Funktionstitel (erforderlich)**: Namenskennung für den Codeblock (z. B. "Calculate\_Total„) + **Funktion (erforderlich):** Python-Codeblock, der Ihre benutzerdefinierte Logik enthält. + Schritt 1: Parameter definieren + Klicken Sie auf die Schaltfläche „Bearbeiten“, um den Code-Editor zu öffnen + Klicken Sie im Parameterbereich auf „Hinzufügen“, um neue Parameter zu erstellen + Geben Sie Parameternamen ein, die Ihren Automatisierungsvariablen entsprechen + Parameter sind als Funktionsargumente verfügbar + Schritt 2: Schreiben Sie Ihren Python-Code + **Rückgabewert (optional):** Variablenname zum Speichern der Ausgabe der Funktion + Folgen Sie der erforderlichen Codeblockstruktur (siehe unten) + Implementieren Sie Ihre benutzerdefinierte Logik innerhalb der Funktion + Verwenden Sie nur zugelassene Bibliotheken und integrierte Funktionen + Fügen Sie eine Rücksendeerklärung bei, wenn Sie Daten ausgeben müssen **Struktur des Codeblocks** Alle Codeblöcke müssen diesem speziellen Format folgen: ``` @code_block() def your_function_name(parameter1, parameter2, parameter3): ------------------------------------------------------------------------------------- """ Optional: Add a docstring describing what your function does """ # Your custom logic here result = parameter1 + parameter2 + parameter3 return result ``` **Built-in Python-Funktionen und Importe** Alle integrierten Standardfunktionen von Python sind ohne Importe verfügbar (len, str, int usw.) **Zugelassene Standardbibliotheken (sicherheitsbeschränkt)** Codeblöcke können NUR diese Standardbibliotheken importieren: + `base64`- Base64 encoding/decoding + `datetime`- Datums- und Uhrzeitoperationen + `json`- Analyse und Generierung von JSON + `math`- Mathematische Funktionen + `re`- Reguläre Ausdrücke + `zoneinfo`- Umgang mit Zeitzonen **Anmerkung** Andere Standardbibliotheken als die oben aufgeführten können nicht importiert werden. Bibliotheken von Drittanbietern können nicht installiert oder importiert werden. `pip install`wird in Codeblöcken nicht unterstützt. **Einschränkungen** + Eingeschränkte Python-Umgebung mit eingeschränktem Bibliothekszugriff. Die Ausführungsumgebung basiert auf RestrictedPython einer Teilmenge von Python 3.10. + Codeblöcke können keine anderen Codeblöcke oder Aktionen aufrufen **Bewährte Methoden** + Halte die Codeblöcke einfach und fokussiert + Verwenden Sie beschreibende Funktionsnamen + Bevorzugen Sie immer vorgefertigte Aktionen, sofern verfügbar + Testen Sie Ihre Codeblöcke gründlich (da die gezielten Debugging-Optionen begrenzt sind) ****-Beispielanwendungsfälle + Mathematische Operationen (Kreiseigenschaften berechnen — Radius als Parameter) ``` def function (radius): return { "radius": radius, "diameter": 2 * radius, "circumference": round(2 * math.pi * radius, 2), "area": round(math.pi * radius ** 2, 2) } ``` + Wird aktuell date/time ``` def function (): now = datetime.datetime.now() return { "current_date": now.strftime("%Y-%m-%d"), "current_time": now.strftime("%H:%M:%S"), "formatted": now.strftime("%B %d, %Y at %I:%M %p"), "iso_format": now.isoformat(), "timestamp": now.timestamp() } ``` + Berechnung von Datumsunterschieden — Startdatum und Enddatum als Parameter ``` def function _(start_date_str, end_date_str): # Parse date strings (format: YYYY-MM-DD)_ start = datetime.datetime.strptime(start_date_str, "%Y-%m-%d") end = datetime.datetime.strptime(end_date_str, "%Y-%m-%d") _# Calculate difference_ difference = end - start return { "days": difference.days, "weeks": difference.days // 7, "start": start_date_str, "end": end_date_str } ``` + Mustervergleich und Textmanipulation mithilfe regulärer Ausdrücke (Validierung von E-Mail-Adressen, Telefonnummern usw.) ``` def function (email, phone, zip_code): email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' phone_pattern = r'^\d{3}-\d{3}-\d{4}$' zip_pattern = r'^\d{5}(-\d{4})?$' return { "email_valid": bool(re.match(email_pattern, email)), "phone_valid": bool(re.match(phone_pattern, phone)), "zip_valid": bool(re.match(zip_pattern, zip_code)) } ``` + Operationen auflisten (Liste filtern und transformieren) ``` def function (numbers, threshold): # Filter numbers above threshold and calculate statistics filtered = [n for n in numbers if n > threshold] if filtered: return { "filtered_numbers": filtered, "count": len(filtered), "sum": sum(filtered), "average": sum(filtered) / len(filtered), "min": min(filtered), "max": max(filtered) } else: return { "filtered_numbers": [], "count": 0, "message": "No numbers above threshold" } ```