Est-ce que les commentaires ralentir un langage interprété?
https://stackoverflow.com/questions/2731022
-
02-10-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je demande parce que je l'utilise Python, mais il pourrait appliquer à d'autres langues interprétées aussi bien (Ruby, PHP, JavaScript).
Suis-je ralentir l'interprète chaque fois que je laisse un commentaire dans mon code? Selon ma compréhension limitée d'un interprète, il lit des expressions du programme en tant que chaînes et convertit ensuite ces chaînes en code. Il semble que chaque fois qu'il parse un commentaire, qui est du temps perdu.
Est-ce le cas? Y at-il une convention pour commentaires dans les langues interprétées ou est négligeable effet?
La solution
Dans le cas de Python, les fichiers sources sont compilés avant d'être exécuté (les fichiers .pyc), et les commentaires sont dépouillés dans le processus. Alors commentaires peut ralentir le temps de compilation si vous avez gazillions d'entre eux, mais ils ne seront pas un impact sur le temps d'exécution.
Autres conseils
Eh bien, je l'ai écrit un programme court python comme ceci:
for i in range (1,1000000):
a = i*10
L'idée est, faire une charge de calcul simples des temps.
Par moment que, il a fallu 0,35 ± 0,01 seconde pour courir.
Je récrit alors avec toute la Bible du roi Jacques inséré comme ceci:
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
Cette fois il a fallu 0,4 ± 0,05 secondes pour courir.
La réponse est oui . 4Mo des commentaires dans une boucle faire une différence mesurable.
Les commentaires sont généralement supprimés dans ou avant l'étape de l'analyse syntaxique et l'analyse syntaxique est très rapide, de manière efficace les commentaires ne ralentiront pas le temps d'initialisation.
Est-ce avec quelques commentaires un script comme Rich (uniquement sur le texte 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
Modifier selon le commentaire 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
L'effet est négligeable pour une utilisation quotidienne. Il est facile à tester, mais si l'on considère une boucle simple comme:
For N = 1 To 100000: Next
Votre ordinateur peut traiter que (nombre de 100 000) plus rapide que vous pouvez clignoter. Ignorant une ligne de texte qui commence par un certain caractère sera plus de 10.000 fois plus vite.
Ne vous inquiétez pas à ce sujet.
Cela dépend de la façon dont l'interprète est mis en œuvre. La plupart des interprètes modernes raisonnablement faire au moins un peu de prétraitement sur le code source avant toute exécution proprement dite, et qui comprendra les commentaires de décapage afin qu'ils font en avant aucune différence de ce point.
À un moment donné, lorsque la mémoire a été sévèrement limitée (par exemple, 64K mémoire adressable totale et cassettes pour le stockage) vous ne pouviez pas prendre les choses comme ça pour acquis. Retour au jour de l'Apple II, Commodore PET, TRS-80, etc., il était assez courant pour les programmeurs de supprimer explicitement les commentaires (et même espace blanc) pour améliorer la vitesse d'exécution. Ce fut aussi un des nombreux hacks au niveau du code source couramment utilisés au moment 1 .
Bien sûr, il a également contribué à ce que ces machines avaient processeurs qui ne pouvait exécuter une instruction à la fois, a des vitesses d'horloge autour de 1 MHz, et avait seulement des registres du processeur 8 bits. Même une machine que vous souhaitez maintenant trouver que dans une benne à ordures est tellement plus rapide que ceux étaient que c'est même pas drôle ...
1. Pour un autre exemple, dans Applesoft vous pouvez gagner ou perdre un peu de vitesse selon la façon dont vous avez numéroté les lignes. Si ma mémoire est bonne, le gain de vitesse était lorsque la cible d'une instruction goto était un multiple de 16.
Avoir des commentaires ralentiront le temps de démarrage, les scripts s'analysable en une forme exécutable. Cependant, dans la plupart des cas commentaires ne runtime vers le bas pas lent.
De plus en python, vous pouvez compiler les fichiers .py dans .pyc, qui ne contiendra pas les commentaires (je l'espère) - cela signifie que vous ne serez pas obtenir un démarrage touché soit si le script est déjà compilé.
Mon compréhension limitée d'un interprète est qu'il lit programme expressions dans les chaînes et les convertis ces chaînes dans le code.
La plupart des interprètes lisent le texte (code) et produire une structure de données arbre de syntaxe abstraite.
Cette structure ne contient pas de code, sous forme de texte, et bien sûr aucun commentaire non plus. Juste cet arbre est suffisant pour l'exécution des programmes. Mais les interprètes, pour des raisons d'efficacité, vont un peu plus loin et produire un code d'octets. Et Python fait exactement cela.
On pourrait dire que le code et les commentaires, sous la forme que vous les avez écrites, sont tout simplement pas présent ,
lorsque le programme est en cours d'exécution. Donc non, les commentaires ne ralentissent pas les programmes à l'exécution.
(*) Les interprètes qui n'utilisent pas d'une autre structure interne pour représenter le code autre que du texte,
à savoir un arbre de syntaxe, doit faire exactement ce que vous avez mentionné. Interprétez encore et encore le code lors de l'exécution.
Comme les autres réponses ont déjà dit, un langage interprété moderne comme Python première analyse et compiler le code source en bytecode, et l'analyseur ignore simplement les commentaires. Cela signifie clairement que toute perte de vitesse ne se produirait au démarrage lorsque la source est effectivement analysée.
Parce que l'analyseur ne tient pas compte des commentaires, la phase de compilation est essentiellement affectée par des commentaires que vous mettez. Mais les octets eux-mêmes sont en fait en cours de lecture dans les commentaires dans, puis sauté lors de l'analyse. Cela signifie, si vous avez une quantité folle de commentaires (par exemple plusieurs centaines de méga-octets), cela ralentirait l'interprète. Mais là encore cela ralentirait tout compilateur aussi bien.
Je me demande si elle compte sur la façon dont les commentaires sont utilisés. Par exemple, des triples guillemets est un docstring. Si vous les utilisez, le contenu est validé. Je suis tombé sur un problème de dos pendant quelque temps où je l'importation d'une bibliothèque dans mon code Python 3 ... Je suis cette erreur concernant la syntaxe sur \ N. Je regardais le numéro de ligne et il était contenu dans un commentaire de devis triple. Je suis un peu surpris. Nouveau à Python, je ne pensais pas un commentaire de bloc serait interprété pour les erreurs de syntaxe.
Il suffit si vous tapez:
'''
(i.e. \Device\NPF_..)
'''
Python 2 ne jette pas une erreur, mais Python 3 rapports: SyntaxError: (erreur unicode) 'unicodeescape' codec ne peut pas décoder les octets en position 14-15: malformé \ fuite de caractère N
Python 3 est évidemment interprète la citation triple, en vous assurant sa syntaxe valide.
Cependant, si transformé en commentaire d'une seule ligne: # (à savoir \ Device \ NPF_ ..)
Aucun résultat d'erreur.
Je me demande si les commentaires de devis triples wer remplacées par des lignes simples, si un changement de performance serait vu.
Cette question est vraiment vieux, mais après avoir lu la réponse acceptée qui prétend que ce ne sera pas un impact sur le temps d'exécution, ce qui est faux, je vous donne un exemple simple où vous pouvez voir et vérifier le montant qu'il influe sur l'exécution En effet le temps.
J'ai un fichier appelé constants.py. Il contient toutes les différentes actions d'échecs dans une liste:
LABELS = [ "a1b1"
"a1c1",
"a1d1",
"a1e1",
"a1f1",....]
La LABELS de liste contient 2272 éléments. Dans un autre dossier que je appelle:
import constants
np.array(constants.LABELS)
I mesurée dix fois et l'exécution du code prend environ 0.597 ms. Maintenant, je l'ai changé le fichier et inséré à côté de chaque élément (2272 fois) un commentaire:
LABELS = [ "a1b1", # 0
"a1c1", # 1
"a1d1", # 2
"a1e1", # 3
"a1f1", # 4
...,
"Q@h8", # 2271]
après la mesure du temps d'exécution des temps np.array(constants.LABELS) de dix, j'ai un temps d'exécution moyen de 4,28 ms, donc, à environ 7 fois plus lente.
Par conséquent, oui, elle influe sur la durée d'exécution si vous avez beaucoup de commentaires.
