On Python 3, use the nonlocal keyword:

The nonlocal statement causes the listed identifiers to refer to previously bound variables in the nearest enclosing scope excluding globals. This is important because the default behavior for binding is to search the local namespace first. The statement allows encapsulated code to rebind variables outside of the local scope besides the global (module) scope.

def foo():
    a = 1
    def bar():
        nonlocal a
        a = 2
    bar()
    print(a)  # Output: 2

On Python 2, use a mutable object (like a list, or dict) and mutate the value instead of reassigning a variable:

def foo():
    a = []
    def bar():
        a.append(1)
    bar()
    bar()
    print a

foo()

Outputs:

[1, 1]

In Python 3.x this is possible:

def f1():
        x = 5
        def f2():
                nonlocal x
                x+=1
        return f2

The problem and a solution to it, for Python 2.x as well, are given in this post. Additionally, please read PEP 3104 for more information on this subject.

You can use nonlocal statement in Python 3:

>>> def f():
...     x = 2
...     def y():
...         nonlocal x
...         x += 3
...         print(x)
...     y()
...     print(x)
...

>>> f()
5
5

In Python 2 you need to declare the variable as an attribute of the outer function to achieve the same.

>>> def f():
...     f.x = 2
...     def y():
...         f.x += 3
...         print(f.x)
...     y()
...     print(f.x)
...

>>> f()
5
5

or using we can also use a dictionary or a list:

>>> def f():
...     dct = {'x': 2}
...     def y():
...         dct['x'] += 3
...         print(dct['x'])
...     y()
...     print(dct['x'])
...

>>> f()
5
5

In Python 3 you can do this with the nonlocal keyword. Do nonlocal a at the beginning of inner to mark a as nonlocal.

In Python 2 it is not possible.

In Python 3.x, you can use the nonlocal keyword:

def outer():
    string = ""
    def inner():
        nonlocal string
        string = "String was changed by a nested function!"
    inner()
    return string

In Python 2.x, you could use a list with a single element and overwrite that single element:

def outer():
    string = [""]
    def inner():
        string[0] = "String was changed by a nested function!"
    inner()
    return string[0]

You could simply reference the 'theVariable' inside the nested InnerFunction, if you don't want to pass it's value as a parameter:

def OuterFunction():
    # Declare the variable
    theVariable = 42

    def InnerFunction():
        # Just reference the 'theVariable', using it, manipulating it, etc...
        print(theVariable)

    # Call the InnerFunction inside the OuterFunction
    InnerFunction()

# Call the OuterFunction on Main
OuterFunction()

# It will print '42' as result

First off, in this simple case you could return the desired value from inner() and assign it when calling inner(). But let's assume that this is a simplified example, and that you are in fact changing multiple variables, or returning inner somewhere else where it will be called multiple times and need to reexamine its variable.

In Python 3 you can declare variab as nonlocal, which would allow you to change it. In Python 2, the only way is to switch to mutating an object with state freshly created on each call to outer. For example, using a list:

def outer():
    variab = [""]
    #some code including, presumably, a call to inner()

    def inner():
        # some code
        variab[0] = "new_value"

    print variab[0]

Nicer variants of this can be achieved, e.g. by making variab contain a dict or a Python instance with mutable __dict__. An elegant idiom is to use the __dict__ of the inner function itself as the container:

def outer():
    def inner():
        # some code
        inner.variab = "new_value"

    inner.variab = ""
    #some code including, presumably, a call to inner()    
    print inner.variab