Python - faire de grandes chaînes de doc mémoire déchets?

Question

Je comprends que dans une chaîne Python est simplement une expression et une chaîne par lui-même serait les déchets ramassés immédiatement après le retour du contrôle à l'appelant d'un code, mais ...

1. Grande classe / méthode des chaînes de doc dans votre code:-ils perdre la mémoire en construisant la chaîne des objets jusqu'à?
2. Niveau module doc strings: sont-ils stocké à l'infini par l'interprète?

Est-ce que cette question même? Mon seul souci est venu de l'idée que si j'utilise un grand cadre comme Django, ou plusieurs grandes bibliothèques open source, ils ont tendance à être très bien documenté avec potentiellement plusieurs méga-octets de texte. Dans ces cas, les chaînes de doc chargées en mémoire pour le code qui est utilisé le long du chemin, puis il gardé, ou est-il immédiatement recueilli comme des chaînes normales?

Answer 1

• « Je comprends que Python une chaîne est tout simplement une expression et une chaîne par lui-même serait les déchets ramassés immédiatement après le retour du contrôle à l'appelant d'un code » indique un malentendu, je pense. Une docstring est évaluée une fois (et non sur chaque appel de fonction) et reste en vie au moins aussi longtemps que la fonction.

• "Est-ce même problème?" en matière d'optimisation n'est pas répondu en pensant à ce sujet, mais abstraitement en mesurant. « Plusieurs méga-octets » de texte n'est probablement pas beaucoup dans une application gourmande en mémoire. La solution pour la mémoire de sauver des vies et probablement ailleurs, vous pouvez déterminer si tel est le cas par la mesure.

• commutateur de ligne de commande -OO de Python Enlève docstrings.

Answer 2

Python docstrings par défaut sont conservés indéfiniment autour, car ils sont accessibles via l'attribut __doc__ d'une fonction ou d'un module. Par exemple, avec ce qui suit dans test.py:

"""This is a test module."""

def f():
   """This is a test function."""
   pass

Alors:

$ python
Python 2.5.1 (r251:54863, Oct 30 2007, 13:54:11) 
[GCC 4.1.2 20070925 (Red Hat 4.1.2-33)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import test
>>> test.__doc__
'This is a test module.'
>>> test.f.__doc__
'This is a test function.'
>>> 

L'option -OO à l'interprète, il provoque apparemment pour enlever docstrings des fichiers générés .pyo, mais il n'a pas l'effet que je me attends:

$ python -OO
Python 2.5.1 (r251:54863, Oct 30 2007, 13:54:11) 
[GCC 4.1.2 20070925 (Red Hat 4.1.2-33)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import test
>>> test.__file__
'/tmp/test.py'
>>> 
$ grep "This is a test" /tmp/test.pyo
Binary file /tmp/test.pyo matches
$ python -OO
Python 2.5.1 (r251:54863, Oct 30 2007, 13:54:11) 
[GCC 4.1.2 20070925 (Red Hat 4.1.2-33)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import test
>>> test.__file__
'/tmp/test.pyo'
>>> test.__doc__
'This is a test module.'
>>> 

En fait, le fichier généré avec test.pyo -OO est identique au fichier généré test.pyc sans arguments de ligne de commande. Quelqu'un peut-il expliquer ce comportement?