Informatique au lycée Faustin Fleret

Paradigmes de programmation :

Un paradigme est une manière de programmer un ordinateur basé sur un ensemble de principes ou une théorie.

La création du premier programme informatique par Ada Lovelace sur la machine de Babbage en 1842 a permis de formaliser les ingrédients des algorithmes tels que nous les connaissons: affectations, boucles, conditions. Cependant, maintenant que l'informatique est présente dans très nombreux domaines, il s'est avéré nécessaire d'adapter la programmation aux problèmes à traiter. Ces approches appelées paradigmes de programmation fournissent au développeur une vue différente de la façon dont s'éxecute le programme.

Chaque nouveau paradigme augmente le niveau d’interactvitié.

Les trois grands types de programmation

Il existe trois grands types de programmation au programme de terminale:

• La programmation impérative: le paradigme originel est le plus courant.
• La programmation orientée objet(POO) consistant en la définition et l’assemblage de briques logicielles appelées objets.
• La programmation fonctionnelle est un paradigme de programmation de type déclaratif qui considère que tous les éléments peuvent être compris comme des fonctions et le code peut être exécuté par des appels successifs de fonctions.

La programmation impérative :

La programmation impérative est le paradigme de programmation le plus ancien. Il consiste à résoudre un problème en listant une série d'instructions (assignations, boucles, conditions, opérations) qui modifient l'état d'un programme jusqu'à obtenir la solution. On donne une recette de cuisine qui est suivie ligne à ligne par l'interpréteur.

x = 2
y = 2 * x
if y == 4:
	print("y vaut 4")
else:
	print("y ne vaut pas 4")

Avantages de la programmation impérative :

• Bien lisible
• Comparativement facile à apprendre car le code se lit étape par étape
• Modèle de pensée aisément compréhensible pour les débutants (étapes de résolution)
• Permet de tenir compte des caractéristiques de cas d’application spéciaux

Inconvénients de la programmation impérative:

• Le code devient très rapidement volumineux et perd en clarté (multiplication des variables)
• Mise à jour plus difficiles

La programmation fonctionnelle

Dans un programme fonctionnel, tous les éléments peuvent être compris comme des fonctions et le code peut être exécuté par des appels successifs de fonctions. En programmation fonctionnelle, l'opération d'affectation est interdite, ce qui permet de s'affranchir des effets de bord.

bord = [1]

def effet(x):
  bord[0] = bord[0] + x
  return bord[0]

print(bord)
print(effet(2))  	# effet() est une fonction  qui modifie le contenu d'une variable (bord) utilisée par d'autres morceaux.
print(effet(2))  	# Une même fonction appelée à différents moments avec les mêmes paramètres peut renvoyer différents résultats.
print(effet(2))		# Effet de bord = Danger absolu !!!

La programmation fonctionnelle offre un haut degré d’abstraction parce qu’elle s’appuie sur le principe mathématique de la fonction.
Elle utilise une syntaxe raccourcie pour la définition de fonctions anonymes, les fonctions lambdas.

lambda param1, ... , paramN: valeur_retournée

La programmation fonctionnelle fait appel à trois grandes opérations sur les itérateurs:

• L'opération map(fonction, itérable) applique la fonction à tous les éléments de l'itérable et retourne un nouvel itérable.
  Copier le code

  list(map(f, it)) <===> [f(x) for x in it]

• L'opération filter(fonction, itérable) renvoie un itérable qui ne contient que les éléments de l'itérable d'entrée pour lesquels la fonction évalue à True.
  Copier le code

  list(filter(f,it)) <===> [x for x in it if f(x)]

• L'opération reduce(fonction, itérable, init) renvoie le résultat de la récurrence Xn=fonction(Xn−1,In) où I0=init et In=itérable[n-1].

Avantages de la programmation fonctionnelle :

• Code facilement vérifiable : même les fonctions sans état peuvent être vérifiées
• Code plus précis et concis

Inconvénients de la programmation fonctionelle:

• Les données (p. ex. variables) ne sont pas modifiables
• La programmation récursive peut entraîner de graves erreurs

La Programmation Orientée Objet

La POO consiste en la définition et l’interaction de briques logicielles appelées objets ; un objet représente un concept, une idée ou toute entité du monde physique. L’objet possède en interne une structure et un comportement, et il sait interagir avec ses pairs.

La POO consiste en la création et l’utilisation d’objets, qui se composent d’attributs et de méthodes liés à des classes.

• Les attributs renvoient aux variables contenues dans l’objet : ce sont les données. On y accède avec la syntaxe objet.attribut.
• Les méthodes sont les éléments qui permettent d’interagir avec les attributs. Les méthodes sont des fonctions internes à une classe.On y accède avec la syntaxe objet.methode().
• La classe est la structure de données définissant une catégorie générique d'objets. La classe est le modèle sur lequel est crée l'objet.
• L'objet est une instance d’une classe, c’est-à-dire qu’il hérite des attributs et des méthodes génériques de sa classe. Il est un représentants de sa classe

Avantages de la programmation orientée objet :

• un code structuré et regroupé
• réutilisation du code
• modification d'une classe rapidement et simplement

Inconvénients de la programmation orientée objet:

• Les objets ont souvent besoin d' une documentation complète (trop abstrait pour un autre programmeur)
• Trop complexe pour des opérations basiques

Quel paradigme choisir?

Certains langages forcent à utiliser un paradigme de programmation (ex: Smalltalk: POO, Haskell: fonctionnelle) mais la plupart des langages modernes comme Python (ou Javascript) sont multiparadigmes et laissent le choix au programmeur du paradigme à utiliser en fonction du problème posé.

• Un bon programme a presque toujours besoin de plusieurs paradigmes
• Chaque paradigme est bon pour certains problèmes
• Un bon langage doit donc soutenir plusieurs paradigmes !!! (sujet à débat ; l’exception confirmant la règle )

Oui mais nous on choisit quoi ?

Pour simplifier :

• Une suite d'instruction simple => Programmation impérative
• Un gros problème avec plein de mathématique => Programmation fonctionnelle
• Des objets différents mais des points communs (attributs) => Programmation Orientée Objet

x = 5
y = 3
result = x + y
print(result)

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

x = 5
y = 3
result = addition(x, y)
print(result)

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age
    
    def afficher_infos(self):
        print(f"Nom: {self.nom}, Age: {self.age}")

# Utilisation de la classe Personne
personne1 = Personne("Alice", 25)
personne1.afficher_infos()