List objects support additional operations that allow in-place modification of the object. These operations would be supported by other mutable sequence types (when added to the language) as well. Strings and tuples are immutable sequence types and such objects cannot be modified once created. The following operations are defined on mutable sequence types (where x is an arbitrary object):
| Operation | Result | Notes | 
|---|---|---|
s[i] = x | 
        item i of s is replaced by x | |
s[i:j] = t | 
        slice of s from i to j is replaced by t | |
del s[i:j] | 
        same as s[i:j] = [] | 
        |
s.append(x) | 
        same as s[len(s):len(s)] = [x] | 
        (1) | 
s.extend(x) | 
        same as s[len(s):len(s)] = x | 
        (2) | 
s.count(x) | 
        return number of i's for which s[i] == x | 
        |
s.index(x) | 
        return smallest i such that s[i] == x | 
        (3) | 
s.insert(i, x) | 
        same as s[i:i] = [x]
	  if i >= 0 | 
        |
s.pop([i]) | 
        same as x = s[i]; del s[i]; return x | 
        (4) | 
s.remove(x) | 
        same as del s[s.index(x)] | 
        (3) | 
s.reverse() | 
        reverses the items of s in place | (5) | 
s.sort([cmpfunc]) | 
        sort the items of s in place | (5), (6) | 
-1,
  so that by default the last item is removed and returned.
-1, 0 or 1 depending on whether
  the first argument is considered smaller than, equal to, or larger
  than the second argument.  Note that this slows the sorting process
  down considerably; e.g. to sort a list in reverse order it is much
  faster to use calls to the methods sort() and
  reverse() than to use the built-in function
  sort() with a comparison function that reverses the
  ordering of the elements.