Quelle est la convention de nommage pour les références de classe Python
Quelle est la convention de nommage pour une variable référençant une classe en Python?
class MyClass(object):
pass
# which one is correct?
reference_to_class = MyClass
# or
ReferenceToClass = MyClass
Voici un autre exemple qui ressemble à ma situation:
# cars.py
class Car(object):
pass
class Sedan(Car):
pass
class Coupe(Car):
pass
class StatonWagon(Car):
pass
class Van(Car):
pass
def get_car_class(slug, config):
return config.get(slug)
# config.py
CONFIG = {
'ford-mustang': Coupe,
'buick-riviera': Coupe,
'chevrolet-caprice': Sedan,
'chevy-wan' Van:
'ford-econoline': Van
}
# main.py
from config.py import CONFIG
from cars import get_car_class
MyCarClass = get_car_class('buick-riviera')
my_car = MyCarClass()
Je préférerais ReferenceToClass, que tout le monde nouveau dans le code sache que c'est une classe et non une instance. Mais comme l'a écrit @poplitea, la référence littéraire serait géniale.
3 réponses
Au niveau du module, le second:
ReferenceToClass = MyClass
En tant qu'argument de fonction, le premier:
reference_to_class = MyClass
Tl; dr : pour les noms globaux/publics, utilisez AllCaps comme xorcist a dit:
class Logger:
pass
AliasLogger = Logger
Pour les paramètres de fonction et les locaux de fonction, indiquez clairement que vous avez affaire à l'objet de classe avec un nom descriptif comme ceci:
def some_func(logger_class):
pass
Ou quelque chose du genre
def some_func(my_class_classobj):
pass
Lorsque le mot "class" est réellement dans votre classname. Pour classobj, voir aussi class_ et klass.
Analyse/la Motivation (version longue)
Pas de lecture approfondie, mais en un coup d'œil PEP 8 ne semble pas être explicite à ce sujet (ni le guide de style Python de google d'ailleurs).
Comme un nom de variable est probablement encore-une autre liaison de nom en python, à mon avis, peu importe si vous liez ce nom avec le bloc de définition ou plus tard avec le signe = égal à un objet.
Pour cela, je suis d'accord avec XORcist dans ce niveau de module, les références "alias" doivent adhérer à votre nom de classe standard, probablement AllCaps:
class MyClass(object):
pass
# good
ReferenceToClass = MyClass
Cependant, quand il s'agit de noms de paramètres et de variables, soi-disant lowercase_underscores devrait s'appliquer, non? Je ne suis pas satisfait que de cela, car cela vous poussera dans l'ambiguïté instance vs class reference. Il est possible qu'un nom en minuscules soit une tentative d'indiquer que l'objet est une instance. D'ailleurs, je recommande de postfixer vos noms de variables de référence de classe en minuscules avec le suffixe "class", comme ceci:
class Logger(object):
pass
def function_expecting_class_reference(logger_class):
pass
Je renommé votre classe d'exemple MyClass en Logger car dans les scénarios réels, seul un petit nombre de noms de classe contient la chaîne "class". Cependant, dans ce dernier cas, je propose d'éviter l'ambiguïté avec la dénomination descriptive encore une fois. Par exemple, vous pouvez utiliser un suffixe classobj:
class MyClass(object):
pass
def function_expecting_class_reference(another_param, my_class_classobj):
ReferenceToClass = MyClass
Une Autre alternative, j'ai tendance à prendre est d'utiliser le suffixe klass, comme my_class_klass. Tout le monde ne semble pas obtenir ce dernier, mais de toute façon, je dois encore tester s'ils obtiendraient le premier mieux.
Je le traite comme une variable d'instance, que PEP8 définit comme utilisant lowercase_underscore_style. (minuscules, avec des mots séparés par des traits de soulignement si nécessaire pour améliorer la lisibilité.)