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

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.

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.

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

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

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

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/

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