Have you tried opening a module and asking for help?
Output:
>>> import interactiveconsole
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'interactiveconsole']
>>> help(interactiveconsole)
Help on module interactiveconsole:
NAME
interactiveconsole
CLASSES
builtins.object
FileCacher
code.InteractiveConsole(code.InteractiveInterpreter)
Shell
class FileCacher(builtins.object)
| Cache the stdout text so we can analyze it before returning it
|
| Methods defined here:
|
| __init__(self)
| Initialize self. See help(type(self)) for accurate signature.
|
| flush(self)
|
| reset(self)
|
| write(self, line)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
class Shell(code.InteractiveConsole)
| Wrapper around Python that can filter input/output to the shell
|
| Method resolution order:
| Shell
| code.InteractiveConsole
| code.InteractiveInterpreter
| builtins.object
|
| Methods defined here:
|
| __init__(self)
| Constructor.
|
| The optional locals argument will be passed to the
| InteractiveInterpreter base class.
|
| The optional filename argument should specify the (file)name
| of the input stream; it will show up in tracebacks.
|
| get_output(self)
|
| push(self, line)
| Push a line to the interpreter.
|
| The line should not have a trailing newline; it may have
| internal newlines. The line is appended to a buffer and the
| interpreter's runsource() method is called with the
| concatenated contents of the buffer as source. If this
| indicates that the command was executed or invalid, the buffer
| is reset; otherwise, the command is incomplete, and the buffer
| is left as it was after the line was appended. The return
| value is 1 if more input is required, 0 if the line was dealt
| with in some way (this is the same as runsource()).
|
| return_output(self)
|
| ----------------------------------------------------------------------
| Methods inherited from code.InteractiveConsole:
|
| interact(self, banner=None, exitmsg=None)
| Closely emulate the interactive Python console.
|
| The optional banner argument specifies the banner to print
| before the first interaction; by default it prints a banner
| similar to the one printed by the real Python interpreter,
| followed by the current class name in parentheses (so as not
| to confuse this with the real interpreter -- since it's so
| close!).
|
| The optional exitmsg argument specifies the exit message
| printed when exiting. Pass the empty string to suppress
| printing an exit message. If exitmsg is not given or None,
| a default message is printed.
|
| raw_input(self, prompt='')
| Write a prompt and read a line.
|
| The returned line does not include the trailing newline.
| When the user enters the EOF key sequence, EOFError is raised.
|
| The base implementation uses the built-in function
| input(); a subclass may replace this with a different
| implementation.
|
| resetbuffer(self)
| Reset the input buffer.
|
| ----------------------------------------------------------------------
| Methods inherited from code.InteractiveInterpreter:
|
| runcode(self, code)
| Execute a code object.
|
| When an exception occurs, self.showtraceback() is called to
| display a traceback. All exceptions are caught except
| SystemExit, which is reraised.
|
| A note about KeyboardInterrupt: this exception may occur
| elsewhere in this code, and may not always be caught. The
| caller should be prepared to deal with it.
|
| runsource(self, source, filename='<input>', symbol='single')
| Compile and run some source in the interpreter.
|
| Arguments are as for compile_command().
|
| One of several things can happen:
|
| 1) The input is incorrect; compile_command() raised an
| exception (SyntaxError or OverflowError). A syntax traceback
| will be printed by calling the showsyntaxerror() method.
|
| 2) The input is incomplete, and more input is required;
| compile_command() returned None. Nothing happens.
|
| 3) The input is complete; compile_command() returned a code
| object. The code is executed by calling self.runcode() (which
| also handles run-time exceptions, except for SystemExit).
|
| The return value is True in case 2, False in the other cases (unless
| an exception is raised). The return value can be used to
| decide whether to use sys.ps1 or sys.ps2 to prompt the next
| line.
|
| showsyntaxerror(self, filename=None)
| Display the syntax error that just occurred.
|
| This doesn't display a stack trace because there isn't one.
|
| If a filename is given, it is stuffed in the exception instead
| of what was there before (because Python's parser always uses
| "<string>" when reading from a string).
|
| The output is written by self.write(), below.
|
| showtraceback(self)
| Display the exception that just occurred.
|
| We remove the first stack item because it is our own code.
|
| The output is written by self.write(), below.
|
| write(self, data)
| Write a string.
|
| The base implementation writes to sys.stderr; a subclass may
| replace this with a different implementation.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from code.InteractiveInterpreter:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
FILE
...\interactiveconsole.py
If you just want to collect all the comments in a file I suggest you look for a tool that does that instead of writing your own.
