First thing is to remember that python uses zero indexing.

You can iterate throught the list except using the range function to get the indexes of the items you want or slices to get the elements.

What I think is becoming confusing here is that in your example, the values and the indexes are the same so to clarify I'll use this list as example:

I = ['a', 'b', 'c', 'd', 'e']
nI = len(I) # 5

The range function will allow you to iterate through the indexes:

for i in range(1, nI):
    print(i)
# Prints:
# 1
# 2
# 3
# 4

If you want to access the values using the range function you should do it like this:

for index in range(1, nI):
    i = I[index]
    print(i)
# Prints:
# b
# c
# d
# e

You can also use array slicing to do that and you don't even need nI. Array slicing returns a new array with your slice.
The slice is done with the_list_reference[start:end:steps] where all three parameters are optional and:
start is the index of the first to be included in the slice
end is the index of the first element to be excluded from the slice
steps is how many steps for each next index starting from (as expected) the start (if steps is 2 and start with 1 it gets every odd index).
Example:

for i in I[1:]:
    print(i)
# Prints:
# b
# c
# d
# e

The range() function

We can generate a sequence of numbers using range() function. range(10) will generate numbers from 0 to 9 (10 numbers). We can also define the start, stop and step size as range(start,stop,step size). step size defaults to 1 if not provided. This function does not store all the values in memory, it would be inefficient. So it remembers the start, stop, step size and generates the next number on the go.

Your code should looks like:

integer = [1,3,2,4]
for i in range(1,len(integer)):
    print (integer[i])

Output:

3
2
4

Well you need tuple of 2 elements, so

data = [1,2,3,4,5,6]
for i,k in zip(data[0::2], data[1::2]):
    print str(i), '+', str(k), '=', str(i+k)

Where:

• data[0::2] means create subset collection of elements that (index % 2 == 0)
• zip(x,y) creates a tuple collection from x and y collections same index elements.

Just slice it.

for script, location in self.device.scripts[1:]:
    pass

For your second question, you don't need to worry about any IndexError since slicing returns an empty list when it's out of range.

You could do it your way, just add a step part to the slice to make both slices skip a number:

for v, w in zip(l[::2],l[1::2]):  # No need to end at -1 because that's the default
    print [v, w]

But I like helper generators:

def pairwise(iterable):
    i = iter(iterable)
    while True:
       yield i.next(), i.next()

for v, w in pairwise(l):
    print v, w

There are different approaches, a simple comprehension would do:

[x[1] for x in l]

Also with map and operator.itemgetter:

from operator import itemgetter
list(map(itemgetter(1), l))

For printing the results you can call print with unpacking:

print(*out_list)

For example:

>>> l = [['id_5', 4], ['id_6', 4], ['id_7', 4], ['id_0', 12], ['id_1', 4], ['id_2', 8], ['id_3', 8], ['id_4', 4], ['id_8
', 1]]
>>> from operator import itemgetter
>>> out_list = list(map(itemgetter(1), l))
>>> out_list
[4, 4, 4, 12, 4, 8, 8, 4, 1]
>>> print(*out_list)
4 4 4 12 4 8 8 4 1

All as a one liner:

>>> print(*(x[1] for x in l))
4 4 4 12 4 8 8 4 1

You can use a modulo

x = [2, 133, 24]

start = 1
end = 3
for i in range(start,end+start):
    index = i % end
    print(x[index])

islice has the advantage that it doesn't need to copy part of the list

from itertools import islice
for day in islice(days, 1, None):
    ...

A more memory efficient way to iterate over a slice of a list would be to use islice() from the itertools module:

from itertools import islice

listOfStuff = (['a','b'], ['c','d'], ['e','f'], ['g','h'])

for item in islice(listOfStuff, 1, 3):
    print(item)

# ['c', 'd']
# ['e', 'f']

However, this can be relatively inefficient in terms of performance if the start value of the range is a large value since islice would have to iterate over the first start value-1 items before returning items.