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.
- attention : 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: ...)
