Comment puis-je dire à PyCharm quel type de paramètre est prévu?
en ce qui concerne les constructeurs, les assignations et les appels de méthode, L'IDE de PyCharm est assez bon pour analyser mon code source et trouver quel type chaque variable devrait être. J'aime quand c'est juste, parce que ça me donne de bonnes informations sur l'achèvement du code et les paramètres, et ça me donne des avertissements si j'essaie d'accéder à un attribut qui n'existe pas.
Mais quand il s'agit de paramètres, il ne sait rien. Les abandons d'achèvement de code ne peuvent rien montrer, parce qu'ils Je ne sais pas quel type sera le paramètre. L'analyse du code ne peut pas chercher les Avertissements.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
peasant = Person("Dennis", 37)
# PyCharm knows that the "peasant" variable is of type Person
peasant.dig_filth() # shows warning -- Person doesn't have a dig_filth method
class King:
def repress(self, peasant):
# PyCharm has no idea what type the "peasant" parameter should be
peasant.knock_over() # no warning even though knock_over doesn't exist
King().repress(peasant)
# Even if I call the method once with a Person instance, PyCharm doesn't
# consider that to mean that the "peasant" parameter should always be a Person
cela a un certain sens. D'autres sites d'appel pourraient passer n'importe quoi pour ce paramètre. Mais si ma méthode s'attend à ce qu'un paramètre soit de type, disons, pygame.Surface , j'aimerais pouvoir l'indiquer à PyCharm en quelque sorte, pour qu'il puisse me montrer tous les attributs de Surface dans son dropdown Code-completion, et mettre en évidence les avertissements si j'appelle la mauvaise méthode, et donc sur.
y a-t-il un moyen de donner un indice à PyCharm, et de dire "psst, ce paramètre est supposé être de type X"? (Ou peut-être, dans l'esprit des langages dynamiques, "ce paramètre est censé faire coin-coin comme un X"? Je serais bien avec.)
modifier: la réponse de CrazyCoder, ci-dessous, fait l'affaire. Pour tous les nouveaux venus comme moi qui veulent le résumé rapide, voici:
class King:
def repress(self, peasant):
"""
Exploit the workers by hanging on to outdated imperialist dogma which
perpetuates the economic and social differences in our society.
@type peasant: Person
@param peasant: Person to repress.
"""
peasant.knock_over() # Shows a warning. And there was much rejoicing.
La partie pertinente est la ligne @type peasant: Person de docstring.
si vous allez aussi dans File > Settings > Python Integrated Tools et mettez" Docstring format "en" Epytext", alors la vue de PyCharm > Quick Documentation Lookup affichera les informations des paramètres au lieu de simplement imprimer toutes les lignes @-telles quelles.
5 réponses
Oui, vous pouvez utiliser un format de documentation spécial pour les méthodes et leurs paramètres afin que PyCharm puisse connaître le type. La version récente de PyCharm supporte les formats de doc les plus courants .
par exemple, PyCharm extrait des types de le style @param commente .
Voir aussi reStructuredText et docstring conventions (PEP 257).
Une autre option est les annotations Python 3.
s'il vous Plaît reportez-vous à la PyCharm section " documentation pour plus de détails et des exemples.
si vous utilisez Python 3.0 ou une version ultérieure, vous pouvez également utiliser des annotations sur les fonctions et les paramètres. PyCharm interprétera ces derniers comme le type que les arguments ou les valeurs de retour sont censés avoir:
class King:
def repress(self, peasant: Person) -> bool:
peasant.knock_over() # Shows a warning. And there was much rejoicing.
return peasant.badly_hurt() # Lets say, its not known from here that this method will always return a bool
parfois cela est utile pour les méthodes non-publiques, qui n'ont pas besoin d'un docstring. Comme avantage supplémentaire, ces annotations peuvent être accédées par code:
>>> King.repress.__annotations__
{'peasant': <class '__main__.Person'>, 'return': <class 'bool'>}
mise à Jour : PEP 484 , qui a été accepté pour Python 3.5, c'est aussi la convention officielle pour spécifier les types argument et retour en utilisant des annotations.
PyCharm extraits de types à partir d'une @type pydoc chaîne. Voir PyCharm docs ici et ici , et Epydoc docs . C'est dans la section' legacy ' de PyCharm, peut-être que ça manque de fonctionnalité.
class King:
def repress(self, peasant):
"""
Exploit the workers by hanging on to outdated imperialist dogma which
perpetuates the economic and social differences in our society.
@type peasant: Person
@param peasant: Person to repress.
"""
peasant.knock_over() # Shows a warning. And there was much rejoicing.
la partie pertinente est la ligne @type peasant: Person du document.
mon intention n'est pas de voler des points de CrazyCoder ou l'original interlocuteur, par tous les moyens de leur donner des points. J'ai juste pensé que la réponse simple devrait être dans un slot de "réponse".
j'utilise PyCharm Professional 2016.1 writing py2.6-2.7 code, et j'ai trouvé qu'en utilisant reStructuredText je peux exprimer les types d'une manière plus succincte:
class Replicant(object):
pass
class Hunter(object):
def retire(self, replicant):
""" Retire the rogue or non-functional replicant.
:param Replicant replicant: the replicant to retire.
"""
replicant.knock_over() # Shows a warning.
voir: https://www.jetbrains.com/help/pycharm/2016.1/type-hinting-in-pycharm.html#legacy
vous pouvez également affirmer pour un type et Pycharm va l'inférer:
def my_function(an_int):
assert isinstance(an_int, int)
# Pycharm now knows that an_int is of type int
pass