Dieses Projekt ist kein offizielles Google-Projekt, sondern wurde von inländischen Programmierern aus Leidenschaft erstellt und gepflegt.
Wenn Sie die offizielle englische Version von Google suchen, besuchen Sie bitteGoogle Style Guide
Im folgenden Code zeigtJaempfohlen an,Neinzeigt nicht empfohlen an.
Semikolons
Fügen Sie keine Semikolons am Ende von Zeilen hinzu und verwenden Sie keine Semikolons, um zwei Befehle in dieselbe Zeile zu setzen.
Zeilenlänge
Jede Zeile sollte 80 Zeichen nicht überschreiten.
Außer in den folgenden Fällen:
- Lange Import-Modulanweisungen
- URLs in Kommentaren
Verwenden Sie keine Backslashes, um Zeilen zu verbinden.
Python wirdZeilen innerhalb von runden Klammern, eckigen Klammern und geschweiften Klammern implizit zusammenfügenSie können sich diese Funktion zunutze machen. Bei Bedarf können Sie ein zusätzliches Klammernpaar um den Ausdruck setzen.
推荐: foo_bar(self, width, height, color='black', design=None, x='foo',
emphasis=None, highlight=0)
if (width == 0 and height == 0 and
color == 'red' and emphasis == 'strong'):
Wenn eine Textzeichenfolge nicht in eine Zeile passt, können Sie Klammern verwenden, um eine implizite Zeilenverbindung zu erreichen:
x = ('这是一个非常长非常长非常长非常长 '
'非常长非常长非常长非常长非常长非常长的字符串')
Setzen Sie in Kommentaren lange URLs bei Bedarf in eine Zeile.
Yes: # See details at
# http://www.example.com/us/developer/documentation/api/content/v2.0/csv_file_name_extension_full_specification.html
No: # See details at
# http://www.example.com/us/developer/documentation/api/content/\
# v2.0/csv_file_name_extension_full_specification.html
Beachten Sie die Einrückung der Elemente im obigen Beispiel; eine Erklärung finden Sie im Abschnitt :ref:`indentation <indentation>` dieses Dokuments.
Runde Klammern
Verwenden Sie Klammern sparsam.
Verwenden Sie keine Klammern in return-Anweisungen oder bedingten Anweisungen, es sei denn, sie werden für die Zeilenverbindung verwendet. Das Setzen von Klammern um Tupel ist jedoch akzeptabel.
Yes: if foo:
bar()
while x:
x = bar()
if x and y:
bar()
if not x:
bar()
return foo
for (x, y) in dict.items(): ...
No: if (x):
bar()
if not(x):
bar()
return (foo)
Einrückung
Verwenden Sie 4 Leerzeichen zum Einrücken von Code.
Verwenden Sie niemals Tabs, und mischen Sie Tabs und Leerzeichen nicht. Zum Zeilenverbinden sollten Sie die umgebrochenen Elemente entweder vertikal ausrichten (siehe das Beispiel im Abschnitt :ref:`line length <line_length>`), oder einen hängenden Einzug mit 4 Leerzeichen verwenden (in diesem Fall sollte die erste Zeile keine Argumente enthalten):
Yes: # 与起始变量对齐
foo = long_function_name(var_one, var_two,
var_three, var_four)
# 字典中与起始值对齐
foo = {
long_dictionary_key: value1 +
value2,
...
}
# 4 个空格缩进,第一行不需要
foo = long_function_name(
var_one, var_two, var_three,
var_four)
# 字典中 4 个空格缩进
foo = {
long_dictionary_key:
long_dictionary_value,
...
}
No: # 第一行有空格是禁止的
foo = long_function_name(var_one, var_two,
var_three, var_four)
# 2 个空格是禁止的
foo = long_function_name(
var_one, var_two, var_three,
var_four)
# 字典中没有处理缩进
foo = {
long_dictionary_key:
long_dictionary_value,
...
}
Leerzeilen
Zwei Leerzeilen zwischen Definitionen auf oberster Ebene, eine Leerzeile zwischen Methodendefinitionen.
Zwei Leerzeilen zwischen Definitionen auf oberster Ebene, wie Funktions- oder Klassendefinitionen. Methodendefinitionen sowie der Bereich zwischen einer Klassendefinition und ihrer ersten Methode sollten eine Leerzeile aufweisen. Fügen Sie innerhalb einer Funktion oder Methode eine Leerzeile dort ein, wo Sie es für angemessen halten.
Leerraum
Befolgen Sie die üblichen typografischen Konventionen für Leerzeichen um Satzzeichen.
Keine Leerzeichen innerhalb von Klammern.
Befolgen Sie die üblichen typografischen Konventionen für Leerzeichen um Satzzeichen.
Yes: spam(ham[1], {eggs: 2}, [])
No: spam( ham[ 1 ], { eggs: 2 }, [ ] )Setzen Sie kein Leerzeichen vor Kommas, Semikolons oder Doppelpunkte, aber setzen Sie danach eines (außer am Ende einer Zeile).
Yes: if x == 4:
print x, y
x, y = y, x
No: if x == 4 :
print x , y
x , y = y , x
Setzen Sie kein Leerzeichen vor die öffnende Klammer einer Parameterliste, eines Index oder eines Slices.
Yes: spam(1)
no: spam (1)
Yes: dict['key'] = list[index]
No: dict ['key'] = list [index]
Setzen Sie auf beiden Seiten von binären Operatoren ein Leerzeichen, wie z. B. Zuweisung (=), Vergleich (==, <, >, !=, <>, <=, >=, in, not in, is, is not) und boolesche Operatoren (and, or, not). Was die Verwendung von Leerzeichen um arithmetische Operatoren betrifft, müssen Sie selbst entscheiden. Sie müssen jedoch auf beiden Seiten konsistent sein.
Yes: x == 1
No: x<1
Wenn '=' verwendet wird, um ein Schlüsselwortargument oder einen Standardparameterwert anzugeben, verwenden Sie auf keiner der beiden Seiten Leerzeichen.
Yes: def complex(real, imag=0.0): return magic(r=real, i=imag)
No: def complex(real, imag = 0.0): return magic(r = real, i = imag)
Verwenden Sie keine Leerzeichen, um Token über mehrere Zeilen hinweg vertikal auszurichten, da dies zu einer Wartungslast wird (gilt für :, #, =, usw.):
Yes:
foo = 1000 # 注释
long_name = 2 # 注释不需要对齐
dictionary = {
"foo": 1,
"long_name": 2,
}
No:
foo = 1000 # 注释
long_name = 2 # 注释不需要对齐
dictionary = {
"foo" : 1,
"long_name": 2,
}
Shebang
Die meisten .py-Dateien müssen nicht mit #! am Anfang der Datei beginnen. GemäßPEP-394sollte die Hauptdatei des Programms mit #!/usr/bin/python2 oder #!/usr/bin/python3 beginnen.
(Anmerkung des Übersetzers: In der Informatik istShebang(auch bekannt als Hashbang) eine Zeichenkette, die aus einem Rautezeichen und einem Ausrufezeichen (#!) besteht und als erste zwei Zeichen der ersten Zeile einer Textdatei erscheint. Wenn der Shebang in einer Datei vorhanden ist, analysiert der Programmlader Unix-ähnlicher Betriebssysteme den Inhalt nach dem Shebang, behandelt diesen Inhalt als Interpreter-Direktive, ruft die Direktive auf und verwendet den Pfad der Datei, die den Shebang enthält, als Argument für den Interpreter. Beispielsweise ruft eine Datei, die mit der Direktive #!/bin/sh beginnt, bei ihrer Ausführung tatsächlich das Programm /bin/sh auf.)
#! wird zunächst verwendet, um dem Kernel zu helfen, den Python-Interpreter zu finden, aber es wird beim Importieren von Modulen ignoriert. Daher müssen nur Dateien, die direkt ausgeführt werden, #! enthalten.
Kommentare
Stellen Sie sicher, dass für Module, Funktionen, Methoden und Inline-Kommentare der richtige Stil verwendet wird.
Docstrings
Python hat eine besondere Art des Kommentierens: die Verwendung von Docstrings. Ein Docstring ist die erste Anweisung in einem Paket, Modul, einer Klasse oder Funktion. Diese Zeichenketten können automatisch über das __doc__-Member des Objekts extrahiert werden und werden von pydoc verwendet. (Sie können pydoc für Ihr Modul ausführen, um es auszuprobieren und zu sehen, wie es aussieht). Unsere Konvention für Docstrings ist die Verwendung von dreifachen doppelten Anführungszeichen """ (PEP-257). Ein Docstring sollte wie folgt organisiert sein: zuerst eine Zusammenfassungszeile, die mit einem Punkt, Fragezeichen oder Ausrufezeichen endet (oder der Docstring hat einfach nur eine Zeile). Dann eine Leerzeile. Dann der Rest des Docstrings, der an dem ersten Anführungszeichen der ersten Zeile des Docstrings ausgerichtet werden sollte. Es gibt weitere Formatierungsspezifikationen für Docstrings unten.
Module
Jede Datei sollte einen Lizenz-Boilerplate enthalten. Wählen Sie den passenden Boilerplate entsprechend der vom Projekt verwendeten Lizenz (z. B. Apache 2.0, BSD, LGPL, GPL).
Funktionen und Methoden
Die unten genannten Funktionen umfassen Funktionen, Methoden und Generatoren.
Eine Funktion muss einen Docstring haben, es sei denn, sie erfüllt die folgenden Bedingungen:
- Nicht extern sichtbar
- Sehr kurz
- Einfach und klar
Der Docstring sollte enthalten, was die Funktion tut, sowie eine detaillierte Beschreibung der Eingaben und Ausgaben. Normalerweise sollte er nicht beschreiben, "wie es gemacht wird," es sei denn, es sind komplexe Algorithmen beteiligt. Der Docstring sollte genügend Informationen bereitstellen, sodass jemand anderes, wenn er Code schreibt, um die Funktion aufzurufen, keine einzige Codezeile ansehen muss — nur den Docstring. Bei komplexem Code ist das Hinzufügen von Kommentaren neben dem Code aussagekräftiger als die Verwendung eines Docstrings.
Mehrere Aspekte einer Funktion sollten in bestimmten Abschnitten dokumentiert werden, wie unten beschrieben. Jeder Abschnitt sollte mit einer Kopfzeile beginnen. Die Kopfzeile endet mit einem Doppelpunkt. Mit Ausnahme der Kopfzeile sollte der Rest des Abschnitts um 2 Leerzeichen eingerückt werden.
- Argumente:
- Listen Sie den Namen jedes Parameters auf, und setzen Sie nach dem Namen einen Doppelpunkt und ein Leerzeichen, um die Beschreibung des Parameters abzutrennen. Wenn die Beschreibung zu lang ist und 80 Zeichen in einer einzelnen Zeile überschreitet, verwenden Sie einen hängenden Einzug von 2 oder 4 Leerzeichen (konsistent mit dem Rest der Datei). Die Beschreibung sollte den erforderlichen Typ und die Bedeutung enthalten. Wenn eine Funktion *foo (Argumentliste variabler Länge) oder **bar (beliebige Schlüsselwortargumente) akzeptiert, sollten *foo und **bar ausführlich aufgeführt werden.
- Gibt zurück: (oder Liefert: für Generatoren)
- Beschreiben Sie den Typ und die Semantik des Rückgabewerts. Wenn die Funktion None zurückgibt, kann dieser Abschnitt weggelassen werden.
- Ausnahmen:
- Listen Sie alle Ausnahmen auf, die mit der Schnittstelle zusammenhängen.
def fetch_bigtable_rows(big_table, keys, other_silly_variable=None): """Fetches rows from a Bigtable. Retrieves rows pertaining to the given keys from the Table instance represented by big_table. Silly things may happen if other_silly_variable is not None. Args: big_table: An open Bigtable Table instance. keys: A sequence of strings representing the key of each table row to fetch. other_silly_variable: Another optional variable, that has a much longer name than the other args, and which does nothing. Returns: A dict mapping keys to the corresponding table row data fetched. Each row is represented as a tuple of strings. For example: {'Serak': ('Rigel VII', 'Preparer'), 'Zim': ('Irk', 'Invader'), 'Lrrr': ('Omicron Persei 8', 'Emperor')} If a key from the keys argument is missing from the dictionary, then that row was not found in the table. Raises: IOError: An error occurred accessing the bigtable.Table object. """ pass
Klasse
Eine Klasse sollte unter ihrer Definition einen Docstring haben, der die Klasse beschreibt. Wenn Ihre Klasse öffentliche Attribute hat, sollte die Dokumentation einen Abschnitt Attribute enthalten. Er sollte demselben Format wie Funktionsparameter folgen.
class SampleClass(object): """Summary of class here. Longer class information.... Longer class information.... Attributes: likes_spam: A boolean indicating if we like SPAM or not. eggs: An integer count of the eggs we have laid. """ def __init__(self, likes_spam=False): """Inits SampleClass with blah.""" self.likes_spam = likes_spam self.eggs = 0 def public_method(self): """Performs operation blah."""
Blockkommentare und Inline-Kommentare
Der Code, der am meisten Kommentare benötigt, sind die kniffligen Teile. Wenn Sie es imCode-Reviewerklären müssen, dann sollten Sie jetzt einen Kommentar dafür schreiben. Schreiben Sie für komplexe Operationen mehrere Zeilen Kommentare, bevor die Operation beginnt. Fügen Sie bei Code, der nicht auf einen Blick ersichtlich ist, einen Kommentar am Ende der Zeile hinzu.
# We use a weighted dictionary search to find out where i is in # the array. We extrapolate position based on the largest num # in the array and the array size and then do binary search to # get the exact number. if i & (i-1) == 0: # true iff i is a power of 2Um die Lesbarkeit zu verbessern, sollten Kommentare mindestens 2 Leerzeichen vom Code entfernt sein.
Andererseits sollten Sie niemals den Code beschreiben. Gehen Sie davon aus, dass die Person, die den Code liest, Python besser kennt als Sie; sie weiß nur nicht, was Ihr Code tun soll.
# BAD COMMENT: Now go through the b array and make sure whenever i occurs # the next element is i+1
Klasse
Wenn eine Klasse nicht von anderen Klassen erbt, erben Sie explizit von object. Dasselbe gilt für verschachtelte Klassen.
Yes: class SampleClass(object):
pass
class OuterClass(object):
class InnerClass(object):
pass
class ChildClass(ParentClass):
"""Explicitly inherits from another class already."""
No: class SampleClass:
pass
class OuterClass:
class InnerClass:
pass
Das Erben vonobjectdient dazu, Eigenschaften korrekt funktionieren zu lassen, und schützt Ihren Code vor einer speziellen potenziellen Inkompatibilität in Python 3000. Dies definiert außerdem einige spezielle Methoden, die die Standard-Semantik von Objekten implementieren, einschließlich__new__, __init__, __delattr__, __getattribute__, __setattr__, __hash__, __repr__, and __str__ .
Zeichenketten
Yes: x = a + b
x = '%s, %s!' % (imperative, expletive)
x = '{}, {}!'.format(imperative, expletive)
x = 'name: %s; score: %d' % (name, n)
x = 'name: {}; score: {}'.format(name, n)
No: x = '%s%s' % (a, b) # use + in this case
x = '{}{}'.format(a, b) # use + in this case
x = imperative + ', ' + expletive + '!'
x = 'name: ' + name + '; score: ' + str(n)
Vermeiden Sie die Verwendung der Operatoren + und += zum Ansammeln von Zeichenketten in einer Schleife. Da Zeichenketten unveränderlich sind, entstehen dadurch unnötige temporäre Objekte, und die Laufzeit ist quadratisch statt linear. Alternativ können Sie jede Teilzeichenkette einer Liste hinzufügen und dann nach dem Ende der Schleife verwenden Sie.joinum die Liste zu verbinden. (Sie können jede Teilzeichenkette auch in einencStringIO.StringIOPuffer schreiben.)
Yes: items = ['<table>']
for last_name, first_name in employee_list:
items.append('<tr><td>%s, %s</td></tr>' % (last_name, first_name))
items.append('</table>')
employee_table = ''.join(items)
No: employee_table = '<table>'
for last_name, first_name in employee_list:
employee_table += '<tr><td>%s, %s</td></tr>' % (last_name, first_name)
employee_table += '</table>'
In derselben Datei sollten Sie bei der Verwendung von Anführungszeichen für Zeichenketten konsistent bleiben. Verwenden Sie entweder einfache Anführungszeichen ' oder doppelte Anführungszeichen " für Zeichenketten, und bleiben Sie in derselben Datei dabei. Sie können die andere Art von Anführungszeichen innerhalb einer Zeichenkette verwenden, um ein Escapen zu vermeiden. PyLint hat diese Prüfung bereits hinzugefügt.
Yes:
Python('Why are you hiding your eyes?')
Gollum("I'm scared of lint errors.")
Narrator('"Good!" thought a happy Python reviewer.')
No:
Python("Why are you hiding your eyes?")
Gollum('The lint. It burns. It burns us.')
Gollum("Always the great lint. Watching. Watching.")
Verwenden Sie dreifache doppelte Anführungszeichen """ für mehrzeilige Zeichenketten anstelle von dreifachen einfachen Anführungszeichen '''. Nur wenn das Projekt einfache Anführungszeichen ' zum Quoten von Zeichenketten verwendet, dürfen dreifache ''' für mehrzeilige Zeichenketten verwendet werden, die keine Docstrings sind. Docstrings müssen dreifache doppelte Anführungszeichen """ verwenden. Beachten Sie jedoch, dass implizite Zeilenverkettung normalerweise klarer ist, weil mehrzeilige Zeichenketten nicht mit der Einrückung des restlichen Programms übereinstimmen.
Yes:
print ("This is much nicer.\n"
"Do it this way.\n")
No:
print """This is pretty ugly.
Don't do this.
"""
Dateien und Sockets
Dateien und Sockets explizit schließen, wenn sie nicht mehr benötigt werden.
Das Offenlassen von Dateien, Sockets oder anderen dateiähnlichen Objekten, wenn dies nicht nötig ist, hat viele Nebenwirkungen, zum Beispiel:
- Sie können begrenzte Systemressourcen wie Dateideskriptoren verbrauchen. Wenn diese Ressourcen nach der Verwendung nicht umgehend an das System zurückgegeben werden, wird der Code, der diese Objekte behandelt, sie erschöpfen.
- Offen gehaltene Dateien können andere Operationen an den Dateien verhindern, z. B. das Verschieben oder Löschen.
- Alleiniges logisches Schließen von Dateien und Sockets lässt sie weiterhin offen für versehentliche Lese- oder Schreibzugriffe durch Programme, die sie gemeinsam nutzen. Erst wenn sie wirklich geschlossen sind, lösen Lese- oder Schreibversuche Ausnahmen aus, sodass Probleme schnell sichtbar werden.
Darüber hinaus ist die Vorstellung unrealistisch, dass Dateien und Sockets automatisch geschlossen werden, wenn Dateiobjekte zerstört werden, wobei versucht wird, die Lebensdauer von Dateiobjekten an den Zustand der Dateien zu binden. Aus folgenden Gründen:
- Es gibt keine Möglichkeit sicherzustellen, dass die Laufzeitumgebung tatsächlich den Destruktor der Datei ausführt. Verschiedene Python-Implementierungen verwenden unterschiedliche Techniken der Speicherverwaltung, wie z. B. verzögerte Garbage Collection. Verzögerte Garbage Collection kann dazu führen, dass die Lebensdauern von Objekten willkürlich und unbegrenzt verlängert werden.
- Unerwartete Referenzen auf Dateien können dazu führen, dass Dateien länger als erwartet gehalten werden (zum Beispiel in Exception-Tracebacks, die globale Variablen enthalten, usw.).
Es wird empfohlen,die "with"-Anweisungzum Verwalten von Dateien zu verwenden:
with open("hello.txt") as hello_file:
for line in hello_file:
print line
Verwenden Sie für dateiähnliche Objekte, die die "with"-Anweisung nicht unterstützen, contextlib.closing():
import contextlib
with contextlib.closing(urllib.urlopen("http://www.python.org/")) as front_page:
for line in front_page:
print line
Legacy-Code für AppEngine Python 2.5, der die "with"-Anweisung verwendet, erfordert das Hinzufügen von "from __future__ import with_statement".
TODO-Kommentare
Verwenden Sie TODO-Kommentare für temporären Code, eine kurzfristige Lösung. Nicht perfekt, aber gut genug.
TODO-Kommentare sollten die Zeichenkette "TODO" ganz am Anfang enthalten, gefolgt von Ihrem Namen, Ihrer E-Mail-Adresse oder einer anderen Kennung in Klammern. Dann ein optionaler Doppelpunkt. Danach muss eine Kommentarzeile folgen, die erklärt, was zu tun ist. Der Hauptzweck ist ein einheitliches TODO-Format, damit nach der Person, die den Kommentar hinzugefügt hat, gesucht werden kann (und sie bei Bedarf weitere Details liefern kann). Das Schreiben eines TODO-Kommentars garantiert nicht, dass der Verfasser das Problem persönlich behebt. Wenn Sie ein TODO schreiben, geben Sie bitte Ihren Namen an.
# TODO(kl@gmail.com): Use a "*" here for string repetition. # TODO(Zeke) Change this to use relations.
Wenn Ihr TODO die Form "in der Zukunft etwas tun" hat, stellen Sie sicher, dass Sie ein konkretes Datum ("im November 2009 beheben") oder ein konkretes Ereignis ("diesen Code entfernen, sobald alle Kunden XML-Anfragen verarbeiten können") angeben.
Importformat
Jeder Import sollte in einer eigenen Zeile stehen
Yes: import os
import sys
No: import os, sys
Importe sollten immer am Anfang der Datei stehen, nach Modulkommentaren und Docstrings und vor modulglobalen Variablen und Konstanten. Importe sollten vom Allgemeinsten zum Spezifischsten gruppiert werden:
- Importe aus der Standardbibliothek
- Importe von Bibliotheken Dritter
- Anwendungsspezifische Importe
Innerhalb jeder Gruppe sollten Importe lexikografisch nach dem vollständigen Paketpfad jedes Moduls sortiert werden, wobei die Groß-/Kleinschreibung ignoriert wird.
import foo from foo import bar from foo.bar import baz from foo.bar import Quux from Foob import ar
Aussagen
Im Allgemeinen sollte jede Anweisung in einer eigenen Zeile stehen
Wenn jedoch der Test und das Ergebnis in eine Zeile passen, können Sie sie auch in dieselbe Zeile setzen. Bei einer if-Anweisung dürfen Sie dies nur tun, wenn es kein else gibt. Insbesondere sollten Sie dies niemals tun, umtry/exceptdies zu tun, weil try und except nicht in dieselbe Zeile gesetzt werden können.
Yes: if foo: bar(foo)
No:
if foo: bar(foo)
else: baz(foo)
try: bar(foo)
except ValueError: baz(foo)
try:
bar(foo)
except ValueError: baz(foo)
Zugriffskontrolle
In Python sollten Sie für triviale und unwichtige Zugriffsfunktionen stattdessen direkt öffentliche Variablen verwenden, um zusätzlichen Overhead durch Funktionsaufrufe zu vermeiden. Wenn Sie mehr Funktionalität hinzufügen, können Sie Properties verwenden, um die syntaktische Konsistenz zu wahren.
(Anmerkung des Übersetzers: Objektorientierte Programmierer, die Kapselung schätzen, könnten daran Anstoß nehmen, weil ihnen immer beigebracht wurde, dass alle Membervariablen privat sein müssen! Tatsächlich ist das wirklich lästig. Versuchen Sie, die Python-Philosophie zu akzeptieren.)
Andererseits, wenn der Zugriff komplexer ist oder der Overhead beim Variablenzugriff erheblich ist, sollten Sie etwas wieget_foo()undset_foo()Funktionsaufrufe verwenden. Wenn früheres Codeverhalten den Zugriff über Properties erlaubte, dann binden Sie keine neuen Zugriffsfunktionen an die Property. Auf diese Weise wird jeder Code, der versucht, über die alte Methode auf die Variable zuzugreifen, fehlschlagen, und Benutzer werden erkennen, dass sich die Komplexität geändert hat.
Benennung
module_name, package_name, ClassName, method_name, ExceptionName, function_name, GLOBAL_VAR_NAME, instance_var_name, function_parameter_name, local_var_name.
Zu vermeidende Namen
- Einzelzeichen-Namen, außer für Zähler und Iteratoren.
- Bindestriche (-) in Paket-/Modulnamen
- Namen, die mit doppelten Unterstrichen beginnen und enden (von Python reserviert, z. B. __init__)
Namenskonventionen
- Das sogenannte "Intern" bedeutet, dass etwas nur innerhalb des Moduls verfügbar ist oder innerhalb einer Klasse geschützt oder privat ist.
- Ein führender einzelner Unterstrich (_) zeigt an, dass eine Modulvariable oder -funktion geschützt ist (nicht enthalten, wenn import * from verwendet wird).
- Instanzvariablen oder Methoden, die mit doppelten Unterstrichen (__) beginnen, sind für die Klasse privat.
- Platziere zusammengehörige Klassen und Top-Level-Funktionen im selben Modul. Anders als in Java besteht keine Notwendigkeit, sich auf eine Klasse pro Modul zu beschränken.
- Verwende großgeschriebene Wörter für Klassennamen (z. B. CapWords, d. h. Pascal-Stil), aber Modulnamen sollten Kleinbuchstaben mit Unterstrichen verwenden (z. B. lower_with_under.py). Obwohl viele bestehende Module Namen wie CapWords.py verwenden, wird davon inzwischen abgeraten, da es verwirrend sein kann, wenn der Modulname zufällig mit einem Klassennamen übereinstimmt.
Vom Vater von Python, Guido, empfohlene Spezifikationen
| Type | Public | Intern |
|---|---|---|
| Module | lower_with_under | _lower_with_under |
| Pakete | lower_with_under | |
| Klassen | CapWords | _CapWords |
| Ausnahmen | CapWords | |
| Funktionen | lower_with_under() | _lower_with_under() |
| Globale/Klassen-Konstanten | CAPS_WITH_UNDER | _CAPS_WITH_UNDER |
| Globale/Klassen-Variablen | lower_with_under | _lower_with_under |
| Instanzvariablen | lower_with_under | _lower_with_under (geschützt) oder __lower_with_under (privat) |
| Methodennamen | lower_with_under() | _lower_with_under() (geschützt) oder __lower_with_under() (privat) |
| Funktions-/Methodenparameter | lower_with_under | |
| Lokale Variablen | lower_with_under |
Main
Auch eine Datei, die als Skript verwendet werden soll, sollte importierbar sein. Und ein einfacher Import sollte nicht dazu führen, dass die Hauptfunktionalität des Skripts ausgeführt wird, da dies ein Nebeneffekt ist. Die Hauptfunktionalität sollte in einer main()-Funktion platziert werden.
In Python setzen pydoc und Unit-Tests voraus, dass Module importierbar sind. Ihr Code sollte immer prüfen, bevor das Hauptprogramm ausgeführt wirdif __name__ == '__main__', damit das Hauptprogramm nicht ausgeführt wird, wenn das Modul importiert wird.
def main():
...
if __name__ == '__main__':
main()
Der gesamte Code auf oberster Ebene wird ausgeführt, wenn das Modul importiert wird. Achten Sie darauf, keine Funktionen aufzurufen, Objekte zu erstellen oder Operationen auszuführen, die bei der Verwendung von pydoc nicht ausgeführt werden sollten.