PYTHON > les listes, tuples, tableaux et dictionnaires

LISTE

liste = ['a', 'b', 'c', 'd', 'e']

accéder à un élément

liste[2] -> c
liste[-1] # dernier élément -> e
liste[-2] # avant-dernier   -> d

 

liste[1:4] # Les éléments de 1 à 3    -> ['b', 'c', 'd']
liste[0:2] # Les éléments de 0 à 1    -> ['a', 'b']
liste[:3]  # les 3 premiers éléments  -> ['a', 'b', 'c']
liste[3:]  # Tout sauf les 3 premiers -> ['d', 'e']
liste[1:-1] # ['b', 'c', 'd']
liste[:2] + ['x', 'y'] # ['a', 'b', 'x', 'y']
3*liste[:3] + ['f']    # ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'f']

élément au hasard

from random import *
liste = [ "Pierre", "Feuille", "Ciseaux"]
résultat = choice(liste)

Ajouter un élément

liste.append('z') # à la fin

 

liste.insert(i, x)      # insère à la position i
liste.insert(0, x)      # insère l’élément au début de liste
liste.insert(len(a), x) # est équivalent à liste.append(x)

 

dix_zeros = [0]*10 # crée 10 zéros -> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
a = [1, 2, 3, 4, 5]
b = [0]*len(a) # autant de 0 que d'éléments dans a -> [0, 0, 0, 0, 0]

 

range(4) -> [0, 1, 2, 3]

 

range(3,40,7) -> [3, 10, 17, 24, 31, 38]

 

b=list(range(1,44,7)) # tous les nombres entre 1 et 44 inclus, par pas de 7
[1, 8, 15, 22, 29, 36, 43]

Si le dernier argument est omis, le pas vaut 1 par défaut.

d=list(range(44)) renvoie une liste comportant tous les nombres entiers compris entre 0 et 43 inclus.

 

soit un dernier item : append(), soit une autre liste avec la méthode extend().

a=[1,2]
a.append(3) -> [1,2,3]
a.extend([3,4]) -> [1,2,3,4], correspond à a+[3,4]
a=[1,2]*3 -> [1,2,1,2,1,2]

Concaténer deux listes

a = [1, 2, 3]
b = [2, 3, 4]
liste = a + b -> [1, 2, 3, 2, 3, 4]

Modifier un élément

a = [10, 20, 30, 40]
a[2] = a[2] + 23 -> [10, 20, 53, 40]
a[0:2] = [1, 12] # Remplacer certains éléments -> [1, 12, 30, 40]
a[0:2] = [] # enlever des éléments -> [123, 1234]
a[1:1] = ['a', 'b'] # insérer des éléments -> [123, 'a', 'b', 40]
a[:0] = a  # insère une copie de lui-même au début -> [123, 'a', 'b', 40, 123, 'a', 'b', 40]

Supprimer un élément

liste.pop(X)  # retirer l'élément n°X
liste.pop()   # retirer le dernier élément
del liste[-1] # retirer le dernier élément
del liste[0]  # retire le premier élément
del liste[2:4]    -> 

 

liste.remove(x) # retire le premier élément dont la valeur est x.
liste.remove('b') -> ['a', 'c', 'd', 'e']

vider toute la liste

liste.clear()
del liste[:]
liste[:]=[]

List slicing

liste[::len(liste)-1] -> ['a', 'e']
[liste[i] for i in (0, -1)] -> ['a', 'e']

NOMBRE D’ÉLÉMENTS

len(liste) -> 5

Mélanger une liste

from random import *
shuffle(liste)

Inverser les valeurs

[x for x in liste[::-1]] -> ['e', 'd', 'c', 'b', 'a']
liste.reverse() -> [4,3,2,1]

Connaître l’index

liste.index('c') -> 2
liste.index(x, start, end) start and end apermet de limiter la recherche to a particular subsequence of the list.
The returned index is computed relative to the beginning of the full sequence rather than the start argument.

Nombre d’occurrences

liste=['a', 'b', 'c', 'a', 'f', 'g', 'a', 'b', 'e']
liste.count('a') -> 3

 

3 in liste -> True
7 in liste -> False

Copier une liste

b=liste[:]
liste.copy() Renvoie une copie superficielle de la liste. Équivalent à a[:]
liste_2 = list(liste)

 

 

liste.sort(key=None, reverse=False) Trie les éléments sur place, (les arguments peuvent personaliser le tri, voir sorted() pour leur explication).

 

liste = ['a', 'b', 'c', 'a', 'b', 'c', 'a']
liste.index('a') -> 0
liste.index('a', 4)  # le a présent après le 4èmé rang -> 6
liste.reverse() -> ['a', 'c', 'b', 'a', 'c', 'b', 'a']

Utiliser les listes comme des piles

append() ajoute un élément sur la pile, pop() récupère l’élement sur la pile

pile = [3, 4, 5]
pile.append(6) -> [3, 4, 5, 6]
pile.append(7) -> [3, 4, 5, 6, 7]
pile.pop() -> 7
pile -> [3, 4, 5, 6]
pile.pop() -> 6
pile.pop() -> 5
pile -> [3, 4]

Compréhensions de liste

squares = []
for x in range(10):
    squares.append(x**2)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

 

ou plus court :

squares = [x**2 for x in range(10)]

 

Compréhension : entre crochets, une expression suivie par une clause for, puis par zéro ou plus clauses for ou if.

Exemple, cette compréhension de liste combine les éléments de deux listes s’ils ne sont pas égaux :

[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

 

équivaut à :

a = []
for x in [1,2,3]:
    for y in [3,1,4]:
        if x != y:
            a.append((x, y))
a -> [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

 

Si l’expression est un tuple (c’est à dire (x, y) dans cet exemple), elle doit être entourée par des parenthèses :

vec = [-4, -2, 0, 2, 4]
# create a new list with the values doubled
[x*2 for x in vec] -> [-8, -4, 0, 4, 8]
# filter the list to exclude negative numbers
[x for x in vec if x >= 0] -> [0, 2, 4]
# apply a function to all the elements
[abs(x) for x in vec] -> [4, 2, 0, 2, 4]
# call a method on each element
liste = ['  a', '  b ', 'c   ']
[L.strip() for L in liste] -> ['a', 'b', 'c']
>>> # create a list of 2-tuples like (number, square)
[(x, x**2) for x in range(6)] -> [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
# the tuple must be parenthesized, otherwise an error is raised

# flatten a list using a listcomp with two 'for'
vec = [[1,2,3], [4,5,6], [7,8,9]]
[N for elem in vec for N in elem] -> [1, 2, 3, 4, 5, 6, 7, 8, 9]

 

Les compréhensions de listes peuvent contenir des expressions complexes et des fonctions imbriquées :

from math import pi
[str(round(pi, i)) for i in range(1, 6)] -> ['3.1', '3.14', '3.142', '3.1416', '3.14159']

Compréhensions de listes imbriquées

La première expression dans une compréhension de liste peut être n’importe quelle expression, y compris une autre compréhension de liste. Exemple d’une matrice de 3×4, implémentée sous la forme de 3 listes de 4 éléments :

matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]

 

Cette compréhension de liste va transposer les lignes et les colonnes :

[[row[i] for row in matrix] for i in range(4)] -> [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

 

La compréhension de liste imbriquée est évaluée dans le contexte de l’instruction for qui la suit, donc cet exemple est équivalent à :

t = []
for i in range(4):
    t.append([row[i] for row in matrix])
t -> [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

équivalent à :

t = []
for i in range(4):
    # the following 3 lines implement the nested listcomp
    t_row = []
    for row in matrix:
        t.append(row[i])
    t.append(t_row)
t -> [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

 

Dans des cas concrets, il est toujours préférable d’utiliser des fonctions natives plutôt que des instructions de contrôle de flux complexes. La fonction zip() ferait dans ce cas un excellent travail :

list(zip(*matrix)) -> [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

 

créer une liste à partir d"une chaine de caractères

tab = chaine.split()

Append and Pop

If we wanted to remove items from our array, we could use the Python pop function. Python pop() works in the same way as append(), but it works as a remove method that deletes an item from an array. In addition, pop() takes an index number as an argument, rather than a string. Here is an example of pop() in action:

students = ['Alex', 'Bill', 'Catherine', 'Andy', 'Molly', 'Rose']
students.pop(0)
['Bill', 'Catherine', 'Andy', 'Molly', 'Rose']

Methods

append() Adds an item to an array

pop() Removes an item from an array

clear() Removes all items from an array

copy() Returns a copy of an array

count() Returns the number of elements in a list

index() Returns the index of the first element with a specific value

insert() Adds an element to the array at a specific position

reverse() Reverses the order of the array

sort() Sorts the list

 

 

 

LIENS

Merge List with common elements in a List of Lists

Sorting list of lists with similar list elements

Add list elements with a multi-list based on index

Replace elements in second list with index of same element in first list

Indices of sorted list of list elements

Maximum sum of elements of list in a list of lists

Index of Non-Zero elements in Python list

Get last N elements from given list

List frequency of elements

Adding two list elements

Remove last K elements of list

Absolute value of list elements

Check if all elements in a List are same

Merge list elements

Bitwise OR among List elements

TUPLES

Un tuple consiste en différentes valeurs séparées par des virgules :

t = (12345, 54321, 'hello!')
t[0] -> 12345
t -> (12345, 54321, 'hello!')
# Tuples may be nested:
u = t, (1, 2, 3, 4, 5)
u -> ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
# Tuples are immutable:
t[0] = 88888 -> provoque une erreur

 

 

x, y, z = t

Un déballage de séquence et fonctionne pour toute séquence placée à droite de l’expression. Ce déballage requiert autant de variables dans la partie gauche qu’il y a d’éléments dans la séquence.

LES ENSEMBLES

Les ensembles suppriment les doublons. Ils supportent également les opérations mathématiques comme les unions, intersections, différences et différences symétriques. Des accolades, ou la fonction set() peuvent être utilisés pour créer des ensembles. Notez que pour créer un ensemble vide, {} ne fonctionne pas, cela créé un dictionnaire vide. Utilisez plutôt set().

Voici une brève démonstration :

 

basket = {'a', 'o', 'a', 'p', 'o', 'b'}
print(basket) # les doublons ont disparus -> {'o', 'b', 'p', 'a'}
'o' in basket -> True
'c' in basket -> False

# Demonstrate set operations on unique letters from two words
a = set('abracadabra')
b = set('alacazam')
a  # unique letters in a -> {'a', 'r', 'b', 'c', 'd'}
a - b  # letters in a but not in b -> {'r', 'd', 'b'}
a | b  # letters in either a or b -> {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
a & b  # letters in both a and b -> {'a', 'c'}
a ^ b  # letters in a or b but not both -> {'r', 'd', 'b', 'm', 'z', 'l'}

 

Tout comme les comprehensions de listes, il est possibled’écrire des comprehensions d’ensembles :

 

a = {x for x in 'abracadabra' if x not in 'abc'}
a -> {'r', 'd'}

LES DICTIONNAIRES

Tels des tableaux associatifs, indexés par des clés (str ou int) uniques. Des tuples peuvent être utilisés comme clés s’ils ne contiennent que des chaînes, des nombres ou des tuples ; si un tuple contient un objet mutable, de façon directe ou indirecte, il ne peut pas être utilisé comme une clé. Vous ne pouvez pas utiliser des listes comme clés, car les listes peuvent être modifiées en place en utilisant des affectations par position, par tranches ou via des méthodes comme append() ou extend().

Céer un dictionnaire vide : {}

Les principales opérations effectuées sur un dictionnaire consistent à stocker une valeur pour une clé et à extraire la valeur correspondant à une clé. Il est également possible de supprimer une paire clé:valeur avec del. Si vous stockez une valeur pour une clé qui est déjà utilisée, l’ancienne valeur associée à cette clé est perdue. Si vous tentez d’extraire une valeur associée à une clé qui n’existe pas, une exception est levée.

Exécuter list(d.keys()) sur un dictionnaire d retourne une liste de toutes lesclés utilisées dans le dictionnaire, dans un ordre arbitraire (si vous voulez qu’elles soient triées, utilisez sorted(d.keys())). Pour tester si une clé est dans le dictionnaire, utilisez le mot-clé in.

Voici un petit exemple utilisant un dictionnaire :

 

d = {'un': 1, 'deux': 2}
d['cinq'] = 5
d -> {'un': 1, 'deux': 2, 'cinq': 5}
d['deux'] -> 2
del d['cinq']
d['trois'] = 3
d -> {'un': 1, 'deux': 2, 'trois': 3}
list(d.keys()) -> ['un', 'deux', 'trois']
sorted(d.keys()) -> ['deux', 'trois', 'un']
'un' in d -> True
'trois' not in d -> False

 

Le constructeur dict() fabrique un dictionnaire directement à partir d’une liste de paires clé-valeur stockées sous la forme de tuples :

dict([('un', 1), ('deux', 2), ('trois', 3)]) -> {'un': 1, 'deux': 2, 'trois': 3}

 

De plus, il est possible de créer des dictionnaires par compréhension depuis un jeu de clef et valeurs :

{x: x**2 for x in (2, 4, 6)} -> {2: 4, 4: 16, 6: 36}

Lorsque les clés sont de simples chaînes de caractères, il est parfois plus facile de spécifier les paires en utilisant des paramètres nommés :

dict(sape=4139, guido=4127, jack=4098) -> {'sape': 4139, 'jack': 4098, 'guido': 4127}

Techniques de boucles

Lors d’une boucle sur un dictionnaire, les clés et leurs valeurs peuvent être récupérées grâce à la méthode items()

a = {'un': '1', 'deux': '2'}
for k, v in a.items():
    print(k, v)
un 1
deux 2

 

Lors d’une itération sur une séquence, la position et la valeur correspondante peuvent être récupérées grâce à la fonction enumerate().

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)
0 tic
1 tac
2 toe

 

Pour faire des boucles sur deux séquences ou plus en même temps, les éléments peuvent être associés par la fonction zip()

q = ['un', 'deux', 'trois']
r = ['1', '2', '3']
for q, a in zip(q, r):
    print('{0} vaut {1}.'.format(q, a))
un vaut 1
deux vaut 2
trois vaut 3

 

Pour faire une boucle sur une séquence inversée, créer la séquence dans son ordre normal, puis appliquer la fonction reversed()

for i in reversed(range(1, 10, 2)):
    print(i)
9
7
5
3
1

 

Pour faire une boucle sur une séquence triée, utilisez la fonction sorted(), qui renvoie une nouvelle liste triée sans altérer la source :

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
    print(f)
apple
banana
orange
pear

 

Au lieu de changer une liste pendant son itération, il est souvent plus simple et plus sûr de créer une nouvelle liste à la place.

import math
raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
filtered_data = []
for value in raw_data:
    if not math.isnan(value):
        filtered_data.append(value)
filtered_data -> [56.2, 51.7, 55.3, 52.5, 47.8]

Informations sur les conditions

in et not in testent si une valeur est présente ou non dans une séquence.

is et is not testent si deux objets sont vraiment le même objet (important que pour des objets mutables comme des listes).

Les comparaison peuvent être enchaînées :

a < b == c teste si a est inférieur ou égal à b et par ailleurs si b est égal à c.

and et or pouvant être inversé avec not.

A and not B or C est équivalent à (A and (not B)) or C

string1, string2, string3 = '', 'a', 'b'
non_null = string1 or string2 or string3
non_null -> 'a'

Comparer des séquences avec d’autres types

La comparaison utilise un ordre lexicographique : les deux premiers éléments de chaque séquence sont comparés, et s’ils diffèrent cela détermine le résultat de la comparaison ; s’ils sont égaux, les deux éléments suivants sont comparés à leur tour, et ainsi de suite jusqu’à ce que l’une des séquences soit épuisée. Si deux éléments à comparer sont eux-mêmes des séquences du même type, alors la comparaison lexicographique est effectuée récursivement. Si tous les éléments des deux séquences sont égaux, les deux séquences sont alors considérées comme égales. Si une séquence est une sous-séquence de l’autre, la séquence la plus courte est celle dont la valeur est inférieure. La comparaison lexicographique des chaînes de caractères utilise le code Unicode des caractères. Voici quelques exemples de comparaisons entre séquences de même type :

(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

Comparer des objets de type différents avec < ou > est autorisé si les objets ont des méthodes de comparaison appropriées. Par exemple, les types numériques sont comparées via leur valeur numérique, donc 0 est égal à 0,0, etc. Dans les autres cas, au lieu de donner un ordre imprévisible, l’interpréteur lancera une exception TypeError.

 

D’autres langages pourraient renvoie l’objet modifié, qui permet de chaîner les méthodes, tel que : d->insert("a")->remove("b")->sort();.

Appeler d.keys() renvoie un objet dictionary view, qui gère les opérations du type test d’appartenance (in) et l’itération. Mais son contenu n’est pas indépendant du dictionnaire d’origine, c’est une simple vue.