You can do slicing and del.

Slicing to obtain first n elements. del to delete first n elements.

mainlist = [5,4,3,2,1]
lst = mainlist[:3]
del mainlist[:3]

Since this is a list, you can just get the last five elements by slicing it:

last_photos = photos[5:]

This will return a shallow copy, so any edit in any of the lists will be reflected in the other. If you don't want this behaviour you should first make a deep copy.

import copy
last_photos = copy.deepcopy(photos)[5:]

edit:

should of course have been [5:] instead of [:-5] But if you actually want to 'pop' it 5 times, this means you want the list without its last 5 elements...

You could slice out a new list, keeping the old list as is:

mylist=['a','b','c','d','e','f','g','h','i']
newlist = mylist[2:-2]

newlist now returns:

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

You can overwrite the reference to the old list too:

mylist = mylist[2:-2]

Both of the above approaches will use more memory than the below.

What you're attempting to do yourself is memory friendly, with the downside that it mutates your old list, but popleft is not available for lists in Python, it's a method of the collections.deque object.

This works well in Python 3:

for x in range(2):
    mylist.pop(0)
    mylist.pop()

In Python 2, use xrange and pop only:

for _ in xrange(2):
    mylist.pop(0)
    mylist.pop()

Fastest way to delete as Martijn suggests, (this only deletes the list's reference to the items, not necessarily the items themselves):

del mylist[:2]
del mylist[-2:]

Do this instead:

eles = list[:2]
list = list[2:]

By the way you should not name a variable list, since it shadows the built-in function list.

Python lists were not made to operate on the beginning of the list and are very ineffective at this operation.

While you can write

mylist = [1, 2 ,3 ,4]
mylist.pop(0)

It's very inefficient.

If you only want to delete items from your list, you can do this with del:

del mylist[:n]

Which is also really fast:

In [34]: %%timeit
help=range(10000)
while help:
    del help[:1000]
   ....:
10000 loops, best of 3: 161 µs per loop

If you need to obtain elements from the beginning of the list, you should use collections.deque by Raymond Hettinger and its popleft() method.

from collections import deque

deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop()                          # return and remove the rightmost item
'j'
>>> d.popleft()                      # return and remove the leftmost item
'f'

A comparison:

list + pop(0)

In [30]: %%timeit
   ....: help=range(10000)
   ....: while help:
   ....:     help.pop(0)
   ....:
100 loops, best of 3: 17.9 ms per loop

deque + popleft()

In [33]: %%timeit
help=deque(range(10000))
while help:
    help.popleft()
   ....:
1000 loops, best of 3: 812 µs per loop

You want a list comprehension:

L = [c for c in L if c not in ['a', 'c']]

Or, if you really don't want to create a copy, go backwards:

for i in reversed(range(len(L))):
    if L[i] in ['a', 'c']:
        L.pop(i)    # del L[i] is more efficient

Thanks to ncoghlan for reversed() & phooji for del L[i] suggestions. (I decided to leave it as L.pop(i), since that's how the question was initially formulated.)

Also, as J.S. Sebastian correctly points out, going backwards is space efficient but time inefficient; most of the time a list comprehension or generator (L = (...) instead of L = [...]) is best.

Edit:

Ok, so since people seem to want something less ridiculously slow than the reversed method above (I can't imagine why... :) here's an order-preserving, in-place filter that should differ in speed from a list comprehension only by a constant. (This is akin to what I'd do if I wanted to filter a string in c.)

write_i = 0
for read_i in range(len(L)):
    L[write_i] = L[read_i]
    if L[read_i] not in ['a', 'c']:
         write_i += 1

del L[write_i:]
print L
# output: ['b', 'd']