How can I call optional inner functions in Python 3

Question

I am trying to learn Python and while creating my own class, I came across this problem. I want to call an inner function inside my function. The problem is how can I build this type of structure in Python 3?

    def GetAttributes(self):
        def GetName(self):
            return self.name
        def GetSurname(self):
            return self.surname
        def GetAge(self):
            return self.age
        def GetID(self):
            return self.ID

Basicly I want to be able to do this "GetAttributes().GetName()" which will return self.name or "GetAttributes().GetAge()" which will return self.

Edit: For duplicate of another question. I am trying to call multiple functions not one.

Answer 1

I think your solution is simple, apply OOP in Python, and rather than making GetAttributes as function make it as a class.

class GetAttributes(object):
    def __init__(self, name, surname, age, custome_id):
        self.name = name
        self.surname = surname
        self.age = age
        self.ID = custome_id
    def GetName(self):
        return self.name
    def GetSurname(self):
        return self.surname
    def GetAge(self):
        return self.age
    def GetID(self):
        return self.ID

Output

>>> ga = GetAttributes("Shivam", "Kotwalia", 25, "N15T5")
>>> ga.GetName()
    'Shivam'
>>> ga.GetAge()
    25

I am not very much sure that how are you filling the data, but this is seems to be very pythonic way tto do this :)

Happy Pythoning!

Answer 2

@ShivamKotwalia's answer is what you're looking for, but since it seems you are trying to understand why your implementation didn't work, I'll expand a little bit.

Currently your implementation is creating nested functions in the local scope. In another word, once the code is outside of the function the objects inside the local scope cease to exist unless returned to the outer scope. Take for instance a modification of your code:

def GetAttributes(person):
    def GetName(person):
        return person.name
    def GetSurname(person):
        return person.surname
    return GetName, GetSurname

This allows you to reference back to GetName and GetSurname now because they have been passed back to the outer scope. Assuming you have a Bob object that has the attribute name and surname:

name = GetAttributes(Bob)
name
# (<function GetAttributes.<locals>.GetName at 0x03E9AB28>, <function GetAttributes.<locals>.GetSurname at 0x03E9AB70>)

Notice how name has the two inner functions passed in, and that they are <locals>. Whereas GetAttributes is under the global scope: <function GetAttributes at 0x03E9AA50>.

You can then get the two functions by the index of name:

name[0](Bob)
# Bobby
name[1](Bob)
# Tables

Notice again how you still require Bob to be passed in, because both functions were defined as requiring the argument person. You could opt to remove the arguments...:

def GetAttributes(person):
    def GetName():
        return person.name
    def GetSurname():
        return person.surname
    return GetName, GetSurname

But then you're still faced with a few problems:

1. You first have to assign an object for the function to access the inner functions.
2. The GetAttributes function return nothing but its inner functions.
3. The access to the local functions are not meaningfully structured.
4. There's no guarantee that the object you pass in will always have name and surname attributes.

That's why the OOP approach (e.g. class) and methods exist:

class Person:
    def __init__(self, name, surname):
        self.name = name
        self.surname = surname
    def GetName(self):
        return self.name
    def GetSurname(self):
        return self.surname

This address all the issues above as you now have:

1. You just need to create an instance of the Person class instead of messy function handling.
2. GetAttributes is not necessary any more.
3. Easy and meaningful access to get Person().GetName().
4. The objects using these methods are guaranteed to have name and surname attributes.

"But what about the GetAttributes method?" you ask? Why, Python does have a built-in getattr() function that will serve your need!

getattr(Bob, 'name')
# Bobby

---

Having said all that, there does exist function attributes where you can do something like this:

def GetAttributes(person):
    def GetName():
        return person.name
    def GetSurname():
        return person.surname
    GetAttributes.GetName = GetName
    GetAttributes.GetSurname = GetSurname
    return GetAttributes

GetAttributes(Bob).GetName()
# Bobby

But you very quickly run into limitations and problems managing all the objects and functions you might pass within the scopes. Try it and you will see. Thus, why would you opt to go through this trouble when class, getattr and methods already do everything that you need with the benefits of safeguards in place?

Answer 3

I think this might be a little helpful, Try this:

def get_attributes(self, attr_name):
    return {
        'name': self.name,
        'surname': self.surname,
        'age': self.age,
        'ID': self.ID,
    }.get(attr_name)

and you can use it like get_attributes(name) or get_attributes(age) and so on. also, note that in the comments our friends are saying method names are better to be lower case in Python.it is one of Python naming conventions.