Séquences en général

En python, une séquence est : une string (chaîne), une list (liste) ou un tuple.

in, not in : opérateurs de condition pour savoir si une valeur est présente dans une séquence.

s = 'ACGANGAC'; 'N' in s : renvoie True
l = [1, 2, 4]; 3 in l : renvoie False

is, is not : pour savoir si 2 objets mutables (liste) sont réellement les mêmes.

Conversion des séquences :

list('abc') : convertit une chaîne en liste, ici ['a', 'b', 'c'].
tuple('abc') : convertit une chaîne en tuple, ici ('a', 'b', 'c').
list(('a', 'b', 'c')) : convertit un tuple en liste, ici ['a', 'b', 'c'].
tuple(['a', 'b', 'c']) : convertit une liste en tuple, ici ('a', 'b', 'c').

affectation : on peut faire les choses suivantes, du moment que les séquences ont le même nombre d'éléments :

(x, y, z) = (1, 2, 3)
[x, y, z] = [1, 2, 3]
mais aussi (x, y, z) = [1, 2, 3] et [x, y, z] = (1, 2, 3)
et même : (x, y, z) = 'abc' ou [x, y, z] = 'abc'

On peut convertir une liste de tuples en dictionnaire :
dict([('a', 2), ('b', 3)]) donne {'a': 2, 'b': 3}.

Fonctions sur les séquences :

filter(myFunc, mySeq) : renvoie les éléments x de la sequence mySeq pour lesquels myFunc(x) est vraie. Le type renvoyé est le même que mySeq
map(myFunc, mySeq) : renvoie la liste myFunc(x) ou x est element de mySeq
map(myFunc, l1, l2) : renvoie la liste des myFunc(x1, x2) ou x1 est dans l1 et x2 est dans l2 pour chaque position (valeur passée à la fin est None si une des listes est plus petite).
zip(['a', 'b', 'c'], ['A', 'B', 'C']) : renvoie une liste de tuples, avec un tuple pour les premiers éléments, puis un tuple pour les seconds ... Ici, [('a', 'A'), ('b', 'B'), ('c', 'C')]. Ca marche aussi avec plus que 2 listes.
si les 2 listes n'ont pas le même nombre d'éléments, zip s'arrête au dernier élément de la liste la plus courte (éléments suivants de la liste la plus longue sont ignorés).
quand on veut boucler sur 2 itérateurs en même temps, même si ce sont des générateurs, on peut faire for x, y in zip(myIterator1, myIterator2): ... (utile pour lire 2 fichiers en même temps dont les éléments se correspondent).
reduce(myFunc, l) : appelle myFunc sur les 2 premiers éléments de l, puis sur le résultat et le 3eme, etc ... et renvoie le dernier résultat.
map et filter fonctionnent aussi sur les sets.

Application : faire à partir d'un dictionnaire de liste, une liste de dictionnaires ayant les mêmes clefs et toutes les combinaisons de valeurs possibles (produit cartésien) :

d = {'a': [4, 6], 'b': [7, 8, 9]}
keys, values = zip(*d.items())
dictList = [dict(zip(keys, v)) for v in itertools.product(*values)]

ça donne : [{'a': 4, 'b': 7}, {'a': 4, 'b': 8}, {'a': 4, 'b': 9}, {'a': 6, 'b': 7}, {'a': 6, 'b': 8}, {'a': 6, 'b': 9}]

On peut utiliser map sur plusieurs séquences avec une fonction qui prend plusieurs arguments :

map(lambda x,y: x + y, ['a', 'b', 'c', 'd'], ['1', '2', '3', '4']) : renvoie ['a1', 'b2', 'c3', 'd4'].
on peut même faire : map(lambda x,y: x + y, ['a', 'b', 'c', 'd'], '1234') qui renvoie aussi ['a1', 'b2', 'c3', 'd4'].

enumerate pour boucler sur les éléments d'une séquences et avoir les index en même temps :

renvoie un itérateur qui renvoie des tuples (numéro d'index, élément).
enumerate(['a', 'b', 'c']) : renvoie un itérateur qui va renvoyer les couples suivants : (0, 'a'), (1, 'b'), (2, 'c').

exemple d'utilisation :

for (ind, elt) in enumerate(['a', 'b', 'c']):
    print(ind, elt)

list(enumerate(['a', 'b', 'c'])) donne [(0, 'a'), (1, 'b'), (2, 'c')].
on peut utiliser enumerate sur n'importe quelle séquence : list(enumerate('abc')) donne aussi [(0, 'a'), (1, 'b'), (2, 'c')].
on peut changer l'index de départ : list(enumerate(['a', 'b', 'c'], start = 1)) (ou simplement list(enumerate(['a', 'b', 'c'], 1))) donne [(1, 'a'), (2, 'b'), (3, 'c')].

min, max : on peut choisir l'ordre à appliquer : max(myList, key = lambda x: ...)

programmer en python, tutoriel python, graphes en python, Aymeric Duclert