Meilleure pratique en python pour la valeur de retour sur l'erreur par rapport au succès

il serait préférable de soulever une exception que de retourner une valeur spéciale. C'est exactement pour cela que les exceptions ont été conçues, pour remplacer les codes d'erreur par un mécanisme de traitement des erreurs plus robuste et structuré.

class IntersectException(Exception):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return self.msg

def intersect_two_lists(self, list1, list2):
    if not list1: raise IntersectException("list1 must not be empty.")
    if not list2: raise IntersectException("list2 must not be empty.")

    #http://bytes.com/topic/python/answers/19083-standard
    return filter(lambda x:x in list1,list2)

dans ce cas précis, bien que je laisse tomber les tests. Il n'y a rien de mal à recouper des listes vides, vraiment. Aussi lambda est en quelque sorte découragé ces jours-ci de préférence à des compréhensions de liste. Voir trouver l'intersection de deux listes? pour un couple de façons d'écrire ceci sans utiliser lambda .

je voudrais retourner un n-uplet:

(Vrai, some_result)

(Faux, some_useful_response)

l'objet some_useful_response peut être utilisé pour gérer la condition de retour ou peut servir à afficher des informations de débogage.

NOTE : cette technique s'applique aux valeurs de retour de toute sorte. Il ne pas confondre avec exceptions .

à la réception, vous avez juste à déballer:

Code de Réponse = une_fonction(...)

cette technique s'applique au flux de commande" normal": il faut utiliser la fonctionnalité d'exception lorsque des entrées / traitements inattendus se produisent.

à noter aussi: cette technique aide à normaliser les retours de fonction. Le programmeur et l'utilisateur des fonctions savoir à quoi s'attendre .

AVERTISSEMENT: je viens d'une Erlang fond :-)

sont certainement meilleures (et plus Pythoniques) que les retours de statut. Pour beaucoup plus sur ce point: Exceptions vs statut renvoie

le cas général est de jeter des exceptions pour des circonstances exceptionnelles. Je souhaite que je pourrais me souvenir de la citation exacte (ou qui l'a dit), mais vous devriez vous efforcer pour les fonctions qui acceptent autant de valeurs et de types comme est raisonnable et maintenir un comportement très étroitement défini. C'est une variante de ce que Nadia parlait de . Considérez les usages suivants de votre fonction:

1. intersect_two_lists(None, None)
2. intersect_two_lists([], ())
3. intersect_two_lists('12', '23')
4. intersect_two_lists([1, 2], {1: 'one', 2: 'two'})
5. intersect_two_lists(False, [1])
6. intersect_two_lists(None, [1])

Je m'attendrais à ce que (5) lance une exception puisque passer False est une erreur de type. Le reste d'entre eux, cependant, font une sorte de sens, mais il dépend vraiment du contrat que la fonction déclare. Si intersect_two_lists étaient définis comme renvoyant le intersection de deux itérables , puis tout autre que (5) devrait fonctionner aussi longtemps que vous faites None une représentation valide du jeu vide . La mise en œuvre serait quelque chose comme:

def intersect_two_lists(seq1, seq2):
    if seq1 is None: seq1 = []
    if seq2 is None: seq2 = []
    if not isinstance(seq1, collections.Iterable):
        raise TypeError("seq1 is not Iterable")
    if not isinstance(seq2, collections.Iterable):
        raise TypeError("seq1 is not Iterable")
    return filter(...)

j'écris habituellement des fonctions d'aide qui font respecter le contrat, quel qu'il soit, et je les appelle ensuite pour vérifier toutes les conditions préalables. Quelque chose comme:

def require_iterable(name, arg):
    """Returns an iterable representation of arg or raises an exception."""
    if arg is not None:
        if not isinstance(arg, collections.Iterable):
            raise TypeError(name + " is not Iterable")
        return arg
    return []

def intersect_two_lists(seq1, seq2):
    list1 = require_iterable("seq1", seq1)
    list2 = require_iterable("seq2", seq2)
    return filter(...)

vous pouvez aussi étendre ce concept et passer dans le "Politique comme un argument facultatif. Je ne conseillerais pas de le faire à moins que vous ne souhaitiez adopter Policy Based Design . Je voulais vous le dire au cas où vous n'auriez pas envisagé cette option.

si le contrat pour intersect_two_lists est qu'il n'accepte que deux paramètres list non vides, alors être explicite et jeter des exceptions si le contrat n'est pas respecté:

def require_non_empty_list(name, var):
    if not isinstance(var, list):
        raise TypeError(name + " is not a list")
    if var == []:
        raise ValueError(name + " is empty")

def intersect_two_lists(list1, list2):
    require_non_empty_list('list1', list1)
    require_non_empty_list('list2', list2)
    return filter(...)

je pense que la morale de l'histoire est quoi que vous fassiez, faites-le systématiquement et soyez explicite . Personnellement, je suis généralement favorable à l'augmentation des exceptions chaque fois qu'un contrat est violé ou on me donne une valeur que je ne peux vraiment pas utiliser. Si les valeurs que je donne sont raisonnables, alors j'essaie de faire quelque chose de raisonnable en retour. Vous pouvez également lire la rubrique de la FAQ C++ sur les exceptions. Cette entrée donne vous un peu plus matière à réflexion sur les exceptions.

pour collections (listes, sets, dicts, etc.) retourner une collection vide est le choix évident car il permet à la logique de votre site d'appel de rester à l'écart de la logique défensive. Plus explicitement, une collection vide est toujours une réponse parfaitement bonne d'une fonction à partir de laquelle vous attendez une collection, vous ne devez pas vérifier que le résultat est de tout autre type, et peut continuer votre logique d'affaires d'une manière propre.

pour les résultats de non-collecte Il ya plusieurs façons de traiter les retours conditionnels:

1. comme de nombreuses réponses l'ont déjà expliqué, l'utilisation D'Exceptions est une façon de résoudre ce problème, et est idiomatique python. Cependant, je préfère ne pas utiliser d'Exceptions pour le flux de contrôle, car je trouve que cela crée une ambiguïté sur les intentions d'une Exception. Il faut plutôt prévoir des Exceptions dans des situations exceptionnelles réelles.
2. une autre solution est de retourner None au lieu de votre résultat attendu, mais cela force un utilisateur à ajouter des contrôles défensifs partout dans leurs sites d'appel, brouillant la logique d'affaires réelle qu'ils essaient d'exécuter.
3. une troisième façon consiste à utiliser un type de collection qui ne peut contenir qu'un seul élément (ou qui est explicitement vide). Ceci est appelé un optionnel et est ma méthode préférée parce qu'il vous permet de garder la logique de site d'appel propre. Cependant, python n'est intégré dans l'option type, donc j'utilise mon propre. Je l'ai édité dans une petite bibliothèque appelée optional.py si quelqu'un veut l'essayer. Vous pouvez l'installer en utilisant pip install optional.py . Je me félicite de commentaires, de demandes de fonctionnalités, et de contributions.