Est-ce que Python peut imprimer une définition de fonction?

Question

En JavaScript, on peut imprimer la définition d'une fonction. Y a-t-il un moyen d'accomplir cela en Python?

(juste à jouer en mode interactif, et je voulais lire un module sans open(). J'étais curieux).

Answer 1

Si vous importez la fonction, vous pouvez utiliser inspect.getsource:

>>> import re 
>>> import inspect 
>>> print inspect.getsource(re.compile) 
def compile(pattern, flags=0): 
    "Compile a regular expression pattern, returning a pattern object." 
    return _compile(pattern, flags) 

Ce sera travail dans l'invite interactive, mais apparemment uniquement sur les objets qui sont importés (pas des objets définis dans l'invite interactive) . Et bien sûr, il ne fonctionnera que si Python peut trouver le code source (donc pas sur des objets intégrés, C libs, fichiers .pyc, etc.)

Answer 2

Si vous utilisez iPython, vous pouvez utiliser function_name? pour obtenir de l'aide, et function_name?? va imprimer la source, si elle peut.

Answer 3

Vous pouvez utiliser le mot-clé __doc__:

#print the class description 
print string.__doc__ 
#print function description 
print open.__doc__ 

Answer 4

Bien que je sois généralement d'accord que inspect est une bonne réponse, je ne serais pas d'accord que vous ne pouvez pas obtenir le code source des objets définis dans l'interpréteur. Si vous utilisez dill.source.getsource de dill, vous pouvez obtenir la source des fonctions et lambdas, même si elles sont définies de manière interactive. Il peut également obtenir le code pour les méthodes et fonctions de classes liées ou non liées définies dans les currys ... cependant, vous ne pourrez peut-être pas compiler ce code sans le code de l'objet englobant.

>>> from dill.source import getsource 
>>> 
>>> def add(x,y): 
... return x+y 
... 
>>> squared = lambda x:x**2 
>>> 
>>> print getsource(add) 
def add(x,y): 
    return x+y 

>>> print getsource(squared) 
squared = lambda x:x**2 

>>> 
>>> class Foo(object): 
... def bar(self, x): 
...  return x*x+x 
... 
>>> f = Foo() 
>>> 
>>> print getsource(f.bar) 
def bar(self, x): 
    return x*x+x 

>>> 

Answer 5

Vous pouvez utiliser la __doc__ dans la fonction, prendre la fonction hog() comme exemple: Vous pouvez voir l'utilisation de hog() comme ceci:

from skimage.feature import hog 

print hog.__doc__ 

La sortie sera:

Extract Histogram of Oriented Gradients (HOG) for a given image. 
Compute a Histogram of Oriented Gradients (HOG) by 

    1. (optional) global image normalisation 
    2. computing the gradient image in x and y 
    3. computing gradient histograms 
    4. normalising across blocks 
    5. flattening into a feature vector 

Parameters 
---------- 
image : (M, N) ndarray 
    Input image (greyscale). 
orientations : int 
    Number of orientation bins. 
pixels_per_cell : 2 tuple (int, int) 
    Size (in pixels) of a cell. 
cells_per_block : 2 tuple (int,int) 
    Number of cells in each block. 
visualise : bool, optional 
    Also return an image of the HOG. 
transform_sqrt : bool, optional 
    Apply power law compression to normalise the image before 
    processing. DO NOT use this if the image contains negative 
    values. Also see `notes` section below. 
feature_vector : bool, optional 
    Return the data as a feature vector by calling .ravel() on the result 
    just before returning. 
normalise : bool, deprecated 
    The parameter is deprecated. Use `transform_sqrt` for power law 
    compression. `normalise` has been deprecated. 

Returns 
------- 
newarr : ndarray 
    HOG for the image as a 1D (flattened) array. 
hog_image : ndarray (if visualise=True) 
    A visualisation of the HOG image. 

References 
---------- 
* http://en.wikipedia.org/wiki/Histogram_of_oriented_gradients 

* Dalal, N and Triggs, B, Histograms of Oriented Gradients for 
    Human Detection, IEEE Computer Society Conference on Computer 
    Vision and Pattern Recognition 2005 San Diego, CA, USA 

Notes 
----- 
Power law compression, also known as Gamma correction, is used to reduce 
the effects of shadowing and illumination variations. The compression makes 
the dark regions lighter. When the kwarg `transform_sqrt` is set to 
``True``, the function computes the square root of each color channel 
and then applies the hog algorithm to the image. 

Answer 6

Ceci est la façon dont je me suis dit comment faire:

import inspect as i 
    import sys 
    sys.stdout.write(inspect.getsource(MyFunction)) 

Cela prend les caractères de nouvelle ligne et imprime la fonction joliment