.. getthecode:: scope.py
    :language: python3
    :hidden:

=======
 Scope
=======

This page contains a memo on scope.


.. code-block:: py3

    from Tools import *
    
Upper scope
-----------
Attributes are local to the "__main__" Python file or a module


.. code-block:: py3

    a_global = 1 # in fact local to upper scope
    print(a_global)

.. code-block:: none

    1
    
_ prefixed attributes are privates by convention


.. code-block:: py3

    _a_private_global = 2
    
Module Scope
~~~~~~~~~~~~
Let a module :file:`ModuleA/__init__.py`


.. literalinclude:: __init__.py


.. code-block:: py3

    import ModuleA
.. code-block:: pytb

    ModuleNotFoundError

.. code-block:: none


Loops
~~~~~


.. code-block:: py3

    for i in range(10):
        # i is local to the upper scope
        pass
    
    print('i' in globals())
    print('last i is', i)

.. code-block:: none

    True
    last i is 9
    
With statement
~~~~~~~~~~~~~~


.. code-block:: py3

    with open(__file__) as fh:
        # fh is local to the upper scope
        print(type(fh))
    print(type(fh))
.. code-block:: pytb

    NameError

.. code-block:: none


Test for main
-------------


.. code-block:: py3

    if __name__ == '__main__':
        print('This file is main')
    
Function scope
--------------


.. code-block:: py3

    another_global = 1
    
    def foo():
        tmp_local = 1 # temporary attribute in function scope
        another_global = 2 # idem
        # global id1, id2, ...
        global a_global # use attribute defined at top level (global)
        print_function('foo', a_global, another_global)
    
    try:
        print(tmp_local)
    except NameError as exception:
        print(exception)
    
    foo()

.. code-block:: none

    name 'tmp_local' is not defined
    @foo
        1
        2
    

.. code-block:: py3

    def outside():
        tmp_local = "outside"
        def inside():
            tmp_local = "inside"
            print_function('inside', tmp_local)
        inside()
        print_function('outside', tmp_local)
    
    outside()

.. code-block:: none

    @inside
        'inside'
    @outside
        'outside'
    

.. code-block:: py3

    def outside():
        tmp_local = "outside"
        def inside():
            # nonlocal id1, id2, ...
            nonlocal tmp_local # # use attribute defined at upper level
            tmp_local = "inside"
            print_function('inside', tmp_local)
        inside()
        print_function('outside', tmp_local)
    
    outside()

.. code-block:: none

    @inside
        'inside'
    @outside
        'inside'
    
We can attach attributes to function


.. code-block:: py3

    foo.attribute = 1
    
Class scope
-----------


.. code-block:: py3

    class Foo:
    
        # We can execute codes in class declaration !
        print('building Foo')
    
        attribute = 1 # local attribute in class scope
    
        # _ prefixed attributes are privates by convention
        _private_attribute = 2
    
        # __ prefixed attributes are prefixed by class name
        # "__foo_attribute" is mangled to "Foo__foo_attribute"
        __foo_attribute = 3
    
        def __init__(self):
            print_method(self, '__init__')
    
        # This method cannot be overridden in subclasses
        def __method(self):
            print_method('Foo', '__method', self)
    
        def method(self):
            print_method(self, 'method')
            self.__method() # call Foo__foo_attribute
    
We can complete class later


.. code-block:: py3

    Foo.attribute = 2
    
    def another_method(self):
        print_method(self, 'another_method')
    Foo.another_method = another_method

.. code-block:: none



.. code-block:: py3

    obj = Foo()
    obj.method()
    obj.another_method()

.. code-block:: none

    @Foo.__init__
    @Foo.method
    @Foo.__method
        <__main__.Foo object at 0x7ff7d0a62c18>
    @Foo.another_method
    

.. code-block:: py3

    class Bar(Foo):
    
        def __method(self):
            print_method('Bar', '__method', self)
    
    obj = Bar()
    obj.method()

.. code-block:: none

    @Bar.__init__
    @Bar.method
    @Foo.__method
        <__main__.Bar object at 0x7ff7d09bd4e0>