Type hinting en Python 2

Dans PEP 484, type hinting a été ajouté à Python 3 avec l'inclusion de la en tapant module. Est-il possible de le faire en Python 2? Tout ce que je peux penser est d'avoir un décorateur d'ajouter à des méthodes de vérification des types, mais ce serait un échec lors de l'exécution et de ne pas être pris plus tôt, comme l'insinue le permettrait.

InformationsquelleAutor Andrew | 2016-02-05

56

Selon a Suggéré que la syntaxe de Python 2.7 et à cheval sur le code en PEP 484 qui définit le type de l'affinage, il existe une autre syntaxe pour la compatibilité avec Python 2.7. Il n'est toutefois pas obligatoire donc je ne sais pas comment bien pris en charge, il est, mais en citant la PEP:
Certains outils peuvent vouloir le type de support des annotations dans le code qui doit être compatible avec Python 2.7. À cette fin, ce PEP a suggéré (mais pas obligatoire) d'extension où la fonction annotations sont placés dans un # type: commentaire. Un tel commentaire doit être placé immédiatement à la suite de la fonction header (avant la docstring). Un exemple: la suite de Python 3 code:
```
def embezzle(self, account: str, funds: int = 1000000, *fake_receipts: str) -> None:
    """Embezzle funds from account using fake receipts."""
    <code goes here>
```
est équivalente à la suivante:
```
def embezzle(self, account, funds=1000000, *fake_receipts):
    # type: (str, int, *str) -> None
    """Embezzle funds from account using fake receipts."""
    <code goes here>
```
Pour mypy de soutien, voir Type de vérification Python 2 code.
- Hmm ok, devrait avoir lu les docs plus loin. Savez-vous si il y a tout les outils de la prise en charge de cela? Pas sûr si c'est juste une norme ou s'il y a réelle de l'outillage encore mis en œuvre.
- Selon PyCharm "PyCharm prend en charge de type hinting en fonction des annotations et des commentaires à l'aide de la saisie de module défini par PEP 484." La référence au TYPE de COMMENTAIRES, il est clair qu'il doit être pris en charge. Je n'utilise pas pyCharm sur cet ordinateur donc je ne peux pas vérifier tout de suite. EDIT : lien vers pycharm: jetbrains.com/pycharm/help/...
- Merci aussi constaté que Emacs Jedi fonctionne comme ça aussi.
- Un peu hors-sujet: vous savez peut-être comment ai-je pu extraire ce type d'annotation en Python 2? Il n'est pas inclus dans __doc__ attr et __annotations__ attr n'est pas disponible en Python 2.
- Je ne connais pas d'outil automatique pour le faire, mais compte tenu de la PEP, ils doivent toujours être dans la ligne droite après la déclaration de la fonction et de commencer avec # type: de sorte que devrait être assez facile à obtenir avec les inspecter.getsourcelines (docs.python.org/2/library/inspect.html#inspect.getsourcelines), puis analysé.
- Actuellement, il y a un module disponible qui analyse Python avec le type de commentaires (et il semble à l'appui de Python 2.7) appelé tapé-ast. Je l'utilise uniquement pour Python 3.5 si.
- Ressemble à ce package peut analyser Python 2.7 type de commentaires, mais il nécessite Python 3 pour l'exécuter. Néanmoins utile, merci.
- Dites-vous que vous avez obtenu PEP-0484 annotation de type de travail dans Emacs Jedi avec Python 2 ? Ne fonctionne pas ici. Elle est annoncée comme pris en charge pour Python 3 seulement AFAIU (voir: "function annotations (python 3 seulement; python 2 fonction des annotations avec des commentaires prévues mais pas encore mis en œuvre)")
- Sera-ce de travailler sur des versions antérieures de Python 3?
InformationsquelleAutor Mijamo

À ce point, le recommandé et python3 compatible façon de le faire est de suivre les python2 à 3 guide : http://python-future.org/func_annotations.html

def embezzle(self, account: str, funds: int = 1000000, *fake_receipts: str) -> None:
    """Embezzle funds from account using fake receipts."""
    pass

Devenir:

def embezzle(self, account, funds = 1000000, *fake_receipts):
    """Embezzle funds from account using fake receipts."""
    pass
embezzle.__annotations__ = {'account': str, 'funds': int, 'fake_receipts': str, 'return': None}

cela ne fonctionnera pas pour les non-littérale des types comme List, Set

InformationsquelleAutor encolpe

Voici une fonction que j'ai écrit pour analyser le Python 2 type de commentaire et d'obtenir un n-uplet de types d'entrée et le type de retour. Il aurait besoin de quelques travaux pour travailler avec les définitions de type complexes à partir de la saisie de la bibliothèque (Tout, en Option, Liste, etc.):

class InvalidTypeHint(Exception):
    pass    

PYTHON_2_TYPE_HINT_REGEX = "\s*#\s*type:\s*(\(.+\))\s*->\s*(.+)\s*"

def parse_python_2_type_hint(typehint_string):
    # type: (str) -> (tuple, type)
    pattern = re.compile(PYTHON_2_TYPE_HINT_REGEX)
    search_results = pattern.search(typehint_string)
    if not search_results:
        raise InvalidTypeHint('%s does not match type hint spec regex %s' % (typehint_string, PYTHON_2_TYPE_HINT_REGEX))
    arg_types_str = search_results.group(1)
    return_type_str = search_results.group(2)
    try:
        arg_types_tuple = eval(arg_types_str)
        assert isinstance(arg_types_tuple, tuple)
        return_type = eval(return_type_str)
        assert isinstance(return_type, type)
    except Exception as e:
        raise InvalidTypeHint(e)
    return arg_types_tuple, return_type


def parse_arg_types_for_callable(func):
    # type:(callable)->tuple
    """

    :param func:
    :return: list of parameter types if successfully parsed, else None
    """

    # todo make this compatible with python 3 type hints
    # python 2.7 type hint
    source_lines = inspect.getsource(func).split("\n")
    def_statements = 0
    for source_line in source_lines:
        try:
            arg_types_tuple, return_type = parse_python_2_type_hint(source_line)
            return arg_types_tuple
        except InvalidTypeHint:
            if source_line.strip().startswith("def "):
                def_statements += 1
            if def_statements > 1:
                return None

InformationsquelleAutor Thomas Belluscio

Vous devez vous connecter pour publier un commentaire.