|
CONVENTION PYTHON |
|
Importer un module from nom_du module import * |
|
# commentaire |
|
Afficher A print(A) |
|
Affecter à A une valeur A= valeur |
|
Saisir un entier A A=int(input(« Saisir un entier : « ) |
|
Saisir un réel X X=float(input(« Saisir un réel : « ) |
|
Saisir une chaîne S S=input(« Saisir une chaîne : « ) |
|
Structure conditionnelle if condition1 : traitement1 elif condition2 : traitement2 else : traitement3 |
|
Boucle non bornée while condition : traitement |
|
Boucle bornée for i in range (vi,vf+1,Pas) : Traitement |
|
|
|
Définition d’une fonction def f (pf1, pf2, …) : y = ….. return y |
|
Racine carré de x sqrt(x) |
|
Tester si une chaîne S est numérique S.isnumeric() |
|
|
|
Reste de la division A par B A % B |
|
Quotient de la division de A par B A//B |
|
A=B (égalité) A==B |
|
A ≠ B A != B |
|
Nombre aléatoire compris entre a et b randint(a,b) |
|
Nombre de caractères dans une chaîne S len(s) |
|
Cherche l’existance d’une chaîne S1 dans une chaîne S2 S2.find(S1) |
|
Code ASCII d’un caractère chr( ) |
|
Caractère d’un code ASCII ord( ) |
|
La partie entière d’un réel x int(x) |
|
Copier des caractères d’une chaîne S S[début :fin] |
|
Effacer des caractères d’une chaîne S S[:début] + S[fin:] |
|
Mettre la châine en majuscule S S.upper( ) |
|
Convertir le type d’une variable Int( ) float( ) str( ) |
|
Déclarer un tableau numpy T from numpy import* T=np.array([type( )]*n |
Important : Les deux fichiers .py et .ui doivent être enregistrer dans le même dossier qui porte votre nom et prénom dans le bureau
Un nombre heureux est un nombre entier qui, lorsqu’on ajoute les carrés de chacun de ses chiffres, puis les carrés des chiffres de ce résultat et ainsi de suite jusqu’à l’obtention d’un nombre à un seul chiffre égal à 1 (un).
Exemple: pour n=7 , on a :
7²=49
4²+9²= 97
9²+7²=130
1²+3²+0²=10
1²+0²=1 ce qui prouve que n est un nombre heureux !
L’interface graphique à concevoir contient les éléments suivants, comme l’illustre la capture d’écran :
- Un label contenant le titre « Nombre Heureux«
- Un label contenant le texte « saisir un nombre : «
- Une zone de saisie pour la saisie du nombre
- Un label pour afficher le résultat
- Un bouton intitulé « Verifier«
Travail demandé :
- Concevoir l’interface graphique présentée en-dessus et l’enregistrer sous le nom « Intr_Heureux »
- Créer un programme Python et l’enregistrer sous le nom « Heureux», dans lequel, il est demandé de :
- développer une fonction nommée verif (x) qui permet de verifier si x est un nombre heureux ou non.
- développer un module Play qui s’exécute suite à un clic sur le bouton « Verifier » permettant de :
- récupérer le nombre saisi
- afficher le résultat retourné par la fonction verif(x) dans le label résultat de l’interface « Intr_Heureux» .
- Intégrer dans le programme Python les instructions de liaisons permettant d’exploiter l’interface graphique « Intr_Heureux».
from PyQt5 import uic,QtWidgets
from PyQt5.QtWidgets import QApplication
def som_chiffre(s):
def play ():
def reset():
app=QApplication([])
s=uic.loadUi(« heureux.ui »)
s.nombre.setFocus()
s.show()
s.BH.clicked.connect(play)
s.BQ.clicked.connect(fermer)
s.BR.clicked.connect(reset)
app.exec()
Important : Les deux fichiers .py et .ui doivent être enregistrer dans le même dossier qui porte votre nom et prénom dans le bureau
Robert Val est un passionné des poids et mesures : il vient d’inventer une nouvelle balance capable de peser les lettres, les mots et les phrases.
Chaque lettre a pour poids son numéro d’ordre dans l’alphabet : a pèse 1 ; b pèse 2 ; c pèse 3 ; … r pèse 18 ; … et z pèse 26. Sachant que code ASCII de a est 97, de b est 98 ainsi de suite
Le poids d’un mot est la somme des poids des lettres qui le composent : par exemple, bac pèse 6 (2+1+3).
Soit l’algorithme suivant « verif » qui permet de vérifier si une chaîne est alphabétique minuscule ou non :
DEBUT
On désire créer l’interface graphique présentée ci-dessus, comportant les éléments suivants :
- Un label contenant le titre.
- Un label demandant la saisie d’un mot.
- Une zone de saisie permettant la saisie du mot.
- Un bouton nommé « Calculez« .
- Un label pour afficher un message.
Travail demandé :
- Concevoir une interface graphique comme illustré ci-dessus et l’enregistrer, dans votre dossier de travail, sous le nom « Ipoids« .
- Implémenter en Python la fonction « verif » et l’enregistrer sous le nom « poids« , dans le même dossier
- Développer la fonction « calcul » permettant de calculer le poids d’une chaîne comme indiquer dans l’énoncé.
- Dans le programme « poids« , ajouter les instructions permettant :
- D’appeler l’interface graphique « Ipoids » en exploitant l’annexe ci-dessous.
- D’implémenter un module « Play« , qui s’exécute à la suite d’un clic sur le bouton « Calculez« , permettant de récupérer le mot saisi puis d’exploiter la fonction « calcul » afin d’afficher le poids du mot ou le message « mot invalide », retourné via un label de l’interface « Ipoids« .
# Poids d’une chaîne
from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
def verif(ch):
def calcul(ch):
def clr():
def play():
« » » PROGRAMME PRINCIPAL « » »
app=QApplication([])
windows = loadUi(« Ipoids.ui« )
windows.show()
windows.BC.clicked.connect(play)
windows.BE.clicked.connect(clr)
app.exec_()
Important : Les deux fichiers .py et .ui doivent être enregistrer dans le même dossier qui porte votre nom et prénom dans le bureau
Deux entiers naturels strictement positifs m et n sont dits nombres amis si et seulement si:
La somme des diviseurs de m sauf lui même est égale à n
Et le somme des diviseurs de n sauf lui même est égale a m
Exemple:
220 et 284 sont deux nombres amis, en effet:
D220= {1,2,4,5,10,11,20,22,44,55,110,220}
D284= {1,2,4,71,142,284}
D220 et D284 sont respectivement les ensembles de tous les diviseurs de 220 et 284.
284= 1+2+4+5+10+11+20+22+44+55+110
220=1+2+4+71+142
On se propose de concevoir une interface graphique permettant de saisir Deux entiers naturels strictement positifs m et n.Puis afficher le message : « m et n sont deux nombre amis! », s’ils vérifient la propriété, dans le cas contraire afficher: « m et n ne sont pas amis! »
L’interface graphique à concevoir contient les éléments suivants, comme l’illustre la capture d’écran ci-dessus:
- Un label contenant le titre « Nombre Amis«
- Un label contenant le texte « saisir n: «
- Une zone de saisie pour la saisie de l’entier n
- Un label contenant le texte « saisir m : «
- Une zone de saisie pour la saisie de l’entier m
- Un label pour afficher le message adéquat
- Un bouton intitulé « Amis«
Travail demandé :
- Concevoir l’interface graphique présentée en-dessus et l’enregistrer sous le nom « Intr_Amis »
- Créer un programme Python et l’enregistrer sous le nom « Amis», dans lequel, il est demandé de :
- développer une fonction nommée verif(m,n) qui permet de verifie si met n sont amis ou non.
- développer un module Play qui s’exécute suite à un clic sur le bouton « Amis » permettant de :
- récupérer les deux entiers n et m
- afficher le message adéquat dans le label résultat de l’interface « Intr_Amis», résulte de la valeur retournée par la fonction verif(m,n)
from PyQt5 import QtWidgets, uic
from PyQt5.QtWidgets import QApplication
def test (ch):
def fn_div(n):
def fn_amis():
def effacer():
##################################
mon_app=QApplication([])
f=uic.loadUi(« NOMBRES_AMIS.ui »)
f.show()
f.pushButton_Amis.clicked.connect(fn_amis) # En cliquant sur le bouton Amis , on exécute la fonction fn_amis
f.B_Reset.clicked.connect(effacer)
f.B_Fermer.clicked.connect(fermer)
mon_app.exec_()
Important : Les deux fichiers .py et .ui doivent être enregistrer dans le même dossier qui porte votre nom et prénom dans le bureau
On désire créer l’interface graphique présentée ci-dessus, comportant les éléments suivants :
- Un label contenant le titre.
- Un label demandant la saisie de l’octet à compresser.
- Une zone de saisie permettant la saisie de l’octet.
- Un bouton nommé « Compresser« .
- Un label pour afficher l’octet compréssé.
Travail demandé :
- Concevoir une interface graphique comme illustré ci-dessus et l’enregistrer, dans votre dossier de travail, sous le nom « Intr_Compresser« .
- Implémenter en Python la fonction « verif » et l’enregistrer sous le nom « Compresser« , dans le même dossier
- Développer la fonction « comp(O) » permettant de compresser l’octet O comme indiquer dans l’énoncé.
- Dans le programme « Compresser« , ajouter les instructions permettant :
- D’appeler l’interface graphique « Intr_Compresser » en exploitant l’annexe ci-dessous.
- D’implémenter un module « Play« , qui s’exécute à la suite d’un clic sur le bouton « Compresser« , permettant de récupérer l’octet dans son état initial, puis d’exploiter la fonction « comp(O) » afin d’afficher l’octet compréssé dans le label adéquat de l’interface « Intr_Compresser« .
from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
« » » TRAITEMENT PYTHON « » »
def verif_bin(s):
def compress(ch):
« » » LIAISON INTERFACE GRAPHIQUE & FONCTION PYTHON « » »
def play():
« » » PROGRAMME PRINCIPAL « » » »
app=QApplication([])
windows=loadUi(« COMPRESSER.ui »)
windows.show()
windows.comp.clicked.connect(play)
app.exec_()
Important : Les deux fichiers .py et .ui doivent être enregistrer dans le même dossier qui porte votre nom et prénom dans le bureau
Un nombre harshad est un entier naturel non nul, divisible par la somme de ses chiffres.
Par exemple, n = 24 est un nombre Harshad car la somme de ses chiffres est 2 + 4 = 6, et 24
est bien divisible par 6.
On se propose de concevoire une interface graphique, comme l’illustre la capture d’écran en dessus, qui contient les éléments suivants:
- Un label contenant le titre « Nombre Harshad«
- Un label contenant le texte « saisir un nombre : «
- Une zone de saisie pour la saisie du nombre
- Un label pour afficher le résultat
- Un bouton intitulé « Verifier«
Travail demandé :
- Concevoir l’interface graphique présentée en-dessus et l’enregistrer sous le nom « Intr_Harshad »
- Créer un programme Python et l’enregistrer sous le nom « Harshad», dans lequel, il est demandé de :
- développer une fonction nommée verif (x) qui permet de verifier si x est un nombre harshad ou non selon le principa décrit ci-dessus.
- développer un module Play qui s’exécute suite à un clic sur le bouton « Verifier » permettant de :
- récupérer le nombre saisi
- afficher le résultat retourné par la fonction verif(x) dans le label résultat de l’interface « Intr_Harshad» .
- Intégrer dans le programme Python les instructions de liaisons permettant d’exploiter l’interface graphique « Intr_Harshad».
from PyQt5 import uic,QtWidgets
from PyQt5.QtWidgets import QApplication
def verif(n):
s=0
ch=str(n)
for i in range(len(ch)):
s=s+int(ch[i])
return n%s==0
def play ():
n=int(s.x.text())
if n>0:
if verif(n)==True:
s.res.setText(str(n)+’ est un nombre Harshad’)
else:
s.res.setText(str(n)+’ est un non Harshad’)
else:
s.res.setText(‘Nombre invalide’)
app=QApplication([])
s=uic.loadUi(« harshad.ui »)
s.show()
s.btn.clicked.connect(play)
app.exec()
On définit le degré de ressemblance entre deux mots de mime longueur par la formule suivante:
DR= Nombre de caractères Commun bien placés / longueur de mot)* 100
Exemple1:
Mot1= « EXEMPLE »
Mot2= « EXAMENS »
DR= (3/7)* 100 = 42.85
Exemple2:
Mot1= « CHIEN »
Mot2= « NICHE »
DR=(O/5)*100 = 0
Un mot est une chaine de caractères nom vide qui contient seulement des lettres majuscules.
Soit l’algorithme de la fonction affiche ci-dessous, qui permet de
On désire créer une interface graphique comme présentée ci-contre, composée de:
- Un label : pour le titre « ressemblance entre deux mots
- Un label demandant de saisir le premier mot
- Un label demandant de saisir le deuxième mot
- Une zone de Saisie pour le premier mot
- Une zone de saisie pour le deuxième mot
- Un bouton calculer
- Un label pour afficher le résultat
TRAVAIL DEMANDE :
- Concevoir une interface graphique comme illustré ci-contre et enregistrer votre travail dans votre dossier de travail sous le nom « interface _DR«
- Implémenter en python la fonction affiche dans un programme et enregistrer le sous le nom DRess0.py dans votre dossier de travail
- Développer la fonction vérif qui permet de vérifier si une chaine est alphabétique majuscule.
- Développer la fonction degre_ressemblance qui permet de calculer le degré de ressemblance entre les deux mots, puis enregistrer la dans un nouveau programme dans votre dossier de travail sous le nom DRess1.py
- Dans le programme DRess0.py ajouter les instructions qui permettent de :
- Appeler l’interface graphique « interface_DR«
- Implémenter le module « Play« , qui s’exécute suite d’un clic sur le bouton Calculer, permettant de récupérer les deux mots mot1 et mot2, puis d’exploiter la fonction afficher afin d’afficher le message retourné via un label de l’interface « interface DR«
from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
def degre_ressemblance(m1,m2):
def verif(m):
def effacer():
def play():
app=QApplication([])
windows = loadUi(« ressemblance.ui »)
windows.show()
windows.BP.clicked.connect(play)
windows.BE.clicked.connect(effacer)
windows.BF.clicked.connect(quitter)
app.exec_()
Enoncé
Enoncé :
Un nombre de Kaprekar est un nombre dont l’écriture décimale du carré de ce nombre peut être séparée en deux nombres (pas forcément de même taille) dont la somme vaut le nombre initial.
Exemples :
- 9 est un nombre de Kaprekar car 9²=81 et on peut séparer 81 en 8 et 1 dont la somme 8+1 = 9.
- 45 est un nombre de Kaprekar car 45²=2025 et on peut séparer 2025 en 20+25=45.
- 12 n’est pas un nombre de Kaprekar car 12²=144 et on ne peut pas couper ce nombre pour trouver 12 (1+44=45, 14+4=18).
- 4 879 est un nombre de Kaprekar car 4879² = 23804641 et 238 + 04 641 = 4 879.
L’interface graphique à concevoir contient les éléments suivants, comme l’illustre la capture d’écran :
- Un label contenant le titre « Nombre Kaprekar«
- Un label contenant le texte « saisir un nombre : «
- Une zone de saisie pour la saisie du nombre
- Un label pour afficher le résultat
- Un bouton intitulé « Verifier«
Travail demandé :
- Concevoir l’interface graphique présentée en-dessus et l’enregistrer sous le nom « Intr_Kaprekar »
- Créer un programme Python et l’enregistrer sous le nom « Kaprekar», dans lequel, il est demandé de :
- développer une fonction nommée verif (x) qui permet de verifier si x est un nombre heureux ou non.
- développer un module Play qui s’exécute suite à un clic sur le bouton « Verifier » permettant de :
- récupérer le nombre saisi
- afficher le résultat retourné par la fonction verif(x) dans le label résultat de l’interface « Intr_Kaprekar» .
- Intégrer dans le programme Python les instructions de liaisons permettant d’exploiter l’interface graphique « Intr_Kaprekar».
#Kaprekar Interface
from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
# La Fonction Kaprekar
def kap(n):
# fonction verif
def verif(n):
a=n*n
s=str(a)
# Fonctions de liaisons
def play():
n=int(f.nombre.text()) # Noter bien que la donnéecrécuperée de type string!
f.res.setText(kap(n))
def Effacer():
f.nombre.clear()
f.nombre.setFocus()
f.res.clear()
def Fermer():
f.close()
# Script de liaison graphique & codage
app=QApplication([])
f=loadUi(« Int_Kaprekar.ui »)
f.show()
f.BP.clicked.connect(play)
f.BE.clicked.connect(Effacer)
f.BF.clicked.connect(Fermer)
app.exec_()
Important : Les deux fichiers .py et .ui doivent être enregistrer dans le même dossier qui porte votre nom et prénom dans le bureau
Jeu de Mots Masqués**
Le jeu *Mots Masqués* consiste à afficher aux joueurs un mot avec certaines lettres masquées. L’utilisateur doit deviner le mot complet.
Exemple: mot à deviné : t*bl*tt*. le mot est « tablette »
Soit l’algorithme suivant « verif » qui permet de vérifier si une chaîne est alphabétique minuscule ou non :
DEBUT
On désire créer l’interface graphique présentée ci-dessus, comportant les éléments suivants :
- Un label contenant le titre.
- Un label affichant un mot masqué, généré par l’ordinateur.
- Une zone de saisie permettant de deviner le mot.
- Un bouton nommé « Valider« .
- Un label pour afficher un message.
Travail demandé :
- Concevoir une interface graphique comme illustré ci-dessus et l’enregistrer, dans votre dossier de travail, sous le nom « Intr_mots_masqués« .
- Implémenter en Python la fonction « verif » et l’enregistrer sous le nom « Masqués« , dans le même dossier
- Développer la fonction « génére » permettant de générer un mot masqué, à partir d’un ensemble de mot enregistrés dans un tableau de mots.
- Développer la fonction « devine(mot) » permettant de tester si le mot deviné est correcte ou non.
- Dans le programme « Masqués« , ajouter les instructions permettant :
- D’appeler l’interface graphique « Intr_mots_masqués » en exploitant l’annexe ci-dessous.
- De générer automatiquement dans le label adéquat un mot à deviné du tableau Mots
- D’implémenter un module « Play« , qui s’exécute à la suite d’un clic sur le bouton « Verifié« , permettant de récupérer le mot deviné puis d’exploiter la fonction devine(mot) afin d’afficher un message de validation, retourné via un label de l’interface « Intr_mots_masqués« .
from PyQt5.uic import loadUi
from PyQt5.QtWidgets import QApplication
#*********************
t=[« abeille », »tablettes », »joies », »Musique »]
def masque(s):
def trouv(mot,s):
def play():
#********************* Programme Principal
app=QApplication([])
windows=loadUi(« mots_masqués.ui« )
windows.show()
from random import*
x=randint(0,3)
s=masque(t[x])
windows.motM.setText(s)
windows.valider.clicked.connect(play)
app.exec_()
Dans le cadre d’une campagne publicitaire, une société commerciale a décidé d’organiser chaque semaine un jeu de chance pour ses clients.
Le principe du jeu consiste à calculer le nombre de chance à partir du numéro de téléphone du client donné et d’afficher le message « Félicitations, vous avez gagné. » dans le cas où ce nombre est premier ou le message « Désolé, vous n’avez pas gagné. » dans le cas contraire.
Sachant que :
- Le numéro de téléphone devrait commencer par 2, 4, 5 ou
- Le nombre de chance est la somme de chaque chiffre du numéro de téléphone multiplié par son indice avec l’indice du premier chiffre est
- Un nombre premier est un nombre qui est divisible par 1 et par lui-même.
Exemple :
Donner le numéro : 29234560
Le programme affiche : Désolé, vous n’avez pas gagné.
En effet, le nombre de chance est égal à 99 qui n’est pas un nombre premier.
99 = 2 * 0 + 9 * 1 + 2 * 2 + 3 * 3 + 4 * 4 + 5 * 5 + 6 * 6 + 0 * 7 c’est la somme de chaque chiffre du numéro de téléphone multiplié par son indice :
Numéro téléphone | 2 | 9 | 2 | 3 | 4 | 5 | 6 | 0 |
Indice | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
Ci-après, un algorithme de la fonction « Chance » à exploiter pour résoudre le problème posé.
DEBUT
FinSi
Retourner msg
FIN
La société a décidé de créer l’interface graphique présentée ci-dessus, comportant les éléments suivants :
- Un label contenant le texte « Numéro Chanceux« .
- Un label demandant la saisie du numéro de téléphone.
- Une zone de saisie permettant la saisie du numéro de téléphone.
- Un bouton nommé « Jouer« .
- Un label pour afficher un message.
Concevoir une interface graphique comme illustré ci-dessus et l’enregistrer, dans votre dossier de travail, sous le nom « Interface_Jeu« .Travail demandé :
- Implémenter en Python la fonction « Chance » dans un programme et l’enregistrer sous le nom « Jeu0« , dans votre dossier de
- Développer la fonction « Premier » permettant de vérifier si un nombre, passé comme paramètre, est premier ou non puis l’enregistrer dans votre dossier de travail sous le nom « Jeu1« .
- Dans le programme « Jeu1« , ajouter les instructions permettant :
- D’appeler l’interface graphique intitulée « Interface_Jeu » en exploitant l’annexe ci-dessous.
- D’implémenter un module « Play« , qui s’exécute à la suite d’un clic sur le bouton « Jouer« , permettant de récupérer le numéro de téléphone saisi puis d’exploiter la fonction « Chance » afin d’afficher le message retourné via un label de l’interface « Interface_Jeu« .
from PyQt5.uic import loadUi
windows.show()
windows.Nom_Bouton.clicked.connect (Nom_Module)
app.exec_()
windows.affiche.setText(chance(num)) # Afficher le message du traitement
Important : Les deux fichiers .py et .ui doivent être enregistrer dans le même dossier qui porte votre nom et prénom dans le bureau
Un palindrome est une chaîne de caractères qui se lit de la même façon de gauche à droite et de droite à gauche. Par exemple, “laval” est un mot palindrome.
Soit l’algorithme suivant « verif » qui permet de vérifier si une chaîne est alphabétique minuscule ou non :
DEBUT
On se propose de concevoire l’interface graphique présentée ci-dessus, comportant les éléments suivants :
- Un label contenant le titre « Palindrome«
- Un label demandant la saisie d’un mot.
- Une zone de saisie permettant la saisie du mot.
- Un bouton nommé « Verifier ».
- Un label pour afficher le message adéquat.
Travail demandé :
- Concevoir une interface graphique comme illustré ci-dessus et l’enregistrer, dans votre dossier de travail, sous le nom « IPalindrome« .
- Implémenter en Python la fonction « verif » et l’enregistrer sous le nom « Palindrome« , dans le même dossier
- Développer la fonction Pal ( ch) permettant de vérifier si la chaîne ch est palindrome ou non.
- Dans le programme « Palindrome« , ajouter les instructions permettant :
- D’appeler l’interface graphique « IPalindrome » en exploitant l’annexe ci-dessous.
- D’implémenter un module « Play« , qui s’exécute à la suite d’un clic sur le bouton « Verifier« , permettant de récupérer le mot saisi puis d’exploiter la fonction « Pal » afin d’afficher le message « mot palindrome» ou « mot non palindrome» suite au résultat retourné, via le label résultat de l’interface « IPalindrome« .
#biblothéque nécessaire pour utiliser Qtdessigner
from PyQt5 import uic,QtWidgets
from PyQt5.QtWidgets import QApplication
#fonction qui test si la chaine est composé que de lettres majuscules
def test (ch):
#fonction qui vérifie les conditions proposées sur la chaine
def verif (ch):
#fonction qui vérifie si la chaine est palindrome ou non
def palindrome(ch) :
#affichage avec une boite de dialogue
def affiche():
def Effacer ( ) :
#programme principal
app = QApplication([])
f = uic.loadUi (« palindrome.ui »)
f. mot . setFocus()
f. show()
f . B_afficher. clicked . connect(affiche)
f . B_effacer. clicked . connect( Effacer)
f . B_quitter. clicked . connect(quitter)
app . exec_( )
Un nombre N est dit premier circulaire s’il vérifie la propriété suivante : chacune des rotations de ses chiffres d’un élément vers la droite, forme à son tour un nombre premier
Exemple :
Si N=719 est un nombre premier circulaire car 719, 971 et 197 sont des nombres premiers avec : 971 est le nombre obtenu après une rotation des chiffres de 719 d’un élément vers la droite.
197 est le nombre obtenu après une rotation des chiffres de 971 d’un élément vers la droite
Si N=23, N n’est pas un nombre premier circulaire car il est premier mais 32 ne l’est pas.
Si N=6102, N n’est pas un nombre premier circulaire car il n’est pas premier.
On désire créer l’interface graphique présentée ci-dessus, comportant les éléments suivants :
- Un label contenant le titre.
- Un label demandant la saisie d’un nombre.
- Un bouton nommé « Vérifier« .
- Un label pour afficher un message.
Travail demandé :
- Concevoir une interface graphique comme illustré ci-dessus et l’enregistrer, dans votre dossier de travail, sous le nom « Ipremier_circulaire« .
- Implémenter en Python la fonction « premier » et l’enregistrer sous le nom « premier_circulaire« , dans le même dossier
- Développer la fonction « verif » permettant de vérifier si le nombre saisi est premier circulaire ou non selon les contraintes indiquées dans l’énoncé.
- Dans le programme « premier_circulaire« , ajouter les instructions permettant :
- D’appeler l’interface graphique « Ipremier_circulaire » en exploitant l’annexe ci-dessous.
- D’implémenter un module « Play« , qui s’exécute à la suite d’un clic sur le bouton « vérifier« , permettant de récupérer le nombre saisi puis d’exploiter la fonction « verif » afin d’afficher si le nombre est premier circulare ou non, retourné via un label de l’interface « Ipremier_circulaire« .
from PyQt5.uic import loadUi
windows.show()
windows.Nom_Bouton.clicked.connect (Nom_Module)
app.exec_()
#biblothéque nécessaire pour utiliser Qtdessigner
from PyQt5 import uic,QtWidgets
from PyQt5.QtWidgets import QApplication
#fonction qui test si la chaine est composé que de lettres majuscules
def test (ch):
#fonction qui vérifie les conditions proposées sur la chaine
def verif (ch):
#fonction qui vérifie si la chaine est palindrome ou non
def palindrome(ch) :
#affichage avec une boite de dialogue
def affiche():
def Effacer ( ) :
#programme principal
app = QApplication([])
f = uic.loadUi (« palindrome.ui »)
f. mot . setFocus()
f. show()
f . B_afficher. clicked . connect(affiche)
f . B_effacer. clicked . connect( Effacer)
f . B_quitter. clicked . connect(quitter)
app . exec_( )
En arithmétique, un auto-nombre est un entier naturel N qui ne peut pas s’écrire sous la forme d’un nombre M ajouté à la somme des chiffres de M.
Exemple
Pour N=21, n’est pas un auto nombre, puisqu’il peut être généré à partir de la somme d’un nombre M égal à 15 et les chiffres qui le constituent (1 et 5) c’est-à-dire 21=15+1+5.
Pour N=20, est un auto-nombre puisqu’il ne peut pas être généré à partir de la somme d’un nombre M et les chiffres qui le constituent.
On désire créer une interface graphique présentée ci-dessus, comportant les éléments suivants :
- Un label contenant le titre.
- Un label demandant la saisie d’un nombre.
- Un bouton nommé « Vérifier« .
- Un label pour afficher un message.
Travail demandé :
- Concevoir une interface graphique comme illustré ci-dessus et l’enregistrer, dans votre dossier de travail, sous le nom « Int_Autonombre« .
- Développer en Python une fonction « auto » permettant de vérifier si un entier passé en paramètre est autonombre ou non selon les contraintes indiquées dans l’énoncé,et l’enregistrer sous le nom « Autonombre« , dans le même dossier
- Dans le programme « Autonombre« , ajouter les instructions permettant :
- D’appeler l’interface graphique « Int_Autonombre » en exploitant l’annexe ci-dessous.
- D’implémenter un module « Play« , qui s’exécute à la suite d’un clic sur le bouton « vérifier« , permettant de récupérer le nombre saisi puis d’exploiter la fonction « auto » afin d’afficher si le nombre est premier circulare ou non, retourné via un label de l’interface « Int_Autonombre« .
from PyQt5.uic import loadUi
windows.show()
windows.Nom_Bouton.clicked.connect (Nom_Module)
app.exec_()
#biblothéque nécessaire pour utiliser Qtdessigner
from PyQt5 import uic,QtWidgets
from PyQt5.QtWidgets import QApplication
#fonction qui test si la chaine est composé que de lettres majuscules
def test (ch):
#fonction qui vérifie les conditions proposées sur la chaine
def verif (ch):
#fonction qui vérifie si la chaine est palindrome ou non
def palindrome(ch) :
#affichage avec une boite de dialogue
def affiche():
def Effacer ( ) :
#programme principal
app = QApplication([])
f = uic.loadUi (« palindrome.ui »)
f. mot . setFocus()
f. show()
f . B_afficher. clicked . connect(affiche)
f . B_effacer. clicked . connect( Effacer)
f . B_quitter. clicked . connect(quitter)
app . exec_( )