View a markdown version of this page

Codice - Amazon Quick
Espressioni a riga singolaBlocco di codice personalizzato

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Codice

Le azioni di codice in Quick Automate consentono di implementare la logica personalizzata utilizzando blocchi di codice Python, andando oltre ciò che supportano le azioni di automazione standard. Sono adatti per trasformazioni e calcoli di dati complessi e vengono eseguiti in un ambiente Python limitato per mantenere la sicurezza.

Due tipi di azioni di codice:

  • Espressioni a riga singola: operazioni rapide su una riga che modificano le variabili senza restituire valori

  • Blocchi di codice personalizzati: funzioni Multi-line Python per logica complessa con parametri e valori restituiti

Quando utilizzare le azioni del codice:

Usa i blocchi di codice quando devi:

  • Esegui trasformazioni di dati complesse non disponibili nelle azioni standard

  • Implementa logica o calcoli aziendali personalizzati

  • Elabora o manipola strutture di dati (elenchi, dizionari, JSON)

  • Lavora con date, orari e fusi orari in modi personalizzati

  • Analizza o formatta stringhe con motivi complessi

  • Ottimizza le prestazioni di automazione consolidando più azioni in un unico blocco di codice

Quando non utilizzare le azioni di codice:

Evita i blocchi di codice quando:

  • Esiste già un'azione di automazione standard per il tuo caso d'uso

  • L'operazione è abbastanza semplice per le azioni integrate

  • È necessario interagire con API esterne (utilizzare invece l'integrazione dell'API REST)

  • È necessario accedere ai file system o ai database (utilizzare le integrazioni appropriate)

Come accedere alle azioni del codice:

I blocchi di codice sono disponibili tramite più interfacce:

  • Pannello delle azioni (consigliato):

    • Apri la tua automazione nel generatore di automazione

    • Fai clic sul pannello delle azioni sul lato destro

    • Individua «Blocco di codice personalizzato» nella sezione Azioni relative al codice

    • Trascina e rilascia il blocco di codice nel tuo flusso di lavoro di automazione

  • Crea con Assistant:

    • Disponibile durante la generazione del piano quando l'assistente determina che è necessario un codice personalizzato

    • L'assistente suggerisce automaticamente blocchi di codice per operazioni complesse

    • Puoi richiedere blocchi di codice descrivendo le tue esigenze logiche personalizzate

Azioni disponibili:

Espressioni a riga singola

Le espressioni a riga singola eseguono istruzioni Python a riga singola che eseguono operazioni senza restituire un valore. Sono ideali per apportare modifiche rapide alle variabili esistenti, ad esempio aggiungendole a elenchi, aggiornando dizionari o eseguendo semplici calcoli che modificano lo stato.

Proprietà:

  • Espressione (richiesta): l'espressione Python da eseguire (ad esempio, «my_list.append ('new item')»)

Esempi:

  • Aggiungere alla lista

    my_list.append("1")
my_list.append(new_item)

  • Rimozione degli elementi dell'elenco

    task_list.remove(completed_task)

Blocco di codice personalizzato

I blocchi di codice personalizzati sono funzioni Python multilinea che eseguono logiche complesse, accettano parametri e restituiscono valori. Sono l'opzione di riserva quando le azioni di automazione standard e le espressioni a riga singola non sono sufficienti per le tue esigenze.

Proprietà:

  • Titolo della funzione (obbligatorio): identificatore del nome per il blocco di codice (ad esempio, "Calculate_Total«)

  • Funzione (richiesta): blocco di codice Python che contiene la logica personalizzata.

    • Fase 1: Definizione dei parametri

      • Fai clic sul pulsante «Modifica» per aprire l'editor di codice

      • Nel pannello Parametri, fai clic su «Aggiungi» per creare nuovi parametri

      • Immettete i nomi dei parametri che corrispondono alle variabili di automazione

      • I parametri sono disponibili come argomenti delle funzioni

    • Passaggio 2: scrivere il codice Python

  • Valore restituito (opzionale): nome della variabile per memorizzare l'output della funzione

    • Segui la struttura a blocchi di codice richiesta (vedi sotto)

    • Implementa la tua logica personalizzata all'interno della funzione

    • Utilizza solo librerie approvate e funzioni integrate

    • Includi una dichiarazione return se hai bisogno di generare dati

Struttura a blocchi di codice

Tutti i blocchi di codice devono seguire questo formato specifico:

@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 Funzioni e importazioni in Python

Tutte le funzioni standard integrate in Python sono disponibili senza importazioni (len, str, int, ecc.)

Librerie standard approvate (con restrizioni di sicurezza)

I blocchi di codice possono importare SOLO queste librerie standard:

  • base64- Base64 encoding/decoding

  • datetime- Operazioni con data e ora

  • json- Analisi e generazione di JSON

  • math- Funzioni matematiche

  • re- Espressioni regolari

  • zoneinfo- Gestione del fuso orario

Nota

  • Non è possibile importare librerie standard diverse da quelle sopra elencate.

  • Impossibile installare o importare librerie di terze parti. pip installnon è supportato nei blocchi di codice.

Limitazioni

  • Ambiente Python limitato con accesso limitato alla libreria. L'ambiente di esecuzione è basato su RestrictedPython un sottoinsieme di Python 3.10.

  • I blocchi di codice non possono richiamare altri blocchi o azioni di codice

Best practice

  • Mantieni i blocchi di codice semplici e mirati

  • Usa nomi di funzioni descrittivi

  • Preferisci sempre le azioni predefinite quando disponibili

  • Testa a fondo i tuoi blocchi di codice (poiché le opzioni di debug mirate sono limitate)

Esempio Casi d'uso

  • Operazioni matematiche (calcolo delle proprietà del cerchio - raggio come parametro

    def function
(radius):

    return {
        "radius": radius,
        "diameter": 2 * radius,
        "circumference": round(2 * math.pi * radius, 2),
        "area": round(math.pi * radius ** 2, 2)
    }

  • Ottenere corrente 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()
    }

  • Calcolo delle differenze di data: data di inizio e data di fine come parametri

    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    }

  • Corrispondenza di modelli e manipolazione del testo mediante espressioni regolari (convalida di indirizzi e-mail, numeri di telefono, ecc.)

    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))
    }

  • Operazioni di elenco (elenco di filtraggio e trasformazione)

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