View a markdown version of this page

Code - Amazon Quick
Einzeilige AusdrückeBenutzerdefinierter Codeblock

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 installwird 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"
        }