Python 3 et typage statique

Merci d'avoir lu mon code!

en effet, il n'est pas difficile de créer un exécuteur d'annotation générique en Python. Voici mon point de vue:

'''Very simple enforcer of type annotations.

This toy super-decorator can decorate all functions in a given module that have 
annotations so that the type of input and output is enforced; an AssertionError is
raised on mismatch.

This module also has a test function func() which should fail and logging facility 
log which defaults to print. 

Since this is a test module, I cut corners by only checking *keyword* arguments.

'''

import sys

log = print


def func(x:'int' = 0) -> 'str':
    '''An example function that fails type checking.'''
    return x


# For simplicity, I only do keyword args.
def check_type(*args):
    param, value, assert_type = args
    log('Checking {0} = {1} of {2}.'.format(*args))
    if not isinstance(value, assert_type):
        raise AssertionError(
            'Check failed - parameter {0} = {1} not {2}.'
            .format(*args))
    return value

def decorate_func(func):    
    def newf(*args, **kwargs):
        for k, v in kwargs.items():
            check_type(k, v, ann[k])
        return check_type('<return_value>', func(*args, **kwargs), ann['return'])

    ann = {k: eval(v) for k, v in func.__annotations__.items()}
    newf.__doc__ = func.__doc__
    newf.__type_checked = True
    return newf

def decorate_module(module = '__main__'):
    '''Enforces type from annotation for all functions in module.'''
    d = sys.modules[module].__dict__
    for k, f in d.items():
        if getattr(f, '__annotations__', {}) and not getattr(f, '__type_checked', False):
            log('Decorated {0!r}.'.format(f.__name__))
            d[k] = decorate_func(f)


if __name__ == '__main__':
    decorate_module()

    # This will raise AssertionError.
    func(x = 5)

étant donné cette simplicité, il est étrange à première vue que cette chose n'est pas mainstream. Cependant, je crois qu'il y a de bonnes raisons pour lesquelles c'est pas aussi utile qu'il pourrait sembler . Généralement, la vérification de type aide parce que si vous ajoutez entier et dictionnaire, les chances sont vous faites une erreur évidente (et si vous voulez dire quelque chose de raisonnable, c'est quand même mieux vaut être explicite qu'implicite ).

mais dans la vie réelle vous mélangez souvent des quantités du même type d'ordinateur comme vu par le compilateur mais clairement différent type humain , par exemple l'extrait suivant contient une erreur évidente:

height = 1.75 # Bob's height in meters.
length = len(sys.modules) # Number of modules imported by program.
area = height * length # What's that supposed to mean???

tout humain devrait immédiatement voir une erreur dans le au-dessus de la ligne à condition qu'il connaisse le 'type humain' des variables height et length même si il regarde à l'ordinateur comme parfaitement légal multiplication de int et float .

il y a plus à dire sur les solutions possibles à ce problème, mais faire respecter les "types d'ordinateurs" est apparemment une demi-solution, donc, du moins à mon avis, c'est pire qu'aucune solution du tout . C'est la même raison pourquoi systèmes hongrois est une idée terrible tandis que Apps hongrois est une grande. Il y a plus sur le très instructif poste de Joel Spolsky .

maintenant si quelqu'un devait implémenter une sorte de bibliothèque pythonique tierce partie qui assignerait automatiquement aux données du monde réel son type humain et a ensuite pris soin de transformer ce type comme width * height -> area et d'appliquer que vérifier avec les annotations de fonction, je pense que ce serait un type vérifiant les gens pourraient vraiment utiliser!