Thème 1: Programmation

Chapitre 1: Récursivité
Venant du latin recursum, qui vient lui même de recurrere (revenir en arrière)

1.1 Problème: la somme des n premiers entiers

→ Technique pour résoudre certain problèmes qu’on ne peut pas résoudre avec des boucles

Fonction récursive: une fonction qui fait appel à elle-même

Appel récursif: appel qui fait référence à la fonction que l’on est en train de définir
Condition d’arrêt: ce qui permet la fin/arrêt d’une boucle ou d’un appel récursif; si il y’a absence d’une
condition d’arrêt la machine indiquera un erreur
Les cas de base: cas pour lesquels la fonction n’a pas besoin de faire appel à elle-même (condition d’arrêt)
Les cas récursifs: cas pour lesquels la fonction fait appel à elle même
Arbre d’appels: représentation sous forme d'escalier du principe d’appel récursif :
somme(3) = return(3) + somme(2)
return(2) + somme(1)
return(1) + somme(0)
return(0)

Définition récursive/Définition par cas: représentation des différentes issues possibles

puissance(x , n) = {1 si n = 0
{x*puissance(x,n-1)

1.2 Formulations récursives

La suite de Fibonacci: suite qui commence toujours par 0 et 1; ensuite sa troisième occurrence est la somme
des deux termes précédents (0,1,1,2,3,5,8,13,21…)
La suite de John McCarthy: On la nomme f91(n) et elle est représentée par la définition récursive:
f 91( n ) = { n-10 si n > 100
{ f91( f91( n + 11)) si n <= 100

Toute formulation récursive d’une fonction possède au moins un cas de base et un cas récursif mais il y’a
plusieurs formes possibles:
- Cas de bases multiples: on peut indiquer d’autre cas de base s' il nécessitent moins de calcul de
l’indiquer
- Cas récursifs multiples: pour réduire le nombre de calculs à effectuer, on peut ajouter plus de cas
récursifs (pair/impair)
- Double récursion: on peut aussi appeler plusieurs fois la fonction
- Récursion imbriquée: on peut aussi appeler la fonction dans la fonction
- Récursions mutuelles: on définit deux fonctions mutuelles (a(n) et b(n)) avec un cas de base respectif et
qui font appel à l’autre dans leur cas récursif et à elle-même.

Règles pour former une récursive:

- Vérifier que la récursive à une fin
- Vérifier que le domaine de définition soit respecté
- S’assurer que la fonction fonctionne pour toutes les valeurs de son domaine (essayer les valeurs
spéciales comme 0 et valeurs limites)
1.3 Programmer avec des fonctions récursives
Pour éviter une erreur de domaine on a trois possibilités:
1. S’assurer que le test couvre bien toutes les valeurs qui ne sont pas définies (1.3.1)
2. Pour restreindre les appels à la fonction aux entiers positifs ou nul on peut aussi utiliser l’instruction
assert (l’instruction assert est très utilisé pour le débogage; si la condition qu’on test avec l’instruction assert est vrai le
programme continue de s'exécuter. Si le retour est faux, le programme s'arrête et un message d’erreur peut être affiché.)
3. On peut créer une seconde fonction qui vérifiera ensuite que le domaine est bon en mettant en place un
test après.

Les piles: Exemples de structures de données que, faute de mieux, nous appellerons des sacs. Un sac offre trois
opérations élémentaires :
 1. tester si le sac est vide,
2. ajouter un élément dans le sac,
3. retirer un élément du sac (tenter de retirer un élément d’un sac vide déclenche une erreur).
Le sac est une structure impérative : un sac se modifie au cours du temps.
représentation:

x 7 puissance (7,4)

n 4

x 7 puissance (7,3)

n 3

Il est important de diminuer au maximum le nombre d’appels récursifs pour ne pas saturer la mémoire du
système.
Python limite le nombre d’appels récursifs à 1000; si excédé, le message d’erreur “RecursionError:
maximum recursion depth exceeded.”.
Pour définir une nouvelle limite on peut utiliser la fonction setrecursionlimit dans le module sys. Soit:
import sys
sys.setrecursionlimit(2000)
 Chapitre 2: Modularité
2.1 Variations sur les ensembles
Paradoxe de l’anniversaire: Il suffit d’un groupe de 23 personnes pour avoir plus d’une chance sur deux d’avoir
deux personnes avec le même anniversaire.

Structure de tableau de bits: Tableau dans lequel les booléens sont remplacés par des bits pour limiter la place
de la mémoire occupée.
Module: fichiers de codes; son nom peut être retrouvé en enlevant le suffixe “.py” du nom du fichier. Il peut
dépendre d’autres modules.

rappel: s=set() marque la création d’un nouvel ensemble vide

2.2 Modules, interfaces et encapsulation

Dans un code on sépare en plusieurs fichiers le frontwear et le backware du code.

Structure d’un module:

dans un fichier: nom.py

- sa réalisation/implémentation: La partie qui explique les fonctions contenues (contrat entre l’utilisateur
et le développeur)
- son interface: La partie visible pour l’utilisateur

Un module réalise une interface quand il remplit toutes les fonctions qu’il définit.
Encapsulation: Tous les éléments hors de l’interface auquel l’utilisateur n'a pas accès. Pour rendre privée un
module, on utilise son nom précédé du symbole “_” au début du code. Tout le reste est public et peut être
modifié par tous ceux qui ont accès au code.
Table de hachage: structure polyvalente qui permet de représenter des ensembles
Fonction de hachage: fonction qui détermine dans quel paquet l'élément doit être

2.3 Exceptions

Exception Contexte

NameError accès à une variable inexistante

IndexError accès à un indice invalide du tableau

KeyError accès à une clée inexistante d’un dictionnaire

ZeroDivisionError division par zéro

TypeError opérations appliquées à des valeurs incompatibles

raise: soulever une exception

On peut essayer d’éviter ces exceptions avec la forme try/except:

try:
x = int(input())
except ValueError:
print(“il faut un nombre entier”)
 Chapitre 3: Programmation objet
https://replit.com/join/qvpcdifdxw-ariane7

3.1 Classes et attributs: structurer les données

Représenter une structure de données en python:
- Le couple: cas particulier de n-uplet ou n=2
- Le tableau: faire attention que les éléments aient la même forme
- Le n-uplet

Classe: Structure de données (dont le nom commence systématiquement par une majuscule)

Pour déclarer une classe on utilise l’instruction:

class Chrono:
def __int__ (self, h, m, s):
self.heures = h
self.minute = m
self.minute = s
>>>t=Chrono(h, m, s)
h, m et s des attributs définis ici.

Instance/Objet: une version qui suit le modèle de la classe ( ex: t=Chrono(h, m, s))

Exception Contexte

AttributeError accès à un attribut innexistant

En tapant:
On peut créer une instance supplémentaire dans la classe t. Néanmoins, il ne faut pas le faire pour que le code ne
soit pas désorganisé.

Attributs de classe: attributs dont la valeur est caractéristique de la classe et ne varie pas en fonction des objets

Class Chrono
→ attribut: champs de valeurs, tableaux....
→ méthodes: fonctions
→ variable de classe
créer un objet ou une instance de la classe

3.2 Méthodes: manipuler les données

Méthode: fonction qu’on utilise dans les classes sous la forme: t.texte()
t.avance(s4)
t: paramètre implicite
s4: paramètre explicite

Quand on défini une nouvelle méthode on utilise la syntaxe:

def avance(self,s):

Méthode Appel Effet

__str__(self) str (t) renvoie une chaîne de caractère

décrivant t

__lt__ (self, u) t<u renvoie True si t est strictement

plus petit que u
 __hash__(self) hash(t) donne un code de hachage pour t,
par exemple pour utiliser
comme clé d’un dictionnaire t

__len___(self) len(t) renvoie un nombre entier

définissant la taille de t

__contains__(self, x) x in t renvoie True si et seulement si x

est dans la collection t

--getitem--(self,i) t［i］ renvoie le i-ème élément de t

On ne peut pas utiliser == entre deux objets, il renverrait Faux. Elle ne renvoie True que si on teste l’égalité
entre un objet et lui-même.

Pour vérifier que deux de nos objets contiennent les mêmes valeurs il faut définir la méthode spéciale
__eq__(self,other) qui compare les objets un par un.

3.3 Retour sur l’encapsulation

RECHERCHE PERSONNEL
L’encapsulation : est un mot qui illustre deux concepts:
Le fait que les attributs et les méthodes d’un objet lui sont spécifiquement associés
Le champ d’action des attributs et des méthodes est par défaut l’objet lui-même et non tout autre objet

Exemple :
Imaginons une classe Coffee_Machine. Lorsque l’on appuie sur le bouton Tass de Cafe (Tass_Cafe()), la
machine s’allume, fait bouillir l’eau puis nous verse un café. On peut donc dire que la méthode _innit()_
contient aussi trois autres méthodes: Demarrer_Machine(), Bouillir_Eau() et Faire_Cafe().
Pourtant la machine ne nous propose pas de boutons pour faire bouillir l’eau, donc cette méthode est une
encapsulation dans Tass_Cafe() de façon privée accessible seulement de l'intérieur du programme.

3.4 Héritage
*Hors programme*
 Chapitre 4: Mise au point des programmes
4.1 Types
Un type: une classification des objets manipulés en fonction de leur nature

Chaque nom de classe Python définit un type de même nom pour toutes les instances de la classe. La fonction
type() permet de renvoyer le type.

valeur type description

1 int nombres entiers

3.4 float nombres décimaux

True bool booléennes

“abc” str chaînes de caractères

None NoneType valeur indéfinie

(1, 2) tuple n-uplets

[2, 3] list tableaux

{1, 2, 3} set ensembles

{‘a’:1, ‘b’:2 , ‘c’:3} dict dictionnaires

Lors de l’utilisation de valeurs incompatible (e.g >>> 1+[2, 3]) le programme renvoie l’erreur TypeError
en précisant souvent l’endroit ou ils sont incompatibles

Surcharge d’un opérateur:

Gestion dynamique: Le langage ne détecte pas les erreurs de types à la compilation (vérification statique de
types); c’est au moment de l'exécution (vérification dynamique de types) qu’ils renvoient l’erreur.
Gestion statique: Le langage détecte les erreurs de types à la compilation
Dimensions:

Il est important d’annoter son code pour aider à comprendre le code créé; on peut utiliser la forme:

def nom_fonction( t:list) -> bool:

Tout ce qui est après “->” n’est pas pris en compte par le programme et sert d’annotation (même fonction que la
notation “#...#”)

Il existe des outils pour vérifier des types pour Python comme:
“pytype” de Google
“pyre” de Facebook
Pour: Ensemble = List [int] On a:
Type de Paramètre:[int]
Type principal: List

On peut créer des modules qui sont compatibles avec différents des données de types différents en utilisant la
syntaxe:

La fonction “hash()” de python, appelée fonction de hachage, prend en paramètre un élément de n’importe quel
type "hashable" et renvoie un entier.

4.2 Tester un programme

Pour vérifier que deux tableaux sont identiques ou calculer le nombre d'occurrence d’une valeur on peut utiliser
des dictionnaires.

Il existe une fonction time de la bibliothèque time qui indiquent le nombre de secondes écoulées depuis un
instant de référence (1/1/1970 à 00:00); on l’appelle avec time.time()

4.3 Invariant de structure

 Chapitre 5: programmation fonctionnelle
Il existe différents langages informatiques qui se renouvellent
paradigmes de programmation: famille qui regroupe des concepts qu’il mettent en oeuvre
un langage de programmation peut appartenir à plusieurs

5.1 Fonctions passées en arguments

tri par
fonction anonyme: une fonction qui n’a pas de nom et ne peut pas être appellée
5.2 fonctions renvoyées come résultats

5.3 structures de données immuables

immuables
mutables
métote