How to do variable substitution in python

Question

I don't know what to call this but I've done it in TCL and Elixir. It's when you substitute a variable to make the code simpler. That's a terrible way of explaining it. The example will make it clear:

Here's regular code:

def get(self, item):
    if item == 'name':
        return self.name
    elif item == 'age':
        return self.age

I'd like to turn that into something like this:

def get(self, item):
    return self.%{item}

Where it interprets the value in the variable item as the name of a variable. like I said, I've done stuff like this in other languages but I don't know what it's called and I don't know how to do it in python.

Can you help me? What is this ability/style called? Also, how do you do it in Python?

PS. Here's a trivial example from TCL

c:\repos\flow>tclsh
% set foo bar
bar
% set bar baz
baz
% puts $foo
bar
% puts [set $foo]
baz

See how [set $foo] essentially told the interpreter to interpret $foo's value as a variable name which was the variable bar then the command puts took bar as a variable and printed out its value which was the string baz

You can even do this kind of thing with commands in Tcl

% set a puts
puts
% $a hello\ world
hello world

Answer 1

You can use getattr:

def get(self, item):
  return getattr(self, item)

getattr can also be used like getattr(object, attrname), and it behaves in the same way.

However, having to do this is usually bad practice. You should probably be using a dictionary instead. An example with a dictionary:

def __init__(self, whatever):
  self.stuff = {"name": "bob", "age": 40}

def get(self, item):
  return self.stuff[item]

See also: this

If you want to get variables from the global or local scopes, you can use:

a = 1
def f():
  b = 2
  print(globals()["a"])
  #print(globals()["b"]) fails, b is not global
  print(locals["b"]) # works, b is in the local scope

There is also a very general way (also very ugly and insecure):

foo="bar"
bar="baz"
baz = ""
obj=None
eval(f"obj.{foo}") # obj.bar
eval(f"obj.{eval(f'{foo}')}") # obj.baz
eval(f"{foo}") # bar / "baz"
eval(f"{eval(f'{foo}')}") # baz / ""

Please never use this.

Answer 2

You can try this approach:

class foo():
    cls_attr = "hello"
    def __init__(self):
        self.name = "i am foo"
        self.age = 0
        self.gender = None
        self.bar = "this is bar"
    def get(self, item):
        if item in foo.__dict__:
            return foo.__dict__[item]
        elif item in self.__dict__:
            return self.__dict__[item]
        else:
            return None

>>> f = foo()
>>> f.get('gender')
>>> f.get('bar')
'this is bar'
>>> f.get('name')
'i am foo'
>>> f.get('nothing')
>>> f.get('age')
0
>>> f.get('cls_attr')
'hello'

Updated my answer based on internet_user's comment. Now it should return both instance and class attributes.

Edit: Okay I don't know how to do the superclass attributes (I mean I can probably guess it's super().__dict__), but at the end of the day internet_user's answer is a better version. I'll leave this answer here for future viewers to see the inefficient approach for comparison.