Question

I am writing a file parser and I want to be able to determine witch “data fields” it would return for me.

I am starting to learn python and am still used to think like a Java programmer, so this question is more about how to design my module than about how specifically parse the file.

Contextualizing, each line of the file has a fixed number of characters and each information is contained between specific indexes. Eg.:

XX20120101NAME1CITYA
XY20120101NAME2CITYB

In this fictional example, from index 0 until 2 you have one information, from 2 to 10 another, and so on…

Using Java, I would normally create an enumerator representing the different pieces of information, each “storing” the start index and the end index. In my parsing class, I would then make an method available design to accept n different enums. Eg.:

enum FileInformation {
    INFO01(0,2), INFO02(2,10), INFO03(10,15), INFO04(15,20);
    int startIndex;
    int endIndex;

    public FileInformation(int si, int ei)  {
        this.startIndex = si;
        this.endIndex = ei;
    }

    public int getStartIndex() { return si; }
    public int getEndIndex() { return ei; }
}

public Whatever parse(FileInformation... infos) {
    // Here I would iterate through infos[], 
    // using its start and end index to retrieve only what I need.
}

I know that I probably should not use the same line of though in python, specially because the language wouldn’t allow it (no enums in python) and because I imagine python can be much less verbose, but I have no idea of a good design practice to achieve this same result.

It is valid to mention that I don’t want to expose the module’s user to unnecessary complexity, or to force him to know the indexes for each information. The module’s user should preferably be able to determine witch information he wants and its order.

So, do you have any insights about solving this requisites in an elegant manner?
Thanks in advance

Answer 1

Python already has a builtin type that does what FileInformation does – check out slice.

Here’s how your module might look:

# module dataparser.py

INFO01, INFO02, INFO03, INFO04 = map(slice, ((0,2),(2,10),(10,15),(15,20)))

def parse(infos, data):
    return [data[info] for info in infos]

And how a calling module might use it:

# module dataparser_user.py

import dataparser as dp

data = """\
XX20120101NAME1CITYA
XY20120101NAME2CITYB""".splitlines()

for d in data:
    print d, dp.parse((dp.INFO01, dp.INFO03), d)

# or use partial to define a function object that takes your 
# subset number of slices
from functools import partial
specific_parse = partial(dp.parse, (dp.INFO01, dp.INFO03))

for d in data:
    print d, specific_parse(d)

If you were to implement your own enum analog in Python, I think namedtuple would be the closest thing (seeing as your Java enum has getters but no setters – namedtuples are likewise immutable):

from collections import namedtuple
FileInformation = namedtuple("FileInformation", "start end")
INFO01, INFO02, INFO03, INFO04 = map(FileInformation, ((0,2),(2,10),(10,15),(15,20)))