Style de programmation

1- Intrduction
Un paradigme en programmation est une manière d’écrire et visualiser le code afin de résoudre des problèmes.
Trois paradigme principaux:
— Programmation impérative
— Programmation déclarative (fonctionnelle)
— Programmation orientée objet: Un programme est un ensemble d’objets en interaction.
2- Programmation impérative
C’est le paradigme originel et le plus ancien, il est fondé sur une exécution étape par étape, on parle d’exécution
«séquentielle».
Un programme est une séquence d’instructions qui modifient l’état de son environnement.
Eemple des langages de programmation: C, Pascal, Python,. . .
Instructions impératives principales: Quatre types d’instructions principales
• l’assignation;
• le branchement conditionnel;
• le branchement sans condition (goto);
• le bouclage.

entree = ['p','y','t','h','o','n']
sortie = ""
for c in entree:
sortie += c
print(sortie)

3- Programmation déclaratif (fonctionnelle)

La programmation fonctionnelle est un paradigme de programmation de type déclaratif qui considère le calcul
en tant qu’évaluation de fonctions mathématiques, dont le résultat est à son tour utilisé pour évaluer d’autres
fonctions
Un programme est une fonction au sens mathématique du terme.
Les langages de programmation tels que Haskell, Ocaml et Lisp font partie des langages de programmation les
plus connus dans le paradigme fonctionnel
Remarque : Même si certains langages de programmation ont été conçus pour “imposer” au programmeur le
paradigme fonctionnel (Lisp, Scheme, Haskell. . . ), il est tout à fait possible d’utiliser le paradigme fonctionnel
avec des langages de programmation plus “généralistes” (Python par exemple).
En programmation fonctionnelle on décrit les résultats que l’on veut obtenir à partir des données plutôt que la
séquence d’instructions qui permettent d’obtenir les résultats

entree = ['p','y','t','h','o','n']

def list2str(liste, chaine=""):

if liste == []: # cas de base
return chaine
else:
chaine += liste.pop(0)
return list2str(liste, chaine) # application récursive

list2str(entree)

1
ops = {
'plus':lambda x,y:x+y,
'moins':lambda x,y:x-y
}

op = input('Quelle operation?\n')
print(ops[op](2, 3))

Des boucles sans boucle:

Dans les langages fonctionnels, les boucles sont facilement remplacées par des appels à des fonctions
s’appliquant à des fonctions.
– map( f unction, list) applique successivement function aux éléments de la liste et retourne la liste des résultats
– f ilter ( f unction, list) retourne une liste des éléments de list pour lesquels function est vrai

l = [1,2,3,4]

print("Carrés:", list(map(lambda x: x**2, l)))

print("Nombres impairs: ", list(filter(lambda x: x%2,l)))

4- Programmation orientée objet: POO

4.1) Introduction
La programmation orientée objet est un paradigme de développement, tout comme le sont la programmation
impérative ou la programmation fonctionnelle. Elle consiste en la définition et l’interaction de briques logicielles
appelées objets.
Il s’agit donc de représenter ces objets et leurs relations; l’interaction entre les objets via leurs relations permet de
concevoir et réaliser les fonctionnalités attendues, de mieux résoudre le ou les problèmes
4.2) Objet et classe
- Objet:
Un objet représente un concept, une idée ou toute entité du monde physique, comme une voiture, une personne
ou encore une page d’un livre.
Il possède une structure interne et un comportement, et il sait interagir avec ses pairs.
- Classe:
Une classe est la définition d’un objet et comprend:
– son nom;
– ses attributs, c’est-à-dire les données qui définissent son état;
– ses méthodes, à savoir les fonctions qu’elle implémente et qui définissent son comportement.
- Tout est objet:
En fait, en Python, tout est objet, y compris les entiers, les flottants, les booléens, les com- plexes, les listes ou les
dictionnaires. On accède facilement à la classe d’un objet à l’aide de la fonction type.

x = 1 x = 1+2j
print(type(x)) print(type(x))

<class 'int'> <class 'complex'>

2
4.3) Exemple
Si tu veux représenter une voiture, tu créeras un objet de type voiture qui aura quatre roues, un moteur, un
kilométrage. Ce sont des attributs.
La voiture pourra également accélérer, ralentir. Ce sont des fonctions. En général, un objet sera représenté par
une classe qui regroupera les données (attributs) et le traitement de ses données (fonctions).
- Exemple 1
Il est conseillé en Python de nommer sa classe en CamelCase, c’est à dire qu’un nom est composéd’une suite de
mots dont la première lettre est une capitale. On préférera par exemple une classe MonNomDeClasse

# Définition d'une classe Point

class Point:
pass
# Création d'un objet de type Point
p = Point()

Méthodes spéciales
Les méthodes spéciales sont identifiées par deux tirets bas à chaque côtés du nom.
On a rencontré pour la première fois une méthode spéciale init(le constructeur).
La fonction repr () donne une représentation textuelle de n’importe quel objet, sous forme de chaîne.

#Définition des méthodes

class Point:
def __init__(self, a, b):
self.x = a
self.y = b

def __repr__(self):
return "("+str(self.x)+","+str(self.y)+")"

def deplace(self, dx, dy):

self.x = self.x + dx
self.y = self.y + dy

p = Point(1,2)
p.deplace(2,2)
p

- Exemple 2

class ListeLettres:
"Classe permettant de lier une chaîne de caractères à une liste de caractères"
def __init__(self, lettres=[]):
self.lettres = lettres
self.string = ''.join(lettres)

# définition d'une méthode

def get_string(self):
return self.string

entree = ['p','y','t','h','o','n']

# instanciation de l'objet avec les données de la liste

objet = ListeLettres(entree)
objet.get_string()