Fare commenti rallentano un linguaggio interpretato?

StackOverflow https://stackoverflow.com/questions/2731022

Domanda

Chiedo questo perché io uso Python, ma potrebbe applicare ad altri linguaggi interpretati come pure (Ruby, PHP, JavaScript).

I Am rallentare l'interprete ogni volta che lascio un commento nel mio codice? Secondo la mia comprensione limitata di un interprete, si legge espressioni di programma in come stringhe e quindi converte quelle stringhe in codice. Sembra che ogni volta che si analizza un commento, che è sprecato tempo.

E 'questo il caso? C'è qualche convenzione per i commenti in linguaggi interpretati, o è l'effetto trascurabile?

È stato utile?

Soluzione

Per il caso di Python, file di origine vengono compilati prima di essere giustiziato (i file .pyc), ed i commenti sono messo a nudo nel processo. Quindi commenti potrebbe rallentare il tempo di compilazione se si dispone di un elevatissimo numero di loro, ma non avrà un impatto sul tempo di esecuzione.

Altri suggerimenti

Bene, ho scritto un breve programma di pitone in questo modo: 

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

L'idea è, fare un semplice calcolo carichi di volte.

Per temporizzazione che, ci sono voluti 0.35 ± 0.01 secondi per corsa.

Poi ho riscritto con tutta la Bibbia di Re Giacomo inserito in questo modo: 

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

Questa volta ci sono voluti 0,4 ± 0,05 secondi per l'esecuzione.

Quindi la risposta è Sì . 4MB di commenti in un ciclo fare la differenza misurabile.

I commenti sono di solito rimossi in o prima della fase di analisi, e l'analisi è molto veloce, in modo così efficace commenti non rallenterà il tempo di inizializzazione.

Ha fatto uno script come Rich con alcuni commenti (solo circa 500 KB di testo): 

# -*- 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

Modifica secondo il commento di David: 

 -*- 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

L'effetto è trascurabile per l'utilizzo quotidiano. E 'facile da testare, ma se si considera un semplice ciclo come ad esempio: 

For N = 1 To 100000: Next

Il computer in grado di elaborare che (conteggio a 100.000) più velocemente di quanto si può lampeggiare. Ignorando una riga di testo che inizia con un certo carattere saranno più di 10.000 volte più veloce.

Non preoccuparti di esso.

Dipende da come viene implementato l'interprete. La maggior parte degli interpreti moderni ragionevolmente fare almeno un po 'di pre-elaborazione sul codice sorgente prima di qualsiasi effettiva esecuzione, e che includeranno nudo i commenti in modo che non fanno differenza da quel punto in avanti.

Un tempo, quando la memoria è stata gravemente limitata (ad esempio, 64 K totale di memoria indirizzabile, e cassette per la conservazione) non si poteva prendere le cose così per scontato. Indietro nel giorno del Apple II, Commodore PET, TRS-80, ecc, era abbastanza di routine per i programmatori di rimuovere in modo esplicito commenti (e anche white-space) per migliorare la velocità di esecuzione. Questo è stato anche solo uno dei tanti hack codice a livello di fonte abitualmente impiegati al momento 1 .

Naturalmente, anche aiutato che tali macchine avuto CPU che possa eseguire una sola istruzione alla volta, aveva velocità di clock circa 1 MHz, e aveva solo registri del processore 8-bit. Anche una macchina che ci si ora trova solo in un cassonetto è molto più veloce di quelli erano che non è nemmeno divertente ...

1. Per un altro esempio, in Applesoft si potrebbe guadagnare o perdere un po 'di velocità a seconda di come si numerati linee. Se la memoria non serve, il guadagno di velocità è stato quando il bersaglio di un goto era un multiplo di 16.

commenti Avere rallenterà il tempo di avvio, come gli script avranno analizzato in una forma eseguibile. Tuttavia, nella maggior parte dei casi fanno commenti runtime down non lento.

In aggiunta in Python, è possibile compilare i file .py in .pyc, che non conterranno i commenti (lo spero) - Questo significa che non sarà possibile ottenere una startup ha colpito sia che lo script è già compilato.

  

La mia comprensione limitata di un   interprete è che si legge il programma   espressioni come stringhe e convertiti   quelle stringhe in codice.

La maggior parte delle interpreti leggono il testo (codice) e producono una struttura dati Abstract Syntax Tree.
Tale struttura contiene alcun codice, sotto forma di testo, e, naturalmente, nessun commento neanche. Solo che albero è sufficiente per l'esecuzione di programmi. Ma gli interpreti, per ragioni di efficienza, fare un passo avanti e prodotti byte code. E Python fa esattamente questo.

Si potrebbe dire che il codice e le osservazioni, nella forma che li ha scritti, sono semplicemente non presente ,
quando il programma è in esecuzione. Quindi no, i commenti non rallentano i programmi in fase di esecuzione.

(*) Gli interpreti che non usano qualche altra struttura interna per rappresentare il codice diverso dal testo,
cioè un albero di sintassi, deve fare esattamente quello che lei ha citato. Interpretare nuovo e di nuovo il codice in fase di esecuzione.

Come le altre risposte hanno già detto, un linguaggio moderno interpretato come primo analizza ed elabora la fonte Python in bytecode, e il parser semplicemente ignora i commenti. Questo significa chiaramente che qualsiasi perdita di velocità si verificherebbe solo in fase di avvio quando la sorgente è in realtà analizzata.

Poiché il parser ignora i commenti, la fase di compilazione è sostanzialmente influenzato da eventuali commenti si mette. Ma i byte nei commenti stessi sono in realtà essere letto, e poi saltato durante l'analisi. Questo significa che, se si dispone di una quantità pazzesca di commenti (per esempio molte centinaia di megabyte), ciò rallenterebbe l'interprete. Ma poi di nuovo questo potrebbe rallentare qualsiasi compilatore pure.

Mi chiedo se è importante su come vengono utilizzati i commenti. Ad esempio, triple virgolette è un docstring. Se li usate, il contenuto viene convalidato. Mi sono imbattuto in un problema un po 'indietro dove ero l'importazione di una biblioteca nel mio codice Python 3 ... Ho ottenuto questo errore di sintassi on \ N. Ho guardato il numero della linea ed è stato contenuto all'interno di un commento tripla preventivo. Ero un po 'sorpreso. Nuovo per Python, non ho mai pensato che un blocco di commento sarebbe stata interpretata per errori di sintassi.

Semplicemente se si digita: 

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

Python 2 non genera un errore, ma Python 3 relazioni: SyntaxError: (errore unicode) 'unicodeescape' codec non può decodificare i byte in posizione 14-15: malformati \ carattere N escape

Python 3 è evidentemente interpreta la citazione tripla, facendo attenzione che di sintassi valida.

Tuttavia, se trasformato in una sola riga di commento: # (vale a dire \ Device \ NPF_ ..)
Nessun risultato di errore.

Mi chiedo se i commenti di citazione triple wer sostituiti con singole linee, se un cambiamento delle prestazioni sarebbe visto.

Questa domanda è molto vecchio, ma dopo aver letto la risposta accettata, che sostiene che non avrà un impatto sul tempo di esecuzione, che è sbagliato, io vi do un semplice esempio dove si possono vedere e controllare la quantità influenza l'esecuzione tempo davvero.
Ho un file chiamato constants.py. Esso contiene tutte le diverse azioni di scacchi in un elenco: 

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

L'elenco LABELS contiene 2272 elementi. In un'altra chiamata file: 

import constants
np.array(constants.LABELS)

I misurava dieci volte e l'esecuzione del codice richiede circa 0,597 ms. Ora ho cambiato il file e inserito accanto a ciascun elemento (2272 volte) un commento: 

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

Ora dopo aver misurato il tempo di esecuzione dei tempi np.array(constants.LABELS) dieci, ho un tempo medio di esecuzione di 4,28 ms, in tal modo, a circa 7 volte più lento.
Quindi, sì, ha un impatto il tempo di esecuzione se si dispone di un sacco di commenti.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top