Cours 3 - Travailler avec des listes et des fonctions

Traitement de l’information

Informatique = traitement de l’information
L’information prend souvent la forme de listes

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
  ['FLE', 'Clémence Flémal'],
]

les traitements que l’on peut faire sur des listes tombent souvent dans l’une de ces 4 catégories:
- transformation,
- filtrage,
- accumulation,
- tri.

Transformation

Mapping en anglais
Il s’agit d’appliquer le même traitement à tous les éléments d’une liste
On obtient la liste des résultats
Exemple

# Transforme une liste de profs
profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

# En une liste de trigrammes
trigrams = [
  'LUR'
  'LRG',
  'FKY',
]

Mapping: diagramme

Mapping des profs en trigrammes:

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

map_to_trigrams function

profs

<r1>

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

map_to_trigrams function

profs

<r1>

results

<r5>

[]

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

map_to_trigrams function

profs

<r1>

results

<r5>

prof

<r2>

<r5>

[]

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

map_to_trigrams function

profs

<r1>

results

<r5>

prof

<r2>

<r5>

'LUR'

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

map_to_trigrams function

profs

<r1>

results

<r5>

prof

<r3>

<r5>

'LUR'

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

map_to_trigrams function

profs

<r1>

results

<r5>

prof

<r3>

<r5>

'LUR'

'LRG'

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

map_to_trigrams function

profs

<r1>

results

<r5>

prof

<r4>

<r5>

'LUR'

'LRG'

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

map_to_trigrams function

profs

<r1>

results

<r5>

prof

<r4>

<r5>

'LUR'

'LRG'

'FKY'

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

map_to_trigrams function

profs

<r1>

results

<r5>

prof

<r4>

<return>

<r5>

'LUR'

'LRG'

'FKY'

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

<r5>

'LUR'

'LRG'

'FKY'

trigrams

<r5>

Mapping: code

def map_to_trigrams(profs):
  results = []
  for prof in profs:
    results.append(prof[0])
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

trigrams = map_to_trigrams(profs)
print(trigrams)

RAM

map_to_trigrams

<function>

profs

<r1>

<r2>

<r3>

<r4>

<r2>

'LUR'

'Quentin Lurkin'

<r3>

'LRG'

'André Lorge'

<r4>

'FKY'

'Martin Fockedey'

<r5>

'LUR'

'LRG'

'FKY'

trigrams

<r5>

['LUR', 'LRG', 'FKY']

Transformation structure

Un mapping suit toujours la même structure:
- création de la nouvelle liste initialement vide
- parcours des éléments de la liste d’entrée
- ajout des résultats à la fin de la nouvelle liste
Autre exemple:

# Transforme une liste de profs

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

# En une liste de descriptions
# prêtes à être affichées
trigrams = [
  'Quentin Lurkin (LUR)'
  'André Lorge (LRG)',
  'Martin Fockedey (FKY)',
]

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

[]

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

[]

prof

'LUR'

'Quentin Lurkin'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

[]

prof

'LUR'

'Quentin Lurkin'

desc

'Quentin Lurkin (LUR)'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

'Quentin Lurkin (LUR)'

prof

'LUR'

'Quentin Lurkin'

desc

'Quentin Lurkin (LUR)'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

'Quentin Lurkin (LUR)'

prof

'LRG'

'André Lorge'

desc

'Quentin Lurkin (LUR)'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

'Quentin Lurkin (LUR)'

prof

'LRG'

'André Lorge'

desc

'André Lorge (LRG)'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

'Quentin Lurkin (LUR)'

'André Lorge (LRG)'

prof

'LRG'

'André Lorge'

desc

'André Lorge (LRG)'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

'Quentin Lurkin (LUR)'

'André Lorge (LRG)'

prof

'FKY'

'Martin Fockedey'

desc

'André Lorge (LRG)'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

'Quentin Lurkin (LUR)'

'André Lorge (LRG)'

prof

'FKY'

'Martin Fockedey'

desc

'Martin Fockedey (FKY)'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

'Quentin Lurkin (LUR)'

'André Lorge (LRG)'

'Martin Fockedey (FKY)'

prof

'FKY'

'Martin Fockedey'

desc

'Martin Fockedey (FKY)'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

map_to_trigrams function

profs

<ref global profs>

results

'Quentin Lurkin (LUR)'

'André Lorge (LRG)'

'Martin Fockedey (FKY)'

prof

'FKY'

'Martin Fockedey'

desc

'Martin Fockedey (FKY)'

<return>

<ref results>

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

desc

'Quentin Lurkin (LUR)'

'André Lorge (LRG)'

'Martin Fockedey (FKY)'

Mapping: code

def map_to_desc(profs):
  results = []
  for prof in profs:
    desc = f"{prof[1]} ({prof[0]})"
    results.append(desc)
  return results

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
]

desc = map_to_trigrams(profs)
print(desc)

Toutes les références ne sont pas représentées

RAM

map_to_desc

<function>

profs

[...]

desc

'Quentin Lurkin (LUR)'

'André Lorge (LRG)'

'Martin Fockedey (FKY)'

['Quentin Lurkin (LUR)', 'André Lorge (LRG)', 'Martin Fockedey (FKY)']

Mapping

Ces deux derniers exemples ont la même structure
Seul le contenu de la boucle est différent
Ce sont des mappings
Il est possible de créer une fonction qui ne contient que la structure d’un mapping.
Il nous faudra juste un moyen de passer le traitement à réaliser.

Les fonctions sont des valeurs

Une fonction peut être assignée à une variable

from math import cos, pi

a = cos # Pas de parenthèse! On n'appelle pas la fonction.
        # On l'assigne à la variable `a`

a(pi/2) # `a` fait référence à la fonction `cos`. Si on
        # appelle `a`, on appelle `cos`

Les fonctions sont des valeurs

On peut passer une fonction en paramètre à une autre fonction

# la structure d'un mapping. `processing` est la fonction
# qui sera appliquée aux éléments de `L`
def map(processing, L):
  results = []
  for elem in L:
    results.append(processing(elem))
  return results

# transforme 1 prof
def describe(prof):
  return f"{prof[1]} ({prof[0]})"

# on transforme tous les profs
descriptions = map(describe, profs)

def get_trigram(prof):
  return prof[0]

trigrams = map(get_trigram, profs)

La fonction `map`

La fonction map existe déjà en Python Pas besoin de la créer

Le filtrage

Il s’agit de créer une nouvelle liste ne contenant que les éléments de la liste d’entrée respectant une certaine condition.
Exemple:

# A partir de cette liste
numbers = [42, 165, 69, 18, 24]

# On veut obtenir celle-ci qui ne contient que les nombre pairs
even = [42, 18, 24]

# Ou ne garder que les nombres plus grands que 60
big = [165, 69]

La fonction `filter`

La structure d’un filtrage est toujours la même
Il est possible de créer une fonction qui ne contient que la structure du filtrage.
On passera la condition sous forme d’une fonction booléenne renvoyant True pour les valeurs à garder.

Code `filter`

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_even(x):
  return x % 2 == 0

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

even = filter(is_even, L)
big = filter(is_big, L)

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

[]

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

[]

item

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

[]

item

function condition

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

[]

item

function condition

<return>

False

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

[]

item

<tmp>

False

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

[]

item

165

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

[]

item

165

function condition

165

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

[]

item

165

function condition

165

<return>

True

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

[]

item

165

<tmp>

True

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

165

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

function condition

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

function condition

<return>

True

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

<tmp>

True

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

function condition

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

function condition

<return>

False

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

<tmp>

False

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

function condition

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

function condition

<return>

False

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

<tmp>

False

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

function filter

condition

<function2>

<numbers>

res

165

item

<return>

<res>

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

big

165

Filter: code

def filter(condition, L):
  res = []
  for item in L:
    if condition(item):
      res.append(item)
  return res

def is_big(x):
  return x > 60

numbers = [42, 165, 69, 18, 24]

big = filter(is_big, numbers)
print(big)

Toutes les références ne sont pas représentées

RAM

filter

<function1>

is_big

<function2>

numbers

165

big

165

[165, 69]

La fonction `filter`

La fonction filter existe déjà en Python

L’accumulation

Il s’agit de calculer une valeur à partir de toutes les valeur d’une liste
Exemple

# A partir de cette liste
numbers = [42, 165, 69, 18, 24]

# Obtenir la valeur minimale
minimum = 18

# Ou obtenir la somme des éléments
total = 318

Accumulation: Diagramme

Accumulation

La structure commune est que:
- Le résultat est initialisé avec une valeur (et non une liste)
- Le contenu de la boucle met à jour le résultat sur base d’une valeur de la liste d’entrée
L’accumulation est aussi appelé réduction
La variable qui contient le résultat et qui est mise à jour à chaque tour de boucle est souvent appelée l’accumulateur
La fonction qui factorise la structure d’une réduction est souvent appelée reduce()
Elle reçoit la valeur initiale de l’accumulateur et une fonction de mise à jour

La fonction `reduce()`

# la fonction `update` reçoit la valeur de l'accumulateur et un élément de la liste
def reduce(update, L, initial):
  acc = initiale
  for item in L:
    acc = update(acc, item)
  return acc

numbers = [42, 165, 69, 18, 24]

def add(a, b):
  return a + b

def min(a, b):
  if a < b:
    return a
  return b

total = reduce(add, numbers, 0)
minimum = reduce(min, numbers, numbers[0])

La fonction `reduce()`

La fonction reduce existe déjà dans le package functools
Si on ne lui passe pas de valeur initiale, elle utilise la première valeur de la liste et commence la boucle au deuxième élément.

from functools import reduce

numbers = [42, 165, 69, 18, 24]

def add(a, b):
  return a + b

def min(a, b):
  if a < b:
    return a
  return b

# Les appels deviennent plus simples avec le `reduce` de `functools`
total = reduce(add, numbers)
minimum = reduce(min, numbers)

Exemple plus complexe

On veut l’age moyen des étudiants de 1BA

students = [
  ['Pierre', '1BA', 17],
  ['Mohamed', '2BA', 18],
  ['Paul', '1BA', 18],
  ['Jacques', '1BA', 17],
  ['Claudine', '2BA', 19],
  ['Charlotte', '1BA', 18],
  ['John', '1BA', 20],
  ['Pauline', '1BA', 17],
  ['Tom', '2BA', 24],
]

Fonctions utiles

Définissons ces fonctions utiles et très simples

NAME = 0
BLOCK = 1
AGE = 2

def is_1BA(student):
  return student[BLOCK] == '1BA'

def get_age(student):
  return student[AGE]

En décomposant

from functools import reduce

students_1ba = filter(is_1BA, students)
ages = map(get_age, students_1ba)
mean_age = reduce(add, ages) / len(ages)

Sans décomposer

acc = 0
count = 0
for student in students:
  if is_1BA(student):
    count += 1
    acc += get_age(student)
mean_age = acc/count

Cette version n’est pas mauvaise
Mais dans la version précédente, les fonctions map, filter et reduce nous ont permis d’aborder le problème avec un modèle mental beaucoup plus simple

Trier une liste

Pourquoi est-il intéressant de trier une liste ?
Est-ce qu’un dictionnaire non trié par ordre alphabétique serait facile à utiliser ?
La recherche dans un liste triée est beaucoup plus efficace.

Recherche dans une liste non triée

def search(L, target):
    for i in range(len(L)):
        if L[i] == target:
            return i
    return None

On est obligé de tester tous les éléments un par un

Recherche dans une liste triée

Recherche dans une liste triée

def dichotomic_search(L, x):
    left = 0
    right = len(L) - 1

    while left <= right:
        mid = (left + right) // 2

        if L[mid] == x:
            return mid

        if L[mid] < x:
            left = mid + 1
        else:
            right = mid - 1

    return None

Speed Test

from time import perf_counter
from random import shuffle

# créer une grande liste triée
L = list(range(100000))

start = perf_counter()
print(search(L, 90000))
print("Time:", perf_counter() - start) # Time: 0.002944834006484598

start = perf_counter()
print(dichotomic_search(L, 90000))
print("Time:", perf_counter() - start) # Time: 6.416026735678315e-06

Speed Test

Temps d’exécution de search() proportionnel à $n$ le nombre d’élément de la liste, $O(n)$
Temps d’exécution de dichotomic_search() proportionnel à $log_2(n)$ , $O(log(n))$

Tri par insertion

On veut placer 3.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 3 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On veut placer 6.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 6 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On veut placer 2.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 2 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On veut placer 8.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 8 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On veut placer 1.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 1 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On veut placer 9.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 9 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On veut placer 4.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 4 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On veut placer 0.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 0 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On veut placer 7.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 7 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On veut placer 5.

Entrée

↑
i

Sortie

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On cherche le bon emplacement j dans la sortie.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

On insere 5 au bon endroit.

Entrée

↑
i

Sortie

↑
j

Tri par insertion

Terminé !

Entrée

Sortie

Tri par insertion: Diagramme

Tri par insertion: Code

def insert_sort(L):
    res = []
    for item in L:
        j = 0
        while j < len(res) and res[j] <= item:
            j += 1
        res.insert(j, item)
    return res

Tri en place

Quand on trie de grandes listes, il n’est pas toujours judicieux de créer une nouvelle liste
Il faut donc pouvoir trier en restant dans la liste On appelle cela un tri “en place”
La liste ne change pas de taille pendant le tri On ne peut pas utiliser insert

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On veut placer 6.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On sauve 6 dans Tmp.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche le bon emplacement j en partant de la fin.

Liste

↑
j=i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche en décalant les valeurs pour faire une place à 6.

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

j est au bon endroit.

Liste

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On met 6 au bon endroit.

Liste

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On veut placer 2.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On sauve 2 dans Tmp.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche le bon emplacement j en partant de la fin.

Liste

↑
j=i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche en décalant les valeurs pour faire une place à 2.

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 6

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 3

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

j est au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On met 2 au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On veut placer 8.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On sauve 8 dans Tmp.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche le bon emplacement j en partant de la fin.

Liste

↑
j=i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche en décalant les valeurs pour faire une place à 8.

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

j est au bon endroit.

Liste

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On met 8 au bon endroit.

Liste

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On veut placer 1.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On sauve 1 dans Tmp.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche le bon emplacement j en partant de la fin.

Liste

↑
j=i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche en décalant les valeurs pour faire une place à 1.

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 8

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 6

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 3

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 2

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

j est au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On met 1 au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On veut placer 9.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On sauve 9 dans Tmp.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche le bon emplacement j en partant de la fin.

Liste

↑
j=i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche en décalant les valeurs pour faire une place à 9.

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

j est au bon endroit.

Liste

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On met 9 au bon endroit.

Liste

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On veut placer 4.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On sauve 4 dans Tmp.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche le bon emplacement j en partant de la fin.

Liste

↑
j=i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche en décalant les valeurs pour faire une place à 4.

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 9

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 8

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 6

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

j est au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On met 4 au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On veut placer 0.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On sauve 0 dans Tmp.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche le bon emplacement j en partant de la fin.

Liste

↑
j=i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche en décalant les valeurs pour faire une place à 0.

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 9

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 8

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 6

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 4

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 3

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 2

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 1

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

j est au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On met 0 au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On veut placer 7.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On sauve 7 dans Tmp.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche le bon emplacement j en partant de la fin.

Liste

↑
j=i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche en décalant les valeurs pour faire une place à 7.

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 9

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 8

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

j est au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On met 7 au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On veut placer 5.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On sauve 5 dans Tmp.

Liste

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche le bon emplacement j en partant de la fin.

Liste

↑
j=i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On cherche en décalant les valeurs pour faire une place à 5.

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 9

Liste

↑
j-1

↑
j

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 8

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 7

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On décale 6

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On continue de chercher

Liste

↑
j-1

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

j est au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

On met 5 au bon endroit.

Liste

↑
j

↑
i

Tmp

Tri par insertion en place

i indique l'élement en cours de placement. Les éléments avant i sont triés. Ceux après reste à trier.

Terminé !

Liste

Tmp

Tri par insertion en place: Diagramme

Tri par insertion en place: Code

def insert_sort_in_place(L):
    for i in range(1, len(L)):
        tmp = L[i]
        j = i
        while j > 0 and L[j - 1] > tmp:
            L[j] = L[j - 1]
            j -= 1
        L[j] = tmp

`sort()` et `sorted()`

Il y a déjà des fonctions de tri en Python
La méthode sort() du type list fait un tri en place

L = [3, 6, 2, 8, 1, 9, 4, 0, 7, 5]
L.sort()
print(L)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

la fonction sorted() fait un tri dans une nouvelle list

L = [3, 6, 2, 8, 1, 9, 4, 0, 7, 5]
L2 = sorted(L)
print(L2)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# `L` est inchangé

`sort()` et `sorted()`

Utilisent des algorithmes plus efficaces que le tri par insertion.
Exécutés directement par le processeur sans interprétation.
Beaucoup plus rapides
Pour faire un tri décroissant

L = [3, 6, 2, 8, 1, 9, 4, 0, 7, 5]
L.sort(reverse=True)
print(L)
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

`sort()` et `sorted()`

Pour trier des valeurs plus complexes, on passe une fonction qui doit renvoyer la clé de tri pour chaque élément

profs = [
  ['LUR', 'Quentin Lurkin'],
  ['LRG', 'André Lorge'],
  ['FKY', 'Martin Fockedey'],
  ['FLE', 'Clémence Flémal'],
]

def get_trigram(prof):
  return prof[0]

# trigramme comme clé de tri
L.sort(key=get_trigram)
print(L)
# profs = [
#   ['FKY', 'Martin Fockedey'],
#   ['FLE', 'Clémence Flémal'],
#   ['LRG', 'André Lorge'],
#   ['LUR', 'Quentin Lurkin'],
# ]