¿Los comentarios ralentizan un lenguaje interpretado?

https://stackoverflow.com/questions/2731022

02-10-2019
|

Pregunta

Lo pregunto porque uso de Python, pero podría aplicarse a otros lenguajes interpretados también (Ruby, PHP, JavaScript).

I Am ralentizar el intérprete cada vez que dejo un comentario en mi código? De acuerdo a mi comprensión limitada de un intérprete, se lee en el programa las expresiones en forma de cadenas y luego se convierte esas cadenas en código. Parece que cada vez que se analiza un comentario, que se desperdicia el tiempo.

Es este el caso? ¿Hay alguna convención para comentarios en lenguajes interpretados, o es el efecto insignificante?

Solución

En el caso de Python, archivos de código fuente se compilan antes de ser ejecutados (los archivos .pyc), y los comentarios son despojados en el proceso. Así comentarios podría ralentizar el tiempo de compilación si tiene tropecientos millones de ellos, pero no van a afectar el tiempo de ejecución.

Otros consejos

Bueno, escribió un programa pitón corto como esto:

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

La idea es, hacer un simple cálculo de cargas veces.

Por tiempo que, se tomó 0,35 ± 0,01 segundos a plazo.

Entonces volvió a escribir con la totalidad de la Biblia King James insertada como esto:

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

Este tiempo que se tardó 0,4 ± 0,05 segundos para ejecutar.

Así que la respuesta es Sí . 4 MB de comentarios en un bucle de hacer una diferencia medible.

Los comentarios son generalmente despojados a cabo en o antes de la etapa de análisis, y el análisis es muy rápido, por lo que efectivamente comentarios no se ralentizará el tiempo de inicialización.

Hizo un guión como Rich con algunos comentarios sobre el texto (solamente 500kb):

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

Editar según el comentario de 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

El efecto es insignificante para el uso diario. Es fácil de prueba, pero si se tiene en cuenta un bucle simple, como:

For N = 1 To 100000: Next

El ordenador puede procesar esa (recuento de 100.000) más rápido que se puede abrir y cerrar. Haciendo caso omiso de una línea de texto que comienza con un cierto carácter serán más de 10.000 veces más rápido.

No se preocupe por ello.

Depende de cómo se implementa el intérprete. La mayoría de los intérpretes modernos razonablemente hacer al menos un poco de pre-procesamiento en el código fuente antes de cualquier ejecución real, y que incluirán eliminar todos sus comentarios por lo que no hacen ninguna diferencia a partir de ese punto en adelante.

En un momento, cuando la memoria se ve gravemente limitada (por ejemplo, 64 K de memoria direccionable totales, y las cintas de cassette para el almacenamiento) no se podía tomar las cosas de esa manera por sentado. De vuelta en el día de la Apple II, Commodore PET, TRS-80, etc., era bastante rutinaria para los programadores para eliminar explícitamente los comentarios (e incluso de espacio en blanco) para mejorar la velocidad de ejecución. Este fue también sólo uno de los muchos hacks fuente de nivel de código empleados rutinariamente en el momento ¹.

Por supuesto, también ayudó a que esas máquinas tenido CPU que sólo podría ejecutar una instrucción a la vez, tenía velocidades de reloj alrededor de 1 MHz, y tenía sólo registros del procesador de 8 bits. Incluso una máquina que ahora iba a encontrar sólo en un contenedor de basura es mucho más rápido que eran los que ni siquiera es gracioso ...

^{1. Para dar otro ejemplo, en Applesoft usted podría ganar o perder un poco de velocidad en función de la forma en que los clasificó líneas. Si falla la memoria, la ganancia de velocidad fue cuando el blanco de una instrucción goto era un múltiplo de 16.}

Tener los comentarios se ralentizará el tiempo de arranque, ya que los guiones se consiguen analizado en una forma ejecutable. Sin embargo, en la mayoría de los casos hacen comentarios en tiempo de ejecución hacia abajo, no lento.

Además en Python, puede compilar los archivos .py en .pyc, que no contendrán los comentarios (eso espero) - Esto significa que usted no conseguirá un inicio golpeado o bien si el guión ya está compilado.

Mi comprensión limitada de una intérprete es que se lea programa expresiones en forma de cadenas y conversos esas cadenas en código.

La mayoría de los intérpretes leen el texto (código) y producen una estructura de datos de árbol de sintaxis abstracta.
Esa estructura no contiene ningún código, en forma de texto, y por supuesto no hay comentarios tampoco. Sólo ese árbol es suficiente para la ejecución de los programas. Pero intérpretes, por razones de eficiencia, van un paso más allá y productos de código de bytes. Y Python hace exactamente eso.

Se podría decir que el código y los comentarios, en la forma que las escribió, son simplemente no está presente , España cuando el programa se está ejecutando. Así que no, los comentarios no retrasan los programas en tiempo de ejecución.

(*) Los intérpretes que no utilizan alguna otra estructura interna para representar el código que no sea texto,
es decir, un árbol sintáctico, debe hacer exactamente lo que usted ha mencionado. Interpretar una y otra vez el código en tiempo de ejecución.

Como las otras respuestas ya han declarado, una lengua moderna interpretado como Python primeros analiza y compila la fuente en bytecode, y el analizador simplemente ignora los comentarios. Esto significa claramente que cualquier pérdida de velocidad sólo ocurriría en el arranque cuando la fuente es en realidad analizada.

Debido a que el analizador ignora los comentarios, la fase de compilación es básicamente afectado por cualquier comentario que pone en. Pero los bytes en los comentarios a sí mismos en realidad están siendo leídos en, y luego pasó por alto durante el análisis. Esto significa que si usted tiene una cantidad loca de los comentarios (por ejemplo, varios cientos de megabytes), esto sería más lento el intérprete. Pero, de nuevo esto podría retrasar cualquier compilador también.

Me pregunto si es importante sobre cómo se utilizan los comentarios. Por ejemplo, comillas triples es una cadena de documentación. Si los usa, el contenido se valida. Me encontré con un problema hace un tiempo atrás donde estaba la importación de una biblioteca en mi código Python 3 ... Tengo este error con respecto a la sintaxis de \ N. Miré el número de línea y fue contenido dentro de un comentario de triple cita. Me sorprendió un poco. Nuevo en Python, nunca pensé que un comentario de bloque sería interpretado por los errores de sintaxis.

Simplemente si escribe:

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

Python 2 no emite un error, pero Python 3 informes: SyntaxError: (error de Unicode) 'unicodeescape' codec no puede decodificar bytes en la posición 14-15: malformación \ carácter de escape N

Así Python 3 está interpretando, evidentemente, la cita triple, asegurándose de que la sintaxis válida.

Sin embargo, si se convirtió en una sola línea de comentario: # (es decir, \ Device \ NPF_ ..)
No hay resultados de error.

Me pregunto si los triples comentarios cotización wer reemplazados con líneas simples, si se observa un cambio en el rendimiento.

Esta pregunta es muy viejo, pero después de leer la respuesta aceptada, que afirma que no tendrá un impacto en el tiempo de ejecución, lo que está mal, te estoy dando un ejemplo sencillo donde se puede ver y comprobar la cantidad que influye en la ejecución de hecho el tiempo.
Tengo un archivo llamado constants.py. Contiene todas las diferentes acciones de ajedrez en una lista:

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

La lista LABELS contiene 2272 elementos. En otra llamada de archivos I:

import constants
np.array(constants.LABELS)

Me midió diez veces y la ejecución del código tarda aproximadamente 0,597 ms. Ahora he cambiado el archivo y se inserta junto a cada elemento (2272 veces) un comentario:

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

Ahora después de medir el tiempo de ejecución de veces np.array(constants.LABELS) diez, tengo un tiempo de ejecución promedio de 4,28 ms, por lo tanto, alrededor de 7 veces más lento.
Por lo tanto, sí, su impacto en el tiempo de ejecución si usted tiene un montón de comentarios.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow