Tipo che suggerisce un elenco di un tipo specificato

Utilizzando le annotazioni di funzione di Python 3, è possibile specificare il tipo di elementi contenuti all'interno di un elenco omogeneo (o altra raccolta) allo scopo di suggerire il tipo in PyCharm e altri IDE?

Un esempio di codice pseudo-python per un elenco di int:

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

So che è possibile usare Docstring ...

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

... ma preferisco lo stile di annotazione, se possibile.

Rispondendo alla mia stessa domanda; la risposta TLDR è No Sì .

Aggiorna 2

Nel settembre 2015, Python 3.5 è stato rilasciato con il supporto per i suggerimenti sul tipo e include un nuovo modulo di digitazione . Ciò consente la specifica dei tipi contenuti nelle raccolte. A partire da novembre 2015, JetBrains PyCharm 5.0 supporta completamente Python 3.5 per includere i suggerimenti sul tipo come illustrato di seguito.

Aggiorna 1

A partire da maggio 2015, PEP0484 (Type Hints) è stato formalmente accettato. La bozza di implementazione è disponibile anche su github sotto ambv / typehinting .

Risposta originale

A partire da agosto 2014, ho confermato che non è possibile utilizzare le annotazioni di tipo Python 3 per specificare i tipi all'interno delle raccolte (es: un elenco di stringhe).

L'uso di docstrings formattate come reStructuredText o Sphinx sono alternative valide e supportate da vari IDE.

Sembra anche che Guido stia riflettendo sull'idea di estendere le annotazioni di tipo nello spirito di mypy: http://mail.python.org/pipermail/python-ideas/2014-August/028618.html

Ora che Python 3.5 è ufficialmente disponibile, c'è il modulo di supporto dei suggerimenti sul tipo - typinge il relativo List"tipo" per i contenitori generici.

In altre parole, ora puoi fare:

from typing import List

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

I commenti sul tipo sono stati aggiunti dopo 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()}]

Questo attualmente funziona per me su PyCharm con Python 3.6.4

Immagine di esempio in Pycharm

Con il supporto del BDFL, è quasi certo ora che python (probabilmente 3.5) fornirà una sintassi standardizzata per i suggerimenti sul tipo tramite annotazioni di funzione.

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

Come indicato nel PEP, esiste un controllo di tipo sperimentale (un po 'come pylint, ma per i tipi) chiamato mypy che utilizza già questo standard e non richiede alcuna nuova sintassi.

http://mypy-lang.org/

A partire da Python 3.9, i tipi incorporati sono generici rispetto alle annotazioni di tipo (vedere PEP 585 ). Ciò consente di specificare direttamente il tipo di elementi:

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

Vari strumenti possono supportare questa sintassi prima di Python 3.9. Quando le annotazioni non vengono controllate in fase di esecuzione, la sintassi è valida utilizzando le virgolette o __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