c1

October 27, 2019

1 Représentation des traitements

1.1 Opérateurs
Les opérations sont représentées par des symboles dits opérateurs.

Opération Syntaxe Exemple Résultat

Addition a+b 2+3 5
Concaténation seq1 + seq2 ‘ab’ + ‘cd’ ‘abcd’
Test d’inclusion obj in seq ‘a’ in ‘cdi’ False
Division a/b 3/2 1.5
Division entière a // b 3 // 2 1
Exponentiation a ** b 2 ** 3 8
Indexation seq[k] ‘abcde’[0] ‘a’
Modulo a%b 5%2 1
Multiplication a*b 5*2 10
Négation (logique) not a not True False
Ou (logique) a or b True or False True
Et (logique) a and b True and False False
Soustraction a-b 5-6 -1
Strictement inférieur a<b 3<3 False
inférieur a <= b 3 <= 3 True
Égalité a == b 3 == 3 True
Différent de a != b 3 != 3 False
Supérieur a >= b 3 >= 3 True
Strictement supérieur a>b 3>3 False

1.2 Expression
Une expression est une formule permettant de trouver une valeur après avoir effectué un calcul
sur des données : constantes, variables ou fonctions.
Exemples :

• Une condition est une expression logique (donne True/False) : (3 * x + y ** .5 < t) or

x >= 0
• Une expression conditionnelle : 'le nombre '+ str(x) + 'est pair' if x % 2 == 0
else 'est impair'

1
1.3 Structures de contrôle de flux d’exécution
Les structures de contrôle de flux permettent d’exprimer l’ordre dans lequel les instructions seront
éxexutées.

1.3.1 Structure séquntielle SQ

L’ordre dans lequel les instructions sont écrites détermine l’ordre d’exécution, l’enseble des in-
structions contrôlées par la structure séquentielle est dit bloc.

1.3.2 Structures séléctives SS

L’exécution d’un bloc dépond d’une condition, si elle est vrai le boc est exécuté, sinon le bloc est
ignoré.

1.3.3 En python if
La sutructure sélective est implémentée par la structure if:
1. if est obligatoire (pas de eilf ou else sans un bloc if) (1:1 fois)
2. elif est optionnelle, permet d’introduire plusieurs blocs conditionnés (0:* fois)
3. else est optionnelle, représente la négation de toutes les conditions précédentes (0:1 fois)

if cnd1:
# bloc 1
elif cnd2:
# bloc 2
elif cnd3:
# bloc 3
else:
# bloc 4

1.3.4 Structures Itérative/Répétitive

2
1.3.5 Pour en python
La boucle pour en python permet d’exécuter un traitement autant de fois qu’on a d’éléments dans
un ensemble :

1. Prendre une valeur de l’ensemble

2. Affecter cette valeur à la variable de boucle
3. Exécuter le bloc indenté de for

for variable in ensemble:

# Traitement

Souvent en utilise i comme variable de boucle et la fonction range() comme ensemble.

• range(n) permet de représenter l’intervalle [0..n[

• range(start, stop, step) permet de spécifer le début, la fin et le pas de l’intervalle
• range génère les valeurs à la demande.

1.3.6 Tant que en python

La boucle tant que permet de répéter un traitement tant que la condition est vraie.

1. Vérifier la condition
2. Exécuter le bloc indenté de while

La boucle tant que se traduit en python par :

while condition:
# Traitement

Attention à ne pas donner une condition Fausse, ou une condition toujours vraie.

1.3.7 Répéter en python

On peut simuler la boucle répéter comme suit

while True:
# Traitement
if condition:
break

2 Projet
2.1 Représentation des données
Nous souhaitons réaliser une petite application qui permet aux élèves de la première année
(CPGE) de comprendre comment les données sont représentées au sein d’un système informa-
tique.

1. Dans un premier temps, répondez aux questions suivantes de la façon la plus précise possi-
ble

3
 1. Comment convertir un nombre en binaire ?
• Exprimer en fonction de la valeur Combien de fois on vérifie si le quotient est nul
2. Comment évaluer un code binaire ?
3. Comment écrire un code binaire sur un nombre de bits donné ?
4. Comment coder un nombre en notation biaisée ?
5. Comment coder un nombre en notation signe + valeur ?
6. Comment coder un nombre en complément à 1
7. Comment coder un nombre en complément à 2

2. En utilisant flowgorithm

1. Représentez vos réponses en utilisant des algorigrammes

2. Exécutez les méthodes pour les tester
3. Affichez le code en python, comparez les instructions de python et de flowgorithm

On peut refomuler la question A comme suit

• Objectif : Conversion d’un nombre en binaire

• Entrées:
– valeur : entier, la valeur à convertir
• Sortie
– code : chaîne, code binaire an ...a0 tel que ∑in=−01 ai ∗ 2i = valeur

In [1]: def bin(valeur):

"Calcule le code binaire d'un enier."
b = 2
code = ''
q = valeur
while True: #This simulates a Do Loop
r = q % b
code = str(r) + code
q = q // 2 # int(float(q) / b)
if q == 0: break #Exit loop
return code

# Exemple d'appel
bin(63)

Out[1]: '111111'

2.1.1 Methode décomposition d’un nombre

On peut réinvestir l’idée exploitée pour calculer le code binaire pour décomposer un nombre
entier.

Il suffit de calculer le reste et le quotient de façon répétitive.

4
 pour représenter une valeur en utilisant les notations demandées il faut présiser le nombre de
bits à utiliser, il nous faut donc une fonction qui permet d’écrire un code sur le nombre de bits
spécifié.

In [2]: def etendre(code, nb):

'Donne le code sur nb bits.'
codesurnbits = code
while len(codesurnbits) < nb:
codesurnbits = '0' + codesurnbits
return codesurnbits

# Exemple d'appel
etendre('111111', 8)

Out[2]: '00111111'

• Objectif : Trouver la valeur d’un code binaire

• Entrées:
– code : chaîne, code binaire an ...a0
• Sortie
– valeur : entier, la valeur tel que valeur = ∑in=−01 ai ∗ 2i

In [3]: def evaluer(code):

"Donne la valeur d'un code bianaire."
b = 2
n = len(code)
valeur = 0 # Résultat initial
for i in range(n):
ai = int(code[n-1-i])
valeur = valeur + ai * b ** i # construction
return valeur # résultat final

# Exemple d'appel
evaluer('00111111')

Out[3]: 63

2.1.2 Méthode : calcul de la somme

n
• Pour calculer une somme de la forme S = ∑ ti
i =0

1. On initialise S à 0 (somme vide)

2. Pour chaque valeur de i on calcule le term i et on l'ajoute à la somme S
3. On obtient le résultat final S
n
Exercice Définissez la fonction somme(n) qui implémente la somme suivante s = ∑ i.
i =0

5
2.1.3 Méthode : calcul du produit
n
• Pour calculer un produit de la forme P = ∏ ti
i =0

1. On initialise P à 1 (Produit vide)

2. Pour chaque valeur de i on calcule le term ti et on le multiplie par P
3. On obtient le résultat final P
n
Exercice Définissez la fonction factoriel(n) qui implémente la formule suivante n! = ∏ i.
i =1

3 Notation biasée
In [4]: def coderennb(n, k, nbits):
codenb = n + k
codenb = bin(codenb)
codenbsurnbits = etendre(codenb, nbits)
return codenbsurnbits

# Exemple d'appel
coderennb(-67, 127, 8)

Out[4]: '00111100'

4 Notation signe+Valeur
Pour programmer la notation signe+Valeur, nous avons besoin de calculer la valeur absolue du
nombre relatif :
Calcul de la valeur absolue (NB: python offre une fonction prédéfinie abs() ):
{
x si x ≥ 0
|x| =
− x si x < 0

In [5]: def abs(x):

'Calcule la valeur absolue de x'
if x < 0:
vabs = -x
else:
vabs = x
return vabs

# Exemple d'appel
abs(-67)

Out[5]: 67

6
 Exercice: Redéfinissez la fonction abs() en utilisant l’expression conditionnelle (vv if cnd else
vf)
Nous avons besoin de coder le signe en utilisant la convention suivante :
{
0 si n ≥ 0
signe(n) =
1 si n < 0

In [6]: def codersigne(n):

'Coder le signe.'
signe = 1 if n < 0 else 0
return signe

# Exemple d'appel
codersigne(-17)

Out[6]: 1

In [7]: def coderensv(n, nbits):

'Conder n en sgine+valeur sur nbits.'
valeur = abs(n)
codevaleur = bin(valeur)
codevaleur = etendre(codevaleur, nbits-1)
codesigne = str(codersigne(n))
codesv = codesigne + codevaleur
return codesv

# Exemple d'appel
coderensv(-17, 8)

Out[7]: '10010001'

4.1 Complément à 1
Pour coder une valeur en complément à 1, il nous faut une fonction qui permet d’intervertir les
bits du code binaire de la valeur absolue du nombre s’il est négatif.

In [8]: def c1(code):

'''Intervertit les bits d'un code binaire.'''
codec1 = "" # Résultat initial
n = len(code)
for i in range(n):
if code[i] == "0":
codec1 = codec1 + "1" # construction
else:
codec1 = codec1 + "0" # construction
return codec1 # résultat final

# Exemple d'appel
c1('11110000')

7
Out[8]: '00001111'

en python on peut utiliser l’expression conditionnelle

valeur_si_vrai if condition else valeur_si_faux

In [9]: def c1(code):

'''Intervertit les bits d'un code binaire.'''
codec1 = "" # Résultat initial
n = len(code)
for i in range(n):
bit = "1" if code[i] == "0" else "0"
codec1 = codec1 + bit # construction
return codec1 # résultat final

# Exemple d'appel
c1('11110000')

Out[9]: '00001111'

4.1.1 Méthode incrémentale

Les résultats qu’on ne peut pas calculer directement avec une formule peuvent être calculés petit
à petit, par construction incrémentale, c’est une généralisation de l’idée utilisée pour calculée la
somme.

1. Définir la valeur initial du résultat

2. Construire le résultat
3. Obtenir le résultat

Exercices

• Définissez la fonction copie(chaine) qui crée une copie de chaine caractère par caractère.
• Définissez la fonction souschaine(chaine, i, n) qui retourne n caractères à parir du car-
actère d’indice i.
• Définissez la fonction inverser(chaine) qui retourne l’inverse de la chaîne passée en argu-
ment.
• Définissez la fonction hexa(n) qui prend un entier n et retourne une chaîne qui représente
son code en hexadécimal.

On combine les fonctions que l’on a définies pour répondre à notre question principale :

In [10]: def coderenc1(n, nbits):

valeurabsolue = abs(n)
codebinaire = bin(valeurabsolue)
codebinairenbits = etendre(codebinaire, nbits)
if n < 0:
codec1 = c1(codebinairenbits)
else:

8
 codec1 = codebinairenbits
return codec1

# Exemple d'appel
coderenc1(-32, 8)

Out[10]: '11011111'

4.1.2 Complément à deux

Le complément à deux peut être calculé de la même façon en remplaçant c1() par c2() qui code les
valeurs négatives en C2 :

In [11]: def coderenc2(n, nbits):

valeurabsolue = abs(n)
codebinaire = bin(valeurabsolue)
codebinairenbits = etendre(codebinaire, nbits)
if n < 0:
codec2 = c2(codebinairenbits)
else:
codec2 = codebinairenbits
return codec2

# Exemple d'appel
coderenc2(-32, 8)

--------------------------------------------------------------------------

NameError Traceback (most recent call last)

<ipython-input-11-e899d6cc384a> in <module>
10
11 # Exemple d'appel
---> 12 coderenc2(-32, 8)

<ipython-input-11-e899d6cc384a> in coderenc2(n, nbits)

4 codebinairenbits = etendre(codebinaire, nbits)
5 if n < 0:
----> 6 codec2 = c2(codebinairenbits)
7 else:
8 codec2 = codebinairenbits

NameError: name 'c2' is not defined

Exercice Définissez la fonction c2(code) pour que le code foncionne.

9
4.1.3 Méthode
Si le problème est difficile

- Décomposer en sous-problèmes plus simples

- Résoudre les sous-problèmes
- Combiner les solutions pour résoudre le problème initial

4.2 Exemple d’exécution

Le programme principal lit les données, fait appel aux fonctions qui font le traitement, puis affiche
les résulatats.

In [15]: # Main
N = int(input('Entrer une valeur '))
nb = int(input('Entrer le nombre de bits '))
codebin = etendre(bin(abs(N)), nb)
codesv = coderensv(N, nb)
codenb = coderennb(N, 127,nb)
codec1 = coderenc1(N, nb)
print(codebin, ' est le code binaire de ', abs(N), ' sur ', nb ,' bits')
print(codesv, ' est le code en signe+valeur de ', N, ' sur ', nb ,' bits')
print(codenb, ' est le code en notation biaisée de ', N, ' sur ', nb ,' bits')
print(codec1, ' est le code en complément à 1 de ', N, ' sur ', nb ,' bits')

Entrer une valeur -97

Entrer le nombre de bits 8
01100001 est le code binaire de 97 sur 8 bits
11100001 est le code en signe+valeur de -97 sur 8 bits
00011110 est le code en notation biaisée de -97 sur 8 bits
10011110 est le code en complément à 1 de -97 sur 8 bits

5 Methode Top down : Analyse descendante

1. Décomposition : Décomposez le problème en sous-problèmes ex.representation? =
{Comp1?, Comp2?, SV?, NB?, IEEE754?}
2. Raffinement successif :
1. Pour chaque sous-problème
1. S’il est simple alors on le résout (ex. NB? = bin(N+K))
2. Sinon on le décompose encore (ex Comp1? = {abs?, bin?, C1?}
3. Combinez les solutions pour trouver une solution au problème de départ (ex. cederenc1())

10
 Top Down

5.1 Avantages :
1. Modularité : Les sous-problèmes peuvent être traités indépendamment, ce qui facilite la
résolution, l’implémentation et le test de chaque solution.
2. Réutilisation : Les solutions partielles peuvent être réutilisées ou adaptées aux problèmes
similaires.
3. Travail en équipe : les membres d’une équipe peuvent travailler en parallèle sur des parties
différentes.

Remarque Les solutions partielles peuvent être implémentées par des fonctions liées re-
groupées dans des ensembles cohérents dits modules.
Exercices Analyser les problèmes suivants en utilisant la méthode TOP/DOWN

• Représentation d’un nombre en IEEE754 (précision simple : 32 bits).

• Représentation d’un nombre en notation à point fixe.
• En connaissant la date d’un jour, Comment calculer la date de la veille.
• En connaissant la date d’un jour, Comment calculer la date du lendemain.

11