Verlangsamen Kommentare eine interpretierte Sprache?

Ich frage dies, weil ich Python verwende, aber es könnte auch für andere interpretierte Sprachen gelten (Ruby, PHP, JavaScript).

Verlangsame ich den Interpreter, wenn ich einen Kommentar in meinem Code hinterlasse? Nach meinem begrenzten Verständnis eines Interpreters liest er Programmausdrücke als Zeichenfolgen ein und konvertiert diese Zeichenfolgen dann in Code. Es scheint, dass jedes Mal, wenn ein Kommentar analysiert wird, dies Zeitverschwendung ist.

Ist das der Fall? Gibt es eine Konvention für Kommentare in interpretierten Sprachen oder ist der Effekt vernachlässigbar?

Im Fall von Python werden Quelldateien vor der Ausführung kompiliert (die .pycDateien) und die Kommentare werden dabei entfernt. Kommentare können also die Kompilierungszeit verlangsamen, wenn Sie Millionen davon haben, aber sie haben keinen Einfluss auf die Ausführungszeit.

Nun, ich habe ein kurzes Python-Programm wie dieses geschrieben:

for i in range (1,1000000):
    a = i*10

Die Idee ist, eine einfache Berechnung viele Male durchzuführen.

Zu diesem Zeitpunkt dauerte der Lauf 0,35 ± 0,01 Sekunden.

Ich habe es dann mit der gesamten King James Bibel umgeschrieben, die so eingefügt wurde:

for i in range (1,1000000):
    """
The Old Testament of the King James Version of the Bible

The First Book of Moses:  Called Genesis


1:1 In the beginning God created the heaven and the earth.

1:2 And the earth was without form, and void; and darkness was upon
the face of the deep. And the Spirit of God moved upon the face of the
waters.

1:3 And God said, Let there be light: and there was light.

...
...
...
...

Even so, come, Lord Jesus.

22:21 The grace of our Lord Jesus Christ be with you all. Amen.
    """
    a = i*10

Diesmal dauerte der Lauf 0,4 ± 0,05 Sekunden.

Die Antwort lautet also ja . 4 MB Kommentare in einer Schleife machen einen messbaren Unterschied.

Kommentare werden normalerweise in oder vor der Analysephase entfernt, und die Analyse ist sehr schnell, sodass Kommentare die Initialisierungszeit nicht verlangsamen.

Der Effekt ist für den täglichen Gebrauch vernachlässigbar. Es ist leicht zu testen, aber wenn Sie eine einfache Schleife in Betracht ziehen, wie zum Beispiel:

For N = 1 To 100000: Next

Ihr Computer kann dies (bis 100.000) schneller verarbeiten, als Sie blinken können. Das Ignorieren einer Textzeile, die mit einem bestimmten Zeichen beginnt, ist mehr als 10.000 Mal schneller.

Mach dir keine Sorgen.

Habe ein Skript wie das von Rich mit einigen Kommentaren erstellt (nur etwa 500 KB Text):

# -*- coding: iso-8859-15 -*-
import timeit

no_comments = """
a = 30
b = 40
for i in range(10):
    c = a**i * b**i
"""
yes_comment = """
a = 30
b = 40

# full HTML from http://en.wikipedia.org/
# wiki/Line_of_succession_to_the_British_throne

for i in range(10):
    c = a**i * b**i
"""
loopcomment = """
a = 30
b = 40

for i in range(10):
    # full HTML from http://en.wikipedia.org/
    # wiki/Line_of_succession_to_the_British_throne

    c = a**i * b**i
"""

t_n = timeit.Timer(stmt=no_comments)
t_y = timeit.Timer(stmt=yes_comment)
t_l = timeit.Timer(stmt=loopcomment)

print "Uncommented block takes %.2f usec/pass" % (
    1e6 * t_n.timeit(number=100000)/1e5)
print "Commented block takes %.2f usec/pass" % (
    1e6 * t_y.timeit(number=100000)/1e5)
print "Commented block (in loop) takes %.2f usec/pass" % (
    1e6 * t_l.timeit(number=100000)/1e5)

C:\Scripts>timecomment.py
Uncommented block takes 15.44 usec/pass
Commented block takes 15.38 usec/pass
Commented block (in loop) takes 15.57 usec/pass

C:\Scripts>timecomment.py
Uncommented block takes 15.10 usec/pass
Commented block takes 14.99 usec/pass
Commented block (in loop) takes 14.95 usec/pass

C:\Scripts>timecomment.py
Uncommented block takes 15.52 usec/pass
Commented block takes 15.42 usec/pass
Commented block (in loop) takes 15.45 usec/pass

Bearbeiten Sie gemäß Davids Kommentar:

 -*- coding: iso-8859-15 -*-
import timeit

init = "a = 30\nb = 40\n"
for_ = "for i in range(10):"
loop = "%sc = a**%s * b**%s"
historylesson = """
# <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
# blah blah...
# --></body></html> 
"""
tabhistorylesson = """
    # <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
    # blah blah...
    # --></body></html> 
"""

s_looped = init + "\n" + for_ + "\n" + tabhistorylesson + loop % ('   ','i','i')
s_unroll = init + "\n"
for i in range(10):
    s_unroll += historylesson + "\n" + loop % ('',i,i) + "\n"
t_looped = timeit.Timer(stmt=s_looped)
t_unroll = timeit.Timer(stmt=s_unroll)

print "Looped length: %i, unrolled: %i." % (len(s_looped), len(s_unroll))

print "For block takes %.2f usec/pass" % (
    1e6 * t_looped.timeit(number=100000)/1e5)
print "Unrolled it takes %.2f usec/pass" % (
    1e6 * t_unroll.timeit(number=100000)/1e5)

C:\Scripts>timecomment_unroll.py
Looped length: 623604, unrolled: 5881926.
For block takes 15.12 usec/pass
Unrolled it takes 14.21 usec/pass

C:\Scripts>timecomment_unroll.py
Looped length: 623604, unrolled: 5881926.
For block takes 15.43 usec/pass
Unrolled it takes 14.63 usec/pass

C:\Scripts>timecomment_unroll.py
Looped length: 623604, unrolled: 5881926.
For block takes 15.10 usec/pass
Unrolled it takes 14.22 usec/pass

Dies hängt davon ab, wie der Interpreter implementiert ist. Die meisten einigermaßen modernen Interpreten führen vor jeder tatsächlichen Ausführung zumindest eine gewisse Vorverarbeitung des Quellcodes durch. Dazu gehört auch das Entfernen der Kommentare, damit sie ab diesem Zeitpunkt keinen Unterschied mehr machen.

Zu einer Zeit, als der Speicher stark eingeschränkt war (z. B. 64 KB adressierbarer Gesamtspeicher und Kassetten zur Speicherung), konnte man solche Dinge nicht als selbstverständlich betrachten. Zu Zeiten von Apple II, Commodore PET, TRS-80 usw. war es für Programmierer ziemlich routinemäßig, Kommentare (und sogar Leerzeichen) explizit zu entfernen, um die Ausführungsgeschwindigkeit zu verbessern. Dies war auch nur einer von vielen Hacks auf Quellcode-Ebene, die zum Zeitpunkt ¹ routinemäßig eingesetzt wurden .

Natürlich hat es auch geholfen, dass diese Maschinen CPUs hatten, die jeweils nur einen Befehl ausführen konnten, Taktraten um 1 MHz hatten und nur 8-Bit-Prozessorregister hatten. Sogar eine Maschine, die Sie jetzt nur in einem Müllcontainer finden würden, ist so viel schneller als diese, dass es nicht einmal lustig ist ...

^{1. In einem anderen Beispiel können Sie in Applesoft ein wenig an Geschwindigkeit gewinnen oder verlieren, je nachdem, wie Sie die Zeilen nummeriert haben. Wenn Speicher dient, war der Geschwindigkeitsgewinn, wenn das Ziel einer goto-Anweisung ein Vielfaches von 16 war.}

Kommentare verlangsamen die Startzeit, da die Skripte in eine ausführbare Form analysiert werden. In den meisten Fällen verlangsamen Kommentare jedoch nicht die Laufzeit.

Zusätzlich können Sie in Python die .py-Dateien in .pyc kompilieren, das keine Kommentare enthält (ich sollte hoffen) - dies bedeutet, dass Sie auch keinen Starttreffer erhalten, wenn das Skript bereits kompiliert ist.

Mein begrenztes Verständnis eines Interpreters besteht darin, dass er Programmausdrücke als Zeichenfolgen einliest und diese Zeichenfolgen in Code konvertiert.

Die meisten Interpreten lesen den Text (Code) und erstellen eine abstrakte Syntaxbaum-Datenstruktur.
Diese Struktur enthält keinen Code in Textform und natürlich auch keine Kommentare. Nur dieser Baum reicht aus, um Programme auszuführen. Aus Effizienzgründen gehen Dolmetscher jedoch noch einen Schritt weiter und erzeugen Bytecode. Und Python macht genau das.

Wir könnten sagen, dass der Code und die Kommentare in der Form, in der Sie sie geschrieben haben, einfach nicht vorhanden sind.
wenn das Programm ausgeführt wird. Nein, Kommentare verlangsamen die Programme zur Laufzeit nicht.

(*) Interpreter, die keine andere innere Struktur verwenden, um den Code als Text darzustellen,
dh einen Syntaxbaum, müssen genau das tun, was Sie erwähnt haben. Interpretieren Sie den Code zur Laufzeit immer wieder.

Wie die anderen Antworten bereits angegeben haben, analysiert und kompiliert eine modern interpretierte Sprache wie Python zuerst die Quelle in Bytecode, und der Parser ignoriert die Kommentare einfach. Dies bedeutet eindeutig, dass ein Geschwindigkeitsverlust nur beim Start auftreten würde, wenn die Quelle tatsächlich analysiert wird.

Da der Parser Kommentare ignoriert, wird die Kompilierungsphase von den von Ihnen eingegebenen Kommentaren grundsätzlich nicht beeinflusst. Die Bytes in den Kommentaren selbst werden jedoch tatsächlich eingelesen und dann beim Parsen übersprungen. Dies bedeutet, wenn Sie eine verrückte Anzahl von Kommentaren haben (z. B. viele hundert Megabyte), würde dies den Interpreter verlangsamen. Andererseits würde dies auch jeden Compiler verlangsamen.

Ich frage mich, ob es darauf ankommt, wie Kommentare verwendet werden. Zum Beispiel ist dreifache Anführungszeichen eine Dokumentzeichenfolge. Wenn Sie sie verwenden, wird der Inhalt validiert. Ich bin vor einiger Zeit auf ein Problem gestoßen, bei dem ich eine Bibliothek in meinen Python 3-Code importiert habe ... Ich habe diesen Fehler bezüglich der Syntax für \ N erhalten. Ich habe mir die Zeilennummer angesehen und sie war in einem dreifachen Zitatkommentar enthalten. Ich war etwas überrascht. Neu in Python, ich hätte nie gedacht, dass ein Blockkommentar für Syntaxfehler interpretiert wird.

Einfach wenn Sie tippen:

'''
(i.e. \Device\NPF_..)
'''

Python 2 gibt keinen Fehler aus, aber Python 3 meldet: SyntaxError: (Unicode-Fehler) Der Codec 'unicodeescape' kann keine Bytes an Position 14-15 dekodieren: fehlerhaftes \ N-Zeichen-Escape

Python 3 interpretiert also offensichtlich das dreifache Anführungszeichen und stellt sicher, dass es eine gültige Syntax ist.

Wenn jedoch in einen einzeiligen Kommentar umgewandelt: # (dh \ Device \ NPF_ ..)
Es keine Fehler auf.

Ich frage mich, ob die Kommentare in dreifachen Anführungszeichen durch einzelne Zeilen ersetzt wurden, wenn sich die Leistung ändern würde.

Diese Frage ist wirklich alt, aber nachdem ich die akzeptierte Antwort gelesen habe, die behauptet, dass sie keinen Einfluss auf die Ausführungszeit hat, was falsch ist, gebe ich Ihnen ein einfaches Beispiel, in dem Sie sehen und überprüfen können, inwieweit sie die Ausführungszeit tatsächlich beeinflusst.
Ich habe eine Datei namens constants.py. Es enthält alle verschiedenen Schachaktionen in einer Liste:

LABELS = [ "a1b1"
    "a1c1", 
    "a1d1", 
    "a1e1", 
    "a1f1",....]

Die Liste LABELSenthält 2272 Elemente. In einer anderen Datei rufe ich auf:

import constants
np.array(constants.LABELS)

Ich habe es zehnmal gemessen und die Ausführung des Codes dauert ungefähr 0,597 ms. Jetzt habe ich die Datei geändert und neben jedes Element (2272 mal) einen Kommentar eingefügt:

LABELS = [ "a1b1",  # 0 
            "a1c1", # 1
            "a1d1", # 2
            "a1e1", # 3
            "a1f1", # 4
             ...,
            "Q@h8", # 2271]

Nachdem np.array(constants.LABELS)ich nun die Ausführungszeit zehnmal gemessen habe , habe ich eine durchschnittliche Ausführungszeit von 4,28 ms, also ungefähr siebenmal langsamer.
Daher wirkt sich dies auf die Ausführungszeit aus, wenn Sie viele Kommentare haben.