Spezifikationen für die Python-Programmierung

Geeignete Leerzeilen sind hilfreich, um die Lesbarkeit des Codes zu verbessern. Sie können sich zum Hinzufügen von Leerzeilen an die folgenden Richtlinien halten:

1) Fügen Sie Leerzeilen zwischen den Definitionen von Klassen und Funktionen ein

2) Fügen Sie Leerzeilen zwischen Importmodulen unterschiedlichen Typs hinzu.

3) Fügen Sie Leerzeilen zwischen logischen Absätzen in Funktionen hinzu, dh schreiben Sie zusammengehörige Codes kompakt als logischen Absatz zwischen Absätzen, getrennt durch Leerzeichen Zeilen;

> Zeilenumbrüche

Obwohl heutige Breitbildmonitore mehr als 256 Zeichenspalten auf einem einzigen Bildschirm anzeigen können, besteht diese Spezifikation immer noch darauf, dass die maximale Länge einer Zeile 80 nicht überschreiten darf Zeichen. Es gibt mehrere Möglichkeiten, lange Zeilen zu falten:

1) Ändern Sie den langen Variablennamen in einen Kurznamen, z. B.:

this.is.a.very.long.variable_name = this.is.another.long.variable_name

Er sollte geändert werden in:

variable_name1 = this.is.a.very.long.variable_name
variable_name2 = this.is.another.variable_name
variable_name1 = variable_name2s

2) Python verbindet die Zeilen implizit in Klammern, eckigen Klammern und geschweiften Klammern. Sie können diese Funktion nutzen. Bei Bedarf können Sie ein zusätzliches Klammerpaar

um den Ausdruck einfügen. 3) Fügen Sie einer langen Zeile ein Zeilenfortsetzungszeichen hinzu, um einen Zeilenumbruch zu erzwingen. Die Position des Zeilenumbruchs sollte vor dem Operator und liegen Nach dem Zeilenumbruch sollte ein zusätzlicher Einzug stehen, damit das Wartungspersonal beim Betrachten des Codes feststellen kann, dass ein Zeilenumbruch vorliegt, wenn es den Anfang der Codezeile sieht, z. B.:

if color == WHITE or color == BLACK \
    or color == BLUE: # 注意 or 操作符在新行的行首而不是旧行的行尾
do_something(color);

> String

1) Vermeiden Sie die Verwendung des Operators „and“ in Schleifen =, um Zeichenfolgen zu akkumulieren. Da Zeichenfolgen unveränderlich sind, werden dadurch unnötige temporäre Objekte erstellt und es kommt zu einer quadratischen statt einer linearen Laufzeit. Alternativ können Sie jede Teilzeichenfolge zu einer Liste hinzufügen und dann .join verwenden, um die Listen nach Ende der Schleife zu verbinden. (Sie können jede Teilzeichenfolge auch in einen cStringIO.StringIO-Cache schreiben)

2) Verwenden Sie für mehrzeilige Zeichenfolgen dreifache doppelte Anführungszeichen anstelle von dreifachen einfachen Anführungszeichen. Beachten Sie jedoch, dass es häufig sauberer ist, eine implizite Zeilenverkettung zu verwenden, da mehrzeilige Zeichenfolgen nicht mit der Einrückung anderer Teile des Programms übereinstimmen.

> Benennung

Eine konsistente Benennung kann eine Menge Ärger für Entwickler reduzieren, und eine geeignete Benennung kann die Lesbarkeit des Codes erheblich verbessern und die Wartungskosten senken.

>> Konstanten

Alle Buchstaben in Konstantennamen werden großgeschrieben, mit Unterstrichen, die jedes Wort verbinden, wie z. B.

WHITE = 0XFFFFFF
THIS_IS_A_CONSTANT = 1

>>

Variablennamen sollten ausschließlich aus Kleinbuchstaben bestehen und jedes Wort durch Unterstriche verbinden, z. B.

. Definieren Sie mehr öffentliche Mitglieder und weniger private Mitglieder.

color = WHITE
this_is_a_variable = 1

Variablennamen sollten keine Typinformationen enthalten, da Python eine dynamisch typisierte Sprache ist. Wie iValue, Names_list, dict_obj usw. sind allesamt schlechte Namen.

>> Funktion

Die Benennungsregeln für Funktionsnamen sind die gleichen wie für Variablennamen.

>> Klasse

Verwenden Sie Wörter, die mit Großbuchstaben beginnen (z. B. Großbuchstaben, Pascal-Stil) für Klassennamen, und verwenden Sie keine Unterstriche, um Wörter zu verbinden. Beispiel:

>> Modul

class ThisIsAClass(object):pass

Für im Paket verwendete Module können Sie einen Unterstrich hinzufügen, z. B.

>> Paket

module.py_
internal_module.py

Die Namenskonvention für Pakete ist dieselbe wie für Module.

>> Abkürzungen

Sie sollten versuchen, bei der Benennung vollständig geschriebene Wörter zu verwenden. Es gibt zwei Arten von Abkürzungen:

1) Häufig verwendete Abkürzungen, wie z. B. XML , ID usw. Bei der Benennung sollte nur der erste Buchstabe großgeschrieben werden, z. B.

2) Wenn der Name lange Wörter enthält, kürzen Sie ein bestimmtes Wort ab. Zu diesem Zeitpunkt sollte die herkömmliche Abkürzungsmethode verwendet werden, z. B. das Entfernen von Vokalen, ersten Zeichen, die Konsonanten enthalten usw., zum Beispiel:

class XmlParser(object):pass

Funktionsabkürzung ist fn

Textabkürzung ist txt

Objekt wird als obj abgekürzt

Anzahl wird als cnt abgekürzt

Zahl wird als num abgekürzt usw.

>> Die spezifische Benennungsmethode

bezieht sich hauptsächlich auf die vom System reservierte Wortbenennungsmethode in der Form __xxx__. Diese Art der Benennung kann auch in Projekten verwendet werden. Ihre Bedeutung besteht darin, dass Variablen in dieser Form schreibgeschützt sind und Klassenmitgliedsfunktionen in dieser Form nicht so stark wie möglich überlastet werden sollten. Beispiel:

wobei __id__, __parent__ und __message__ alle die vom System reservierte Wortnomenklatur verwenden.

class Base(object):
    def __init__(self, id, parent =None):
        self.__id__ = id
        self.__parent__ = parent    def __message__(self, msgid):
        # …略

>> Importformat

1) Die Reihenfolge des Imports: Importieren Sie zuerst integrierte Python-Module, importieren Sie dann Module von Drittanbietern und importieren Sie schließlich andere Module in selbstentwickelte Projekte ; diese Modultypen werden durch Leerzeilen getrennt.

2) Jeder Import sollte in einer eigenen Zeile erfolgen.

3) Verwenden Sie nicht from module import *, es sei denn, es handelt sich um ein Importkonstantendefinitionsmodul oder ein anderes Modul, bei dem Sie sicherstellen, dass es keine Namespacekonflikte gibt.

> Zuweisung

Bei Zuweisungssprachen kommt es vor allem darauf an, keine unnötige Ausrichtung wie

vorzunehmen

a            = 1                               # 这是一个行注释
variable = 2                               # 另一个行注释
fn           = callback_function    # 还是行注释

没有必要做这种对齐，原因有两点：一是这种对齐会打乱编程时的注意力，大脑要同时处理两件事（编程和对齐）；二是以后阅读和维护都很困难，因为人眼的横向视野很窄，把三个字段看成一行很困难，而且维护时要增加一个更长的变量名也会破坏对齐。直接这样写为佳：

a = 1 # 这是一个行注释
variable = 2 # 另一个行注释
fn = callback_function # 还是行注释

>  语句

通常每个语句应该独占一行。不过， 如果测试结果与测试语句在一行放得下， 你也可以将它们放在同一行。如果是if语句， 只有在没有else时才能这样做。特别地，绝不要对 try/except 这样做，因为try和except不能放在同一行。