for i in range(15):
    print i #will print out 0..14

for i in range(1, 15):
    print i # will print out 1..14


for i in range (a, b, s):
    print i # will print a..b-1 counting by s. interestingly if while counting by the step 's' you exceed b, it will stop at the last 'reachable' number, example

for i in range(1, 10, 3):
    print i

> 1
> 4
> 7

List Splicing:

a = "hello" # there are 5 characters, so the characters are accessible on indexes 0..4

a[1] = 'e'
a[1:2] = 'e' # because the number after the colon is not reached.

a[x:y] = all characters starting from the character AT index 'x' and ending at the character which is before 'y'

a[x:] = all characters starting from x and to the end of the string

In the future, if you ever wonder what the behavior of python is like, you can try it out in the python shell. just type python in the terminal and you can enter any lines you want (though this is mostly convenient for one-liners rather than scripts).

a = [12,11,5,7,2,21,32,13,6,42,1,8,9,0,32,38]
indices = [idx for idx,val in enumerate(a) if val < 10]

This creates a list of indices:

[2, 3, 4, 8, 10, 11, 12, 13]

I would recommend keeping it that way for easy parsing, but you can also turn it into ranges as follows:

ranges = [[]]
for val in indices:
    if not ranges[-1] or ranges[-1][-1] == val-1:
        ranges[-1].append(val)
    else:
        ranges.append([val])

This creates a list of ranges:

[[2, 3, 4], [8], [10, 11, 12, 13]]

Now to take out the middle:

ranges = [[item[0],item[-1]] if len(item) > 1 else item for item in ranges]

Result:

[[2, 4], [8], [10, 13]]

One alternative is to do:

mylist1 = [11, 4, 5, 6, 8, 6, 3]

for i in mylist1:
    a = list(range(i))
    print(a[-2:] + a[:2])

Output

[9, 10, 0, 1]
[2, 3, 0, 1]
[3, 4, 0, 1]
[4, 5, 0, 1]
[6, 7, 0, 1]
[4, 5, 0, 1]
[1, 2, 0, 1]

If you really want to use manual indexing, then dont use enumerate() and just create a range() (or xrange() if Python 2.x) of the right size, ie:

for i in xrange(len(a) - 2):
   # code here

Now you don't have to manually take care of indexes at all - if you want to iterate over (a[x], a[x+1]) pairs all you need is zip():

for x, y in zip(a, a[1:]):
   if abs(x - y) < min:
       min = abs(x - y)

zip(seq1, seq2) will build a list of (seq1[i], seq2[i]) tuples (stopping when the smallest sequence or iterator is exhausted). Using a[1:] as the second sequence, we will have a list of (a[i], a[i+1]) tuples. Then we use tuple unpacking to assign each of the tuple's values to x and y.

But you can also just use the builtin min(iterable) function instead:

min(abs(x - y) for x, y in zip(a, a[1:]))

which is the pythonic way to get the smallest value of any sequence or iterable.

Note that with Python 2.x, if your real list is actually way bigger, you'll benefit from using itertools.izip instead of zip

As as side note, using min (actually using any builtin name) as a variable name is possibly not a good idea as it shadows the builtin in the current namespace. If you get a TypeError: 'int' object is not callable message trying this code you'll know why...

A slice and range are subtly different things, even though both use a start, stop, step triplet. If Python were to silently use one in place of the other, it could lead to subtle bugs.

To see the difference directly, one can indeed look at numpy where the two cause different indexing:

>>> arr = np.array([0, 1, 2, 3, 4])
>>> arr[slice(1, -1)]
array([1, 2, 3])
>>> arr[range(1, -1)]
array([], dtype=int64)

The result is different because slice and range have different meaning for negative numbers.

• A range represents a part of the number line of integers. This extends to negative numbers.
• A slice represents a part of the ordinal numbers/indices of sequences.¹ This wraps negative numbers back to positive numbers.

Or put simpler, the meaning of a slice depends on the size of a sequence whereas a range does not. Thus, accidentally using one in place of the other would be wrong.

¹ Technically, a slice represents any concept of start, stop, step. The standard sequence types interpret this as numerical indices. It is also possible for a slice to represent the edges of a graph, for example.

Numpy slicing allows you to input a list of indices to an array so that you can slice to the exact values you want.

For example:

    import numpy as np
    a = np.random.randn(10)
    a[[2,4,6,8]]

This will return the 2nd, 4th, 6th, and 8th array elements (keeping in mind that python indices start from 0). So, if you want every 2nd element starting from an index x, you can simply populate a list with those elements and then feed that list into the array to get the elements you want, e.g:

    idx = list(range(2,10,2))
    a[idx]

This again returns the desired elements (index 2,4,6,8).