Le cours a pu se faire au travers de cette activité, mais nous sommes revenus à l’utilisation de Python.

1. Introduction

Problème : « Donner l’écart entre les carrés de deux nombres entiers positifs consécutifs. »

1.1. Première solution

Algo ecarts_carres_1
Variables:
 |  n, r: entiers
Début algo
 |  Afficher "Donnez un entier: "
 |  Demander n
 |  r <- (n+1)² - (n)²
 |  Afficher "L’écart vaut: "
 |  Afficher r
Fin algo

ou plus simplement :

Algo ecarts_carres_2
Variables:
 |  n: entier
Début algo
 |  Afficher "Donnez un entier: "
 |  Demander n
 |  Afficher (n+1)² - (n)²
Fin algo

Que faire si le commanditaire veut maintenant les écarts des cubes ?

1.2. Deuxième solution

On donne un nom au calcul à faire.

Algo ecarts_cubes
Variables:
 |  n: entier
Fonction f(i: entier)
 | Retourner i³
Fin fonction
Début algo
 |  Afficher "Donnez un entier: "
 |  Demander n
 |  Afficher f(n+1) - f(n)
Fin algo

Ici, on a « factorisé » un motif. C’est une idée que l’on retrouve :

• avec le Light Bot, le jeu du robot, lorsqu’il doit faire une série de mouvements identiques,
• en maths quand on écrit $2x + yx = x(2+y)$.

On respecte ainsi le principe « Ne vous répétez pas », aussi écrit DRY pour Don't repeat yourself. Les avantages sont multiples :

• code plus concis si beaucoup de répétitions (pas dans notre exemple !),
• code plus lisible,
• code plus réutilisable,
• code plus maintenable,
• …

Même si le copier-coller est souvent plus rapide, ce n’est pas une vraie solution à moyen terme.

2. Définitions

2.1. Générales

Ce paragraphe ne convient pas à tous les langages, mais il convient à la plupart, et surtout au pseudo-code et à Python.

Une fonction est définie par :

• un nom,
• une liste de paramètres (et éventuellement leur type),
• une valeur de retour (et éventuellement son type).

Les deux derniers points constituent la signature de la fonction.

Une fois définie, une fonction peut être appelée en lui fournissant un argument par paramètre. L’appel de la fonction sera en quelque sorte remplacé par la valeur de retour, afin de, suivant ce que l’on a voulu faire :

• l’intégrer à une expression,
• l’affecter à une variable,
• l’afficher,
• servir de nouvelle valeur de retour si on appelle cette fonction depuis une autre fonction,
• …

Remarques

• Les fonctions ainsi définies sont très proches des fonctions mathématiques.
• Les syntaxes de définitions de fonctions peuvent varier énormément selon les langages.
• Certains langages comme Lisp, Tcl ou Haskell (entre autres) ont leurs appels de fonctions de la forme ma_fonction arg1 arg2 arg3. Cela simplifie la syntaxe et facilite la simulation du langage naturel.
• Concernant le « retour » :
  • Certains puristes considèrent qu’une fonction pure doit toujours retourner le même type de valeur. Elle ne peut par renvoyer un entier pour certains arguments, et un booléen pour d’autres.
  • Dans certains langages, les fonctions retournent par défaut :
    • la dernière valeur calculée,
    • None si.
  • L’instruction de retour (souvent return) interrompt immédiatement le déroulement de la fonction. Si on simplifie, on peut dire que l’exécution reprend directement où la fonction a été appelée.

2.2. En algorithmique et pseudo-code

On peut définir une fonction dans l’en-tête de l’algorithme, juste après les déclarations de variables (ou même dans l’algorithme).

Pour une fonction à deux paramètres :

Fonction ma_fonction(param1: type1; param2: type2)
 |  ...
 |  Retourner ...
Fin fonction

Où les points de suspension correspondent :

• à un éventuel traitement, parfois inutile pour les fonctions simples,
• à une valeur de retour, obligatoire.

On appellera une fonction avec ma_fonction(arg1; arg2).

Voir la deuxième solution ci-dessus pour un exemple.

2.3. En Python

Pour une fonction à trois paramètres :

def ma_fonction(param1, param2, param3):
    ...
    return ...

Dans la première ligne, on ne fait pas figurer les types attendus, et on n’oublie pas les :.

Appel avec ma_fonction(arg1, arg2, arg3).

3. Propriétés

Les fonctions pures n’ont pas d’interaction avec l’extérieur.

1. Elles n’ont pas d’effets de bord. Rien d’autre que le calcul est effectué.
   • Pas d’affichage,
   • pas d’impression,
   • pas de commande vers l’extérieur,
   • pas d’arrêt du programme, pas d’extinction de l’ordinateur.
2. Si une même fonction est appelée deux fois avec les mêmes arguments, elle retournera deux fois la même valeur.

4. Exemples et exercices

Note : C’est peut-être le moment de se mettre aux doctests.

4.1. Pas de paramètre

Une fonction pure sans paramètre ne peut-être que constante.

4.2. Un paramètre

doubler, mettre_au_carre, valeur_absolue, pair, positif_ou_nul, strictement_positif

4.3. Deux paramètres

somme_2, produit_2, difference, quotient, moyenne, maxi, mini, compare (retourne le signe (1 ou -1) de la différence entre le premier argument et le second, 0 s'ils sont égaux), divisible.

4.4. Une liste en paramètre

Vous aurez peut-être besoin des fonctions :

• len http://docs.python.org/3.2/library/functions.html#len ou
• range http://docs.python.org/3.2/library/functions.html#range, qui prend tout son sens ici.

somme, produit, moyenne, maxi, mini, tous_positifs, au_moins_un_positif.

5. Conversions

Certaines fonctions pures permettent de convertir une valeur d’un certain type en un autre. Par exemple 1 en 1.0 ou "1" en 1.

Ce sont par exemple : bool, complex, float, int, str…

D’autres fonctions peuvent être considérées comme des fonctions de conversion, comme bin, hex et oct, qui retournent cependant toujours une chaîne de caractères.

6. Exemples en pseudo-code

6.1. Somme

Fonction somme(m: entier, n: entier)
 | Retourner m + n
Fin fonction

6.2. Test de parité

Fonction pair(n: entier)
 |  Si n % 2 == 0, alors
 |   |  Retourner Vrai
 |  Sinon
 |   |  Retourner Faux
 |  Fin Si
Fin fonction

7. Exemples en Python

7.1. Somme

def somme(m, n):
    return m + n

7.2. Test de parité

def pair(n):
    if n % 2 == 0:
        return True
    else:
        return False

Sinon, comme en Python un nombre peut être considéré comme un booléen, on peut aussi écrire :

def pair(n):
    return n % 2 == 0

Voire :

def pair(n):
    return not n % 2

7.3. Fonctions pures du cœur de Python

http://docs.python.org/3.2/library/functions.html

À vous de deviner lesquelles sont pures.

abs(x)

all(iterable)

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any(iterable)

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object)

bin(x)

bool([x])

bytearray([source[, encoding[, errors]]])

bytes([source[, encoding[, errors]]])

callable(object)

chr(i)

classmethod(function)

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

complex([real[, imag]])

delattr(object, name)

dict(**kwarg)
dict(mapping, **kwarg)
dict(iterable, **kwarg)

divmod(a, b)

enumerate(iterable, start=0)

eval(expression, globals=None, locals=None)

exec(object[, globals[, locals]])

filter(function, iterable)

float([x])

format(value[, format_spec])

frozenset([iterable])

getattr(object, name[, default])

globals()

hasattr(object, name)

hash(object)

hex(x)

id(object)

input([prompt])

int(x=0)
int(x, base=10)

isinstance(object, classinfo)

issubclass(class, classinfo)

iter(object[, sentinel])

len(s)

list([iterable])

locals()

map(function, iterable, ...)

max(iterable, *[, key])
max(arg1, arg2, *args[, key])

memoryview(obj)

min(iterable, *[, key])
min(arg1, arg2, *args[, key])

next(iterator[, default])

object()

oct(x)

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True)

ord(c)

pow(x, y[, z])

print(*objects, sep=' ', end='\n', file=sys.stdout)

property(fget=None, fset=None, fdel=None, doc=None)

range(stop)
range(start, stop[, step])

repr(object)

reversed(seq)

round(number[, ndigits])

set([iterable])

setattr(object, name, value)

slice(stop)
slice(start, stop[, step])

sorted(iterable[, key][, reverse])

staticmethod(function)

str(object='')
str(object[, encoding[, errors]])

sum(iterable[, start])

super([type[, object-or-type]])

tuple([iterable])

zip(*iterables)

7.4. Fonctions pures des modules numériques

http://docs.python.org/3.2/library/numeric.html

Exemple d’utilisation :

>>> import math  # à taper en tête de fichier dans un script
>>> math.sqrt(9)
3.0

7.5. Un exemple de session intéractive

Python 3.2.2 (default, Sep  4 2011, 09:51:08) [MSC v.1500 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> bool("")
False
>>> bool("lwdriop")
True
>>> bool("False")
True
>>> bool(" ")
True
>>> bool("zero")
True
>>> bool("0")
True
>>> bool(False)
False
>>> bool(0)
False
>>> bool(1)
True
>>> str(12345)
'12345'
>>> for chiffre in 12345: print(chiffre)

Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    for chiffre in 12345: print(chiffre)
TypeError: 'int' object is not iterable
>>> for chiffre in str(12345): print(chiffre)

1
2
3
4
5
>>> bin(16)
'0b10000'
>>> oct(16)
'0o20'
>>> hex(16)
'0x10'
>>> not 0
True
>>> not 1
False
>>> int(True)
1
>>> int(False)
0
>>> chr(65)
'A'
>>> ord('A')
65
>>> ord('é')
233
>>> ord('ù')
249
>>> ord('?')
63
>>> ord('þ')
254
>>> ord('µ')
181
>>> ord('Õ')
213
>>> ord('?')
2349
>>> for i in range(32, 1000): print(chr(i), end='')

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~??????????????????????????? ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿAaAaAaCcCcCcCcDdÐdEeEeEeEeEeGgGgGgGgHhHhIiIiIiIiIi??JjKk?LlLlLl??LlNnNnNn???OoOoOoŒœRrRrRrSsSsSsŠšTtTtTtUuUuUuUuUuUuWwYyŸZzZzŽž?b????????Ð???????ƒƒ????I??l????OOo?????????t??TUu?????z?????????|??!?????????AaIiOoUuUuUuUuUu?Aa????GgGgKkOoOo??j????????????????????????????????????????????????????????????????????????????????????????????????????????????????g???????????????????????????????????????????????????????????????????????????????????????'"?'???????^?ˆ?'¯´`?_????????????°?˜???????????????????????????????????`´^~¯¯??¨?°???"????????????????????????¸?????????__???????????????????????????????????????????????????????????????????????????;????????????????????G????T??????????S??F??O???????aß?de??????µ???p??st?f?????????????????????????????????
>>> divmod(17,3)
(5, 2)
>>> globals()
{'__builtins__': <module 'builtins' (built-in)>, 'chiffre': '5', '__package__': None, 'i': 999, '__name__': '__main__', '__doc__': None}
>>> bts_sio = ''
>>> globals()
{'bts_sio': '', '__builtins__': <module 'builtins' (built-in)>, 'chiffre': '5', '__package__': None, 'i': 999, '__name__': '__main__', '__doc__': None}
>>> 2*input()
bonjour
'bonjourbonjour'
>>> 2*input()
hello
'hellohello'
>>> len("bonjour")
7
>>> len("hello")
5
>>> len("hello")
5
>>> max("bonjour", "hello", "bts sio")
'hello'
>>> 'a' < 'b'
True
>>> 'a' < 'ba'
True
>>> 'ca' < 'ba'
False
>>> 'aa' < 'ab'
True
>>> 'A' < 'a'
True
>>> 'a' < 'aa'
True
>>> 'aa' < 'b'
True