class: center, middle # Listes, Tuples & Sets --- # Listes Une liste est une structure pour stocker des chiffres, des nombres, des caractères, des chaînes de caractères, ... sous la forme de tableaux. ```python >>> alphabet=['A','B','C','D','E','F','G','H','I','J'] >>> alphabet ['A','B','C','D','E','F','G','H','I','J'] ``` Les éléments de la liste sont accessibles par des indices. 'A' est à l'indice 0, 'B' est à l'indice 1, ..., 'J' est à l'indice 9. ```python >>> alphabet[5] 'F' # et non pas 'E' >>> alphabet[-1] 'J' # dernier élément ``` * Récupération de l'indice ```python >>> lettres = ['a','b','c'] >>> lettres.index('b') 1 ``` --- # Listes * Accès à plusieurs éléments de la liste ```python >>> alphabet[0:3] ['A', 'B', 'C'] # on obtient une sous liste, attention au dernier indice ``` * Nombre d'éléments dans une liste ```python >>> sequence=['a', 'b', 'c', 'd', 'e', 'f'] >>> len(sequence) 6 ``` * Nombre d'occurences ```python >>> lettres=['a','b','c','b','b','a'] >>> lettres.count('b') 3 >>> lettres.count('a') 2 ``` --- # Listes * Insérer un élément à une position donnée ```python >>> seq = ['seq2','seq3'] >>> seq.insert(0,'seq1') >>> seq ['seq1', 'seq2', 'seq3'] ``` * Ajouter un élément en fin de liste ```python >>> seq.append('seq4') >>> seq ['seq1', 'seq2', 'seq3', 'seq4'] ``` --- # Listes * Retrait d'un élément à une position donnée ```python >>> seq = ['seq1','seq2','seq3'] >>> seq.pop(0) # retrait à la position 0 'seq1' >>> seq # pop modifie la liste ['seq2', 'seq3'] ``` * Suppression d'un élément donné ```python >>> seq.remove('seq3') >>> seq ['seq1', 'seq2'] ``` --- # Listes * Concaténer deux listes ```python >>> seq = ['seq1'] + ['seq2'] >>> seq ['seq1', 'seq2'] ```
Remarque :
l'opérateur `+=` est un raccourci pour concaténer deux listes. ```python >>> seq += ['seq3'] >>> seq ['seq1', 'seq2', 'seq3'] ``` * Transformer une chaîne de caractère en liste grâce à un séparateur ```python >>> sequence = 'a*b*c*d*e*f' >>> sequence.split('*') ['a', 'b', 'c', 'd', 'e', 'f'] ``` --- # Listes * Passer d'une liste à une chaîne de caractères ```python >>> list_seq = ['A', 'T', 'G', 'C'] >>> list-seq ['A', 'T', 'G', 'C'] >>> seq = "".join(list_seq) >>> seq 'ATGC' >>> seq = "-".join(list_seq) >>> seq 'A-T-G-C' ``` * Duplication d'une liste ```python >>> seq = ['seq1','seq2'] >>> seq*2 >>> seq ['seq1','seq2','seq1','seq2'] ``` --- # Listes * Inverser une liste ```python >>> seq = ['a','b','c'] >>> seq.reverse() ['c','b','a'] ``` * Trier dans l'ordre ASCII ```python >>> seq = ['c','b','a'] >>> seq.sort() # sort() ne renvoie rien, trie la liste "sur place" >>> seq ['a','b','c'] >>> seq = ['c','b','a'] >>> seq2 = sorted(seq) # pour ne pas modifier la liste il faut utiliser sorted() >>> seq2 ['a','b','c'] >>> seq ['c','b','a'] ``` --- # Tuples * Un `tuple` est une liste
non modifiable
. * Il n'existe donc pas de méthodes pour ajouter/enlever des éléments dans un tuple. * L'accès aux valeurs par l'indice ainsi que l'interrogation du tuple est possible. * Exemple ```python >>> t = (1,2,3) >>> t (1, 2, 3) >>> t[1] # accès aux valeurs 2 >>> 2 in t # interroger le tuple True ``` --- # Sets Un `set` est
modifiable
,
non ordonné
,
non indexable
et ne contient qu'
une seule copie maximum d'un élément
. ```python >>> s = {1, 2, 3, 4, 5, 6, 1, 2} >>> s {1, 2, 3, 4, 5, 6} >>> type(s)
``` ```python >>> s[1] Traceback (most recent call last): File "
", line 1, in
TypeError: 'set' object is not subscriptable ``` ```python >>> s[0] = 9 Traceback (most recent call last): File "
", line 1, in
TypeError: 'set' object does not support item assignment ```
Remarque :
impossible car les sets sont non ordonnés et non indexables. --- # Sets : opérations Les sets supportent les opérations d'ensembles. En voici quelques exemples : * Union ```python >>> s1 = {1, 2, 3} >>> s2 = {3, 4, 5} >>> s1 | s2 {1, 2, 3, 4, 5} ``` * Intersection ```python >>> s1 & s2 {3} ``` * Différence ```python >>> s1 - s2 {1, 2} ``` * Différence symétrique ```python >>> s1 ^ s2 {1, 2, 4, 5} ``` --- # Sets : itération Les sets sont itérables : on peut les parcourir avec une boucle `for`. ```python >>> s = {1, 2, 3, 4, 5, 6} >>> for elt in s: ... print(elt) ... 1 2 3 4 5 6 ``` --- # Sets : modifications Les méthodes `add` et `discard` permettent d'ajouter ou supprimer des valeurs d'un `set`. ```python >>> s {1, 2, 3, 4, 5, 6} >>> s.add(9) >>> s {1, 2, 3, 4, 5, 6, 9} >>> s.discard(1) >>> s {2, 3, 4, 5, 6, 9} ``` L'opérateur `|=` permet d'ajouter des éléments d'un autre `set` à un `set`. ```python >>> s1 = {1, 2, 3} >>> s2 = {3, 4, 5} >>> s1 |= s2 >>> s1 {1, 2, 3, 4, 5} ``` --- # Tuples, Listes ou Sets ? * Les `tuples` sont plus rapides que les `listes`. * Si vous souhaitez parcourir un ensemble fixe de données, utilisez un `tuple`. * Utile aussi pour protéger votre code en écriture. Source :
https://python.developpez.com/cours/DiveIntoPython/php/frdiveintopython/native_data_types/tuples.php
* Les `sets` sont très utiles pour rechercher des éléments uniques dans une suite d'éléments (élimination des doublons). --- # Travaux Pratiques Créer un programme Python nommé « `liste.py` » ou un notebook Jupyter nommé « `liste.ipynb` » permettant de manipuler une liste générée à partir de la chaîne de caractères
atg ccc AAA AAC Cat GGa Taa
et d'afficher les informations suivantes en *25 minutes d'autonomie* : * la
séquence
en
lettres majuscules
uniquement, * la
longueur
de la séquence, * le
premier codon
, * le
dernier codon
.