Tapez indiquant une liste d'un type spécifié

130

En utilisant les annotations de fonction de Python 3, il est possible de spécifier le type d'éléments contenus dans une liste homogène (ou une autre collection) à des fins d'indication de type dans PyCharm et d'autres IDE?

Un exemple de code pseudo-python pour une liste d'int:

def my_func(l:list<int>):
    pass

Je sais que c'est possible en utilisant Docstring ...

def my_func(l):
    """
    :type l: list[int]
    """
    pass

... mais je préfère le style d'annotation si c'est possible.

Eric W.
la source
Avez-vous essayé d'utiliser le même format dans les annotations de fonction? Qu'est-il arrivé?
jonrsharpe
@jonrsharpe Cela devrait générer une erreur car type object is not subscriptablelors de la définition de la fonction. Évidemment, vous pouvez utiliser une chaîne: def my_func(L: 'list[int]')mais je ne sais pas si PyCharm l'analysera en analysant les docstrings ...
Bakuriu
@Bakuriu oui, je voulais dire 'list[int]', excuses si ce n'était pas clair.
jonrsharpe
Il ne semble pas que PyCharm l'analysera comme il le fait avec des docstrings.
Eric W.20

Réponses:

161

Répondre à ma propre question; la réponse TLDR est Non Oui .

Mise à jour 2

En septembre 2015, Python 3.5 a été publié avec la prise en charge des indicateurs de type et inclut un nouveau module de saisie . Cela permet de spécifier les types contenus dans les collections. Depuis novembre 2015, JetBrains PyCharm 5.0 prend entièrement en charge Python 3.5 pour inclure les indices de type comme illustré ci-dessous.

Achèvement du code PyCharm 5.0 à l'aide d'indices de type

Mise à jour 1

Depuis mai 2015, PEP0484 (Type Hints) a été formellement accepté. Le projet d'implémentation est également disponible sur github sous ambv / typehinting .

Réponse originale

Depuis août 2014, j'ai confirmé qu'il n'était pas possible d'utiliser des annotations de type Python 3 pour spécifier des types dans des collections (ex: une liste de chaînes).

L'utilisation de docstrings formatés tels que reStructuredText ou Sphinx sont des alternatives viables et prises en charge par divers IDE.

Il semble également que Guido réfléchisse à l'idée d'étendre les annotations de type dans l'esprit de mypy: http://mail.python.org/pipermail/python-ideas/2014-August/028618.html

Eric W.
la source
Mise à jour: Il semble que l'indication de type pour inclure la prise en charge des types génériques a fait son chemin vers PEP484 python.org/dev/peps/pep-0484
Eric W.
75

Maintenant que Python 3.5 est officiellement sorti, il y a le module de support Type Hints - typinget le List«type» approprié pour les conteneurs génériques.

En d'autres termes, vous pouvez maintenant faire:

from typing import List

def my_func(l: List[int]):
    pass
alecxe
la source
10

Des commentaires de type ont été ajoutés depuis la PEP 484

from . import Monitor
from typing import List, Set, Tuple, Dict


active_monitors = [] # type: List[Monitor]
# or
active_monitors: List[Monitor] = []

# bonus
active_monitors: Set[Monitor] = set()
monitor_pair: Tuple[Monitor, Monitor] = (Monitor(), Monitor())
monitor_dict: Dict[str, Monitor] = {'codename': Monitor()}

# nested
monitor_pair_list: List[Dict[str, Monitor]] = [{'codename': Monitor()}]

Cela fonctionne actuellement pour moi sur PyCharm avec Python 3.6.4

Exemple d'image dans Pycharm

CoreCreatives
la source
4

Avec le soutien du BDFL, il est presque certain maintenant que python (probablement 3.5) fournira une syntaxe normalisée pour les indices de type via des annotations de fonction.

https://www.python.org/dev/peps/pep-0484/

Comme référencé dans le PEP, il existe un vérificateur de type expérimental (un peu comme pylint, mais pour les types) appelé mypy qui utilise déjà ce standard, et ne nécessite aucune nouvelle syntaxe.

http://mypy-lang.org/

Brendan Abel
la source
3

Depuis Python 3.9, les types intégrés sont génériques par rapport aux annotations de type (voir PEP 585 ). Cela permet de spécifier directement le type d'éléments:

def my_func(l: list[int]):
    pass

Divers outils peuvent prendre en charge cette syntaxe antérieure à Python 3.9. Lorsque les annotations ne sont pas inspectées lors de l'exécution, la syntaxe est valide en utilisant les guillemets ou __future__.annotations.

# quoted
def my_func(l: 'list[int]'):
    pass
# postponed evaluation of annotation
from __future__ import annotations

def my_func(l: list[int]):
    pass
MonsieurMiyagi
la source