Je soutiens la réponse de Michael Kent (et je l'ai votée en haut).
Mais aussi, vous devez lire "PEP 8" et absorber ses leçons.
http://www.python.org/dev/peps/pep-0008/
Mais Python, avec ses espaces de noms, ses fonctionnalités puissantes et ses classes orientées objet, devrait vous permettre d'utiliser des noms courts et pratiques pour les choses.
En C, vous devez utiliser des identifiants longs dans de nombreux cas, car les noms doivent être uniques dans une portée donnée. Ainsi :
char *StringFromInt(int x);
char *StringFromFloat(float x);
char *StringFromUnsigned(unsigned int x);
char *str_temp = strdup(StringFromUnsigned(foo_flags));
En Python, tous ces éléments seraient les fonctions intégrées de la commande str() :
temp = str(foo_flags)
En C++, vous disposez de classes et d'espaces de noms, ce qui vous permet d'utiliser des fonctionnalités orientées objet comme en Python, mais en C, vous avez besoin de noms globalement uniques, ce qui vous oblige souvent à faire ce genre de choses :
typedef struct s_foo
{
// struct members go here
} FOO;
FooAdd();
FooSubtract();
StringFromFoo();
En Python, vous devez soit ajouter des fonctions membres, soit surcharger les opérateurs, selon le cas :
class Foo(object):
def __init__(self):
# member variables initialized here
def add(self, x):
# add x to a Foo
def subtract(self, x):
# subtract x from a Foo
def __str___(self):
# return a string that represents a foo
f = Foo()
f.add(x)
f.sub(y)
# the following two both use __str__()
temp = str(f)
print(f)
Vous pouvez également privilégier les noms de variables très longs à des fins d'auto-documentation. Je préfère la brièveté :
import math
class Circle(object):
"""\
Circle: a class representing a circle in a plane.
Includes the following member functions:
area() -- return the area of the circle"""
def __init__(self, center=Point([0, 0]), radius=0.0):
"""\
Circle(center, radius)
center must be an instance of class Point() or convertible to Point()
radius must be an int or float and must not be negative"""
if radius < 0:
raise ValueError("radius must be >= 0")
self.center = Point(center)
self.radius = float(radius)
def area(self):
"returns area as a float."
return math.pi * self.radius ** 2
c = Circle([23, 45], 0.5)
print(c.area())
class CircleGraphicsObject(object):
def __init__(self, CenterOfTheCircle, RadiusOfTheCircle):
# init code goes here
def AreaOfTheCircle(self):
return math.pi * self.RadiusOfTheCircle ** 2
CircleInstance = CircleGraphicsObject(PointObject([23, 45]), 0.5)
print(CircleInstance.AreaOfTheCircle())
Je préfère nettement le premier style, laconique, au second. Conformément à la PEP 8, j'aime les noms de variables en minuscules (tels que c pour le Circle instance). En Python, il est aussi généralement recommandé d'utiliser le "Duck Typing" comme je l'ai fait dans la classe terse : si vous voulez que le rayon soit un float, alors il faut le convertir en un float sur __init__() plutôt que de vérifier son type. De même, plutôt que de vérifier si l'on vous a transmis un fichier Point Par exemple, il suffit de contraindre tout ce que vous obtenez à une Point . Vous laissez Point.__init__() soulève une exception si l'argument n'a pas de sens en tant que Point il n'est pas nécessaire de procéder à un enregistrement supplémentaire. Circle.__init__() . En outre, votre Point.__init__() peut vérifier explicitement si vous lui avez passé une instance de Point et retourner l'instance inchangée, s'il est vraiment coûteux d'initier une Point . (Dans cet exemple, un Point n'est en fait qu'une paire de valeurs, donc il est probablement assez rapide de simplement recréer le point et vous n'avez pas besoin de la vérification).
Vous avez peut-être remarqué la façon étrange dont j'ai fait la chaîne de caractères multi-lignes à triple guillemets. En raison des règles d'indentation de Python, j'ai dû indenter la chaîne de caractères entre guillemets, mais je ne veux pas indenter les lignes de la chaîne de caractères car l'indentation ferait partie de la chaîne de caractères. En fait, je veux que toutes les lignes multiples soient dans la marge de gauche, afin de pouvoir voir clairement la longueur de ces lignes (et m'assurer qu'elles font toutes 79 caractères ou moins). J'utilise donc l'échappement backslash pour permettre à la première ligne de la chaîne multi-lignes d'être dans la marge de gauche avec les autres lignes, sans insérer de nouvelle ligne au début de la chaîne multi-lignes.
Quoi qu'il en soit, le style plus court permet de taper plus facilement les noms de variables et autres, et de faire rentrer plus facilement vos lignes dans la limite des 79 colonnes recommandée par PEP 8.
Il ne serait même pas complètement horrible d'utiliser des noms de membres internes d'une seule lettre, dans une classe aussi simple que celle-ci. Avec seulement deux membres, vous pourriez très bien utiliser les noms suivants .c pour l'élément central et .r pour le rayon. Mais cela ne s'adapte pas bien, et .center et .radius sont toujours faciles à taper et à retenir.
C'est aussi une très bonne idée de mettre des docstrings informatifs. Vous pouvez utiliser des noms un peu laconiques, mais donner des explications plus longues dans la docstring.
class Foo(object):
# init goes here
def area(self):
"returns area as a float."
return self.area
class VerboseFoo(object):
# init goes here
def AreaAsFloat(self):
return self.FloatAreaValue
Les espaces de noms sont excellents. Remarquez comme c'est clair quand on utilise math.pi ; vous savez que c'est la constante mathématique, et vous pourriez avoir une variable locale pi (pour "Program Index" peut-être) et il n'entre pas en collision avec la constante mathématique.
