0

I want to read an external data source (excel) and create variables containing the data. Suppose the data is in columns and each column has a header with the variable name.

My first idea is to write a function so i can easily reuse it. Also, I could easily give some additional keyword arguments to make the function more versatile.

The problem I'm facing is that I want to refer to the data in python (interactively) via the variable names. I don't know how to do that (with a function). The only solution I see is returning the variable names and the data from my function (eg as lists), and do something like this:

def get_data()
    (...)
    return names, values

names, values = get_data(my_excel)

for n,v in zip(names, values):
    exec(''.join([n, '= v']))

Can I get the same result directly? Thanks, Roel

Improve this question
1
  • Thank you all for your answers. Choosing THE accepted answer is difficult as you all contributed and learned me things. I finally chose to use the 'object' approach of @lazyr as it gives me most easy access to my data (moreover, the Ipython console can automatically complete the attributes, so really practical!) Commented Apr 5, 2011 at 8:21

3 Answers 3

Reset to default
2

Use a dictionary to store your mapping from name to value instead of creating local variable.

def get_data(excel_document):
    mapping = {}
    mapping['name1'] = 'value1'
    # ...
    return mapping

mapping = get_data(my_excel)
for name, value in mapping:
    # use them

If you really want to populate variables from the mapping, you can modify globals() (or locals()), but it is generally considered bad practice.

mapping = get_data(my_excel)
globals().update(mapping)
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

thanks for your answer. You say updating globals() is considered bad practice. The answer from @lazyr seems to do the same but with locals, which looks like a good intermediate solution, or is this considered bad practice too?
Changing locals() is also frequently considered bad practice since, you can't easily deduce what variables are defined just by reading the code (this is worse when updating globals()). This goes against the principle of least surprise and will render the code harder to understand. If this is just for a small script, then it is probably fine, but for larger application, you should consider other alternatives.
I guess in this case I can live with it: I want to use the variables in matlab-like way to make graphs in a try/error approach. It's just easier to type plt.plot(Temp1) than plt.plot(d.Temp1) (if d is the dictionary). (BTW, how do I format code in this comment section?)
1

If you just want to set local variables for each name in names, use:

for n, v in zip(names, values):
    locals()[n] = v

If you'd rather like to have a single object to access the data, which is much cleaner, simply use a dict, and return that from your function.

def get_data():
    (...)
    return dict(zip(names, values))

To access the value of the name "a", simply use get_data()["a"].

Finally, if you want to access the data as attributes of an object, you can update the __dict__ of an object (unexpected behaviour may occur if any of your column names are equal to any special python methods).

class Data(object):
   def __init__(self, my_excel):
       (...)
       self.__dict__.update(zip(names, values))

data = Data("test.xls")
print data.a
Improve this answer

6 Comments

thanks a lot for your answer. Updating the locals looks like a nice trick to have the data at hand for scripting without having to type data.a all the time.
Is that really a problem, though? You only have to type 'data.' a few times while you're writing your program the first time, and then you're done with it for life. In exchange, you know that data.foo isn't going to interfere with your "real" variable foo.
Well, it's because i want to make graphs and such interactively, like one would do in a matlab command window. This requires typing the variables rather often. But indeed, it's not a real issue when i can use the object approach as showed above. It's much easier than dictionaries: data.a instead of data['a']
Have you tried your example with locals()? It doesn't work here (Python 2.7), and the documentation says it doesn't work.
Yes, it works (Python 2.6). I am using the object approach of lazyr with data = Data("my_excel") and I updated locals like this: ´locals().update(data.__dict__)´
|
1

The traditional approach would be to stuff the key/value pairs into a dict so that you can easily pass the whole structure around to other functions. If you really want to store them as attributes instead of dict keys, consider creating a class to hold them:

class Values(object): pass
store = Values()
for key, value in zip(names, values):
    setattr(store, key, value)

That keeps the variables in their own namespace, separate from your running code. That's almost always a Good Thing. What if you get a spreadsheet with a header called "my_excel"? Suddenly you've lost access to your original my_excel object, which would be very inconvenient if you needed it again.

But in any case, you should never use exec unless you know exactly what you're doing. And even then, don't use exec. For instance, I know how your code works and send you a spreadsheet with "os.system('echo rm -rf *')" in a cell. You probably don't really want to execute that.

Improve this answer

2 Comments

That's a clear example why using exec can be dangerous indeed. I don't know what your code does, but i suppose I don't want to try :-)
Well, /this one/ is just a harmless little print statement so that I couldn't be blamed if someone copied-and-pasted to see if it really worked. :-)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.