How to Access Function variables in Another Function [duplicate]

You can't. Variables created in a function are local to that function. So if you want function yyy to get the values of some variables defined in function xxx then you need to return them from xxx, as demonstrated in Sharon Dwilif K's answer. Note that the names of the variables in yyy are irrelevant; you could write:

def yyy():
    p, q = xxx()
    print p        ### value a from xxx()
    print q        ### value b from xxx()

and it would give the same output.

Alternatively, you could create a custom class. Briefly, a class is a collection of data together with functions that operate on that data. Functions of a class are called methods, the data items are known as attributes. Each method of a class can have its own local variables, but it can also access the attributes of the class. Eg

class MyClass(object):
    def xxx(self):
        self.a = 10
        self.b = 15
        self.c = 20

    def yyy(self):
        self.xxx()
        print self.a
        print self.b

#Create an instance of the class
obj = MyClass()

obj.yyy()

output

10
15

Please see the linked documentation for more information about classes in Python.

Try this:

def xxx():
    a=10
    b=15
    c=20
    return a, b

def yyy():
    a, b = xxx()
    print a
    print b

yyy()

Or this:

def xxx():
    global a, b
    a=10
    b=15
    c=20

def yyy():
    print a
    print b

xxx()
yyy()

For more info, use help('return') and help('global'), or see this and this question.

And only use global when you need the variable can use at everywhere or you need the function return other things. Because modifying globals will breaks modularity.

pickle.dump-workaround

In general, I'm working with a return statement if I need the variable for another function or a script.

But especially if I want to investigate why my code is failing with new data I'd like to analyze the parameters without rebuilding all the code.

My solution is just to store the file on disk.

def xxx():
    a=10

    tmp_dir = os.path.join(os.getcwd(),'tmp')
    if not os.path.exists(tmp_dir):        
        os.mkdir(tmp_dir)
    pickle.dump(a, open(os.path.join(tmp_dir,'a.pickle'), 'wb'))

    b=15
    c=20
    

Then you may load the parameter from where ever you want. In my case usually from a Jupyter-Notebook for the analyses.

def yyy():
    a = pickle.load(open(os.path.join(tmp_dir,'a.pickle'), 'rb'))
    print a        ### value a from xxx()
    print b 

Btw: this is for sure a construction I would only use to analyze errors.

The answers people gave above are correct. But from a design perspective this is not something correct. Method local variables are mean to be local. If at all there is something that needs to be shared across a file or some set of methods I suggest you use file level variables or constants.

Use the global keyword, like the following example:

global a=0
global b=0
global c=0

def xxx():
    a=10
    b=15
    c=20
    return a,b

def yyy():
    print a
    print b 
    xxx()