cpython/Doc/library/symtable.rst

:mod:`symtable` --- Access to the compiler's symbol tables
==========================================================

.. module:: symtable
   :synopsis: Interface to the compiler's internal symbol tables.

.. moduleauthor:: Jeremy Hylton <jeremy@alum.mit.edu>
.. sectionauthor:: Benjamin Peterson <benjamin@python.org>


Symbol tables are generated by the compiler from AST just before bytecode is
generated.  The symbol table is responsible for calculating the scope of every
identifier in the code.  :mod:`symtable` provides an interface to examine these
tables.


Generating Symbol Tables
------------------------

.. function:: symtable(code, filename, compile_type)

   Return the toplevel :class:`SymbolTable` for the Python source *code*.
   *filename* is the name of the file containing the code.  *compile_type* is
   like the *mode* argument to :func:`compile`.


Examining Symbol Tables
-----------------------

.. class:: SymbolTable

   A namespace table for a block.  The constructor is not public.

   .. method:: get_type()

      Return the type of the symbol table.  Possible values are ``'class'``,
      ``'module'``, and ``'function'``.

   .. method:: get_id()

      Return the table's identifier.

   .. method:: get_name()

      Return the table's name.  This is the name of the class if the table is
      for a class, the name of the function if the table is for a function, or
      ``'top'`` if the table is global (:meth:`get_type` returns ``'module'``).

   .. method:: get_lineno()

      Return the number of the first line in the block this table represents.

   .. method:: is_optimized()

      Return ``True`` if the locals in this table can be optimized.

   .. method:: is_nested()

      Return ``True`` if the block is a nested class or function.

   .. method:: has_children()

      Return ``True`` if the block has nested namespaces within it.  These can
      be obtained with :meth:`get_children`.

   .. method:: has_exec()

      Return ``True`` if the block uses ``exec``.

   .. method:: has_import_start()

      Return ``True`` if the block uses a starred from-import.

   .. method:: get_identifiers()

      Return a list of names of symbols in this table.

   .. method:: lookup(name)

      Lookup *name* in the table and return a :class:`Symbol` instance.

   .. method:: get_symbols()

      Return a list of :class:`Symbol` instances for names in the table.

   .. method:: get_children()

      Return a list of the nested symbol tables.


.. class:: Function

   A namespace for a function or method.  This class inherits
   :class:`SymbolTable`.

   .. method:: get_parameters()

      Return a tuple containing names of parameters to this function.

   .. method:: get_locals()

      Return a tuple containing names of locals in this function.

   .. method:: get_globals()

      Return a tuple containing names of globals in this function.

   .. method:: get_frees()

      Return a tuple containing names of free variables in this function.


.. class:: Class

   A namespace of a class.  This class inherits :class:`SymbolTable`.

   .. method:: get_methods()

      Return a tuple containing the names of methods declared in the class.


.. class:: Symbol

   An entry in a :class:`SymbolTable` corresponding to an identifier in the
   source.  The constructor is not public.

   .. method:: get_name()

      Return the symbol's name.

   .. method:: is_referenced()

      Return ``True`` if the symbol is used in its block.

   .. method:: is_imported()

      Return ``True`` if the symbol is created from an import statement.

   .. method:: is_parameter()

      Return ``True`` if the symbol is a parameter.

   .. method:: is_global()

      Return ``True`` if the symbol is global.

   .. method:: is_local()

      Return ``True`` if the symbol is local to its block.

   .. method:: is_free()

      Return ``True`` if the symbol is referenced in its block, but not assigned
      to.

   .. method:: is_assigned()

      Return ``True`` if the symbol is assigned to in its block.

   .. method:: is_namespace()

      Return ``True`` if name binding introduces new namespace.

      If the name is used as the target of a function or class statement, this
      will be true.

      For example::

         >>> table = symtable.symtable("def some_func(): pass", "string", "exec")
         >>> table.lookup("some_func").is_namespace()
         True

      Note that a single name can be bound to multiple objects.  If the result
      is ``True``, the name may also be bound to other objects, like an int or
      list, that does not introduce a new namespace.

   .. method:: get_namespaces()

      Return a list of namespaces bound to this name.

   .. method:: get_namespace()

      Return the namespace bound to this name.  If more than one namespace is
      bound, a :exc:`ValueError` is raised.