Partie I : les modules usuels

I-Saisie avec contrôle de données :

Ecrire un programme qui permet de saisir un entier n avec 5 ≤ 𝑛 ≤ 20 ….

Explication :
On nous demande de donner la main à l’utilisateur de saisir un entier et pas
n’importe quel entier il doit être compris entre 5 et 20.

Une condition qui nécessite l’utilisation

d’une boucle répéter…jusqu’a

Solution 1 : une procédure saisie Solution 2 : une fonction saisie

Procédure saisie (@n : entier) Fonction saisie ( ): entier
Début saisie Début saisie
Répéter Répéter
Ecrire ("Donner un entier n") Ecrire ("Donner un entier ")
Lire(n) Lire(x)
TDO
Jusqu’à n dans [5..20] Objet Type Jusqu’à n dans [5..20]
TDO
Fin saisie ø ø Retourne n
Objet Type
Fin saisie x Entier

Appel dans le programme principal : Appel dans le programme principal :

…. TDO …. TDO
Saisie(n) Objet Type nSaisie() Objet Type
… … … …
….. n Entier ….. n Entier
… … … …
saisie procédure saisie fonction

Procédure saisie en python : Fonction saisie en python :

 Appel de la procédure saisie en python : Appel de la fonction saisie en python :

II- Remplissage d'un tableau :

Un module permettant de remplir un tableau T de n (5 ≤ 𝑛 ≤ 20) entiers.

Explication :
On nous demande de remplir un tableau de n cases avec des entiers
quelconques.
• Aucun résultat pour ce module il faut donc développer une
procédure.
• Il s'agit de remplir un tableau il faut donc utiliser une boucle pour

Solution : une procédure remplir Procédure remplir en python :

Procédure remplir (@T: tab , n : entier)
Début remplir
Pour i de 0 a n-1 faire
Ecrire ("T[",i,"]")
Lire(T[i]) TDO
Objet Type Appel de la procédure remplir en python :
Fin pour
i entier
Fin remplir

Appel dans le programme principal :

TDNT
Type
tab = tableau de 20
…. entiers

remplir(T,n) TDO
Objet Type
….. T tab
n entier
remplir procédure
… …
III- Remplissage d'un tableau avec une condition :

Un module permettant de remplir un tableau T de n (5 ≤ 𝑛 ≤ 20) entiers

pairs.

Explication :
On nous demande de remplir un tableau de n cases avec des entiers
quelconques.
• Aucun résultat pour ce module il faut donc développer une
procédure.
• Il s'agit de remplir un tableau il faut donc utiliser une boucle pour
• Il y'a une condition de remplissage : on n'accepte que les entiers
pairs il faut donc utiliser la boucle répéter .. Jusqu’à.

Solution : une procédure remplir Procédure remplir en python :

Procédure remplir (@T: tab , n : entier)
Début remplir
Pour i de 0 a n-1 faire
Répéter
Ecrire ("T[",i,"]") TDO
Objet Type
Lire(T[i])
i entier
Jusqu'à T[i] mod 2 =0
Fin pour
Fin remplir

Appel dans le programme principal : Appel de la procédure remplir en python :

TDNT
Type
tab = tableau de 20
…. entiers
TDO
remplir(T,n)
Objet Type
….. T tab
n entier
remplir procédure
… …
IV- les nombres premiers :

Un module premier permettant de retourner un booléen : Vrai si le nombre

passé en paramètre est premier sinon la fonction retourne Faux

Explication :
Nous partons du principe qu'un nombre premier X n'a que deux
diviseurs :
• Parcourir les diviseurs potentiels de 1 à X
• Tester la division : X mod i si le résultat est zéro
incrémenter un compteur (nb_div)
• A la fin du parcours si le compteur nb_div =2 alors la
fonction retourne Vrai sinon la fonction retourne Faux
Rq : X est un entier positif

Solution : une fonction premier Fonction premier en python :

Fonction premier (X: entier) : booléen
Début premier
nb_div0
Pour i de 1 à X+1 faire
Si X mod i =0 alors
nb_divnb_div+1
fin si TDO
Objet Type
Fin pour nb_div Entier
i entier
Si nb_div=2 alos
Retourne VRAI
Sinon
Retourne FAUX
Fin si
Fin premier
V- Le tri des tableaux :

Un module procédure permettant de trier par ordre croissant un tableau T de n entiers.

1- Le tri sélection :

Explication :
Le principe est de chercher la valeur minimale (min) dans T de la position
1 à la position n-1 puis de placer la valeur trouvée dans T[0] de
recommencer l'opération en avançant d'une position à chaque fois.
Pour mieux comprendre prenons un exemple :
n=5 Permutation entre min et T[4]
T[4]<min
T 3 17 5 7 2
0 1 2 3 4

min
Chercher T[j]<min
Permutation entre min et T[4]
T[4]<min
T 2 17 5 7 3
0 1 2 3 4

min Chercher T[j]<min

T 2 3 5 7 17
0 1 2 3 4

min Chercher T[j]<min

T 2 3 5 7 17
0 1 2 3 4

min Chercher T[j]<min

T 2 3 5 7 17
0 1 2 3 4

Le tableau T est trié.

Solution : une procédure Tri_selection procédure Tri_selection en python :
Procédure tri_selection(@T: tab, n:entier)
début tri_selection
pour i de 0 à n-2 faire
min  i
pour j de i+1 à n-1 faire
si T[ j ] < T[ min ] alors
min j
finsi
fin pour
si min ≠ i alors
temp T[ min ]
T[ min ] T[ i ] TDO
Objet Type
T[ i ] temp min Entier
finsi j Entier
i Entier
fin pour temp Entier

Fin Tri_Selection

2- Le tri insertion :
Explication :
Le principe est d'insérer le ième élément à sa place parmi ceux qui le
précèdes et décaler les cases supérieures
n=5 3
T 11 3 5 2 17
0 1 2 3 4

T 3 11 5 2 17
0 1 2 3 4

T 3 5 11 2 17
0 1 2 3 4

i
 17

T 2 3 5 11 17
0 1 2 3 4

T 2 3 5 11 17
0 1 2 3 4

Le tableau est trié

Solution : une procédure Tri_insertion Procédure Tri_insertion en python :

Procédure tri_insertion(@T: tab, n:entier)
début tri_insertion
pour i de 1 à n-1 faire
tmpT[i]
ji
tant que (j>0) et (T[j-1]>temp) faire
T[j]T[j-1]
jj-1
TDO
Fin tant que Objet Type
j Entier
T[j]tmp i Entier
tmp Entier
Fin pour
Fin Tri_insertion

3- Le tri à bulle :
Explication :
Le principe est de comparer les éléments du tableau 2 par deux puis de
faire la permutation entre T[i] et T[i+1] si T[i]>T[i+1].
Répéter le parcours du tableau jusqu’à ce qu'il n'y ait plus de permutation.
n=5
T 11 3 5 2 17
0 1 2 3 4

T[i]>T[i+1] alors permutation

 T 3 11 5 2 17
0 1 2 3 4

T[i]>T[i+1] alors permutation

T 3 5 11 2 17
0 1 2 3 4

T[i]>T[i+1] alors permutation

T 3 5 2 11 17
0 1 2 3 4

T[i]<T[i+1] alors pas de permutation

T 3 5 2 11 17
0 1 2 3 4
T[i]<T[i+1] alors pas de permutation

T 3 5 2 11 17
0 1 2 3 4
T[i]>T[i+1] alors permutation

T 3 2 5 11 17
0 1 2 3 4

Aucune permutation jusqu' a la fin du parcours

T 3 2 5 11 17
0 1 2 3 4
T[i]>T[i+1] alors permutation

T 3 2 5 11 17
0 1 2 3 4

Aucune permutation le tableau est trié

 Solution : une procédure Tri_bulle Procédure Tri_bulle en python :
Procédure tri_bulle(@T: tab, n:entier)
début tri_bulle
permVRAI
tant que perm=VRAI faire
permFAUX
pour i de 0 à n-2 faire
si T[i]>T[i+1] alors
tmpT[i]
T[i]T[i+1]
T[i+1]tmp
PermFAUX TDO
Fin si Objet Type
perm booléen
Fin pour i Entier
tmp Entier
Fin tant que
Fin Tri_tribulle

VI- les nombres parfaits :

Un module permettant de vérifier si un entier X passé en paramètre est un nombre

parfait le module retourne un booléen VRAI si X est parfait FAUX sinon.

Explication :
Un nombre parfait est égal à la somme de ses diviseurs stricts,
Exemple :
6=1+2+3------------ 6 est un nombre parfait.
28= 1+2+4+7+14 -------------------28 est un nombre parfait

Fonction parfait en python :

Solution : une fonction parfait
Fonction parfait (X:entier) :Booléen
Début parfait
S0
Pour i de 1 à (X div 2)+1 faire
Si X mod i =0 alors
SS+i
 Fin si Remarque :
Fin pour La boucle pour s'arrête à la moitié de X (X
Si S=X alors div 2) car il n'y a plus de diviseurs au-delà
Retourne VRAI TDO de X div 2 sauf X lui même
Objet Type
Sinon S Entier
Retourne FAUX i Entier

Fin si
Fin parfait

VII- Les nombres amis :

Un module permettant de vérifier si un entier X et Y passés en paramètres sont des

nombres amis le module retourne un booléen VRAI si X et Y sont amis FAUX sinon.

Explication :
Deux nombres sont dits « amis » quand la somme des diviseurs de l’un
est égale à l’autre, par exemple (220, 284).
220 a pour diviseurs (hors lui-même) 1, 2, 4, 5, 10, 11, 20, 22, 44, 55,
110, dont la somme est 284.
284 a pour diviseurs (hors lui-même) 1, 2, 4, 71, 142, dont la somme est
220.

Solution : une fonction amis Fonction amis en python :

Fonction amis (X,Y:entier) :Booléen
Début amis
S_divx0
S_divy0
Pour i de 1 à (X div 2)+1 faire
Si X mod i =0 alors
S_divx  S_divx +i
Fin si
Fin pour
Pour i de 1 à (Y div 2)+1 faire
Si Y mod i =0 alors
 S_divyS_divy+i
Fin si
Fin pour
Si X=S_divy et Y=S_divx alors
Retourne VRAI
Sinon TDO
Objet Type
Retourne FAUX
S_divx Entier
Fin si S_divy Entier
i Entier
Fin amis

VIII- Tableau d'entiers distinct :

Un module permettant de vérifier qu'un tableau contient ou pas des doublons (des
valeurs qui se répètent) le module retourne VRAI si un entier à une position i se répète
et FAUX sinon

Explication :
Dans un tableau à chaque saisie (donc dans la procédure remplir) nous
allons faire l'appel de ce module pour vérifier l'existence de l'élément
saisi dans le tableau. Concrètement :
Elément saisi

T 13 3 3
0 1 2 3 4

J i
T[j]≠T[i]

T 13 3 3
0 1 2 3 4

j i
T[j]=T[i]

La fonction retourne FAUX

La boucle répéter jusqu’à va donner la main à l'utilisateur de refaire la
saisie de l'élément i.
 Solution : une procédure remplir Solution : une fonction distinct
Procédure remplir (@T: tab , n : entier) fonction distinct (T: tab,i : entier): booléen
Début remplir TDO Début distinct
Objet Type
Pour i de 0 a n-1 faire j0
i Entier
Répéter distinct fonction test VRAI
Ecrire ("T[",i,"]") tantque (j<i) et test= VRAI faire
Lire(T[i]) si T[i]=T[j] alors
Jusqu'à distinct(T,i)=VRAI testfaux
Fin pour sinon
jj+1 TDO
Fin remplir
Objet Type
fin si j Entier
test booléen
fin tantque
Fonction distinct en python : Retourne test
Fin distinct

Procédure remplir en python :

IX- Recherche dans un tableau :

Un module permettant de rechercher un entier dans un tableau T de taille N le module

retourne la position de la première apparition de l'entier dans T s'il existe et -1 sinon.

1- Recherche dans un tableau non trié (recherche séquentielle) :

Explication :
Parcourir le tableau case par case et faire la comparaison de la case
courante avec l'entier recherché s'il y a égalité renvoyer la position
courante sinon continuer le parcours.
Renvoyer -1 si on sort de la boucle sans aucune correspondance.
 Exemple :
X=15
T 6 9 73 15 3
0 1 2 3 4

i X≠T[i]

T 6 9 73 15 3
0 1 2 3 4

i X≠T[i]

T 6 9 73 15 3
0 1 2 3 4

i X≠T[i]

T 6 9 73 15 3
0 1 2 3 4

i X=T[i]

Le module renvoi :3

Solution : une fonction rech_seq : Fonction rech_seq en python :

Fonction rech_seq (T: tab , n,x : entier)
Début rech_seq
Pour i de 0 a n-1 faire
Si T[i] = x alors
Retourne i
Fin si TDO
Objet Type
Fin pour i Entier

Retourne -1
Fin rech_seq
2- Recherche dans un tableau trié croissant (recherche dichotomique)

Explication :
Chercher la case du milieu dans T et faire la comparaison entre
T[milieu]et X s'il y a égalité retourner milieu sinon si T[milieu]>X
rechercher entre le début et le milieu sinon rechercher entre le milieu et la
fin de la même manière.
Si X n'est pas trouvé le module renvoie -1.
Exemple :
X=15
T 3 6 9 15 73
0 1 2 3 4

deb mil fin

mil=(4+0)div2
X>T[mil]
T 3 6 9 15 73
0 1 2 3 4

Mil=(3+4)div2 deb fin

mil
X=T[mil]

Solution : une fonction rech_dic : Fonction rech_dic en python :

Fonction rech_dic (T: tab , n,x : entier) :entier
Début rech_dic
deb0
finn-1
tantque deb<= fin faire
mil=(deb+fin)div2
si T[mil]=x alors
retourne mil
sinon si T[mil]<x alors
deb=mil+1
sinon
fin = mil-1
TDO
fin si Objet Type
fin tant que deb Entier
fin Entier
retourne -1 mil Entier
Fin rech_dic
X- Chaines palindromes :

Un module permettant de vérifier si une chaine ch est lisible de gauche à droite comme
de droite a gauche (palindrome) ou pas et qui renvoie VRAI si la chaine est un
palindrome et FAUX sinon.

1- Fonction basique :

Explication :
Il existe plusieurs méthodes pour créer ce module le plus simple est de
créer une chaine che à partir des caractères de ch à l'envers et faire la
comparaison entre ch et che si elles sont identiques renvoyer VRAI sinon
renvoyer FAUX
Exemple :

Ch = e l l e
Che =e
Che=el
Che=ell
Che=elle
Che=ch le module renvoie VRAI

Solution : une fonction palindrome : Fonction palindrome en python :

Fonction palindrome (ch:chaine) :booléen
Début palindrome
Che""
Pour i 0 a long(ch):
chech[i]+che
fin pour
si che = ch alors
retourne VRAI TDO
Objet Type Remarque :
sinon
che chaine
retourne FAUX i Entier Cet algorithme ne marche pas si ch contient des
finsi espaces, des majuscules ou des caractères spéciaux.
Fin palindrome
 2- Variante plus aboutie de la fonction palindrome :

Explication :
Nous allons garder la même fonction palindrome si dessus tout en
ajoutant une nouvelle fonction standard permettant de :
• Supprimer les espaces et les caractères spéciaux
• Transformer les majuscules en minuscules
Exemple :
Ch ="La mariee ira mal."
L'appel de la fonction standard retourne "lamarieeiramal" et la fonction
palindrome peut maintenant renvoyer VRAI.

Solution : une fonction standard

Fonction standard (ch:chaine) :chaine de caractères Appel de la fonction standard dans palindrome
Début standard Fonction palindrome (ch:chaine) :booléen
Chs"" Début palindrome
Pour i 0 a long(ch) faire ch1standard(ch)
Si ord(ch[i]) dans [97..122] alors che""
chschs+ch[i] Pour i 0 a long(ch1):
sinon si ord(ch[i]) dans [65..90]alors chech1[i]+che
chschs+chr(ord(ch[i])+32) fin pour
TDO
finsi si che = ch1 alors Objet Type
TDO che chaine
fin pour retourne VRAI
Objet Type
retourne chs chs chaine sinon
i Entier
Fin standard retourne FAUX
finsi

Fonction standard en python : Fin palindrome

Fonction palindrome en python :

Partie II : les interfaces graphiques :
I- Création d'une interface graphique :
1- Logiciel Qt-designer :
2- Les objets
a- Les labels (zones de textes)
Dans le filtre de la boite de widget taper "label"
puis glisser l'objet vers le formulaire

Clique droite sur le label puis choisir l'option

modifier texte riche pour modifier la police la
taille et la couleur du texte du label.

Dans l'éditeur de propriétés changer le nom du

label vous en aurez besoin plus tard.

Pour écrire dans la zone label utiliser l'instruction

suivante:

b- Les "line edit" (les zones de saisie) :

Dans le filtre de la boite de widget taper "line edit"

puis glisser l'objet vers le formulaire

• Indiquer le nom de la zone de saisie.

• Vous pouvez modifier la taille et la police du texte
de la zone de saisie en cliquant sur la propriété font:

• Pour récupérer le texte de la zone de saisie :

c- Les combo box ou listes déroulantes :

• Dans le filtre de la boite de widget taper

"combo" puis glisser l'objet vers le
formulaire.
• Modifier le nom de l'objet dans les
propriétés.

Pour éditer les éléments du combo : clique droit

puis choisir : Editer les éléments.

• Clique sur le "+" vert pour ajouter un élément.

• Clique sur le "-" rouge pour supprimer un
élément.
• Les flèches servent à déplacer les éléments en
haut et en bas.
• Une fois la liste terminée valider par ok.

• Pour récupérer l'élément sélectionné du combo :

d- Les boutons radio :

• Dans le filtre de la boite de widget taper

"radio" puis glisser l'objet vers le
formulaire.
• Modifier le nom de l'objet dans les
propriétés.

• Si on veut que l'option soit sélectionnée par

défaut cochez l'option checked :

• Pour tester si une option est cochée :

Cette instruction retourne vrai si le bouton

est coché ou faux sinon.
• Pour récupérer la valeur d'un bouton radio :
 e- Les boutons ou pushbutton :

• Dans le filtre de la boite de widget taper

"pushbutton" puis glisser l'objet vers le
formulaire.

• Changer le nom de l'objet dans les

propriétés.

• Pour associer le clique sur le bouton à un module du programme :

II- Code permettant d'exploiter l'interface :

Ce code permet de faire le lien entre l'interface graphique créée et le code source du programme, il est
impératif que les deux fichiers interface et code soient enregistrés dans le même dossier.
▪ Nom_interface.ui : l'interface déjà créée et enregistrée, cependant il est conseillé de garder le
logiciel QTdesigner ouvert pour consulter les différentes informations.
✓ Le nom de l'interface :

▪ Le nom du bouton : dans Qtdesigner cliquer sur le bouton et récupérer le nom du bouton.

▪ Le nom du module : le nom du module principal est proposé par l'exercice dans la plupart des cas
est appelé Play.
II- Exemples :
1- Zone de saisie (line edit) et zone de texte (label):

Nous allons créer une interface graphique "Activité1" contenant :

• Un label "titre" avec le texte "Une première activité".

• Un label "lb1" avec le texte "Votre nom et prénom".
• Un label "resultat" vide.
• Une zone de saisie "chaine".
• Un bouton "valider" avec le texte "OK".
Le but de l'exercice est simple écrire une chaine dans la zone de saisie "chaine", cliquer
sur le bouton "valider" et faire apparaitre la chaine saisie dans le label "resultat".

Remarque :
Les noms des objets dans qtdesigner ne peuvent pas contenir d'espaces ni de caractères
accentués.
L'enregistrement des fichiers doit être dans le même répertoire pour simplifier le travail.

Solutions :

Enregistrez le travail sous le nom "Activité1" dans votre dossier de travail ne fermez pas
QTDesigner vous pouvez en avoir besoin, maintenant au tour de l'éditeur python
Thonny.

Après avoir lancé Thonny allez dans le menu "outils" et activez la commande "ajouter
code PyQt5".

L'option cité doit être ajoutée manuellement après l'installation de Thonny suivez ce lien
pour voir les étapes.
from [Link] import loadUi
from [Link] import QApplication,QMessageBox,QTableWidget,QTableWidgetItem
#le module Play
Def Play() :
nom=[Link]()
[Link](nom)
#le programme principal
app = QApplication([])
windows = loadUi ("activité[Link]")
[Link]()
[Link] (Play)
app.exec_()
#remplacer le nom de l'interface, le nom du bouton et le nom du module par les
valeurs saisient dans QTDesigner.

Le clique sur le bouton "Valider" affiche le contenu de

la zone de saisie "chaine" dans la zone de texte
"Resultat".

2- Un combo et une zone de texte :

Nous allons créer une interface graphique "activité2" contenant :

• Un label "titre" avec le texte "Activité 2".

• Un label "lb1" avec le texte "Faites un choix".
• Un label "resultat" vide.
• Un combo box (liste déroulante) "liste" contenant [2020,2021,2022,2023,2024]
• Un bouton "valider" avec le texte "OK".
1- Concevoir l'interface graphique et l'enregistrer sous le nom "activité2" dans votre
dossier de travail.
2- Créer un programme python "activiteCombo" et l'enregistrer dans votre dossier de
travail.
3- Développer le module Play qui s'exécute suite au clique sur le bouton valider.
Solutions :

Enregistrez le travail sous le nom "Activité2" dans votre dossier de travail ne fermez pas
QTDesigner vous pouvez en avoir besoin, maintenant au tour de l'éditeur python
Thonny.

Après avoir lancé Thonny allez dans le menu "outils" et activez la commande "ajouter
code PyQt5" puis enregistrez votre travail sous le nom activiteCombo.
from [Link] import loadUi
from [Link] import
QApplication,QMessageBox,QTableWidget,QTableWidgetItem
#le module Play
Def Play() :
choix=[Link]()
[Link](choix)
#le programme principal
app = QApplication([])
windows = loadUi ("activité[Link]")
[Link]()
[Link] (Play)
app.exec_()
#remplacer le nom de l'interface, le nom du bouton et le nom du module par
les valeurs saisient dans QTDesigner.

Le clique sur le bouton "Valider" affiche le

choix de l'utilisateur "liste" dans la zone de
texte "Resultat".
 3- Deux boutons radios et une zone de texte :

Nous allons créer une interface graphique "activité3" contenant :

• Un label "titre" avec le texte "Activité 3".

• Un label "lb1" avec le texte "Faites un choix".
• Un label "resultat" vide.
• Deux boutons radio "rd1" et "rd2" avec les textes "option 1" et "option 2"
• Un bouton "valider" avec le texte "OK".
4- Concevoir l'interface graphique et l'enregistrer sous le nom "activité3" dans votre
dossier de travail.
5- Créer un programme python "activiteradio" et l'enregistrer dans votre dossier de
travail.
6- Développer le module Play qui s'exécute suite au clique sur le bouton valider.

Solutions :

Enregistrez le travail sous le nom "Activité3" dans votre dossier de travail ne fermez pas
QTDesigner vous pouvez en avoir besoin, maintenant au tour de l'éditeur python
Thonny.

Après avoir lancé Thonny allez dans le menu "outils" et activez la commande "ajouter
code PyQt5" puis enregistrez votre travail sous le nom activiteradio.
from [Link] import loadUi
from [Link] import
QApplication,QMessageBox,QTableWidget,QTableWidgetItem
#le module Play
def Play() :
if [Link]()== True:
choix=[Link]()
elif [Link]()== True:
choix=[Link]()
else:
choix="Aucun choix"
[Link](choix)
#le programme principal
app = QApplication([])
windows = loadUi ("activité[Link]")
[Link]()
[Link] (Play)
app.exec_()
#remplacer le nom de l'interface, le nom du bouton et le nom du module par les valeurs
saisient dans QTDesigner.

III- Quelques BACs pratiques :

1- Session 2022 8h:00mn :
 2- Correction BAC pratique 2022 8h:00mn:.
a- Partie QtDesigner :

Réalisez l'interface graphique et l'enregistrer dans votre dossier de travail sous le nom [Link]
b- Programmation :
from [Link] import loadUi
from [Link] import QApplication,QMessageBox,QTableWidget,QTableWidgetItem
def Play():
x=[Link]()#récupérer X comme chaine de caractère
if int(x)<100:#transformer x en entier pour faire la comparaison
ch="Veuillez introduire un nombre >=100"#chaine de l'affichage si le nombre
introduit est infèrieur à 100
else :
test=ondulant(x)#ondulant renvoie un booléen qu'on met dans la variable test
if test==True:
ch=x+" est un nombre ondulant"#chaine affichage si x est ondulant
else:
ch=x+" n'est pas un nombre ondulant"#chaine affichage si x n'est pas ondulant
[Link](ch)#mettre la chaine ch dans la zone de texte
def ondulant(x):#ici on va utiliser la fonction palindrome elle donne le même résultat
ch=""#initialiser une chaine vide pour Y mettre le contenu de x à l'envers
for i in range(len(x)):#parcourir la chaine normalement
ch=x[i]+ch#incrémenter ch par le caracère courant de x mettre ch à la fin
pour obtenir une chaine inversée
if ch==x:#s'il y a égalité entre ch et x alor x est ondulant sinon x ne l'est pas
return True
else:
return False
#PP
app = QApplication([])
windows = loadUi ("[Link]")
[Link]()
[Link] (Play)
app.exec_()