L'input dell'utente fa schifo. Non puoi fidarti di quegli utenti per ottenere qualcosa di giusto, e quindi devi gestire tutti i tipi di casi speciali che rendono la vita difficile. Detto questo, possiamo minimizzare la difficoltà con i principi generali.

Convalidare in anticipo, non spesso

Controlla l'input per la validità non appena viene letto nel tuo programma. Se si legge in una stringa che dovrebbe essere un numero, convertirlo in un numero subito e reclamare all'utente se non è un numero. Tutti i dati canaglia che non verifichi in ingresso si faranno strada nel resto del programma e produrranno bug.

Ora, non puoi sempre farlo. Ci saranno casi in cui non è possibile verificare subito le proprietà corrette e sarà necessario verificarle durante l'elaborazione successiva. Ma vuoi che avvenga il più presto possibile la verifica in modo da avere i casi speciali attorno alla logica di input centralizzata in una posizione il più possibile.

Usa schemi

Consideriamo una funzione che analizza alcuni json.

def parse_student(text):
    try: 
        data = json.parse(text)
    except ValueError as error:
        raise ParseError(error)

    if not isinstance(data, dict):
        raise ParseError("Expected an object!")

    try:
        name = data['name']
    except KeyError:
        raise ParseError('Expected a name')

    if not isinstance(name, dict):
       raise ParseError("Expected an object for name")

    try:
        first = name['first']
    except KeyError:
        raise ParseError("Expected a first name")

    if not isinstance(first, basestring):
        raise ParseError("Expected first name to be a string")

    if first == '':
        raise ParseError("Expected non-empty first name")

Era molto lavoro solo per estrarre il nome, per non parlare di altri attributi. Possiamo rendere questo molto meglio se possiamo usare uno schema JSON. Vedi: link .

Posso descrivere come appare il mio oggetto studente:

{
    "type": "object",
    "properties": {
        "name": {
            "type": "object",
            "properties": {
                  "first" : {
                       "type" : "string"
                  }
            },
            "required": "first"
        },
    } 
    "required": ["name"]
}

Quando analizzo, faccio qualcosa del tipo:

def parse_student(text):
    try: 
        data = json.parse(text)
    except ValueError as error:
        raise ParseError(error)

    try:
        validate(data, STUDENT_SCHEMA)
    except ValidationError as error:
        raise ParseError(error)

    first = data['name']['first']

Il controllo dello schema verifica la presenza della struttura di cui ho bisogno. Se l'input dell'utente ha esito negativo nello schema, il validatore dello schema produrrà un messaggio di errore che spiega esattamente cosa è stato sbagliato. Lo farà in modo più coerente e corretto se poi scrissi manualmente il codice di controllo. Una volta superata la convalida, posso semplicemente estrarre i dati dall'oggetto json, perché so che avrà la struttura corretta.

Ora, probabilmente non stai analizzando JSON. Ma potresti scoprire che puoi fare qualcosa di simile per il tuo formato che ti consente di riutilizzare la logica di convalida di base tra le diverse informazioni che ottieni.

Probabilmente puoi semplificare il tuo codice centralizzando la prova / eccetto la validazione di argomenti di funzione e la conversione di eccezioni nella classe di eccezioni, in uno o due decoratori, che applichi a ciascuno dei tuoi metodi e funzioni. google per decoratori python per eccezioni e decoratori python per convalidare gli argomenti e troverete esempi di stackoverflow come    questo e questo .

Spesso non è necessario convalidare esplicitamente gli argomenti del metodo come il tuo codice andando a causare eccezioni naturalmente, e questo potrebbe essere abbastanza buono, come non puoi testare per tutte le eventualità.

Ricorda quando scrivi uno script, che spesso il tuo codice sarà ancora più utile se qualcuno può includerlo come modulo di libreria, in modo che principale sia specifico per ciò che un utente vorrebbe dalla riga di comando, ma nella parte della libreria non tentare troppo di oscurare dove un'eccezione deriva da e così via.