
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 the contents of the iterable t  
del s[i:j] 
same as s[i:j] = [] 

s[i:j:k] = t 
the elements of s[i:j:k] are replaced by those of t 
(1) 
del s[i:j:k] 
removes the elements of s[i:j:k] from the list 

s.append(x) 
same as s[len(s):len(s)] = [x] 
(2) 
s.extend(x) 
same as s[len(s):len(s)] = x 
(3) 
s.count(x) 
return number of i's for which s[i] == x 

s.index(x[, i[, j]]) 
return smallest k such that s[k] == x and
i <= k < j 
(4) 
s.insert(i, x) 
same as s[i:i] = [x] 
(5) 
s.pop([i]) 
same as x = s[i]; del s[i]; return x 
(6) 
s.remove(x) 
same as del s[s.index(x)] 
(4) 
s.reverse() 
reverses the items of s in place  (7) 
s.sort([cmp[,
key[, reverse]]]) 
sort the items of s in place  (7), (8), (9), (10) 
1
,
so that by default the last item is removed and returned.
cmp specifies a custom comparison function of two arguments (list items) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument: "cmp=lambda x,y: cmp(x.lower(), y.lower())"
key specifies a function of one argument that is used to extract a comparison key from each list element: "key=str.lower"
reverse is a boolean value. If set to True
, then the
list elements are sorted as if each comparison were reversed.
In general, the key and reverse conversion processes are much faster than specifying an equivalent cmp function. This is because cmp is called multiple times for each list element while key and reverse touch each element only once.
Changed in version 2.3:
Support for None
as an equivalent to omitting
cmp was added.
Changed in version 2.4: Support for key and reverse was added.
See About this document... for information on suggesting changes.