introduction

Une fois, j'ai posté un article sur mon blog intitulé Ecrire FizzBuzz avec des erreurs après avoir pratiqué Ruby. Cependant, il y a eu une réaction surprenante, et l'histoire suivante a été écrite en Qiita:

Je suis originaire de Python, j'ai donc écrit le code rapidement dans l'esprit de "Au fait, je n'ai pas écrit Python depuis longtemps, mes compétences seront ennuyeuses, et je suis la personne qui a écrit dans l'article original, donc MOTTAINAI !!" Vu.

Cependant, comme le modèle a déjà été décidé en moi, cela a pris environ 20 minutes, donc cela peut être une bonne idée de l'essayer comme guide (pour ceux qui ont confiance en Python).

Réponse pour le moment

class FizzBuzzError(Exception):
    def __init__(self, message, errors):
        self.message = message
        self.errors = errors


def fizzbuzz_function(n, message):
    def _return_fizz(i):
        try:
            1 / (i % n)
            return ''
        except ZeroDivisionError:
            raise FizzBuzzError(message, message)
    return _return_fizz


def error_message(f, *args, **kargs):
    def _f(n):
        try:
            return f(n)
        except FizzBuzzError as e:
            return e.message
    return _f


@error_message
def fizz(n):
    return fizzbuzz_function(3, "Fizz")(n)


@error_message
def buzz(n):
    return fizzbuzz_function(5, "Buzz")(n)


def fizzbuzz(n):
    return "".join([fizz(n), buzz(n)]) or n


def main():
    for i in [fizzbuzz(n + 1) for n in range(99)]:
        print(i)


if __name__ == "__main__":
    main()

Il s'agit d'une spécification Python3. Si vous utilisez Python2, veuillez utiliser ʻimport future from print_function``;) `

Commentaire

Je ne comprends pas les spécifications de l'erreur personnalisée de Python ...!

Je ne peux rien dire parce que je n'ai pas approfondi parce que je suis un peu loin de Python, mais je me demande si une telle implémentation est correcte. Pour le moment, j'utilise ce StackOverflow sans le comprendre, alors peut-être Cette implémentation peut être redondante.

class FizzBuzzError(Exception):
    def __init__(self, message, errors):
        self.message = message
        self.errors = errors

Après tout, Python utilise la fermeture

Ce qui rend Python un peu meilleur que Ruby est la facilité d'écriture des fermetures? Je pense honnêtement qu'il est gênant de faire un proc et un hoge en Ruby, et si vous n'ajoutez pas () en Python, j'aime personnellement la spécification de la gestion des objets de fonction (Masakari accueilli par Rubyist) ……!).

À propos, fizzbuzz est abstrait à ** s'il s'agit d'un multiple de quelque chose, il émet un message correspondant **. Si vous ne retirez que cette partie et la faites, il est pratique d'utiliser une fermeture en Python. En tant qu'exemple d'utilisation réel, il ressemble à ce qui suit.

def fizzbuzz_function(n, message):
    def _return_fizz(i):
        try:
            1 / (i % n)
            return ''
        except ZeroDivisionError:
            raise FizzBuzzError(message, message)
    return _return_fizz


def fizz(n):
    return fizzbuzz_function(3, "Fizz")(n)

La partie acquisition de message peut aussi être abstraite ... C'est une décoration!

Maintenant, réfléchissons plus loin. Nous voulons un hyper-retour d'Erreur, nous ne voulons pas d'erreur.

Si vous pouvez comprendre la fermeture, vous devriez essayer d'utiliser un décorateur. Pour la définition du décorateur, l'explication suivante de PEP 318 est la plus simple à comprendre, je vais donc la citer:

@dec2
@dec1
def func(arg1, arg2, ...):
    pass

This is equivalent to:

def func(arg1, arg2, ...):
    pass
func = dec2(dec1(func))

Ici dans ce code:

def error_message(f, *args, **kargs):
    def _f(n):
        try:
            return f(n)
        except FizzBuzzError as e:
            return e.message
    return _f

En Python, `" "` est faux!

C'est un point controversé, mais «» »est faux dans la spécification Python. En d'autres termes, si le résultat de la jonction des deux résultats est une chaîne vide, il est déjà faux, il vous suffit donc de renvoyer le numéro reçu tel quel. Cela semble pratique car il ne peut être écrit qu'avec le soi-disant «opérateur or»! Je n'ai pas besoin d'un opérateur ternaire!

def fizzbuzz(n):
    return "".join([fizz(n), buzz(n)]) or n

Résumé

Donc, cette fois, j'ai écrit sur l'erreur FizzBuzz de Python en fonction de la réaction inattendue.

Cependant, étant donné que l'article original est utilisé comme un Super retour, je pense qu'il est plus susceptible de souligner que «augmenter» n'est pas différent de simplement «retour» dans ce cas. Quand j'ai essayé de mettre l'accent sur le "décorateur" ou quelque chose comme Python, je me suis retrouvé avec le code ci-dessus.

Tâche

Maintenant, que faire si la langue n'a pas de gestion des erreurs?

Par exemple, je me souviens que Go n'a pas de syntaxe dédiée à la gestion des erreurs (je sais que «panic» et «recover» sont disponibles ...), mais dans le cas de Haskell. Il y a des moments où vous voulez voir quelque chose;)

Écrivons FizzBuzz avec une erreur: Version Python