Splitting tuples in Python - best practice?

Question

I have a method in my Python code that returns a tuple - a row from a SQL query. Let's say it has three fields: (jobId, label, username)

For ease of passing it around between functions, I've been passing the entire tuple as a variable called 'job'. Eventually, however, I want to get at the bits, so I've been using code like this: (jobId, label, username) = job

I've realised, however, that this is a maintenance nightmare, because now I can never add new fields to the result set without breaking all of my existing code. How should I have written this?

Here are my two best guesses: (jobId, label, username) = (job[0], job[1], job[2]) ...but that doesn't scale nicely when you have 15...20 fields

or to convert the results from the SQL query to a dictionary straight away and pass that around (I don't have control over the fact that it starts life as a tuple, that's fixed for me)

Answer 1

I'd say that a dictionary is definitely the best way to do it. It's easily extensible, allows you to give each value a sensible name, and Python has a lot of built-in language features for using and manipulating dictionaries. If you need to add more fields later, all you need to change is the code that converts the tuple to a dictionary and the code that actually makes use of the new values.

For example:

job={}
job['jobid'], job['label'], job['username']=<querycode>

Answer 2

With a tuple it will always be a hassle to add or change fields. You're right that a dictionary will be much better.

If you want something with slightly friendlier syntax you might want to take a look at the answers this question about a simple 'struct-like' object. That way you can pass around an object, say job, and access its fields even more easily than a tuple or dict:

job.jobId, job.username = jobId, username

Answer 3

Perhaps this is overkill for your case, but I would be tempted to create a "Job" class that takes the tuple as its constructor argument and has respective properties on it. I'd then pass instances of this class around instead.

Answer 4

I would use a dictionary. You can convert the tuple to a dictionary this way:

values = <querycode>
keys = ["jobid", "label", "username"]
job = dict([[keys[i], values [i]] for i in xrange(len(values ))])

This will first create an array [["jobid", val1], ["label", val2], ["username", val3]] and then convert that to a dictionary. If the result order or count changes, you just need to change the list of keys to match the new result.

PS still fresh on Python myself, so there might be better ways off doing this.

Answer 5

How about this:

class TypedTuple:
    def __init__(self, fieldlist, items):
       self.fieldlist = fieldlist
       self.items = items
    def __getattr__(self, field):
       return self.items[self.fieldlist.index(field)]

You could then do:

j = TypedTuple(["jobid", "label", "username"], job)
print j.jobid

It should be easy to swap self.fieldlist.index(field) with a dictionary lookup later on... just edit your __init__ method! Something like Staale does.

Answer 6

@Staale

There is a better way:

job = dict(zip(keys, values))

Answer 7

An old question, but since no one mentioned it I'll add this from the Python Cookbook:

Recipe 81252: Using dtuple for Flexible Query Result Access

This recipe is specifically designed for dealing with database results, and the dtuple solution allows you to access the results by name OR index number. This avoids having to access everything by subscript which is very difficult to maintain, as noted in your question.

Answer 8

This is an old question, but...

I'd suggest using a named tuple in this situation: collections.namedtuple

This is the part, in particular, that you'd find useful:

Subclassing is not useful for adding new, stored fields. Instead, simply create a new named tuple type from the _fields attribute.

Answer 9

If you're using the MySQLdb package, you can set up your cursor objects to return dicts instead of tuples.

import MySQLdb, MySQLdb.cursors
conn = MySQLdb.connect(..., cursorclass=MySQLdb.cursors.DictCursor)
cur = conn.cursor() # a DictCursor
cur2 = conn.cursor(cursorclass=MySQLdb.cursors.Cursor) # a "normal" tuple cursor