Résumé du cours : Structures de données, contrôles, sous-programmes et interface graphique

id: 33-1310-resume-cours-complet slug: 33-1310-resume-cours-complet titre: 'Résumé du cours : Structures de données, contrôles, sous-programmes et interface graphique' chapitre: 0 chapitre_titre: Synthèse générale lecon: 1 niveau: 4eme-sci ordre: 1 prerequis: [] duree_estimee_min: 45 mots_cles:

structures de donnees
structures de controle
sous-programmes
fonctions
procedures
interface graphique
pyqt5
operateurs langages:
analyse
pascal
python objectifs:
Récapituler les principales structures de données et leurs opérations
Distinguer les structures de contrôle simples, conditionnelles et itératives
Définir et appeler des fonctions et procédures en algorithmique et en Python
Construire une interface graphique simple avec PyQt5 status: published source_pdf: 33_1310.pdf source_pages:
1
2
3
4 kind: fiche

Ce document constitue une synthèse générale du programme : structures de données, structures de contrôle, sous-programmes et interface graphique. Il met en parallèle l'écriture algorithmique et l'écriture Python.

1. Les structures de données

1.1 Les objets

Déclaration en algorithmique (T.D.O — Tableau de Déclaration des Objets) :

Objets	Types / Natures
m	Réel
g	Constante = 9.8

1.2 Entier (`int`)

Type représentant un entier relatif.

1.3 Réel (`float`)

Type représentant un nombre réel.

Opérations sur les nombres

Algorithme	Rôle
`n ← aléa (vi, vf)`	Retourner un entier aléatoire ∈ [Vi..Vf]
`n ← arrondi (x)`	Arrondir x (entier pair si décimale = 0.5)
`n ← racinecarré (x)`	Retourner √x, x ≥ 0
`n ← ent (x)`	Convertir un réel en entier
`n ← abs (x)`	Valeur absolue de x

En Analyse

Algorithme	Rôle
`n ← aléa (vi, vf)`	Retourner un entier aléatoire ∈ [Vi..Vf]
`n ← arrondi (x)`	Arrondir x (entier pair si décimale = 0.5)
`n ← racinecarré (x)`	Retourner √x, x ≥ 0
`n ← ent (x)`	Convertir un réel en entier
`n ← abs (x)`	Valeur absolue de x

En Python

from random import *
n = randint(vi, vf)

n = round(x)

from math import *
n = sqrt(x)

n = int(x)
n = abs(x)

Exemples :

n = randint(-1, 2)   # n ∈ {-1, 0, 1, 2}
n = round(2.4)       # n = 2
n = round(-2.6)      # n = -3
n = round(4.5)       # n = 4   (entier pair)
n = round(3.5)       # n = 4   (entier pair)
n = sqrt(16)         # n = 4.0
n = int(4.9)         # n = 4
n = int(-1.95)       # n = -1
n = abs(-4.95)       # n = 4.95

1.4 Booléen (`bool`)

Variable logique qui peut contenir Faux (False) ou Vrai (True).

1.5 Chaîne (`str`)

Une chaîne est formée par une succession de caractères. Pour ch = "PC", chaque caractère est indexé de 0 à long(ch)-1, d'où ch[0]='P', ch[1]='C'.

Algorithme	Rôle
`ch ← ch1 + ch2 + ch3`	Concaténer des chaînes
`L ← long (ch)`	Nombre de caractères de ch
`n ← pos (ch1, ch2)`	Première position de ch1 dans ch2
`ch ← convch (x)`	Convertir un nombre en chaîne
`n ← valeur (ch)`	Convertir une chaîne en nombre
`ch ← majus (ph)`	Convertir en majuscules
`ph ← sous_chaine (ch, d, f)`	Extraire ch[d..f-1]
`ch ← effacer (ch, d, f)`	Effacer ch[d..f-1]
`test ← estnum (ch)`	Vérifier si ch est convertible en nombre

En Analyse

Algorithme	Rôle
`ch ← ch1 + ch2 + ch3`	Concaténer des chaînes
`L ← long (ch)`	Nombre de caractères de ch
`n ← pos (ch1, ch2)`	Première position de ch1 dans ch2
`ch ← convch (x)`	Convertir un nombre en chaîne
`n ← valeur (ch)`	Convertir une chaîne en nombre
`ch ← majus (ph)`	Convertir en majuscules
`ph ← sous_chaine (ch, d, f)`	Extraire ch[d..f-1]
`ch ← effacer (ch, d, f)`	Effacer ch[d..f-1]
`test ← estnum (ch)`	Vérifier si ch est convertible en nombre

En Python

ch = ch1 + ch2 + ch3
L = len(ch)
n = ch2.find(ch1)
ch = str(x)
n = int(ch)        # ou float(ch)
ch = ph.upper()
ph = ch[d:f]
ch = ch[:d] + ch[f:]
test = ch.isdecimal()

Exemples :

ch = "Bac" + " " + "info"          # ch = "Bac info"
L = len("Bac info")                # L = 8
n = "bonbon".find("on")            # n = 1
n = "bonbon".find("N")             # n = -1
ch = str(12.5)                     # ch = "12.5"
n = int("123")                     # n = 123
n = float("12.95")                 # n = 12.95
ch = "Bac 1!".upper()              # ch = "BAC 1!"
ph = "informatique"[2:5]           # ph = "for"
ch = "informatique"[:2] + "informatique"[7:]  # ch = "intique"
test = "123".isdecimal()           # test = True

1.6 Caractère (`str`)

Un caractère est une touche du clavier : lettre minuscule ou majuscule, chiffre ou symbole. En Python, on utilise le type str.

Algorithme	Rôle
`n ← ord (c)`	Code ASCII du caractère c
`c ← chr (n)`	Caractère dont le code ASCII est n

En Analyse

Algorithme	Rôle
`n ← ord (c)`	Code ASCII du caractère c
`c ← chr (n)`	Caractère dont le code ASCII est n

En Python

n = ord(c)
c = chr(n)

Exemples :

ord('0')   # 48
ord('A')   # 65
ord('a')   # 97
chr(48)    # '0'
chr(65)    # 'A'
chr(97)    # 'a'

1.7 Tableau (`array`)

Un tableau permet de ranger plusieurs valeurs de même type, sur une seule ligne et plusieurs colonnes.

Pour N = 4 et T = ["info", "PC", "2.25", "w"], chaque case est indexée de 0 à N-1 : T[0]="info", T[1]="PC", T[2]="2.25", T[3]="w".

T.D.N.T (Nouveaux Types) :

Nouveaux Types
`Tab = tableau de 100 chaînes`

T.D.O :

Objets	Types / Natures
T	Tab

En Analyse

T.D.N.T (Nouveaux Types) :

Nouveaux Types
`Tab = tableau de 100 chaînes`

T.D.O :

Objets	Types / Natures
T	Tab

En Python

from numpy import *

T = array([float] * 100)

# Exemples :
T = array([int] * N)    # N doit être défini
T = array([bool] * 20)
T = array([str] * 5)

2. Les opérateurs

2.1 Opérateurs arithmétiques

Opérateur	Algorithme	Python	Exemple
Multiplication	`*`	`*`	`-3.5 * 2 = -7.0`
Division	`/`	`/`	`7 / 2 = 3.5`
Division entière	`Div`	`//`	`7 // 2 = 3`
Reste (modulo)	`Mod`	`%`	`7 % 2 = 1`
Addition	`+`	`+`	`3.5 + 2 = 5.5`
Soustraction	`-`	`-`	`3 - 2 = 1`

2.2 Opérateurs logiques

Opérateur	Algorithme	Python	Exemple
Négation	`non`	`not`	`not False == True`
Conjonction	`et`	`and`	`False and True == False`
Disjonction	`ou`	`or`	`False or True == True`

2.3 Opérateurs de comparaison, ensembles et intervalles

Opérateur	Algorithme	Python	Exemple
Égal	`=`	`==`	`5 == 5` → `True`
Différent	`≠`	`!=`	`5.7 != 5.7` → `False`
Strictement supérieur	`>`	`>`	`"a" > "A"` → `True`
Supérieur ou égal	`≥`	`>=`	`"s" >= "ali"` → `True`
Strictement inférieur	`<`	`<`	`False < True` → `True`
Inférieur ou égal	`≤`	`<=`	`"O" <= "A"` → `True`
Appartient (ensemble)	`∈ {V1,V2,V3}`	`in {V1,V2,V3}`	`"A" in {"A","a","*","?"}` → `True`
Appartient (intervalle)	`Vi ≤ x ≤ Vf`	`Vi <= x <= Vf` ou `x in range(Vi, Vf+1)`	`7 in range(7)` → `False`

3. Les structures de contrôle

3.1 Les structures simples

Opération	Description	Algorithme	Python
Entrée	Saisir une valeur au clavier	`lire(n)`	`n = int(input("Donner un entier : "))`
Affectation	Affecter ou modifier une variable	`n ← n - 2`	`n = n - 2`
Sortie	Afficher objets, messages, expressions	`écrire_nl("La somme de ", a, " et ", b, " est : ", a+b)`	`print("La somme de", a, "et", b, "est :", a+b)`

lire(n)

Saisie en Algorithme

lire(n)

Saisie en Python

ch = input("Donner une chaîne : ")
ch = str(input("Donner une chaîne : "))
n  = int(input("Donner un entier : "))
x  = float(input("Donner un réel : "))

3.2 Les structures conditionnelles

But : choisir un traitement parmi plusieurs.

Forme réduite (1 état)

si conditions = vrai alors
    instruction_1
    ...
    instruction_n
finsi

Algorithme

si conditions = vrai alors
    instruction_1
    ...
    instruction_n
finsi

Python

if conditions == True:
    instruction_1
    ...
    instruction_n

Forme complète (2 états)

si conditions = vrai alors
    instruction_1
    ...
sinon
    instruction_1
    ...
finsi

Algorithme

si conditions = vrai alors
    instruction_1
    ...
sinon
    instruction_1
    ...
finsi

Python

if conditions == True:
    instruction_1
    ...
else:
    instruction_1
    ...

Forme généralisée (> 2 états)

si conditions_1 = vrai alors
    traitement_1
sinon si conditions_2 = vrai alors
    traitement_2
sinon si conditions_3 = vrai alors
    traitement_3
...
sinon si conditions_n-1 = vrai alors
    traitement_n-1
sinon
    traitement_n
finsi

Algorithme

si conditions_1 = vrai alors
    traitement_1
sinon si conditions_2 = vrai alors
    traitement_2
sinon si conditions_3 = vrai alors
    traitement_3
...
sinon si conditions_n-1 = vrai alors
    traitement_n-1
sinon
    traitement_n
finsi

Python

if conditions_1 == True:
    traitement_1
elif conditions_2 == True:
    traitement_2
elif conditions_3 == True:
    traitement_3
...
else:
    traitement_n

Structure à choix multiples

Le sélecteur doit être de type scalaire : entier, caractère ou booléen.

selon selecteur
    valeur1 : traitement_1
    valeur2 :
        traitement_2
    valeur3, valeur4, valeur20 : traitement_3
    valeur7 .. valeur10 : traitement_4
    valeur30 .. valeur40 : traitement_5
    ...
    sinon : traitement_n
finselon

Algorithme

selon selecteur
    valeur1 : traitement_1
    valeur2 :
        traitement_2
    valeur3, valeur4, valeur20 : traitement_3
    valeur7 .. valeur10 : traitement_4
    valeur30 .. valeur40 : traitement_5
    ...
    sinon : traitement_n
finselon

Python

match selecteur:
    case v1: traitement_1
    case v2:
        traitement_2
    case v3 | v4 | v20: traitement_3
    case selecteur if selecteur in range(v7, v11):
        traitement_4
    case selecteur if v30 <= selecteur <= v40:
        traitement_5
    ...
    case _: traitement_n

3.3 Les structures répétitives (itératives)

But : répéter un traitement plusieurs fois.

Forme complète (nombre de répétitions connu)

Nombre de répétitions = |Vf - Vi| + 1
Compteur de type scalaire discret ordonné : entier, caractère ou booléen.

pour i de Vi à Vf [pas = valeur] faire
    instruction_1
    instruction_2
    ...
    instruction_n
finpour

Algorithme

pour i de Vi à Vf [pas = valeur] faire
    instruction_1
    instruction_2
    ...
    instruction_n
finpour

Python

for i in range(n):
    instruction_1
    instruction_2
    ...
    instruction_n

1ʳᵉ forme à condition d'arrêt (`tant que` / `while`)

Nombre de répétitions inconnu
Nombre minimal de répétitions = 0

tant que conditions = vrai faire
    instruction_1
    instruction_2
    ...
    instruction_n
fin tant que

Algorithme

tant que conditions = vrai faire
    instruction_1
    instruction_2
    ...
    instruction_n
fin tant que

Python

while conditions == True:
    instruction_1
    instruction_2
    ...
    instruction_n

2ᵉ forme à condition d'arrêt (`répéter` / boucle simulée)

Nombre de répétitions inconnu
Nombre minimal de répétitions = 1

répéter
    instruction_1
    instruction_2
    ...
    instruction_n
jusqu'à conditions = vrai

Algorithme

répéter
    instruction_1
    instruction_2
    ...
    instruction_n
jusqu'à conditions = vrai

Python

while not (conditions == True):
    instruction_1
    ...
    instruction_n

# ou bien :
test = False
while test == False:
    instruction_1
    ...
    instruction_n
    test = conditions == True

4. Les sous-programmes

4.1 Présentation

Une approche modulaire consiste à diviser un programme en plusieurs sous-programmes (modules) de difficultés moindres : chaque module peut être divisé lui aussi en plusieurs modules.

Un module peut être une fonction ou une procédure, et il n'est exécuté que moyennant des appels.

4.2 Les fonctions

Définition :

Fonction nom_fonction (paramètres_formels : types) : type_résultat
Début
    instruction_1
    ...
    instruction_n
    retourner objet_resultat
Fin

Algorithme

Fonction nom_fonction (paramètres_formels : types) : type_résultat
Début
    instruction_1
    ...
    instruction_n
    retourner objet_resultat
Fin

Python

def nom_fonction(parametres_formels):
    instruction_1
    ...
    instruction_n
    return objet_resultat

Appel :

nom_variable ← nom_fonction(parametres_effectifs)

Algorithme

nom_variable ← nom_fonction(parametres_effectifs)

Python

nom_variable = nom_fonction(parametres_effectifs)

4.3 Les procédures

Définition :

Procédure nom_procedure (paramètres_formels : types)
Début
    instruction_1
    ...
    instruction_n
Fin

Algorithme

Procédure nom_procedure (paramètres_formels : types)
Début
    instruction_1
    ...
    instruction_n
Fin

Python

def nom_procedure(parametres_formels):
    instruction_1
    ...
    instruction_n

Appel :

nom_procedure(parametres_effectifs)

Algorithme

nom_procedure(parametres_effectifs)

Python

nom_procedure(parametres_effectifs)

4.4 Objets globaux et locaux

4.5 Paramètres

Formels : figurent au niveau de l'en-tête (dans la définition du module).
Effectifs : figurent au niveau de l'appel (dans le programme appelant).

Objet immutable (ne change pas de valeur) : int, float, bool, str
Objet mutable (peut changer de valeur) : array

5. Interface graphique (PyQt5)

5.1 Objets

Label : zone d'affichage (chaîne)
LineEdit : zone de saisie (chaîne)
PushButton : bouton poussoir

5.2 Événement

Cliquer sur un bouton poussoir :

nom_variable_graphique.nom_bouton.clicked.connect(module_action)

5.3 Actions

Action	Syntaxe
Lecture	`nom_variable_graphique.nom_lineedit.text()`
Écriture	`nom_variable_graphique.nom_label.setText(chaine)`
Effacement	`nom_variable_graphique.nom_element_graphique.clear()`

5.4 Formulation générale

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication   # importer les modules graphiques

app = QApplication([])                     # générer une application graphique
windows = loadUi("nom_fichier_graphique.ui")  # charger le fichier .ui créé avec DesignerQt5
windows.show()                             # visualiser la fenêtre graphique
windows.nom_bouton.clicked.connect(slot)   # appeler un slot après le clic
app.exec()                                 # exécuter l'application

5.5 Exemple : application SOMME

Correspondance des éléments graphiques :

Type_élément	Nom
LineEdit	s1
LineEdit	s2
Label	a
PushButton	b1 (calculer)
PushButton	b2 (effacer)

Code Python complet :

from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication

def somme(n1, n2):
    s = n1 + n2
    return s

def play():
    ch1 = windows.s1.text()
    ch2 = windows.s2.text()
    if not (ch1.isdecimal() and ch2.isdecimal()):
        ch = "Données invalides"
    else:
        ch = str(somme(int(ch1), int(ch2)))
    windows.a.setText(ch)

def reset():
    windows.s1.clear()
    windows.s2.clear()
    windows.a.clear()

app = QApplication([])
windows = loadUi("Interface_somme.ui")
windows.show()
windows.b1.clicked.connect(play)
windows.b2.clicked.connect(reset)
app.exec()