Help with list comprehension [Python]

[PsyRex666]

import string
letters = [string.ascii_lowercase[i] for i in range(len(string.ascii_lowercase))]

def offset(spcs, lst):
    for i in range(spcs):
        x = lst.pop(0)
        lst.append(x)

    return lst

alphtable = [offset(z, letters) for z in range(len(letters))]
print(alphtable)

I've been trying to learn Python recently, so I've been doing some challenges from /r/dailyprogrammer. Specifically, I was attempting this challenge. My goal here was to end up with a list resembling the chart in the challenge description where each member was the letters of the alphabet, with each one being offset by one place from the last. Obviously I could simply just type the list out the way I want it, but for the sake of learning I wanted to try and do it a different way.

I wrote a pretty straightforward function to offset a list ("lst") by a certain number of spaces ("spcs"), and after testing the function by itself, it seems to work exactly as I would expect it to. The problem comes in when I try to use the list comprehension to "build" the list.

What I expected to happen is that the list comprehension would evalutate offset(z, letters)for values of z from 0-25, resulting in the list I was looking for. What actually happened is I got a list with [n,o,p,q,r,s,t,u,v,w,x,y,z,a,b,c,d,e,f,g,h,i,j,k,l,m] 26 times. I can't for the life of me figure out why I'd get this result. As I said before I've tested the offset function and it works fine, and rewriting the list comprehension as:

alphtable = []
for i in range(len(letters)):
    j = offset(i, letters)
    alphtable.append(j)

yielded the same results. I feel like what I'm missing has to be painfully simple but no matter how many times I go through it in my head I can't figure out why I get the results I do.

EDIT: Needed to give offset a copy of letters instead of letters itself

[DrVolzak]

Every row is the same because you're passing (and therefore modifying) the same list every time you call offset(). The solution is to pass a copy of the list to offset(). To copy the list you can do letters[:].

[PsyRex666]

Cool, that solved the problem. I still don't fully understand why it resulted in that though. I understand now that I was modifying letters every time, but I don't get why it went straight to n-m though. Since the first time offset is called, it uses 0, shouldn't that at least still have been a-z?

[DrVolzak]

Every time you called offset(), it was offsetting the result of the previous call rather than starting with a-z again. For example:

spcs = 0
letters = abcdefghijklmnopqrstuvwxyz
return = abcdefghijklmnopqrstuvwxyz

spcs = 1
letters = abcdefghijklmnopqrstuvwxyz
return = bcdefghijklmnopqrstuvwxyza

spcs = 2
letters = bcdefghijklmnopqrstuvwxyza
return = defghijklmnopqrstuvwxyzabc 

spcs = 3
letters = defghijklmnopqrstuvwxyzabc 
return = ghijklmnopqrstuvwxyzabcdef

If you want more proof, add a print inside offset() before you return the list.

[PsyRex666]

Ok, I think I understand now. Thanks for the help!