Note that you can use a variable in a slice:

l = ['a',' b',' c',' d',' e']
c_index = l.index("c")
l2 = l[:c_index]

This would put the first two entries of l in l2

A few cosmetic changes to makes your code more beautiful/pythonic :

Fix formatting

• Remove some line breaks as it makes the code harder to read
• Change variables name to follow PEP 8
• Your code lacks documentation making it hard to understand.

Use enumerate

Enumerate does exactly what you are trying to achieve : keep track of the index while looping on an iterable. Just use for indexofitem,item in enumerate(List):.

Remove levels of nested logic

Using elif, you could make your code a bit easier to follow. The inside of the for-loop becomes :

    if breakcounter <= numberofbreaks:
        if indexofitem < nextbreakindex:
            templist1.append(item)
        elif breakcounter < (numberofbreaks - 1):
            templist1.append(item)
            templist2.append(templist1)
            templist1 = []
            breakcounter +=1
        elif indexofitem <= lastindexval and indexofitem <= totalitems:
            templist1.append(item)
            templist2.append(templist1)
            templist1 = []
        elif indexofitem >= lastindexval and indexofitem < totalitems + 1:
            finalcounter += 1
            templist3.append(item)
            if finalcounter == finalcounttrigger:
                templist2.append(templist3)

Rewrite your comparisons

In Python, you can write comparisons in a very natural way : indexofitem >= lastindexval and indexofitem < totalitems + 1 becomes lastindexval <= indexofitem < totalitems + 1.

Use smart indices to get the last element of array

You can rewrite lastindexval = index[(len(index)-1)] with the much clearer lastindexval = index[-1].

Rethink your logic

You have totalitems = len(List) and indexofitem going from 0 to len(List) - 1 (included). Thus, indexofitem <= totalitems is not an interesting condition to check. The same goes for indexofitem < totalitems + 1.

Once this is removed, we have :

    #Less than the last cut
    if breakcounter <= numberofbreaks:
        if indexofitem < nextbreakindex:
            templist1.append(item)
        elif breakcounter < (numberofbreaks - 1):
            templist1.append(item)
            templist2.append(templist1)
            templist1 = []
            breakcounter +=1
        elif indexofitem <= lastindexval:
            templist1.append(item)
            templist2.append(templist1)
            templist1 = []
        elif lastindexval <= indexofitem:
            finalcounter += 1
            templist3.append(item)
            if finalcounter == finalcounttrigger:
                templist2.append(templist3)

Re-think your logic (bis)

On the code above, the last 2 elif checks are a bit redundant : if we don't go into the indexofitem <= lastindexval block then we must have lastindexval < indexofitem and ``lastindexval <= indexofitem` must be true.

After cleaning this, the code looks like :

    for indexofitem,item in enumerate(List):
        nextbreakindex = index[breakcounter]

        #Less than the last cut
        if breakcounter <= numberofbreaks:
            if indexofitem < nextbreakindex:
                templist1.append(item)
            elif breakcounter < (numberofbreaks - 1):
                templist1.append(item)
                templist2.append(templist1)
                templist1 = []
                breakcounter +=1
            elif indexofitem <= lastindexval:
                templist1.append(item)
                templist2.append(templist1)
                templist1 = []
            else:
                finalcounter += 1
                templist3.append(item)
                if finalcounter == finalcounttrigger:
                    templist2.append(templist3)
    return templist2

Re-think your logic (ter)

Nothing happens in the loop if breakcounter > numberofbreaks as breakcounter and numberofbreaks are not changed. If this is really the case, we might as well just break out of the loop. However, things are even better than this : once again we are in a situation that cannot happen. This can be seen in two different ways :

• if breakcounter was to be bigger than numberofbreaks, nextbreakindex = index[breakcounter] would have thrown an exception.

• breakcounter only gets incremented one element at a time. This happens only if breakcounter < (numberofbreaks - 1). Thus, once breakcounter reaches numberofbreaks - 1, it stops growing.

At the end of this rewriting, your code looks like :

def lindexsplit(List,*lindex):
    index = list(lindex)
    index.sort()

    templist1 = []
    templist2 = []
    templist3 = []

    breakcounter = 0
    finalcounter = 0

    numberofbreaks = len(index)

    lastindexval = index[-1]
    finalcounttrigger = (len(List)-(lastindexval+1))

    for indexofitem,item in enumerate(List):
        nextbreakindex = index[breakcounter]

        if indexofitem < nextbreakindex:
            print "A"
            templist1.append(item)
        elif breakcounter < (numberofbreaks - 1):
            print "B"
            templist1.append(item)
            templist2.append(templist1)
            templist1 = []
            breakcounter +=1
        elif indexofitem <= lastindexval:
            print "C"
            templist1.append(item)
            templist2.append(templist1)
            templist1 = []
        else:
            print "D"
            finalcounter += 1
            templist3.append(item)
            if finalcounter == finalcounttrigger:
                templist2.append(templist3)
    return templist2

I reckon there is still a lot more to improve and a much more simple solution could be written (as suggested in the comments).

I would be interested in seeing a more Pythonic way of doing this also. But this is a crappy solution. You need to add a checking for an empty index list.

Something along the lines of:

indexes = [5, 12, 17]
list = range(20)

output = []
prev = 0

for index in indexes:
    output.append(list[prev:index])
    prev = index

output.append(list[indexes[-1]:])

print output

produces

[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16], [17, 18, 19]]

Here is a short solution with heavy usage of the itertools module. The tee function is used to iterate pairwise over the indices. See the Recipe section in the module for more help.

>>> from itertools import tee, izip_longest
>>> s = 'long string that I want to split up'
>>> indices = [0,5,12,17]
>>> start, end = tee(indices)
>>> next(end)
0
>>> [s[i:j] for i,j in izip_longest(start, end)]
['long ', 'string ', 'that ', 'I want to split up']

Edit: This is a version that does not copy the indices list, so it should be faster.