Les listes sont des objets qui possèdent quelques méthodes très pratiques pour les manipuler:
l.append(x) : ajoute l'occurence x en fin de liste.
l.extend(x) : ajoute chaque élement de la séquence x en fin de liste.
l.count(x) : renvoie le nombre d'occurences x de la liste.
l.index(x[, i[, j]]) : retourne le plus petit k tel que s[k] = x et i<=k<=j. retourne une erreur si l'élément n'est pas présent dans la liste. Si i et j sont omis, l'ensemble de la liste est considéré.
l.insert(i, x) : insère l'occurence x à la position i.
l.pop([i]) : retourne l'élément de la position i et le supprime de la liste. Si i est omis, le dernier élément de la liste est retourné et supprimé
l.remove(x) : supprime la première occurence de x de la liste. retourne une erreur si cette valeur n'est pas présente.
l.reverse() : renverse la liste sur place.
l.sort([cmp[, key[, reverse]]]) : trie les éléments de la liste sur place. Vous pouvez définir votre propre fonction de comparaison en définissant le paramètre cmp. Le booléan reverse permet de retourner ou non la liste triée dans l'ordre croissant ou décroissant. Si ces paramètres sont omis, la liste est triée dans l'ordre alphanumérique croissant.

>>> a = [5, 0, 3, 9, 4, 3, 7]
>>> a.append(15) ## a = [5, 0, 3, 9, 4, 3, 7, 15]
>>> a.extend((45, 12, 35)) ## a = [5, 0, 3, 9, 4, 3, 7, 15, 45, 12, 35]
>>> a.extend('abcdef') ## a = [5, 0, 3, 9, 4, 3, 7 ,15, 45, 12 ,35, 'a', 'b', 'c', 'd', 'e', 'f']
>>> a.count(3)
2
>>> a.index(3)
2
>>> a.insert(8, 6) ## a = [5, 0, 3, 9, 4, 3, 7 ,15, 6, 45, 12 ,35, 'a', 'b', 'c', 'd', 'e', 'f']
>>> a.pop() ## a = [5, 0, 3, 9, 4, 3, 7 ,15, 6, 45, 12 ,35, 'a', 'b', 'c', 'd', 'e']
'f'
>>> a.remove(3) ## a = [5, 0, 9, 4, 3, 7 ,15, 6, 45, 12 ,35, 'a', 'b', 'c', 'd', 'e']
>>> a.reverse() ## a = ['e', 'd', 'c', 'b', 'a', 35, 12, 6, 45, 7, 3, 4, 9, 0, 5]
>>> a.sort() ## a = [0, 3, 4, 5, 6, 7, 9, 12, 35, 45, 'a', 'b', 'c', 'd', 'e']

Vous avez plusieurs manières de supprimer une occurence dans une liste
La première façon est d'utiliser la méthode l.remove(x) qui supprime la première occurence x dans la liste l et qui retourne une erreur si l'occurence x n'existe pas dans l.

l = [1,5,4,1,23,1,2,1]
try:
    while True: l.remove(1)
except: pass
print l  ## [5,4,23,2]

Si vous voulez supprimer toutes les occurences d'une valeur dans une liste, ne passer pas par la méthode remove qui est lente mais reconstruisez plutôt entièrement votre liste en omettant les éléments qui ne vous intéressent plus. Cela se fait très facilement avec une liste en intension.

l = 5 * range(4)  ##  [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
l = [x for x in l if x!=0]
print l  ##  [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

Pour ne conserver qu'une seule occurence pour chaque élement de la liste, utilisez le type set qui représente les objets ensembles et qui conserve donc une unique occurence de chaque élément d'une séquence.

l = [1,5,4,1,23,1,2,1]
s = set(l)
l = list(s)
print l ## [1,2,4,5,23]

Si votre liste ne contient que des string, il suffira d'utiliser la méthode ''.join(l) où l représente une séquence.
Si votre liste contient autre chose que des string, vous pouvez utilisez toujours cette méthode join tout en traitant chaque élément de la séquence
exemple:

l1 = ['toto',' ','part',' ','en',' ','voyage']
strl1 = ''.join(l1)
l2 = [116, 111, 116, 111, 32, 112, 97, 114, 116, 32, 101, 110, 32, 118, 111, 121, 97,
 103, 101]
str2 = ''.join(chr(i) for i in l2)

Le module random propose la fonction random.shuffle( x[, random]) qui permet de mélanger une séquence en place.

>>> import random
>>> l = range(100)
>>> random.shuffle(l)

Niveau algorithmique, voici une méthode pour mélanger une liste d'une complexité linéaire (par rapport au nombre d'éléments de la liste). On va simplement parcourir tous les élements de la liste et à chaque fois en choisir un autre au hasard et faire l'échange des 2 éléments. Cette méthode sera de toute façon beaucoup plus longue que l'utilisation de la fonction précédente.

import random
l = range(1000)
count = len(l)
randint = random.randint
for i in range(count):
    j = randint(0,count-1) ## Selection au hasard de l'index d'un element de la liste
    ## Echange des 2 elements
    l[i], l[j] = l[j], l[i]

L'objet list ne possède pas de méthode pour vider complètement ses éléments.
Si vous affecter la liste vide à votre liste ( mylist = [] ), vous créer en faite un nouvel objet, ce qui peut poser problème si d'autres références pointent sur ce même objet et que cette particularité est importante dans votre programme. La méthode la plus simple si vous souhaitez toujour travailler sur la même liste est d'utiliser directement la fonction comme suit:

del(mylist[:])

une autre méthode beaucoup moins rapide est d'utiliser la méthode pop dans une boucle while

while mylist: mylist.pop()

Supposons que nous voulions créer un tableau d'entiers de 5 cases par 5. La méthode intuitive serait la suivante:

>>> l = 5 * [5*[0]]
>>> l[0][0] = 1
>>> print l
[[1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0]]

Cependant en tenant de modifier un élément de la liste, on s'aperçoit que l'affectation s'est faite à plusieurs endroits. Ceci vient simplement du fait que lors de la création de notre liste de listes, la sous-liste 5*[0] n'a en fait été créée qu'une seule fois et que chaque sous-liste l[i] (0<=i<=4) pointe ainsi sur la même zone mémoire.
Pour créer une liste de listes (contenant des éléments initialisés), il vous faudra donc passer par 2 étapes:

>>> l = 5*[0]  ## peu importe ce que l'on met dans cette liste
>>> for i in range(len(l)):	l[i] = 5*[0]

>>> l[0][0]=1
>>> print l
[[1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]

Il est à noter que cette méthode ne fonctionne qu'avec des types ou objets immuables (nombres ou chaînes de caractères) mais pas avec des objets.