I assume do_this and do_that are actually dependent on some argument of foo, since otherwise you could just move them out of foo and call them directly.

I suggest reworking the whole thing as a class. Something like this:

class Foo(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def do_this(self):
        pass

    def do_that(self):
        pass

    def __call__(self):
        self.do_this()
        self.do_that()

foo = Foo(x, y)
foo()
foo.do_this()

Python inner functions (or nested functions) have many use cases but in non of them, accessing through the nested function from outside is an option. A nested function is created to have access to the parent function variables and calling it from outside of the parent function is in conflict with principle.

You can call the function from the parent function or make it a decorator:

Calling the nested function from the parent would be:

def run_code(filename):
    def fileCommand():
        print("the file type is\n")
        os.system("file " + filename).read().strip()
    fileCommand()

If you describe more about your use case and the reason why you want to run the code like this, I can give more details about how you can implement your code.

If you want, you can return several functions that way:

class Box(object):
    def __init__(self,**kw): vars(self).update(kw)
def first(x):
    def second():
        print(x)
    def third(y): return x+y
    return Box(second=second,third=third)

first(10).second()   # prints 10
x=first(15)
x.second()           # prints 15
print(x.third(10))   # prints 25

Any resemblance to reputation scores for answers is coincidental.

You would have to return the function object; function2 is just another local variable inside function1 otherwise:

def function1():
    #code here
    def function2():
        return foo
    return function2

def function3():
    x = function1()()  # calls function2, returned by function1()

Calling function1() returns the function2 object, which is then called immediately.

Demo:

>>> def foo(bar):
...     def spam():
...         return bar + 42
...     return spam
... 
>>> foo(0)
<function spam at 0x10f371c08>
>>> foo(0)()
42
>>> def ham(eggs):
...     result = foo(eggs + 3)()
...     return result
... 
>>> ham(38)
83

Note how calling foo() returns a function object.

The nested function is only available to the function in whose scope you defined it, just like if you declare a local variable inside a function (and indeed, a function is really just a variable whose value is a "callable").

One way to enforce this is to put the definitions in a class.

class Parent:
    def __init__(self):
        self.p1 = neighbor()

    def child(self):
        print("c1", self.p1)

Now, you will be able to call the child method from outside the class scope, but only when you have created a Parent object instance. (The __init__ method gets called when you create the instance.)

instance = Parent()  # create instance
... # maybe other code here
instance.child()

An additional benefit is that you can have multiple Parent instances if you want to; each has its own state (the set of attributes and their values, like here the p1 attribute which you access via instance.p1 or inside the class via self.p1).

Learning object-oriented programming concepts doesn't end here, but this is actually a pretty simple and gentle way to get started.

func1 does return nothing (implicitly None), that is why you get the exception, if you want to call func3 from main block, just return func2, call func2 to get func3 and then call it.

# File: nesteFunc.py
def func1():
    x1 = 1
    def func2():
        x2 = 2
        def func3():
            x3 = 3
            print(x1, x2, x3)
        return func3
    return func2

if __name__ == "__main__":
    f2 = func1()
    f3 = f2()
    f3()

About your second question, yes, func3 will hace access to variables x1 and x2 because they exist in the parent scope.

When you do this, function b is defined locally within a. This means that it cannot be accessed by default outside of a. There are two main ways to solve this, but both involve modifying a:

1. The global keyword (not recommended)

   def a():
       global b
       def b():
           print("hi")
   

   Here the global keyword sets b up as a global variable, so that you can then access it by calling it normally from within c. This is generally frowned upon.

2. Returning the function from a and passing it to c

   def a():
       def b():
           print("hi")
       return b
   
   def c(b):
       #your code
   

   Then, when you call c, you should pass b to it, which a will have returned. You can either do so thus:

   b = a()
   c(b)
   

   Or you can simply call a every time you call c, thus:

   c(a())
   

   If you choose to do this, you can then define c thus:

   def c():
       b = a()
       #your code here
   

   which would allow you to simply call c normally, thus:

   `c()`
   

To answer your first question: to call all of the functions you need to put the names of your functions into the main() function. But, you had several other errors so I have decided to walk you through the program, step-by-step.

First, we set the prices:

secA = 20
secB = 15
secC = 10

Here is the first function, getTickets()

def getTickets():

    global A
    A = int(input("Please enter the number of tickets sold in section A: "))

    global B
    B =int(input("Please enter the number of tickets sold in section B: "))

    global C
    C =int(input("Please enter the number of tickets sold in section C: "))

Notice the word global before I use the variable. This tells the computer that this variable can be used everywhere. Next, notice the double parentheses - since both int() and input() are functions, so we need to show that by doing that.

I fixed your code for the ticketsValid() function. Usually, it isn't a good idea to nest functions, so this is at the same indentation level as the above code.

def ticketsValid(A,B,C):
    while A > 300 or A < 0:
        print("ERROR: Section A has a limit of 300 seats\n")
        A = int(input("Please enter the number of tickets sold in section A: "))
    while B > 500 or B < 0:
        print("ERROR: Section B has a limit of 500 seats")
        B =int(input("Please enter the number of tickets sold in section B: "))
    while C > 200 or C < 0:
        print("ERROR: Section C has a limit of 200 seats")
        C =int(input("Please enter the number of tickets sold in section C: "))

This gets the variables from above, and checks to see if they are valid. Notice that I added a check for negative numbers - you can't sell negative tickets.

Then we come to calcIncome(A,B,C):

def calcIncome(A, B, C):
    total = A * secA + B * secB + C * secC
    print ("The income generated is $%d" % (total))

First, we multiply the sections by the set prices to calculate the total. Then, we print it.

Lastly, we need to call the functions. I used your idea for a main() function, which uses the other functions. It looks like this.

def main():
    getTickets()
    ticketsValid(A,B,C)
    calcIncome(A, B, C)

It simply calls the other functions, in the correct order, when run.

Lastly, we call the main() function by typing:

main()

I hope that this answered your question. If not, feel free to comment. If so, please check the green check mark next to my answer.