Diciamo che ho:Nota di tipo docstring Python - una classe, non un'istanza?
class A(object):
pass
class B(A):
pass
Voglio dichiarare una funzione che prende una sottoclasse di A come argomento:
def do_something(klass):
"""
:type klass: WHAT_HERE
"""
pass
Cosa devo mettere in WHAT_HERE? Se faccio questo:
:type klass: A
PyCharm pensa che dovrei dare un'istanza di A come argomento, non la classe stessa.
Secondo il pycharm docs il più vicino si può ottenere è:
() -> SomeClass
Quindi nel vostro esempio
def do_something(klass):
"""
:type klass:() -> A
"""
pass
Ciò significa (per PyCharm) che l'argomento che viene fornito è una funzione che restituisce un oggetto di un determinato tipo. Digiterà correttamente qualsiasi suggerimento dopo la creazione dell'oggetto.
Tutte le classi sono un'istanza della classe type:
>>> class Foo:
... pass
...
>>> type(Foo())
<class '__main__.Foo'>
>>> type(Foo)
<class 'type'>
>>> type(Foo) is type
True
Quindi, una valida risposta sarebbe:
:type klass: type
OK, ma poi dice solo che è * qualsiasi * tipo. Mi piacerebbe che PyCharm trattasse l'argomento come una sottoclasse di A. – Matt
temo che l'unico modo sarebbe utilizzare una metaclasse. Ma non sono sicuro che PyCharm lo supporti. –
Guido risposto a questa domanda here, ma credo PyCharm non supporta correttamente la sintassi appropriata in Python 2. Credo la sintassi dovrebbe essere (...) -> A in PyCharm con Python 2. In Python 3, la sintassi appropriata è Callable[..., A].
Ho notato che PyCharm non tratta () -> A come classe; se chiami un metodo di classe su A usando questa sintassi, l'ispezione di PyCharm mostrerà che non può trovare il metodo di classe di riferimento.
Questo è stato filed in the JetBrains bugtracker, sebbene sia stato chiuso in base ai commenti precedenti. Dati i recenti commenti di Guido nel primo riferimento, spero che JetBrains riaprirà.
La risposta è Type. Se si dispone di un modulo typing installato, è possibile anche legata questa classe di essere una sottoclasse di qualcosa, come nel seguente esempio:
class BaseUser(): pass
class Admin(BaseUser): pass
class Staff(BaseUser): pass
class Client(BaseUser): pass
poi
from typing import Type, TypeVar
U = TypeVar('U', bound=BaseUser)
def new_user(user_class):
"""
type user_class: Type[U]
"""
return user_class()
e seguenti sono l'utilizzo
new_user(Admin)
new_user(Client)
new_user(Staff)
Pycharm | L'IDEA comprende gli spunti typing piuttosto buoni, quindi farà il trucco
Sfortunatamente questo causa problemi di inferenza di tipo in PyCharm per chiamare i metodi di classe disponibili su A. Puoi chiamare 'klass().klassmethod() ', ma questo istanzia la classe, che potrebbe non essere desiderabile. Grazie per il suggerimento però, '() -> A' aiuta almeno un po '. – Malina